eslint-plugin-barrel-rules 1.4.3 → 1.4.4

package/dist/index.cjs

@@ -55,54 +55,124 @@ var Glob = class {
 // src/utils/alias.ts
 var import_tsconfig_paths = require("tsconfig-paths");
 var import_path = __toESM(require("path"), 1);
-var Alias = class {
+var Alias = class _Alias {
   constructor() {
   }
+  /**
+   * Resolves an alias path to an absolute file path
+   *
+   * @param rawPath - The alias path to resolve (e.g., "@entities/user", "@utils")
+   * @param currentFileDir - The directory of the current file (used to find tsconfig.json)
+   * @returns Result object with absolutePath and type ("success" or "fail")
+   *
+   * @example
+   * // With wildcard alias: "@entities/*" -> "src/entities/*"
+   * Alias.resolvePath("@entities/user", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/entities/user", type: "success" }
+   *
+   * @example
+   * // Without wildcard: "@utils" -> "src/utils/index"
+   * Alias.resolvePath("@utils", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/utils/index", type: "success" }
+   */
   static resolvePath(rawPath, currentFileDir) {
     try {
       const configResult = (0, import_tsconfig_paths.loadConfig)(currentFileDir);
-      if (configResult.resultType === "success") {
-        for (const [pattern, targets] of Object.entries(configResult.paths)) {
-          const origin = targets[0];
-          if (pattern.includes("*")) {
-            const patternRegex = new RegExp(
-              `^${pattern.replace("*", "(.*)")}$`
-            );
-            const match = rawPath.match(patternRegex);
-            if (match) {
-              const [, matchedPath] = match;
-              const extendedOrigin = origin.replace("*", matchedPath);
-              const absolutePath = import_path.default.resolve(
-                `${configResult.absoluteBaseUrl}/${extendedOrigin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          } else {
-            if (rawPath === pattern) {
-              const absolutePath = import_path.default.resolve(
-                `${configResult.absoluteBaseUrl}/${origin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          }
+      if (configResult.resultType !== "success") {
+        return this.createFailResult(rawPath);
+      }
+      const { paths, absoluteBaseUrl } = configResult;
+      for (const [aliasPattern, targetPaths] of Object.entries(paths)) {
+        const targetPath = targetPaths[0];
+        const matchResult = this.tryMatchPattern(
+          rawPath,
+          aliasPattern,
+          targetPath,
+          absoluteBaseUrl
+        );
+        if (matchResult) {
+          return matchResult;
         }
       }
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
-    } catch (e) {
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
+      return _Alias.createFailResult(rawPath);
+    } catch (error) {
+      return _Alias.createFailResult(rawPath);
+    }
+  }
+  /**
+   * Attempts to match a raw path against an alias pattern
+   *
+   * @param rawPath - The path to match (e.g., "@entities/user")
+   * @param aliasPattern - The alias pattern from tsconfig (e.g., "@entities/*")
+   * @param targetPath - The target path from tsconfig (e.g., "src/entities/*")
+   * @param baseUrl - The absolute base URL from tsconfig
+   * @returns Success result if matched, null otherwise
+   */
+  static tryMatchPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const hasWildcard = aliasPattern.includes("*");
+    if (hasWildcard) {
+      return this.matchWildcardPattern(
+        rawPath,
+        aliasPattern,
+        targetPath,
+        baseUrl
+      );
+    } else {
+      return this.matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl);
+    }
+  }
+  /**
+   * Matches a wildcard alias pattern (e.g., "@entities/*")
+   *
+   * Pattern: "@entities/*" -> Target: "src/entities/*"
+   * Input: "@entities/user" -> Matches: "user" -> Output: "src/entities/user"
+   *
+   * Note: The original implementation uses simple string replacement for regex,
+   * which works because alias patterns typically don't contain special regex chars.
+   * We maintain this behavior for compatibility.
+   */
+  static matchWildcardPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const regexPattern = `^${aliasPattern.replace(/\*/g, "(.*)")}$`;
+    const regex = new RegExp(regexPattern);
+    const match = rawPath.match(regex);
+    if (!match) {
+      return null;
+    }
+    const capturedPath = match[1];
+    const resolvedTargetPath = targetPath.replace(/\*/g, capturedPath);
+    const absolutePath = import_path.default.resolve(`${baseUrl}/${resolvedTargetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Matches an exact alias pattern (no wildcard)
+   *
+   * Pattern: "@utils" -> Target: "src/utils/index"
+   * Input: "@utils" -> Output: "src/utils/index"
+   */
+  static matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    if (rawPath !== aliasPattern) {
+      return null;
     }
+    const absolutePath = import_path.default.resolve(`${baseUrl}/${targetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Creates a success result
+   */
+  static createSuccessResult(absolutePath) {
+    return {
+      absolutePath,
+      type: "success"
+    };
+  }
+  /**
+   * Creates a fail result
+   */
+  static createFailResult(originalPath) {
+    return {
+      absolutePath: originalPath,
+      type: "fail"
+    };
   }
 };
 
@@ -229,16 +299,16 @@ var enforceBarrelPattern = {
           if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
             return;
           }
-          absoluteImportPath = import_resolve.default.sync(rawImportPath, {
-            basedir: import_path2.default.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
-          });
+          try {
+            absoluteImportPath = import_resolve.default.sync(rawImportPath, {
+              basedir: import_path2.default.dirname(absoluteCurrentFilePath),
+              extensions: RESOLVE_EXTENSIONS
+            });
+          } catch (e) {
+            return;
+          }
         }
       } catch (e) {
-        context.report({
-          node,
-          messageId: "TransformedAliasResolveFailed"
-        });
         return;
       }
       {
@@ -252,8 +322,8 @@ var enforceBarrelPattern = {
             const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
             const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
             const currentFileInEnforceBarrel = absoluteCurrentFilePath.startsWith(closedTargetPath);
-            const importedOutsideOfTargetPath = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
-            const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
+            const importedOutsideOfBarrel = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
+            const invalidImported = !targetPathEntryPointed && importedOutsideOfBarrel;
             if (invalidImported) {
               matchedLatestTargetPath = absoluteTargetPath;
             }
@@ -359,7 +429,7 @@ var isolateBarrelFile = {
               return;
             }
           } else {
-            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/")) {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
               return;
             }
             absoluteImportPath = import_resolve2.default.sync(rawImportPath, {
@@ -374,31 +444,26 @@ var isolateBarrelFile = {
           });
           return;
         }
-        const isolationIndex = absoluteIsolations.findIndex((isolation) => {
-          const absoluteIsolationPath = isolation.isolationPath;
-          const closedIsolationPath = absoluteIsolationPath + "/";
-          return absoluteCurrentFilePath.startsWith(closedIsolationPath);
-        });
-        const matchedIsolation = absoluteIsolations[isolationIndex];
-        if (!matchedIsolation) return;
-        const isAllowedImport = matchedIsolation.allowedPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
-          }
-        );
-        const isGlobalAllowedImport = absoluteGlobalAllowPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
+        const matchedIsolationIndex = absoluteIsolations.findIndex(
+          (isolation) => {
+            const closedIsolationPath = isolation.isolationPath + "/";
+            return absoluteCurrentFilePath.startsWith(closedIsolationPath);
           }
         );
-        const allowedImport = isAllowedImport || isGlobalAllowedImport;
-        if (!allowedImport) {
+        const matchedIsolation = absoluteIsolations[matchedIsolationIndex];
+        if (!matchedIsolation) return;
+        const isAllowedImport = [
+          //global allowed import paths
+          ...absoluteGlobalAllowPaths,
+          //allowed import paths in the matched isolation
+          ...matchedIsolation.allowedPaths
+        ].some((allowedPath) => {
+          const same = absoluteImportPath === allowedPath;
+          const closedAllowedPath = allowedPath + "/";
+          const sub = absoluteImportPath.startsWith(closedAllowedPath);
+          return same || sub;
+        });
+        if (!isAllowedImport) {
           context.report({
             node,
             messageId: "IsolatedBarrelImportDisallowed"
@@ -450,73 +515,128 @@ var noWildcard = {
 // src/rules/no-cycle.ts
 var import_types4 = require("@typescript-eslint/types");
 var import_path4 = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
 var import_resolve3 = __toESM(require("resolve"), 1);
 var importGraph = /* @__PURE__ */ new Map();
-var fileToImports = /* @__PURE__ */ new Map();
 var barrelExportsCache = /* @__PURE__ */ new Map();
-function detectCycle(currentFile, visited, recStack, path5) {
-  visited.add(currentFile);
-  recStack.add(currentFile);
-  path5.push(currentFile);
-  const imports = importGraph.get(currentFile) || /* @__PURE__ */ new Set();
-  for (const importedFile of imports) {
-    if (!visited.has(importedFile)) {
-      const cycle = detectCycle(importedFile, visited, recStack, [...path5]);
-      if (cycle) {
-        return cycle;
-      }
-    } else if (recStack.has(importedFile)) {
-      const cycleStart = path5.indexOf(importedFile);
-      return [...path5.slice(cycleStart), importedFile];
-    }
-  }
-  recStack.delete(currentFile);
-  return null;
-}
 function isBarrelFile(filePath) {
   const fileName = import_path4.default.basename(filePath);
   return BARREL_ENTRY_POINT_FILE_NAMES.includes(
     fileName
   );
 }
-function getExportedModulesFromBarrel(barrelFileDir, sourceCode) {
-  const exportedModules = [];
-  const ast = sourceCode.ast;
+function isExternalImport(rawPath) {
+  if (!rawPath.startsWith(".") && !rawPath.startsWith("/")) {
+    return true;
+  }
+  if (rawPath.includes("/node_modules/")) {
+    return true;
+  }
+  return false;
+}
+function resolveImportPath(rawImportPath, currentFileDir) {
+  try {
+    const aliasResult = Alias.resolvePath(rawImportPath, currentFileDir);
+    if (aliasResult.type === "success") {
+      return resolveAliasPath(aliasResult.absolutePath, currentFileDir);
+    }
+    if (isExternalImport(rawImportPath)) {
+      return null;
+    }
+    return import_resolve3.default.sync(rawImportPath, {
+      basedir: currentFileDir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function resolveAliasPath(resolvedPath, currentFileDir) {
+  try {
+    const stats = import_fs.default.statSync(resolvedPath);
+    if (stats.isDirectory()) {
+      return import_resolve3.default.sync("index", {
+        basedir: resolvedPath,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    }
+    return resolvedPath;
+  } catch (e) {
+    try {
+      return import_resolve3.default.sync(resolvedPath, {
+        basedir: currentFileDir,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    } catch (e2) {
+      return resolvedPath;
+    }
+  }
+}
+function getBarrelExports(barrelFileDir, ast) {
+  const exports2 = [];
   for (const statement of ast.body) {
-    if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") {
-      if (statement.source) {
-        const exportPath = statement.source.value;
-        try {
-          const resolvedPath = import_resolve3.default.sync(exportPath, {
-            basedir: barrelFileDir,
-            extensions: RESOLVE_EXTENSIONS
-          });
-          if (!exportedModules.includes(resolvedPath)) {
-            exportedModules.push(resolvedPath);
-          }
-        } catch (e) {
-        }
+    if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source) {
+      const exportPath = statement.source.value;
+      const resolved = tryResolve(exportPath, barrelFileDir);
+      if (resolved && !exports2.includes(resolved)) {
+        exports2.push(resolved);
       }
     }
-    if (statement.type === "ImportDeclaration") {
-      if (statement.source) {
-        const importPath = statement.source.value;
-        if (importPath.startsWith(".") || importPath.startsWith("/")) {
-          try {
-            const resolvedPath = import_resolve3.default.sync(importPath, {
-              basedir: barrelFileDir,
-              extensions: RESOLVE_EXTENSIONS
-            });
-            if (!exportedModules.includes(resolvedPath)) {
-              exportedModules.push(resolvedPath);
-            }
-          } catch (e) {
-          }
+    if (statement.type === "ImportDeclaration" && statement.source) {
+      const importPath = statement.source.value;
+      if (importPath.startsWith(".") || importPath.startsWith("/")) {
+        const resolved = tryResolve(importPath, barrelFileDir);
+        if (resolved && !exports2.includes(resolved)) {
+          exports2.push(resolved);
         }
       }
     }
   }
-  return exportedModules;
+  return exports2;
+}
+function tryResolve(importPath, basedir) {
+  try {
+    return import_resolve3.default.sync(importPath, {
+      basedir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function detectCycle(startFile, visited, recStack, currentPath) {
+  visited.add(startFile);
+  recStack.add(startFile);
+  currentPath.push(startFile);
+  const imports = importGraph.get(startFile) || /* @__PURE__ */ new Set();
+  for (const importedFile of imports) {
+    if (!visited.has(importedFile)) {
+      const cycle = detectCycle(importedFile, visited, recStack, [
+        ...currentPath
+      ]);
+      if (cycle) return cycle;
+    } else if (recStack.has(importedFile)) {
+      const cycleStart = currentPath.indexOf(importedFile);
+      return [...currentPath.slice(cycleStart), importedFile];
+    }
+  }
+  recStack.delete(startFile);
+  return null;
+}
+function hasBidirectionalCycle(fileA, fileB) {
+  var _a;
+  const bImports = importGraph.get(fileB);
+  return (_a = bImports == null ? void 0 : bImports.has(fileA)) != null ? _a : false;
+}
+function hasCycleThroughBarrel(currentFile, exportedModules) {
+  for (const exportedModule of exportedModules) {
+    if (exportedModule === currentFile) continue;
+    const moduleImports = importGraph.get(exportedModule);
+    if (moduleImports == null ? void 0 : moduleImports.has(currentFile)) {
+      return exportedModule;
+    }
+  }
+  return null;
 }
 var noCycle = {
   meta: {
@@ -533,161 +653,88 @@ var noCycle = {
   },
   defaultOptions: [],
   create(context) {
-    const absoluteCurrentFilePath = context.getFilename();
-    if (!importGraph.has(absoluteCurrentFilePath)) {
-      importGraph.set(absoluteCurrentFilePath, /* @__PURE__ */ new Set());
-    }
-    const currentImportsSet = importGraph.get(absoluteCurrentFilePath);
-    currentImportsSet.clear();
-    if (!fileToImports.has(absoluteCurrentFilePath)) {
-      fileToImports.set(absoluteCurrentFilePath, /* @__PURE__ */ new Set());
+    const currentFile = context.getFilename();
+    const currentDir = import_path4.default.dirname(currentFile);
+    if (!importGraph.has(currentFile)) {
+      importGraph.set(currentFile, /* @__PURE__ */ new Set());
     }
-    if (isBarrelFile(absoluteCurrentFilePath)) {
-      const barrelFileDir = import_path4.default.dirname(absoluteCurrentFilePath);
-      const sourceCode = context.getSourceCode();
-      const exportedModules = getExportedModulesFromBarrel(
-        barrelFileDir,
-        sourceCode
-      );
-      barrelExportsCache.set(absoluteCurrentFilePath, exportedModules);
+    importGraph.get(currentFile).clear();
+    if (isBarrelFile(currentFile)) {
+      const ast = context.getSourceCode().ast;
+      const exports2 = getBarrelExports(currentDir, ast);
+      barrelExportsCache.set(currentFile, exports2);
     }
-    function resolveImportPath(rawImportPath) {
-      try {
-        const aliasResult = Alias.resolvePath(
-          rawImportPath,
-          import_path4.default.dirname(absoluteCurrentFilePath)
-        );
-        if (aliasResult.type === "success") {
-          const resolvedPath = aliasResult.absolutePath;
-          try {
-            const fs = require("fs");
-            const stats = fs.statSync(resolvedPath);
-            if (stats.isDirectory()) {
-              return import_resolve3.default.sync("index", {
-                basedir: resolvedPath,
-                extensions: RESOLVE_EXTENSIONS
-              });
-            }
-          } catch (e) {
-            try {
-              return import_resolve3.default.sync(resolvedPath, {
-                basedir: import_path4.default.dirname(absoluteCurrentFilePath),
-                extensions: RESOLVE_EXTENSIONS
-              });
-            } catch (e2) {
-              return resolvedPath;
-            }
-          }
-          return resolvedPath;
-        } else {
-          if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
-            return null;
-          }
-          return import_resolve3.default.sync(rawImportPath, {
-            basedir: import_path4.default.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
+    function checkImport(node) {
+      if (!node.source) return;
+      const rawPath = node.source.value;
+      const absolutePath = resolveImportPath(rawPath, currentDir);
+      if (!absolutePath) return;
+      if (isBarrelFile(currentFile)) {
+        const error = checkBarrelInternalImport(rawPath, absolutePath);
+        if (error) {
+          context.report({
+            node,
+            messageId: "BarrelInternalImportDisallowed",
+            data: { relativePath: error }
           });
+          return;
         }
-      } catch (e) {
-        return null;
       }
-    }
-    function checker(node) {
-      if (!node.source) {
-        return;
+      const isBarrelInternal = isBarrelFile(currentFile) && absolutePath.startsWith(currentDir + import_path4.default.sep);
+      addToGraph(absolutePath);
+      if (isBarrelInternal) return;
+      const cycleError = checkForCycles(absolutePath);
+      if (cycleError) {
+        context.report({
+          node,
+          messageId: "CircularDependency",
+          data: { cyclePath: cycleError }
+        });
       }
-      const rawImportPath = node.source.value;
-      const absoluteImportPath = resolveImportPath(rawImportPath);
-      if (!absoluteImportPath) {
-        return;
+    }
+    function checkBarrelInternalImport(rawPath, absolutePath) {
+      const isInternal = absolutePath.startsWith(currentDir + import_path4.default.sep) || absolutePath === currentDir;
+      if (!isInternal) return null;
+      if (rawPath.startsWith("./") || rawPath.startsWith("../")) {
+        return null;
       }
-      if (isBarrelFile(absoluteCurrentFilePath)) {
-        const barrelFileDir = import_path4.default.dirname(absoluteCurrentFilePath);
-        const isInternalModule = absoluteImportPath.startsWith(barrelFileDir + import_path4.default.sep) || absoluteImportPath === barrelFileDir;
-        if (isInternalModule) {
-          if (!rawImportPath.startsWith("./") && !rawImportPath.startsWith("../")) {
-            const relativePath = import_path4.default.relative(
-              barrelFileDir,
-              absoluteImportPath
-            );
-            const suggestedRelativePath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-            context.report({
-              node,
-              messageId: "BarrelInternalImportDisallowed",
-              data: {
-                relativePath: suggestedRelativePath.replace(/\\/g, "/")
-              }
-            });
-            return;
+      const relative = import_path4.default.relative(currentDir, absolutePath);
+      const suggested = relative.startsWith(".") ? relative : `./${relative}`;
+      return suggested.replace(/\\/g, "/");
+    }
+    function addToGraph(absolutePath) {
+      const imports = importGraph.get(currentFile);
+      imports.add(absolutePath);
+      if (isBarrelFile(absolutePath)) {
+        const exports2 = barrelExportsCache.get(absolutePath) || [];
+        for (const exp of exports2) {
+          if (exp !== currentFile) {
+            imports.add(exp);
           }
         }
       }
-      const isBarrelImportingInternal = isBarrelFile(absoluteCurrentFilePath) && absoluteImportPath.startsWith(
-        import_path4.default.dirname(absoluteCurrentFilePath) + import_path4.default.sep
-      );
-      const currentImports = importGraph.get(absoluteCurrentFilePath);
-      if (currentImports) {
-        currentImports.add(absoluteImportPath);
-        if (isBarrelFile(absoluteImportPath)) {
-          const exportedModules = barrelExportsCache.get(absoluteImportPath) || [];
-          for (const exportedModule of exportedModules) {
-            if (exportedModule !== absoluteCurrentFilePath) {
-              currentImports.add(exportedModule);
-              const exportedModuleImports = importGraph.get(exportedModule);
-              if (exportedModuleImports && exportedModuleImports.has(absoluteCurrentFilePath)) {
-                const cyclePath = `${absoluteCurrentFilePath} \u2192 ${absoluteImportPath} \u2192 ${exportedModule} \u2192 ${absoluteImportPath} \u2192 ${absoluteCurrentFilePath}`;
-                context.report({
-                  node,
-                  messageId: "CircularDependency",
-                  data: {
-                    cyclePath
-                  }
-                });
-                return;
-              }
-            }
-          }
+    }
+    function checkForCycles(absolutePath) {
+      if (isBarrelFile(absolutePath)) {
+        const exports2 = barrelExportsCache.get(absolutePath) || [];
+        const cycleModule = hasCycleThroughBarrel(currentFile, exports2);
+        if (cycleModule) {
+          return `${currentFile} \u2192 ${absolutePath} \u2192 ${cycleModule} \u2192 ${absolutePath} \u2192 ${currentFile}`;
         }
       }
-      if (isBarrelImportingInternal) {
-        return;
-      }
-      const importedFileImports = importGraph.get(absoluteImportPath);
-      if (importedFileImports && importedFileImports.has(absoluteCurrentFilePath)) {
-        const cyclePath = `${absoluteCurrentFilePath} \u2192 ${absoluteImportPath} \u2192 ${absoluteCurrentFilePath}`;
-        context.report({
-          node,
-          messageId: "CircularDependency",
-          data: {
-            cyclePath
-          }
-        });
-        return;
+      if (hasBidirectionalCycle(currentFile, absolutePath)) {
+        return `${currentFile} \u2192 ${absolutePath} \u2192 ${currentFile}`;
       }
-      const visited = /* @__PURE__ */ new Set();
-      const recStack = /* @__PURE__ */ new Set();
-      const cycle = detectCycle(absoluteCurrentFilePath, visited, recStack, []);
+      const cycle = detectCycle(currentFile, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), []);
       if (cycle && cycle.length > 0) {
-        const cyclePath = cycle.join(" \u2192 ");
-        context.report({
-          node,
-          messageId: "CircularDependency",
-          data: {
-            cyclePath
-          }
-        });
+        return cycle.join(" \u2192 ");
       }
+      return null;
     }
     return {
-      ImportDeclaration(node) {
-        return checker(node);
-      },
-      ExportNamedDeclaration(node) {
-        return checker(node);
-      },
-      ExportAllDeclaration(node) {
-        return checker(node);
-      }
+      ImportDeclaration: checkImport,
+      ExportNamedDeclaration: checkImport,
+      ExportAllDeclaration: checkImport
     };
   }
 };