eslint-plugin-barrel-rules 1.1.1 → 1.1.3

package/README.ko.md

@@ -3,7 +3,7 @@
 # **Advanced Barrel Pattern Enforcement for JavaScript/TypeScript Projects**
 
 <div align="center">
-  <img src="https://img.shields.io/badge/version-1.1.1-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.1.3-blue.svg" alt="Version"/>
   <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"/>
   <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"/>
 </div>
@@ -28,6 +28,10 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
 내부 파일을 직접 import하는 것을 차단하여  
 **모듈화, 추상화, 유지보수성, 확장성**을 극대화합니다.
 
+> 💡 Tip:  
+> 코드 품질을 더욱 강화하고 싶다면, 이 플러그인과 함께 [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import)의 `no-cycle` 룰을 사용하는 것을 추천합니다.  
+> 이를 통해 프로젝트 내의 순환 참조(Import Cycle)도 효과적으로 감지하고 방지할 수 있습니다.
+
 ---
 
 ## 지원 환경
@@ -48,6 +52,17 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
   (예: `import ... from "../domains/foo"`는 허용,  
   `import ... from "../domains/foo/components/Bar"`는 차단)
 
+- **Isolation Barrel Module**  
+  지정한 barrel path 외부의 모듈이 내부 파일을 직접 import하지 못하도록 막을 수 있습니다.  
+  `isolated: true` 옵션을 사용하면 같은 barrel path 내부에서는 자유롭게 import가 가능하고,  
+  외부에서는 해당 barrel path로의 import가 모두 차단됩니다. (barrel(index) 파일을 통한 접근도 불가)  
+  만약 특정 공유 import 경로만 허용하고 싶다면 `allowedImportPaths` 옵션을 사용할 수 있습니다.  
+  이를 통해 각 모듈의 경계를 엄격하게 보호하고, 모듈의 독립성을 유지할 수 있습니다.
+
+- **와일드카드 import/export 방지**  
+  `import * as foo from "module"` 또는 `export * from "./module"`과 같은 와일드카드(네임스페이스) import/export를 금지합니다.  
+  명시적인 이름 기반 import/export만 허용하여 트리쉐이킹과 코드 명확성을 높입니다.
+
 - **고성능 glob 매칭**  
   `src/domains/*`처럼 glob 패턴으로 여러 디렉토리 지정 가능
 
@@ -56,16 +71,22 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
 ## 규칙(Rules)
 
 1. **enforce-barrel-pattern**  
-   모듈 임포트 시 배럴 패턴(Barrel Pattern)을 강제합니다.  
-   지정한 배럴 파일을 통해서만 임포트가 가능하며, 내부 모듈에 직접 접근하는 것을 방지합니다.
+   모듈 import 시 barrel 패턴을 강제합니다.  
+   지정한 barrel 파일(예: index.ts)로만 import를 허용하고, 내부 모듈에 대한 직접 접근을 차단합니다.
+   `isolated: true` 옵션을 사용하면 같은 barrel path 내부 파일끼리만 import가 가능하며, 외부에서의 import는 barrel 파일을 통한 접근도 모두 차단됩니다.  
+   `allowedImportPaths` 옵션을 사용하면 특정 공유 import 경로만 예외적으로 허용할 수 있습니다.
 
    - **옵션:**
-     - `paths`: 배럴 패턴으로 보호할 디렉토리 경로(`baseDir` 기준 상대경로)
-     - `baseDir` (선택): `paths` 해석 기준이 되는 디렉토리. 기본값은 ESLint 실행 위치입니다.
+     - `paths`: barrel 패턴을 적용할 디렉토리 목록(`baseDir` 기준 상대경로)
+     - `baseDir` (선택): `paths` 기준이 되는 베이스 디렉토리 (기본값: ESLint 실행 디렉토리)
+     - `isolated` (선택): `true`일 경우, barrel path 외부에서의 모든 import를 차단합니다(barrel 파일 통한 접근 포함). 같은 barrel path 내부 또는 `allowedImportPaths`만 허용.
+     - `allowedImportPaths` (선택): isolation 모드에서도 직접 import를 허용할 경로 배열
 
 2. **no-wildcard**  
