create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/destructuring-assignment.js

@@ -1,280 +0,0 @@
-/**
- * @fileoverview Enforce consistent usage of destructuring assignment of props, state, and context.
- */
-
-'use strict';
-
-const Components = require('../util/Components');
-const docsUrl = require('../util/docsUrl');
-const isAssignmentLHS = require('../util/ast').isAssignmentLHS;
-const report = require('../util/report');
-
-const DEFAULT_OPTION = 'always';
-
-function createSFCParams() {
-  const queue = [];
-
-  return {
-    push(params) {
-      queue.unshift(params);
-    },
-    pop() {
-      queue.shift();
-    },
-    propsName() {
-      const found = queue.find((params) => {
-        const props = params[0];
-        return props && !props.destructuring && props.name;
-      });
-      return found && found[0] && found[0].name;
-    },
-    contextName() {
-      const found = queue.find((params) => {
-        const context = params[1];
-        return context && !context.destructuring && context.name;
-      });
-      return found && found[1] && found[1].name;
-    },
-  };
-}
-
-function evalParams(params) {
-  return params.map((param) => ({
-    destructuring: param.type === 'ObjectPattern',
-    name: param.type === 'Identifier' && param.name,
-  }));
-}
-
-const messages = {
-  noDestructPropsInSFCArg: 'Must never use destructuring props assignment in SFC argument',
-  noDestructContextInSFCArg: 'Must never use destructuring context assignment in SFC argument',
-  noDestructAssignment: 'Must never use destructuring {{type}} assignment',
-  useDestructAssignment: 'Must use destructuring {{type}} assignment',
-  destructureInSignature: 'Must destructure props in the function signature.',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce consistent usage of destructuring assignment of props, state, and context',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('destructuring-assignment'),
-    },
-    fixable: 'code',
-    messages,
-
-    schema: [{
-      type: 'string',
-      enum: [
-        'always',
-        'never',
-      ],
-    }, {
-      type: 'object',
-      properties: {
-        ignoreClassFields: {
-          type: 'boolean',
-        },
-        destructureInSignature: {
-          type: 'string',
-          enum: [
-            'always',
-            'ignore',
-          ],
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create: Components.detect((context, components, utils) => {
-    const configuration = context.options[0] || DEFAULT_OPTION;
-    const ignoreClassFields = (context.options[1] && (context.options[1].ignoreClassFields === true)) || false;
-    const destructureInSignature = (context.options[1] && context.options[1].destructureInSignature) || 'ignore';
-    const sfcParams = createSFCParams();
-
-    /**
-     * @param {ASTNode} node We expect either an ArrowFunctionExpression,
-     *   FunctionDeclaration, or FunctionExpression
-     */
-    function handleStatelessComponent(node) {
-      const params = evalParams(node.params);
-
-      const SFCComponent = components.get(context.getScope(node).block);
-      if (!SFCComponent) {
-        return;
-      }
-      sfcParams.push(params);
-
-      if (params[0] && params[0].destructuring && components.get(node) && configuration === 'never') {
-        report(context, messages.noDestructPropsInSFCArg, 'noDestructPropsInSFCArg', {
-          node,
-        });
-      } else if (params[1] && params[1].destructuring && components.get(node) && configuration === 'never') {
-        report(context, messages.noDestructContextInSFCArg, 'noDestructContextInSFCArg', {
-          node,
-        });
-      }
-    }
-
-    function handleStatelessComponentExit(node) {
-      const SFCComponent = components.get(context.getScope(node).block);
-      if (SFCComponent) {
-        sfcParams.pop();
-      }
-    }
-
-    function handleSFCUsage(node) {
-      const propsName = sfcParams.propsName();
-      const contextName = sfcParams.contextName();
-      // props.aProp || context.aProp
-      const isPropUsed = (
-        (propsName && node.object.name === propsName)
-          || (contextName && node.object.name === contextName)
-      )
-        && !isAssignmentLHS(node);
-      if (isPropUsed && configuration === 'always' && !node.optional) {
-        report(context, messages.useDestructAssignment, 'useDestructAssignment', {
-          node,
-          data: {
-            type: node.object.name,
-          },
-        });
-      }
-    }
-
-    function isInClassProperty(node) {
-      let curNode = node.parent;
-      while (curNode) {
-        if (curNode.type === 'ClassProperty' || curNode.type === 'PropertyDefinition') {
-          return true;
-        }
-        curNode = curNode.parent;
-      }
-      return false;
-    }
-
-    function handleClassUsage(node) {
-      // this.props.Aprop || this.context.aProp || this.state.aState
-      const isPropUsed = (
-        node.object.type === 'MemberExpression' && node.object.object.type === 'ThisExpression'
-        && (node.object.property.name === 'props' || node.object.property.name === 'context' || node.object.property.name === 'state')
-        && !isAssignmentLHS(node)
-      );
-
-      if (
-        isPropUsed && configuration === 'always'
-        && !(ignoreClassFields && isInClassProperty(node))
-      ) {
-        report(context, messages.useDestructAssignment, 'useDestructAssignment', {
-          node,
-          data: {
-            type: node.object.property.name,
-          },
-        });
-      }
-    }
-
-    return {
-
-      FunctionDeclaration: handleStatelessComponent,
-
-      ArrowFunctionExpression: handleStatelessComponent,
-
-      FunctionExpression: handleStatelessComponent,
-
-      'FunctionDeclaration:exit': handleStatelessComponentExit,
-
-      'ArrowFunctionExpression:exit': handleStatelessComponentExit,
-
-      'FunctionExpression:exit': handleStatelessComponentExit,
-
-      MemberExpression(node) {
-        let scope = context.getScope(node);
-        let SFCComponent = components.get(scope.block);
-        while (!SFCComponent && scope.upper && scope.upper !== scope) {
-          SFCComponent = components.get(scope.upper.block);
-          scope = scope.upper;
-        }
-        if (SFCComponent) {
-          handleSFCUsage(node);
-        }
-
-        const classComponent = utils.getParentComponent(node);
-        if (classComponent) {
-          handleClassUsage(node);
-        }
-      },
-
-      VariableDeclarator(node) {
-        const classComponent = utils.getParentComponent(node);
-        const SFCComponent = components.get(context.getScope(node).block);
-
-        const destructuring = (node.init && node.id && node.id.type === 'ObjectPattern');
-        // let {foo} = props;
-        const destructuringSFC = destructuring && (node.init.name === 'props' || node.init.name === 'context');
-        // let {foo} = this.props;
-        const destructuringClass = destructuring && node.init.object && node.init.object.type === 'ThisExpression' && (
-          node.init.property.name === 'props' || node.init.property.name === 'context' || node.init.property.name === 'state'
-        );
-
-        if (SFCComponent && destructuringSFC && configuration === 'never') {
-          report(context, messages.noDestructAssignment, 'noDestructAssignment', {
-            node,
-            data: {
-              type: node.init.name,
-            },
-          });
-        }
-
-        if (
-          classComponent && destructuringClass && configuration === 'never'
-          && !(ignoreClassFields && (node.parent.type === 'ClassProperty' || node.parent.type === 'PropertyDefinition'))
-        ) {
-          report(context, messages.noDestructAssignment, 'noDestructAssignment', {
-            node,
-            data: {
-              type: node.init.property.name,
-            },
-          });
-        }
-
-        if (
-          SFCComponent
-          && destructuringSFC
-          && configuration === 'always'
-          && destructureInSignature === 'always'
-          && node.init.name === 'props'
-        ) {
-          const scopeSetProps = context.getScope().set.get('props');
-          const propsRefs = scopeSetProps && scopeSetProps.references;
-          if (!propsRefs) {
-            return;
-          }
-          // Skip if props is used elsewhere
-          if (propsRefs.length > 1) {
-            return;
-          }
-          report(context, messages.destructureInSignature, 'destructureInSignature', {
-            node,
-            fix(fixer) {
-              const param = SFCComponent.node.params[0];
-              if (!param) {
-                return;
-              }
-              const replaceRange = [
-                param.range[0],
-                param.typeAnnotation ? param.typeAnnotation.range[0] : param.range[1],
-              ];
-              return [
-                fixer.replaceTextRange(replaceRange, context.getSourceCode().getText(node.id)),
-                fixer.remove(node.parent),
-              ];
-            },
-          });
-        }
-      },
-    };
-  }),
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/display-name.js

@@ -1,283 +0,0 @@
-/**
- * @fileoverview Prevent missing displayName in a React component definition
- * @author Yannick Croissant
- */
-
-'use strict';
-
-const values = require('object.values');
-const filter = require('es-iterator-helpers/Iterator.prototype.filter');
-const forEach = require('es-iterator-helpers/Iterator.prototype.forEach');
-
-const Components = require('../util/Components');
-const isCreateContext = require('../util/isCreateContext');
-const astUtil = require('../util/ast');
-const componentUtil = require('../util/componentUtil');
-const docsUrl = require('../util/docsUrl');
-const testReactVersion = require('../util/version').testReactVersion;
-const propsUtil = require('../util/props');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  noDisplayName: 'Component definition is missing display name',
-  noContextDisplayName: 'Context definition is missing display name',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow missing displayName in a React component definition',
-      category: 'Best Practices',
-      recommended: true,
-      url: docsUrl('display-name'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        ignoreTranspilerName: {
-          type: 'boolean',
-        },
-        checkContextObjects: {
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create: Components.detect((context, components, utils) => {
-    const config = context.options[0] || {};
-    const ignoreTranspilerName = config.ignoreTranspilerName || false;
-    const checkContextObjects = (config.checkContextObjects || false) && testReactVersion(context, '>= 16.3.0');
-
-    const contextObjects = new Map();
-
-    /**
-     * Mark a prop type as declared
-     * @param {ASTNode} node The AST node being checked.
-     */
-    function markDisplayNameAsDeclared(node) {
-      components.set(node, {
-        hasDisplayName: true,
-      });
-    }
-
-    /**
-     * Checks if React.forwardRef is nested inside React.memo
-     * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if React.forwardRef is nested inside React.memo, false if not.
-     */
-    function isNestedMemo(node) {
-      const argumentIsCallExpression = node.arguments && node.arguments[0] && node.arguments[0].type === 'CallExpression';
-
-      return node.type === 'CallExpression' && argumentIsCallExpression && utils.isPragmaComponentWrapper(node);
-    }
-
-    /**
-     * Reports missing display name for a given component
-     * @param {Object} component The component to process
-     */
-    function reportMissingDisplayName(component) {
-      if (
-        testReactVersion(context, '^0.14.10 || ^15.7.0 || >= 16.12.0')
-        && isNestedMemo(component.node)
-      ) {
-        return;
-      }
-
-      report(context, messages.noDisplayName, 'noDisplayName', {
-        node: component.node,
-      });
-    }
-
-    /**
-     * Reports missing display name for a given context object
-     * @param {Object} contextObj The context object to process
-     */
-    function reportMissingContextDisplayName(contextObj) {
-      report(context, messages.noContextDisplayName, 'noContextDisplayName', {
-        node: contextObj.node,
-      });
-    }
-
-    /**
-     * Checks if the component have a name set by the transpiler
-     * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if component has a name, false if not.
-     */
-    function hasTranspilerName(node) {
-      const namedObjectAssignment = (
-        node.type === 'ObjectExpression'
-        && node.parent
-        && node.parent.parent
-        && node.parent.parent.type === 'AssignmentExpression'
-        && (
-          !node.parent.parent.left.object
-          || node.parent.parent.left.object.name !== 'module'
-          || node.parent.parent.left.property.name !== 'exports'
-        )
-      );
-      const namedObjectDeclaration = (
-        node.type === 'ObjectExpression'
-        && node.parent
-        && node.parent.parent
-        && node.parent.parent.type === 'VariableDeclarator'
-      );
-      const namedClass = (
-        (node.type === 'ClassDeclaration' || node.type === 'ClassExpression')
-        && node.id
-        && !!node.id.name
-      );
-
-      const namedFunctionDeclaration = (
-        (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression')
-        && node.id
-        && !!node.id.name
-      );
-
-      const namedFunctionExpression = (
-        astUtil.isFunctionLikeExpression(node)
-        && node.parent
-        && (node.parent.type === 'VariableDeclarator' || node.parent.type === 'Property' || node.parent.method === true)
-        && (!node.parent.parent || !componentUtil.isES5Component(node.parent.parent, context))
-      );
-
-      if (
-        namedObjectAssignment || namedObjectDeclaration
-        || namedClass
-        || namedFunctionDeclaration || namedFunctionExpression
-      ) {
-        return true;
-      }
-      return false;
-    }
-
-    // --------------------------------------------------------------------------
-    // Public
-    // --------------------------------------------------------------------------
-
-    return {
-      ExpressionStatement(node) {
-        if (checkContextObjects && isCreateContext(node)) {
-          contextObjects.set(node.expression.left.name, { node, hasDisplayName: false });
-        }
-      },
-      VariableDeclarator(node) {
-        if (checkContextObjects && isCreateContext(node)) {
-          contextObjects.set(node.id.name, { node, hasDisplayName: false });
-        }
-      },
-      'ClassProperty, PropertyDefinition'(node) {
-        if (!propsUtil.isDisplayNameDeclaration(node)) {
-          return;
-        }
-        markDisplayNameAsDeclared(node);
-      },
-
-      MemberExpression(node) {
-        if (!propsUtil.isDisplayNameDeclaration(node.property)) {
-          return;
-        }
-        if (
-          checkContextObjects
-          && node.object
-          && node.object.name
-          && contextObjects.has(node.object.name)
-        ) {
-          contextObjects.get(node.object.name).hasDisplayName = true;
-        }
-        const component = utils.getRelatedComponent(node);
-        if (!component) {
-          return;
-        }
-        markDisplayNameAsDeclared(component.node.type === 'TSAsExpression' ? component.node.expression : component.node);
-      },
-
-      'FunctionExpression, FunctionDeclaration, ArrowFunctionExpression'(node) {
-        if (ignoreTranspilerName || !hasTranspilerName(node)) {
-          return;
-        }
-        if (components.get(node)) {
-          markDisplayNameAsDeclared(node);
-        }
-      },
-
-      MethodDefinition(node) {
-        if (!propsUtil.isDisplayNameDeclaration(node.key)) {
-          return;
-        }
-        markDisplayNameAsDeclared(node);
-      },
-
-      'ClassExpression, ClassDeclaration'(node) {
-        if (ignoreTranspilerName || !hasTranspilerName(node)) {
-          return;
-        }
-        markDisplayNameAsDeclared(node);
-      },
-
-      ObjectExpression(node) {
-        if (!componentUtil.isES5Component(node, context)) {
-          return;
-        }
-        if (ignoreTranspilerName || !hasTranspilerName(node)) {
-          // Search for the displayName declaration
-          node.properties.forEach((property) => {
-            if (!property.key || !propsUtil.isDisplayNameDeclaration(property.key)) {
-              return;
-            }
-            markDisplayNameAsDeclared(node);
-          });
-          return;
-        }
-        markDisplayNameAsDeclared(node);
-      },
-
-      CallExpression(node) {
-        if (!utils.isPragmaComponentWrapper(node)) {
-          return;
-        }
-
-        if (node.arguments.length > 0 && astUtil.isFunctionLikeExpression(node.arguments[0])) {
-          // Skip over React.forwardRef declarations that are embeded within
-          // a React.memo i.e. React.memo(React.forwardRef(/* ... */))
-          // This means that we raise a single error for the call to React.memo
-          // instead of one for React.memo and one for React.forwardRef
-          const isWrappedInAnotherPragma = utils.getPragmaComponentWrapper(node);
-          if (
-            !isWrappedInAnotherPragma
-            && (ignoreTranspilerName || !hasTranspilerName(node.arguments[0]))
-          ) {
-            return;
-          }
-
-          if (components.get(node)) {
-            markDisplayNameAsDeclared(node);
-          }
-        }
-      },
-
-      'Program:exit'() {
-        const list = components.list();
-        // Report missing display name for all components
-        values(list).filter((component) => !component.hasDisplayName).forEach((component) => {
-          reportMissingDisplayName(component);
-        });
-        if (checkContextObjects) {
-          // Report missing display name for all context objects
-          forEach(
-            filter(contextObjects.values(), (v) => !v.hasDisplayName),
-            (contextObj) => reportMissingContextDisplayName(contextObj)
-          );
-        }
-      },
-    };
-  }),
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/forbid-component-props.js

@@ -1,134 +0,0 @@
-/**
- * @fileoverview Forbid certain props on components
- * @author Joe Lencioni
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Constants
-// ------------------------------------------------------------------------------
-
-const DEFAULTS = ['className', 'style'];
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  propIsForbidden: 'Prop "{{prop}}" is forbidden on Components',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow certain props on components',
-      category: 'Best Practices',
-      recommended: false,
-      url: docsUrl('forbid-component-props'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        forbid: {
-          type: 'array',
-          items: {
-            anyOf: [
-              { type: 'string' },
-              {
-                type: 'object',
-                properties: {
-                  propName: { type: 'string' },
-                  allowedFor: {
-                    type: 'array',
-                    uniqueItems: true,
-                    items: { type: 'string' },
-                  },
-                  message: { type: 'string' },
-                },
-                additionalProperties: false,
-              },
-              {
-                type: 'object',
-                properties: {
-                  propName: { type: 'string' },
-                  disallowedFor: {
-                    type: 'array',
-                    uniqueItems: true,
-                    minItems: 1,
-                    items: { type: 'string' },
-                  },
-                  message: { type: 'string' },
-                },
-                required: ['disallowedFor'],
-                additionalProperties: false,
-              },
-            ],
-          },
-        },
-      },
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const forbid = new Map((configuration.forbid || DEFAULTS).map((value) => {
-      const propName = typeof value === 'string' ? value : value.propName;
-      const options = {
-        allowList: typeof value === 'string' ? [] : (value.allowedFor || []),
-        disallowList: typeof value === 'string' ? [] : (value.disallowedFor || []),
-        message: typeof value === 'string' ? null : value.message,
-      };
-      return [propName, options];
-    }));
-
-    function isForbidden(prop, tagName) {
-      const options = forbid.get(prop);
-      if (!options) {
-        return false;
-      }
-
-      // disallowList should have a least one item (schema configuration)
-      const isTagForbidden = options.disallowList.length > 0
-        ? options.disallowList.indexOf(tagName) !== -1
-        : options.allowList.indexOf(tagName) === -1;
-
-      // if the tagName is undefined (`<this.something>`), we assume it's a forbidden element
-      return typeof tagName === 'undefined' || isTagForbidden;
-    }
-
-    return {
-      JSXAttribute(node) {
-        const parentName = node.parent.name;
-        // Extract a component name when using a "namespace", e.g. `<AntdLayout.Content />`.
-        const tag = parentName.name || `${parentName.object.name}.${parentName.property.name}`;
-        const componentName = parentName.name || parentName.property.name;
-        if (componentName && typeof componentName[0] === 'string' && componentName[0] !== componentName[0].toUpperCase()) {
-          // This is a DOM node, not a Component, so exit.
-          return;
-        }
-
-        const prop = node.name.name;
-
-        if (!isForbidden(prop, tag)) {
-          return;
-        }
-
-        const customMessage = forbid.get(prop).message;
-
-        report(context, customMessage || messages.propIsForbidden, !customMessage && 'propIsForbidden', {
-          node,
-          data: {
-            prop,
-          },
-        });
-      },
-    };
-  },
-};