);var _builder2 = _interopRequireDefault(_builder);
var _scc = require('../scc');var _scc2 = _interopRequireDefault(_scc);
var _importType = require('../core/importType');
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {arr2[i] = arr[i];}return arr2;} else {return Array.from(arr);}}

var traversed = new Set();

function routeString(route) {
  return route.map(function (s) {return String(s.value) + ':' + String(s.loc.start.line);}).join('=>');
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      category: 'Static analysis',
      description: 'Forbid a module from importing a module with a dependency path back to itself.',
      url: (0, _docsUrl2['default'])('no-cycle') },

    schema: [(0, _moduleVisitor.makeOptionsSchema)({
      maxDepth: {
        anyOf: [
        {
          description: 'maximum dependency depth to traverse',
          type: 'integer',
          minimum: 1 },

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



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

      allowUnsafeDynamicCyclicDependency: {
        description: 'Allow cyclic dependency if there is at least one dynamic import in the chain',
        type: 'boolean',
        'default': false },

      disableScc: {
        description: 'When true, don\'t calculate a strongly-connected-components graph. SCC is used to reduce the time-complexity of cycle detection, but adds overhead.',
        type: 'boolean',
        'default': false } })] },




  create: function () {function create(context) {
      var myPath = (0, _contextCompat.getPhysicalFilename)(context);
      if (myPath === '<text>') {return {};} // can't cycle-check a non-file

      var options = context.options[0] || {};
      var maxDepth = typeof options.maxDepth === 'number' ? options.maxDepth : Infinity;
      var ignoreModule = function () {function ignoreModule(name) {return options.ignoreExternal && (0, _importType.isExternalModule)(
          name,
          (0, _resolve2['default'])(name, context),
          context);}return ignoreModule;}();


      var scc = options.disableScc ? {} : _scc2['default'].get(myPath, context);

      function checkSourceValue(sourceNode, importer) {
        if (ignoreModule(sourceNode.value)) {
          return; // ignore external modules
        }
        if (
        options.allowUnsafeDynamicCyclicDependency && (
        // Ignore `import()`
        importer.type === 'ImportExpression'
        // `require()` calls are always checked (if possible)
        || importer.type === 'CallExpression' && importer.callee.name !== 'require'))

        {
          return; // cycle via dynamic import allowed by config
        }

        if (
        importer.type === 'ImportDeclaration' && (
        // import type { Foo } (TS and Flow)
        importer.importKind === 'type'
        // import { type Foo } (Flow)
        || importer.specifiers.every(function (_ref) {var importKind = _ref.importKind;return importKind === 'type';})))

        {
          return; // ignore type imports
        }

        var imported = _builder2['default'].get(sourceNode.value, context);

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

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

        /* If we're in the same Strongly Connected Component,
           * Then there exists a path from each node in the SCC to every other node in the SCC,
           * Then there exists at least one path from them to us and from us to them,
           * Then we have a cycle between us.
           */
        var hasDependencyCycle = options.disableScc || scc[myPath] === scc[imported.path];
        if (!hasDependencyCycle) {
          return;
        }

        var untraversed = [{ mget: function () {function mget() {return imported;}return mget;}(), route: [] }];
        function detectCycle(_ref2) {var mget = _ref2.mget,route = _ref2.route;
          var m = mget();
          if (m == null) {return;}
          if (traversed.has(m.path)) {return;}
          traversed.add(m.path);var _loop = function () {function _loop(

            path, getter, declarations) {
              // If we're in different SCCs, we can't have a circular dependency
              if (!options.disableScc && scc[myPath] !== scc[path]) {return 'continue';}

              if (traversed.has(path)) {return 'continue';}
              var toTraverse = [].concat(_toConsumableArray(declarations)).filter(function (_ref5) {var source = _ref5.source,isOnlyImportingTypes = _ref5.isOnlyImportingTypes;return !ignoreModule(source.value)
                // Ignore only type imports
                && !isOnlyImportingTypes;});


              /*
                                             If cyclic dependency is allowed via dynamic import, skip checking if any module is imported dynamically
                                             */
              if (options.allowUnsafeDynamicCyclicDependency && toTraverse.some(function (d) {return d.dynamic;})) {return { v: void 0 };}

              /*
                                                                                                                                           Only report as a cycle if there are any import declarations that are considered by
                                                                                                                                           the rule. For example:
                                                                                                                                            a.ts:
                                                                                                                                           import { foo } from './b' // should not be reported as a cycle
                                                                                                                                            b.ts:
                                                                                                                                           import type { Bar } from './a'
                                                                                                                                           */


              if (path === myPath && toTraverse.length > 0) {return { v: true };}
              if (route.length + 1 < maxDepth) {
                toTraverse.forEach(function (_ref6) {var source = _ref6.source;
                  untraversed.push({ mget: getter, route: route.concat(source) });
                });
              }}return _loop;}();var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {for (var _iterator = m.imports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var _ref3 = _step.value;var _ref4 = _slicedToArray(_ref3, 2);var path = _ref4[0];var _ref4$ = _ref4[1];var getter = _ref4$.getter;var declarations = _ref4$.declarations;var _ret = _loop(path, getter, declarations);switch (_ret) {case 'continue':continue;default:if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;}
            }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}
        }

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

      return Object.assign((0, _moduleVisitor2['default'])(checkSourceValue, context.options[0]), {
        'Program:exit': function () {function ProgramExit() {
            traversed.clear();
          }return ProgramExit;}() });

    }return create;}() };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-cycle.js"],"names":["traversed","Set","routeString","route","map","s","value","loc","start","line","join","module","exports","meta","type","docs","category","description","url","schema","maxDepth","anyOf","minimum","ignoreExternal","allowUnsafeDynamicCyclicDependency","disableScc","create","context","myPath","options","Infinity","ignoreModule","name","scc","StronglyConnectedComponentsBuilder","get","checkSourceValue","sourceNode","importer","callee","importKind","specifiers","every","imported","ExportMapBuilder","path","hasDependencyCycle","untraversed","mget","detectCycle","m","has","add","getter","declarations","toTraverse","filter","source","isOnlyImportingTypes","some","d","dynamic","length","forEach","push","concat","imports","next","shift","message","report","Object","assign","clear"],"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 { getPhysicalFilename } from 'eslint-module-utils/contextCompat';\nimport moduleVisitor, { makeOptionsSchema } from 'eslint-module-utils/moduleVisitor';\nimport resolve from 'eslint-module-utils/resolve';\n\nimport ExportMapBuilder from '../exportMap/builder';\nimport StronglyConnectedComponentsBuilder from '../scc';\nimport { isExternalModule } from '../core/importType';\nimport docsUrl from '../docsUrl';\n\nconst traversed = new Set();\n\nfunction routeString(route) {\n  return route.map((s) => `${s.value}:${s.loc.start.line}`).join('=>');\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Static analysis',\n      description: 'Forbid a module from importing a module with a dependency path back to itself.',\n      url: docsUrl('no-cycle'),\n    },\n    schema: [makeOptionsSchema({\n      maxDepth: {\n        anyOf: [\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      allowUnsafeDynamicCyclicDependency: {\n        description: 'Allow cyclic dependency if there is at least one dynamic import in the chain',\n        type: 'boolean',\n        default: false,\n      },\n      disableScc: {\n        description: 'When true, don\\'t calculate a strongly-connected-components graph. SCC is used to reduce the time-complexity of cycle detection, but adds overhead.',\n        type: 'boolean',\n        default: false,\n      },\n    })],\n  },\n\n  create(context) {\n    const myPath = getPhysicalFilename(context);\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(\n      name,\n      resolve(name, context),\n      context,\n    );\n\n    const scc = options.disableScc ? {} : StronglyConnectedComponentsBuilder.get(myPath, context);\n\n    function checkSourceValue(sourceNode, importer) {\n      if (ignoreModule(sourceNode.value)) {\n        return; // ignore external modules\n      }\n      if (\n        options.allowUnsafeDynamicCyclicDependency && (\n          // Ignore `import()`\n          importer.type === 'ImportExpression'\n          // `require()` calls are always checked (if possible)\n          || importer.type === 'CallExpression' && importer.callee.name !== 'require'\n        )\n      ) {\n        return; // cycle via dynamic import allowed by config\n      }\n\n      if (\n        importer.type === 'ImportDeclaration' && (\n          // import type { Foo } (TS and Flow)\n          importer.importKind === 'type'\n          // import { type Foo } (Flow)\n          || importer.specifiers.every(({ importKind }) => importKind === 'type')\n        )\n      ) {\n        return; // ignore type imports\n      }\n\n      const imported = ExportMapBuilder.get(sourceNode.value, context);\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      /* If we're in the same Strongly Connected Component,\n       * Then there exists a path from each node in the SCC to every other node in the SCC,\n       * Then there exists at least one path from them to us and from us to them,\n       * Then we have a cycle between us.\n       */\n      const hasDependencyCycle = options.disableScc || scc[myPath] === scc[imported.path];\n      if (!hasDependencyCycle) {\n        return;\n      }\n\n      const untraversed = [{ mget: () => imported, route: [] }];\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 (const [path, { getter, declarations }] of m.imports) {\n          // If we're in different SCCs, we can't have a circular dependency\n          if (!options.disableScc && scc[myPath] !== scc[path]) { continue; }\n\n          if (traversed.has(path)) { continue; }\n          const toTraverse = [...declarations].filter(({ source, isOnlyImportingTypes }) => !ignoreModule(source.value)\n            // Ignore only type imports\n            && !isOnlyImportingTypes,\n          );\n\n          /*\n          If cyclic dependency is allowed via dynamic import, skip checking if any module is imported dynamically\n          */\n          if (options.allowUnsafeDynamicCyclicDependency && toTraverse.some((d) => d.dynamic)) { return; }\n\n          /*\n          Only report as a cycle if there are any import declarations that are considered by\n          the rule. For example:\n\n          a.ts:\n          import { foo } from './b' // should not be reported as a cycle\n\n          b.ts:\n          import type { Bar } from './a'\n          */\n          if (path === myPath && toTraverse.length > 0) { return true; }\n          if (route.length + 1 < maxDepth) {\n            toTraverse.forEach(({ source }) => {\n              untraversed.push({ mget: getter, 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 Object.assign(moduleVisitor(checkSourceValue, context.options[0]), {\n      'Program:exit'() {\n        traversed.clear();\n      },\n    });\n  },\n};\n"]}