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

'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 _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 _staticRequire = require('../core/staticRequire');var _staticRequire2 = _interopRequireDefault(_staticRequire);
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: (0, _docsUrl2.default)('no-internal-modules') },


    schema: [
    {
      type: 'object',
      properties: {
        allow: {
          type: 'array',
          items: {
            type: 'string' } } },



      additionalProperties: false }] },




  create: function noReachingInside(context) {
    const options = context.options[0] || {};
    const allowRegexps = (options.allow || []).map(p => _minimatch2.default.makeRe(p));

    // test if reaching to this destination is allowed
    function reachingAllowed(importPath) {
      return allowRegexps.some(re => re.test(importPath));
    }

    // 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('/');
    }

    // find a directory that is being reached into, but which shouldn't be
    function isReachViolation(importPath) {
      const steps = normalizeSep(importPath).
      split('/').
      reduce((acc, step) => {
        if (!step || step === '.') {
          return acc;
        } else if (step === '..') {
          return acc.slice(0, -1);
        } else {
          return acc.concat(step);
        }
      }, []);

      const nonScopeSteps = steps.filter(step => 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
      const justSteps = steps.join('/');
      if (reachingAllowed(justSteps) || reachingAllowed(`/${justSteps}`)) return false;

      // if the import statement doesn't match directly, try to match the
      // resolved path if the import is resolvable
      const 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 checkImportForReaching(importPath, node) {
      const potentialViolationTypes = ['parent', 'index', 'sibling', 'external', 'internal'];
      if (potentialViolationTypes.indexOf((0, _importType2.default)(importPath, context)) !== -1 &&
      isReachViolation(importPath))
      {
        context.report({
          node,
          message: `Reaching to "${importPath}" is not allowed.` });

      }
    }

    return {
      ImportDeclaration(node) {
        checkImportForReaching(node.source.value, node.source);
      },
      ExportAllDeclaration(node) {
        checkImportForReaching(node.source.value, node.source);
      },
      ExportNamedDeclaration(node) {
        if (node.source) {
          checkImportForReaching(node.source.value, node.source);
        }
      },
      CallExpression(node) {
        if ((0, _staticRequire2.default)(node)) {var _node$arguments = _slicedToArray(
          node.arguments, 1);const firstArgument = _node$arguments[0];
          checkImportForReaching(firstArgument.value, firstArgument);
        }
      } };

  } };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-internal-modules.js"],"names":["module","exports","meta","type","docs","url","schema","properties","allow","items","additionalProperties","create","noReachingInside","context","options","allowRegexps","map","p","minimatch","makeRe","reachingAllowed","importPath","some","re","test","normalizeSep","somePath","split","join","isReachViolation","steps","reduce","acc","step","slice","concat","nonScopeSteps","filter","indexOf","length","justSteps","resolved","checkImportForReaching","node","potentialViolationTypes","report","message","ImportDeclaration","source","value","ExportAllDeclaration","ExportNamedDeclaration","CallExpression","arguments","firstArgument"],"mappings":"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","file":"no-internal-modules.js","sourcesContent":["import minimatch from 'minimatch'\n\nimport resolve from 'eslint-module-utils/resolve'\nimport importType from '../core/importType'\nimport isStaticRequire from '../core/staticRequire'\nimport docsUrl from '../docsUrl'\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      url: docsUrl('no-internal-modules'),\n    },\n\n    schema: [\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  },\n\n  create: function noReachingInside(context) {\n    const options = context.options[0] || {}\n    const allowRegexps = (options.allow || []).map(p => minimatch.makeRe(p))\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    // 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    // find a directory that is being reached into, but which shouldn't be\n    function isReachViolation(importPath) {\n      const steps = normalizeSep(importPath)\n        .split('/')\n        .reduce((acc, step) => {\n          if (!step || step === '.') {\n            return acc\n          } else if (step === '..') {\n            return acc.slice(0, -1)\n          } else {\n            return acc.concat(step)\n          }\n        }, [])\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 checkImportForReaching(importPath, node) {\n      const potentialViolationTypes = ['parent', 'index', 'sibling', 'external', 'internal']\n      if (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 {\n      ImportDeclaration(node) {\n        checkImportForReaching(node.source.value, node.source)\n      },\n      ExportAllDeclaration(node) {\n        checkImportForReaching(node.source.value, node.source)\n      },\n      ExportNamedDeclaration(node) {\n        if (node.source) {\n          checkImportForReaching(node.source.value, node.source)\n        }\n      },\n      CallExpression(node) {\n        if (isStaticRequire(node)) {\n          const [ firstArgument ] = node.arguments\n          checkImportForReaching(firstArgument.value, firstArgument)\n        }\n      },\n    }\n  },\n}\n"]}