create-packer 1.34.9 → 1.35.0

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

@@ -1,293 +0,0 @@
-/**
- * @fileoverview Report missing `key` props in iterators/collection literals.
- * @author Ben Mosher
- */
-
-'use strict';
-
-const hasProp = require('jsx-ast-utils/hasProp');
-const propName = require('jsx-ast-utils/propName');
-const values = require('object.values');
-const docsUrl = require('../util/docsUrl');
-const pragmaUtil = require('../util/pragma');
-const report = require('../util/report');
-const astUtil = require('../util/ast');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const defaultOptions = {
-  checkFragmentShorthand: false,
-  checkKeyMustBeforeSpread: false,
-  warnOnDuplicates: false,
-};
-
-const messages = {
-  missingIterKey: 'Missing "key" prop for element in iterator',
-  missingIterKeyUsePrag: 'Missing "key" prop for element in iterator. Shorthand fragment syntax does not support providing keys. Use {{reactPrag}}.{{fragPrag}} instead',
-  missingArrayKey: 'Missing "key" prop for element in array',
-  missingArrayKeyUsePrag: 'Missing "key" prop for element in array. Shorthand fragment syntax does not support providing keys. Use {{reactPrag}}.{{fragPrag}} instead',
-  keyBeforeSpread: '`key` prop must be placed before any `{...spread}, to avoid conflicting with React’s new JSX transform: https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html`',
-  nonUniqueKeys: '`key` prop must be unique',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow missing `key` props in iterators/collection literals',
-      category: 'Possible Errors',
-      recommended: true,
-      url: docsUrl('jsx-key'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        checkFragmentShorthand: {
-          type: 'boolean',
-          default: defaultOptions.checkFragmentShorthand,
-        },
-        checkKeyMustBeforeSpread: {
-          type: 'boolean',
-          default: defaultOptions.checkKeyMustBeforeSpread,
-        },
-        warnOnDuplicates: {
-          type: 'boolean',
-          default: defaultOptions.warnOnDuplicates,
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const options = Object.assign({}, defaultOptions, context.options[0]);
-    const checkFragmentShorthand = options.checkFragmentShorthand;
-    const checkKeyMustBeforeSpread = options.checkKeyMustBeforeSpread;
-    const warnOnDuplicates = options.warnOnDuplicates;
-    const reactPragma = pragmaUtil.getFromContext(context);
-    const fragmentPragma = pragmaUtil.getFragmentFromContext(context);
-
-    function checkIteratorElement(node) {
-      if (node.type === 'JSXElement' && !hasProp(node.openingElement.attributes, 'key')) {
-        report(context, messages.missingIterKey, 'missingIterKey', {
-          node,
-        });
-      } else if (checkFragmentShorthand && node.type === 'JSXFragment') {
-        report(context, messages.missingIterKeyUsePrag, 'missingIterKeyUsePrag', {
-          node,
-          data: {
-            reactPrag: reactPragma,
-            fragPrag: fragmentPragma,
-          },
-        });
-      }
-    }
-
-    function getReturnStatements(node) {
-      const returnStatements = arguments[1] || [];
-      if (node.type === 'IfStatement') {
-        if (node.consequent) {
-          getReturnStatements(node.consequent, returnStatements);
-        }
-        if (node.alternate) {
-          getReturnStatements(node.alternate, returnStatements);
-        }
-      } else if (Array.isArray(node.body)) {
-        node.body.forEach((item) => {
-          if (item.type === 'IfStatement') {
-            getReturnStatements(item, returnStatements);
-          }
-
-          if (item.type === 'ReturnStatement') {
-            returnStatements.push(item);
-          }
-        });
-      }
-
-      return returnStatements;
-    }
-
-    function isKeyAfterSpread(attributes) {
-      let hasFoundSpread = false;
-      return attributes.some((attribute) => {
-        if (attribute.type === 'JSXSpreadAttribute') {
-          hasFoundSpread = true;
-          return false;
-        }
-        if (attribute.type !== 'JSXAttribute') {
-          return false;
-        }
-        return hasFoundSpread && propName(attribute) === 'key';
-      });
-    }
-
-    /**
-     * Checks if the given node is a function expression or arrow function,
-     * and checks if there is a missing key prop in return statement's arguments
-     * @param {ASTNode} node
-     */
-    function checkFunctionsBlockStatement(node) {
-      if (astUtil.isFunctionLikeExpression(node)) {
-        if (node.body.type === 'BlockStatement') {
-          getReturnStatements(node.body)
-            .filter((returnStatement) => returnStatement && returnStatement.argument)
-            .forEach((returnStatement) => {
-              checkIteratorElement(returnStatement.argument);
-            });
-        }
-      }
-    }
-
-    /**
-     * Checks if the given node is an arrow function that has an JSX Element or JSX Fragment in its body,
-     * and the JSX is missing a key prop
-     * @param {ASTNode} node
-     */
-    function checkArrowFunctionWithJSX(node) {
-      const isArrFn = node && node.type === 'ArrowFunctionExpression';
-      const shouldCheckNode = (n) => n && (n.type === 'JSXElement' || n.type === 'JSXFragment');
-      if (isArrFn && shouldCheckNode(node.body)) {
-        checkIteratorElement(node.body);
-      }
-      if (node.body.type === 'ConditionalExpression') {
-        if (shouldCheckNode(node.body.consequent)) {
-          checkIteratorElement(node.body.consequent);
-        }
-        if (shouldCheckNode(node.body.alternate)) {
-          checkIteratorElement(node.body.alternate);
-        }
-      } else if (node.body.type === 'LogicalExpression' && shouldCheckNode(node.body.right)) {
-        checkIteratorElement(node.body.right);
-      }
-    }
-
-    const childrenToArraySelector = `:matches(
-      CallExpression
-        [callee.object.object.name=${reactPragma}]
-        [callee.object.property.name=Children]
-        [callee.property.name=toArray],
-      CallExpression
-        [callee.object.name=Children]
-        [callee.property.name=toArray]
-    )`.replace(/\s/g, '');
-    let isWithinChildrenToArray = false;
-
-    const seen = new WeakSet();
-
-    return {
-      [childrenToArraySelector]() {
-        isWithinChildrenToArray = true;
-      },
-
-      [`${childrenToArraySelector}:exit`]() {
-        isWithinChildrenToArray = false;
-      },
-
-      'ArrayExpression, JSXElement > JSXElement'(node) {
-        if (isWithinChildrenToArray) {
-          return;
-        }
-
-        const jsx = (node.type === 'ArrayExpression' ? node.elements : node.parent.children).filter((x) => x && x.type === 'JSXElement');
-        if (jsx.length === 0) {
-          return;
-        }
-
-        const map = {};
-        jsx.forEach((element) => {
-          const attrs = element.openingElement.attributes;
-          const keys = attrs.filter((x) => x.name && x.name.name === 'key');
-
-          if (keys.length === 0) {
-            if (node.type === 'ArrayExpression') {
-              report(context, messages.missingArrayKey, 'missingArrayKey', {
-                node: element,
-              });
-            }
-          } else {
-            keys.forEach((attr) => {
-              const value = context.getSourceCode().getText(attr.value);
-              if (!map[value]) { map[value] = []; }
-              map[value].push(attr);
-
-              if (checkKeyMustBeforeSpread && isKeyAfterSpread(attrs)) {
-                report(context, messages.keyBeforeSpread, 'keyBeforeSpread', {
-                  node: node.type === 'ArrayExpression' ? node : node.parent,
-                });
-              }
-            });
-          }
-        });
-
-        if (warnOnDuplicates) {
-          values(map).filter((v) => v.length > 1).forEach((v) => {
-            v.forEach((n) => {
-              if (!seen.has(n)) {
-                seen.add(n);
-                report(context, messages.nonUniqueKeys, 'nonUniqueKeys', {
-                  node: n,
-                });
-              }
-            });
-          });
-        }
-      },
-
-      JSXFragment(node) {
-        if (!checkFragmentShorthand || isWithinChildrenToArray) {
-          return;
-        }
-
-        if (node.parent.type === 'ArrayExpression') {
-          report(context, messages.missingArrayKeyUsePrag, 'missingArrayKeyUsePrag', {
-            node,
-            data: {
-              reactPrag: reactPragma,
-              fragPrag: fragmentPragma,
-            },
-          });
-        }
-      },
-
-      // Array.prototype.map
-      // eslint-disable-next-line no-multi-str
-      'CallExpression[callee.type="MemberExpression"][callee.property.name="map"],\
-       CallExpression[callee.type="OptionalMemberExpression"][callee.property.name="map"],\
-       OptionalCallExpression[callee.type="MemberExpression"][callee.property.name="map"],\
-       OptionalCallExpression[callee.type="OptionalMemberExpression"][callee.property.name="map"]'(node) {
-        if (isWithinChildrenToArray) {
-          return;
-        }
-
-        const fn = node.arguments.length > 0 && node.arguments[0];
-        if (!fn || !astUtil.isFunctionLikeExpression(fn)) {
-          return;
-        }
-
-        checkArrowFunctionWithJSX(fn);
-
-        checkFunctionsBlockStatement(fn);
-      },
-
-      // Array.from
-      'CallExpression[callee.type="MemberExpression"][callee.property.name="from"]'(node) {
-        if (isWithinChildrenToArray) {
-          return;
-        }
-
-        const fn = node.arguments.length > 1 && node.arguments[1];
-        if (!astUtil.isFunctionLikeExpression(fn)) {
-          return;
-        }
-
-        checkArrowFunctionWithJSX(fn);
-
-        checkFunctionsBlockStatement(fn);
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-max-depth.js

@@ -1,162 +0,0 @@
-/**
- * @fileoverview Validate JSX maximum depth
- * @author Chris<wfsr@foxmail.com>
- */
-
-'use strict';
-
-const has = require('object.hasown/polyfill')();
-const includes = require('array-includes');
-const variableUtil = require('../util/variable');
-const jsxUtil = require('../util/jsx');
-const docsUrl = require('../util/docsUrl');
-const reportC = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  wrongDepth: 'Expected the depth of nested jsx elements to be <= {{needed}}, but found {{found}}.',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce JSX maximum depth',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-max-depth'),
-    },
-
-    messages,
-
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          max: {
-            type: 'integer',
-            minimum: 0,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const DEFAULT_DEPTH = 2;
-
-    const option = context.options[0] || {};
-    const maxDepth = has(option, 'max') ? option.max : DEFAULT_DEPTH;
-
-    function isExpression(node) {
-      return node.type === 'JSXExpressionContainer';
-    }
-
-    function hasJSX(node) {
-      return jsxUtil.isJSX(node) || (isExpression(node) && jsxUtil.isJSX(node.expression));
-    }
-
-    function isLeaf(node) {
-      const children = node.children;
-
-      return !children || children.length === 0 || !children.some(hasJSX);
-    }
-
-    function getDepth(node) {
-      let count = 0;
-
-      while (jsxUtil.isJSX(node.parent) || isExpression(node.parent)) {
-        node = node.parent;
-        if (jsxUtil.isJSX(node)) {
-          count += 1;
-        }
-      }
-
-      return count;
-    }
-
-    function report(node, depth) {
-      reportC(context, messages.wrongDepth, 'wrongDepth', {
-        node,
-        data: {
-          found: depth,
-          needed: maxDepth,
-        },
-      });
-    }
-
-    function findJSXElementOrFragment(variables, name, previousReferences) {
-      function find(refs, prevRefs) {
-        for (let i = refs.length - 1; i >= 0; i--) {
-          if (has(refs[i], 'writeExpr')) {
-            const writeExpr = refs[i].writeExpr;
-
-            return (jsxUtil.isJSX(writeExpr)
-              && writeExpr)
-              || ((writeExpr && writeExpr.type === 'Identifier')
-              && findJSXElementOrFragment(variables, writeExpr.name, prevRefs));
-          }
-        }
-
-        return null;
-      }
-
-      const variable = variableUtil.getVariable(variables, name);
-      if (variable && variable.references) {
-        const containDuplicates = previousReferences.some((ref) => includes(variable.references, ref));
-
-        // Prevent getting stuck in circular references
-        if (containDuplicates) {
-          return false;
-        }
-
-        return find(variable.references, previousReferences.concat(variable.references));
-      }
-
-      return false;
-    }
-
-    function checkDescendant(baseDepth, children) {
-      baseDepth += 1;
-      (children || []).filter((node) => hasJSX(node)).forEach((node) => {
-        if (baseDepth > maxDepth) {
-          report(node, baseDepth);
-        } else if (!isLeaf(node)) {
-          checkDescendant(baseDepth, node.children);
-        }
-      });
-    }
-
-    function handleJSX(node) {
-      if (!isLeaf(node)) {
-        return;
-      }
-
-      const depth = getDepth(node);
-      if (depth > maxDepth) {
-        report(node, depth);
-      }
-    }
-
-    return {
-      JSXElement: handleJSX,
-      JSXFragment: handleJSX,
-
-      JSXExpressionContainer(node) {
-        if (node.expression.type !== 'Identifier') {
-          return;
-        }
-
-        const variables = variableUtil.variablesInScope(context);
-        const element = findJSXElementOrFragment(variables, node.expression.name, []);
-
-        if (element) {
-          const baseDepth = getDepth(node);
-          checkDescendant(baseDepth, element.children);
-        }
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-max-props-per-line.js

@@ -1,154 +0,0 @@
-/**
- * @fileoverview Limit maximum of props on a single line in JSX
- * @author Yannick Croissant
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-function getPropName(context, propNode) {
-  if (propNode.type === 'JSXSpreadAttribute') {
-    return context.getSourceCode().getText(propNode.argument);
-  }
-  return propNode.name.name;
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  newLine: 'Prop `{{prop}}` must be placed on a new line',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce maximum of props on a single line in JSX',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-max-props-per-line'),
-    },
-    fixable: 'code',
-
-    messages,
-
-    schema: [{
-      anyOf: [{
-        type: 'object',
-        properties: {
-          maximum: {
-            type: 'object',
-            properties: {
-              single: {
-                type: 'integer',
-                minimum: 1,
-              },
-              multi: {
-                type: 'integer',
-                minimum: 1,
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-      }, {
-        type: 'object',
-        properties: {
-          maximum: {
-            type: 'number',
-            minimum: 1,
-          },
-          when: {
-            type: 'string',
-            enum: ['always', 'multiline'],
-          },
-        },
-        additionalProperties: false,
-      }],
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const maximum = configuration.maximum || 1;
-
-    const maxConfig = typeof maximum === 'number'
-      ? {
-        single: configuration.when === 'multiline' ? Infinity : maximum,
-        multi: maximum,
-      }
-      : {
-        single: maximum.single || Infinity,
-        multi: maximum.multi || Infinity,
-      };
-
-    function generateFixFunction(line, max) {
-      const sourceCode = context.getSourceCode();
-      const output = [];
-      const front = line[0].range[0];
-      const back = line[line.length - 1].range[1];
-
-      for (let i = 0; i < line.length; i += max) {
-        const nodes = line.slice(i, i + max);
-        output.push(nodes.reduce((prev, curr) => {
-          if (prev === '') {
-            return sourceCode.getText(curr);
-          }
-          return `${prev} ${sourceCode.getText(curr)}`;
-        }, ''));
-      }
-
-      const code = output.join('\n');
-
-      return function fix(fixer) {
-        return fixer.replaceTextRange([front, back], code);
-      };
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        if (!node.attributes.length) {
-          return;
-        }
-
-        const isSingleLineTag = node.loc.start.line === node.loc.end.line;
-
-        if ((isSingleLineTag ? maxConfig.single : maxConfig.multi) === Infinity) {
-          return;
-        }
-
-        const firstProp = node.attributes[0];
-        const linePartitionedProps = [[firstProp]];
-
-        node.attributes.reduce((last, decl) => {
-          if (last.loc.end.line === decl.loc.start.line) {
-            linePartitionedProps[linePartitionedProps.length - 1].push(decl);
-          } else {
-            linePartitionedProps.push([decl]);
-          }
-          return decl;
-        });
-
-        linePartitionedProps.forEach((propsInLine) => {
-          const maxPropsCountPerLine = isSingleLineTag && propsInLine[0].loc.start.line === node.loc.start.line
-            ? maxConfig.single
-            : maxConfig.multi;
-
-          if (propsInLine.length > maxPropsCountPerLine) {
-            const name = getPropName(context, propsInLine[maxPropsCountPerLine]);
-            report(context, messages.newLine, 'newLine', {
-              node: propsInLine[maxPropsCountPerLine],
-              data: {
-                prop: name,
-              },
-              fix: generateFixFunction(propsInLine, maxPropsCountPerLine),
-            });
-          }
-        });
-      },
-    };
-  },
-};