create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/no-access-state-in-setstate.js

@@ -0,0 +1,187 @@
+/**
+ * @fileoverview Prevent usage of this.state within setState
+ * @author Rolf Erik Lekang, Jørgen Aaberg
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const componentUtil = require('../util/componentUtil');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  useCallback: 'Use callback in setState when referencing the previous state.',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow when this.state is accessed within setState',
+      category: 'Possible Errors',
+      recommended: false,
+      url: docsUrl('no-access-state-in-setstate'),
+    },
+
+    messages,
+  },
+
+  create(context) {
+    function isSetStateCall(node) {
+      return node.type === 'CallExpression'
+        && node.callee.property
+        && node.callee.property.name === 'setState'
+        && node.callee.object.type === 'ThisExpression';
+    }
+
+    function isFirstArgumentInSetStateCall(current, node) {
+      if (!isSetStateCall(current)) {
+        return false;
+      }
+      while (node && node.parent !== current) {
+        node = node.parent;
+      }
+      return current.arguments[0] === node;
+    }
+
+    function isClassComponent() {
+      return !!(componentUtil.getParentES6Component(context) || componentUtil.getParentES5Component(context));
+    }
+
+    // The methods array contains all methods or functions that are using this.state
+    // or that are calling another method or function using this.state
+    const methods = [];
+    // The vars array contains all variables that contains this.state
+    const vars = [];
+    return {
+      CallExpression(node) {
+        if (!isClassComponent()) {
+          return;
+        }
+        // Appends all the methods that are calling another
+        // method containing this.state to the methods array
+        methods.forEach((method) => {
+          if (node.callee.name === method.methodName) {
+            let current = node.parent;
+            while (current.type !== 'Program') {
+              if (current.type === 'MethodDefinition') {
+                methods.push({
+                  methodName: current.key.name,
+                  node: method.node,
+                });
+                break;
+              }
+              current = current.parent;
+            }
+          }
+        });
+
+        // Finding all CallExpressions that is inside a setState
+        // to further check if they contains this.state
+        let current = node.parent;
+        while (current.type !== 'Program') {
+          if (isFirstArgumentInSetStateCall(current, node)) {
+            const methodName = node.callee.name;
+            methods.forEach((method) => {
+              if (method.methodName === methodName) {
+                report(context, messages.useCallback, 'useCallback', {
+                  node: method.node,
+                });
+              }
+            });
+
+            break;
+          }
+          current = current.parent;
+        }
+      },
+
+      MemberExpression(node) {
+        if (
+          node.property.name === 'state'
+          && node.object.type === 'ThisExpression'
+          && isClassComponent()
+        ) {
+          let current = node;
+          while (current.type !== 'Program') {
+            // Reporting if this.state is directly within this.setState
+            if (isFirstArgumentInSetStateCall(current, node)) {
+              report(context, messages.useCallback, 'useCallback', {
+                node,
+              });
+              break;
+            }
+
+            // Storing all functions and methods that contains this.state
+            if (current.type === 'MethodDefinition') {
+              methods.push({
+                methodName: current.key.name,
+                node,
+              });
+              break;
+            } else if (current.type === 'FunctionExpression' && current.parent.key) {
+              methods.push({
+                methodName: current.parent.key.name,
+                node,
+              });
+              break;
+            }
+
+            // Storing all variables containing this.state
+            if (current.type === 'VariableDeclarator') {
+              vars.push({
+                node,
+                scope: context.getScope(),
+                variableName: current.id.name,
+              });
+              break;
+            }
+
+            current = current.parent;
+          }
+        }
+      },
+
+      Identifier(node) {
+        // Checks if the identifier is a variable within an object
+        let current = node;
+        while (current.parent.type === 'BinaryExpression') {
+          current = current.parent;
+        }
+        if (
+          current.parent.value === current
+          || current.parent.object === current
+        ) {
+          while (current.type !== 'Program') {
+            if (isFirstArgumentInSetStateCall(current, node)) {
+              vars
+                .filter((v) => v.scope === context.getScope() && v.variableName === node.name)
+                .forEach((v) => {
+                  report(context, messages.useCallback, 'useCallback', {
+                    node: v.node,
+                  });
+                });
+            }
+            current = current.parent;
+          }
+        }
+      },
+
+      ObjectPattern(node) {
+        const isDerivedFromThis = node.parent.init && node.parent.init.type === 'ThisExpression';
+        node.properties.forEach((property) => {
+          if (property && property.key && property.key.name === 'state' && isDerivedFromThis) {
+            vars.push({
+              node: property.key,
+              scope: context.getScope(),
+              variableName: property.key.name,
+            });
+          }
+        });
+      },
+    };
+  },
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/no-adjacent-inline-elements.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Prevent adjacent inline elements not separated by whitespace.
+ * @author Sean Hayes
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const isCreateElement = require('../util/isCreateElement');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------------------
+
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elements
+const inlineNames = [
+  'a',
+  'b',
+  'big',
+  'i',
+  'small',
+  'tt',
+  'abbr',
+  'acronym',
+  'cite',
+  'code',
+  'dfn',
+  'em',
+  'kbd',
+  'strong',
+  'samp',
+  'time',
+  'var',
+  'bdo',
+  'br',
+  'img',
+  'map',
+  'object',
+  'q',
+  'script',
+  'span',
+  'sub',
+  'sup',
+  'button',
+  'input',
+  'label',
+  'select',
+  'textarea',
+];
+// Note: raw   will be transformed into \u00a0.
+const whitespaceRegex = /(?:^\s|\s$)/;
+
+function isInline(node) {
+  if (node.type === 'Literal') {
+    // Regular whitespace will be removed.
+    const value = node.value;
+    // To properly separate inline elements, each end of the literal will need
+    // whitespace.
+    return !whitespaceRegex.test(value);
+  }
+  if (node.type === 'JSXElement' && inlineNames.indexOf(node.openingElement.name.name) > -1) {
+    return true;
+  }
+  if (node.type === 'CallExpression' && inlineNames.indexOf(node.arguments[0].value) > -1) {
+    return true;
+  }
+  return false;
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  inlineElement: 'Child elements which render as inline HTML elements should be separated by a space or wrapped in block level elements.',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow adjacent inline elements not separated by whitespace.',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-adjacent-inline-elements'),
+    },
+    schema: [],
+
+    messages,
+  },
+  create(context) {
+    function validate(node, children) {
+      let currentIsInline = false;
+      let previousIsInline = false;
+      if (!children) {
+        return;
+      }
+      for (let i = 0; i < children.length; i++) {
+        currentIsInline = isInline(children[i]);
+        if (previousIsInline && currentIsInline) {
+          report(context, messages.inlineElement, 'inlineElement', {
+            node,
+          });
+          return;
+        }
+        previousIsInline = currentIsInline;
+      }
+    }
+    return {
+      JSXElement(node) {
+        validate(node, node.children);
+      },
+      CallExpression(node) {
+        if (!isCreateElement(node, context)) {
+          return;
+        }
+        if (node.arguments.length < 2 || !node.arguments[2]) {
+          return;
+        }
+        const children = node.arguments[2].elements;
+        validate(node, children);
+      },
+    };
+  },
+};

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/no-array-index-key.js

@@ -0,0 +1,288 @@
+/**
+ * @fileoverview Prevent usage of Array index in keys
+ * @author Joe Lencioni
+ */
+
+'use strict';
+
+const has = require('object.hasown/polyfill')();
+const astUtil = require('../util/ast');
+const docsUrl = require('../util/docsUrl');
+const pragma = require('../util/pragma');
+const report = require('../util/report');
+const variableUtil = require('../util/variable');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+function isCreateCloneElement(node, context) {
+  if (!node) {
+    return false;
+  }
+
+  if (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') {
+    return node.object
+      && node.object.name === pragma.getFromContext(context)
+      && ['createElement', 'cloneElement'].indexOf(node.property.name) !== -1;
+  }
+
+  if (node.type === 'Identifier') {
+    const variable = variableUtil.findVariableByName(context, node.name);
+    if (variable && variable.type === 'ImportSpecifier') {
+      return variable.parent.source.value === 'react';
+    }
+  }
+
+  return false;
+}
+
+const messages = {
+  noArrayIndex: 'Do not use Array index in keys',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of Array index in keys',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-array-index-key'),
+    },
+
+    messages,
+
+    schema: [],
+  },
+
+  create(context) {
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+    const indexParamNames = [];
+    const iteratorFunctionsToIndexParamPosition = {
+      every: 1,
+      filter: 1,
+      find: 1,
+      findIndex: 1,
+      flatMap: 1,
+      forEach: 1,
+      map: 1,
+      reduce: 2,
+      reduceRight: 2,
+      some: 1,
+    };
+
+    function isArrayIndex(node) {
+      return node.type === 'Identifier'
+        && indexParamNames.indexOf(node.name) !== -1;
+    }
+
+    function isUsingReactChildren(node) {
+      const callee = node.callee;
+      if (
+        !callee
+        || !callee.property
+        || !callee.object
+      ) {
+        return null;
+      }
+
+      const isReactChildMethod = ['map', 'forEach'].indexOf(callee.property.name) > -1;
+      if (!isReactChildMethod) {
+        return null;
+      }
+
+      const obj = callee.object;
+      if (obj && obj.name === 'Children') {
+        return true;
+      }
+      if (obj && obj.object && obj.object.name === pragma.getFromContext(context)) {
+        return true;
+      }
+
+      return false;
+    }
+
+    function getMapIndexParamName(node) {
+      const callee = node.callee;
+      if (callee.type !== 'MemberExpression' && callee.type !== 'OptionalMemberExpression') {
+        return null;
+      }
+      if (callee.property.type !== 'Identifier') {
+        return null;
+      }
+      if (!has(iteratorFunctionsToIndexParamPosition, callee.property.name)) {
+        return null;
+      }
+
+      const callbackArg = isUsingReactChildren(node)
+        ? node.arguments[1]
+        : node.arguments[0];
+
+      if (!callbackArg) {
+        return null;
+      }
+
+      if (!astUtil.isFunctionLikeExpression(callbackArg)) {
+        return null;
+      }
+
+      const params = callbackArg.params;
+
+      const indexParamPosition = iteratorFunctionsToIndexParamPosition[callee.property.name];
+      if (params.length < indexParamPosition + 1) {
+        return null;
+      }
+
+      return params[indexParamPosition].name;
+    }
+
+    function getIdentifiersFromBinaryExpression(side) {
+      if (side.type === 'Identifier') {
+        return side;
+      }
+
+      if (side.type === 'BinaryExpression') {
+        // recurse
+        const left = getIdentifiersFromBinaryExpression(side.left);
+        const right = getIdentifiersFromBinaryExpression(side.right);
+        return [].concat(left, right).filter(Boolean);
+      }
+
+      return null;
+    }
+
+    function checkPropValue(node) {
+      if (isArrayIndex(node)) {
+        // key={bar}
+        report(context, messages.noArrayIndex, 'noArrayIndex', {
+          node,
+        });
+        return;
+      }
+
+      if (node.type === 'TemplateLiteral') {
+        // key={`foo-${bar}`}
+        node.expressions.filter(isArrayIndex).forEach(() => {
+          report(context, messages.noArrayIndex, 'noArrayIndex', {
+            node,
+          });
+        });
+
+        return;
+      }
+
+      if (node.type === 'BinaryExpression') {
+        // key={'foo' + bar}
+        const identifiers = getIdentifiersFromBinaryExpression(node);
+
+        identifiers.filter(isArrayIndex).forEach(() => {
+          report(context, messages.noArrayIndex, 'noArrayIndex', {
+            node,
+          });
+        });
+
+        return;
+      }
+
+      if (node.type === 'CallExpression'
+          && node.callee
+          && node.callee.type === 'MemberExpression'
+          && node.callee.object
+          && isArrayIndex(node.callee.object)
+          && node.callee.property
+          && node.callee.property.type === 'Identifier'
+          && node.callee.property.name === 'toString'
+      ) {
+        // key={bar.toString()}
+        report(context, messages.noArrayIndex, 'noArrayIndex', {
+          node,
+        });
+        return;
+      }
+
+      if (node.type === 'CallExpression'
+          && node.callee
+          && node.callee.type === 'Identifier'
+          && node.callee.name === 'String'
+          && Array.isArray(node.arguments)
+          && node.arguments.length > 0
+          && isArrayIndex(node.arguments[0])
+      ) {
+        // key={String(bar)}
+        report(context, messages.noArrayIndex, 'noArrayIndex', {
+          node: node.arguments[0],
+        });
+      }
+    }
+
+    function popIndex(node) {
+      const mapIndexParamName = getMapIndexParamName(node);
+      if (!mapIndexParamName) {
+        return;
+      }
+
+      indexParamNames.pop();
+    }
+
+    return {
+      'CallExpression, OptionalCallExpression'(node) {
+        if (isCreateCloneElement(node.callee, context) && node.arguments.length > 1) {
+          // React.createElement
+          if (!indexParamNames.length) {
+            return;
+          }
+
+          const props = node.arguments[1];
+
+          if (props.type !== 'ObjectExpression') {
+            return;
+          }
+
+          props.properties.forEach((prop) => {
+            if (!prop.key || prop.key.name !== 'key') {
+              // { ...foo }
+              // { foo: bar }
+              return;
+            }
+
+            checkPropValue(prop.value);
+          });
+
+          return;
+        }
+
+        const mapIndexParamName = getMapIndexParamName(node);
+        if (!mapIndexParamName) {
+          return;
+        }
+
+        indexParamNames.push(mapIndexParamName);
+      },
+
+      JSXAttribute(node) {
+        if (node.name.name !== 'key') {
+          // foo={bar}
+          return;
+        }
+
+        if (!indexParamNames.length) {
+          // Not inside a call expression that we think has an index param.
+          return;
+        }
+
+        const value = node.value;
+        if (!value || value.type !== 'JSXExpressionContainer') {
+          // key='foo' or just simply 'key'
+          return;
+        }
+
+        checkPropValue(value.expression);
+      },
+
+      'CallExpression:exit': popIndex,
+      'OptionalCallExpression:exit': popIndex,
+    };
+  },
+};