immosquare-cleaner 0.1.5 → 0.1.7

data/node_modules/eslint-plugin-import/lib/rules/no-extraneous-dependencies.js

@@ -0,0 +1,300 @@
+'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _path = require('path');var _path2 = _interopRequireDefault(_path);
+var _fs = require('fs');var _fs2 = _interopRequireDefault(_fs);
+var _pkgUp = require('eslint-module-utils/pkgUp');var _pkgUp2 = _interopRequireDefault(_pkgUp);
+var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
+var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
+var _moduleVisitor = require('eslint-module-utils/moduleVisitor');var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor);
+var _importType = require('../core/importType');var _importType2 = _interopRequireDefault(_importType);
+var _packagePath = require('../core/packagePath');
+var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var depFieldCache = new Map();
+
+function hasKeys() {var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return Object.keys(obj).length > 0;
+}
+
+function arrayOrKeys(arrayOrObject) {
+  return Array.isArray(arrayOrObject) ? arrayOrObject : Object.keys(arrayOrObject);
+}
+
+function readJSON(jsonPath, throwException) {
+  try {
+    return JSON.parse(_fs2['default'].readFileSync(jsonPath, 'utf8'));
+  } catch (err) {
+    if (throwException) {
+      throw err;
+    }
+  }
+}
+
+function extractDepFields(pkg) {
+  return {
+    dependencies: pkg.dependencies || {},
+    devDependencies: pkg.devDependencies || {},
+    optionalDependencies: pkg.optionalDependencies || {},
+    peerDependencies: pkg.peerDependencies || {},
+    // BundledDeps should be in the form of an array, but object notation is also supported by
+    // `npm`, so we convert it to an array if it is an object
+    bundledDependencies: arrayOrKeys(pkg.bundleDependencies || pkg.bundledDependencies || []) };
+
+}
+
+function getPackageDepFields(packageJsonPath, throwAtRead) {
+  if (!depFieldCache.has(packageJsonPath)) {
+    var depFields = extractDepFields(readJSON(packageJsonPath, throwAtRead));
+    depFieldCache.set(packageJsonPath, depFields);
+  }
+
+  return depFieldCache.get(packageJsonPath);
+}
+
+function getDependencies(context, packageDir) {
+  var paths = [];
+  try {
+    var packageContent = {
+      dependencies: {},
+      devDependencies: {},
+      optionalDependencies: {},
+      peerDependencies: {},
+      bundledDependencies: [] };
+
+
+    if (packageDir && packageDir.length > 0) {
+      if (!Array.isArray(packageDir)) {
+        paths = [_path2['default'].resolve(packageDir)];
+      } else {
+        paths = packageDir.map(function (dir) {return _path2['default'].resolve(dir);});
+      }
+    }
+
+    if (paths.length > 0) {
+      // use rule config to find package.json
+      paths.forEach(function (dir) {
+        var packageJsonPath = _path2['default'].join(dir, 'package.json');
+        var _packageContent = getPackageDepFields(packageJsonPath, true);
+        Object.keys(packageContent).forEach(function (depsKey) {
+          Object.assign(packageContent[depsKey], _packageContent[depsKey]);
+        });
+      });
+    } else {
+      var packageJsonPath = (0, _pkgUp2['default'])({
+        cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename(),
+        normalize: false });
+
+
+      // use closest package.json
+      Object.assign(
+      packageContent,
+      getPackageDepFields(packageJsonPath, false));
+
+    }
+
+    if (![
+    packageContent.dependencies,
+    packageContent.devDependencies,
+    packageContent.optionalDependencies,
+    packageContent.peerDependencies,
+    packageContent.bundledDependencies].
+    some(hasKeys)) {
+      return null;
+    }
+
+    return packageContent;
+  } catch (e) {
+    if (paths.length > 0 && e.code === 'ENOENT') {
+      context.report({
+        message: 'The package.json file could not be found.',
+        loc: { line: 0, column: 0 } });
+
+    }
+    if (e.name === 'JSONError' || e instanceof SyntaxError) {
+      context.report({
+        message: 'The package.json file could not be parsed: ' + String(e.message),
+        loc: { line: 0, column: 0 } });
+
+    }
+
+    return null;
+  }
+}
+
+function missingErrorMessage(packageName) {
+  return '\'' + String(packageName) + '\' should be listed in the project\'s dependencies. Run \'npm i -S ' + String(packageName) + '\' to add it';
+}
+
+function devDepErrorMessage(packageName) {
+  return '\'' + String(packageName) + '\' should be listed in the project\'s dependencies, not devDependencies.';
+}
+
+function optDepErrorMessage(packageName) {
+  return '\'' + String(packageName) + '\' should be listed in the project\'s dependencies, not optionalDependencies.';
+}
+
+function getModuleOriginalName(name) {var _name$split =
+  name.split('/'),_name$split2 = _slicedToArray(_name$split, 2),first = _name$split2[0],second = _name$split2[1];
+  return first.startsWith('@') ? String(first) + '/' + String(second) : first;
+}
+
+function getModuleRealName(resolved) {
+  return (0, _packagePath.getFilePackageName)(resolved);
+}
+
+function checkDependencyDeclaration(deps, packageName, declarationStatus) {
+  var newDeclarationStatus = declarationStatus || {
+    isInDeps: false,
+    isInDevDeps: false,
+    isInOptDeps: false,
+    isInPeerDeps: false,
+    isInBundledDeps: false };
+
+
+  // in case of sub package.json inside a module
+  // check the dependencies on all hierarchy
+  var packageHierarchy = [];
+  var packageNameParts = packageName ? packageName.split('/') : [];
+  packageNameParts.forEach(function (namePart, index) {
+    if (!namePart.startsWith('@')) {
+      var ancestor = packageNameParts.slice(0, index + 1).join('/');
+      packageHierarchy.push(ancestor);
+    }
+  });
+
+  return packageHierarchy.reduce(function (result, ancestorName) {return {
+      isInDeps: result.isInDeps || deps.dependencies[ancestorName] !== undefined,
+      isInDevDeps: result.isInDevDeps || deps.devDependencies[ancestorName] !== undefined,
+      isInOptDeps: result.isInOptDeps || deps.optionalDependencies[ancestorName] !== undefined,
+      isInPeerDeps: result.isInPeerDeps || deps.peerDependencies[ancestorName] !== undefined,
+      isInBundledDeps:
+      result.isInBundledDeps || deps.bundledDependencies.indexOf(ancestorName) !== -1 };},
+  newDeclarationStatus);
+}
+
+function reportIfMissing(context, deps, depsOptions, node, name) {
+  // Do not report when importing types unless option is enabled
+  if (
+  !depsOptions.verifyTypeImports && (
+
+  node.importKind === 'type' ||
+  node.importKind === 'typeof' ||
+  Array.isArray(node.specifiers) && node.specifiers.length && node.specifiers.every(function (specifier) {return specifier.importKind === 'type' || specifier.importKind === 'typeof';})))
+
+  {
+    return;
+  }
+
+  var typeOfImport = (0, _importType2['default'])(name, context);
+
+  if (
+  typeOfImport !== 'external' && (
+  typeOfImport !== 'internal' || !depsOptions.verifyInternalDeps))
+  {
+    return;
+  }
+
+  var resolved = (0, _resolve2['default'])(name, context);
+  if (!resolved) {return;}
+
+  var importPackageName = getModuleOriginalName(name);
+  var declarationStatus = checkDependencyDeclaration(deps, importPackageName);
+
+  if (
+  declarationStatus.isInDeps ||
+  depsOptions.allowDevDeps && declarationStatus.isInDevDeps ||
+  depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps ||
+  depsOptions.allowOptDeps && declarationStatus.isInOptDeps ||
+  depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps)
+  {
+    return;
+  }
+
+  // test the real name from the resolved package.json
+  // if not aliased imports (alias/react for example), importPackageName can be misinterpreted
+  var realPackageName = getModuleRealName(resolved);
+  if (realPackageName && realPackageName !== importPackageName) {
+    declarationStatus = checkDependencyDeclaration(deps, realPackageName, declarationStatus);
+
+    if (
+    declarationStatus.isInDeps ||
+    depsOptions.allowDevDeps && declarationStatus.isInDevDeps ||
+    depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps ||
+    depsOptions.allowOptDeps && declarationStatus.isInOptDeps ||
+    depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps)
+    {
+      return;
+    }
+  }
+
+  if (declarationStatus.isInDevDeps && !depsOptions.allowDevDeps) {
+    context.report(node, devDepErrorMessage(realPackageName || importPackageName));
+    return;
+  }
+
+  if (declarationStatus.isInOptDeps && !depsOptions.allowOptDeps) {
+    context.report(node, optDepErrorMessage(realPackageName || importPackageName));
+    return;
+  }
+
+  context.report(node, missingErrorMessage(realPackageName || importPackageName));
+}
+
+function testConfig(config, filename) {
+  // Simplest configuration first, either a boolean or nothing.
+  if (typeof config === 'boolean' || typeof config === 'undefined') {
+    return config;
+  }
+  // Array of globs.
+  return config.some(function (c) {return (0, _minimatch2['default'])(filename, c) ||
+    (0, _minimatch2['default'])(filename, _path2['default'].join(process.cwd(), c));});
+
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      category: 'Helpful warnings',
+      description: 'Forbid the use of extraneous packages.',
+      url: (0, _docsUrl2['default'])('no-extraneous-dependencies') },
+
+
+    schema: [
+    {
+      type: 'object',
+      properties: {
+        devDependencies: { type: ['boolean', 'array'] },
+        optionalDependencies: { type: ['boolean', 'array'] },
+        peerDependencies: { type: ['boolean', 'array'] },
+        bundledDependencies: { type: ['boolean', 'array'] },
+        packageDir: { type: ['string', 'array'] },
+        includeInternal: { type: ['boolean'] },
+        includeTypes: { type: ['boolean'] } },
+
+      additionalProperties: false }] },
+
+
+
+
+  create: function () {function create(context) {
+      var options = context.options[0] || {};
+      var filename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();
+      var deps = getDependencies(context, options.packageDir) || extractDepFields({});
+
+      var depsOptions = {
+        allowDevDeps: testConfig(options.devDependencies, filename) !== false,
+        allowOptDeps: testConfig(options.optionalDependencies, filename) !== false,
+        allowPeerDeps: testConfig(options.peerDependencies, filename) !== false,
+        allowBundledDeps: testConfig(options.bundledDependencies, filename) !== false,
+        verifyInternalDeps: !!options.includeInternal,
+        verifyTypeImports: !!options.includeTypes };
+
+
+      return (0, _moduleVisitor2['default'])(function (source, node) {
+        reportIfMissing(context, deps, depsOptions, node, source.value);
+      }, { commonjs: true });
+    }return create;}(),
+
+  'Program:exit': function () {function ProgramExit() {
+      depFieldCache.clear();
+    }return ProgramExit;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-extraneous-dependencies.js"],"names":["depFieldCache","Map","hasKeys","obj","Object","keys","length","arrayOrKeys","arrayOrObject","Array","isArray","readJSON","jsonPath","throwException","JSON","parse","fs","readFileSync","err","extractDepFields","pkg","dependencies","devDependencies","optionalDependencies","peerDependencies","bundledDependencies","bundleDependencies","getPackageDepFields","packageJsonPath","throwAtRead","has","depFields","set","get","getDependencies","context","packageDir","paths","packageContent","path","resolve","map","dir","forEach","join","_packageContent","depsKey","assign","cwd","getPhysicalFilename","getFilename","normalize","some","e","code","report","message","loc","line","column","name","SyntaxError","missingErrorMessage","packageName","devDepErrorMessage","optDepErrorMessage","getModuleOriginalName","split","first","second","startsWith","getModuleRealName","resolved","checkDependencyDeclaration","deps","declarationStatus","newDeclarationStatus","isInDeps","isInDevDeps","isInOptDeps","isInPeerDeps","isInBundledDeps","packageHierarchy","packageNameParts","namePart","index","ancestor","slice","push","reduce","result","ancestorName","undefined","indexOf","reportIfMissing","depsOptions","node","verifyTypeImports","importKind","specifiers","every","specifier","typeOfImport","verifyInternalDeps","importPackageName","allowDevDeps","allowPeerDeps","allowOptDeps","allowBundledDeps","realPackageName","testConfig","config","filename","c","process","module","exports","meta","type","docs","category","description","url","schema","properties","includeInternal","includeTypes","additionalProperties","create","options","source","value","commonjs","clear"],"mappings":"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","file":"no-extraneous-dependencies.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport pkgUp from 'eslint-module-utils/pkgUp';\nimport minimatch from 'minimatch';\nimport resolve from 'eslint-module-utils/resolve';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport importType from '../core/importType';\nimport { getFilePackageName } from '../core/packagePath';\nimport docsUrl from '../docsUrl';\n\nconst depFieldCache = new Map();\n\nfunction hasKeys(obj = {}) {\n  return Object.keys(obj).length > 0;\n}\n\nfunction arrayOrKeys(arrayOrObject) {\n  return Array.isArray(arrayOrObject) ? arrayOrObject : Object.keys(arrayOrObject);\n}\n\nfunction readJSON(jsonPath, throwException) {\n  try {\n    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));\n  } catch (err) {\n    if (throwException) {\n      throw err;\n    }\n  }\n}\n\nfunction extractDepFields(pkg) {\n  return {\n    dependencies: pkg.dependencies || {},\n    devDependencies: pkg.devDependencies || {},\n    optionalDependencies: pkg.optionalDependencies || {},\n    peerDependencies: pkg.peerDependencies || {},\n    // BundledDeps should be in the form of an array, but object notation is also supported by\n    // `npm`, so we convert it to an array if it is an object\n    bundledDependencies: arrayOrKeys(pkg.bundleDependencies || pkg.bundledDependencies || []),\n  };\n}\n\nfunction getPackageDepFields(packageJsonPath, throwAtRead) {\n  if (!depFieldCache.has(packageJsonPath)) {\n    const depFields = extractDepFields(readJSON(packageJsonPath, throwAtRead));\n    depFieldCache.set(packageJsonPath, depFields);\n  }\n\n  return depFieldCache.get(packageJsonPath);\n}\n\nfunction getDependencies(context, packageDir) {\n  let paths = [];\n  try {\n    const packageContent = {\n      dependencies: {},\n      devDependencies: {},\n      optionalDependencies: {},\n      peerDependencies: {},\n      bundledDependencies: [],\n    };\n\n    if (packageDir && packageDir.length > 0) {\n      if (!Array.isArray(packageDir)) {\n        paths = [path.resolve(packageDir)];\n      } else {\n        paths = packageDir.map((dir) => path.resolve(dir));\n      }\n    }\n\n    if (paths.length > 0) {\n      // use rule config to find package.json\n      paths.forEach((dir) => {\n        const packageJsonPath = path.join(dir, 'package.json');\n        const _packageContent = getPackageDepFields(packageJsonPath, true);\n        Object.keys(packageContent).forEach((depsKey) => {\n          Object.assign(packageContent[depsKey], _packageContent[depsKey]);\n        });\n      });\n    } else {\n      const packageJsonPath = pkgUp({\n        cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename(),\n        normalize: false,\n      });\n\n      // use closest package.json\n      Object.assign(\n        packageContent,\n        getPackageDepFields(packageJsonPath, false),\n      );\n    }\n\n    if (![\n      packageContent.dependencies,\n      packageContent.devDependencies,\n      packageContent.optionalDependencies,\n      packageContent.peerDependencies,\n      packageContent.bundledDependencies,\n    ].some(hasKeys)) {\n      return null;\n    }\n\n    return packageContent;\n  } catch (e) {\n    if (paths.length > 0 && e.code === 'ENOENT') {\n      context.report({\n        message: 'The package.json file could not be found.',\n        loc: { line: 0, column: 0 },\n      });\n    }\n    if (e.name === 'JSONError' || e instanceof SyntaxError) {\n      context.report({\n        message: `The package.json file could not be parsed: ${e.message}`,\n        loc: { line: 0, column: 0 },\n      });\n    }\n\n    return null;\n  }\n}\n\nfunction missingErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies. Run 'npm i -S ${packageName}' to add it`;\n}\n\nfunction devDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not devDependencies.`;\n}\n\nfunction optDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not optionalDependencies.`;\n}\n\nfunction getModuleOriginalName(name) {\n  const [first, second] = name.split('/');\n  return first.startsWith('@') ? `${first}/${second}` : first;\n}\n\nfunction getModuleRealName(resolved) {\n  return getFilePackageName(resolved);\n}\n\nfunction checkDependencyDeclaration(deps, packageName, declarationStatus) {\n  const newDeclarationStatus = declarationStatus || {\n    isInDeps: false,\n    isInDevDeps: false,\n    isInOptDeps: false,\n    isInPeerDeps: false,\n    isInBundledDeps: false,\n  };\n\n  // in case of sub package.json inside a module\n  // check the dependencies on all hierarchy\n  const packageHierarchy = [];\n  const packageNameParts = packageName ? packageName.split('/') : [];\n  packageNameParts.forEach((namePart, index) => {\n    if (!namePart.startsWith('@')) {\n      const ancestor = packageNameParts.slice(0, index + 1).join('/');\n      packageHierarchy.push(ancestor);\n    }\n  });\n\n  return packageHierarchy.reduce((result, ancestorName) => ({\n    isInDeps: result.isInDeps || deps.dependencies[ancestorName] !== undefined,\n    isInDevDeps: result.isInDevDeps || deps.devDependencies[ancestorName] !== undefined,\n    isInOptDeps: result.isInOptDeps || deps.optionalDependencies[ancestorName] !== undefined,\n    isInPeerDeps: result.isInPeerDeps || deps.peerDependencies[ancestorName] !== undefined,\n    isInBundledDeps:\n        result.isInBundledDeps || deps.bundledDependencies.indexOf(ancestorName) !== -1,\n  }), newDeclarationStatus);\n}\n\nfunction reportIfMissing(context, deps, depsOptions, node, name) {\n  // Do not report when importing types unless option is enabled\n  if (\n    !depsOptions.verifyTypeImports\n    && (\n      node.importKind === 'type'\n      || node.importKind === 'typeof'\n      || Array.isArray(node.specifiers) && node.specifiers.length && node.specifiers.every((specifier) => specifier.importKind === 'type' || specifier.importKind === 'typeof')\n    )\n  ) {\n    return;\n  }\n\n  const typeOfImport = importType(name, context);\n\n  if (\n    typeOfImport !== 'external'\n    && (typeOfImport !== 'internal' || !depsOptions.verifyInternalDeps)\n  ) {\n    return;\n  }\n\n  const resolved = resolve(name, context);\n  if (!resolved) { return; }\n\n  const importPackageName = getModuleOriginalName(name);\n  let declarationStatus = checkDependencyDeclaration(deps, importPackageName);\n\n  if (\n    declarationStatus.isInDeps\n    || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n    || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n    || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n    || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n  ) {\n    return;\n  }\n\n  // test the real name from the resolved package.json\n  // if not aliased imports (alias/react for example), importPackageName can be misinterpreted\n  const realPackageName = getModuleRealName(resolved);\n  if (realPackageName && realPackageName !== importPackageName) {\n    declarationStatus = checkDependencyDeclaration(deps, realPackageName, declarationStatus);\n\n    if (\n      declarationStatus.isInDeps\n      || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n      || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n      || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n      || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n    ) {\n      return;\n    }\n  }\n\n  if (declarationStatus.isInDevDeps && !depsOptions.allowDevDeps) {\n    context.report(node, devDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  if (declarationStatus.isInOptDeps && !depsOptions.allowOptDeps) {\n    context.report(node, optDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  context.report(node, missingErrorMessage(realPackageName || importPackageName));\n}\n\nfunction testConfig(config, filename) {\n  // Simplest configuration first, either a boolean or nothing.\n  if (typeof config === 'boolean' || typeof config === 'undefined') {\n    return config;\n  }\n  // Array of globs.\n  return config.some((c) => minimatch(filename, c)\n    || minimatch(filename, path.join(process.cwd(), c)),\n  );\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid the use of extraneous packages.',\n      url: docsUrl('no-extraneous-dependencies'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          devDependencies: { type: ['boolean', 'array'] },\n          optionalDependencies: { type: ['boolean', 'array'] },\n          peerDependencies: { type: ['boolean', 'array'] },\n          bundledDependencies: { type: ['boolean', 'array'] },\n          packageDir: { type: ['string', 'array'] },\n          includeInternal: { type: ['boolean'] },\n          includeTypes: { type: ['boolean'] },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const options = context.options[0] || {};\n    const filename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    const deps = getDependencies(context, options.packageDir) || extractDepFields({});\n\n    const depsOptions = {\n      allowDevDeps: testConfig(options.devDependencies, filename) !== false,\n      allowOptDeps: testConfig(options.optionalDependencies, filename) !== false,\n      allowPeerDeps: testConfig(options.peerDependencies, filename) !== false,\n      allowBundledDeps: testConfig(options.bundledDependencies, filename) !== false,\n      verifyInternalDeps: !!options.includeInternal,\n      verifyTypeImports: !!options.includeTypes,\n    };\n\n    return moduleVisitor((source, node) => {\n      reportIfMissing(context, deps, depsOptions, node, source.value);\n    }, { commonjs: true });\n  },\n\n  'Program:exit'() {\n    depFieldCache.clear();\n  },\n};\n"]}

data/node_modules/eslint-plugin-import/lib/rules/no-import-module-exports.js

@@ -0,0 +1,85 @@
+'use strict';var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
+var _path = require('path');var _path2 = _interopRequireDefault(_path);
+var _pkgUp = require('eslint-module-utils/pkgUp');var _pkgUp2 = _interopRequireDefault(_pkgUp);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+function getEntryPoint(context) {
+  var pkgPath = (0, _pkgUp2['default'])({ cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename() });
+  try {
+    return require.resolve(_path2['default'].dirname(pkgPath));
+  } catch (error) {
+    // Assume the package has no entrypoint (e.g. CLI packages)
+    // in which case require.resolve would throw.
+    return null;
+  }
+}
+
+function findScope(context, identifier) {var _context$getSourceCod =
+  context.getSourceCode(),scopeManager = _context$getSourceCod.scopeManager;
+
+  return scopeManager && scopeManager.scopes.slice().reverse().find(function (scope) {return scope.variables.some(function (variable) {return variable.identifiers.some(function (node) {return node.name === identifier;});});});
+}
+
+function findDefinition(objectScope, identifier) {
+  var variable = objectScope.variables.find(function (variable) {return variable.name === identifier;});
+  return variable.defs.find(function (def) {return def.name.name === identifier;});
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      category: 'Module systems',
+      description: 'Forbid import statements with CommonJS module.exports.',
+      recommended: true },
+
+    fixable: 'code',
+    schema: [
+    {
+      type: 'object',
+      properties: {
+        exceptions: { type: 'array' } },
+
+      additionalProperties: false }] },
+
+
+
+  create: function () {function create(context) {
+      var importDeclarations = [];
+      var entryPoint = getEntryPoint(context);
+      var options = context.options[0] || {};
+      var alreadyReported = false;
+
+      function report(node) {
+        var fileName = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();
+        var isEntryPoint = entryPoint === fileName;
+        var isIdentifier = node.object.type === 'Identifier';
+        var hasKeywords = /^(module|exports)$/.test(node.object.name);
+        var objectScope = hasKeywords && findScope(context, node.object.name);
+        var variableDefinition = objectScope && findDefinition(objectScope, node.object.name);
+        var isImportBinding = variableDefinition && variableDefinition.type === 'ImportBinding';
+        var hasCJSExportReference = hasKeywords && (!objectScope || objectScope.type === 'module');
+        var isException = !!options.exceptions && options.exceptions.some(function (glob) {return (0, _minimatch2['default'])(fileName, glob);});
+
+        if (isIdentifier && hasCJSExportReference && !isEntryPoint && !isException && !isImportBinding) {
+          importDeclarations.forEach(function (importDeclaration) {
+            context.report({
+              node: importDeclaration,
+              message: 'Cannot use import declarations in modules that export using CommonJS (module.exports = \'foo\' or exports.bar = \'hi\')' });
+
+          });
+          alreadyReported = true;
+        }
+      }
+
+      return {
+        ImportDeclaration: function () {function ImportDeclaration(node) {
+            importDeclarations.push(node);
+          }return ImportDeclaration;}(),
+        MemberExpression: function () {function MemberExpression(node) {
+            if (!alreadyReported) {
+              report(node);
+            }
+          }return MemberExpression;}() };
+
+    }return create;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-import-module-exports.js"],"names":["getEntryPoint","context","pkgPath","cwd","getPhysicalFilename","getFilename","require","resolve","path","dirname","error","findScope","identifier","getSourceCode","scopeManager","scopes","slice","reverse","find","scope","variables","some","variable","identifiers","node","name","findDefinition","objectScope","defs","def","module","exports","meta","type","docs","category","description","recommended","fixable","schema","properties","exceptions","additionalProperties","create","importDeclarations","entryPoint","options","alreadyReported","report","fileName","isEntryPoint","isIdentifier","object","hasKeywords","test","variableDefinition","isImportBinding","hasCJSExportReference","isException","glob","forEach","importDeclaration","message","ImportDeclaration","push","MemberExpression"],"mappings":"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","file":"no-import-module-exports.js","sourcesContent":["import minimatch from 'minimatch';\nimport path from 'path';\nimport pkgUp from 'eslint-module-utils/pkgUp';\n\nfunction getEntryPoint(context) {\n  const pkgPath = pkgUp({ cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename() });\n  try {\n    return require.resolve(path.dirname(pkgPath));\n  } catch (error) {\n    // Assume the package has no entrypoint (e.g. CLI packages)\n    // in which case require.resolve would throw.\n    return null;\n  }\n}\n\nfunction findScope(context, identifier) {\n  const { scopeManager } = context.getSourceCode();\n\n  return scopeManager && scopeManager.scopes.slice().reverse().find((scope) => scope.variables.some((variable) => variable.identifiers.some((node) => node.name === identifier)));\n}\n\nfunction findDefinition(objectScope, identifier) {\n  const variable = objectScope.variables.find((variable) => variable.name === identifier);\n  return variable.defs.find((def) => def.name.name === identifier);\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Module systems',\n      description: 'Forbid import statements with CommonJS module.exports.',\n      recommended: true,\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          exceptions: { type: 'array' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n  create(context) {\n    const importDeclarations = [];\n    const entryPoint = getEntryPoint(context);\n    const options = context.options[0] || {};\n    let alreadyReported = false;\n\n    function report(node) {\n      const fileName = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n      const isEntryPoint = entryPoint === fileName;\n      const isIdentifier = node.object.type === 'Identifier';\n      const hasKeywords = (/^(module|exports)$/).test(node.object.name);\n      const objectScope = hasKeywords && findScope(context, node.object.name);\n      const variableDefinition = objectScope && findDefinition(objectScope, node.object.name);\n      const isImportBinding = variableDefinition && variableDefinition.type === 'ImportBinding';\n      const hasCJSExportReference = hasKeywords && (!objectScope || objectScope.type === 'module');\n      const isException = !!options.exceptions && options.exceptions.some((glob) => minimatch(fileName, glob));\n\n      if (isIdentifier && hasCJSExportReference && !isEntryPoint && !isException && !isImportBinding) {\n        importDeclarations.forEach((importDeclaration) => {\n          context.report({\n            node: importDeclaration,\n            message: `Cannot use import declarations in modules that export using CommonJS (module.exports = 'foo' or exports.bar = 'hi')`,\n          });\n        });\n        alreadyReported = true;\n      }\n    }\n\n    return {\n      ImportDeclaration(node) {\n        importDeclarations.push(node);\n      },\n      MemberExpression(node) {\n        if (!alreadyReported) {\n          report(node);\n        }\n      },\n    };\n  },\n};\n"]}

data/node_modules/eslint-plugin-import/lib/rules/no-internal-modules.js

@@ -0,0 +1,144 @@
+'use strict';var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
+
+var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
+var _importType = require('../core/importType');var _importType2 = _interopRequireDefault(_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 };}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      category: 'Static analysis',
+      description: 'Forbid importing the submodules of other modules.',
+      url: (0, _docsUrl2['default'])('no-internal-modules') },
+
+
+    schema: [
+    {
+      anyOf: [
+      {
+        type: 'object',
+        properties: {
+          allow: {
+            type: 'array',
+            items: {
+              type: 'string' } } },
+
+
+
+        additionalProperties: false },
+
+      {
+        type: 'object',
+        properties: {
+          forbid: {
+            type: 'array',
+            items: {
+              type: 'string' } } },
+
+
+
+        additionalProperties: false }] }] },
+
+
+
+
+
+
+  create: function () {function noReachingInside(context) {
+      var options = context.options[0] || {};
+      var allowRegexps = (options.allow || []).map(function (p) {return _minimatch2['default'].makeRe(p);});
+      var forbidRegexps = (options.forbid || []).map(function (p) {return _minimatch2['default'].makeRe(p);});
+
+      // minimatch patterns are expected to use / path separators, like import
+      // statements, so normalize paths to use the same
+      function normalizeSep(somePath) {
+        return somePath.split('\\').join('/');
+      }
+
+      function toSteps(somePath) {
+        return normalizeSep(somePath).
+        split('/').
+        filter(function (step) {return step && step !== '.';}).
+        reduce(function (acc, step) {
+          if (step === '..') {
+            return acc.slice(0, -1);
+          }
+          return acc.concat(step);
+        }, []);
+      }
+
+      // test if reaching to this destination is allowed
+      function reachingAllowed(importPath) {
+        return allowRegexps.some(function (re) {return re.test(importPath);});
+      }
+
+      // test if reaching to this destination is forbidden
+      function reachingForbidden(importPath) {
+        return forbidRegexps.some(function (re) {return re.test(importPath);});
+      }
+
+      function isAllowViolation(importPath) {
+        var steps = toSteps(importPath);
+
+        var nonScopeSteps = steps.filter(function (step) {return step.indexOf('@') !== 0;});
+        if (nonScopeSteps.length <= 1) {return false;}
+
+        // before trying to resolve, see if the raw import (with relative
+        // segments resolved) matches an allowed pattern
+        var justSteps = steps.join('/');
+        if (reachingAllowed(justSteps) || reachingAllowed('/' + String(justSteps))) {return false;}
+
+        // if the import statement doesn't match directly, try to match the
+        // resolved path if the import is resolvable
+        var resolved = (0, _resolve2['default'])(importPath, context);
+        if (!resolved || reachingAllowed(normalizeSep(resolved))) {return false;}
+
+        // this import was not allowed by the allowed paths, and reaches
+        // so it is a violation
+        return true;
+      }
+
+      function isForbidViolation(importPath) {
+        var steps = toSteps(importPath);
+
+        // before trying to resolve, see if the raw import (with relative
+        // segments resolved) matches a forbidden pattern
+        var justSteps = steps.join('/');
+
+        if (reachingForbidden(justSteps) || reachingForbidden('/' + String(justSteps))) {return true;}
+
+        // if the import statement doesn't match directly, try to match the
+        // resolved path if the import is resolvable
+        var resolved = (0, _resolve2['default'])(importPath, context);
+        if (resolved && reachingForbidden(normalizeSep(resolved))) {return true;}
+
+        // this import was not forbidden by the forbidden paths so it is not a violation
+        return false;
+      }
+
+      // find a directory that is being reached into, but which shouldn't be
+      var isReachViolation = options.forbid ? isForbidViolation : isAllowViolation;
+
+      function checkImportForReaching(importPath, node) {
+        var potentialViolationTypes = ['parent', 'index', 'sibling', 'external', 'internal'];
+        if (
+        potentialViolationTypes.indexOf((0, _importType2['default'])(importPath, context)) !== -1 &&
+        isReachViolation(importPath))
+        {
+          context.report({
+            node: node,
+            message: 'Reaching to "' + String(importPath) + '" is not allowed.' });
+
+        }
+      }
+
+      return (0, _moduleVisitor2['default'])(
+      function (source) {
+        checkImportForReaching(source.value, source);
+      },
+      { commonjs: true });
+
+    }return noReachingInside;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-internal-modules.js"],"names":["module","exports","meta","type","docs","category","description","url","schema","anyOf","properties","allow","items","additionalProperties","forbid","create","noReachingInside","context","options","allowRegexps","map","p","minimatch","makeRe","forbidRegexps","normalizeSep","somePath","split","join","toSteps","filter","step","reduce","acc","slice","concat","reachingAllowed","importPath","some","re","test","reachingForbidden","isAllowViolation","steps","nonScopeSteps","indexOf","length","justSteps","resolved","isForbidViolation","isReachViolation","checkImportForReaching","node","potentialViolationTypes","report","message","source","value","commonjs"],"mappings":"aAAA,sC;;AAEA,sD;AACA,gD;AACA,kE;AACA,qC;;AAEAA,OAAOC,OAAP,GAAiB;AACfC,QAAM;AACJC,UAAM,YADF;AAEJC,UAAM;AACJC,gBAAU,iBADN;AAEJC,mBAAa,mDAFT;AAGJC,WAAK,0BAAQ,qBAAR,CAHD,EAFF;;;AAQJC,YAAQ;AACN;AACEC,aAAO;AACL;AACEN,cAAM,QADR;AAEEO,oBAAY;AACVC,iBAAO;AACLR,kBAAM,OADD;AAELS,mBAAO;AACLT,oBAAM,QADD,EAFF,EADG,EAFd;;;;AAUEU,8BAAsB,KAVxB,EADK;;AAaL;AACEV,cAAM,QADR;AAEEO,oBAAY;AACVI,kBAAQ;AACNX,kBAAM,OADA;AAENS,mBAAO;AACLT,oBAAM,QADD,EAFD,EADE,EAFd;;;;AAUEU,8BAAsB,KAVxB,EAbK,CADT,EADM,CARJ,EADS;;;;;;;AAyCfE,uBAAQ,SAASC,gBAAT,CAA0BC,OAA1B,EAAmC;AACzC,UAAMC,UAAUD,QAAQC,OAAR,CAAgB,CAAhB,KAAsB,EAAtC;AACA,UAAMC,eAAe,CAACD,QAAQP,KAAR,IAAiB,EAAlB,EAAsBS,GAAtB,CAA0B,UAACC,CAAD,UAAOC,uBAAUC,MAAV,CAAiBF,CAAjB,CAAP,EAA1B,CAArB;AACA,UAAMG,gBAAgB,CAACN,QAAQJ,MAAR,IAAkB,EAAnB,EAAuBM,GAAvB,CAA2B,UAACC,CAAD,UAAOC,uBAAUC,MAAV,CAAiBF,CAAjB,CAAP,EAA3B,CAAtB;;AAEA;AACA;AACA,eAASI,YAAT,CAAsBC,QAAtB,EAAgC;AAC9B,eAAOA,SAASC,KAAT,CAAe,IAAf,EAAqBC,IAArB,CAA0B,GAA1B,CAAP;AACD;;AAED,eAASC,OAAT,CAAiBH,QAAjB,EAA2B;AACzB,eAAOD,aAAaC,QAAb;AACJC,aADI,CACE,GADF;AAEJG,cAFI,CAEG,UAACC,IAAD,UAAUA,QAAQA,SAAS,GAA3B,EAFH;AAGJC,cAHI,CAGG,UAACC,GAAD,EAAMF,IAAN,EAAe;AACrB,cAAIA,SAAS,IAAb,EAAmB;AACjB,mBAAOE,IAAIC,KAAJ,CAAU,CAAV,EAAa,CAAC,CAAd,CAAP;AACD;AACD,iBAAOD,IAAIE,MAAJ,CAAWJ,IAAX,CAAP;AACD,SARI,EAQF,EARE,CAAP;AASD;;AAED;AACA,eAASK,eAAT,CAAyBC,UAAzB,EAAqC;AACnC,eAAOlB,aAAamB,IAAb,CAAkB,UAACC,EAAD,UAAQA,GAAGC,IAAH,CAAQH,UAAR,CAAR,EAAlB,CAAP;AACD;;AAED;AACA,eAASI,iBAAT,CAA2BJ,UAA3B,EAAuC;AACrC,eAAOb,cAAcc,IAAd,CAAmB,UAACC,EAAD,UAAQA,GAAGC,IAAH,CAAQH,UAAR,CAAR,EAAnB,CAAP;AACD;;AAED,eAASK,gBAAT,CAA0BL,UAA1B,EAAsC;AACpC,YAAMM,QAAQd,QAAQQ,UAAR,CAAd;;AAEA,YAAMO,gBAAgBD,MAAMb,MAAN,CAAa,UAACC,IAAD,UAAUA,KAAKc,OAAL,CAAa,GAAb,MAAsB,CAAhC,EAAb,CAAtB;AACA,YAAID,cAAcE,MAAd,IAAwB,CAA5B,EAA+B,CAAE,OAAO,KAAP,CAAe;;AAEhD;AACA;AACA,YAAMC,YAAYJ,MAAMf,IAAN,CAAW,GAAX,CAAlB;AACA,YAAIQ,gBAAgBW,SAAhB,KAA8BX,6BAAoBW,SAApB,EAAlC,EAAoE,CAAE,OAAO,KAAP,CAAe;;AAErF;AACA;AACA,YAAMC,WAAW,0BAAQX,UAAR,EAAoBpB,OAApB,CAAjB;AACA,YAAI,CAAC+B,QAAD,IAAaZ,gBAAgBX,aAAauB,QAAb,CAAhB,CAAjB,EAA0D,CAAE,OAAO,KAAP,CAAe;;AAE3E;AACA;AACA,eAAO,IAAP;AACD;;AAED,eAASC,iBAAT,CAA2BZ,UAA3B,EAAuC;AACrC,YAAMM,QAAQd,QAAQQ,UAAR,CAAd;;AAEA;AACA;AACA,YAAMU,YAAYJ,MAAMf,IAAN,CAAW,GAAX,CAAlB;;AAEA,YAAIa,kBAAkBM,SAAlB,KAAgCN,+BAAsBM,SAAtB,EAApC,EAAwE,CAAE,OAAO,IAAP,CAAc;;AAExF;AACA;AACA,YAAMC,WAAW,0BAAQX,UAAR,EAAoBpB,OAApB,CAAjB;AACA,YAAI+B,YAAYP,kBAAkBhB,aAAauB,QAAb,CAAlB,CAAhB,EAA2D,CAAE,OAAO,IAAP,CAAc;;AAE3E;AACA,eAAO,KAAP;AACD;;AAED;AACA,UAAME,mBAAmBhC,QAAQJ,MAAR,GAAiBmC,iBAAjB,GAAqCP,gBAA9D;;AAEA,eAASS,sBAAT,CAAgCd,UAAhC,EAA4Ce,IAA5C,EAAkD;AAChD,YAAMC,0BAA0B,CAAC,QAAD,EAAW,OAAX,EAAoB,SAApB,EAA+B,UAA/B,EAA2C,UAA3C,CAAhC;AACA;AACEA,gCAAwBR,OAAxB,CAAgC,6BAAWR,UAAX,EAAuBpB,OAAvB,CAAhC,MAAqE,CAAC,CAAtE;AACGiC,yBAAiBb,UAAjB,CAFL;AAGE;AACApB,kBAAQqC,MAAR,CAAe;AACbF,sBADa;AAEbG,8CAAyBlB,UAAzB,uBAFa,EAAf;;AAID;AACF;;AAED,aAAO;AACL,gBAACmB,MAAD,EAAY;AACVL,+BAAuBK,OAAOC,KAA9B,EAAqCD,MAArC;AACD,OAHI;AAIL,QAAEE,UAAU,IAAZ,EAJK,CAAP;;AAMD,KA9FD,OAAiB1C,gBAAjB,IAzCe,EAAjB","file":"no-internal-modules.js","sourcesContent":["import minimatch from 'minimatch';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport importType from '../core/importType';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Static analysis',\n      description: 'Forbid importing the submodules of other modules.',\n      url: docsUrl('no-internal-modules'),\n    },\n\n    schema: [\n      {\n        anyOf: [\n          {\n            type: 'object',\n            properties: {\n              allow: {\n                type: 'array',\n                items: {\n                  type: 'string',\n                },\n              },\n            },\n            additionalProperties: false,\n          },\n          {\n            type: 'object',\n            properties: {\n              forbid: {\n                type: 'array',\n                items: {\n                  type: 'string',\n                },\n              },\n            },\n            additionalProperties: false,\n          },\n        ],\n      },\n    ],\n  },\n\n  create: function noReachingInside(context) {\n    const options = context.options[0] || {};\n    const allowRegexps = (options.allow || []).map((p) => minimatch.makeRe(p));\n    const forbidRegexps = (options.forbid || []).map((p) => minimatch.makeRe(p));\n\n    // minimatch patterns are expected to use / path separators, like import\n    // statements, so normalize paths to use the same\n    function normalizeSep(somePath) {\n      return somePath.split('\\\\').join('/');\n    }\n\n    function toSteps(somePath) {\n      return normalizeSep(somePath)\n        .split('/')\n        .filter((step) => step && step !== '.')\n        .reduce((acc, step) => {\n          if (step === '..') {\n            return acc.slice(0, -1);\n          }\n          return acc.concat(step);\n        }, []);\n    }\n\n    // test if reaching to this destination is allowed\n    function reachingAllowed(importPath) {\n      return allowRegexps.some((re) => re.test(importPath));\n    }\n\n    // test if reaching to this destination is forbidden\n    function reachingForbidden(importPath) {\n      return forbidRegexps.some((re) => re.test(importPath));\n    }\n\n    function isAllowViolation(importPath) {\n      const steps = toSteps(importPath);\n\n      const nonScopeSteps = steps.filter((step) => step.indexOf('@') !== 0);\n      if (nonScopeSteps.length <= 1) { return false; }\n\n      // before trying to resolve, see if the raw import (with relative\n      // segments resolved) matches an allowed pattern\n      const justSteps = steps.join('/');\n      if (reachingAllowed(justSteps) || reachingAllowed(`/${justSteps}`)) { return false; }\n\n      // if the import statement doesn't match directly, try to match the\n      // resolved path if the import is resolvable\n      const resolved = resolve(importPath, context);\n      if (!resolved || reachingAllowed(normalizeSep(resolved))) { return false; }\n\n      // this import was not allowed by the allowed paths, and reaches\n      // so it is a violation\n      return true;\n    }\n\n    function isForbidViolation(importPath) {\n      const steps = toSteps(importPath);\n\n      // before trying to resolve, see if the raw import (with relative\n      // segments resolved) matches a forbidden pattern\n      const justSteps = steps.join('/');\n\n      if (reachingForbidden(justSteps) || reachingForbidden(`/${justSteps}`)) { return true; }\n\n      // if the import statement doesn't match directly, try to match the\n      // resolved path if the import is resolvable\n      const resolved = resolve(importPath, context);\n      if (resolved && reachingForbidden(normalizeSep(resolved))) { return true; }\n\n      // this import was not forbidden by the forbidden paths so it is not a violation\n      return false;\n    }\n\n    // find a directory that is being reached into, but which shouldn't be\n    const isReachViolation = options.forbid ? isForbidViolation : isAllowViolation;\n\n    function checkImportForReaching(importPath, node) {\n      const potentialViolationTypes = ['parent', 'index', 'sibling', 'external', 'internal'];\n      if (\n        potentialViolationTypes.indexOf(importType(importPath, context)) !== -1\n        && isReachViolation(importPath)\n      ) {\n        context.report({\n          node,\n          message: `Reaching to \"${importPath}\" is not allowed.`,\n        });\n      }\n    }\n\n    return moduleVisitor(\n      (source) => {\n        checkImportForReaching(source.value, source);\n      },\n      { commonjs: true },\n    );\n  },\n};\n"]}