eslint-plugin-barrel-rules 1.1.3 → 1.3.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.3-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.3.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>
@@ -39,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 모듈 모두 지원
 
@@ -53,11 +58,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를 금지합니다.  
@@ -70,17 +71,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를 금지합니다.  
@@ -88,6 +85,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)
+
 ---
 
 ## 설치
@@ -113,23 +118,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"],
   },
 };
 ```
@@ -167,22 +192,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/*", "node_modules/*"],
+        },
+      ],
+
+      // "*"를 사용한 불 분명한 import/export 방지
       "barrel-rules/no-wildcard": ["error"],
     },
   },
@@ -193,20 +237,41 @@ 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";
+
+// ✅ 같은 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)

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.3-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.3.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>
@@ -43,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
 
@@ -57,10 +60,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"`.  
@@ -73,17 +75,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"`.  
@@ -91,6 +89,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
@@ -116,23 +122,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"],
+
   },
 };
 ```
@@ -170,23 +197,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/*", "node_modules/*"],
+        },
+      ],
+
+      // protect wildcard import/export
       "barrel-rules/no-wildcard": ["error"],
+
     },
   },
 ]);
@@ -194,9 +242,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";
 
@@ -204,6 +256,23 @@ 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";
+
+// ✅ 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 "@shared/utils"; // if "src/shared/*" is in allowedPaths or globalAllowedPaths
+```
+
 ---
 
 ## Future Work
@@ -211,8 +280,7 @@ 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)**

package/dist/index.cjs

@@ -35,28 +35,82 @@ __export(index_exports, {
 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_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(path2, baseDir) {
-    const globResult = import_fast_glob.default.sync(path2, {
+  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: ${path2}, any directory was not found`
+        `[Glob] In baseDir: ${baseDir}, path: ${path4}, 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",
@@ -88,37 +142,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) {
@@ -126,11 +190,23 @@ var enforceBarrelPattern = {
         const absoluteCurrentFilePath = context.getFilename();
         let absoluteImportPath = null;
         try {
-          absoluteImportPath = import_resolve.default.sync(rawImportPath, {
-            basedir: import_path.default.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
-          });
+          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) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
           return;
         }
         {
@@ -138,7 +214,7 @@ var enforceBarrelPattern = {
           const invalidDirectedImport = absoluteTargetPaths.some(
             (absoluteTargetPath) => {
               const targetPathEntryPoints = BARREL_ENTRY_POINT_FILE_NAMES.map(
-                (entry) => import_path.default.resolve(absoluteTargetPath, entry)
+                (entry) => import_path2.default.resolve(absoluteTargetPath, entry)
               );
               const closedTargetPath = absoluteTargetPath + "/";
               const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
@@ -163,34 +239,127 @@ 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",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".d.ts",
+  ".mjs",
+  ".cjs"
+];
+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 {
+            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"
+          });
         }
       }
     };
@@ -198,7 +367,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",
@@ -238,6 +407,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,26 +1,80 @@
 // src/rules/enforce-barrel-pattern.ts
-import "@typescript-eslint/utils";
-import path from "path";
+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(path2, baseDir) {
-    const globResult = FastGlob.sync(path2, {
+  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: ${path2}, any directory was not found`
+        `[Glob] In baseDir: ${baseDir}, path: ${path4}, 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",
@@ -52,37 +106,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) {
@@ -90,11 +154,23 @@ var enforceBarrelPattern = {
         const absoluteCurrentFilePath = context.getFilename();
         let absoluteImportPath = null;
         try {
-          absoluteImportPath = resolve.sync(rawImportPath, {
-            basedir: path.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
-          });
+          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) {
+          context.report({
+            node,
+            messageId: "TransformedAliasResolveFailed"
+          });
           return;
         }
         {
@@ -102,7 +178,7 @@ var enforceBarrelPattern = {
           const invalidDirectedImport = absoluteTargetPaths.some(
             (absoluteTargetPath) => {
               const targetPathEntryPoints = BARREL_ENTRY_POINT_FILE_NAMES.map(
-                (entry) => path.resolve(absoluteTargetPath, entry)
+                (entry) => path2.resolve(absoluteTargetPath, entry)
               );
               const closedTargetPath = absoluteTargetPath + "/";
               const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
@@ -127,34 +203,127 @@ 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",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".d.ts",
+  ".mjs",
+  ".cjs"
+];
+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 {
+            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"
+          });
         }
       }
     };
@@ -162,7 +331,7 @@ var enforceBarrelPattern = {
 };
 
 // src/rules/no-wildcard.ts
-import "@typescript-eslint/utils";
+import "@typescript-eslint/types";
 var noWildcard = {
   meta: {
     type: "problem",
@@ -202,6 +371,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.1.3",
+  "version": "1.3.0",
   "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"
   }
 }