create-packer 1.34.9 → 1.35.0

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

@@ -1,76 +0,0 @@
-/**
- * @fileoverview Enforce no duplicate props
- * @author Markus Ånöstam
- */
-
-'use strict';
-
-const has = require('object.hasown/polyfill')();
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  noDuplicateProps: 'No duplicate props allowed',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow duplicate properties in JSX',
-      category: 'Possible Errors',
-      recommended: true,
-      url: docsUrl('jsx-no-duplicate-props'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        ignoreCase: {
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const ignoreCase = configuration.ignoreCase || false;
-
-    return {
-      JSXOpeningElement(node) {
-        const props = {};
-
-        node.attributes.forEach((decl) => {
-          if (decl.type === 'JSXSpreadAttribute') {
-            return;
-          }
-
-          let name = decl.name.name;
-
-          if (typeof name !== 'string') {
-            return;
-          }
-
-          if (ignoreCase) {
-            name = name.toLowerCase();
-          }
-
-          if (has(props, name)) {
-            report(context, messages.noDuplicateProps, 'noDuplicateProps', {
-              node: decl,
-            });
-          } else {
-            props[name] = 1;
-          }
-        });
-      },
-    };
-  },
-};

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

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Prevent problematic leaked values from being rendered
- * @author Mario Beltrán
- */
-
-'use strict';
-
-const find = require('es-iterator-helpers/Iterator.prototype.find');
-const from = require('es-iterator-helpers/Iterator.from');
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-const testReactVersion = require('../util/version').testReactVersion;
-const isParenthesized = require('../util/ast').isParenthesized;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const messages = {
-  noPotentialLeakedRender: 'Potential leaked value that might cause unintentionally rendered values or rendering crashes',
-};
-
-const COERCE_STRATEGY = 'coerce';
-const TERNARY_STRATEGY = 'ternary';
-const DEFAULT_VALID_STRATEGIES = [TERNARY_STRATEGY, COERCE_STRATEGY];
-const COERCE_VALID_LEFT_SIDE_EXPRESSIONS = ['UnaryExpression', 'BinaryExpression', 'CallExpression'];
-const TERNARY_INVALID_ALTERNATE_VALUES = [undefined, null, false];
-
-function trimLeftNode(node) {
-  // Remove double unary expression (boolean coercion), so we avoid trimming valid negations
-  if (node.type === 'UnaryExpression' && node.argument.type === 'UnaryExpression') {
-    return trimLeftNode(node.argument.argument);
-  }
-
-  return node;
-}
-
-function getIsCoerceValidNestedLogicalExpression(node) {
-  if (node.type === 'LogicalExpression') {
-    return getIsCoerceValidNestedLogicalExpression(node.left) && getIsCoerceValidNestedLogicalExpression(node.right);
-  }
-
-  return COERCE_VALID_LEFT_SIDE_EXPRESSIONS.some((validExpression) => validExpression === node.type);
-}
-
-function extractExpressionBetweenLogicalAnds(node) {
-  if (node.type !== 'LogicalExpression') return [node];
-  if (node.operator !== '&&') return [node];
-  return [].concat(
-    extractExpressionBetweenLogicalAnds(node.left),
-    extractExpressionBetweenLogicalAnds(node.right)
-  );
-}
-
-function ruleFixer(context, fixStrategy, fixer, reportedNode, leftNode, rightNode) {
-  const sourceCode = context.getSourceCode();
-  const rightSideText = sourceCode.getText(rightNode);
-
-  if (fixStrategy === COERCE_STRATEGY) {
-    const expressions = extractExpressionBetweenLogicalAnds(leftNode);
-    const newText = expressions.map((node) => {
-      let nodeText = sourceCode.getText(node);
-      if (isParenthesized(context, node)) {
-        nodeText = `(${nodeText})`;
-      }
-      if (node.parent && node.parent.type === 'ConditionalExpression' && node.parent.consequent.value === false) {
-        return `${getIsCoerceValidNestedLogicalExpression(node) ? '' : '!'}${nodeText}`;
-      }
-      return `${getIsCoerceValidNestedLogicalExpression(node) ? '' : '!!'}${nodeText}`;
-    }).join(' && ');
-
-    if (rightNode.parent && rightNode.parent.type === 'ConditionalExpression' && rightNode.parent.consequent.value === false) {
-      const consequentVal = rightNode.parent.consequent.raw || rightNode.parent.consequent.name;
-      const alternateVal = rightNode.parent.alternate.raw || rightNode.parent.alternate.name;
-      if (rightNode.parent.test && rightNode.parent.test.type === 'LogicalExpression') {
-        return fixer.replaceText(reportedNode, `${newText} ? ${consequentVal} : ${alternateVal}`);
-      }
-      return fixer.replaceText(reportedNode, `${newText} && ${alternateVal}`);
-    }
-
-    if (rightNode.type === 'ConditionalExpression') {
-      return fixer.replaceText(reportedNode, `${newText} && (${rightSideText})`);
-    }
-    if (rightNode.type === 'Literal') {
-      return null;
-    }
-    return fixer.replaceText(reportedNode, `${newText} && ${rightSideText}`);
-  }
-
-  if (fixStrategy === TERNARY_STRATEGY) {
-    let leftSideText = sourceCode.getText(trimLeftNode(leftNode));
-    if (isParenthesized(context, leftNode)) {
-      leftSideText = `(${leftSideText})`;
-    }
-    return fixer.replaceText(reportedNode, `${leftSideText} ? ${rightSideText} : null`);
-  }
-
-  throw new TypeError('Invalid value for "validStrategies" option');
-}
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow problematic leaked values from being rendered',
-      category: 'Possible Errors',
-      recommended: false,
-      url: docsUrl('jsx-no-leaked-render'),
-    },
-
-    messages,
-
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          validStrategies: {
-            type: 'array',
-            items: {
-              enum: [
-                TERNARY_STRATEGY,
-                COERCE_STRATEGY,
-              ],
-            },
-            uniqueItems: true,
-            default: DEFAULT_VALID_STRATEGIES,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-
-  create(context) {
-    const config = context.options[0] || {};
-    const validStrategies = new Set(config.validStrategies || DEFAULT_VALID_STRATEGIES);
-    const fixStrategy = find(from(validStrategies), () => true);
-
-    return {
-      'JSXExpressionContainer > LogicalExpression[operator="&&"]'(node) {
-        const leftSide = node.left;
-
-        const isCoerceValidLeftSide = COERCE_VALID_LEFT_SIDE_EXPRESSIONS
-          .some((validExpression) => validExpression === leftSide.type);
-        if (validStrategies.has(COERCE_STRATEGY)) {
-          if (isCoerceValidLeftSide || getIsCoerceValidNestedLogicalExpression(leftSide)) {
-            return;
-          }
-        }
-
-        if (testReactVersion(context, '>= 18') && leftSide.type === 'Literal' && leftSide.value === '') {
-          return;
-        }
-        report(context, messages.noPotentialLeakedRender, 'noPotentialLeakedRender', {
-          node,
-          fix(fixer) {
-            return ruleFixer(context, fixStrategy, fixer, node, leftSide, node.right);
-          },
-        });
-      },
-
-      'JSXExpressionContainer > ConditionalExpression'(node) {
-        if (validStrategies.has(TERNARY_STRATEGY)) {
-          return;
-        }
-
-        const isValidTernaryAlternate = TERNARY_INVALID_ALTERNATE_VALUES.indexOf(node.alternate.value) === -1;
-        const isJSXElementAlternate = node.alternate.type === 'JSXElement';
-        if (isValidTernaryAlternate || isJSXElementAlternate) {
-          return;
-        }
-
-        report(context, messages.noPotentialLeakedRender, 'noPotentialLeakedRender', {
-          node,
-          fix(fixer) {
-            return ruleFixer(context, fixStrategy, fixer, node, node.test, node.consequent);
-          },
-        });
-      },
-    };
-  },
-};

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

