eslint-plugin-barrel-rules 1.2.0 → 1.3.1

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.2.0-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.3.1-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,7 +28,11 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
 내부 파일을 직접 import하는 것을 차단하여  
 **모듈화, 추상화, 유지보수성, 확장성**을 극대화합니다.
 
-> 💡 Tip:  
+> 💡 Tip:
+>
+> > 이 플러그인은 `node_modules`(외부 패키지)의 import는 제한하거나 검사하지 않습니다.  
+> > 모든 규칙은 오직 프로젝트 내부(로컬 소스 파일) 경로의 import에만 적용됩니다.
+>
 > 코드 품질을 더욱 강화하고 싶다면, 이 플러그인과 함께 [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import)의 `no-cycle` 룰을 사용하는 것을 추천합니다.  
 > 이를 통해 프로젝트 내의 순환 참조(Import Cycle)도 효과적으로 감지하고 방지할 수 있습니다.
 
@@ -58,11 +62,7 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
   `import ... from "../domains/foo/components/Bar"`는 차단)
 
 - **Isolation Barrel Module**  
-  지정한 barrel path 외부의 모듈이 내부 파일을 직접 import하지 못하도록 막을 수 있습니다.  
-  `isolated: true` 옵션을 사용하면 같은 barrel path 내부에서는 자유롭게 import가 가능하고,  
-  외부에서는 해당 barrel path로의 import가 모두 차단됩니다. (barrel(index) 파일을 통한 접근도 불가)  
-  만약 특정 공유 import 경로만 허용하고 싶다면 `allowedImportPaths` 옵션을 사용할 수 있습니다.  
-  이를 통해 각 모듈의 경계를 엄격하게 보호하고, 모듈의 독립성을 유지할 수 있습니다.
+  지정한 barrel path 외부의 모듈이 내부 파일을 직접 import하지 못하도록 막을 수 있습니다.
 
 - **와일드카드 import/export 방지**  
   `import * as foo from "module"` 또는 `export * from "./module"`과 같은 와일드카드(네임스페이스) import/export를 금지합니다.  
@@ -75,17 +75,13 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
 
 ## 규칙(Rules)
 
-1. **enforce-barrel-pattern**  
+1. **enforce-barrel-pattern** (isolate 옵션이 제거되었습니다.)
    모듈 import 시 barrel 패턴을 강제합니다.  
    지정한 barrel 파일(예: index.ts)로만 import를 허용하고, 내부 모듈에 대한 직접 접근을 차단합니다.
-   `isolated: true` 옵션을 사용하면 같은 barrel path 내부 파일끼리만 import가 가능하며, 외부에서의 import는 barrel 파일을 통한 접근도 모두 차단됩니다.  
-   `allowedImportPaths` 옵션을 사용하면 특정 공유 import 경로만 예외적으로 허용할 수 있습니다.
 
    - **옵션:**
      - `paths`: barrel 패턴을 적용할 디렉토리 목록(`baseDir` 기준 상대경로)
-     - `baseDir` (선택): `paths` 기준이 되는 베이스 디렉토리 (기본값: ESLint 실행 디렉토리)
-     - `isolated` (선택): `true`일 경우, barrel path 외부에서의 모든 import를 차단합니다(barrel 파일 통한 접근 포함). 같은 barrel path 내부 또는 `allowedImportPaths`만 허용.
-     - `allowedImportPaths` (선택): isolation 모드에서도 직접 import를 허용할 경로 배열
+     - `baseDir`: `paths` 기준이 되는 베이스 디렉토리 (기본값: ESLint 실행 디렉토리)
 
 2. **no-wildcard**  
    `import * as foo from "module"` 또는 `export * from "./module"`과 같은 와일드카드(네임스페이스) import/export를 금지합니다.  
@@ -93,6 +89,14 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
    두 룰을 함께 적용하면 모듈 경계를 엄격하게 지킬 수 있을 뿐만 아니라,  
    트리쉐이킹을 통한 성능 향상과 코드 추적 및 유지보수의 용이성까지 모두 얻을 수 있습니다.
 
