create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint-plugin-react/lib/util/annotations.js

@@ -1,32 +0,0 @@
-/**
- * @fileoverview Utility functions for type annotation detection.
- * @author Yannick Croissant
- * @author Vitor Balocco
- */
-
-'use strict';
-
-/**
- * Checks if we are declaring a `props` argument with a flow type annotation.
- * @param {ASTNode} node The AST node being checked.
- * @param {Object} context
- * @returns {Boolean} True if the node is a type annotated props declaration, false if not.
- */
-function isAnnotatedFunctionPropsDeclaration(node, context) {
-  if (!node || !node.params || !node.params.length) {
-    return false;
-  }
-
-  const typeNode = node.params[0].type === 'AssignmentPattern' ? node.params[0].left : node.params[0];
-
-  const tokens = context.getFirstTokens(typeNode, 2);
-  const isAnnotated = typeNode.typeAnnotation;
-  const isDestructuredProps = typeNode.type === 'ObjectPattern';
-  const isProps = tokens[0].value === 'props' || (tokens[1] && tokens[1].value === 'props');
-
-  return (isAnnotated && (isDestructuredProps || isProps));
-}
-
-module.exports = {
-  isAnnotatedFunctionPropsDeclaration,
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/util/ast.js

@@ -1,461 +0,0 @@
-/**
- * @fileoverview Utility functions for AST
- */
-
-'use strict';
-
-const estraverse = require('estraverse');
-// const pragmaUtil = require('./pragma');
-
-/**
- * Wrapper for estraverse.traverse
- *
- * @param {ASTNode} ASTnode The AST node being checked
- * @param {Object} visitor Visitor Object for estraverse
- */
-function traverse(ASTnode, visitor) {
-  const opts = Object.assign({}, {
-    fallback(node) {
-      return Object.keys(node).filter((key) => key === 'children' || key === 'argument');
-    },
-  }, visitor);
-
-  opts.keys = Object.assign({}, visitor.keys, {
-    JSXElement: ['children'],
-    JSXFragment: ['children'],
-  });
-
-  estraverse.traverse(ASTnode, opts);
-}
-
-function loopNodes(nodes) {
-  for (let i = nodes.length - 1; i >= 0; i--) {
-    if (nodes[i].type === 'ReturnStatement') {
-      return nodes[i];
-    }
-    if (nodes[i].type === 'SwitchStatement') {
-      const j = nodes[i].cases.length - 1;
-      if (j >= 0) {
-        return loopNodes(nodes[i].cases[j].consequent);
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * Find a return statement in the current node
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {ASTNode | false}
- */
-function findReturnStatement(node) {
-  if (
-    (!node.value || !node.value.body || !node.value.body.body)
-    && (!node.body || !node.body.body)
-  ) {
-    return false;
-  }
-
-  const bodyNodes = node.value ? node.value.body.body : node.body.body;
-
-  return loopNodes(bodyNodes);
-}
-
-// eslint-disable-next-line valid-jsdoc -- valid-jsdoc cannot parse function types.
-/**
- * Helper function for traversing "returns" (return statements or the
- * returned expression in the case of an arrow function) of a function
- *
- * @param {ASTNode} ASTNode The AST node being checked
- * @param {Context} context The context of `ASTNode`.
- * @param {(returnValue: ASTNode, breakTraverse: () => void) => void} onReturn
- *   Function to execute for each returnStatement found
- * @returns {undefined}
- */
-function traverseReturns(ASTNode, context, onReturn) {
-  const nodeType = ASTNode.type;
-
-  if (nodeType === 'ReturnStatement') {
-    onReturn(ASTNode.argument, () => {});
-    return;
-  }
-
-  if (nodeType === 'ArrowFunctionExpression' && ASTNode.expression) {
-    onReturn(ASTNode.body, () => {});
-    return;
-  }
-
-  /* TODO: properly warn on React.forwardRefs having typo properties
-  if (nodeType === 'CallExpression') {
-    const callee = ASTNode.callee;
-    const pragma = pragmaUtil.getFromContext(context);
-    if (
-      callee.type === 'MemberExpression'
-      && callee.object.type === 'Identifier'
-      && callee.object.name === pragma
-      && callee.property.type === 'Identifier'
-      && callee.property.name === 'forwardRef'
-      && ASTNode.arguments.length > 0
-    ) {
-      return enterFunc(ASTNode.arguments[0]);
-    }
-    return;
-  }
-  */
-
-  if (
-    nodeType !== 'FunctionExpression'
-    && nodeType !== 'FunctionDeclaration'
-    && nodeType !== 'ArrowFunctionExpression'
-    && nodeType !== 'MethodDefinition'
-  ) {
-    return;
-  }
-
-  traverse(ASTNode.body, {
-    enter(node) {
-      const breakTraverse = () => {
-        this.break();
-      };
-      switch (node.type) {
-        case 'ReturnStatement':
-          this.skip();
-          onReturn(node.argument, breakTraverse);
-          return;
-        case 'BlockStatement':
-        case 'IfStatement':
-        case 'ForStatement':
-        case 'WhileStatement':
-        case 'SwitchStatement':
-        case 'SwitchCase':
-          return;
-        default:
-          this.skip();
-      }
-    },
-  });
-}
-
-/**
- * Get node with property's name
- * @param {Object} node - Property.
- * @returns {Object} Property name node.
- */
-function getPropertyNameNode(node) {
-  if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
-    return node.key;
-  }
-  if (node.type === 'MemberExpression') {
-    return node.property;
-  }
-  return null;
-}
-
-/**
- * Get properties name
- * @param {Object} node - Property.
- * @returns {String} Property name.
- */
-function getPropertyName(node) {
-  const nameNode = getPropertyNameNode(node);
-  return nameNode ? nameNode.name : '';
-}
-
-/**
- * Get properties for a given AST node
- * @param {ASTNode} node The AST node being checked.
- * @returns {Array} Properties array.
- */
-function getComponentProperties(node) {
-  switch (node.type) {
-    case 'ClassDeclaration':
-    case 'ClassExpression':
-      return node.body.body;
-    case 'ObjectExpression':
-      return node.properties;
-    default:
-      return [];
-  }
-}
-
-/**
- * Gets the first node in a line from the initial node, excluding whitespace.
- * @param {Object} context The node to check
- * @param {ASTNode} node The node to check
- * @return {ASTNode} the first node in the line
- */
-function getFirstNodeInLine(context, node) {
-  const sourceCode = context.getSourceCode();
-  let token = node;
-  let lines;
-  do {
-    token = sourceCode.getTokenBefore(token);
-    lines = token.type === 'JSXText'
-      ? token.value.split('\n')
-      : null;
-  } while (
-    token.type === 'JSXText'
-        && /^\s*$/.test(lines[lines.length - 1])
-  );
-  return token;
-}
-
-/**
- * Checks if the node is the first in its line, excluding whitespace.
- * @param {Object} context The node to check
- * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's the first node in its line
- */
-function isNodeFirstInLine(context, node) {
-  const token = getFirstNodeInLine(context, node);
-  const startLine = node.loc.start.line;
-  const endLine = token ? token.loc.end.line : -1;
-  return startLine !== endLine;
-}
-
-/**
- * Checks if the node is a function or arrow function expression.
- * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function-like expression
- */
-function isFunctionLikeExpression(node) {
-  return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
-}
-
-/**
- * Checks if the node is a function.
- * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function
- */
-function isFunction(node) {
-  return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
-}
-
-/**
- * Checks if node is a function declaration or expression or arrow function.
- * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function-like
- */
-function isFunctionLike(node) {
-  return node.type === 'FunctionDeclaration' || isFunctionLikeExpression(node);
-}
-
-/**
- * Checks if the node is a class.
- * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a class
- */
-function isClass(node) {
-  return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
-}
-
-/**
- * Check if we are in a class constructor
- * @param {Context} context
- * @return {boolean}
- */
-function inConstructor(context) {
-  let scope = context.getScope();
-  while (scope) {
-    // @ts-ignore
-    if (scope.block && scope.block.parent && scope.block.parent.kind === 'constructor') {
-      return true;
-    }
-    scope = scope.upper;
-  }
-  return false;
-}
-
-/**
- * Removes quotes from around an identifier.
- * @param {string} string the identifier to strip
- * @returns {string}
- */
-function stripQuotes(string) {
-  return string.replace(/^'|'$/g, '');
-}
-
-/**
- * Retrieve the name of a key node
- * @param {Context} context The AST node with the key.
- * @param {any} node The AST node with the key.
- * @return {string | undefined} the name of the key
- */
-function getKeyValue(context, node) {
-  if (node.type === 'ObjectTypeProperty') {
-    const tokens = context.getSourceCode().getFirstTokens(node, 2);
-    return (tokens[0].value === '+' || tokens[0].value === '-'
-      ? tokens[1].value
-      : stripQuotes(tokens[0].value)
-    );
-  }
-  if (node.type === 'GenericTypeAnnotation') {
-    return node.id.name;
-  }
-  if (node.type === 'ObjectTypeAnnotation') {
-    return;
-  }
-  const key = node.key || node.argument;
-  if (!key) {
-    return;
-  }
-  return key.type === 'Identifier' ? key.name : key.value;
-}
-
-/**
- * Checks if a node is surrounded by parenthesis.
- *
- * @param {object} context - Context from the rule
- * @param {ASTNode} node - Node to be checked
- * @returns {boolean}
- */
-function isParenthesized(context, node) {
-  const sourceCode = context.getSourceCode();
-  const previousToken = sourceCode.getTokenBefore(node);
-  const nextToken = sourceCode.getTokenAfter(node);
-
-  return !!previousToken && !!nextToken
-    && previousToken.value === '(' && previousToken.range[1] <= node.range[0]
-    && nextToken.value === ')' && nextToken.range[0] >= node.range[1];
-}
-
-/**
- * Checks if a node is being assigned a value: props.bar = 'bar'
- * @param {ASTNode} node The AST node being checked.
- * @returns {Boolean}
- */
-function isAssignmentLHS(node) {
-  return (
-    node.parent
-    && node.parent.type === 'AssignmentExpression'
-    && node.parent.left === node
-  );
-}
-
-/**
- * Extracts the expression node that is wrapped inside a TS type assertion
- *
- * @param {ASTNode} node - potential TS node
- * @returns {ASTNode} - unwrapped expression node
- */
-function unwrapTSAsExpression(node) {
-  if (node && node.type === 'TSAsExpression') return node.expression;
-  return node;
-}
-
-function isTSTypeReference(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeReference';
-}
-
-function isTSTypeAnnotation(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeAnnotation';
-}
-
-function isTSTypeLiteral(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeLiteral';
-}
-
-function isTSIntersectionType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSIntersectionType';
-}
-
-function isTSInterfaceHeritage(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSInterfaceHeritage';
-}
-
-function isTSInterfaceDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
-  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-  }
-  return nodeType === 'TSInterfaceDeclaration';
-}
-
-function isTSTypeDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
-  let nodeKind = node.kind;
-  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-    nodeKind = node.declaration.kind;
-  }
-  return nodeType === 'VariableDeclaration' && nodeKind === 'type';
-}
-
-function isTSTypeAliasDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
-  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-    return nodeType === 'TSTypeAliasDeclaration' && node.exportKind === 'type';
-  }
-  return nodeType === 'TSTypeAliasDeclaration';
-}
-
-function isTSParenthesizedType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeAliasDeclaration';
-}
-
-function isTSFunctionType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSFunctionType';
-}
-
-function isTSTypeQuery(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeQuery';
-}
-
-function isTSTypeParameterInstantiation(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeParameterInstantiation';
-}
-
-module.exports = {
-  traverse,
-  findReturnStatement,
-  getFirstNodeInLine,
-  getPropertyName,
-  getPropertyNameNode,
-  getComponentProperties,
-  getKeyValue,
-  isParenthesized,
-  isAssignmentLHS,
-  isClass,
-  isFunction,
-  isFunctionLikeExpression,
-  isFunctionLike,
-  inConstructor,
-  isNodeFirstInLine,
-  unwrapTSAsExpression,
-  traverseReturns,
-  isTSTypeReference,
-  isTSTypeAnnotation,
-  isTSTypeLiteral,
-  isTSIntersectionType,
-  isTSInterfaceHeritage,
-  isTSInterfaceDeclaration,
-  isTSTypeAliasDeclaration,
-  isTSParenthesizedType,
-  isTSFunctionType,
-  isTSTypeQuery,
-  isTSTypeParameterInstantiation,
-  isTSTypeDeclaration,
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/util/componentUtil.js

@@ -1,182 +0,0 @@
-'use strict';
-
-const doctrine = require('doctrine');
-const pragmaUtil = require('./pragma');
-
-// eslint-disable-next-line valid-jsdoc
-/**
- * @template {(_: object) => any} T
- * @param {T} fn
- * @returns {T}
- */
-function memoize(fn) {
-  const cache = new WeakMap();
-  // @ts-ignore
-  return function memoizedFn(arg) {
-    const cachedValue = cache.get(arg);
-    if (cachedValue !== undefined) {
-      return cachedValue;
-    }
-    const v = fn(arg);
-    cache.set(arg, v);
-    return v;
-  };
-}
-
-const getPragma = memoize(pragmaUtil.getFromContext);
-const getCreateClass = memoize(pragmaUtil.getCreateClassFromContext);
-
-/**
- * @param {ASTNode} node
- * @param {Context} context
- * @returns {boolean}
- */
-function isES5Component(node, context) {
-  const pragma = getPragma(context);
-  const createClass = getCreateClass(context);
-
-  if (!node.parent || !node.parent.callee) {
-    return false;
-  }
-  const callee = node.parent.callee;
-  // React.createClass({})
-  if (callee.type === 'MemberExpression') {
-    return callee.object.name === pragma && callee.property.name === createClass;
-  }
-  // createClass({})
-  if (callee.type === 'Identifier') {
-    return callee.name === createClass;
-  }
-  return false;
-}
-
-/**
- * Check if the node is explicitly declared as a descendant of a React Component
- * @param {any} node
- * @param {Context} context
- * @returns {boolean}
- */
-function isExplicitComponent(node, context) {
-  const sourceCode = context.getSourceCode();
-  let comment;
-  // Sometimes the passed node may not have been parsed yet by eslint, and this function call crashes.
-  // Can be removed when eslint sets "parent" property for all nodes on initial AST traversal: https://github.com/eslint/eslint-scope/issues/27
-  // eslint-disable-next-line no-warning-comments
-  // FIXME: Remove try/catch when https://github.com/eslint/eslint-scope/issues/27 is implemented.
-  try {
-    comment = sourceCode.getJSDocComment(node);
-  } catch (e) {
-    comment = null;
-  }
-
-  if (comment === null) {
-    return false;
-  }
-
-  let commentAst;
-  try {
-    commentAst = doctrine.parse(comment.value, {
-      unwrap: true,
-      tags: ['extends', 'augments'],
-    });
-  } catch (e) {
-    // handle a bug in the archived `doctrine`, see #2596
-    return false;
-  }
-
-  const relevantTags = commentAst.tags.filter((tag) => tag.name === 'React.Component' || tag.name === 'React.PureComponent');
-
-  return relevantTags.length > 0;
-}
-
-/**
- * @param {ASTNode} node
- * @param {Context} context
- * @returns {boolean}
- */
-function isES6Component(node, context) {
-  const pragma = getPragma(context);
-  if (isExplicitComponent(node, context)) {
-    return true;
-  }
-
-  if (!node.superClass) {
-    return false;
-  }
-  if (node.superClass.type === 'MemberExpression') {
-    return node.superClass.object.name === pragma
-          && /^(Pure)?Component$/.test(node.superClass.property.name);
-  }
-  if (node.superClass.type === 'Identifier') {
-    return /^(Pure)?Component$/.test(node.superClass.name);
-  }
-  return false;
-}
-
-/**
- * Get the parent ES5 component node from the current scope
- * @param {Context} context
- * @returns {ASTNode|null}
- */
-function getParentES5Component(context) {
-  let scope = context.getScope();
-  while (scope) {
-    // @ts-ignore
-    const node = scope.block && scope.block.parent && scope.block.parent.parent;
-    if (node && isES5Component(node, context)) {
-      return node;
-    }
-    scope = scope.upper;
-  }
-  return null;
-}
-
-/**
- * Get the parent ES6 component node from the current scope
- * @param {Context} context
- * @returns {ASTNode | null}
- */
-function getParentES6Component(context) {
-  let scope = context.getScope();
-  while (scope && scope.type !== 'class') {
-    scope = scope.upper;
-  }
-  const node = scope && scope.block;
-  if (!node || !isES6Component(node, context)) {
-    return null;
-  }
-  return node;
-}
-
-/**
- * Checks if a component extends React.PureComponent
- * @param {ASTNode} node
- * @param {Context} context
- * @returns {boolean}
- */
-function isPureComponent(node, context) {
-  const pragma = getPragma(context);
-  const sourceCode = context.getSourceCode();
-  if (node.superClass) {
-    return new RegExp(`^(${pragma}\\.)?PureComponent$`).test(sourceCode.getText(node.superClass));
-  }
-  return false;
-}
-
-/**
- * @param {ASTNode} node
- * @returns {boolean}
- */
-function isStateMemberExpression(node) {
-  return node.type === 'MemberExpression' && node.object.type === 'ThisExpression' && node.property.name === 'state';
-}
-
-module.exports = {
-  isES5Component,
-  isES6Component,
-  getParentES5Component,
-  getParentES6Component,
-  isExplicitComponent,
-  isPureComponent,
-  isStateMemberExpression,
-};