create-packer 1.34.9 → 1.35.0

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

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Require or prevent a new line after jsx elements and expressions.
- * @author Johnny Zabala
- * @author Joseph Stiles
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  require: 'JSX element should start in a new line',
-  prevent: 'JSX element should not start in a new line',
-  allowMultilines: 'Multiline JSX elements should start in a new line',
-};
-
-function isMultilined(node) {
-  return node.loc.start.line !== node.loc.end.line;
-}
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Require or prevent a new line after jsx elements and expressions.',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-newline'),
-    },
-    fixable: 'code',
-
-    messages,
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          prevent: {
-            default: false,
-            type: 'boolean',
-          },
-          allowMultilines: {
-            default: false,
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-        if: {
-          properties: {
-            allowMultilines: {
-              const: true,
-            },
-          },
-        },
-        then: {
-          properties: {
-            prevent: {
-              const: true,
-            },
-          },
-          required: [
-            'prevent',
-          ],
-        },
-      },
-    ],
-  },
-  create(context) {
-    const jsxElementParents = new Set();
-    const sourceCode = context.getSourceCode();
-
-    function isBlockCommentInCurlyBraces(element) {
-      const elementRawValue = sourceCode.getText(element);
-      return /^\s*{\/\*/.test(elementRawValue);
-    }
-
-    function isNonBlockComment(element) {
-      return !isBlockCommentInCurlyBraces(element) && (element.type === 'JSXElement' || element.type === 'JSXExpressionContainer');
-    }
-
-    return {
-      'Program:exit'() {
-        jsxElementParents.forEach((parent) => {
-          parent.children.forEach((element, index, elements) => {
-            if (element.type === 'JSXElement' || element.type === 'JSXExpressionContainer') {
-              const configuration = context.options[0] || {};
-              const prevent = configuration.prevent || false;
-              const allowMultilines = configuration.allowMultilines || false;
-
-              const firstAdjacentSibling = elements[index + 1];
-              const secondAdjacentSibling = elements[index + 2];
-
-              const hasSibling = firstAdjacentSibling
-              && secondAdjacentSibling
-              && (firstAdjacentSibling.type === 'Literal' || firstAdjacentSibling.type === 'JSXText');
-
-              if (!hasSibling) return;
-
-              // Check adjacent sibling has the proper amount of newlines
-              const isWithoutNewLine = !/\n\s*\n/.test(firstAdjacentSibling.value);
-
-              if (isBlockCommentInCurlyBraces(element)) return;
-
-              if (
-                allowMultilines
-                && (
-                  isMultilined(element)
-                  || isMultilined(elements.slice(index + 2).find(isNonBlockComment))
-                )
-              ) {
-                if (!isWithoutNewLine) return;
-
-                const regex = /(\n)(?!.*\1)/g;
-                const replacement = '\n\n';
-                const messageId = 'allowMultilines';
-
-                report(context, messages[messageId], messageId, {
-                  node: secondAdjacentSibling,
-                  fix(fixer) {
-                    return fixer.replaceText(
-                      firstAdjacentSibling,
-                      sourceCode.getText(firstAdjacentSibling)
-                        .replace(regex, replacement)
-                    );
-                  },
-                });
-
-                return;
-              }
-
-              if (isWithoutNewLine === prevent) return;
-
-              const messageId = prevent
-                ? 'prevent'
-                : 'require';
-
-              const regex = prevent
-                ? /(\n\n)(?!.*\1)/g
-                : /(\n)(?!.*\1)/g;
-
-              const replacement = prevent
-                ? '\n'
-                : '\n\n';
-
-              report(context, messages[messageId], messageId, {
-                node: secondAdjacentSibling,
-                fix(fixer) {
-                  return fixer.replaceText(
-                    firstAdjacentSibling,
-                    // double or remove the last newline
-                    sourceCode.getText(firstAdjacentSibling)
-                      .replace(regex, replacement)
-                  );
-                },
-              });
-            }
-          });
-        });
-      },
-      ':matches(JSXElement, JSXFragment) > :matches(JSXElement, JSXExpressionContainer)': (node) => {
-        jsxElementParents.add(node.parent);
-      },
-    };
-  },
-};

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

