eslint-plugin-barrel-rules 1.1.1 → 1.2.0

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.2.0-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)도 효과적으로 감지하고 방지할 수 있습니다.
+
 ---
 
 ## 지원 환경
@@ -35,7 +39,12 @@ JavaScript/TypeScript 프로젝트에서 Barrel Pattern(배럴 패턴)을 강제
 - ESLint 9
   > Flat config(eslint.config.js), TypeScript 지원 시 "typescript-eslint" config 사용 필요
 - ESLint 8
+
   > Legacy config(.eslintrc.js), TypeScript 지원 시 "@typescript-eslint/parser"를 parser로 지정하고, "@typescript-eslint"를 plugin에 추가해야 함
+
+- TypeScript Alias Import 지원
+  > Import 구문에서 TypeScript 경로 별칭(예: `@ts/barrel/inner`)을 `tsconfig.json` 기반으로 자동 해석합니다.  
+  > 단, ESLint 플러그인 설정에서는 alias 사용 불가능 - 상대경로나 절대경로만 사용하세요.
 - Node.js (ES2015 이상)
 - ES 모듈, CommonJS 모듈 모두 지원
 
@@ -48,6 +57,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 +76,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 +126,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 +180,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 * 금지
@@ -162,25 +198,49 @@ export default tseslint.config([
 
 ## 예시
 
+### 1. 배럴 내부파일 직접 접근
+
 ```ts
-// ❌ 내부 파일을 직접 import하면 차단됩니다.
+file(src / index.ts);
+
+// ❌ 내부 파일 직접 import 차단
 import { Test } from "../domains/foo/components/Test";
 
-// ✅ 반드시 배럴(index) 파일을 통해 import해야 합니다.
+// ✅ barrel(index) 파일을 통한 import만 허용
 import { Test } from "../domains/foo";
 ```
 
+### 2. 격리된 모듈 접근 (TypeScript Alias 지원)
+
+```ts
+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 내부에서
+import { Utils } from "./utils/helper"; // 같은 barrel 내부에서
+
+// ✅ 허용된 import 경로는 사용 가능 (alias 지원)
+import { SharedUtil } from "@shared/utils"; // allowedImportPaths에 "src/shared/*"가 있는 경우
+```
+
 ---
 
 ## 앞으로의 계획
 
 - 더 다양한 모듈 경계/추상화 관련 룰 추가 예정 (~Ing)
-- Alias/tsconfig 지원: TypeScript의 paths, Vite의 resolve.alias, 기타 커스텀 경로 매핑을 완벽하게 지원 (~Ing)
+- **Alias/tsconfig 지원: TypeScript의 paths 맵핑 완벽하게 지원** (OK)
 - **CJS 지원** (OK)
 - **ESLint 8 지원** (OK)
 - **번들 플러그인(플러그인 내 모든 기능 통합)** (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.2.0-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
@@ -39,6 +43,9 @@ Direct imports from internal files are blocked, maximizing
   > Flat config(eslint.config.js), for TypeScript support, use the "typescript-eslint" config
 - ESLint 8
   > Legacy config(.eslintrc.js), for TypeScript support, set "@typescript-eslint/parser" as the parser and add "@typescript-eslint" as a plugin
+- TypeScript Alias Import Support
+  > Automatically resolves TypeScript path aliases (e.g., `@ts/barrel/inner`) in import statements based on your `tsconfig.json`.  
+  > Note: ESLint plugin configuration does not support aliases - use relative or absolute paths only.
 - Node.js (ES2015+)
 - Supports both ES Modules and CommonJS
 
@@ -51,6 +58,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 +79,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 +127,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 +181,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.
@@ -163,9 +197,13 @@ export default tseslint.config([
 
 ---
 
-## Example
+## Examples
+
+### 1. Direct Access
 
 ```ts
+file(src / index.ts);
+
 // ❌ Direct import from internal file is blocked
 import { Test } from "../domains/foo/components/Test";
 
@@ -173,6 +211,25 @@ import { Test } from "../domains/foo/components/Test";
 import { Test } from "../domains/foo";
 ```
 
+### 2. Isolated Module Access (with TypeScript Alias Support)
+
+```ts
+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
+```
+
 ---
 
 ## Future Work
@@ -180,14 +237,14 @@ import { Test } from "../domains/foo";
 - More rules for module boundaries and abstraction (~Ing)
 
 - **Alias/tsconfig Support**  
-  Fully supports TypeScript `paths`, Vite `resolve.alias`, and other custom path mappings (~Ing)
-
+  Fully supports TypeScript `paths` (OK)
 - **CJS Support** (OK)
 - **Eslint8 Support** (OK)
 - **Bundle Plugin(capsure any features in plugin)**
   (OK)
 - **Wrong Path Setup Validator** (OK)
 - **Wildcard Import/Export Protection Rule** (OK)
+- **Isolation Barrel Module** (OK)
 
 ---
 

package/dist/index.cjs

@@ -36,9 +36,101 @@ module.exports = __toCommonJS(index_exports);
 
 // src/rules/enforce-barrel-pattern.ts
 var import_utils = require("@typescript-eslint/utils");
-var import_path = __toESM(require("path"), 1);
+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, {
+      cwd: baseDir,
+      onlyDirectories: true,
+      absolute: true
+    });
+    if (globResult.length === 0) {
+      throw new Error(
+        `[Glob] In baseDir: ${baseDir}, path: ${path3}, any directory was not found`
+      );
+    }
+    return globResult;
+  }
+};
+
+// src/utils/alias.ts
+var import_tsconfig_paths = require("tsconfig-paths");
+var import_path = __toESM(require("path"), 1);
+var Alias = class {
+  constructor() {
+  }
+  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"
+              };
+            }
+          }
+        }
+      }
+      return {
+        absolutePath: rawPath,
+        type: "fail"
+      };
+    } catch (e) {
+      return {
+        absolutePath: rawPath,
+        type: "fail"
+      };
+    }
+  }
+};
+
+// 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 +142,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)
@@ -85,48 +180,79 @@ var enforceBarrelPattern = {
         const absoluteCurrentFilePath = context.getFilename();
         let absoluteImportPath = null;
         try {
-          absoluteImportPath = import_resolve.default.sync(rawImportPath, {
-            basedir: import_path.default.dirname(absoluteCurrentFilePath),
-            extensions: [
-              ".ts",
-              ".tsx",
-              ".js",
-              ".jsx",
-              ".json",
-              ".d.ts",
-              ".mjs",
-              ".cjs"
-            ]
-          });
+          const aliasResult = Alias.resolvePath(
+            rawImportPath,
+            import_path2.default.dirname(absoluteCurrentFilePath)
+          );
+          if (aliasResult.type === "success") {
+            absoluteImportPath = aliasResult.absolutePath;
+          } else {
+            absoluteImportPath = import_resolve.default.sync(rawImportPath, {
+              basedir: import_path2.default.dirname(absoluteCurrentFilePath),
+              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_path2.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

@@ -1,8 +1,100 @@
 // src/rules/enforce-barrel-pattern.ts
 import "@typescript-eslint/utils";
-import path from "path";
+import path2 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(path3, baseDir) {
+    const globResult = FastGlob.sync(path3, {
+      cwd: baseDir,
+      onlyDirectories: true,
+      absolute: true
+    });
+    if (globResult.length === 0) {
+      throw new Error(
+        `[Glob] In baseDir: ${baseDir}, path: ${path3}, any directory was not found`
+      );
+    }
+    return globResult;
+  }
+};
+
+// src/utils/alias.ts
+import { loadConfig } from "tsconfig-paths";
+import path from "path";
+var Alias = class {
+  constructor() {
+  }
+  static resolvePath(rawPath, currentFileDir) {
+    try {
+      const configResult = 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 = path.resolve(
+                `${configResult.absoluteBaseUrl}/${extendedOrigin}`
+              );
+              return {
+                absolutePath,
+                type: "success"
+              };
+            }
+          } else {
+            if (rawPath === pattern) {
+              const absolutePath = path.resolve(
+                `${configResult.absoluteBaseUrl}/${origin}`
+              );
+              return {
+                absolutePath,
+                type: "success"
+              };
+            }
+          }
+        }
+      }
+      return {
+        absolutePath: rawPath,
+        type: "fail"
+      };
+    } catch (e) {
+      return {
+        absolutePath: rawPath,
+        type: "fail"
+      };
+    }
+  }
+};
+
+// 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 +106,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)
@@ -49,48 +144,79 @@ var enforceBarrelPattern = {
         const absoluteCurrentFilePath = context.getFilename();
         let absoluteImportPath = null;
         try {
-          absoluteImportPath = resolve.sync(rawImportPath, {
-            basedir: path.dirname(absoluteCurrentFilePath),
-            extensions: [
-              ".ts",
-              ".tsx",
-              ".js",
-              ".jsx",
-              ".json",
-              ".d.ts",
-              ".mjs",
-              ".cjs"
-            ]
-          });
+          const aliasResult = Alias.resolvePath(
+            rawImportPath,
+            path2.dirname(absoluteCurrentFilePath)
+          );
+          if (aliasResult.type === "success") {
+            absoluteImportPath = aliasResult.absolutePath;
+          } else {
+            absoluteImportPath = resolve.sync(rawImportPath, {
+              basedir: path2.dirname(absoluteCurrentFilePath),
+              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) => path2.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.2.0",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",