+3. **isolate-barrel-file** (isolated 기능을 새로운 룰로 제작했습니다.)
+   모듈 import 시 barrel 패턴을 강제합니다.  
+   지정한 barrel 파일(예: index.ts)로만 import를 허용하고, 내부 모듈에 대한 직접 접근을 차단합니다.
+   - **옵션:**
+     - `isolations(Array<{ path: string, allowedPaths: string[] }>)`: `path`와 `allowedPaths`로 구성된 isolation을 추가할 수 있습니다.
+     - `baseDir`: `paths` 기준이 되는 베이스 디렉토리 (기본값: ESLint 실행 디렉토리)
+     - `globalAllowedPaths` : 모든 isolations에 공통적으로 허용할 경로를 지정합니다(node_modules ... etc)
+
 ---
 
 ## 설치
@@ -118,23 +122,43 @@ module.exports = {
   parser: "@typescript-eslint/parser",
   plugins: ["@typescript-eslint", "barrel-rules"],
   rules: {
-    "barrel-rules/enforce-barrel-pattern": [
-      "error",
-      {
-        // 배럴 파일로 보호할 디렉토리의 경로입니다. baseDir을 기준으로 상대 경로로 설정합니다.
-        paths: ["src/typescript/barrel/*", "src/javascript/barrel/*"],
-        // (옵션) 설정하지 않으면 기본값은 ESLint를 실행한 위치(작업 디렉토리)입니다.
-        // 예: `npx eslint .`처럼 실행하면, 실행 시점의 현재 디렉토리가 기본값이 됩니다.
-        baseDir: __dirname,
-        // isolation 모드 활성화: barrel path 외부에서의 모든 import를 차단합니다.
-        isolated: true,
-        // "shared" 디렉토리만 직접 import를 허용합니다.
-        // 필요에 따라 이 배열에 "node_modules/*" 등 원하는 경로를 자유롭게 추가할 수 있습니다.
-        allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
-      },
-    ],
-    // import * 또는 export * 금지
-    "barrel-rules/no-wildcard": ["error"],
+
+      //barrel-file 캡슐화
+      "barrel-rules/enforce-barrel-pattern": [
+        "error",
+        {
+          // encapsulation barrel file
+          paths: ["src/pages/*", "src/features/*", "src/entities/*"],
+          baseDir: __dirname,
+        },
+      ],
+
+      //barrel file내부에서 외부 모듈 사용 제한
+      "barrel-rules/isolate-barrel-file": [
+        "error",
+        {
+          //isolation options
+          isolations: [
+            {
+              path: "src/pages/*",
+              allowedPaths: ["src/features/*", "src/entities/*"],
+            },
+            {
+              path: "src/features/*",
+              allowedPaths: ["src/entities/*"],
+            },
+            {
+              path: "src/entities/*",
+              allowedPaths: [],
+            },
+          ],
+          baseDir: __dirname,
+          globalAllowPaths: ["src/shares/*", "node_modules/*"],
+        },
+      ],
+
+      // "*"를 사용한 불 분명한 import/export 방지
+      "barrel-rules/no-wildcard": ["error"],
   },
 };
 ```
@@ -172,22 +196,41 @@ export default tseslint.config([
     },
     // barrel-rules에 대한 설정만 추가하면 됩니다.
     rules: {
+      //barrel-file 캡슐화
       "barrel-rules/enforce-barrel-pattern": [
         "error",
         {
-          // 배럴 파일로 보호할 디렉토리의 경로입니다. baseDir을 기준으로 상대 경로로 설정합니다.
-          paths: ["src/typescript/barrel/*"],
-          // (옵션) 설정하지 않으면 기본값은 ESLint를 실행한 위치(작업 디렉토리)입니다.
-          // 예: `npx eslint .`처럼 실행하면, 실행 시점의 현재 디렉토리가 기본값이 됩니다.
+          // encapsulation barrel file
+          paths: ["src/pages/*", "src/features/*", "src/entities/*"],
           baseDir: __dirname,
-          // isolation 모드 활성화: barrel path 외부에서의 모든 import를 차단합니다.
-          isolated: true,
-          // "shared" 디렉토리만 직접 import를 허용합니다.
-          // 필요에 따라 이 배열에 "node_modules/*" 등 원하는 경로를 자유롭게 추가할 수 있습니다.
-          allowedImportPaths: ["src/typescript/shared", "node_modules/*"],
         },
       ],
-      // import * 또는 export * 금지
+
+      //barrel file내부에서 외부 모듈 사용 제한
+      "barrel-rules/isolate-barrel-file": [
+        "error",
+        {
+          //isolation options
+          isolations: [
+            {
+              path: "src/pages/*",
+              allowedPaths: ["src/features/*", "src/entities/*"],
+            },
+            {
+              path: "src/features/*",
+              allowedPaths: ["src/entities/*"],
+            },
+            {
+              path: "src/entities/*",
+              allowedPaths: [],
+            },
+          ],
+          baseDir: __dirname,
+          globalAllowPaths: ["src/shares/*"],
+        },
+      ],
+
+      // "*"를 사용한 불 분명한 import/export 방지
       "barrel-rules/no-wildcard": ["error"],
     },
   },
@@ -218,8 +261,6 @@ file(src / domains / foo / index.ts);
 // ❌ 격리된 barrel로의 외부 import 차단 (alias 사용해도 차단)
 // barrel 외부에서 접근 (bar의 경로는 src/domains/bar/)
 import { Test } from "@domains/bar/components/Test";
-// 또는
-import { Test } from "../domains/bar";
 
 // ✅ 같은 barrel 내부에서의 import는 허용 (alias 지원)
 import { Hook } from "@domains/foo/hooks/useTest"; // 같은 barrel 내부에서

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.2.0-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.3.1-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>
@@ -32,6 +32,9 @@ Direct imports from internal files are blocked, maximizing
 **modularity, abstraction, maintainability, and scalability**.
 
 > 💡 Tip:  
+> This plugin does not restrict or track imports from `node_modules` (external packages).  
+> The rules only apply to imports of internal (local source file) paths within your project.
+>
 > 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.
 
@@ -60,10 +63,9 @@ Direct imports from internal files are blocked, maximizing
 
 - **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.  
+  By enabling `isolate-barrel-file`, 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.
+  If you want to allow specific shared imports, you can use the `allowedPaths` or `globalAllowedPaths` option.
 
 - **Prevent Wildcard Import/Export**  
   Disallows wildcard (namespace) imports and exports such as `import * as foo from "module"` or `export * from "./module"`.  
@@ -76,17 +78,13 @@ Direct imports from internal files are blocked, maximizing
 
 ## Rules
 
-1. **enforce-barrel-pattern**  
+1. **enforce-barrel-pattern** (Isolation is exracted as new rule :))
    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.
+     - `baseDir`: The base directory for resolving `paths`. Defaults to the ESLint execution directory.
 
 2. **no-wildcard**  
    Disallows wildcard (namespace) imports such as `import * as foo from "module"` or `export * from "./module"`.  
@@ -94,6 +92,14 @@ Direct imports from internal files are blocked, maximizing
    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.
 
+3. **isolate-barrel-file** (New Rules!!!)
+   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 `allowedPaths` option.
+   - **Options:**
+     - `isolations(Array<{ path: string, allowedPaths: string[] }>)`: If you set isolation path, blocks all imports from outside the barrel path, even via the barrel file. Only allows imports within the same barrel path or from `allowedPaths` or `globalAllowedPaths`.
+     - `baseDir`: The base directory for resolving `paths`. Defaults to the ESLint execution directory.
+     - `globalAllowedPaths` : Array of paths that are allowed to be imported directly, even in isolation mode.
+
 ---
 
 ## Install
@@ -119,23 +125,44 @@ module.exports = {
   parser: "@typescript-eslint/parser",
   plugins: ["@typescript-eslint", "barrel-rules"],
   rules: {
-    "barrel-rules/enforce-barrel-pattern": [
-      "error",
-      {
-        // The path to the directory that should be protected by using a barrel file. This path is relative to baseDir.
-        paths: ["src/typescript/barrel/*", "src/javascript/barrel/*"],
-        // 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.
-    "barrel-rules/no-wildcard": ["error"],
+
+   //enforce barrel capsuling
+      "barrel-rules/enforce-barrel-pattern": [
+        "error",
+        {
+          // encapsulation barrel file
+          paths: ["src/pages/*", "src/features/*", "src/entities/*"],
+          baseDir: __dirname,
+        },
+      ],
+
+      //protect barrel file from outside module
+      "barrel-rules/isolate-barrel-file": [
+        "error",
+        {
+          //isolation options
+          isolations: [
+            {
+              path: "src/pages/*",
+              allowedPaths: ["src/features/*", "src/entities/*"],
+            },
+            {
+              path: "src/features/*",
+              allowedPaths: ["src/entities/*"],
+            },
+            {
+              path: "src/entities/*",
+              allowedPaths: [],
+            },
+          ],
+          baseDir: __dirname,
+          globalAllowPaths: ["src/shares/*", "node_modules/*"],
+        },
+      ],
+
+      // protect wildcard import/export
+      "barrel-rules/no-wildcard": ["error"],
+
   },
 };
 ```