-   `import * as foo from "module"`, `export * from "./module"`과 같은 와일드카드(네임스페이스) import/export를 금지합니다.  
-   트리쉐이킹 및 코드 명확성을 위해 반드시 개별(named) import/export만 허용합니다.
+   `import * as foo from "module"` 또는 `export * from "./module"`과 같은 와일드카드(네임스페이스) import/export를 금지합니다.  
+   `enforce-barrel-pattern` 룰과 함께 사용하는 것을 적극 추천합니다.  
+   두 룰을 함께 적용하면 모듈 경계를 엄격하게 지킬 수 있을 뿐만 아니라,  
+   트리쉐이킹을 통한 성능 향상과 코드 추적 및 유지보수의 용이성까지 모두 얻을 수 있습니다.
 
 ---
 
@@ -100,6 +121,11 @@ module.exports = {
         // (옵션) 설정하지 않으면 기본값은 ESLint를 실행한 위치(작업 디렉토리)입니다.
         // 예: `npx eslint .`처럼 실행하면, 실행 시점의 현재 디렉토리가 기본값이 됩니다.
         baseDir: __dirname,
+        // isolation 모드 활성화: barrel path 외부에서의 모든 import를 차단합니다.
+        isolated: true,
+        // "shared" 디렉토리만 직접 import를 허용합니다.
+        // 필요에 따라 이 배열에 "node_modules/*" 등 원하는 경로를 자유롭게 추가할 수 있습니다.
+        allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
       },
     ],
     // import * 또는 export * 금지
@@ -149,6 +175,11 @@ export default tseslint.config([
           // (옵션) 설정하지 않으면 기본값은 ESLint를 실행한 위치(작업 디렉토리)입니다.
           // 예: `npx eslint .`처럼 실행하면, 실행 시점의 현재 디렉토리가 기본값이 됩니다.
           baseDir: __dirname,
+          // isolation 모드 활성화: barrel path 외부에서의 모든 import를 차단합니다.
+          isolated: true,
+          // "shared" 디렉토리만 직접 import를 허용합니다.
+          // 필요에 따라 이 배열에 "node_modules/*" 등 원하는 경로를 자유롭게 추가할 수 있습니다.
+          allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
         },
       ],
       // import * 또는 export * 금지
@@ -181,6 +212,7 @@ import { Test } from "../domains/foo";
 - **번들 플러그인(플러그인 내 모든 기능 통합)** (OK)
 - **잘못된 경로 설정 검증 기능** (OK)
 - **와일드카드 import/export 제한 규칙** (OK)
+- **지정한 Barrel 경로 격리** (OK)
 
 ---
 

package/README.md

@@ -3,7 +3,7 @@
 # **Advanced Barrel Pattern Enforcement for JavaScript/TypeScript Projects**
 
 <div align="center">
-  <img src="https://img.shields.io/badge/version-1.1.1-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.1.3-blue.svg" alt="Version"/>
   <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"/>
   <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"/>
 </div>
@@ -31,6 +31,10 @@ internal implementation details must only be accessed via the directory’s **in
 Direct imports from internal files are blocked, maximizing  
 **modularity, abstraction, maintainability, and scalability**.
 
+> 💡 Tip:  
+> For even stronger code quality, we recommend using the `no-cycle` rule from [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import) together with this plugin.  
+> This allows you to detect and prevent circular dependencies (import cycles) in your project.
+
 ---
 
 ## Supports
@@ -51,6 +55,17 @@ Direct imports from internal files are blocked, maximizing
   (e.g., `import ... from "../domains/foo"` is allowed,  
   but `import ... from "../domains/foo/components/Bar"` is blocked)
 
