From ea543b7154220cc427192e58f799fab6489941fe Mon Sep 17 00:00:00 2001 From: ZYSzys Date: Mon, 17 Jun 2019 22:38:43 +0800 Subject: [PATCH] tools: update babel-eslint to 10.0.2 --- .../babel-eslint/lib/analyze-scope.js | 5 - .../@babel/generator/lib/node/index.js | 117 ++++++++ .../@babel/generator/lib/node/parentheses.js | 253 ++++++++++++++++++ .../@babel/generator/lib/node/whitespace.js | 192 +++++++++++++ .../babel-eslint/node_modules/ms/index.js | 4 +- .../babel-eslint/node_modules/ms/package.json | 2 +- .../babel-eslint/node_modules/ms/readme.md | 2 +- tools/node_modules/babel-eslint/package.json | 2 +- 8 files changed, 567 insertions(+), 10 deletions(-) create mode 100644 tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/index.js create mode 100644 tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/parentheses.js create mode 100644 tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/whitespace.js diff --git a/tools/node_modules/babel-eslint/lib/analyze-scope.js b/tools/node_modules/babel-eslint/lib/analyze-scope.js index 9b2a40d6dbf4f0..05b470b1b10b6c 100644 --- a/tools/node_modules/babel-eslint/lib/analyze-scope.js +++ b/tools/node_modules/babel-eslint/lib/analyze-scope.js @@ -327,11 +327,6 @@ module.exports = function(ast, parserOptions) { fallback, }; - if (OriginalReferencer._babelEslintPatched) { - require("./patch-eslint-scope")(parserOptions); - return escope.analyze(ast, options); - } - options.childVisitorKeys = childVisitorKeys; const scopeManager = new escope.ScopeManager(options); diff --git a/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/index.js b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/index.js new file mode 100644 index 00000000000000..bef46f0eede721 --- /dev/null +++ b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/index.js @@ -0,0 +1,117 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.needsWhitespace = needsWhitespace; +exports.needsWhitespaceBefore = needsWhitespaceBefore; +exports.needsWhitespaceAfter = needsWhitespaceAfter; +exports.needsParens = needsParens; + +var whitespace = _interopRequireWildcard(require("./whitespace")); + +var parens = _interopRequireWildcard(require("./parentheses")); + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function () { + return data; + }; + + return data; +} + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function expandAliases(obj) { + const newObj = {}; + + function add(type, func) { + const fn = newObj[type]; + newObj[type] = fn ? function (node, parent, stack) { + const result = fn(node, parent, stack); + return result == null ? func(node, parent, stack) : result; + } : func; + } + + for (const type of Object.keys(obj)) { + const aliases = t().FLIPPED_ALIAS_KEYS[type]; + + if (aliases) { + for (const alias of aliases) { + add(alias, obj[type]); + } + } else { + add(type, obj[type]); + } + } + + return newObj; +} + +const expandedParens = expandAliases(parens); +const expandedWhitespaceNodes = expandAliases(whitespace.nodes); +const expandedWhitespaceList = expandAliases(whitespace.list); + +function find(obj, node, parent, printStack) { + const fn = obj[node.type]; + return fn ? fn(node, parent, printStack) : null; +} + +function isOrHasCallExpression(node) { + if (t().isCallExpression(node)) { + return true; + } + + if (t().isMemberExpression(node)) { + return isOrHasCallExpression(node.object) || !node.computed && isOrHasCallExpression(node.property); + } else { + return false; + } +} + +function needsWhitespace(node, parent, type) { + if (!node) return 0; + + if (t().isExpressionStatement(node)) { + node = node.expression; + } + + let linesInfo = find(expandedWhitespaceNodes, node, parent); + + if (!linesInfo) { + const items = find(expandedWhitespaceList, node, parent); + + if (items) { + for (let i = 0; i < items.length; i++) { + linesInfo = needsWhitespace(items[i], node, type); + if (linesInfo) break; + } + } + } + + if (typeof linesInfo === "object" && linesInfo !== null) { + return linesInfo[type] || 0; + } + + return 0; +} + +function needsWhitespaceBefore(node, parent) { + return needsWhitespace(node, parent, "before"); +} + +function needsWhitespaceAfter(node, parent) { + return needsWhitespace(node, parent, "after"); +} + +function needsParens(node, parent, printStack) { + if (!parent) return false; + + if (t().isNewExpression(parent) && parent.callee === node) { + if (isOrHasCallExpression(node)) return true; + } + + return find(expandedParens, node, parent, printStack); +} \ No newline at end of file diff --git a/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/parentheses.js b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/parentheses.js new file mode 100644 index 00000000000000..3f98dc18f8e3ab --- /dev/null +++ b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/parentheses.js @@ -0,0 +1,253 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.NullableTypeAnnotation = NullableTypeAnnotation; +exports.FunctionTypeAnnotation = FunctionTypeAnnotation; +exports.UpdateExpression = UpdateExpression; +exports.ObjectExpression = ObjectExpression; +exports.DoExpression = DoExpression; +exports.Binary = Binary; +exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation; +exports.TSAsExpression = TSAsExpression; +exports.TSTypeAssertion = TSTypeAssertion; +exports.TSIntersectionType = exports.TSUnionType = TSUnionType; +exports.BinaryExpression = BinaryExpression; +exports.SequenceExpression = SequenceExpression; +exports.AwaitExpression = exports.YieldExpression = YieldExpression; +exports.ClassExpression = ClassExpression; +exports.UnaryLike = UnaryLike; +exports.FunctionExpression = FunctionExpression; +exports.ArrowFunctionExpression = ArrowFunctionExpression; +exports.ConditionalExpression = ConditionalExpression; +exports.OptionalMemberExpression = OptionalMemberExpression; +exports.AssignmentExpression = AssignmentExpression; +exports.NewExpression = NewExpression; + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function () { + return data; + }; + + return data; +} + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +const PRECEDENCE = { + "||": 0, + "&&": 1, + "|": 2, + "^": 3, + "&": 4, + "==": 5, + "===": 5, + "!=": 5, + "!==": 5, + "<": 6, + ">": 6, + "<=": 6, + ">=": 6, + in: 6, + instanceof: 6, + ">>": 7, + "<<": 7, + ">>>": 7, + "+": 8, + "-": 8, + "*": 9, + "/": 9, + "%": 9, + "**": 10 +}; + +const isClassExtendsClause = (node, parent) => (t().isClassDeclaration(parent) || t().isClassExpression(parent)) && parent.superClass === node; + +function NullableTypeAnnotation(node, parent) { + return t().isArrayTypeAnnotation(parent); +} + +function FunctionTypeAnnotation(node, parent) { + return t().isUnionTypeAnnotation(parent) || t().isIntersectionTypeAnnotation(parent) || t().isArrayTypeAnnotation(parent); +} + +function UpdateExpression(node, parent) { + return t().isMemberExpression(parent, { + object: node + }) || t().isCallExpression(parent, { + callee: node + }) || t().isNewExpression(parent, { + callee: node + }) || isClassExtendsClause(node, parent); +} + +function ObjectExpression(node, parent, printStack) { + return isFirstInStatement(printStack, { + considerArrow: true + }); +} + +function DoExpression(node, parent, printStack) { + return isFirstInStatement(printStack); +} + +function Binary(node, parent) { + if (node.operator === "**" && t().isBinaryExpression(parent, { + operator: "**" + })) { + return parent.left === node; + } + + if (isClassExtendsClause(node, parent)) { + return true; + } + + if ((t().isCallExpression(parent) || t().isNewExpression(parent)) && parent.callee === node || t().isUnaryLike(parent) || t().isMemberExpression(parent) && parent.object === node || t().isAwaitExpression(parent)) { + return true; + } + + if (t().isBinary(parent)) { + const parentOp = parent.operator; + const parentPos = PRECEDENCE[parentOp]; + const nodeOp = node.operator; + const nodePos = PRECEDENCE[nodeOp]; + + if (parentPos === nodePos && parent.right === node && !t().isLogicalExpression(parent) || parentPos > nodePos) { + return true; + } + } + + return false; +} + +function UnionTypeAnnotation(node, parent) { + return t().isArrayTypeAnnotation(parent) || t().isNullableTypeAnnotation(parent) || t().isIntersectionTypeAnnotation(parent) || t().isUnionTypeAnnotation(parent); +} + +function TSAsExpression() { + return true; +} + +function TSTypeAssertion() { + return true; +} + +function TSUnionType(node, parent) { + return t().isTSArrayType(parent) || t().isTSOptionalType(parent) || t().isTSIntersectionType(parent) || t().isTSUnionType(parent) || t().isTSRestType(parent); +} + +function BinaryExpression(node, parent) { + return node.operator === "in" && (t().isVariableDeclarator(parent) || t().isFor(parent)); +} + +function SequenceExpression(node, parent) { + if (t().isForStatement(parent) || t().isThrowStatement(parent) || t().isReturnStatement(parent) || t().isIfStatement(parent) && parent.test === node || t().isWhileStatement(parent) && parent.test === node || t().isForInStatement(parent) && parent.right === node || t().isSwitchStatement(parent) && parent.discriminant === node || t().isExpressionStatement(parent) && parent.expression === node) { + return false; + } + + return true; +} + +function YieldExpression(node, parent) { + return t().isBinary(parent) || t().isUnaryLike(parent) || t().isCallExpression(parent) || t().isMemberExpression(parent) || t().isNewExpression(parent) || t().isAwaitExpression(parent) && t().isYieldExpression(node) || t().isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent); +} + +function ClassExpression(node, parent, printStack) { + return isFirstInStatement(printStack, { + considerDefaultExports: true + }); +} + +function UnaryLike(node, parent) { + return t().isMemberExpression(parent, { + object: node + }) || t().isCallExpression(parent, { + callee: node + }) || t().isNewExpression(parent, { + callee: node + }) || t().isBinaryExpression(parent, { + operator: "**", + left: node + }) || isClassExtendsClause(node, parent); +} + +function FunctionExpression(node, parent, printStack) { + return isFirstInStatement(printStack, { + considerDefaultExports: true + }); +} + +function ArrowFunctionExpression(node, parent) { + return t().isExportDeclaration(parent) || ConditionalExpression(node, parent); +} + +function ConditionalExpression(node, parent) { + if (t().isUnaryLike(parent) || t().isBinary(parent) || t().isConditionalExpression(parent, { + test: node + }) || t().isAwaitExpression(parent) || t().isOptionalMemberExpression(parent) || t().isTaggedTemplateExpression(parent) || t().isTSTypeAssertion(parent) || t().isTSAsExpression(parent)) { + return true; + } + + return UnaryLike(node, parent); +} + +function OptionalMemberExpression(node, parent) { + return t().isCallExpression(parent) || t().isMemberExpression(parent); +} + +function AssignmentExpression(node) { + if (t().isObjectPattern(node.left)) { + return true; + } else { + return ConditionalExpression(...arguments); + } +} + +function NewExpression(node, parent) { + return isClassExtendsClause(node, parent); +} + +function isFirstInStatement(printStack, { + considerArrow = false, + considerDefaultExports = false +} = {}) { + let i = printStack.length - 1; + let node = printStack[i]; + i--; + let parent = printStack[i]; + + while (i > 0) { + if (t().isExpressionStatement(parent, { + expression: node + }) || t().isTaggedTemplateExpression(parent) || considerDefaultExports && t().isExportDefaultDeclaration(parent, { + declaration: node + }) || considerArrow && t().isArrowFunctionExpression(parent, { + body: node + })) { + return true; + } + + if (t().isCallExpression(parent, { + callee: node + }) || t().isSequenceExpression(parent) && parent.expressions[0] === node || t().isMemberExpression(parent, { + object: node + }) || t().isConditional(parent, { + test: node + }) || t().isBinary(parent, { + left: node + }) || t().isAssignmentExpression(parent, { + left: node + })) { + node = parent; + i--; + parent = printStack[i]; + } else { + return false; + } + } + + return false; +} \ No newline at end of file diff --git a/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/whitespace.js b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/whitespace.js new file mode 100644 index 00000000000000..061218601cbbed --- /dev/null +++ b/tools/node_modules/babel-eslint/node_modules/@babel/generator/lib/node/whitespace.js @@ -0,0 +1,192 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.list = exports.nodes = void 0; + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function () { + return data; + }; + + return data; +} + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function crawl(node, state = {}) { + if (t().isMemberExpression(node)) { + crawl(node.object, state); + if (node.computed) crawl(node.property, state); + } else if (t().isBinary(node) || t().isAssignmentExpression(node)) { + crawl(node.left, state); + crawl(node.right, state); + } else if (t().isCallExpression(node)) { + state.hasCall = true; + crawl(node.callee, state); + } else if (t().isFunction(node)) { + state.hasFunction = true; + } else if (t().isIdentifier(node)) { + state.hasHelper = state.hasHelper || isHelper(node.callee); + } + + return state; +} + +function isHelper(node) { + if (t().isMemberExpression(node)) { + return isHelper(node.object) || isHelper(node.property); + } else if (t().isIdentifier(node)) { + return node.name === "require" || node.name[0] === "_"; + } else if (t().isCallExpression(node)) { + return isHelper(node.callee); + } else if (t().isBinary(node) || t().isAssignmentExpression(node)) { + return t().isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right); + } else { + return false; + } +} + +function isType(node) { + return t().isLiteral(node) || t().isObjectExpression(node) || t().isArrayExpression(node) || t().isIdentifier(node) || t().isMemberExpression(node); +} + +const nodes = { + AssignmentExpression(node) { + const state = crawl(node.right); + + if (state.hasCall && state.hasHelper || state.hasFunction) { + return { + before: state.hasFunction, + after: true + }; + } + }, + + SwitchCase(node, parent) { + return { + before: node.consequent.length || parent.cases[0] === node, + after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node + }; + }, + + LogicalExpression(node) { + if (t().isFunction(node.left) || t().isFunction(node.right)) { + return { + after: true + }; + } + }, + + Literal(node) { + if (node.value === "use strict") { + return { + after: true + }; + } + }, + + CallExpression(node) { + if (t().isFunction(node.callee) || isHelper(node)) { + return { + before: true, + after: true + }; + } + }, + + VariableDeclaration(node) { + for (let i = 0; i < node.declarations.length; i++) { + const declar = node.declarations[i]; + let enabled = isHelper(declar.id) && !isType(declar.init); + + if (!enabled) { + const state = crawl(declar.init); + enabled = isHelper(declar.init) && state.hasCall || state.hasFunction; + } + + if (enabled) { + return { + before: true, + after: true + }; + } + } + }, + + IfStatement(node) { + if (t().isBlockStatement(node.consequent)) { + return { + before: true, + after: true + }; + } + } + +}; +exports.nodes = nodes; + +nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) { + if (parent.properties[0] === node) { + return { + before: true + }; + } +}; + +nodes.ObjectTypeCallProperty = function (node, parent) { + if (parent.callProperties[0] === node && (!parent.properties || !parent.properties.length)) { + return { + before: true + }; + } +}; + +nodes.ObjectTypeIndexer = function (node, parent) { + if (parent.indexers[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length)) { + return { + before: true + }; + } +}; + +nodes.ObjectTypeInternalSlot = function (node, parent) { + if (parent.internalSlots[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length) && (!parent.indexers || !parent.indexers.length)) { + return { + before: true + }; + } +}; + +const list = { + VariableDeclaration(node) { + return node.declarations.map(decl => decl.init); + }, + + ArrayExpression(node) { + return node.elements; + }, + + ObjectExpression(node) { + return node.properties; + } + +}; +exports.list = list; +[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) { + if (typeof amounts === "boolean") { + amounts = { + after: amounts, + before: amounts + }; + } + + [type].concat(t().FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) { + nodes[type] = function () { + return amounts; + }; + }); +}); \ No newline at end of file diff --git a/tools/node_modules/babel-eslint/node_modules/ms/index.js b/tools/node_modules/babel-eslint/node_modules/ms/index.js index 72297501f9b9bb..c4498bcc212589 100644 --- a/tools/node_modules/babel-eslint/node_modules/ms/index.js +++ b/tools/node_modules/babel-eslint/node_modules/ms/index.js @@ -28,7 +28,7 @@ module.exports = function(val, options) { var type = typeof val; if (type === 'string' && val.length > 0) { return parse(val); - } else if (type === 'number' && isNaN(val) === false) { + } else if (type === 'number' && isFinite(val)) { return options.long ? fmtLong(val) : fmtShort(val); } throw new Error( @@ -50,7 +50,7 @@ function parse(str) { if (str.length > 100) { return; } - var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( str ); if (!match) { diff --git a/tools/node_modules/babel-eslint/node_modules/ms/package.json b/tools/node_modules/babel-eslint/node_modules/ms/package.json index c59290ffb9edea..7192a30c57c910 100644 --- a/tools/node_modules/babel-eslint/node_modules/ms/package.json +++ b/tools/node_modules/babel-eslint/node_modules/ms/package.json @@ -42,5 +42,5 @@ "precommit": "lint-staged", "test": "mocha tests.js" }, - "version": "2.1.1" + "version": "2.1.2" } \ No newline at end of file diff --git a/tools/node_modules/babel-eslint/node_modules/ms/readme.md b/tools/node_modules/babel-eslint/node_modules/ms/readme.md index bb767293ac740d..9a1996b17e0de6 100644 --- a/tools/node_modules/babel-eslint/node_modules/ms/readme.md +++ b/tools/node_modules/babel-eslint/node_modules/ms/readme.md @@ -1,7 +1,7 @@ # ms [![Build Status](https://travis-ci.org/zeit/ms.svg?branch=master)](https://travis-ci.org/zeit/ms) -[![Slack Channel](http://zeit-slackin.now.sh/badge.svg)](https://zeit.chat/) +[![Join the community on Spectrum](https://withspectrum.github.io/badge/badge.svg)](https://spectrum.chat/zeit) Use this package to easily convert various time formats to milliseconds. diff --git a/tools/node_modules/babel-eslint/package.json b/tools/node_modules/babel-eslint/package.json index 73a82acccd0fbc..296e9f51f410b1 100644 --- a/tools/node_modules/babel-eslint/package.json +++ b/tools/node_modules/babel-eslint/package.json @@ -63,5 +63,5 @@ "test": "npm run lint && npm run test-only", "test-only": "mocha && mocha --require test/fixtures/preprocess-to-patch.js" }, - "version": "10.0.1" + "version": "10.0.2" } \ No newline at end of file