@@ -173,23 +200,44 @@ export default tseslint.config([
     },
     //just set your setting for barrel-rules
     rules: {
+
+      //enforce barrel capsuling
       "barrel-rules/enforce-barrel-pattern": [
         "error",
         {
-          // The path to the directory that should be protected by using a barrel file. This path is relative to baseDir.
-          paths: ["src/typescript/barrel/*"],
-          // 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.
+          // encapsulation barrel file
+          paths: ["src/pages/*", "src/features/*", "src/entities/*"],
           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.
+
+      //protect barrel file from outside module
+      "barrel-rules/isolate-barrel-file": [
+        "error",
+        {
+          //isolation options
+          isolations: [
+            {
+              path: "src/pages/*",
+              allowedPaths: ["src/features/*", "src/entities/*"],
+            },
+            {
+              path: "src/features/*",
+              allowedPaths: ["src/entities/*"],
+            },
+            {
+              path: "src/entities/*",
+              allowedPaths: [],
+            },
+          ],
+          baseDir: __dirname,
+          globalAllowPaths: ["src/shares/*"],
+        },
+      ],
+
+      // protect wildcard import/export
       "barrel-rules/no-wildcard": ["error"],
+
     },
   },
 ]);
@@ -219,15 +267,13 @@ file(src / domains / foo / index.ts);
 // ❌ External import to isolated barrel is blocked (even with alias)
 // from outside barrel (bar's path is src/domains/bar/)
 import { Test } from "@domains/bar/components/Test";