+- **Isolation Barrel Module**  
+  You can prevent modules outside the specified barrel path from directly importing internal files.  
+  By enabling `isolated: true`, only files within the same barrel path can freely import each other.  
+  Any import from outside the enforced barrel path is completely blocked, even if it tries to import via the barrel (index) file.  
+  If you want to allow specific shared imports, you can use the `allowedImportPaths` option.  
+  This helps you strictly protect your module boundaries and keep each module truly independent.
+
+- **Prevent Wildcard Import/Export**  
+  Disallows wildcard (namespace) imports and exports such as `import * as foo from "module"` or `export * from "./module"`.  
+  This enforces the use of named imports/exports for better tree-shaking and code clarity.
+
 - **High-performance glob matching**  
   Specify multiple directories using glob patterns like `src/domains/*`
 
@@ -61,14 +76,20 @@ Direct imports from internal files are blocked, maximizing
 1. **enforce-barrel-pattern**  
    Enforces the barrel pattern for module imports.  
    Only allows imports from designated barrel files and prevents direct access to internal modules.
+   When `isolated: true` is set, only files within the same barrel path can import each other, and any import from outside the barrel path is completely blocked (even via the barrel file).  
+   You can allow specific shared import paths by using the `allowedImportPaths` option.
 
    - **Options:**
      - `paths`: The directories to be protected by the barrel pattern (relative to `baseDir`).
      - `baseDir` (optional): The base directory for resolving `paths`. Defaults to the ESLint execution directory.
+     - `isolated` (optional): If `true`, blocks all imports from outside the barrel path, even via the barrel file. Only allows imports within the same barrel path or from `allowedImportPaths`.
+     - `allowedImportPaths` (optional): Array of paths that are allowed to be imported directly, even in isolation mode.
 
 2. **no-wildcard**  
-   Disallows wildcard (namespace) imports such as `import * as foo from "module"`, `export * from "./module"`
-   Forces you to use named imports for better tree-shaking and code clarity.
+   Disallows wildcard (namespace) imports such as `import * as foo from "module"` or `export * from "./module"`.  
+   We highly recommend enabling this rule together with the `enforce-barrel-pattern` rule.  
+   Using both rules together not only enforces strict module boundaries,  
+   but also improves performance through better tree-shaking and makes code tracing and maintenance much easier.
 
 ---
 
@@ -103,6 +124,11 @@ module.exports = {
         // Optional config. The default value is the directory where ESLint is executed.
 // For example, if you run `npx eslint .`, the default will be the current working directory at the time of execution.
         baseDir: __dirname,
+        // Enable isolation mode: block all imports from outside the barrel path
+        isolated: true,
+        // Allow direct imports only from the "shared" directory.
+        // You can customize this array as needed, e.g., add "node_modules/..." or any other path you want to allow.
+        allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
       },
     ],
     // Disallow wildcard (namespace) import/export.
@@ -152,6 +178,11 @@ export default tseslint.config([
           // Optional config. The default value is the directory where ESLint is executed.
           // For example, if you run `npx eslint .`, the default will be the current working directory at the time of execution.
           baseDir: __dirname,
+          // Enable isolation mode: block all imports from outside the barrel path
+          isolated: true,
+          // Allow direct imports only from the "shared" directory.
+          // You can customize this array as needed, e.g., add "node_modules/*" or any other path you want to allow.
+          allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
         },
       ],
       // Disallow wildcard (namespace) import/export.
@@ -188,6 +219,7 @@ import { Test } from "../domains/foo";
   (OK)
 - **Wrong Path Setup Validator** (OK)
 - **Wildcard Import/Export Protection Rule** (OK)
+- **Isolation Barrel Module** (OK)
 
 ---
 

package/dist/index.cjs

