node_modules/eslint-plugin-import/lib/rules/no-cycle.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");}};}(); /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       * @fileOverview Ensures that no imported module imports the linted module.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       * @author Ben Mosher
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       */

var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap);
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 };}

// todo: cache cycles / deep relationships for faster repeat evaluation
module.exports = {
  meta: {
    type: 'suggestion',
    docs: { url: (0, _docsUrl2.default)('no-cycle') },
    schema: [(0, _moduleVisitor.makeOptionsSchema)({
      maxDepth: {
        oneOf: [
        {
          description: 'maximum dependency depth to traverse',
          type: 'integer',
          minimum: 1 },

        {
          enum: ['∞'],
          type: 'string' }] },



      ignoreExternal: {
        description: 'ignore external modules',
        type: 'boolean',
        default: false } })] },




  create: function (context) {
    const myPath = context.getFilename();
    if (myPath === '<text>') return {}; // can't cycle-check a non-file

    const options = context.options[0] || {};
    const maxDepth = typeof options.maxDepth === 'number' ? options.maxDepth : Infinity;
    const ignoreModule = name => options.ignoreExternal ? (0, _importType.isExternalModule)(name) : false;

    function checkSourceValue(sourceNode, importer) {
      if (ignoreModule(sourceNode.value)) {
        return; // ignore external modules
      }

      const imported = _ExportMap2.default.get(sourceNode.value, context);

      if (importer.importKind === 'type') {
        return; // no Flow import resolution
      }

      if (imported == null) {
        return; // no-unresolved territory
      }

      if (imported.path === myPath) {
        return; // no-self-import territory
      }

      const untraversed = [{ mget: () => imported, route: [] }];
      const traversed = new Set();
      function detectCycle(_ref) {let mget = _ref.mget,route = _ref.route;
        const m = mget();
        if (m == null) return;
        if (traversed.has(m.path)) return;
        traversed.add(m.path);

        for (let _ref2 of m.imports) {var _ref3 = _slicedToArray(_ref2, 2);let path = _ref3[0];var _ref3$ = _ref3[1];let getter = _ref3$.getter;let source = _ref3$.source;
          if (path === myPath) return true;
          if (traversed.has(path)) continue;
          if (ignoreModule(source.value)) continue;
          if (route.length + 1 < maxDepth) {
            untraversed.push({
              mget: getter,
              route: route.concat(source) });

          }
        }
      }

      while (untraversed.length > 0) {
        const next = untraversed.shift(); // bfs!
        if (detectCycle(next)) {
          const message = next.route.length > 0 ?
          `Dependency cycle via ${routeString(next.route)}` :
          'Dependency cycle detected.';
          context.report(importer, message);
          return;
        }
      }
    }

    return (0, _moduleVisitor2.default)(checkSourceValue, context.options[0]);
  } };


function routeString(route) {
  return route.map(s => `${s.value}:${s.loc.start.line}`).join('=>');
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-cycle.js"],"names":["module","exports","meta","type","docs","url","schema","maxDepth","oneOf","description","minimum","enum","ignoreExternal","default","create","context","myPath","getFilename","options","Infinity","ignoreModule","name","checkSourceValue","sourceNode","importer","value","imported","Exports","get","importKind","path","untraversed","mget","route","traversed","Set","detectCycle","m","has","add","imports","getter","source","length","push","concat","next","shift","message","routeString","report","map","s","loc","start","line","join"],"mappings":"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","file":"no-cycle.js","sourcesContent":["/**\n * @fileOverview Ensures that no imported module imports the linted module.\n * @author Ben Mosher\n */\n\nimport Exports from '../ExportMap'\nimport { isExternalModule } from '../core/importType'\nimport moduleVisitor, { makeOptionsSchema } from 'eslint-module-utils/moduleVisitor'\nimport docsUrl from '../docsUrl'\n\n// todo: cache cycles / deep relationships for faster repeat evaluation\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: { url: docsUrl('no-cycle') },\n    schema: [makeOptionsSchema({\n      maxDepth: {\n        oneOf: [\n          {\n            description: 'maximum dependency depth to traverse',\n            type: 'integer',\n            minimum: 1,\n          },\n          {\n            enum: ['∞'],\n            type: 'string',\n          },\n        ],\n      },\n      ignoreExternal: {\n        description: 'ignore external modules',\n        type: 'boolean',\n        default: false,\n      },\n    })],\n  },\n\n  create: function (context) {\n    const myPath = context.getFilename()\n    if (myPath === '<text>') return {} // can't cycle-check a non-file\n\n    const options = context.options[0] || {}\n    const maxDepth = typeof options.maxDepth === 'number' ? options.maxDepth : Infinity\n    const ignoreModule = (name) => options.ignoreExternal ? isExternalModule(name) : false\n\n    function checkSourceValue(sourceNode, importer) {\n      if (ignoreModule(sourceNode.value)) {\n        return // ignore external modules\n      }\n\n      const imported = Exports.get(sourceNode.value, context)\n\n      if (importer.importKind === 'type') {\n        return // no Flow import resolution\n      }\n\n      if (imported == null) {\n        return  // no-unresolved territory\n      }\n\n      if (imported.path === myPath) {\n        return  // no-self-import territory\n      }\n\n      const untraversed = [{mget: () => imported, route:[]}]\n      const traversed = new Set()\n      function detectCycle({mget, route}) {\n        const m = mget()\n        if (m == null) return\n        if (traversed.has(m.path)) return\n        traversed.add(m.path)\n\n        for (let [path, { getter, source }] of m.imports) {\n          if (path === myPath) return true\n          if (traversed.has(path)) continue\n          if (ignoreModule(source.value)) continue\n          if (route.length + 1 < maxDepth) {\n            untraversed.push({\n              mget: getter,\n              route: route.concat(source),\n            })\n          }\n        }\n      }\n\n      while (untraversed.length > 0) {\n        const next = untraversed.shift() // bfs!\n        if (detectCycle(next)) {\n          const message = (next.route.length > 0\n            ? `Dependency cycle via ${routeString(next.route)}`\n            : 'Dependency cycle detected.')\n          context.report(importer, message)\n          return\n        }\n      }\n    }\n\n    return moduleVisitor(checkSourceValue, context.options[0])\n  },\n}\n\nfunction routeString(route) {\n  return route.map(s => `${s.value}:${s.loc.start.line}`).join('=>')\n}\n"]}