create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint-plugin-react/lib/rules/jsx-one-expression-per-line.js

@@ -1,233 +0,0 @@
-/**
- * @fileoverview Limit to one expression per line in JSX
- * @author Mark Ivan Allen <Vydia.com>
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const jsxUtil = require('../util/jsx');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const optionDefaults = {
-  allow: 'none',
-};
-
-const messages = {
-  moveToNewLine: '`{{descriptor}}` must be placed on a new line',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Require one JSX element per line',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-one-expression-per-line'),
-    },
-    fixable: 'whitespace',
-
-    messages,
-
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allow: {
-            enum: ['none', 'literal', 'single-child'],
-          },
-        },
-        default: optionDefaults,
-        additionalProperties: false,
-      },
-    ],
-  },
-
-  create(context) {
-    const options = Object.assign({}, optionDefaults, context.options[0]);
-
-    function nodeKey(node) {
-      return `${node.loc.start.line},${node.loc.start.column}`;
-    }
-
-    function nodeDescriptor(n) {
-      return n.openingElement ? n.openingElement.name.name : context.getSourceCode().getText(n).replace(/\n/g, '');
-    }
-
-    function handleJSX(node) {
-      const children = node.children;
-
-      if (!children || !children.length) {
-        return;
-      }
-
-      const openingElement = node.openingElement || node.openingFragment;
-      const closingElement = node.closingElement || node.closingFragment;
-      const openingElementStartLine = openingElement.loc.start.line;
-      const openingElementEndLine = openingElement.loc.end.line;
-      const closingElementStartLine = closingElement.loc.start.line;
-      const closingElementEndLine = closingElement.loc.end.line;
-
-      if (children.length === 1) {
-        const child = children[0];
-        if (
-          openingElementStartLine === openingElementEndLine
-          && openingElementEndLine === closingElementStartLine
-          && closingElementStartLine === closingElementEndLine
-          && closingElementEndLine === child.loc.start.line
-          && child.loc.start.line === child.loc.end.line
-        ) {
-          if (
-            options.allow === 'single-child'
-            || (options.allow === 'literal' && (child.type === 'Literal' || child.type === 'JSXText'))
-          ) {
-            return;
-          }
-        }
-      }
-
-      const childrenGroupedByLine = {};
-      const fixDetailsByNode = {};
-
-      children.forEach((child) => {
-        let countNewLinesBeforeContent = 0;
-        let countNewLinesAfterContent = 0;
-
-        if (child.type === 'Literal' || child.type === 'JSXText') {
-          if (jsxUtil.isWhiteSpaces(child.raw)) {
-            return;
-          }
-
-          countNewLinesBeforeContent = (child.raw.match(/^\s*\n/g) || []).length;
-          countNewLinesAfterContent = (child.raw.match(/\n\s*$/g) || []).length;
-        }
-
-        const startLine = child.loc.start.line + countNewLinesBeforeContent;
-        const endLine = child.loc.end.line - countNewLinesAfterContent;
-
-        if (startLine === endLine) {
-          if (!childrenGroupedByLine[startLine]) {
-            childrenGroupedByLine[startLine] = [];
-          }
-          childrenGroupedByLine[startLine].push(child);
-        } else {
-          if (!childrenGroupedByLine[startLine]) {
-            childrenGroupedByLine[startLine] = [];
-          }
-          childrenGroupedByLine[startLine].push(child);
-          if (!childrenGroupedByLine[endLine]) {
-            childrenGroupedByLine[endLine] = [];
-          }
-          childrenGroupedByLine[endLine].push(child);
-        }
-      });
-
-      Object.keys(childrenGroupedByLine).forEach((_line) => {
-        const line = parseInt(_line, 10);
-        const firstIndex = 0;
-        const lastIndex = childrenGroupedByLine[line].length - 1;
-
-        childrenGroupedByLine[line].forEach((child, i) => {
-          let prevChild;
-          let nextChild;
-
-          if (i === firstIndex) {
-            if (line === openingElementEndLine) {
-              prevChild = openingElement;
-            }
-          } else {
-            prevChild = childrenGroupedByLine[line][i - 1];
-          }
-
-          if (i === lastIndex) {
-            if (line === closingElementStartLine) {
-              nextChild = closingElement;
-            }
-          } else {
-            // We don't need to append a trailing because the next child will prepend a leading.
-            // nextChild = childrenGroupedByLine[line][i + 1];
-          }
-
-          function spaceBetweenPrev() {
-            return ((prevChild.type === 'Literal' || prevChild.type === 'JSXText') && / $/.test(prevChild.raw))
-              || ((child.type === 'Literal' || child.type === 'JSXText') && /^ /.test(child.raw))
-              || context.getSourceCode().isSpaceBetweenTokens(prevChild, child);
-          }
-
-          function spaceBetweenNext() {
-            return ((nextChild.type === 'Literal' || nextChild.type === 'JSXText') && /^ /.test(nextChild.raw))
-              || ((child.type === 'Literal' || child.type === 'JSXText') && / $/.test(child.raw))
-              || context.getSourceCode().isSpaceBetweenTokens(child, nextChild);
-          }
-
-          if (!prevChild && !nextChild) {
-            return;
-          }
-
-          const source = context.getSourceCode().getText(child);
-          const leadingSpace = !!(prevChild && spaceBetweenPrev());
-          const trailingSpace = !!(nextChild && spaceBetweenNext());
-          const leadingNewLine = !!prevChild;
-          const trailingNewLine = !!nextChild;
-
-          const key = nodeKey(child);
-
-          if (!fixDetailsByNode[key]) {
-            fixDetailsByNode[key] = {
-              node: child,
-              source,
-              descriptor: nodeDescriptor(child),
-            };
-          }
-
-          if (leadingSpace) {
-            fixDetailsByNode[key].leadingSpace = true;
-          }
-          if (leadingNewLine) {
-            fixDetailsByNode[key].leadingNewLine = true;
-          }
-          if (trailingNewLine) {
-            fixDetailsByNode[key].trailingNewLine = true;
-          }
-          if (trailingSpace) {
-            fixDetailsByNode[key].trailingSpace = true;
-          }
-        });
-      });
-
-      Object.keys(fixDetailsByNode).forEach((key) => {
-        const details = fixDetailsByNode[key];
-
-        const nodeToReport = details.node;
-        const descriptor = details.descriptor;
-        const source = details.source.replace(/(^ +| +(?=\n)*$)/g, '');
-
-        const leadingSpaceString = details.leadingSpace ? '\n{\' \'}' : '';
-        const trailingSpaceString = details.trailingSpace ? '{\' \'}\n' : '';
-        const leadingNewLineString = details.leadingNewLine ? '\n' : '';
-        const trailingNewLineString = details.trailingNewLine ? '\n' : '';
-
-        const replaceText = `${leadingSpaceString}${leadingNewLineString}${source}${trailingNewLineString}${trailingSpaceString}`;
-
-        report(context, messages.moveToNewLine, 'moveToNewLine', {
-          node: nodeToReport,
-          data: {
-            descriptor,
-          },
-          fix(fixer) {
-            return fixer.replaceText(nodeToReport, replaceText);
-          },
-        });
-      });
-    }
-
-    return {
-      JSXElement: handleJSX,
-      JSXFragment: handleJSX,
-    };
-  },
-};

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

@@ -1,163 +0,0 @@
-/**
- * @fileoverview Enforce PascalCase for user-defined JSX components
- * @author Jake Marsh
- */
-
-'use strict';
-
-const elementType = require('jsx-ast-utils/elementType');
-const minimatch = require('minimatch');
-const docsUrl = require('../util/docsUrl');
-const jsxUtil = require('../util/jsx');
-const report = require('../util/report');
-
-function testDigit(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 48 && charCode <= 57;
-}
-
-function testUpperCase(char) {
-  const upperCase = char.toUpperCase();
-  return char === upperCase && upperCase !== char.toLowerCase();
-}
-
-function testLowerCase(char) {
-  const lowerCase = char.toLowerCase();
-  return char === lowerCase && lowerCase !== char.toUpperCase();
-}
-
-function testPascalCase(name) {
-  if (!testUpperCase(name.charAt(0))) {
-    return false;
-  }
-  const anyNonAlphaNumeric = Array.prototype.some.call(
-    name.slice(1),
-    (char) => char.toLowerCase() === char.toUpperCase() && !testDigit(char)
-  );
-  if (anyNonAlphaNumeric) {
-    return false;
-  }
-  return Array.prototype.some.call(
-    name.slice(1),
-    (char) => testLowerCase(char) || testDigit(char)
-  );
-}
-
-function testAllCaps(name) {
-  const firstChar = name.charAt(0);
-  if (!(testUpperCase(firstChar) || testDigit(firstChar))) {
-    return false;
-  }
-  for (let i = 1; i < name.length - 1; i += 1) {
-    const char = name.charAt(i);
-    if (!(testUpperCase(char) || testDigit(char) || char === '_')) {
-      return false;
-    }
-  }
-  const lastChar = name.charAt(name.length - 1);
-  if (!(testUpperCase(lastChar) || testDigit(lastChar))) {
-    return false;
-  }
-  return true;
-}
-
-function ignoreCheck(ignore, name) {
-  return ignore.some(
-    (entry) => name === entry || minimatch(name, entry, { noglobstar: true })
-  );
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  usePascalCase: 'Imported JSX component {{name}} must be in PascalCase',
-  usePascalOrSnakeCase: 'Imported JSX component {{name}} must be in PascalCase or SCREAMING_SNAKE_CASE',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Enforce PascalCase for user-defined JSX components',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-pascal-case'),
-    },
-
-    messages,
-
-    schema: [{
-      type: 'object',
-      properties: {
-        allowAllCaps: {
-          type: 'boolean',
-        },
-        allowLeadingUnderscore: {
-          type: 'boolean',
-        },
-        allowNamespace: {
-          type: 'boolean',
-        },
-        ignore: {
-          items: [
-            {
-              type: 'string',
-            },
-          ],
-          minItems: 0,
-          type: 'array',
-          uniqueItems: true,
-        },
-      },
-      additionalProperties: false,
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const allowAllCaps = configuration.allowAllCaps || false;
-    const allowLeadingUnderscore = configuration.allowLeadingUnderscore || false;
-    const allowNamespace = configuration.allowNamespace || false;
-    const ignore = configuration.ignore || [];
-
-    return {
-      JSXOpeningElement(node) {
-        const isCompatTag = jsxUtil.isDOMComponent(node);
-        if (isCompatTag) return undefined;
-
-        const name = elementType(node);
-        let checkNames = [name];
-        let index = 0;
-
-        if (name.lastIndexOf(':') > -1) {
-          checkNames = name.split(':');
-        } else if (name.lastIndexOf('.') > -1) {
-          checkNames = name.split('.');
-        }
-
-        do {
-          const splitName = checkNames[index];
-          if (splitName.length === 1) return undefined;
-          const isIgnored = ignoreCheck(ignore, splitName);
-
-          const checkName = allowLeadingUnderscore && splitName.startsWith('_') ? splitName.slice(1) : splitName;
-          const isPascalCase = testPascalCase(checkName);
-          const isAllowedAllCaps = allowAllCaps && testAllCaps(checkName);
-
-          if (!isPascalCase && !isAllowedAllCaps && !isIgnored) {
-            const messageId = allowAllCaps ? 'usePascalOrSnakeCase' : 'usePascalCase';
-            report(context, messages[messageId], messageId, {
-              node,
-              data: {
-                name: splitName,
-              },
-            });
-            break;
-          }
-          index += 1;
-        } while (index < checkNames.length && !allowNamespace);
-      },
-    };
-  },
-};

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