@@ -38,7 +38,45 @@ module.exports = __toCommonJS(index_exports);
 var import_utils = require("@typescript-eslint/utils");
 var import_path = __toESM(require("path"), 1);
 var import_resolve = __toESM(require("resolve"), 1);
+
+// src/utils/glob.ts
 var import_fast_glob = __toESM(require("fast-glob"), 1);
+var Glob = class {
+  static resolvePath(path2, baseDir) {
+    const globResult = import_fast_glob.default.sync(path2, {
+      cwd: baseDir,
+      onlyDirectories: true,
+      absolute: true
+    });
+    if (globResult.length === 0) {
+      throw new Error(
+        `[Glob] In baseDir: ${baseDir}, path: ${path2}, any directory was not found`
+      );
+    }
+    return globResult;
+  }
+};
+
+// src/rules/enforce-barrel-pattern.ts
+var BARREL_ENTRY_POINT_FILE_NAMES = [
+  "index.ts",
+  "index.tsx",
+  "index.js",
+  "index.jsx",
+  "index.cjs",
+  "index.mjs",
+  "index.d.ts"
+];
+var RESOLVE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".d.ts",
+  ".mjs",
+  ".cjs"
+];
 var enforceBarrelPattern = {
   meta: {
     type: "problem",
@@ -50,33 +88,36 @@ var enforceBarrelPattern = {
         type: "object",
         properties: {
           paths: { type: "array", items: { type: "string" } },
-          baseDir: { type: "string" }
+          baseDir: { type: "string" },
+          isolated: { type: "boolean" },
+          allowedImportPaths: { type: "array", items: { type: "string" } }
         },
         required: ["paths"],
         additionalProperties: false
       }
     ],
     messages: {
-      DirectImportDisallowed: "Please import from '{{matchedTargetPath}}'. Direct access to '{{rawImportPath}}' is not allowed. You must use the barrel pattern and only consume APIs exposed externally. This is to ensure encapsulation of internal logic and maintain module boundaries."
+      DirectImportDisallowed: "Please import from '{{matchedTargetPath}}'. Direct access to '{{rawImportPath}}' is not allowed. You must use the barrel pattern and only consume APIs exposed externally. This is to ensure encapsulation of internal logic and maintain module boundaries.",
+      IsolatedBarrelImportDisallowed: "This barrel file is isolated. external import is not allowed. if you want to import outside of the barrel file, please add 'allowedImportPaths' to the plugin options."
     }
   },
   //default options(baseDir is current working directory. almost user execute eslint in project root)