@@ -1,195 +0,0 @@
-/**
- * @fileoverview Prevent using string literals in React component definition
- * @author Caleb Morris
- * @author David Buchan-Swanson
- */
-
-'use strict';
-
-const iterFrom = require('es-iterator-helpers/Iterator.from');
-const map = require('es-iterator-helpers/Iterator.prototype.map');
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-function trimIfString(val) {
-  return typeof val === 'string' ? val.trim() : val;
-}
-
-const messages = {
-  invalidPropValue: 'Invalid prop value: "{{text}}"',
-  noStringsInAttributes: 'Strings not allowed in attributes: "{{text}}"',
-  noStringsInJSX: 'Strings not allowed in JSX files: "{{text}}"',
-  literalNotInJSXExpression: 'Missing JSX expression container around literal string: "{{text}}"',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow usage of string literals in JSX',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-no-literals'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        noStrings: {
-          type: 'boolean',
-        },
-        allowedStrings: {
-          type: 'array',
-          uniqueItems: true,
-          items: {
-            type: 'string',
-          },
-        },
-        ignoreProps: {
-          type: 'boolean',
-        },
-        noAttributeStrings: {
-          type: 'boolean',
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const defaults = {
-      noStrings: false,
-      allowedStrings: [],
-      ignoreProps: false,
-      noAttributeStrings: false,
-    };
-    const config = Object.assign({}, defaults, context.options[0] || {});
-    config.allowedStrings = new Set(map(iterFrom(config.allowedStrings), trimIfString));
-
-    function defaultMessageId() {
-      const ancestorIsJSXElement = arguments.length >= 1 && arguments[0];
-      if (config.noAttributeStrings && !ancestorIsJSXElement) {
-        return 'noStringsInAttributes';
-      }
-      if (config.noStrings) {
-        return 'noStringsInJSX';
-      }
-      return 'literalNotInJSXExpression';
-    }
-
-    function getParentIgnoringBinaryExpressions(node) {
-      let current = node;
-      while (current.parent.type === 'BinaryExpression') {
-        current = current.parent;
-      }
-      return current.parent;
-    }
-
-    function getValidation(node) {
-      const values = [trimIfString(node.raw), trimIfString(node.value)];
-      if (values.some((value) => config.allowedStrings.has(value))) {
-        return false;
-      }
-
-      const parent = getParentIgnoringBinaryExpressions(node);
-
-      function isParentNodeStandard() {
-        if (!/^[\s]+$/.test(node.value) && typeof node.value === 'string' && parent.type.includes('JSX')) {
-          if (config.noAttributeStrings) {
-            return parent.type === 'JSXAttribute' || parent.type === 'JSXElement';
-          }
-          if (!config.noAttributeStrings) {
-            return parent.type !== 'JSXAttribute';
-          }
-        }
-
-        return false;
-      }
-
-      const standard = isParentNodeStandard();
-
-      if (config.noStrings) {
-        return standard;
-      }
-      return standard && parent.type !== 'JSXExpressionContainer';
-    }
-
-    function getParentAndGrandParentType(node) {
-      const parent = getParentIgnoringBinaryExpressions(node);
-      const parentType = parent.type;
-      const grandParentType = parent.parent.type;
-
-      return {
-        parent,
-        parentType,
-        grandParentType,
-        grandParent: parent.parent,
-      };
-    }
-
-    function hasJSXElementParentOrGrandParent(node) {
-      const parents = getParentAndGrandParentType(node);
-      const parentType = parents.parentType;
-      const grandParentType = parents.grandParentType;
-
-      return parentType === 'JSXFragment' || parentType === 'JSXElement' || grandParentType === 'JSXElement';
-    }
-
-    function reportLiteralNode(node, messageId) {
-      const ancestorIsJSXElement = hasJSXElementParentOrGrandParent(node);
-      messageId = messageId || defaultMessageId(ancestorIsJSXElement);
-
-      report(context, messages[messageId], messageId, {
-        node,
-        data: {
-          text: context.getSourceCode().getText(node).trim(),
-        },
-      });
-    }
-
-    // --------------------------------------------------------------------------
-    // Public
-    // --------------------------------------------------------------------------
-
-    return {
-      Literal(node) {
-        if (getValidation(node) && (hasJSXElementParentOrGrandParent(node) || !config.ignoreProps)) {
-          reportLiteralNode(node);
-        }
-      },
-
-      JSXAttribute(node) {
-        const isNodeValueString = node && node.value && node.value.type === 'Literal' && typeof node.value.value === 'string' && !config.allowedStrings.has(node.value.value);
-
-        if (config.noStrings && !config.ignoreProps && isNodeValueString) {
-          const messageId = 'invalidPropValue';
-          reportLiteralNode(node, messageId);
-        }
-      },
-
-      JSXText(node) {
-        if (getValidation(node)) {
-          reportLiteralNode(node);
-        }
-      },
-
-      TemplateLiteral(node) {
-        const parents = getParentAndGrandParentType(node);
-        const parentType = parents.parentType;
-        const grandParentType = parents.grandParentType;
-        const isParentJSXExpressionCont = parentType === 'JSXExpressionContainer';
-        const isParentJSXElement = parentType === 'JSXElement' || grandParentType === 'JSXElement';
-
-        if (isParentJSXExpressionCont && config.noStrings && (isParentJSXElement || !config.ignoreProps)) {
-          reportLiteralNode(node);
-        }
-      },
-    };
-  },
-};

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

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Prevent usage of `javascript:` URLs
- * @author Sergei Startsev
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-// https://github.com/facebook/react/blob/d0ebde77f6d1232cefc0da184d731943d78e86f2/packages/react-dom/src/shared/sanitizeURL.js#L30
-/* eslint-disable-next-line max-len, no-control-regex */
-const isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
-
-function hasJavaScriptProtocol(attr) {
-  return attr.value && attr.value.type === 'Literal'
-    && isJavaScriptProtocol.test(attr.value.value);
-}
-
-function shouldVerifyElement(node, config) {
-  const name = node.name && node.name.name;
-  return name === 'a' || config.find((i) => i.name === name);
-}
-
-function shouldVerifyProp(node, config) {
-  const name = node.name && node.name.name;
-  const parentName = node.parent.name && node.parent.name.name;
-
-  if (parentName === 'a' && name === 'href') {
-    return true;
-  }
-
-  const el = config.find((i) => i.name === parentName);
-  if (!el) {
-    return false;
-  }
-
-  const props = el.props || [];
-  return node.name && props.indexOf(name) !== -1;
-}
-
-const messages = {
-  noScriptURL: 'A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML, try using dangerouslySetInnerHTML instead.',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow usage of `javascript:` URLs',
-      category: 'Best Practices',
-      recommended: false,
-      url: docsUrl('jsx-no-script-url'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'array',
-      uniqueItems: true,
-      items: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-          },
-          props: {
-            type: 'array',
-            items: {
-              type: 'string',
-              uniqueItems: true,
-            },
-          },
-        },
-        required: ['name', 'props'],
-        additionalProperties: false,
-      },
-    }],
-  },
-
-  create(context) {
-    const config = context.options[0] || [];
-    return {
-      JSXAttribute(node) {
-        const parent = node.parent;
-        if (shouldVerifyElement(parent, config) && shouldVerifyProp(node, config) && hasJavaScriptProtocol(node)) {
-          report(context, messages.noScriptURL, 'noScriptURL', {
-            node,
-          });
-        }
-      },
-    };
-  },
-};