@@ -1,134 +0,0 @@
-/**
- * @fileoverview Disallow multiple spaces between inline JSX props
- * @author Adrian Moennich
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  noLineGap: 'Expected no line gap between “{{prop1}}” and “{{prop2}}”',
-  onlyOneSpace: 'Expected only one space between “{{prop1}}” and “{{prop2}}”',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow multiple spaces between inline JSX props',
-      category: 'Stylistic Issues',
-      recommended: false,
-      url: docsUrl('jsx-props-no-multi-spaces'),
-    },
-    fixable: 'code',
-
-    messages,
-
-    schema: [],
-  },
-
-  create(context) {
-    const sourceCode = context.getSourceCode();
-
-    function getPropName(propNode) {
-      switch (propNode.type) {
-        case 'JSXSpreadAttribute':
-          return context.getSourceCode().getText(propNode.argument);
-        case 'JSXIdentifier':
-          return propNode.name;
-        case 'JSXMemberExpression':
-          return `${getPropName(propNode.object)}.${propNode.property.name}`;
-        default:
-          return propNode.name
-            ? propNode.name.name
-            : `${context.getSourceCode().getText(propNode.object)}.${propNode.property.name}`; // needed for typescript-eslint parser
-      }
-    }
-
-    // First and second must be adjacent nodes
-    function hasEmptyLines(first, second) {
-      const comments = sourceCode.getCommentsBefore ? sourceCode.getCommentsBefore(second) : [];
-      const nodes = [].concat(first, comments, second);
-
-      for (let i = 1; i < nodes.length; i += 1) {
-        const prev = nodes[i - 1];
-        const curr = nodes[i];
-        if (curr.loc.start.line - prev.loc.end.line >= 2) {
-          return true;
-        }
-      }
-
-      return false;
-    }
-
-    function checkSpacing(prev, node) {
-      if (hasEmptyLines(prev, node)) {
-        report(context, messages.noLineGap, 'noLineGap', {
-          node,
-          data: {
-            prop1: getPropName(prev),
-            prop2: getPropName(node),
-          },
-        });
-      }
-
-      if (prev.loc.end.line !== node.loc.end.line) {
-        return;
-      }
-
-      const between = context.getSourceCode().text.slice(prev.range[1], node.range[0]);
-
-      if (between !== ' ') {
-        report(context, messages.onlyOneSpace, 'onlyOneSpace', {
-          node,
-          data: {
-            prop1: getPropName(prev),
-            prop2: getPropName(node),
-          },
-          fix(fixer) {
-            return fixer.replaceTextRange([prev.range[1], node.range[0]], ' ');
-          },
-        });
-      }
-    }
-
-    function containsGenericType(node) {
-      const containsTypeParams = typeof node.typeParameters !== 'undefined';
-      return containsTypeParams && node.typeParameters.type === 'TSTypeParameterInstantiation';
-    }
-
-    function getGenericNode(node) {
-      const name = node.name;
-      if (containsGenericType(node)) {
-        const type = node.typeParameters;
-
-        return Object.assign(
-          {},
-          node,
-          {
-            range: [
-              name.range[0],
-              type.range[1],
-            ],
-          }
-        );
-      }
-
-      return name;
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        node.attributes.reduce((prev, prop) => {
-          checkSpacing(prev, prop);
-          return prop;
-        }, getGenericNode(node));
-      },
-    };
-  },
-};

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

@@ -1,141 +0,0 @@
-/**
- * @fileoverview Prevent JSX prop spreading
- * @author Ashish Gambhir
- */
-
-'use strict';
-
-const docsUrl = require('../util/docsUrl');
-const report = require('../util/report');
-
-// ------------------------------------------------------------------------------
-// Constants
-// ------------------------------------------------------------------------------
-
-const OPTIONS = { ignore: 'ignore', enforce: 'enforce' };
-const DEFAULTS = {
-  html: OPTIONS.enforce,
-  custom: OPTIONS.enforce,
-  explicitSpread: OPTIONS.enforce,
-  exceptions: [],
-};
-
-const isException = (tag, allExceptions) => allExceptions.indexOf(tag) !== -1;
-const isProperty = (property) => property.type === 'Property';
-const getTagNameFromMemberExpression = (node) => {
-  if (node.property.parent) {
-    return `${node.property.parent.object.name}.${node.property.name}`;
-  }
-  // for eslint 3
-  return `${node.object.name}.${node.property.name}`;
-};
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-const messages = {
-  noSpreading: 'Prop spreading is forbidden',
-};
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Disallow JSX prop spreading',
-      category: 'Best Practices',
-      recommended: false,
-      url: docsUrl('jsx-props-no-spreading'),
-    },
-
-    messages,
-
-    schema: [{
-      allOf: [{
-        type: 'object',
-        properties: {
-          html: {
-            enum: [OPTIONS.enforce, OPTIONS.ignore],
-          },
-          custom: {
-            enum: [OPTIONS.enforce, OPTIONS.ignore],
-          },
-          exceptions: {
-            type: 'array',
-            items: {
-              type: 'string',
-              uniqueItems: true,
-            },
-          },
-        },
-      }, {
-        not: {
-          type: 'object',
-          required: ['html', 'custom'],
-          properties: {
-            html: {
-              enum: [OPTIONS.ignore],
-            },
-            custom: {
-              enum: [OPTIONS.ignore],
-            },
-            exceptions: {
-              type: 'array',
-              minItems: 0,
-              maxItems: 0,
-            },
-          },
-        },
-      }],
-    }],
-  },
-
-  create(context) {
-    const configuration = context.options[0] || {};
-    const ignoreHtmlTags = (configuration.html || DEFAULTS.html) === OPTIONS.ignore;
-    const ignoreCustomTags = (configuration.custom || DEFAULTS.custom) === OPTIONS.ignore;
-    const ignoreExplicitSpread = (configuration.explicitSpread || DEFAULTS.explicitSpread) === OPTIONS.ignore;
-    const exceptions = configuration.exceptions || DEFAULTS.exceptions;
-    return {
-      JSXSpreadAttribute(node) {
-        const jsxOpeningElement = node.parent.name;
-        const type = jsxOpeningElement.type;
-
-        let tagName;
-        if (type === 'JSXIdentifier') {
-          tagName = jsxOpeningElement.name;
-        } else if (type === 'JSXMemberExpression') {
-          tagName = getTagNameFromMemberExpression(jsxOpeningElement);
-        } else {
-          tagName = undefined;
-        }
-
-        const isHTMLTag = tagName && tagName[0] !== tagName[0].toUpperCase();
-        const isCustomTag = tagName && (tagName[0] === tagName[0].toUpperCase() || tagName.includes('.'));
-        if (
-          isHTMLTag
-          && ((ignoreHtmlTags && !isException(tagName, exceptions))
-          || (!ignoreHtmlTags && isException(tagName, exceptions)))
-        ) {
-          return;
-        }
-        if (
-          isCustomTag
-          && ((ignoreCustomTags && !isException(tagName, exceptions))
-          || (!ignoreCustomTags && isException(tagName, exceptions)))
-        ) {
-          return;
-        }
-        if (
-          ignoreExplicitSpread
-          && node.argument.type === 'ObjectExpression'
-          && node.argument.properties.every(isProperty)
-        ) {
-          return;
-        }
-        report(context, messages.noSpreading, 'noSpreading', {
-          node,
-        });
-      },
-    };
-  },
-};