create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-first-prop-new-line.js

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Ensure proper position of the first property in JSX
+ * @author Joachim Seminck
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  propOnNewLine: 'Property should be placed on a new line',
+  propOnSameLine: 'Property should be placed on the same line as the component declaration',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce proper position of the first property in JSX',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('jsx-first-prop-new-line'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [{
+      enum: ['always', 'never', 'multiline', 'multiline-multiprop', 'multiprop'],
+    }],
+  },
+
+  create(context) {
+    const configuration = context.options[0] || 'multiline-multiprop';
+
+    function isMultilineJSX(jsxNode) {
+      return jsxNode.loc.start.line < jsxNode.loc.end.line;
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        if (
+          (configuration === 'multiline' && isMultilineJSX(node))
+          || (configuration === 'multiline-multiprop' && isMultilineJSX(node) && node.attributes.length > 1)
+          || (configuration === 'multiprop' && node.attributes.length > 1)
+          || (configuration === 'always')
+        ) {
+          node.attributes.some((decl) => {
+            if (decl.loc.start.line === node.loc.start.line) {
+              report(context, messages.propOnNewLine, 'propOnNewLine', {
+                node: decl,
+                fix(fixer) {
+                  return fixer.replaceTextRange([(node.typeParameters || node.name).range[1], decl.range[0]], '\n');
+                },
+              });
+            }
+            return true;
+          });
+        } else if (
+          (configuration === 'never' && node.attributes.length > 0)
+          || (configuration === 'multiprop' && isMultilineJSX(node) && node.attributes.length <= 1)
+        ) {
+          const firstNode = node.attributes[0];
+          if (node.loc.start.line < firstNode.loc.start.line) {
+            report(context, messages.propOnSameLine, 'propOnSameLine', {
+              node: firstNode,
+              fix(fixer) {
+                return fixer.replaceTextRange([node.name.range[1], firstNode.range[0]], ' ');
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview Enforce shorthand or standard form for React fragments.
+ * @author Alex Zherdev
+ */
+
+'use strict';
+
+const elementType = require('jsx-ast-utils/elementType');
+const pragmaUtil = require('../util/pragma');
+const variableUtil = require('../util/variable');
+const testReactVersion = require('../util/version').testReactVersion;
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+function replaceNode(source, node, text) {
+  return `${source.slice(0, node.range[0])}${text}${source.slice(node.range[1])}`;
+}
+
+const messages = {
+  fragmentsNotSupported: 'Fragments are only supported starting from React v16.2. '
+    + 'Please disable the `react/jsx-fragments` rule in `eslint` settings or upgrade your version of React.',
+  preferPragma: 'Prefer {{react}}.{{fragment}} over fragment shorthand',
+  preferFragment: 'Prefer fragment shorthand over {{react}}.{{fragment}}',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce shorthand or standard form for React fragments',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('jsx-fragments'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [{
+      enum: ['syntax', 'element'],
+    }],
+  },
+
+  create(context) {
+    const configuration = context.options[0] || 'syntax';
+    const reactPragma = pragmaUtil.getFromContext(context);
+    const fragmentPragma = pragmaUtil.getFragmentFromContext(context);
+    const openFragShort = '<>';
+    const closeFragShort = '</>';
+    const openFragLong = `<${reactPragma}.${fragmentPragma}>`;
+    const closeFragLong = `</${reactPragma}.${fragmentPragma}>`;
+
+    function reportOnReactVersion(node) {
+      if (!testReactVersion(context, '>= 16.2.0')) {
+        report(context, messages.fragmentsNotSupported, 'fragmentsNotSupported', {
+          node,
+        });
+        return true;
+      }
+
+      return false;
+    }
+
+    function getFixerToLong(jsxFragment) {
+      const sourceCode = context.getSourceCode();
+      if (!jsxFragment.closingFragment || !jsxFragment.openingFragment) {
+        // the old TS parser crashes here
+        // TODO: FIXME: can we fake these two descriptors?
+        return null;
+      }
+      return function fix(fixer) {
+        let source = sourceCode.getText();
+        source = replaceNode(source, jsxFragment.closingFragment, closeFragLong);
+        source = replaceNode(source, jsxFragment.openingFragment, openFragLong);
+        const lengthDiff = openFragLong.length - sourceCode.getText(jsxFragment.openingFragment).length
+          + closeFragLong.length - sourceCode.getText(jsxFragment.closingFragment).length;
+        const range = jsxFragment.range;
+        return fixer.replaceTextRange(range, source.slice(range[0], range[1] + lengthDiff));
+      };
+    }
+
+    function getFixerToShort(jsxElement) {
+      const sourceCode = context.getSourceCode();
+      return function fix(fixer) {
+        let source = sourceCode.getText();
+        let lengthDiff;
+        if (jsxElement.closingElement) {
+          source = replaceNode(source, jsxElement.closingElement, closeFragShort);
+          source = replaceNode(source, jsxElement.openingElement, openFragShort);
+          lengthDiff = sourceCode.getText(jsxElement.openingElement).length - openFragShort.length
+            + sourceCode.getText(jsxElement.closingElement).length - closeFragShort.length;
+        } else {
+          source = replaceNode(source, jsxElement.openingElement, `${openFragShort}${closeFragShort}`);
+          lengthDiff = sourceCode.getText(jsxElement.openingElement).length - openFragShort.length
+            - closeFragShort.length;
+        }
+
+        const range = jsxElement.range;
+        return fixer.replaceTextRange(range, source.slice(range[0], range[1] - lengthDiff));
+      };
+    }
+
+    function refersToReactFragment(name) {
+      const variableInit = variableUtil.findVariableByName(context, name);
+      if (!variableInit) {
+        return false;
+      }
+
+      // const { Fragment } = React;
+      if (variableInit.type === 'Identifier' && variableInit.name === reactPragma) {
+        return true;
+      }
+
+      // const Fragment = React.Fragment;
+      if (
+        variableInit.type === 'MemberExpression'
+        && variableInit.object.type === 'Identifier'
+        && variableInit.object.name === reactPragma
+        && variableInit.property.type === 'Identifier'
+        && variableInit.property.name === fragmentPragma
+      ) {
+        return true;
+      }
+
+      // const { Fragment } = require('react');
+      if (
+        variableInit.callee
+        && variableInit.callee.name === 'require'
+        && variableInit.arguments
+        && variableInit.arguments[0]
+        && variableInit.arguments[0].value === 'react'
+      ) {
+        return true;
+      }
+
+      return false;
+    }
+
+    const jsxElements = [];
+    const fragmentNames = new Set([`${reactPragma}.${fragmentPragma}`]);
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      JSXElement(node) {
+        jsxElements.push(node);
+      },
+
+      JSXFragment(node) {
+        if (reportOnReactVersion(node)) {
+          return;
+        }
+
+        if (configuration === 'element') {
+          report(context, messages.preferPragma, 'preferPragma', {
+            node,
+            data: {
+              react: reactPragma,
+              fragment: fragmentPragma,
+            },
+            fix: getFixerToLong(node),
+          });
+        }
+      },
+
+      ImportDeclaration(node) {
+        if (node.source && node.source.value === 'react') {
+          node.specifiers.forEach((spec) => {
+            if (spec.imported && spec.imported.name === fragmentPragma) {
+              if (spec.local) {
+                fragmentNames.add(spec.local.name);
+              }
+            }
+          });
+        }
+      },
+
+      'Program:exit'() {
+        jsxElements.forEach((node) => {
+          const openingEl = node.openingElement;
+          const elName = elementType(openingEl);
+
+          if (fragmentNames.has(elName) || refersToReactFragment(elName)) {
+            if (reportOnReactVersion(node)) {
+              return;
+            }
+
+            const attrs = openingEl.attributes;
+            if (configuration === 'syntax' && !(attrs && attrs.length > 0)) {
+              report(context, messages.preferFragment, 'preferFragment', {
+                node,
+                data: {
+                  react: reactPragma,
+                  fragment: fragmentPragma,
+                },
+                fix: getFixerToShort(node),
+              });
+            }
+          }
+        });
+      },
+    };
+  },
+};

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

@@ -0,0 +1,171 @@
+/**
+ * @fileoverview Enforce event handler naming conventions in JSX
+ * @author Jake Marsh
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  badHandlerName: 'Handler function for {{propKey}} prop key must be a camelCase name beginning with \'{{handlerPrefix}}\' only',
+  badPropKey: 'Prop key for {{propValue}} must begin with \'{{handlerPropPrefix}}\'',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce event handler naming conventions in JSX',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('jsx-handler-names'),
+    },
+
+    messages,
+
+    schema: [{
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            eventHandlerPrefix: { type: 'string' },
+            eventHandlerPropPrefix: { type: 'string' },
+            checkLocalVariables: { type: 'boolean' },
+            checkInlineFunction: { type: 'boolean' },
+          },
+          additionalProperties: false,
+        }, {
+          type: 'object',
+          properties: {
+            eventHandlerPrefix: { type: 'string' },
+            eventHandlerPropPrefix: {
+              type: 'boolean',
+              enum: [false],
+            },
+            checkLocalVariables: { type: 'boolean' },
+            checkInlineFunction: { type: 'boolean' },
+          },
+          additionalProperties: false,
+        }, {
+          type: 'object',
+          properties: {
+            eventHandlerPrefix: {
+              type: 'boolean',
+              enum: [false],
+            },
+            eventHandlerPropPrefix: { type: 'string' },
+            checkLocalVariables: { type: 'boolean' },
+            checkInlineFunction: { type: 'boolean' },
+          },
+          additionalProperties: false,
+        }, {
+          type: 'object',
+          properties: {
+            checkLocalVariables: { type: 'boolean' },
+          },
+          additionalProperties: false,
+        }, {
+          type: 'object',
+          properties: {
+            checkInlineFunction: { type: 'boolean' },
+          },
+          additionalProperties: false,
+        },
+      ],
+    }],
+  },
+
+  create(context) {
+    function isPrefixDisabled(prefix) {
+      return prefix === false;
+    }
+
+    function isInlineHandler(node) {
+      return node.value.expression.type === 'ArrowFunctionExpression';
+    }
+
+    const configuration = context.options[0] || {};
+
+    const eventHandlerPrefix = isPrefixDisabled(configuration.eventHandlerPrefix)
+      ? null
+      : configuration.eventHandlerPrefix || 'handle';
+    const eventHandlerPropPrefix = isPrefixDisabled(configuration.eventHandlerPropPrefix)
+      ? null
+      : configuration.eventHandlerPropPrefix || 'on';
+
+    const EVENT_HANDLER_REGEX = !eventHandlerPrefix
+      ? null
+      : new RegExp(`^((props\\.${eventHandlerPropPrefix || ''})|((.*\\.)?${eventHandlerPrefix}))[0-9]*[A-Z].*$`);
+    const PROP_EVENT_HANDLER_REGEX = !eventHandlerPropPrefix
+      ? null
+      : new RegExp(`^(${eventHandlerPropPrefix}[A-Z].*|ref)$`);
+
+    const checkLocal = !!configuration.checkLocalVariables;
+
+    const checkInlineFunction = !!configuration.checkInlineFunction;
+
+    return {
+      JSXAttribute(node) {
+        if (
+          !node.value
+          || !node.value.expression
+          || (!checkInlineFunction && isInlineHandler(node))
+          || (
+            !checkLocal
+            && (isInlineHandler(node)
+              ? !node.value.expression.body.callee || !node.value.expression.body.callee.object
+              : !node.value.expression.object
+            )
+          )
+        ) {
+          return;
+        }
+
+        const propKey = typeof node.name === 'object' ? node.name.name : node.name;
+        const expression = node.value.expression;
+        const propValue = context.getSourceCode()
+          .getText(checkInlineFunction && isInlineHandler(node) ? expression.body.callee : expression)
+          .replace(/\s*/g, '')
+          .replace(/^this\.|.*::/, '');
+
+        if (propKey === 'ref') {
+          return;
+        }
+
+        const propIsEventHandler = PROP_EVENT_HANDLER_REGEX && PROP_EVENT_HANDLER_REGEX.test(propKey);
+        const propFnIsNamedCorrectly = EVENT_HANDLER_REGEX && EVENT_HANDLER_REGEX.test(propValue);
+
+        if (
+          propIsEventHandler
+          && propFnIsNamedCorrectly !== null
+          && !propFnIsNamedCorrectly
+        ) {
+          report(context, messages.badHandlerName, 'badHandlerName', {
+            node,
+            data: {
+              propKey,
+              handlerPrefix: eventHandlerPrefix,
+            },
+          });
+        } else if (
+          propFnIsNamedCorrectly
+          && propIsEventHandler !== null
+          && !propIsEventHandler
+        ) {
+          report(context, messages.badPropKey, 'badPropKey', {
+            node,
+            data: {
+              propValue,
+              handlerPropPrefix: eventHandlerPropPrefix,
+            },
+          });
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,213 @@
+/**
+ * @fileoverview Validate props indentation in JSX
+ * @author Yannick Croissant
+
+ * This rule has been ported and modified from eslint and nodeca.
+ * @author Vitaly Puzrin
+ * @author Gyandeep Singh
+ * @copyright 2015 Vitaly Puzrin. All rights reserved.
+ * @copyright 2015 Gyandeep Singh. All rights reserved.
+ Copyright (C) 2014 by Vitaly Puzrin
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the 'Software'), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+'use strict';
+
+const astUtil = require('../util/ast');
+const docsUrl = require('../util/docsUrl');
+const reportC = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  wrongIndent: 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.',
+};
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce props indentation in JSX',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('jsx-indent-props'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [{
+      anyOf: [{
+        enum: ['tab', 'first'],
+      }, {
+        type: 'integer',
+      }, {
+        type: 'object',
+        properties: {
+          indentMode: {
+            anyOf: [{
+              enum: ['tab', 'first'],
+            }, {
+              type: 'integer',
+            }],
+          },
+          ignoreTernaryOperator: {
+            type: 'boolean',
+          },
+        },
+      }],
+    }],
+  },
+
+  create(context) {
+    const extraColumnStart = 0;
+    let indentType = 'space';
+    /** @type {number|'first'} */
+    let indentSize = 4;
+    const line = {
+      isUsingOperator: false,
+      currentOperator: false,
+    };
+    let ignoreTernaryOperator = false;
+
+    if (context.options.length) {
+      const isConfigObject = typeof context.options[0] === 'object';
+      const indentMode = isConfigObject
+        ? context.options[0].indentMode
+        : context.options[0];
+
+      if (indentMode === 'first') {
+        indentSize = 'first';
+        indentType = 'space';
+      } else if (indentMode === 'tab') {
+        indentSize = 1;
+        indentType = 'tab';
+      } else if (typeof indentMode === 'number') {
+        indentSize = indentMode;
+        indentType = 'space';
+      }
+
+      if (isConfigObject && context.options[0].ignoreTernaryOperator) {
+        ignoreTernaryOperator = true;
+      }
+    }
+
+    /**
+     * Reports a given indent violation and properly pluralizes the message
+     * @param {ASTNode} node Node violating the indent rule
+     * @param {Number} needed Expected indentation character count
+     * @param {Number} gotten Indentation character count in the actual node/code
+     */
+    function report(node, needed, gotten) {
+      const msgContext = {
+        needed,
+        type: indentType,
+        characters: needed === 1 ? 'character' : 'characters',
+        gotten,
+      };
+
+      reportC(context, messages.wrongIndent, 'wrongIndent', {
+        node,
+        data: msgContext,
+        fix(fixer) {
+          return fixer.replaceTextRange([node.range[0] - node.loc.start.column, node.range[0]],
+            Array(needed + 1).join(indentType === 'space' ? ' ' : '\t'));
+        },
+      });
+    }
+
+    /**
+     * Get node indent
+     * @param {ASTNode} node Node to examine
+     * @return {Number} Indent
+     */
+    function getNodeIndent(node) {
+      let src = context.getSourceCode().getText(node, node.loc.start.column + extraColumnStart);
+      const lines = src.split('\n');
+      src = lines[0];
+
+      let regExp;
+      if (indentType === 'space') {
+        regExp = /^[ ]+/;
+      } else {
+        regExp = /^[\t]+/;
+      }
+
+      const indent = regExp.exec(src);
+      const useOperator = /^([ ]|[\t])*[:]/.test(src) || /^([ ]|[\t])*[?]/.test(src);
+      const useBracket = /[<]/.test(src);
+
+      line.currentOperator = false;
+      if (useOperator) {
+        line.isUsingOperator = true;
+        line.currentOperator = true;
+      } else if (useBracket) {
+        line.isUsingOperator = false;
+      }
+
+      return indent ? indent[0].length : 0;
+    }
+
+    /**
+     * Check indent for nodes list
+     * @param {ASTNode[]} nodes list of node objects
+     * @param {Number} indent needed indent
+     */
+    function checkNodesIndent(nodes, indent) {
+      let nestedIndent = indent;
+      nodes.forEach((node) => {
+        const nodeIndent = getNodeIndent(node);
+        if (
+          line.isUsingOperator
+          && !line.currentOperator
+          && indentSize !== 'first'
+          && !ignoreTernaryOperator
+        ) {
+          nestedIndent += indentSize;
+          line.isUsingOperator = false;
+        }
+        if (
+          node.type !== 'ArrayExpression' && node.type !== 'ObjectExpression'
+          && nodeIndent !== nestedIndent && astUtil.isNodeFirstInLine(context, node)
+        ) {
+          report(node, nestedIndent, nodeIndent);
+        }
+      });
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        if (!node.attributes.length) {
+          return;
+        }
+        let propIndent;
+        if (indentSize === 'first') {
+          const firstPropNode = node.attributes[0];
+          propIndent = firstPropNode.loc.start.column;
+        } else {
+          const elementIndent = getNodeIndent(node);
+          propIndent = elementIndent + indentSize;
+        }
+        checkNodesIndent(node.attributes, propIndent);
+      },
+    };
+  },
+};