create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/extensions.js

@@ -0,0 +1,193 @@
+'use strict';var _path = require('path');var _path2 = _interopRequireDefault(_path);
+
+var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
+var _importType = require('../core/importType');
+var _moduleVisitor = require('eslint-module-utils/moduleVisitor');var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor);
+var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var enumValues = { 'enum': ['always', 'ignorePackages', 'never'] };
+var patternProperties = {
+  type: 'object',
+  patternProperties: { '.*': enumValues } };
+
+var properties = {
+  type: 'object',
+  properties: {
+    pattern: patternProperties,
+    ignorePackages: { type: 'boolean' } } };
+
+
+
+function buildProperties(context) {
+
+  var result = {
+    defaultConfig: 'never',
+    pattern: {},
+    ignorePackages: false };
+
+
+  context.options.forEach(function (obj) {
+
+    // If this is a string, set defaultConfig to its value
+    if (typeof obj === 'string') {
+      result.defaultConfig = obj;
+      return;
+    }
+
+    // If this is not the new structure, transfer all props to result.pattern
+    if (obj.pattern === undefined && obj.ignorePackages === undefined) {
+      Object.assign(result.pattern, obj);
+      return;
+    }
+
+    // If pattern is provided, transfer all props
+    if (obj.pattern !== undefined) {
+      Object.assign(result.pattern, obj.pattern);
+    }
+
+    // If ignorePackages is provided, transfer it to result
+    if (obj.ignorePackages !== undefined) {
+      result.ignorePackages = obj.ignorePackages;
+    }
+  });
+
+  if (result.defaultConfig === 'ignorePackages') {
+    result.defaultConfig = 'always';
+    result.ignorePackages = true;
+  }
+
+  return result;
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      category: 'Style guide',
+      description: 'Ensure consistent use of file extension within the import path.',
+      url: (0, _docsUrl2['default'])('extensions') },
+
+
+    schema: {
+      anyOf: [
+      {
+        type: 'array',
+        items: [enumValues],
+        additionalItems: false },
+
+      {
+        type: 'array',
+        items: [
+        enumValues,
+        properties],
+
+        additionalItems: false },
+
+      {
+        type: 'array',
+        items: [properties],
+        additionalItems: false },
+
+      {
+        type: 'array',
+        items: [patternProperties],
+        additionalItems: false },
+
+      {
+        type: 'array',
+        items: [
+        enumValues,
+        patternProperties],
+
+        additionalItems: false }] } },
+
+
+
+
+
+  create: function () {function create(context) {
+
+      var props = buildProperties(context);
+
+      function getModifier(extension) {
+        return props.pattern[extension] || props.defaultConfig;
+      }
+
+      function isUseOfExtensionRequired(extension, isPackage) {
+        return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackage);
+      }
+
+      function isUseOfExtensionForbidden(extension) {
+        return getModifier(extension) === 'never';
+      }
+
+      function isResolvableWithoutExtension(file) {
+        var extension = _path2['default'].extname(file);
+        var fileWithoutExtension = file.slice(0, -extension.length);
+        var resolvedFileWithoutExtension = (0, _resolve2['default'])(fileWithoutExtension, context);
+
+        return resolvedFileWithoutExtension === (0, _resolve2['default'])(file, context);
+      }
+
+      function isExternalRootModule(file) {
+        if (file === '.' || file === '..') {return false;}
+        var slashCount = file.split('/').length - 1;
+
+        if (slashCount === 0) {return true;}
+        if ((0, _importType.isScoped)(file) && slashCount <= 1) {return true;}
+        return false;
+      }
+
+      function checkFileExtension(source, node) {
+        // bail if the declaration doesn't have a source, e.g. "export { foo };", or if it's only partially typed like in an editor
+        if (!source || !source.value) {return;}
+
+        var importPathWithQueryString = source.value;
+
+        // don't enforce anything on builtins
+        if ((0, _importType.isBuiltIn)(importPathWithQueryString, context.settings)) {return;}
+
+        var importPath = importPathWithQueryString.replace(/\?(.*)$/, '');
+
+        // don't enforce in root external packages as they may have names with `.js`.
+        // Like `import Decimal from decimal.js`)
+        if (isExternalRootModule(importPath)) {return;}
+
+        var resolvedPath = (0, _resolve2['default'])(importPath, context);
+
+        // get extension from resolved path, if possible.
+        // for unresolved, use source value.
+        var extension = _path2['default'].extname(resolvedPath || importPath).substring(1);
+
+        // determine if this is a module
+        var isPackage = (0, _importType.isExternalModule)(
+        importPath,
+        (0, _resolve2['default'])(importPath, context),
+        context) ||
+        (0, _importType.isScoped)(importPath);
+
+        if (!extension || !importPath.endsWith('.' + String(extension))) {
+          // ignore type-only imports and exports
+          if (node.importKind === 'type' || node.exportKind === 'type') {return;}
+          var extensionRequired = isUseOfExtensionRequired(extension, isPackage);
+          var extensionForbidden = isUseOfExtensionForbidden(extension);
+          if (extensionRequired && !extensionForbidden) {
+            context.report({
+              node: source,
+              message: 'Missing file extension ' + (
+              extension ? '"' + String(extension) + '" ' : '') + 'for "' + String(importPathWithQueryString) + '"' });
+
+          }
+        } else if (extension) {
+          if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
+            context.report({
+              node: source,
+              message: 'Unexpected use of file extension "' + String(extension) + '" for "' + String(importPathWithQueryString) + '"' });
+
+          }
+        }
+      }
+
+      return (0, _moduleVisitor2['default'])(checkFileExtension, { commonjs: true });
+    }return create;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/extensions.js"],"names":["enumValues","patternProperties","type","properties","pattern","ignorePackages","buildProperties","context","result","defaultConfig","options","forEach","obj","undefined","Object","assign","module","exports","meta","docs","category","description","url","schema","anyOf","items","additionalItems","create","props","getModifier","extension","isUseOfExtensionRequired","isPackage","isUseOfExtensionForbidden","isResolvableWithoutExtension","file","path","extname","fileWithoutExtension","slice","length","resolvedFileWithoutExtension","isExternalRootModule","slashCount","split","checkFileExtension","source","node","value","importPathWithQueryString","settings","importPath","replace","resolvedPath","substring","endsWith","importKind","exportKind","extensionRequired","extensionForbidden","report","message","commonjs"],"mappings":"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","file":"extensions.js","sourcesContent":["import path from 'path';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport { isBuiltIn, isExternalModule, isScoped } from '../core/importType';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nconst enumValues = { enum: ['always', 'ignorePackages', 'never'] };\nconst patternProperties = {\n  type: 'object',\n  patternProperties: { '.*': enumValues },\n};\nconst properties = {\n  type: 'object',\n  properties: {\n    pattern: patternProperties,\n    ignorePackages: { type: 'boolean' },\n  },\n};\n\nfunction buildProperties(context) {\n\n  const result = {\n    defaultConfig: 'never',\n    pattern: {},\n    ignorePackages: false,\n  };\n\n  context.options.forEach((obj) => {\n\n    // If this is a string, set defaultConfig to its value\n    if (typeof obj === 'string') {\n      result.defaultConfig = obj;\n      return;\n    }\n\n    // If this is not the new structure, transfer all props to result.pattern\n    if (obj.pattern === undefined && obj.ignorePackages === undefined) {\n      Object.assign(result.pattern, obj);\n      return;\n    }\n\n    // If pattern is provided, transfer all props\n    if (obj.pattern !== undefined) {\n      Object.assign(result.pattern, obj.pattern);\n    }\n\n    // If ignorePackages is provided, transfer it to result\n    if (obj.ignorePackages !== undefined) {\n      result.ignorePackages = obj.ignorePackages;\n    }\n  });\n\n  if (result.defaultConfig === 'ignorePackages') {\n    result.defaultConfig = 'always';\n    result.ignorePackages = true;\n  }\n\n  return result;\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Ensure consistent use of file extension within the import path.',\n      url: docsUrl('extensions'),\n    },\n\n    schema: {\n      anyOf: [\n        {\n          type: 'array',\n          items: [enumValues],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            properties,\n          ],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [properties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [patternProperties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            patternProperties,\n          ],\n          additionalItems: false,\n        },\n      ],\n    },\n  },\n\n  create(context) {\n\n    const props = buildProperties(context);\n\n    function getModifier(extension) {\n      return props.pattern[extension] || props.defaultConfig;\n    }\n\n    function isUseOfExtensionRequired(extension, isPackage) {\n      return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackage);\n    }\n\n    function isUseOfExtensionForbidden(extension) {\n      return getModifier(extension) === 'never';\n    }\n\n    function isResolvableWithoutExtension(file) {\n      const extension = path.extname(file);\n      const fileWithoutExtension = file.slice(0, -extension.length);\n      const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context);\n\n      return resolvedFileWithoutExtension === resolve(file, context);\n    }\n\n    function isExternalRootModule(file) {\n      if (file === '.' || file === '..') { return false; }\n      const slashCount = file.split('/').length - 1;\n\n      if (slashCount === 0)  { return true; }\n      if (isScoped(file) && slashCount <= 1) { return true; }\n      return false;\n    }\n\n    function checkFileExtension(source, node) {\n      // bail if the declaration doesn't have a source, e.g. \"export { foo };\", or if it's only partially typed like in an editor\n      if (!source || !source.value) { return; }\n\n      const importPathWithQueryString = source.value;\n\n      // don't enforce anything on builtins\n      if (isBuiltIn(importPathWithQueryString, context.settings)) { return; }\n\n      const importPath = importPathWithQueryString.replace(/\\?(.*)$/, '');\n\n      // don't enforce in root external packages as they may have names with `.js`.\n      // Like `import Decimal from decimal.js`)\n      if (isExternalRootModule(importPath)) { return; }\n\n      const resolvedPath = resolve(importPath, context);\n\n      // get extension from resolved path, if possible.\n      // for unresolved, use source value.\n      const extension = path.extname(resolvedPath || importPath).substring(1);\n\n      // determine if this is a module\n      const isPackage = isExternalModule(\n        importPath,\n        resolve(importPath, context),\n        context,\n      ) || isScoped(importPath);\n\n      if (!extension || !importPath.endsWith(`.${extension}`)) {\n        // ignore type-only imports and exports\n        if (node.importKind === 'type' || node.exportKind === 'type') { return; }\n        const extensionRequired = isUseOfExtensionRequired(extension, isPackage);\n        const extensionForbidden = isUseOfExtensionForbidden(extension);\n        if (extensionRequired && !extensionForbidden) {\n          context.report({\n            node: source,\n            message:\n              `Missing file extension ${extension ? `\"${extension}\" ` : ''}for \"${importPathWithQueryString}\"`,\n          });\n        }\n      } else if (extension) {\n        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {\n          context.report({\n            node: source,\n            message: `Unexpected use of file extension \"${extension}\" for \"${importPathWithQueryString}\"`,\n          });\n        }\n      }\n    }\n\n    return moduleVisitor(checkFileExtension, { commonjs: true });\n  },\n};\n"]}

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/first.js

@@ -0,0 +1,144 @@
+'use strict';var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+function getImportValue(node) {
+  return node.type === 'ImportDeclaration' ?
+  node.source.value :
+  node.moduleReference.expression.value;
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      category: 'Style guide',
+      description: 'Ensure all imports appear before other statements.',
+      url: (0, _docsUrl2['default'])('first') },
+
+    fixable: 'code',
+    schema: [
+    {
+      type: 'string',
+      'enum': ['absolute-first', 'disable-absolute-first'] }] },
+
+
+
+
+  create: function () {function create(context) {
+      function isPossibleDirective(node) {
+        return node.type === 'ExpressionStatement' &&
+        node.expression.type === 'Literal' &&
+        typeof node.expression.value === 'string';
+      }
+
+      return {
+        Program: function () {function Program(n) {
+            var body = n.body;
+            if (!body) {
+              return;
+            }
+            var absoluteFirst = context.options[0] === 'absolute-first';
+            var message = 'Import in body of module; reorder to top.';
+            var sourceCode = context.getSourceCode();
+            var originSourceCode = sourceCode.getText();
+            var nonImportCount = 0;
+            var anyExpressions = false;
+            var anyRelative = false;
+            var lastLegalImp = null;
+            var errorInfos = [];
+            var shouldSort = true;
+            var lastSortNodesIndex = 0;
+            body.forEach(function (node, index) {
+              if (!anyExpressions && isPossibleDirective(node)) {
+                return;
+              }
+
+              anyExpressions = true;
+
+              if (node.type === 'ImportDeclaration' || node.type === 'TSImportEqualsDeclaration') {
+                if (absoluteFirst) {
+                  if (/^\./.test(getImportValue(node))) {
+                    anyRelative = true;
+                  } else if (anyRelative) {
+                    context.report({
+                      node: node.type === 'ImportDeclaration' ? node.source : node.moduleReference,
+                      message: 'Absolute imports should come before relative imports.' });
+
+                  }
+                }
+                if (nonImportCount > 0) {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {
+                    for (var _iterator = context.getDeclaredVariables(node)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var variable = _step.value;
+                      if (!shouldSort) {break;}
+                      var references = variable.references;
+                      if (references.length) {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try {
+                          for (var _iterator2 = references[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var reference = _step2.value;
+                            if (reference.identifier.range[0] < node.range[1]) {
+                              shouldSort = false;
+                              break;
+                            }
+                          }} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}}
+                      }
+                    }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}
+                  shouldSort && (lastSortNodesIndex = errorInfos.length);
+                  errorInfos.push({
+                    node: node,
+                    range: [body[index - 1].range[1], node.range[1]] });
+
+                } else {
+                  lastLegalImp = node;
+                }
+              } else {
+                nonImportCount++;
+              }
+            });
+            if (!errorInfos.length) {return;}
+            errorInfos.forEach(function (errorInfo, index) {
+              var node = errorInfo.node;
+              var infos = {
+                node: node,
+                message: message };
+
+              if (index < lastSortNodesIndex) {
+                infos.fix = function (fixer) {
+                  return fixer.insertTextAfter(node, '');
+                };
+              } else if (index === lastSortNodesIndex) {
+                var sortNodes = errorInfos.slice(0, lastSortNodesIndex + 1);
+                infos.fix = function (fixer) {
+                  var removeFixers = sortNodes.map(function (_errorInfo) {
+                    return fixer.removeRange(_errorInfo.range);
+                  });
+                  var range = [0, removeFixers[removeFixers.length - 1].range[1]];
+                  var insertSourceCode = sortNodes.map(function (_errorInfo) {
+                    var nodeSourceCode = String.prototype.slice.apply(
+                    originSourceCode, _errorInfo.range);
+
+                    if (/\S/.test(nodeSourceCode[0])) {
+                      return '\n' + String(nodeSourceCode);
+                    }
+                    return nodeSourceCode;
+                  }).join('');
+                  var insertFixer = null;
+                  var replaceSourceCode = '';
+                  if (!lastLegalImp) {
+                    insertSourceCode = insertSourceCode.trim() + insertSourceCode.match(/^(\s+)/)[0];
+                  }
+                  insertFixer = lastLegalImp ?
+                  fixer.insertTextAfter(lastLegalImp, insertSourceCode) :
+                  fixer.insertTextBefore(body[0], insertSourceCode);
+
+                  var fixers = [insertFixer].concat(removeFixers);
+                  fixers.forEach(function (computedFixer, i) {
+                    replaceSourceCode += originSourceCode.slice(
+                    fixers[i - 1] ? fixers[i - 1].range[1] : 0, computedFixer.range[0]) +
+                    computedFixer.text;
+                  });
+
+                  return fixer.replaceTextRange(range, replaceSourceCode);
+                };
+              }
+              context.report(infos);
+            });
+          }return Program;}() };
+
+    }return create;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/first.js"],"names":["getImportValue","node","type","source","value","moduleReference","expression","module","exports","meta","docs","category","description","url","fixable","schema","create","context","isPossibleDirective","Program","n","body","absoluteFirst","options","message","sourceCode","getSourceCode","originSourceCode","getText","nonImportCount","anyExpressions","anyRelative","lastLegalImp","errorInfos","shouldSort","lastSortNodesIndex","forEach","index","test","report","getDeclaredVariables","variable","references","length","reference","identifier","range","push","errorInfo","infos","fix","fixer","insertTextAfter","sortNodes","slice","removeFixers","map","_errorInfo","removeRange","insertSourceCode","nodeSourceCode","String","prototype","apply","join","insertFixer","replaceSourceCode","trim","match","insertTextBefore","fixers","concat","computedFixer","i","text","replaceTextRange"],"mappings":"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","file":"first.js","sourcesContent":["import docsUrl from '../docsUrl';\n\nfunction getImportValue(node) {\n  return node.type === 'ImportDeclaration'\n    ? node.source.value\n    : node.moduleReference.expression.value;\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Ensure all imports appear before other statements.',\n      url: docsUrl('first'),\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'string',\n        enum: ['absolute-first', 'disable-absolute-first'],\n      },\n    ],\n  },\n\n  create(context) {\n    function isPossibleDirective(node) {\n      return node.type === 'ExpressionStatement'\n        && node.expression.type === 'Literal'\n        && typeof node.expression.value === 'string';\n    }\n\n    return {\n      Program(n) {\n        const body = n.body;\n        if (!body) {\n          return;\n        }\n        const absoluteFirst = context.options[0] === 'absolute-first';\n        const message = 'Import in body of module; reorder to top.';\n        const sourceCode = context.getSourceCode();\n        const originSourceCode = sourceCode.getText();\n        let nonImportCount = 0;\n        let anyExpressions = false;\n        let anyRelative = false;\n        let lastLegalImp = null;\n        const errorInfos = [];\n        let shouldSort = true;\n        let lastSortNodesIndex = 0;\n        body.forEach(function (node, index) {\n          if (!anyExpressions && isPossibleDirective(node)) {\n            return;\n          }\n\n          anyExpressions = true;\n\n          if (node.type === 'ImportDeclaration' || node.type === 'TSImportEqualsDeclaration') {\n            if (absoluteFirst) {\n              if ((/^\\./).test(getImportValue(node))) {\n                anyRelative = true;\n              } else if (anyRelative) {\n                context.report({\n                  node: node.type === 'ImportDeclaration' ? node.source : node.moduleReference,\n                  message: 'Absolute imports should come before relative imports.',\n                });\n              }\n            }\n            if (nonImportCount > 0) {\n              for (const variable of context.getDeclaredVariables(node)) {\n                if (!shouldSort) { break; }\n                const references = variable.references;\n                if (references.length) {\n                  for (const reference of references) {\n                    if (reference.identifier.range[0] < node.range[1]) {\n                      shouldSort = false;\n                      break;\n                    }\n                  }\n                }\n              }\n              shouldSort && (lastSortNodesIndex = errorInfos.length);\n              errorInfos.push({\n                node,\n                range: [body[index - 1].range[1], node.range[1]],\n              });\n            } else {\n              lastLegalImp = node;\n            }\n          } else {\n            nonImportCount++;\n          }\n        });\n        if (!errorInfos.length) { return; }\n        errorInfos.forEach(function (errorInfo, index) {\n          const node = errorInfo.node;\n          const infos = {\n            node,\n            message,\n          };\n          if (index < lastSortNodesIndex) {\n            infos.fix = function (fixer) {\n              return fixer.insertTextAfter(node, '');\n            };\n          } else if (index === lastSortNodesIndex) {\n            const sortNodes = errorInfos.slice(0, lastSortNodesIndex + 1);\n            infos.fix = function (fixer) {\n              const removeFixers = sortNodes.map(function (_errorInfo) {\n                return fixer.removeRange(_errorInfo.range);\n              });\n              const range = [0, removeFixers[removeFixers.length - 1].range[1]];\n              let insertSourceCode = sortNodes.map(function (_errorInfo) {\n                const nodeSourceCode = String.prototype.slice.apply(\n                  originSourceCode, _errorInfo.range,\n                );\n                if ((/\\S/).test(nodeSourceCode[0])) {\n                  return `\\n${nodeSourceCode}`;\n                }\n                return nodeSourceCode;\n              }).join('');\n              let insertFixer = null;\n              let replaceSourceCode = '';\n              if (!lastLegalImp) {\n                insertSourceCode = insertSourceCode.trim() + insertSourceCode.match(/^(\\s+)/)[0];\n              }\n              insertFixer = lastLegalImp\n                ? fixer.insertTextAfter(lastLegalImp, insertSourceCode)\n                : fixer.insertTextBefore(body[0], insertSourceCode);\n\n              const fixers = [insertFixer].concat(removeFixers);\n              fixers.forEach((computedFixer, i) => {\n                replaceSourceCode += originSourceCode.slice(\n                  fixers[i - 1] ? fixers[i - 1].range[1] : 0, computedFixer.range[0],\n                ) + computedFixer.text;\n              });\n\n              return fixer.replaceTextRange(range, replaceSourceCode);\n            };\n          }\n          context.report(infos);\n        });\n      },\n    };\n  },\n};\n"]}

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/group-exports.js

@@ -0,0 +1,155 @@
+'use strict';var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);
+var _object = require('object.values');var _object2 = _interopRequireDefault(_object);
+var _arrayPrototype = require('array.prototype.flat');var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var meta = {
+  type: 'suggestion',
+  docs: {
+    category: 'Style guide',
+    description: 'Prefer named exports to be grouped together in a single export declaration',
+    url: (0, _docsUrl2['default'])('group-exports') } };
+
+
+/* eslint-disable max-len */
+var errors = {
+  ExportNamedDeclaration: 'Multiple named export declarations; consolidate all named exports into a single export declaration',
+  AssignmentExpression: 'Multiple CommonJS exports; consolidate all exports into a single assignment to `module.exports`' };
+
+/* eslint-enable max-len */
+
+/**
+                             * Returns an array with names of the properties in the accessor chain for MemberExpression nodes
+                             *
+                             * Example:
+                             *
+                             * `module.exports = {}` => ['module', 'exports']
+                             * `module.exports.property = true` => ['module', 'exports', 'property']
+                             *
+                             * @param     {Node}    node    AST Node (MemberExpression)
+                             * @return    {Array}           Array with the property names in the chain
+                             * @private
+                             */
+function accessorChain(node) {
+  var chain = [];
+
+  do {
+    chain.unshift(node.property.name);
+
+    if (node.object.type === 'Identifier') {
+      chain.unshift(node.object.name);
+      break;
+    }
+
+    node = node.object;
+  } while (node.type === 'MemberExpression');
+
+  return chain;
+}
+
+function create(context) {
+  var nodes = {
+    modules: {
+      set: new Set(),
+      sources: {} },
+
+    types: {
+      set: new Set(),
+      sources: {} },
+
+    commonjs: {
+      set: new Set() } };
+
+
+
+  return {
+    ExportNamedDeclaration: function () {function ExportNamedDeclaration(node) {
+        var target = node.exportKind === 'type' ? nodes.types : nodes.modules;
+        if (!node.source) {
+          target.set.add(node);
+        } else if (Array.isArray(target.sources[node.source.value])) {
+          target.sources[node.source.value].push(node);
+        } else {
+          target.sources[node.source.value] = [node];
+        }
+      }return ExportNamedDeclaration;}(),
+
+    AssignmentExpression: function () {function AssignmentExpression(node) {
+        if (node.left.type !== 'MemberExpression') {
+          return;
+        }
+
+        var chain = accessorChain(node.left);
+
+        // Assignments to module.exports
+        // Deeper assignments are ignored since they just modify what's already being exported
+        // (ie. module.exports.exported.prop = true is ignored)
+        if (chain[0] === 'module' && chain[1] === 'exports' && chain.length <= 3) {
+          nodes.commonjs.set.add(node);
+          return;
+        }
+
+        // Assignments to exports (exports.* = *)
+        if (chain[0] === 'exports' && chain.length === 2) {
+          nodes.commonjs.set.add(node);
+          return;
+        }
+      }return AssignmentExpression;}(),
+
+    'Program:exit': function () {function onExit() {
+        // Report multiple `export` declarations (ES2015 modules)
+        if (nodes.modules.set.size > 1) {
+          nodes.modules.set.forEach(function (node) {
+            context.report({
+              node: node,
+              message: errors[node.type] });
+
+          });
+        }
+
+        // Report multiple `aggregated exports` from the same module (ES2015 modules)
+        (0, _arrayPrototype2['default'])((0, _object2['default'])(nodes.modules.sources).
+        filter(function (nodesWithSource) {return Array.isArray(nodesWithSource) && nodesWithSource.length > 1;})).
+        forEach(function (node) {
+          context.report({
+            node: node,
+            message: errors[node.type] });
+
+        });
+
+        // Report multiple `export type` declarations (FLOW ES2015 modules)
+        if (nodes.types.set.size > 1) {
+          nodes.types.set.forEach(function (node) {
+            context.report({
+              node: node,
+              message: errors[node.type] });
+
+          });
+        }
+
+        // Report multiple `aggregated type exports` from the same module (FLOW ES2015 modules)
+        (0, _arrayPrototype2['default'])((0, _object2['default'])(nodes.types.sources).
+        filter(function (nodesWithSource) {return Array.isArray(nodesWithSource) && nodesWithSource.length > 1;})).
+        forEach(function (node) {
+          context.report({
+            node: node,
+            message: errors[node.type] });
+
+        });
+
+        // Report multiple `module.exports` assignments (CommonJS)
+        if (nodes.commonjs.set.size > 1) {
+          nodes.commonjs.set.forEach(function (node) {
+            context.report({
+              node: node,
+              message: errors[node.type] });
+
+          });
+        }
+      }return onExit;}() };
+
+}
+
+module.exports = {
+  meta: meta,
+  create: create };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/group-exports.js"],"names":["meta","type","docs","category","description","url","errors","ExportNamedDeclaration","AssignmentExpression","accessorChain","node","chain","unshift","property","name","object","create","context","nodes","modules","set","Set","sources","types","commonjs","target","exportKind","source","add","Array","isArray","value","push","left","length","onExit","size","forEach","report","message","filter","nodesWithSource","module","exports"],"mappings":"aAAA,qC;AACA,uC;AACA,sD;;AAEA,IAAMA,OAAO;AACXC,QAAM,YADK;AAEXC,QAAM;AACJC,cAAU,aADN;AAEJC,iBAAa,4EAFT;AAGJC,SAAK,0BAAQ,eAAR,CAHD,EAFK,EAAb;;;AAQA;AACA,IAAMC,SAAS;AACbC,0BAAwB,oGADX;AAEbC,wBAAsB,iGAFT,EAAf;;AAIA;;AAEA;;;;;;;;;;;;AAYA,SAASC,aAAT,CAAuBC,IAAvB,EAA6B;AAC3B,MAAMC,QAAQ,EAAd;;AAEA,KAAG;AACDA,UAAMC,OAAN,CAAcF,KAAKG,QAAL,CAAcC,IAA5B;;AAEA,QAAIJ,KAAKK,MAAL,CAAYd,IAAZ,KAAqB,YAAzB,EAAuC;AACrCU,YAAMC,OAAN,CAAcF,KAAKK,MAAL,CAAYD,IAA1B;AACA;AACD;;AAEDJ,WAAOA,KAAKK,MAAZ;AACD,GATD,QASSL,KAAKT,IAAL,KAAc,kBATvB;;AAWA,SAAOU,KAAP;AACD;;AAED,SAASK,MAAT,CAAgBC,OAAhB,EAAyB;AACvB,MAAMC,QAAQ;AACZC,aAAS;AACPC,WAAK,IAAIC,GAAJ,EADE;AAEPC,eAAS,EAFF,EADG;;AAKZC,WAAO;AACLH,WAAK,IAAIC,GAAJ,EADA;AAELC,eAAS,EAFJ,EALK;;AASZE,cAAU;AACRJ,WAAK,IAAIC,GAAJ,EADG,EATE,EAAd;;;;AAcA,SAAO;AACLd,0BADK,+CACkBG,IADlB,EACwB;AAC3B,YAAMe,SAASf,KAAKgB,UAAL,KAAoB,MAApB,GAA6BR,MAAMK,KAAnC,GAA2CL,MAAMC,OAAhE;AACA,YAAI,CAACT,KAAKiB,MAAV,EAAkB;AAChBF,iBAAOL,GAAP,CAAWQ,GAAX,CAAelB,IAAf;AACD,SAFD,MAEO,IAAImB,MAAMC,OAAN,CAAcL,OAAOH,OAAP,CAAeZ,KAAKiB,MAAL,CAAYI,KAA3B,CAAd,CAAJ,EAAsD;AAC3DN,iBAAOH,OAAP,CAAeZ,KAAKiB,MAAL,CAAYI,KAA3B,EAAkCC,IAAlC,CAAuCtB,IAAvC;AACD,SAFM,MAEA;AACLe,iBAAOH,OAAP,CAAeZ,KAAKiB,MAAL,CAAYI,KAA3B,IAAoC,CAACrB,IAAD,CAApC;AACD;AACF,OAVI;;AAYLF,wBAZK,6CAYgBE,IAZhB,EAYsB;AACzB,YAAIA,KAAKuB,IAAL,CAAUhC,IAAV,KAAmB,kBAAvB,EAA2C;AACzC;AACD;;AAED,YAAMU,QAAQF,cAAcC,KAAKuB,IAAnB,CAAd;;AAEA;AACA;AACA;AACA,YAAItB,MAAM,CAAN,MAAa,QAAb,IAAyBA,MAAM,CAAN,MAAa,SAAtC,IAAmDA,MAAMuB,MAAN,IAAgB,CAAvE,EAA0E;AACxEhB,gBAAMM,QAAN,CAAeJ,GAAf,CAAmBQ,GAAnB,CAAuBlB,IAAvB;AACA;AACD;;AAED;AACA,YAAIC,MAAM,CAAN,MAAa,SAAb,IAA0BA,MAAMuB,MAAN,KAAiB,CAA/C,EAAkD;AAChDhB,gBAAMM,QAAN,CAAeJ,GAAf,CAAmBQ,GAAnB,CAAuBlB,IAAvB;AACA;AACD;AACF,OAhCI;;AAkCL,iCAAgB,SAASyB,MAAT,GAAkB;AAChC;AACA,YAAIjB,MAAMC,OAAN,CAAcC,GAAd,CAAkBgB,IAAlB,GAAyB,CAA7B,EAAgC;AAC9BlB,gBAAMC,OAAN,CAAcC,GAAd,CAAkBiB,OAAlB,CAA0B,UAAC3B,IAAD,EAAU;AAClCO,oBAAQqB,MAAR,CAAe;AACb5B,wBADa;AAEb6B,uBAASjC,OAAOI,KAAKT,IAAZ,CAFI,EAAf;;AAID,WALD;AAMD;;AAED;AACA,yCAAK,yBAAOiB,MAAMC,OAAN,CAAcG,OAArB;AACFkB,cADE,CACK,UAACC,eAAD,UAAqBZ,MAAMC,OAAN,CAAcW,eAAd,KAAkCA,gBAAgBP,MAAhB,GAAyB,CAAhF,EADL,CAAL;AAEGG,eAFH,CAEW,UAAC3B,IAAD,EAAU;AACjBO,kBAAQqB,MAAR,CAAe;AACb5B,sBADa;AAEb6B,qBAASjC,OAAOI,KAAKT,IAAZ,CAFI,EAAf;;AAID,SAPH;;AASA;AACA,YAAIiB,MAAMK,KAAN,CAAYH,GAAZ,CAAgBgB,IAAhB,GAAuB,CAA3B,EAA8B;AAC5BlB,gBAAMK,KAAN,CAAYH,GAAZ,CAAgBiB,OAAhB,CAAwB,UAAC3B,IAAD,EAAU;AAChCO,oBAAQqB,MAAR,CAAe;AACb5B,wBADa;AAEb6B,uBAASjC,OAAOI,KAAKT,IAAZ,CAFI,EAAf;;AAID,WALD;AAMD;;AAED;AACA,yCAAK,yBAAOiB,MAAMK,KAAN,CAAYD,OAAnB;AACFkB,cADE,CACK,UAACC,eAAD,UAAqBZ,MAAMC,OAAN,CAAcW,eAAd,KAAkCA,gBAAgBP,MAAhB,GAAyB,CAAhF,EADL,CAAL;AAEGG,eAFH,CAEW,UAAC3B,IAAD,EAAU;AACjBO,kBAAQqB,MAAR,CAAe;AACb5B,sBADa;AAEb6B,qBAASjC,OAAOI,KAAKT,IAAZ,CAFI,EAAf;;AAID,SAPH;;AASA;AACA,YAAIiB,MAAMM,QAAN,CAAeJ,GAAf,CAAmBgB,IAAnB,GAA0B,CAA9B,EAAiC;AAC/BlB,gBAAMM,QAAN,CAAeJ,GAAf,CAAmBiB,OAAnB,CAA2B,UAAC3B,IAAD,EAAU;AACnCO,oBAAQqB,MAAR,CAAe;AACb5B,wBADa;AAEb6B,uBAASjC,OAAOI,KAAKT,IAAZ,CAFI,EAAf;;AAID,WALD;AAMD;AACF,OAlDD,OAAyBkC,MAAzB,IAlCK,EAAP;;AAsFD;;AAEDO,OAAOC,OAAP,GAAiB;AACf3C,YADe;AAEfgB,gBAFe,EAAjB","file":"group-exports.js","sourcesContent":["import docsUrl from '../docsUrl';\nimport values from 'object.values';\nimport flat from 'array.prototype.flat';\n\nconst meta = {\n  type: 'suggestion',\n  docs: {\n    category: 'Style guide',\n    description: 'Prefer named exports to be grouped together in a single export declaration',\n    url: docsUrl('group-exports'),\n  },\n};\n/* eslint-disable max-len */\nconst errors = {\n  ExportNamedDeclaration: 'Multiple named export declarations; consolidate all named exports into a single export declaration',\n  AssignmentExpression: 'Multiple CommonJS exports; consolidate all exports into a single assignment to `module.exports`',\n};\n/* eslint-enable max-len */\n\n/**\n * Returns an array with names of the properties in the accessor chain for MemberExpression nodes\n *\n * Example:\n *\n * `module.exports = {}` => ['module', 'exports']\n * `module.exports.property = true` => ['module', 'exports', 'property']\n *\n * @param     {Node}    node    AST Node (MemberExpression)\n * @return    {Array}           Array with the property names in the chain\n * @private\n */\nfunction accessorChain(node) {\n  const chain = [];\n\n  do {\n    chain.unshift(node.property.name);\n\n    if (node.object.type === 'Identifier') {\n      chain.unshift(node.object.name);\n      break;\n    }\n\n    node = node.object;\n  } while (node.type === 'MemberExpression');\n\n  return chain;\n}\n\nfunction create(context) {\n  const nodes = {\n    modules: {\n      set: new Set(),\n      sources: {},\n    },\n    types: {\n      set: new Set(),\n      sources: {},\n    },\n    commonjs: {\n      set: new Set(),\n    },\n  };\n\n  return {\n    ExportNamedDeclaration(node) {\n      const target = node.exportKind === 'type' ? nodes.types : nodes.modules;\n      if (!node.source) {\n        target.set.add(node);\n      } else if (Array.isArray(target.sources[node.source.value])) {\n        target.sources[node.source.value].push(node);\n      } else {\n        target.sources[node.source.value] = [node];\n      }\n    },\n\n    AssignmentExpression(node) {\n      if (node.left.type !== 'MemberExpression') {\n        return;\n      }\n\n      const chain = accessorChain(node.left);\n\n      // Assignments to module.exports\n      // Deeper assignments are ignored since they just modify what's already being exported\n      // (ie. module.exports.exported.prop = true is ignored)\n      if (chain[0] === 'module' && chain[1] === 'exports' && chain.length <= 3) {\n        nodes.commonjs.set.add(node);\n        return;\n      }\n\n      // Assignments to exports (exports.* = *)\n      if (chain[0] === 'exports' && chain.length === 2) {\n        nodes.commonjs.set.add(node);\n        return;\n      }\n    },\n\n    'Program:exit': function onExit() {\n      // Report multiple `export` declarations (ES2015 modules)\n      if (nodes.modules.set.size > 1) {\n        nodes.modules.set.forEach((node) => {\n          context.report({\n            node,\n            message: errors[node.type],\n          });\n        });\n      }\n\n      // Report multiple `aggregated exports` from the same module (ES2015 modules)\n      flat(values(nodes.modules.sources)\n        .filter((nodesWithSource) => Array.isArray(nodesWithSource) && nodesWithSource.length > 1))\n        .forEach((node) => {\n          context.report({\n            node,\n            message: errors[node.type],\n          });\n        });\n\n      // Report multiple `export type` declarations (FLOW ES2015 modules)\n      if (nodes.types.set.size > 1) {\n        nodes.types.set.forEach((node) => {\n          context.report({\n            node,\n            message: errors[node.type],\n          });\n        });\n      }\n\n      // Report multiple `aggregated type exports` from the same module (FLOW ES2015 modules)\n      flat(values(nodes.types.sources)\n        .filter((nodesWithSource) => Array.isArray(nodesWithSource) && nodesWithSource.length > 1))\n        .forEach((node) => {\n          context.report({\n            node,\n            message: errors[node.type],\n          });\n        });\n\n      // Report multiple `module.exports` assignments (CommonJS)\n      if (nodes.commonjs.set.size > 1) {\n        nodes.commonjs.set.forEach((node) => {\n          context.report({\n            node,\n            message: errors[node.type],\n          });\n        });\n      }\n    },\n  };\n}\n\nmodule.exports = {\n  meta,\n  create,\n};\n"]}

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/imports-first.js

@@ -0,0 +1,16 @@
+'use strict';var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var first = require('./first');
+
+var newMeta = Object.assign({},
+first.meta, {
+  deprecated: true,
+  docs: {
+    category: 'Style guide',
+    description: 'Replaced by `import/first`.',
+    url: (0, _docsUrl2['default'])('imports-first', '7b25c1cb95ee18acc1531002fd343e1e6031f9ed') } });
+
+
+
+module.exports = Object.assign({}, first, { meta: newMeta });
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydWxlcy9pbXBvcnRzLWZpcnN0LmpzIl0sIm5hbWVzIjpbImZpcnN0IiwicmVxdWlyZSIsIm5ld01ldGEiLCJtZXRhIiwiZGVwcmVjYXRlZCIsImRvY3MiLCJjYXRlZ29yeSIsImRlc2NyaXB0aW9uIiwidXJsIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6ImFBQUEscUM7O0FBRUEsSUFBTUEsUUFBUUMsUUFBUSxTQUFSLENBQWQ7O0FBRUEsSUFBTUM7QUFDREYsTUFBTUcsSUFETDtBQUVKQyxjQUFZLElBRlI7QUFHSkMsUUFBTTtBQUNKQyxjQUFVLGFBRE47QUFFSkMsaUJBQWEsNkJBRlQ7QUFHSkMsU0FBSywwQkFBUSxlQUFSLEVBQXlCLDBDQUF6QixDQUhELEVBSEYsR0FBTjs7OztBQVVBQyxPQUFPQyxPQUFQLHFCQUFzQlYsS0FBdEIsSUFBNkJHLE1BQU1ELE9BQW5DIiwiZmlsZSI6ImltcG9ydHMtZmlyc3QuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZG9jc1VybCBmcm9tICcuLi9kb2NzVXJsJztcblxuY29uc3QgZmlyc3QgPSByZXF1aXJlKCcuL2ZpcnN0Jyk7XG5cbmNvbnN0IG5ld01ldGEgPSB7XG4gIC4uLmZpcnN0Lm1ldGEsXG4gIGRlcHJlY2F0ZWQ6IHRydWUsXG4gIGRvY3M6IHtcbiAgICBjYXRlZ29yeTogJ1N0eWxlIGd1aWRlJyxcbiAgICBkZXNjcmlwdGlvbjogJ1JlcGxhY2VkIGJ5IGBpbXBvcnQvZmlyc3RgLicsXG4gICAgdXJsOiBkb2NzVXJsKCdpbXBvcnRzLWZpcnN0JywgJzdiMjVjMWNiOTVlZTE4YWNjMTUzMTAwMmZkMzQzZTFlNjAzMWY5ZWQnKSxcbiAgfSxcbn07XG5cbm1vZHVsZS5leHBvcnRzID0geyAuLi5maXJzdCwgbWV0YTogbmV3TWV0YSB9O1xuIl19

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/max-dependencies.js

@@ -0,0 +1,60 @@
+'use strict';var _moduleVisitor = require('eslint-module-utils/moduleVisitor');var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor);
+var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var DEFAULT_MAX = 10;
+var DEFAULT_IGNORE_TYPE_IMPORTS = false;
+var TYPE_IMPORT = 'type';
+
+var countDependencies = function countDependencies(dependencies, lastNode, context) {var _ref =
+  context.options[0] || { max: DEFAULT_MAX },max = _ref.max;
+
+  if (dependencies.size > max) {
+    context.report(lastNode, 'Maximum number of dependencies (' + String(max) + ') exceeded.');
+  }
+};
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      category: 'Style guide',
+      description: 'Enforce the maximum number of dependencies a module can have.',
+      url: (0, _docsUrl2['default'])('max-dependencies') },
+
+
+    schema: [
+    {
+      type: 'object',
+      properties: {
+        max: { type: 'number' },
+        ignoreTypeImports: { type: 'boolean' } },
+
+      additionalProperties: false }] },
+
+
+
+
+  create: function () {function create(context) {var _ref2 =
+
+
+      context.options[0] || {},_ref2$ignoreTypeImpor = _ref2.ignoreTypeImports,ignoreTypeImports = _ref2$ignoreTypeImpor === undefined ? DEFAULT_IGNORE_TYPE_IMPORTS : _ref2$ignoreTypeImpor;
+
+      var dependencies = new Set(); // keep track of dependencies
+      var lastNode = void 0; // keep track of the last node to report on
+
+      return Object.assign({
+        'Program:exit': function () {function ProgramExit() {
+            countDependencies(dependencies, lastNode, context);
+          }return ProgramExit;}() },
+      (0, _moduleVisitor2['default'])(
+      function (source, _ref3) {var importKind = _ref3.importKind;
+        if (importKind !== TYPE_IMPORT || !ignoreTypeImports) {
+          dependencies.add(source.value);
+        }
+        lastNode = source;
+      },
+      { commonjs: true }));
+
+
+    }return create;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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