create-packer 1.34.9 → 1.35.0

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

@@ -1,174 +0,0 @@
-/**
- * @fileoverview Enforce default props alphabetical sorting
- * @author Vladimir Kattsov
- * @deprecated
- */
-
-'use strict';
-
-const variableUtil = require('../util/variable');
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  propsNotSorted: 'Default prop types declarations should be sorted alphabetically',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce defaultProps declarations alphabetical sorting',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('sort-default-props'),
-    },
-    // fixable: 'code',
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        ignoreCase: {
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const ignoreCase = configuration.ignoreCase || false;
-
-    /**
-     * Get properties name
-     * @param {Object} node - Property.
-     * @returns {String} Property name.
-     */
-    function getPropertyName(node) {
-      if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
-        return node.key.name;
-      }
-      if (node.type === 'MemberExpression') {
-        return node.property.name;
-      // Special case for class properties
-      // (babel-eslint@5 does not expose property name so we have to rely on tokens)
-      }
-      if (node.type === 'ClassProperty') {
-        const tokens = context.getSourceCode().getFirstTokens(node, 2);
-        return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
-      }
-      return '';
-    }
-
-    /**
-     * Checks if the Identifier node passed in looks like a defaultProps declaration.
-     * @param   {ASTNode}  node The node to check. Must be an Identifier node.
-     * @returns {Boolean}       `true` if the node is a defaultProps declaration, `false` if not
-     */
-    function isDefaultPropsDeclaration(node) {
-      const propName = getPropertyName(node);
-      return (propName === 'defaultProps' || propName === 'getDefaultProps');
-    }
-
-    function getKey(node) {
-      return context.getSourceCode().getText(node.key || node.argument);
-    }
-
-    /**
-     * Find a variable by name in the current scope.
-     * @param  {string} name Name of the variable to look for.
-     * @returns {ASTNode|null} Return null if the variable could not be found, ASTNode otherwise.
-     */
-    function findVariableByName(name) {
-      const variable = variableUtil.variablesInScope(context).find((item) => item.name === name);
-
-      if (!variable || !variable.defs[0] || !variable.defs[0].node) {
-        return null;
-      }
-
-      if (variable.defs[0].node.type === 'TypeAlias') {
-        return variable.defs[0].node.right;
-      }
-
-      return variable.defs[0].node.init;
-    }
-
-    /**
-     * Checks if defaultProps declarations are sorted
-     * @param {Array} declarations The array of AST nodes being checked.
-     * @returns {void}
-     */
-    function checkSorted(declarations) {
-      // function fix(fixer) {
-      //   return propTypesSortUtil.fixPropTypesSort(fixer, context, declarations, ignoreCase);
-      // }
-
-      declarations.reduce((prev, curr, idx, decls) => {
-        if (/Spread(?:Property|Element)$/.test(curr.type)) {
-          return decls[idx + 1];
-        }
-
-        let prevPropName = getKey(prev);
-        let currentPropName = getKey(curr);
-
-        if (ignoreCase) {
-          prevPropName = prevPropName.toLowerCase();
-          currentPropName = currentPropName.toLowerCase();
-        }
-
-        if (currentPropName < prevPropName) {
-          report(context, messages.propsNotSorted, 'propsNotSorted', {
-            node: curr,
-            // fix
-          });
-
-          return prev;
-        }
-
-        return curr;
-      }, declarations[0]);
-    }
-
-    function checkNode(node) {
-      if (!node) {
-        return;
-      }
-      if (node.type === 'ObjectExpression') {
-        checkSorted(node.properties);
-      } else if (node.type === 'Identifier') {
-        const propTypesObject = findVariableByName(node.name);
-        if (propTypesObject && propTypesObject.properties) {
-          checkSorted(propTypesObject.properties);
-        }
-      }
-    }
-
-    // --------------------------------------------------------------------------
-    // Public API
-    // --------------------------------------------------------------------------
-
-    return {
-      'ClassProperty, PropertyDefinition'(node) {
-        if (!isDefaultPropsDeclaration(node)) {
-          return;
-        }
-
-        checkNode(node.value);
-      },
-
-      MemberExpression(node) {
-        if (!isDefaultPropsDeclaration(node)) {
-          return;
-        }
-
-        checkNode(node.parent.right);
-      },
-    };
-  },
-};

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