-// or
-import { Test } from "../domains/bar";
 
 // ✅ Internal imports within same barrel are allowed (alias supported)
 import { Hook } from "@domains/foo/hooks/useTest"; // from inside same barrel
 import { Utils } from "./utils/helper"; // from inside same barrel
 
 // ✅ Allowed import paths are permitted (alias supported)
-import { SharedUtil } from "@shㅇㅇared/utils"; // if "src/shared/*" is in allowedImportPaths
+import { SharedUtil } from "@shared/utils"; // if "src/shared/*" is in allowedPaths or globalAllowedPaths
 ```
 
 ---

package/dist/index.cjs

@@ -35,22 +35,22 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/rules/enforce-barrel-pattern.ts
-var import_utils = require("@typescript-eslint/utils");
+var import_types = require("@typescript-eslint/types");
 var import_path2 = __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(path3, baseDir) {
-    const globResult = import_fast_glob.default.sync(path3, {
+  static resolvePath(path4, baseDir) {
+    const globResult = import_fast_glob.default.sync(path4, {
       cwd: baseDir,
       onlyDirectories: true,
       absolute: true
     });
     if (globResult.length === 0) {
       throw new Error(
-        `[Glob] In baseDir: ${baseDir}, path: ${path3}, any directory was not found`
+        `[Glob] In baseDir: ${baseDir}, path: ${path4}, any directory was not found`
       );
     }
     return globResult;
@@ -123,13 +123,20 @@ var BARREL_ENTRY_POINT_FILE_NAMES = [
 ];
 var RESOLVE_EXTENSIONS = [
   ".ts",
-  ".tsx",
   ".js",
+  ".tsx",
   ".jsx",
   ".json",
+  ".d.js",
   ".d.ts",
   ".mjs",
-  ".cjs"
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".d.mjs",
+  ".d.cjs",
+  ".d.mts",
+  ".d.cts"
 ];
 var enforceBarrelPattern = {
   meta: {
@@ -142,37 +149,47 @@ var enforceBarrelPattern = {
         type: "object",
         properties: {
           paths: { type: "array", items: { type: "string" } },
-          baseDir: { type: "string" },
-          isolated: { type: "boolean" },
-          allowedImportPaths: { type: "array", items: { type: "string" } }
+          baseDir: { type: "string" }
         },
-        required: ["paths"],
+        required: ["paths", "baseDir"],
         additionalProperties: false
       }
     ],
     messages: {
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config.",
       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."
+      EmptyEslintConfig: "Please set the eslint config '{{property}}' to the eslint config. if you want to use this rule, please set the eslint config."
     }
   },
   //default options(baseDir is current working directory. almost user execute eslint in project root)
   defaultOptions: [
     {
       paths: [],
-      baseDir: process.cwd(),
-      isolated: false,
-      allowedImportPaths: []
+      baseDir: process.cwd()
     }
   ],
   create(context) {
     const option = context.options[0];
+    if (!option) {
+      return {
+        Program(node) {
+          const option2 = context.options[0];
+          if (!option2) {
+            return context.report({
+              node,
+              messageId: "EmptyEslintConfig",
+              data: {
+                property: "{ path: Array<string>, baseDir: string }"
+              }
+            });
+          }
+        }
+      };
+    }
     const baseDir = option.baseDir;
     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)
       ImportDeclaration(node) {
@@ -187,12 +204,19 @@ var enforceBarrelPattern = {
           if (aliasResult.type === "success") {
             absoluteImportPath = aliasResult.absolutePath;
           } else {
+            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
             });
           }
         } catch (e) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
           return;
         }
         {
@@ -225,34 +249,138 @@ var enforceBarrelPattern = {
             });
           }
         }
-        {
-          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"
-              });
+      }
+    };
+  }
+};
+
+// src/rules/isolate-barrel-file.ts
+var import_types2 = require("@typescript-eslint/types");
+var import_path3 = __toESM(require("path"), 1);
+var import_resolve2 = __toESM(require("resolve"), 1);
+var RESOLVE_EXTENSIONS2 = [
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".json",
+  ".d.js",
+  ".d.ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".d.mjs",
+  ".d.cjs",
+  ".d.mts",
+  ".d.cts"
+];
+var isolateBarrelFile = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Isolate barrel file is not allowed to import outside of the barrel file"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          isolations: { type: "array", items: { type: "object" } },
+          baseDir: { type: "string" },
+          globalAllowPaths: { type: "array", items: { type: "string" } }
+        },
+        required: ["isolations", "baseDir", "globalAllowPaths"],
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config.",
+      IsolatedBarrelImportDisallowed: "This barrel file is isolated. external import is not allowed. if you want to import outside of the barrel file, please add 'allowedPath' to the plugin options."
+    }
+  },
+  //default options(baseDir is current working directory. almost user execute eslint in project root)
+  defaultOptions: [
+    {
+      isolations: [],
+      baseDir: process.cwd(),
+      globalAllowPaths: []
+    }
+  ],
+  create(context) {
+    const option = context.options[0];
+    const baseDir = option.baseDir;
+    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path4) => {
+      return Glob.resolvePath(path4, baseDir);
+    });
+    const absoluteIsolations = option.isolations.flatMap((isolation) => {
+      const isolationPaths = Glob.resolvePath(isolation.path, baseDir);
+      const allowedPaths = isolation.allowedPaths.flatMap((path4) => {
+        return Glob.resolvePath(path4, baseDir);
+      });
+      return isolationPaths.map((isolationPath) => ({
+        isolationPath,
+        //self isolatedPath also allowed to be imported
+        allowedPaths: [...allowedPaths, isolationPath]
+      }));
+    });
+    return {
+      //check only import declaration(ESM)
+      ImportDeclaration(node) {
+        const rawImportPath = node.source.value;
+        const absoluteCurrentFilePath = context.getFilename();
+        let absoluteImportPath = null;
+        try {
+          const aliasResult = Alias.resolvePath(
+            rawImportPath,
+            import_path3.default.dirname(absoluteCurrentFilePath)
+          );
+          if (aliasResult.type === "success") {
+            absoluteImportPath = aliasResult.absolutePath;
+          } else {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
+              return;
             }
+            absoluteImportPath = import_resolve2.default.sync(rawImportPath, {
+              basedir: import_path3.default.dirname(absoluteCurrentFilePath),
+              extensions: RESOLVE_EXTENSIONS2
+            });
           }
+        } catch (e) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
+          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 allowedImport = isAllowedImport || isGlobalAllowedImport;
+        if (!allowedImport) {
+          context.report({
+            node,
+            messageId: "IsolatedBarrelImportDisallowed"
+          });
         }
       }
     };
@@ -260,7 +388,7 @@ var enforceBarrelPattern = {
 };
 
 // src/rules/no-wildcard.ts
-var import_utils2 = require("@typescript-eslint/utils");
+var import_types3 = require("@typescript-eslint/types");
 var noWildcard = {
   meta: {
     type: "problem",
@@ -300,6 +428,7 @@ var noWildcard = {
 // src/index.ts
 var rules = {
   "enforce-barrel-pattern": enforceBarrelPattern,
+  "isolate-barrel-file": isolateBarrelFile,
   "no-wildcard": noWildcard
 };
 var index_default = { rules };

package/dist/index.d.cts

@@ -2,11 +2,17 @@ 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" | "IsolatedBarrelImportDisallowed", {
+        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed" | "TransformedAliasResolveFailed" | "EmptyEslintConfig", {
             paths: string[];
             baseDir: string;
-            isolated: boolean;
-            allowedImportPaths: string[];
+        }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "isolate-barrel-file": _typescript_eslint_utils_ts_eslint.RuleModule<"TransformedAliasResolveFailed" | "IsolatedBarrelImportDisallowed", {
+            isolations: {
+                path: string;
+                allowedPaths: string[];
+            }[];
+            baseDir: string;
+            globalAllowPaths: 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,11 +2,17 @@ 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" | "IsolatedBarrelImportDisallowed", {
+        "enforce-barrel-pattern": _typescript_eslint_utils_ts_eslint.RuleModule<"DirectImportDisallowed" | "TransformedAliasResolveFailed" | "EmptyEslintConfig", {
             paths: string[];
             baseDir: string;
-            isolated: boolean;
-            allowedImportPaths: string[];
+        }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "isolate-barrel-file": _typescript_eslint_utils_ts_eslint.RuleModule<"TransformedAliasResolveFailed" | "IsolatedBarrelImportDisallowed", {
+            isolations: {
+                path: string;
+                allowedPaths: string[];
+            }[];
+            baseDir: string;
+            globalAllowPaths: 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

@@ -1,20 +1,20 @@
 // src/rules/enforce-barrel-pattern.ts
-import "@typescript-eslint/utils";
+import "@typescript-eslint/types";
 import path2 from "path";
 import resolve from "resolve";
 
 // src/utils/glob.ts
 import FastGlob from "fast-glob";
 var Glob = class {
-  static resolvePath(path3, baseDir) {
-    const globResult = FastGlob.sync(path3, {
+  static resolvePath(path4, baseDir) {
+    const globResult = FastGlob.sync(path4, {
       cwd: baseDir,
       onlyDirectories: true,
       absolute: true
     });
     if (globResult.length === 0) {
       throw new Error(
-        `[Glob] In baseDir: ${baseDir}, path: ${path3}, any directory was not found`
+        `[Glob] In baseDir: ${baseDir}, path: ${path4}, any directory was not found`
       );
     }
     return globResult;
@@ -87,13 +87,20 @@ var BARREL_ENTRY_POINT_FILE_NAMES = [
 ];
 var RESOLVE_EXTENSIONS = [
   ".ts",
-  ".tsx",
   ".js",
+  ".tsx",
   ".jsx",
   ".json",
+  ".d.js",
   ".d.ts",
   ".mjs",
-  ".cjs"
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".d.mjs",
+  ".d.cjs",
+  ".d.mts",
+  ".d.cts"
 ];
 var enforceBarrelPattern = {
   meta: {
@@ -106,37 +113,47 @@ var enforceBarrelPattern = {
         type: "object",
         properties: {
           paths: { type: "array", items: { type: "string" } },
-          baseDir: { type: "string" },
-          isolated: { type: "boolean" },
-          allowedImportPaths: { type: "array", items: { type: "string" } }
+          baseDir: { type: "string" }
         },
-        required: ["paths"],
+        required: ["paths", "baseDir"],
         additionalProperties: false
       }
     ],
     messages: {
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config.",
       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."
+      EmptyEslintConfig: "Please set the eslint config '{{property}}' to the eslint config. if you want to use this rule, please set the eslint config."
     }
   },
   //default options(baseDir is current working directory. almost user execute eslint in project root)
   defaultOptions: [
     {
       paths: [],
-      baseDir: process.cwd(),
-      isolated: false,
-      allowedImportPaths: []
+      baseDir: process.cwd()
     }
   ],
   create(context) {
     const option = context.options[0];
+    if (!option) {
+      return {
+        Program(node) {
+          const option2 = context.options[0];
+          if (!option2) {
+            return context.report({
+              node,
+              messageId: "EmptyEslintConfig",
+              data: {
+                property: "{ path: Array<string>, baseDir: string }"
+              }
+            });
+          }
+        }
+      };
+    }
     const baseDir = option.baseDir;
     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)
       ImportDeclaration(node) {
@@ -151,12 +168,19 @@ var enforceBarrelPattern = {
           if (aliasResult.type === "success") {
             absoluteImportPath = aliasResult.absolutePath;
           } else {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
+              return;
+            }
             absoluteImportPath = resolve.sync(rawImportPath, {
               basedir: path2.dirname(absoluteCurrentFilePath),
               extensions: RESOLVE_EXTENSIONS
             });
           }
         } catch (e) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
           return;
         }
         {
@@ -189,34 +213,138 @@ var enforceBarrelPattern = {
             });
           }
         }
-        {
-          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"
-              });
+      }
+    };
+  }
+};
+
+// src/rules/isolate-barrel-file.ts
+import "@typescript-eslint/types";
+import path3 from "path";
+import resolve2 from "resolve";
+var RESOLVE_EXTENSIONS2 = [
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".json",
+  ".d.js",
+  ".d.ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".d.mjs",
+  ".d.cjs",
+  ".d.mts",
+  ".d.cts"
+];
+var isolateBarrelFile = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Isolate barrel file is not allowed to import outside of the barrel file"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          isolations: { type: "array", items: { type: "object" } },
+          baseDir: { type: "string" },
+          globalAllowPaths: { type: "array", items: { type: "string" } }
+        },
+        required: ["isolations", "baseDir", "globalAllowPaths"],
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config.",
+      IsolatedBarrelImportDisallowed: "This barrel file is isolated. external import is not allowed. if you want to import outside of the barrel file, please add 'allowedPath' to the plugin options."
+    }
+  },
+  //default options(baseDir is current working directory. almost user execute eslint in project root)
+  defaultOptions: [
+    {
+      isolations: [],
+      baseDir: process.cwd(),
+      globalAllowPaths: []
+    }
+  ],
+  create(context) {
+    const option = context.options[0];
+    const baseDir = option.baseDir;
+    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path4) => {
+      return Glob.resolvePath(path4, baseDir);
+    });
+    const absoluteIsolations = option.isolations.flatMap((isolation) => {
+      const isolationPaths = Glob.resolvePath(isolation.path, baseDir);
+      const allowedPaths = isolation.allowedPaths.flatMap((path4) => {
+        return Glob.resolvePath(path4, baseDir);
+      });
+      return isolationPaths.map((isolationPath) => ({
+        isolationPath,
+        //self isolatedPath also allowed to be imported
+        allowedPaths: [...allowedPaths, isolationPath]
+      }));
+    });
+    return {
+      //check only import declaration(ESM)
+      ImportDeclaration(node) {
+        const rawImportPath = node.source.value;
+        const absoluteCurrentFilePath = context.getFilename();
+        let absoluteImportPath = null;
+        try {
+          const aliasResult = Alias.resolvePath(
+            rawImportPath,
+            path3.dirname(absoluteCurrentFilePath)
+          );
+          if (aliasResult.type === "success") {
+            absoluteImportPath = aliasResult.absolutePath;
+          } else {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
+              return;
             }
+            absoluteImportPath = resolve2.sync(rawImportPath, {
+              basedir: path3.dirname(absoluteCurrentFilePath),
+              extensions: RESOLVE_EXTENSIONS2
+            });
           }
+        } catch (e) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
+          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 allowedImport = isAllowedImport || isGlobalAllowedImport;
+        if (!allowedImport) {
+          context.report({
+            node,
+            messageId: "IsolatedBarrelImportDisallowed"
+          });
         }
       }
     };
@@ -224,7 +352,7 @@ var enforceBarrelPattern = {
 };
 
 // src/rules/no-wildcard.ts
-import "@typescript-eslint/utils";
+import "@typescript-eslint/types";
 var noWildcard = {
   meta: {
     type: "problem",
@@ -264,6 +392,7 @@ var noWildcard = {
 // src/index.ts
 var rules = {
   "enforce-barrel-pattern": enforceBarrelPattern,
+  "isolate-barrel-file": isolateBarrelFile,
   "no-wildcard": noWildcard
 };
 var index_default = { rules };

package/package.json

@@ -25,15 +25,21 @@
     "isolated barrel module",
     "no-wildcard"
   ],
-  "version": "1.2.0",
+  "version": "1.3.1",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/parser": "^8.46.2",
+    "@typescript-eslint/rule-tester": "^8.46.2",
+    "@typescript-eslint/types": "^8.46.2",
     "@typescript-eslint/utils": "^8.36.0",
     "fast-glob": "^3.3.3",
+    "jest": "^30.2.0",
     "resolve": "^1.22.10",
+    "ts-jest": "^29.4.5",
     "tsconfig-paths": "^4.2.0"
   },
   "devDependencies": {
@@ -43,8 +49,11 @@
     "typescript": "~5.8.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts --dts --format cjs,esm",
+    "build": "pnpm run test && tsup src/index.ts --dts --format cjs,esm",
     "type-check": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "release": "pnpm run build && pnpm publish --access=public"
   }
 }