@@ -1,208 +0,0 @@
-/**
- * @fileoverview Prevents usage of Function.prototype.bind and arrow functions
- *               in React component props.
- * @author Daniel Lo Nigro <dan.cx>
- * @author Jacky Ho
- */
-
-'use strict';
-
-const propName = require('jsx-ast-utils/propName');
-const docsUrl = require('../util/docsUrl');
-const jsxUtil = require('../util/jsx');
-const report = require('../util/report');
-
-// -----------------------------------------------------------------------------
-// Rule Definition
-// -----------------------------------------------------------------------------
-
-const messages = {
-  bindCall: 'JSX props should not use .bind()',
-  arrowFunc: 'JSX props should not use arrow functions',
-  bindExpression: 'JSX props should not use ::',
-  func: 'JSX props should not use functions',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow `.bind()` or arrow functions in JSX props',
-      category: 'Best Practices',
-      recommended: false,
-      url: docsUrl('jsx-no-bind'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        allowArrowFunctions: {
-          default: false,
-          type: 'boolean',
-        },
-        allowBind: {
-          default: false,
-          type: 'boolean',
-        },
-        allowFunctions: {
-          default: false,
-          type: 'boolean',
-        },
-        ignoreRefs: {
-          default: false,
-          type: 'boolean',
-        },
-        ignoreDOMComponents: {
-          default: false,
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-
-    // Keep track of all the variable names pointing to a bind call,
-    // bind expression or an arrow function in different block statements
-    const blockVariableNameSets = {};
-
-    /**
-     * @param {string | number} blockStart
-     */
-    function setBlockVariableNameSet(blockStart) {
-      blockVariableNameSets[blockStart] = {
-        arrowFunc: new Set(),
-        bindCall: new Set(),
-        bindExpression: new Set(),
-        func: new Set(),
-      };
-    }
-
-    function getNodeViolationType(node) {
-      const nodeType = node.type;
-      if (
-        !configuration.allowBind
-        && nodeType === 'CallExpression'
-        && node.callee.type === 'MemberExpression'
-        && node.callee.property.type === 'Identifier'
-        && node.callee.property.name === 'bind'
-      ) {
-        return 'bindCall';
-      }
-      if (nodeType === 'ConditionalExpression') {
-        return getNodeViolationType(node.test)
-               || getNodeViolationType(node.consequent)
-               || getNodeViolationType(node.alternate);
-      }
-      if (!configuration.allowArrowFunctions && nodeType === 'ArrowFunctionExpression') {
-        return 'arrowFunc';
-      }
-      if (
-        !configuration.allowFunctions
-        && (nodeType === 'FunctionExpression' || nodeType === 'FunctionDeclaration')
-      ) {
-        return 'func';
-      }
-      if (!configuration.allowBind && nodeType === 'BindExpression') {
-        return 'bindExpression';
-      }
-
-      return null;
-    }
-
-    /**
-     * @param {string | number} violationType
-     * @param {any} variableName
-     * @param {string | number} blockStart
-     */
-    function addVariableNameToSet(violationType, variableName, blockStart) {
-      blockVariableNameSets[blockStart][violationType].add(variableName);
-    }
-
-    function getBlockStatementAncestors(node) {
-      return context.getAncestors(node).reverse().filter(
-        (ancestor) => ancestor.type === 'BlockStatement'
-      );
-    }
-
-    function reportVariableViolation(node, name, blockStart) {
-      const blockSets = blockVariableNameSets[blockStart];
-      const violationTypes = Object.keys(blockSets);
-
-      return violationTypes.find((type) => {
-        if (blockSets[type].has(name)) {
-          report(context, messages[type], type, {
-            node,
-          });
-          return true;
-        }
-
-        return false;
-      });
-    }
-
-    function findVariableViolation(node, name) {
-      getBlockStatementAncestors(node).find(
-        (block) => reportVariableViolation(node, name, block.range[0])
-      );
-    }
-
-    return {
-      BlockStatement(node) {
-        setBlockVariableNameSet(node.range[0]);
-      },
-
-      FunctionDeclaration(node) {
-        const blockAncestors = getBlockStatementAncestors(node);
-        const variableViolationType = getNodeViolationType(node);
-
-        if (blockAncestors.length > 0 && variableViolationType) {
-          addVariableNameToSet(variableViolationType, node.id.name, blockAncestors[0].range[0]);
-        }
-      },
-
-      VariableDeclarator(node) {
-        if (!node.init) {
-          return;
-        }
-        const blockAncestors = getBlockStatementAncestors(node);
-        const variableViolationType = getNodeViolationType(node.init);
-
-        if (
-          blockAncestors.length > 0
-          && variableViolationType
-          && node.parent.kind === 'const' // only support const right now
-        ) {
-          addVariableNameToSet(
-            variableViolationType, node.id.name, blockAncestors[0].range[0]
-          );
-        }
-      },
-
-      JSXAttribute(node) {
-        const isRef = configuration.ignoreRefs && propName(node) === 'ref';
-        if (isRef || !node.value || !node.value.expression) {
-          return;
-        }
-        const isDOMComponent = jsxUtil.isDOMComponent(node.parent);
-        if (configuration.ignoreDOMComponents && isDOMComponent) {
-          return;
-        }
-        const valueNode = node.value.expression;
-        const valueNodeType = valueNode.type;
-        const nodeViolationType = getNodeViolationType(valueNode);
-
-        if (valueNodeType === 'Identifier') {
-          findVariableViolation(node, valueNode.name);
-        } else if (nodeViolationType) {
-          report(context, messages[nodeViolationType], nodeViolationType, {
-            node,
-          });
-        }
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-no-comment-textnodes.js

@@ -1,64 +0,0 @@
-/**
- * @fileoverview Comments inside children section of tag should be placed inside braces.
- * @author Ben Vinegar
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  putCommentInBraces: 'Comments inside children section of tag should be placed inside braces',
-};
-
-function checkText(node, context) {
-  // since babel-eslint has the wrong node.raw, we'll get the source text
-  const rawValue = context.getSourceCode().getText(node);
-  if (/^\s*\/(\/|\*)/m.test(rawValue)) {
-    // inside component, e.g. <div>literal</div>
-    if (
-      node.parent.type !== 'JSXAttribute'
-      && node.parent.type !== 'JSXExpressionContainer'
-      && node.parent.type.indexOf('JSX') !== -1
-    ) {
-      report(context, messages.putCommentInBraces, 'putCommentInBraces', {
-        node,
-      });
-    }
-  }
-}
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow comments from being inserted as text nodes',
-      category: 'Possible Errors',
-      recommended: true,
-      url: docsUrl('jsx-no-comment-textnodes'),
-    },
-
-    messages,
-
-    schema: [],
-  },
-
-  create(context) {
-    // --------------------------------------------------------------------------
-    // Public
-    // --------------------------------------------------------------------------
-
-    return {
-      Literal(node) {
-        checkText(node, context);
-      },
-      JSXText(node) {
-        checkText(node, context);
-      },
-    };
-  },
-};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-no-constructed-context-values.js

@@ -1,225 +0,0 @@
-/**
- * @fileoverview Prevents jsx context provider values from taking values that
- *               will cause needless rerenders.
- * @author Dylan Oshima
- */
-
-'use strict';
-
-const Components = require('../util/Components');
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-// Recursively checks if an element is a construction.
-// A construction is a variable that changes identity every render.
-function isConstruction(node, callScope) {
-  switch (node.type) {
-    case 'Literal':
-      if (node.regex != null) {
-        return { type: 'regular expression', node };
-      }
-      return null;
-    case 'Identifier': {
-      const variableScoping = callScope.set.get(node.name);
-
-      if (variableScoping == null || variableScoping.defs == null) {
-        // If it's not in scope, we don't care.
-        return null; // Handled
-      }
-
-      // Gets the last variable identity
-      const variableDefs = variableScoping.defs;
-      const def = variableDefs[variableDefs.length - 1];
-      if (def != null
-        && def.type !== 'Variable'
-        && def.type !== 'FunctionName'
-      ) {
-        // Parameter or an unusual pattern. Bail out.
-        return null; // Unhandled
-      }
-
-      if (def.node.type === 'FunctionDeclaration') {
-        return { type: 'function declaration', node: def.node, usage: node };
-      }
-
-      const init = def.node.init;
-      if (init == null) {
-        return null;
-      }
-
-      const initConstruction = isConstruction(init, callScope);
-      if (initConstruction == null) {
-        return null;
-      }
-
-      return {
-        type: initConstruction.type,
-        node: initConstruction.node,
-        usage: node,
-      };
-    }
-    case 'ObjectExpression':
-      // Any object initialized inline will create a new identity
-      return { type: 'object', node };
-    case 'ArrayExpression':
-      return { type: 'array', node };
-    case 'ArrowFunctionExpression':
-    case 'FunctionExpression':
-      // Functions that are initialized inline will have a new identity
-      return { type: 'function expression', node };
-    case 'ClassExpression':
-      return { type: 'class expression', node };
-    case 'NewExpression':
-      // `const a = new SomeClass();` is a construction
-      return { type: 'new expression', node };
-    case 'ConditionalExpression':
-      return (isConstruction(node.consequent, callScope)
-        || isConstruction(node.alternate, callScope)
-      );
-    case 'LogicalExpression':
-      return (isConstruction(node.left, callScope)
-        || isConstruction(node.right, callScope)
-      );
-    case 'MemberExpression': {
-      const objConstruction = isConstruction(node.object, callScope);
-      if (objConstruction == null) {
-        return null;
-      }
-      return {
-        type: objConstruction.type,
-        node: objConstruction.node,
-        usage: node.object,
-      };
-    }
-    case 'JSXFragment':
-      return { type: 'JSX fragment', node };
-    case 'JSXElement':
-      return { type: 'JSX element', node };
-    case 'AssignmentExpression': {
-      const construct = isConstruction(node.right, callScope);
-      if (construct != null) {
-        return {
-          type: 'assignment expression',
-          node: construct.node,
-          usage: node,
-        };
-      }
-      return null;
-    }
-    case 'TypeCastExpression':
-    case 'TSAsExpression':
-      return isConstruction(node.expression, callScope);
-    default:
-      return null;
-  }
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  withIdentifierMsg: "The '{{variableName}}' {{type}} (at line {{nodeLine}}) passed as the value prop to the Context provider (at line {{usageLine}}) changes every render. To fix this consider wrapping it in a useMemo hook.",
-  withIdentifierMsgFunc: "The '{{variableName}}' {{type}} (at line {{nodeLine}}) passed as the value prop to the Context provider (at line {{usageLine}}) changes every render. To fix this consider wrapping it in a useCallback hook.",
-  defaultMsg: 'The {{type}} passed as the value prop to the Context provider (at line {{nodeLine}}) changes every render. To fix this consider wrapping it in a useMemo hook.',
-  defaultMsgFunc: 'The {{type}} passed as the value prop to the Context provider (at line {{nodeLine}}) changes every render. To fix this consider wrapping it in a useCallback hook.',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallows JSX context provider values from taking values that will cause needless rerenders',
-      category: 'Best Practices',
-      recommended: false,
-      url: docsUrl('jsx-no-constructed-context-values'),
-    },
-    messages,
-    schema: {},
-  },
-
-  // eslint-disable-next-line arrow-body-style
-  create: Components.detect((context, components, utils) => {
-    return {
-      JSXOpeningElement(node) {
-        const openingElementName = node.name;
-        if (openingElementName.type !== 'JSXMemberExpression') {
-          // Has no member
-          return;
-        }
-
-        const isJsxContext = openingElementName.property.name === 'Provider';
-        if (!isJsxContext) {
-          // Member is not Provider
-          return;
-        }
-
-        // Contexts can take in more than just a value prop
-        // so we need to iterate through all of them
-        const jsxValueAttribute = node.attributes.find(
-          (attribute) => attribute.type === 'JSXAttribute' && attribute.name.name === 'value'
-        );
-
-        if (jsxValueAttribute == null) {
-          // No value prop was passed
-          return;
-        }
-
-        const valueNode = jsxValueAttribute.value;
-        if (!valueNode) {
-          // attribute is a boolean shorthand
-          return;
-        }
-        if (valueNode.type !== 'JSXExpressionContainer') {
-          // value could be a literal
-          return;
-        }
-
-        const valueExpression = valueNode.expression;
-        const invocationScope = context.getScope();
-
-        // Check if the value prop is a construction
-        const constructInfo = isConstruction(valueExpression, invocationScope);
-        if (constructInfo == null) {
-          return;
-        }
-
-        if (!utils.getParentComponent(node)) {
-          return;
-        }
-
-        // Report found error
-        const constructType = constructInfo.type;
-        const constructNode = constructInfo.node;
-        const constructUsage = constructInfo.usage;
-        const data = {
-          type: constructType, nodeLine: constructNode.loc.start.line,
-        };
-        let messageId = 'defaultMsg';
-
-        // Variable passed to value prop
-        if (constructUsage != null) {
-          messageId = 'withIdentifierMsg';
-          data.usageLine = constructUsage.loc.start.line;
-          data.variableName = constructUsage.name;
-        }
-
-        // Type of expression
-        if (
-          constructType === 'function expression'
-          || constructType === 'function declaration'
-        ) {
-          messageId += 'Func';
-        }
-
-        report(context, messages[messageId], messageId, {
-          node: constructNode,
-          data,
-        });
-      },
-    };
-  }),
-};