create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/prop-types.js

@@ -0,0 +1,201 @@
+/**
+ * @fileoverview Prevent missing props validation in a React component definition
+ * @author Yannick Croissant
+ */
+
+'use strict';
+
+// As for exceptions for props.children or props.className (and alike) look at
+// https://github.com/jsx-eslint/eslint-plugin-react/issues/7
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  missingPropType: '\'{{name}}\' is missing in props validation',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow missing props validation in a React component definition',
+      category: 'Best Practices',
+      recommended: true,
+      url: docsUrl('prop-types'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        customValidators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        skipUndeclared: {
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const ignored = configuration.ignore || [];
+    const skipUndeclared = configuration.skipUndeclared || false;
+
+    /**
+     * Checks if the prop is ignored
+     * @param {String} name Name of the prop to check.
+     * @returns {Boolean} True if the prop is ignored, false if not.
+     */
+    function isIgnored(name) {
+      return ignored.indexOf(name) !== -1;
+    }
+
+    /**
+     * Checks if the component must be validated
+     * @param {Object} component The component to process
+     * @returns {Boolean} True if the component must be validated, false if not.
+     */
+    function mustBeValidated(component) {
+      const isSkippedByConfig = skipUndeclared && typeof component.declaredPropTypes === 'undefined';
+      return Boolean(
+        component
+        && component.usedPropTypes
+        && !component.ignorePropsValidation
+        && !isSkippedByConfig
+      );
+    }
+
+    /**
+     * Internal: Checks if the prop is declared
+     * @param {Object} declaredPropTypes Description of propTypes declared in the current component
+     * @param {String[]} keyList Dot separated name of the prop to check.
+     * @returns {Boolean} True if the prop is declared, false if not.
+     */
+    function internalIsDeclaredInComponent(declaredPropTypes, keyList) {
+      for (let i = 0, j = keyList.length; i < j; i++) {
+        const key = keyList[i];
+        const propType = (
+          declaredPropTypes && (
+            // Check if this key is declared
+            (declaredPropTypes[key] // If not, check if this type accepts any key
+            || declaredPropTypes.__ANY_KEY__) // eslint-disable-line no-underscore-dangle
+          )
+        );
+
+        if (!propType) {
+          // If it's a computed property, we can't make any further analysis, but is valid
+          return key === '__COMPUTED_PROP__';
+        }
+        if (typeof propType === 'object' && !propType.type) {
+          return true;
+        }
+        // Consider every children as declared
+        if (propType.children === true || propType.containsUnresolvedSpread || propType.containsIndexers) {
+          return true;
+        }
+        if (propType.acceptedProperties) {
+          return key in propType.acceptedProperties;
+        }
+        if (propType.type === 'union') {
+          // If we fall in this case, we know there is at least one complex type in the union
+          if (i + 1 >= j) {
+            // this is the last key, accept everything
+            return true;
+          }
+          // non trivial, check all of them
+          const unionTypes = propType.children;
+          const unionPropType = {};
+          for (let k = 0, z = unionTypes.length; k < z; k++) {
+            unionPropType[key] = unionTypes[k];
+            const isValid = internalIsDeclaredInComponent(
+              unionPropType,
+              keyList.slice(i)
+            );
+            if (isValid) {
+              return true;
+            }
+          }
+
+          // every possible union were invalid
+          return false;
+        }
+        declaredPropTypes = propType.children;
+      }
+      return true;
+    }
+
+    /**
+     * Checks if the prop is declared
+     * @param {ASTNode} node The AST node being checked.
+     * @param {String[]} names List of names of the prop to check.
+     * @returns {Boolean} True if the prop is declared, false if not.
+     */
+    function isDeclaredInComponent(node, names) {
+      while (node) {
+        const component = components.get(node);
+
+        const isDeclared = component && component.confidence === 2
+          && internalIsDeclaredInComponent(component.declaredPropTypes || {}, names);
+
+        if (isDeclared) {
+          return true;
+        }
+
+        node = node.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Reports undeclared proptypes for a given component
+     * @param {Object} component The component to process
+     */
+    function reportUndeclaredPropTypes(component) {
+      const undeclareds = component.usedPropTypes.filter((propType) => (
+        propType.node
+        && !isIgnored(propType.allNames[0])
+        && !isDeclaredInComponent(component.node, propType.allNames)
+      ));
+      undeclareds.forEach((propType) => {
+        report(context, messages.missingPropType, 'missingPropType', {
+          node: propType.node,
+          data: {
+            name: propType.allNames.join('.').replace(/\.__COMPUTED_PROP__/g, '[]'),
+          },
+        });
+      });
+    }
+
+    return {
+      'Program:exit'() {
+        const list = components.list();
+        // Report undeclared proptypes for all classes
+        values(list)
+          .filter((component) => mustBeValidated(component))
+          .forEach((component) => {
+            reportUndeclaredPropTypes(component);
+          });
+      },
+    };
+  }),
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/react-in-jsx-scope.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Prevent missing React when using JSX
+ * @author Glen Mailer
+ */
+
+'use strict';
+
+const variableUtil = require('../util/variable');
+const pragmaUtil = require('../util/pragma');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// -----------------------------------------------------------------------------
+// Rule Definition
+// -----------------------------------------------------------------------------
+
+const messages = {
+  notInScope: '\'{{name}}\' must be in scope when using JSX',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow missing React when using JSX',
+      category: 'Possible Errors',
+      recommended: true,
+      url: docsUrl('react-in-jsx-scope'),
+    },
+
+    messages,
+
+    schema: [],
+  },
+
+  create(context) {
+    const pragma = pragmaUtil.getFromContext(context);
+
+    function checkIfReactIsInScope(node) {
+      const variables = variableUtil.variablesInScope(context);
+      if (variableUtil.findVariable(variables, pragma)) {
+        return;
+      }
+      report(context, messages.notInScope, 'notInScope', {
+        node,
+        data: {
+          name: pragma,
+        },
+      });
+    }
+
+    return {
+      JSXOpeningElement: checkIfReactIsInScope,
+      JSXOpeningFragment: checkIfReactIsInScope,
+    };
+  },
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/require-default-props.js

@@ -0,0 +1,193 @@
+/**
+ * @fileOverview Enforce a defaultProps definition for every prop that is not a required prop.
+ * @author Vitor Balocco
+ */
+
+'use strict';
+
+const entries = require('object.entries');
+const values = require('object.values');
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  noDefaultWithRequired: 'propType "{{name}}" is required and should not have a defaultProps declaration.',
+  shouldHaveDefault: 'propType "{{name}}" is not required, but has no corresponding defaultProps declaration.',
+  noDefaultPropsWithFunction: 'Don’t use defaultProps with function components.',
+  shouldAssignObjectDefault: 'propType "{{name}}" is not required, but has no corresponding default argument value.',
+  destructureInSignature: 'Must destructure props in the function signature to initialize an optional prop.',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce a defaultProps definition for every prop that is not a required prop',
+      category: 'Best Practices',
+      url: docsUrl('require-default-props'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        forbidDefaultForRequired: {
+          type: 'boolean',
+        },
+        classes: {
+          enum: ['defaultProps', 'ignore'],
+        },
+        functions: {
+          enum: ['defaultArguments', 'defaultProps', 'ignore'],
+        },
+        /**
+         * @deprecated
+         */
+        ignoreFunctionalComponents: {
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const forbidDefaultForRequired = configuration.forbidDefaultForRequired || false;
+    const classes = configuration.classes || 'defaultProps';
+    /**
+     * @todo
+     * - Remove ignoreFunctionalComponents
+     * - Change default to 'defaultArguments'
+     */
+    const functions = configuration.ignoreFunctionalComponents
+      ? 'ignore'
+      : configuration.functions || 'defaultProps';
+
+    /**
+     * Reports all propTypes passed in that don't have a defaultProps counterpart.
+     * @param  {Object[]} propTypes    List of propTypes to check.
+     * @param  {Object}   defaultProps Object of defaultProps to check. Keys are the props names.
+     * @return {void}
+     */
+    function reportPropTypesWithoutDefault(propTypes, defaultProps) {
+      entries(propTypes).forEach((propType) => {
+        const propName = propType[0];
+        const prop = propType[1];
+
+        if (!prop.node) {
+          return;
+        }
+        if (prop.isRequired) {
+          if (forbidDefaultForRequired && defaultProps[propName]) {
+            report(context, messages.noDefaultWithRequired, 'noDefaultWithRequired', {
+              node: prop.node,
+              data: { name: propName },
+            });
+          }
+          return;
+        }
+
+        if (defaultProps[propName]) {
+          return;
+        }
+
+        report(context, messages.shouldHaveDefault, 'shouldHaveDefault', {
+          node: prop.node,
+          data: { name: propName },
+        });
+      });
+    }
+
+    /**
+     * If functions option is 'defaultArguments', reports defaultProps is used and all params that doesn't initialized.
+     * @param {Object} componentNode Node of component.
+     * @param {Object[]} declaredPropTypes List of propTypes to check `isRequired`.
+     * @param {Object} defaultProps Object of defaultProps to check used.
+     */
+    function reportFunctionComponent(componentNode, declaredPropTypes, defaultProps) {
+      if (defaultProps) {
+        report(context, messages.noDefaultPropsWithFunction, 'noDefaultPropsWithFunction', {
+          node: componentNode,
+        });
+      }
+
+      const props = componentNode.params[0];
+      const propTypes = declaredPropTypes;
+
+      if (!props) {
+        return;
+      }
+
+      if (props.type === 'Identifier') {
+        const hasOptionalProp = values(propTypes).some((propType) => !propType.isRequired);
+        if (hasOptionalProp) {
+          report(context, messages.destructureInSignature, 'destructureInSignature', {
+            node: props,
+          });
+        }
+      } else if (props.type === 'ObjectPattern') {
+        props.properties.filter((prop) => {
+          if (prop.type === 'RestElement' || prop.type === 'ExperimentalRestProperty') {
+            return false;
+          }
+          const propType = propTypes[prop.key.name];
+          if (!propType || propType.isRequired) {
+            return false;
+          }
+          return prop.value.type !== 'AssignmentPattern';
+        }).forEach((prop) => {
+          report(context, messages.shouldAssignObjectDefault, 'shouldAssignObjectDefault', {
+            node: prop,
+            data: { name: prop.key.name },
+          });
+        });
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+
+    return {
+      'Program:exit'() {
+        const list = components.list();
+
+        values(list).filter((component) => {
+          if (functions === 'ignore' && astUtil.isFunctionLike(component.node)) {
+            return false;
+          }
+          if (classes === 'ignore' && astUtil.isClass(component.node)) {
+            return false;
+          }
+
+          // If this defaultProps is "unresolved", then we should ignore this component and not report
+          // any errors for it, to avoid false-positives with e.g. external defaultProps declarations or spread operators.
+          if (component.defaultProps === 'unresolved') {
+            return false;
+          }
+          return component.declaredPropTypes !== undefined;
+        }).forEach((component) => {
+          if (functions === 'defaultArguments' && astUtil.isFunctionLike(component.node)) {
+            reportFunctionComponent(
+              component.node,
+              component.declaredPropTypes,
+              component.defaultProps
+            );
+          } else {
+            reportPropTypesWithoutDefault(
+              component.declaredPropTypes,
+              component.defaultProps || {}
+            );
+          }
+        });
+      },
+    };
+  }),
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/require-optimization.js

@@ -0,0 +1,239 @@
+/**
+ * @fileoverview Enforce React components to have a shouldComponentUpdate method
+ * @author Evgueni Naverniouk
+ */
+
+'use strict';
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+const messages = {
+  noShouldComponentUpdate: 'Component is not optimized. Please add a shouldComponentUpdate method.',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce React components to have a shouldComponentUpdate method',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('require-optimization'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        allowDecorators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const allowDecorators = configuration.allowDecorators || [];
+
+    /**
+     * Checks to see if our component is decorated by PureRenderMixin via reactMixin
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {Boolean} True if node is decorated with a PureRenderMixin, false if not.
+     */
+    function hasPureRenderDecorator(node) {
+      if (node.decorators && node.decorators.length) {
+        for (let i = 0, l = node.decorators.length; i < l; i++) {
+          if (
+            node.decorators[i].expression
+            && node.decorators[i].expression.callee
+            && node.decorators[i].expression.callee.object
+            && node.decorators[i].expression.callee.object.name === 'reactMixin'
+            && node.decorators[i].expression.callee.property
+            && node.decorators[i].expression.callee.property.name === 'decorate'
+            && node.decorators[i].expression.arguments
+            && node.decorators[i].expression.arguments.length
+            && node.decorators[i].expression.arguments[0].name === 'PureRenderMixin'
+          ) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Checks to see if our component is custom decorated
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {Boolean} True if node is decorated name with a custom decorated, false if not.
+     */
+    function hasCustomDecorator(node) {
+      const allowLength = allowDecorators.length;
+
+      if (allowLength && node.decorators && node.decorators.length) {
+        for (let i = 0; i < allowLength; i++) {
+          for (let j = 0, l = node.decorators.length; j < l; j++) {
+            if (
+              node.decorators[j].expression
+              && node.decorators[j].expression.name === allowDecorators[i]
+            ) {
+              return true;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Checks if we are declaring a shouldComponentUpdate method
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {Boolean} True if we are declaring a shouldComponentUpdate method, false if not.
+     */
+    function isSCUDeclared(node) {
+      return Boolean(
+        node
+        && node.name === 'shouldComponentUpdate'
+      );
+    }
+
+    /**
+     * Checks if we are declaring a PureRenderMixin mixin
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {Boolean} True if we are declaring a PureRenderMixin method, false if not.
+     */
+    function isPureRenderDeclared(node) {
+      let hasPR = false;
+      if (node.value && node.value.elements) {
+        for (let i = 0, l = node.value.elements.length; i < l; i++) {
+          if (node.value.elements[i] && node.value.elements[i].name === 'PureRenderMixin') {
+            hasPR = true;
+            break;
+          }
+        }
+      }
+
+      return Boolean(
+        node
+        && node.key.name === 'mixins'
+        && hasPR
+      );
+    }
+
+    /**
+     * Mark shouldComponentUpdate as declared
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markSCUAsDeclared(node) {
+      components.set(node, {
+        hasSCU: true,
+      });
+    }
+
+    /**
+     * Reports missing optimization for a given component
+     * @param {Object} component The component to process
+     */
+    function reportMissingOptimization(component) {
+      report(context, messages.noShouldComponentUpdate, 'noShouldComponentUpdate', {
+        node: component.node,
+      });
+    }
+
+    /**
+     * Checks if we are declaring function in class
+     * @returns {Boolean} True if we are declaring function in class, false if not.
+     */
+    function isFunctionInClass() {
+      let blockNode;
+      let scope = context.getScope();
+      while (scope) {
+        blockNode = scope.block;
+        if (blockNode && blockNode.type === 'ClassDeclaration') {
+          return true;
+        }
+        scope = scope.upper;
+      }
+
+      return false;
+    }
+
+    return {
+      ArrowFunctionExpression(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass()) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      ClassDeclaration(node) {
+        if (!(
+          hasPureRenderDecorator(node)
+          || hasCustomDecorator(node)
+          || componentUtil.isPureComponent(node, context)
+        )) {
+          return;
+        }
+        markSCUAsDeclared(node);
+      },
+
+      FunctionDeclaration(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass()) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      FunctionExpression(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass()) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      MethodDefinition(node) {
+        if (!isSCUDeclared(node.key)) {
+          return;
+        }
+        markSCUAsDeclared(node);
+      },
+
+      ObjectExpression(node) {
+        // Search for the shouldComponentUpdate declaration
+        const found = node.properties.some((property) => (
+          property.key
+          && (isSCUDeclared(property.key) || isPureRenderDeclared(property))
+        ));
+        if (found) {
+          markSCUAsDeclared(node);
+        }
+      },
+
+      'Program:exit'() {
+        // Report missing shouldComponentUpdate for all components
+        values(components.list())
+          .filter((component) => !component.hasSCU)
+          .forEach((component) => {
+            reportMissingOptimization(component);
+          });
+      },
+    };
+  }),
+};