@@ -1,266 +0,0 @@
-/**
- * @fileoverview Enforce propTypes declarations alphabetical sorting
- */
-
-'use strict';
-
-const variableUtil = require('../util/variable');
-const propsUtil = require('../util/props');
-const docsUrl = require('../util/docsUrl');
-const propWrapperUtil = require('../util/propWrapper');
-const propTypesSortUtil = require('../util/propTypesSort');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  requiredPropsFirst: 'Required prop types must be listed before all other prop types',
-  callbackPropsLast: 'Callback prop types must be listed after all other prop types',
-  propsNotSorted: 'Prop types declarations should be sorted alphabetically',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce propTypes declarations alphabetical sorting',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('sort-prop-types'),
-    },
-    fixable: 'code',
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        requiredFirst: {
-          type: 'boolean',
-        },
-        callbacksLast: {
-          type: 'boolean',
-        },
-        ignoreCase: {
-          type: 'boolean',
-        },
-        // Whether alphabetical sorting should be enforced
-        noSortAlphabetically: {
-          type: 'boolean',
-        },
-        sortShapeProp: {
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const requiredFirst = configuration.requiredFirst || false;
-    const callbacksLast = configuration.callbacksLast || false;
-    const ignoreCase = configuration.ignoreCase || false;
-    const noSortAlphabetically = configuration.noSortAlphabetically || false;
-    const sortShapeProp = configuration.sortShapeProp || false;
-
-    function getKey(node) {
-      if (node.key && node.key.value) {
-        return node.key.value;
-      }
-      return context.getSourceCode().getText(node.key || node.argument);
-    }
-
-    function getValueName(node) {
-      return node.type === 'Property' && node.value.property && node.value.property.name;
-    }
-
-    function isCallbackPropName(propName) {
-      return /^on[A-Z]/.test(propName);
-    }
-
-    function isRequiredProp(node) {
-      return getValueName(node) === 'isRequired';
-    }
-
-    function isShapeProp(node) {
-      return Boolean(
-        node && node.callee && node.callee.property && node.callee.property.name === 'shape'
-      );
-    }
-
-    function toLowerCase(item) {
-      return String(item).toLowerCase();
-    }
-
-    /**
-     * Checks if propTypes declarations are sorted
-     * @param {Array} declarations The array of AST nodes being checked.
-     * @returns {void}
-     */
-    function checkSorted(declarations) {
-      // Declarations will be `undefined` if the `shape` is not a literal. For
-      // example, if it is a propType imported from another file.
-      if (!declarations) {
-        return;
-      }
-
-      function fix(fixer) {
-        return propTypesSortUtil.fixPropTypesSort(
-          fixer,
-          context,
-          declarations,
-          ignoreCase,
-          requiredFirst,
-          callbacksLast,
-          noSortAlphabetically,
-          sortShapeProp
-        );
-      }
-
-      const callbackPropsLastSeen = new WeakSet();
-      const requiredPropsFirstSeen = new WeakSet();
-      const propsNotSortedSeen = new WeakSet();
-
-      declarations.reduce((prev, curr, idx, decls) => {
-        if (curr.type === 'ExperimentalSpreadProperty' || curr.type === 'SpreadElement') {
-          return decls[idx + 1];
-        }
-
-        let prevPropName = getKey(prev);
-        let currentPropName = getKey(curr);
-        const previousIsRequired = isRequiredProp(prev);
-        const currentIsRequired = isRequiredProp(curr);
-        const previousIsCallback = isCallbackPropName(prevPropName);
-        const currentIsCallback = isCallbackPropName(currentPropName);
-
-        if (ignoreCase) {
-          prevPropName = toLowerCase(prevPropName);
-          currentPropName = toLowerCase(currentPropName);
-        }
-
-        if (requiredFirst) {
-          if (previousIsRequired && !currentIsRequired) {
-            // Transition between required and non-required. Don't compare for alphabetical.
-            return curr;
-          }
-          if (!previousIsRequired && currentIsRequired) {
-            // Encountered a non-required prop after a required prop
-            if (!requiredPropsFirstSeen.has(curr)) {
-              requiredPropsFirstSeen.add(curr);
-              report(context, messages.requiredPropsFirst, 'requiredPropsFirst', {
-                node: curr,
-                fix,
-              });
-            }
-            return curr;
-          }
-        }
-
-        if (callbacksLast) {
-          if (!previousIsCallback && currentIsCallback) {
-            // Entering the callback prop section
-            return curr;
-          }
-          if (previousIsCallback && !currentIsCallback) {
-            // Encountered a non-callback prop after a callback prop
-            if (!callbackPropsLastSeen.has(prev)) {
-              callbackPropsLastSeen.add(prev);
-              report(context, messages.callbackPropsLast, 'callbackPropsLast', {
-                node: prev,
-                fix,
-              });
-            }
-            return prev;
-          }
-        }
-
-        if (!noSortAlphabetically && currentPropName < prevPropName) {
-          if (!propsNotSortedSeen.has(curr)) {
-            propsNotSortedSeen.add(curr);
-            report(context, messages.propsNotSorted, 'propsNotSorted', {
-              node: curr,
-              fix,
-            });
-          }
-          return prev;
-        }
-
-        return curr;
-      }, declarations[0]);
-    }
-
-    function checkNode(node) {
-      switch (node && node.type) {
-        case 'ObjectExpression':
-          checkSorted(node.properties);
-          break;
-        case 'Identifier': {
-          const propTypesObject = variableUtil.findVariableByName(context, node.name);
-          if (propTypesObject && propTypesObject.properties) {
-            checkSorted(propTypesObject.properties);
-          }
-          break;
-        }
-        case 'CallExpression': {
-          const innerNode = node.arguments && node.arguments[0];
-          if (propWrapperUtil.isPropWrapperFunction(context, node.callee.name) && innerNode) {
-            checkNode(innerNode);
-          }
-          break;
-        }
-        default:
-          break;
-      }
-    }
-
-    return {
-      CallExpression(node) {
-        if (!sortShapeProp || !isShapeProp(node) || !(node.arguments && node.arguments[0])) {
-          return;
-        }
-
-        const firstArg = node.arguments[0];
-        if (firstArg.properties) {
-          checkSorted(firstArg.properties);
-        } else if (firstArg.type === 'Identifier') {
-          const variable = variableUtil.findVariableByName(context, firstArg.name);
-          if (variable && variable.properties) {
-            checkSorted(variable.properties);
-          }
-        }
-      },
-
-      'ClassProperty, PropertyDefinition'(node) {
-        if (!propsUtil.isPropTypesDeclaration(node)) {
-          return;
-        }
-        checkNode(node.value);
-      },
-
-      MemberExpression(node) {
-        if (!propsUtil.isPropTypesDeclaration(node)) {
-          return;
-        }
-
-        checkNode(node.parent.right);
-      },
-
-      ObjectExpression(node) {
-        node.properties.forEach((property) => {
-          if (!property.key) {
-            return;
-          }
-
-          if (!propsUtil.isPropTypesDeclaration(property)) {
-            return;
-          }
-          if (property.value.type === 'ObjectExpression') {
-            checkSorted(property.value.properties);
-          }
-        });
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/state-in-constructor.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Enforce the state initialization style to be either in a constructor or with a class property
- * @author Kanitkorn Sujautra
- */
-
-'use strict';
-
-const astUtil = require('../util/ast');
-const componentUtil = require('../util/componentUtil');
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  stateInitConstructor: 'State initialization should be in a constructor',
-  stateInitClassProp: 'State initialization should be in a class property',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce class component state initialization style',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('state-in-constructor'),
-    },
-
-    messages,
-
-    schema: [{
-      enum: ['always', 'never'],
-    }],
-  },
-
-  create(context) {
-    const option = context.options[0] || 'always';
-    return {
-      'ClassProperty, PropertyDefinition'(node) {
-        if (
-          option === 'always'
-          && !node.static
-          && node.key.name === 'state'
-          && componentUtil.getParentES6Component(context)
-        ) {
-          report(context, messages.stateInitConstructor, 'stateInitConstructor', {
-            node,
-          });
-        }
-      },
-      AssignmentExpression(node) {
-        if (
-          option === 'never'
-          && componentUtil.isStateMemberExpression(node.left)
-          && astUtil.inConstructor(context)
-          && componentUtil.getParentES6Component(context)
-        ) {
-          report(context, messages.stateInitClassProp, 'stateInitClassProp', {
-            node,
-          });
-        }
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/static-property-placement.js

@@ -1,187 +0,0 @@
-/**
- * @fileoverview Defines where React component static properties should be positioned.
- * @author Daniel Mason
- */
-
-'use strict';
-
-const fromEntries = require('object.fromentries');
-const Components = require('../util/Components');
-const docsUrl = require('../util/docsUrl');
-const astUtil = require('../util/ast');
-const componentUtil = require('../util/componentUtil');
-const propsUtil = require('../util/props');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Positioning Options
-// ------------------------------------------------------------------------------
-const STATIC_PUBLIC_FIELD = 'static public field';
-const STATIC_GETTER = 'static getter';
-const PROPERTY_ASSIGNMENT = 'property assignment';
-const POSITION_SETTINGS = [STATIC_PUBLIC_FIELD, STATIC_GETTER, PROPERTY_ASSIGNMENT];
-
-// ------------------------------------------------------------------------------
-// Rule messages
-// ------------------------------------------------------------------------------
-const ERROR_MESSAGES = {
-  [STATIC_PUBLIC_FIELD]: 'notStaticClassProp',
-  [STATIC_GETTER]: 'notGetterClassFunc',
-  [PROPERTY_ASSIGNMENT]: 'declareOutsideClass',
-};
-
-// ------------------------------------------------------------------------------
-// Properties to check
-// ------------------------------------------------------------------------------
-const propertiesToCheck = {
-  propTypes: propsUtil.isPropTypesDeclaration,
-  defaultProps: propsUtil.isDefaultPropsDeclaration,
-  childContextTypes: propsUtil.isChildContextTypesDeclaration,
-  contextTypes: propsUtil.isContextTypesDeclaration,
-  contextType: propsUtil.isContextTypeDeclaration,
-  displayName: (node) => propsUtil.isDisplayNameDeclaration(astUtil.getPropertyNameNode(node)),
-};
-
-const classProperties = Object.keys(propertiesToCheck);
-const schemaProperties = fromEntries(classProperties.map((property) => [property, { enum: POSITION_SETTINGS }]));
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  notStaticClassProp: '\'{{name}}\' should be declared as a static class property.',
-  notGetterClassFunc: '\'{{name}}\' should be declared as a static getter class function.',
-  declareOutsideClass: '\'{{name}}\' should be declared outside the class body.',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforces where React component static properties should be positioned.',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('static-property-placement'),
-    },
-    fixable: null, // or 'code' or 'whitespace'
-
-    messages,
-
-    schema: [
-      { enum: POSITION_SETTINGS },
-      {
-        type: 'object',
-        properties: schemaProperties,
-        additionalProperties: false,
-      },
-    ],
-  },
-
-  create: Components.detect((context, components, utils) => {
-    // variables should be defined here
-    const options = context.options;
-    const defaultCheckType = options[0] || STATIC_PUBLIC_FIELD;
-    const hasAdditionalConfig = options.length > 1;
-    const additionalConfig = hasAdditionalConfig ? options[1] : {};
-
-    // Set config
-    const config = fromEntries(classProperties.map((property) => [
-      property,
-      additionalConfig[property] || defaultCheckType,
-    ]));
-
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-
-    /**
-      * Checks if we are declaring context in class
-      * @returns {Boolean} True if we are declaring context in class, false if not.
-     */
-    function isContextInClass() {
-      let blockNode;
-      let scope = context.getScope();
-      while (scope) {
-        blockNode = scope.block;
-        if (blockNode && blockNode.type === 'ClassDeclaration') {
-          return true;
-        }
-        scope = scope.upper;
-      }
-
-      return false;
-    }
-
-    /**
-     * Check if we should report this property node
-     * @param {ASTNode} node
-     * @param {string} expectedRule
-     */
-    function reportNodeIncorrectlyPositioned(node, expectedRule) {
-      // Detect if this node is an expected property declaration adn return the property name
-      const name = classProperties.find((propertyName) => {
-        if (propertiesToCheck[propertyName](node)) {
-          return !!propertyName;
-        }
-
-        return false;
-      });
-
-      // If name is set but the configured rule does not match expected then report error
-      if (
-        name
-        && (
-          config[name] !== expectedRule
-          || (!node.static && (config[name] === STATIC_PUBLIC_FIELD || config[name] === STATIC_GETTER))
-        )
-      ) {
-        const messageId = ERROR_MESSAGES[config[name]];
-        report(context, messages[messageId], messageId, {
-          node,
-          data: { name },
-        });
-      }
-    }
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-    return {
-      'ClassProperty, PropertyDefinition'(node) {
-        if (!componentUtil.getParentES6Component(context)) {
-          return;
-        }
-
-        reportNodeIncorrectlyPositioned(node, STATIC_PUBLIC_FIELD);
-      },
-
-      MemberExpression(node) {
-        // If definition type is undefined then it must not be a defining expression or if the definition is inside a
-        // class body then skip this node.
-        const right = node.parent.right;
-        if (!right || right.type === 'undefined' || isContextInClass()) {
-          return;
-        }
-
-        // Get the related component
-        const relatedComponent = utils.getRelatedComponent(node);
-
-        // If the related component is not an ES6 component then skip this node
-        if (!relatedComponent || !componentUtil.isES6Component(relatedComponent.node, context)) {
-          return;
-        }
-
-        // Report if needed
-        reportNodeIncorrectlyPositioned(node, PROPERTY_ASSIGNMENT);
-      },
-
-      MethodDefinition(node) {
-        // If the function is inside a class and is static getter then check if correctly positioned
-        if (componentUtil.getParentES6Component(context) && node.static && node.kind === 'get') {
-          // Report error if needed
-          reportNodeIncorrectlyPositioned(node, STATIC_GETTER);
-        }
-      },
-    };
-  }),
-};