-  defaultOptions: [{ paths: [], baseDir: process.cwd() }],
+  defaultOptions: [
+    {
+      paths: [],
+      baseDir: process.cwd(),
+      isolated: false,
+      allowedImportPaths: []
+    }
+  ],
   create(context) {
     const option = context.options[0];
     const baseDir = option.baseDir;
-    const targetPaths = option.paths.flatMap((_path) => {
-      const globResult = import_fast_glob.default.sync(_path, {
-        cwd: baseDir,
-        onlyDirectories: true,
-        absolute: true
-      });
-      if (globResult.length === 0) {
-        throw new Error(
-          `[enforce-barrel-pattern] In baseDir: ${baseDir}, path: ${_path}, any directory was not found`
-        );
-      }
-      return globResult;
+    const absoluteTargetPaths = option.paths.flatMap((_path) => {
+      return Glob.resolvePath(_path, baseDir);
+    });
+    const allowedImportPaths = option.allowedImportPaths.flatMap((_path) => {
+      return Glob.resolvePath(_path, baseDir);
     });
     return {
       //check only import declaration(ESM)
@@ -87,46 +128,69 @@ var enforceBarrelPattern = {
         try {
           absoluteImportPath = import_resolve.default.sync(rawImportPath, {
             basedir: import_path.default.dirname(absoluteCurrentFilePath),
-            extensions: [
-              ".ts",
-              ".tsx",
-              ".js",
-              ".jsx",
-              ".json",
-              ".d.ts",
-              ".mjs",
-              ".cjs"
-            ]
+            extensions: RESOLVE_EXTENSIONS
           });
         } catch (e) {
           return;
         }
-        let matchedLatestTargetPath = null;
-        const invalidDirectedImport = targetPaths.some((targetPath) => {
-          const targetPathEntryPoints = [
-            "index.ts",
-            "index.tsx",
-            "index.js",
-            "index.jsx",
-            "index.cjs",
-            "index.mjs",
-            "index.d.ts"
-          ].map((entry) => import_path.default.resolve(targetPath, entry));
-          const closedTargetPath = targetPath + "/";
-          const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
-          const importedOutsideOfTargetPath = !absoluteCurrentFilePath.startsWith(closedTargetPath) && absoluteImportPath.startsWith(closedTargetPath);
-          const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
-          if (invalidImported) {
-            matchedLatestTargetPath = targetPath;
+        {
+          let matchedLatestTargetPath = null;
+          const invalidDirectedImport = absoluteTargetPaths.some(
+            (absoluteTargetPath) => {
+              const targetPathEntryPoints = BARREL_ENTRY_POINT_FILE_NAMES.map(
+                (entry) => import_path.default.resolve(absoluteTargetPath, entry)
+              );
+              const closedTargetPath = absoluteTargetPath + "/";
+              const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
+              const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
+              const currentFileInEnforceBarrel = absoluteCurrentFilePath.startsWith(closedTargetPath);
+              const importedOutsideOfTargetPath = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
+              const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
+              if (invalidImported) {
+                matchedLatestTargetPath = absoluteTargetPath;
+              }
+              return invalidImported;
+            }
+          );
+          if (invalidDirectedImport) {
+            context.report({
+              node,
+              messageId: "DirectImportDisallowed",
+              data: {
+                rawImportPath,
+                matchedTargetPath: matchedLatestTargetPath
+              }
+            });
+          }
+        }
+        {
+          if (option.isolated) {
+            const currentFileInEnforceBarrel = absoluteTargetPaths.some(
+              (absoluteTargetPath) => {
+                const closedTargetPath = absoluteTargetPath + "/";
+                return absoluteCurrentFilePath.startsWith(closedTargetPath);
+              }
+            );
+            const sameBarrel = absoluteTargetPaths.some(
+              (absoluteTargetPath) => {
+                const closedTargetPath = absoluteTargetPath + "/";
+                const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
+                const currentFileInEnforceBarrel2 = absoluteCurrentFilePath.startsWith(closedTargetPath);
+                return importedEnforceBarrelFile && currentFileInEnforceBarrel2;
+              }
+            );
+            const allowedImportPath = allowedImportPaths.some(
+              (allowedImportPath2) => {
+                return absoluteImportPath.startsWith(allowedImportPath2);
+              }
+            );
+            if (!allowedImportPath && !sameBarrel && currentFileInEnforceBarrel) {
+              context.report({
+                node,
+                messageId: "IsolatedBarrelImportDisallowed"
+              });
+            }
           }
-          return invalidImported;
-        });
-        if (invalidDirectedImport) {
-          context.report({
-            node,
-            messageId: "DirectImportDisallowed",
-            data: { rawImportPath, matchedTargetPath: matchedLatestTargetPath }
-          });
         }
       }
     };

package/dist/index.d.cts

@@ -2,9 +2,11 @@ import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts
 
 declare const _default: {
     rules: {
-        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed", {
+        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed" | "IsolatedBarrelImportDisallowed", {
             paths: string[];
             baseDir: string;
+            isolated: boolean;
+            allowedImportPaths: string[];
         }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
         "no-wildcard": _typescript_eslint_utils_ts_eslint.RuleModule<"NoWildcardImport" | "NoExportAll", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     };

package/dist/index.d.ts

@@ -2,9 +2,11 @@ import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts
 
 declare const _default: {
     rules: {
-        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed", {
+        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed" | "IsolatedBarrelImportDisallowed", {
             paths: string[];
             baseDir: string;
+            isolated: boolean;
+            allowedImportPaths: string[];
         }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
         "no-wildcard": _typescript_eslint_utils_ts_eslint.RuleModule<"NoWildcardImport" | "NoExportAll", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     };

package/dist/index.js

@@ -2,7 +2,45 @@
 import "@typescript-eslint/utils";
 import path from "path";
 import resolve from "resolve";
-import fastGlob from "fast-glob";
+
+// src/utils/glob.ts
+import FastGlob from "fast-glob";
+var Glob = class {
+  static resolvePath(path2, baseDir) {
+    const globResult = FastGlob.sync(path2, {
+      cwd: baseDir,
+      onlyDirectories: true,
+      absolute: true
+    });
+    if (globResult.length === 0) {
+      throw new Error(
+        `[Glob] In baseDir: ${baseDir}, path: ${path2}, any directory was not found`
+      );
+    }
+    return globResult;
+  }
+};
+
+// src/rules/enforce-barrel-pattern.ts
+var BARREL_ENTRY_POINT_FILE_NAMES = [
+  "index.ts",
+  "index.tsx",
+  "index.js",
+  "index.jsx",
+  "index.cjs",
+  "index.mjs",
+  "index.d.ts"
+];
+var RESOLVE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".d.ts",
+  ".mjs",
+  ".cjs"
+];
 var enforceBarrelPattern = {
   meta: {
     type: "problem",
@@ -14,33 +52,36 @@ var enforceBarrelPattern = {
         type: "object",
         properties: {
           paths: { type: "array", items: { type: "string" } },
-          baseDir: { type: "string" }
+          baseDir: { type: "string" },
+          isolated: { type: "boolean" },
+          allowedImportPaths: { type: "array", items: { type: "string" } }
         },
         required: ["paths"],
         additionalProperties: false
       }
     ],
     messages: {
-      DirectImportDisallowed: "Please import from '{{matchedTargetPath}}'. Direct access to '{{rawImportPath}}' is not allowed. You must use the barrel pattern and only consume APIs exposed externally. This is to ensure encapsulation of internal logic and maintain module boundaries."
+      DirectImportDisallowed: "Please import from '{{matchedTargetPath}}'. Direct access to '{{rawImportPath}}' is not allowed. You must use the barrel pattern and only consume APIs exposed externally. This is to ensure encapsulation of internal logic and maintain module boundaries.",
+      IsolatedBarrelImportDisallowed: "This barrel file is isolated. external import is not allowed. if you want to import outside of the barrel file, please add 'allowedImportPaths' to the plugin options."
     }
   },
   //default options(baseDir is current working directory. almost user execute eslint in project root)
-  defaultOptions: [{ paths: [], baseDir: process.cwd() }],
+  defaultOptions: [
+    {
+      paths: [],
+      baseDir: process.cwd(),
+      isolated: false,
+      allowedImportPaths: []
+    }
+  ],
   create(context) {
     const option = context.options[0];
     const baseDir = option.baseDir;
-    const targetPaths = option.paths.flatMap((_path) => {
-      const globResult = fastGlob.sync(_path, {
-        cwd: baseDir,
-        onlyDirectories: true,
-        absolute: true
-      });
-      if (globResult.length === 0) {
-        throw new Error(
-          `[enforce-barrel-pattern] In baseDir: ${baseDir}, path: ${_path}, any directory was not found`
-        );
-      }
-      return globResult;
+    const absoluteTargetPaths = option.paths.flatMap((_path) => {
+      return Glob.resolvePath(_path, baseDir);
+    });
+    const allowedImportPaths = option.allowedImportPaths.flatMap((_path) => {
+      return Glob.resolvePath(_path, baseDir);
     });
     return {
       //check only import declaration(ESM)
@@ -51,46 +92,69 @@ var enforceBarrelPattern = {
         try {
           absoluteImportPath = resolve.sync(rawImportPath, {
             basedir: path.dirname(absoluteCurrentFilePath),
-            extensions: [
-              ".ts",
-              ".tsx",
-              ".js",
-              ".jsx",
-              ".json",
-              ".d.ts",
-              ".mjs",
-              ".cjs"
-            ]
+            extensions: RESOLVE_EXTENSIONS
           });
         } catch (e) {
           return;
         }
-        let matchedLatestTargetPath = null;
-        const invalidDirectedImport = targetPaths.some((targetPath) => {
-          const targetPathEntryPoints = [
-            "index.ts",
-            "index.tsx",
-            "index.js",
-            "index.jsx",
-            "index.cjs",
-            "index.mjs",
-            "index.d.ts"
-          ].map((entry) => path.resolve(targetPath, entry));
-          const closedTargetPath = targetPath + "/";
-          const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
-          const importedOutsideOfTargetPath = !absoluteCurrentFilePath.startsWith(closedTargetPath) && absoluteImportPath.startsWith(closedTargetPath);
-          const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
-          if (invalidImported) {
-            matchedLatestTargetPath = targetPath;
+        {
+          let matchedLatestTargetPath = null;
+          const invalidDirectedImport = absoluteTargetPaths.some(
+            (absoluteTargetPath) => {
+              const targetPathEntryPoints = BARREL_ENTRY_POINT_FILE_NAMES.map(
+                (entry) => path.resolve(absoluteTargetPath, entry)
+              );
+              const closedTargetPath = absoluteTargetPath + "/";
+              const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
+              const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
+              const currentFileInEnforceBarrel = absoluteCurrentFilePath.startsWith(closedTargetPath);
+              const importedOutsideOfTargetPath = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
+              const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
+              if (invalidImported) {
+                matchedLatestTargetPath = absoluteTargetPath;
+              }
+              return invalidImported;
+            }
+          );
+          if (invalidDirectedImport) {
+            context.report({
+              node,
+              messageId: "DirectImportDisallowed",
+              data: {
+                rawImportPath,
+                matchedTargetPath: matchedLatestTargetPath
+              }
+            });
+          }
+        }
+        {
+          if (option.isolated) {
+            const currentFileInEnforceBarrel = absoluteTargetPaths.some(
+              (absoluteTargetPath) => {
+                const closedTargetPath = absoluteTargetPath + "/";
+                return absoluteCurrentFilePath.startsWith(closedTargetPath);
+              }
+            );
+            const sameBarrel = absoluteTargetPaths.some(
+              (absoluteTargetPath) => {
+                const closedTargetPath = absoluteTargetPath + "/";
+                const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
+                const currentFileInEnforceBarrel2 = absoluteCurrentFilePath.startsWith(closedTargetPath);
+                return importedEnforceBarrelFile && currentFileInEnforceBarrel2;
+              }
+            );
+            const allowedImportPath = allowedImportPaths.some(
+              (allowedImportPath2) => {
+                return absoluteImportPath.startsWith(allowedImportPath2);
+              }
+            );
+            if (!allowedImportPath && !sameBarrel && currentFileInEnforceBarrel) {
+              context.report({
+                node,
+                messageId: "IsolatedBarrelImportDisallowed"
+              });
+            }
           }
-          return invalidImported;
-        });
-        if (invalidDirectedImport) {
-          context.report({
-            node,
-            messageId: "DirectImportDisallowed",
-            data: { rawImportPath, matchedTargetPath: matchedLatestTargetPath }
-          });
         }
       }
     };

package/package.json

@@ -21,9 +21,11 @@
     "barrel-module",
     "barrel pattern",
     "encapsulation directory",
-    "enforce barrel pattern"
+    "enforce barrel pattern",
+    "isolated barrel module",
+    "no-wildcard"
   ],
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",