create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/function-component-definition.js

@@ -0,0 +1,284 @@
+/**
+ * @fileoverview Standardize the way function component get defined
+ * @author Stefan Wullems
+ */
+
+'use strict';
+
+const arrayIncludes = require('array-includes');
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const reportC = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+function buildFunction(template, parts) {
+  return Object.keys(parts).reduce(
+    (acc, key) => acc.replace(`{${key}}`, () => parts[key] || ''),
+    template
+  );
+}
+
+const NAMED_FUNCTION_TEMPLATES = {
+  'function-declaration': 'function {name}{typeParams}({params}){returnType} {body}',
+  'arrow-function': '{varType} {name}{typeAnnotation} = {typeParams}({params}){returnType} => {body}',
+  'function-expression': '{varType} {name}{typeAnnotation} = function{typeParams}({params}){returnType} {body}',
+};
+
+const UNNAMED_FUNCTION_TEMPLATES = {
+  'function-expression': 'function{typeParams}({params}){returnType} {body}',
+  'arrow-function': '{typeParams}({params}){returnType} => {body}',
+};
+
+function hasOneUnconstrainedTypeParam(node) {
+  if (node.typeParameters) {
+    return (
+      node.typeParameters.params.length === 1
+      && !node.typeParameters.params[0].constraint
+    );
+  }
+
+  return false;
+}
+
+function hasName(node) {
+  return (
+    node.type === 'FunctionDeclaration'
+    || node.parent.type === 'VariableDeclarator'
+  );
+}
+
+function getNodeText(prop, source) {
+  if (!prop) return null;
+  return source.slice(prop.range[0], prop.range[1]);
+}
+
+function getName(node) {
+  if (node.type === 'FunctionDeclaration') {
+    return node.id.name;
+  }
+
+  if (
+    node.type === 'ArrowFunctionExpression'
+    || node.type === 'FunctionExpression'
+  ) {
+    return hasName(node) && node.parent.id.name;
+  }
+}
+
+function getParams(node, source) {
+  if (node.params.length === 0) return null;
+  return source.slice(
+    node.params[0].range[0],
+    node.params[node.params.length - 1].range[1]
+  );
+}
+
+function getBody(node, source) {
+  const range = node.body.range;
+
+  if (node.body.type !== 'BlockStatement') {
+    return ['{', `  return ${source.slice(range[0], range[1])}`, '}'].join('\n');
+  }
+
+  return source.slice(range[0], range[1]);
+}
+
+function getTypeAnnotation(node, source) {
+  if (!hasName(node) || node.type === 'FunctionDeclaration') return;
+
+  if (
+    node.type === 'ArrowFunctionExpression'
+    || node.type === 'FunctionExpression'
+  ) {
+    return getNodeText(node.parent.id.typeAnnotation, source);
+  }
+}
+
+function isUnfixableBecauseOfExport(node) {
+  return (
+    node.type === 'FunctionDeclaration'
+    && node.parent
+    && node.parent.type === 'ExportDefaultDeclaration'
+  );
+}
+
+function isFunctionExpressionWithName(node) {
+  return node.type === 'FunctionExpression' && node.id && node.id.name;
+}
+
+const messages = {
+  'function-declaration': 'Function component is not a function declaration',
+  'function-expression': 'Function component is not a function expression',
+  'arrow-function': 'Function component is not an arrow function',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce a specific function type for function components',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('function-component-definition'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          namedComponents: {
+            anyOf: [
+              {
+                enum: [
+                  'function-declaration',
+                  'arrow-function',
+                  'function-expression',
+                ],
+              },
+              {
+                type: 'array',
+                items: {
+                  type: 'string',
+                  enum: [
+                    'function-declaration',
+                    'arrow-function',
+                    'function-expression',
+                  ],
+                },
+              },
+            ],
+          },
+          unnamedComponents: {
+            anyOf: [
+              { enum: ['arrow-function', 'function-expression'] },
+              {
+                type: 'array',
+                items: {
+                  type: 'string',
+                  enum: ['arrow-function', 'function-expression'],
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    let fileVarType = 'var';
+
+    const namedConfig = [].concat(
+      configuration.namedComponents || 'function-declaration'
+    );
+    const unnamedConfig = [].concat(
+      configuration.unnamedComponents || 'function-expression'
+    );
+
+    function getFixer(node, options) {
+      const sourceCode = context.getSourceCode();
+      const source = sourceCode.getText();
+
+      const typeAnnotation = getTypeAnnotation(node, source);
+
+      if (options.type === 'function-declaration' && typeAnnotation) {
+        return;
+      }
+      if (options.type === 'arrow-function' && hasOneUnconstrainedTypeParam(node)) {
+        return;
+      }
+      if (isUnfixableBecauseOfExport(node)) return;
+      if (isFunctionExpressionWithName(node)) return;
+      let varType = fileVarType;
+      if (
+        (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression')
+        && node.parent.type === 'VariableDeclarator'
+      ) {
+        varType = node.parent.parent.kind;
+      }
+
+      return (fixer) => fixer.replaceTextRange(
+        options.range,
+        buildFunction(options.template, {
+          typeAnnotation,
+          typeParams: getNodeText(node.typeParameters, source),
+          params: getParams(node, source),
+          returnType: getNodeText(node.returnType, source),
+          body: getBody(node, source),
+          name: getName(node),
+          varType,
+        })
+      );
+    }
+
+    function report(node, options) {
+      reportC(context, messages[options.messageId], options.messageId, {
+        node,
+        fix: getFixer(node, options.fixerOptions),
+      });
+    }
+
+    function validate(node, functionType) {
+      if (!components.get(node)) return;
+
+      if (node.parent && node.parent.type === 'Property') return;
+
+      if (hasName(node) && !arrayIncludes(namedConfig, functionType)) {
+        report(node, {
+          messageId: namedConfig[0],
+          fixerOptions: {
+            type: namedConfig[0],
+            template: NAMED_FUNCTION_TEMPLATES[namedConfig[0]],
+            range:
+              node.type === 'FunctionDeclaration'
+                ? node.range
+                : node.parent.parent.range,
+          },
+        });
+      }
+      if (!hasName(node) && !arrayIncludes(unnamedConfig, functionType)) {
+        report(node, {
+          messageId: unnamedConfig[0],
+          fixerOptions: {
+            type: unnamedConfig[0],
+            template: UNNAMED_FUNCTION_TEMPLATES[unnamedConfig[0]],
+            range: node.range,
+          },
+        });
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+    const validatePairs = [];
+    let hasES6OrJsx = false;
+    return {
+      FunctionDeclaration(node) {
+        validatePairs.push([node, 'function-declaration']);
+      },
+      ArrowFunctionExpression(node) {
+        validatePairs.push([node, 'arrow-function']);
+      },
+      FunctionExpression(node) {
+        validatePairs.push([node, 'function-expression']);
+      },
+      VariableDeclaration(node) {
+        hasES6OrJsx = hasES6OrJsx || node.kind === 'const' || node.kind === 'let';
+      },
+      'Program:exit'() {
+        if (hasES6OrJsx) fileVarType = 'const';
+        validatePairs.forEach((pair) => validate(pair[0], pair[1]));
+      },
+      'ImportDeclaration, ExportNamedDeclaration, ExportDefaultDeclaration, ExportAllDeclaration, ExportSpecifier, ExportDefaultSpecifier, JSXElement, TSExportAssignment, TSImportEqualsDeclaration'() {
+        hasES6OrJsx = true;
+      },
+    };
+  }),
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/hook-use-state.js

@@ -0,0 +1,203 @@
+/**
+ * @fileoverview Ensure symmetric naming of useState hook value and setter variables
+ * @author Duncan Beevers
+ */
+
+'use strict';
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+const getMessageData = require('../util/message');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+function isNodeDestructuring(node) {
+  return node && (node.type === 'ArrayPattern' || node.type === 'ObjectPattern');
+}
+
+const messages = {
+  useStateErrorMessage: 'useState call is not destructured into value + setter pair',
+  useStateErrorMessageOrAddOption: 'useState call is not destructured into value + setter pair (you can allow destructuring by enabling "allowDestructuredState" option)',
+  suggestPair: 'Destructure useState call into value + setter pair',
+  suggestMemo: 'Replace useState call with useMemo',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Ensure destructuring and symmetric naming of useState hook value and setter variables',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('hook-use-state'),
+    },
+    messages,
+    schema: [{
+      type: 'object',
+      properties: {
+        allowDestructuredState: {
+          default: false,
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+    type: 'suggestion',
+    hasSuggestions: true,
+  },
+
+  create: Components.detect((context, components, util) => {
+    const configuration = context.options[0] || {};
+    const allowDestructuredState = configuration.allowDestructuredState || false;
+
+    return {
+      CallExpression(node) {
+        const isImmediateReturn = node.parent
+          && node.parent.type === 'ReturnStatement';
+
+        if (isImmediateReturn || !util.isReactHookCall(node, ['useState'])) {
+          return;
+        }
+
+        const isDestructuringDeclarator = node.parent
+          && node.parent.type === 'VariableDeclarator'
+          && node.parent.id.type === 'ArrayPattern';
+
+        if (!isDestructuringDeclarator) {
+          report(
+            context,
+            messages.useStateErrorMessage,
+            'useStateErrorMessage',
+            {
+              node,
+              suggest: false,
+            }
+          );
+          return;
+        }
+
+        const variableNodes = node.parent.id.elements;
+        const valueVariable = variableNodes[0];
+        const setterVariable = variableNodes[1];
+        const isOnlyValueDestructuring = isNodeDestructuring(valueVariable) && !isNodeDestructuring(setterVariable);
+
+        if (allowDestructuredState && isOnlyValueDestructuring) {
+          return;
+        }
+
+        const valueVariableName = valueVariable
+          ? valueVariable.name
+          : undefined;
+
+        const setterVariableName = setterVariable
+          ? setterVariable.name
+          : undefined;
+
+        const caseCandidateMatch = valueVariableName ? valueVariableName.match(/(^[a-z]+)(.*)/) : undefined;
+        const upperCaseCandidatePrefix = caseCandidateMatch ? caseCandidateMatch[1] : undefined;
+        const caseCandidateSuffix = caseCandidateMatch ? caseCandidateMatch[2] : undefined;
+        const expectedSetterVariableNames = upperCaseCandidatePrefix ? [
+          `set${upperCaseCandidatePrefix.charAt(0).toUpperCase()}${upperCaseCandidatePrefix.slice(1)}${caseCandidateSuffix}`,
+          `set${upperCaseCandidatePrefix.toUpperCase()}${caseCandidateSuffix}`,
+        ] : [];
+
+        const isSymmetricGetterSetterPair = valueVariable
+          && setterVariable
+          && expectedSetterVariableNames.indexOf(setterVariableName) !== -1
+          && variableNodes.length === 2;
+
+        if (!isSymmetricGetterSetterPair) {
+          const suggestions = [
+            Object.assign(
+              getMessageData('suggestPair', messages.suggestPair),
+              {
+                fix(fixer) {
+                  if (expectedSetterVariableNames.length > 0) {
+                    return fixer.replaceTextRange(
+                      node.parent.id.range,
+                      `[${valueVariableName}, ${expectedSetterVariableNames[0]}]`
+                    );
+                  }
+                },
+              }
+            ),
+          ];
+
+          const defaultReactImports = components.getDefaultReactImports();
+          const defaultReactImportSpecifier = defaultReactImports
+            ? defaultReactImports[0]
+            : undefined;
+
+          const defaultReactImportName = defaultReactImportSpecifier
+            ? defaultReactImportSpecifier.local.name
+            : undefined;
+
+          const namedReactImports = components.getNamedReactImports();
+          const useStateReactImportSpecifier = namedReactImports
+            ? namedReactImports.find((specifier) => specifier.imported.name === 'useState')
+            : undefined;
+
+          const isSingleGetter = valueVariable && variableNodes.length === 1;
+          const isUseStateCalledWithSingleArgument = node.arguments.length === 1;
+          if (isSingleGetter && isUseStateCalledWithSingleArgument) {
+            const useMemoReactImportSpecifier = namedReactImports
+              && namedReactImports.find((specifier) => specifier.imported.name === 'useMemo');
+
+            let useMemoCode;
+            if (useMemoReactImportSpecifier) {
+              useMemoCode = useMemoReactImportSpecifier.local.name;
+            } else if (defaultReactImportName) {
+              useMemoCode = `${defaultReactImportName}.useMemo`;
+            } else {
+              useMemoCode = 'useMemo';
+            }
+
+            suggestions.unshift(Object.assign(
+              getMessageData('suggestMemo', messages.suggestMemo),
+              {
+                fix: (fixer) => [
+                  // Add useMemo import, if necessary
+                  useStateReactImportSpecifier
+                      && (!useMemoReactImportSpecifier || defaultReactImportName)
+                      && fixer.insertTextAfter(useStateReactImportSpecifier, ', useMemo'),
+                  // Convert single-value destructure to simple assignment
+                  fixer.replaceTextRange(node.parent.id.range, valueVariableName),
+                  // Convert useState call to useMemo + arrow function + dependency array
+                  fixer.replaceTextRange(
+                    node.range,
+                    `${useMemoCode}(() => ${context.getSourceCode().getText(node.arguments[0])}, [])`
+                  ),
+                ].filter(Boolean),
+              }
+            ));
+          }
+
+          if (isOnlyValueDestructuring) {
+            report(
+              context,
+              messages.useStateErrorMessageOrAddOption,
+              'useStateErrorMessageOrAddOption',
+              {
+                node: node.parent.id,
+                suggest: false,
+              }
+            );
+            return;
+          }
+
+          report(
+            context,
+            messages.useStateErrorMessage,
+            'useStateErrorMessage',
+            {
+              node: node.parent.id,
+              suggest: suggestions,
+            }
+          );
+        }
+      },
+    };
+  }),
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/iframe-missing-sandbox.js

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview TBD
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const isCreateElement = require('../util/isCreateElement');
+const report = require('../util/report');
+
+const messages = {
+  attributeMissing: 'An iframe element is missing a sandbox attribute',
+  invalidValue: 'An iframe element defines a sandbox attribute with invalid value "{{ value }}"',
+  invalidCombination: 'An iframe element defines a sandbox attribute with both allow-scripts and allow-same-origin which is invalid',
+};
+
+const ALLOWED_VALUES = [
+  // From https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-sandbox
+  '',
+  'allow-downloads-without-user-activation',
+  'allow-downloads',
+  'allow-forms',
+  'allow-modals',
+  'allow-orientation-lock',
+  'allow-pointer-lock',
+  'allow-popups',
+  'allow-popups-to-escape-sandbox',
+  'allow-presentation',
+  'allow-same-origin',
+  'allow-scripts',
+  'allow-storage-access-by-user-activation',
+  'allow-top-navigation',
+  'allow-top-navigation-by-user-activation',
+];
+
+function validateSandboxAttribute(context, node, attribute) {
+  if (typeof attribute !== 'string') {
+    // Only string literals are supported for now
+    return;
+  }
+  const values = attribute.split(' ');
+  let allowScripts = false;
+  let allowSameOrigin = false;
+  values.forEach((attributeValue) => {
+    const trimmedAttributeValue = attributeValue.trim();
+    if (ALLOWED_VALUES.indexOf(trimmedAttributeValue) === -1) {
+      report(context, messages.invalidValue, 'invalidValue', {
+        node,
+        data: {
+          value: trimmedAttributeValue,
+        },
+      });
+    }
+    if (trimmedAttributeValue === 'allow-scripts') {
+      allowScripts = true;
+    }
+    if (trimmedAttributeValue === 'allow-same-origin') {
+      allowSameOrigin = true;
+    }
+  });
+  if (allowScripts && allowSameOrigin) {
+    report(context, messages.invalidCombination, 'invalidCombination', {
+      node,
+    });
+  }
+}
+
+function checkAttributes(context, node) {
+  let sandboxAttributeFound = false;
+  node.attributes.forEach((attribute) => {
+    if (attribute.type === 'JSXAttribute'
+        && attribute.name
+        && attribute.name.type === 'JSXIdentifier'
+        && attribute.name.name === 'sandbox'
+    ) {
+      sandboxAttributeFound = true;
+      if (
+        attribute.value
+        && attribute.value.type === 'Literal'
+        && attribute.value.value
+      ) {
+        validateSandboxAttribute(context, node, attribute.value.value);
+      }
+    }
+  });
+  if (!sandboxAttributeFound) {
+    report(context, messages.attributeMissing, 'attributeMissing', {
+      node,
+    });
+  }
+}
+
+function checkProps(context, node) {
+  let sandboxAttributeFound = false;
+  if (node.arguments.length > 1) {
+    const props = node.arguments[1];
+    const sandboxProp = props.properties && props.properties.find((x) => x.type === 'Property' && x.key.name === 'sandbox');
+    if (sandboxProp) {
+      sandboxAttributeFound = true;
+      if (sandboxProp.value && sandboxProp.value.type === 'Literal' && sandboxProp.value.value) {
+        validateSandboxAttribute(context, node, sandboxProp.value.value);
+      }
+    }
+  }
+  if (!sandboxAttributeFound) {
+    report(context, messages.attributeMissing, 'attributeMissing', {
+      node,
+    });
+  }
+}
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce sandbox attribute on iframe elements',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('iframe-missing-sandbox'),
+    },
+
+    schema: [],
+
+    messages,
+  },
+
+  create(context) {
+    return {
+      'JSXOpeningElement[name.name="iframe"]'(node) {
+        checkAttributes(context, node);
+      },
+
+      CallExpression(node) {
+        if (isCreateElement(node, context) && node.arguments && node.arguments.length > 0) {
+          const tag = node.arguments[0];
+          if (tag.type === 'Literal' && tag.value === 'iframe') {
+            checkProps(context, node);
+          }
+        }
+      },
+    };
+  },
+};