@codeperfect/eslint-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CodePerfect
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# @codeperfect/eslint-plugin
+
+Custom ESLint rules for TypeScript repositories.
+
+## What this package provides
+
+`@codeperfect/eslint-plugin` ships a single ESLint plugin object, ready-to-use first-party presets, and direct exports for every package-owned rule. It does not compose third-party configs, load optional integrations, or provide a wrapper factory for `eslint.config.ts`.
+
+The package scope is intentionally narrow:
+
+- root preset exports for package-owned rules only
+- package-owned custom rules
+- rule documentation under `docs/rules/`
+- a small registry used by tests and benchmarks
+
+## Installation
+
+```bash
+npm install -D @codeperfect/eslint-plugin eslint
+```
+
+If you lint TypeScript files, also install and configure the parser or plugin stack that your repository already uses.
+
+## Usage
+
+Import a preset if you want the plugin registration and matching rules together:
+
+```typescript
+import { defineConfig } from "eslint/config";
+import { all } from "@codeperfect/eslint-plugin";
+
+export default defineConfig(all);
+```
+
+You can also use a narrower preset such as `architecture`, `core`, `docs`, `testing`, or `aaa`:
+
+```typescript
+import { defineConfig } from "eslint/config";
+import { aaa, testing } from "@codeperfect/eslint-plugin";
+
+export default defineConfig(testing, aaa);
+```
+
+Register the plugin directly in your local ESLint config when you want full manual control:
+
+```typescript
+import { defineConfig } from "eslint/config";
+import { parser } from "typescript-eslint";
+import codeperfectPlugin from "@codeperfect/eslint-plugin";
+
+export default defineConfig({
+  files: ["**/*.ts"],
+  languageOptions: {
+    parser,
+    sourceType: "module",
+  },
+  plugins: {
+    codeperfect: codeperfectPlugin,
+  },
+  rules: {
+    "codeperfect/prefer-interface-types": "error",
+    "codeperfect/require-example-language": "error",
+  },
+});
+```
+
+## Exported surface
+
+The root package exports:
+
+- the default plugin object
+- the named `codeperfectPlugin` export
+- the named preset exports: `all`, `architecture`, `core`, `docs`, `testing`, and `aaa`
+- the `customRules` registry
+- each rule module as a named export
+
+Example:
+
+```typescript
+import codeperfectPlugin, {
+  all,
+  customRules,
+  preferInterfaceTypesRule,
+} from "@codeperfect/eslint-plugin";
+
+void codeperfectPlugin;
+void all;
+void customRules;
+void preferInterfaceTypesRule;
+```
+
+## Package-owned rules
+
+- `codeperfect/assert-actual-expected-names`
+- `codeperfect/barrel-files-exports-only`
+- `codeperfect/consistent-barrel-files`
+- `codeperfect/enforce-aaa-phase-purity`
+- `codeperfect/enforce-aaa-structure`
+- `codeperfect/no-interface-member-docs`
+- `codeperfect/no-reexports-outside-barrels`
+- `codeperfect/prefer-interface-types`
+- `codeperfect/prefer-vi-mocked-import`
+- `codeperfect/require-aaa-sections`
+- `codeperfect/require-act-result-capture`
+- `codeperfect/require-example-language`
+- `codeperfect/require-test-companion`
+- `codeperfect/single-act-statement`
+- `codeperfect/single-line-jsdoc`
+
+Rule documentation lives in `docs/rules/` and each rule metadata entry points at the matching page.
+
+## Internal layout
+
+- `src/rules/` is the shared entrypoint for exported rule modules.
+- `src/architecture/`, `src/core/`, `src/docs/`, and `src/testing/` own the concrete rule implementations.
+- `src/custom-rules.ts` is the registry used by tests and benchmarks.
+
+## Validation
+
+When changing this package:
+
+- run `npm run validate`
+- run `npm run validate` a second time to confirm deterministic results
+- keep the README and rule documentation aligned with the exported surface
+
+## License
+
+MIT

package/dist/.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/benchmark-rules.ts","../src/codeperfect-plugin.ts","../src/custom-rule-documentation.ts","../src/custom-rules.ts","../src/index.ts","../src/presets.ts","../src/architecture/index.ts","../src/architecture/consistent-barrel-files/consistent-barrel-files-listeners.ts","../src/architecture/consistent-barrel-files/consistent-barrel-files-options.ts","../src/architecture/consistent-barrel-files/exports-only-rule-test-utilities.ts","../src/architecture/consistent-barrel-files/exports-only-rule.ts","../src/architecture/consistent-barrel-files/index.ts","../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.ts","../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.ts","../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts","../src/architecture/consistent-barrel-files/rule.ts","../src/architecture/consistent-barrel-files/test-helpers.ts","../src/architecture/consistent-barrel-files/types.ts","../src/core/index.ts","../src/core/no-multiple-declarators/index.ts","../src/core/no-multiple-declarators/rule.ts","../src/core/prefer-interface-types/index.ts","../src/core/prefer-interface-types/rule.ts","../src/core/prefer-interface-types/test-helpers.ts","../src/docs/index.ts","../src/docs/test-helpers.ts","../src/docs/no-interface-member-docs/comment-utilities-test-helpers.ts","../src/docs/no-interface-member-docs/comment-utilities.ts","../src/docs/no-interface-member-docs/index.ts","../src/docs/no-interface-member-docs/parameter-tags.ts","../src/docs/no-interface-member-docs/parameter-utilities.ts","../src/docs/no-interface-member-docs/rule.ts","../src/docs/no-interface-member-docs/test-helpers.ts","../src/docs/no-interface-member-docs/types.ts","../src/docs/require-example-language/empty-fence-fixes.ts","../src/docs/require-example-language/example-utilities.ts","../src/docs/require-example-language/examples.ts","../src/docs/require-example-language/fixes.ts","../src/docs/require-example-language/index.ts","../src/docs/require-example-language/reporting.ts","../src/docs/require-example-language/rule.ts","../src/docs/require-example-language/types.ts","../src/docs/single-line-jsdoc/index.ts","../src/docs/single-line-jsdoc/rule.ts","../src/docs/single-line-jsdoc/single-line-jsdoc-content.ts","../src/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts","../src/rules/index.ts","../src/testing/index.ts","../src/testing/aaa/analyzer.ts","../src/testing/aaa/index.ts","../src/testing/aaa/types.ts","../src/testing/assert-actual-expected-names/index.ts","../src/testing/assert-actual-expected-names/rule.ts","../src/testing/enforce-aaa-phase-purity/index.ts","../src/testing/enforce-aaa-phase-purity/rule.ts","../src/testing/enforce-aaa-structure/index.ts","../src/testing/enforce-aaa-structure/rule.ts","../src/testing/prefer-vi-mocked-import/fix.ts","../src/testing/prefer-vi-mocked-import/index.ts","../src/testing/prefer-vi-mocked-import/match-bindings.ts","../src/testing/prefer-vi-mocked-import/match-declarations.ts","../src/testing/prefer-vi-mocked-import/match-helpers.ts","../src/testing/prefer-vi-mocked-import/match-imports.ts","../src/testing/prefer-vi-mocked-import/match-rewrites.ts","../src/testing/prefer-vi-mocked-import/match-walk.ts","../src/testing/prefer-vi-mocked-import/match.ts","../src/testing/prefer-vi-mocked-import/rule.ts","../src/testing/prefer-vi-mocked-import/types.ts","../src/testing/require-aaa-sections/index.ts","../src/testing/require-aaa-sections/rule.ts","../src/testing/require-act-result-capture/index.ts","../src/testing/require-act-result-capture/rule.ts","../src/testing/require-test-companion/index.ts","../src/testing/require-test-companion/require-test-companion-listeners.ts","../src/testing/require-test-companion/require-test-companion-options.ts","../src/testing/require-test-companion/require-test-companion-test-helpers.ts","../src/testing/require-test-companion/require-test-companion-utilities.ts","../src/testing/require-test-companion/rule.ts","../src/testing/require-test-companion/types.ts","../src/testing/single-act-statement/index.ts","../src/testing/single-act-statement/rule.ts","../conventional-changelog-conventionalcommits.d.ts","../eslint-plugin-jasmine.d.ts"],"version":"5.9.3"}

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-listeners.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type { ConsistentBarrelFilesState } from "./consistent-barrel-files-options";
+/**
+ * Builds a listener for a specific file.
+ * @param context Rule execution context.
+ * @param filename Absolute filename.
+ * @param options Normalized rule options.
+ * @returns The rule listener for the file.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForFile(context, filename, state);
+ * ```
+ */
+declare const buildListenerForFile: (context: Rule.RuleContext, filename: string, options: ConsistentBarrelFilesState) => Rule.RuleListener;
+export { buildListenerForFile };
+//# sourceMappingURL=consistent-barrel-files-listeners.d.ts.map

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-barrel-files-listeners.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/consistent-barrel-files-listeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AA6IpF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,IAAI,CAAC,WAAW,EACzB,UAAU,MAAM,EAChB,SAAS,0BAA0B,KAClC,IAAI,CAAC,YAcP,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-listeners.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+import { shouldLintFile } from "./consistent-barrel-files-options";
+/** Cache to avoid repeated directory scans. */
+const directoryCache = new Map();
+/** Tracks cache keys already reported as missing barrels. */
+const reportedMissing = new Set();
+/**
+ * Checks hasBarrelFile.
+ * @param directory Input directory value.
+ * @param names Input names value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasBarrelFile();
+ * ```
+ */
+const hasBarrelFile = (directory, names) => names.some((name) => fs.existsSync(path.join(directory, name)));
+/**
+ * Gets cached barrel presence or computes it.
+ * @param cacheKey Cache key for the lookup.
+ * @param directory Directory to scan.
+ * @param names Allowed barrel filenames.
+ * @returns True when a barrel file exists.
+ * @example
+ * ```typescript
+ * const exists = getCachedBarrelPresence(key, directory, names);
+ * ```
+ */
+const getCachedBarrelPresence = (cacheKey, directory, names) => {
+    const cached = directoryCache.get(cacheKey);
+    if (cached !== void 0) {
+        return cached;
+    }
+    const hasBarrel = hasBarrelFile(directory, names);
+    directoryCache.set(cacheKey, hasBarrel);
+    return hasBarrel;
+};
+/**
+ * Builds a listener for a directory when enforcement is enabled.
+ * @param context Rule execution context.
+ * @param directory Directory to inspect.
+ * @param options Normalized rule options.
+ * @returns The rule listener for the directory.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForDirectory(context, dir, state);
+ * ```
+ */
+const buildListenerForDirectory = (context, directory, options) => {
+    const cacheKey = `${directory}|${options.namesKey}`;
+    if (getCachedBarrelPresence(cacheKey, directory, options.names)) {
+        return {};
+    }
+    return buildMissingListener(context, options.names, cacheKey);
+};
+/**
+ * Builds a listener for forbidden barrel files.
+ * @param context Rule execution context.
+ * @param basename Filename being checked.
+ * @param namesSet Allowed barrel names.
+ * @returns The rule listener for forbidden barrels.
+ * @example
+ * ```typescript
+ * const listener = buildForbiddenListener(context, basename, names);
+ * ```
+ */
+const buildForbiddenListener = (context, basename, namesSet) => {
+    if (!namesSet.has(basename)) {
+        return {};
+    }
+    return {
+        Program(node) {
+            context.report({
+                data: { name: basename },
+                messageId: "forbiddenBarrel",
+                node,
+            });
+        },
+    };
+};
+/**
+ * Builds a listener that reports missing barrel files.
+ * @param context Rule execution context.
+ * @param names Allowed barrel names.
+ * @param cacheKey Cache key for the directory.
+ * @returns The rule listener for missing barrels.
+ * @example
+ * ```typescript
+ * const listener = buildMissingListener(context, names, cacheKey);
+ * ```
+ */
+const buildMissingListener = (context, names, cacheKey) => {
+    if (reportedMissing.has(cacheKey)) {
+        return {};
+    }
+    reportedMissing.add(cacheKey);
+    return {
+        Program(node) {
+            context.report({
+                data: { names: names.join(", ") },
+                messageId: "missingBarrel",
+                node,
+            });
+        },
+    };
+};
+/**
+ * Builds a listener for a specific file.
+ * @param context Rule execution context.
+ * @param filename Absolute filename.
+ * @param options Normalized rule options.
+ * @returns The rule listener for the file.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForFile(context, filename, state);
+ * ```
+ */
+const buildListenerForFile = (context, filename, options) => {
+    const { enforce, folders, names, namesSet } = options;
+    if (!shouldLintFile(filename, folders, names)) {
+        return {};
+    }
+    const basename = path.basename(filename);
+    if (!enforce) {
+        return buildForbiddenListener(context, basename, namesSet);
+    }
+    return buildListenerForDirectory(context, path.dirname(filename), options);
+};
+export { buildListenerForFile };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"consistent-barrel-files-listeners.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/consistent-barrel-files-listeners.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAI7B,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEnE,+CAA+C;AAC/C,MAAM,cAAc,GAAG,IAAI,GAAG,EAAmB,CAAC;AAElD,6DAA6D;AAC7D,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;AAE1C;;;;;;;;;GASG;AACH,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAE,KAAe,EAAW,EAAE,CACpE,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;GAUG;AACH,MAAM,uBAAuB,GAAG,CAC9B,QAAgB,EAChB,SAAiB,EACjB,KAAe,EACN,EAAE;IACX,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAE5C,IAAI,MAAM,KAAK,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAElD,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAExC,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,yBAAyB,GAAG,CAChC,OAAyB,EACzB,SAAiB,EACjB,OAAmC,EAChB,EAAE;IACrB,MAAM,QAAQ,GAAG,GAAG,SAAS,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAEpD,IAAI,uBAAuB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,sBAAsB,GAAG,CAC7B,OAAyB,EACzB,QAAgB,EAChB,QAA6B,EACV,EAAE;IACrB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO;QACL,OAAO,CAAC,IAAI;YACV,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACxB,SAAS,EAAE,iBAAiB;gBAC5B,IAAI;aACL,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,oBAAoB,GAAG,CAC3B,OAAyB,EACzB,KAAe,EACf,QAAgB,EACG,EAAE;IACrB,IAAI,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAE9B,OAAO;QACL,OAAO,CAAC,IAAI;YACV,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACjC,SAAS,EAAE,eAAe;gBAC1B,IAAI;aACL,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,oBAAoB,GAAG,CAC3B,OAAyB,EACzB,QAAgB,EAChB,OAAmC,EAChB,EAAE;IACrB,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAEtD,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC;QAC9C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAEzC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAED,OAAO,yBAAyB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\n\nimport type { ConsistentBarrelFilesState } from \"./consistent-barrel-files-options\";\n\nimport { shouldLintFile } from \"./consistent-barrel-files-options\";\n\n/** Cache to avoid repeated directory scans. */\nconst directoryCache = new Map<string, boolean>();\n\n/** Tracks cache keys already reported as missing barrels. */\nconst reportedMissing = new Set<string>();\n\n/**\n * Checks hasBarrelFile.\n * @param directory Input directory value.\n * @param names Input names value.\n * @returns Return value output.\n * @example\n * ```typescript\n * hasBarrelFile();\n * ```\n */\nconst hasBarrelFile = (directory: string, names: string[]): boolean =>\n  names.some((name) => fs.existsSync(path.join(directory, name)));\n\n/**\n * Gets cached barrel presence or computes it.\n * @param cacheKey Cache key for the lookup.\n * @param directory Directory to scan.\n * @param names Allowed barrel filenames.\n * @returns True when a barrel file exists.\n * @example\n * ```typescript\n * const exists = getCachedBarrelPresence(key, directory, names);\n * ```\n */\nconst getCachedBarrelPresence = (\n  cacheKey: string,\n  directory: string,\n  names: string[],\n): boolean => {\n  const cached = directoryCache.get(cacheKey);\n\n  if (cached !== void 0) {\n    return cached;\n  }\n\n  const hasBarrel = hasBarrelFile(directory, names);\n\n  directoryCache.set(cacheKey, hasBarrel);\n\n  return hasBarrel;\n};\n\n/**\n * Builds a listener for a directory when enforcement is enabled.\n * @param context Rule execution context.\n * @param directory Directory to inspect.\n * @param options Normalized rule options.\n * @returns The rule listener for the directory.\n * @example\n * ```typescript\n * const listener = buildListenerForDirectory(context, dir, state);\n * ```\n */\nconst buildListenerForDirectory = (\n  context: Rule.RuleContext,\n  directory: string,\n  options: ConsistentBarrelFilesState,\n): Rule.RuleListener => {\n  const cacheKey = `${directory}|${options.namesKey}`;\n\n  if (getCachedBarrelPresence(cacheKey, directory, options.names)) {\n    return {};\n  }\n\n  return buildMissingListener(context, options.names, cacheKey);\n};\n\n/**\n * Builds a listener for forbidden barrel files.\n * @param context Rule execution context.\n * @param basename Filename being checked.\n * @param namesSet Allowed barrel names.\n * @returns The rule listener for forbidden barrels.\n * @example\n * ```typescript\n * const listener = buildForbiddenListener(context, basename, names);\n * ```\n */\nconst buildForbiddenListener = (\n  context: Rule.RuleContext,\n  basename: string,\n  namesSet: ReadonlySet<string>,\n): Rule.RuleListener => {\n  if (!namesSet.has(basename)) {\n    return {};\n  }\n\n  return {\n    Program(node): void {\n      context.report({\n        data: { name: basename },\n        messageId: \"forbiddenBarrel\",\n        node,\n      });\n    },\n  };\n};\n\n/**\n * Builds a listener that reports missing barrel files.\n * @param context Rule execution context.\n * @param names Allowed barrel names.\n * @param cacheKey Cache key for the directory.\n * @returns The rule listener for missing barrels.\n * @example\n * ```typescript\n * const listener = buildMissingListener(context, names, cacheKey);\n * ```\n */\nconst buildMissingListener = (\n  context: Rule.RuleContext,\n  names: string[],\n  cacheKey: string,\n): Rule.RuleListener => {\n  if (reportedMissing.has(cacheKey)) {\n    return {};\n  }\n\n  reportedMissing.add(cacheKey);\n\n  return {\n    Program(node): void {\n      context.report({\n        data: { names: names.join(\", \") },\n        messageId: \"missingBarrel\",\n        node,\n      });\n    },\n  };\n};\n\n/**\n * Builds a listener for a specific file.\n * @param context Rule execution context.\n * @param filename Absolute filename.\n * @param options Normalized rule options.\n * @returns The rule listener for the file.\n * @example\n * ```typescript\n * const listener = buildListenerForFile(context, filename, state);\n * ```\n */\nconst buildListenerForFile = (\n  context: Rule.RuleContext,\n  filename: string,\n  options: ConsistentBarrelFilesState,\n): Rule.RuleListener => {\n  const { enforce, folders, names, namesSet } = options;\n\n  if (!shouldLintFile(filename, folders, names)) {\n    return {};\n  }\n\n  const basename = path.basename(filename);\n\n  if (!enforce) {\n    return buildForbiddenListener(context, basename, namesSet);\n  }\n\n  return buildListenerForDirectory(context, path.dirname(filename), options);\n};\n\nexport { buildListenerForFile };\n"]}

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-options.d.ts

@@ -0,0 +1,48 @@
+/** Type definition for rule data. */
+interface ConsistentBarrelFilesState {
+    /** Enforce field value. */
+    enforce: boolean;
+    /** Folders field value. */
+    folders: string[];
+    /** Names field value. */
+    names: string[];
+    /** NamesKey field value. */
+    namesKey: string;
+    /** NamesSet field value. */
+    namesSet: Set<string>;
+}
+/**
+ * Builds normalized rule options from raw input.
+ * @param options Raw rule options array.
+ * @returns Normalized rule options.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+declare const getOptions: (options: readonly unknown[]) => ConsistentBarrelFilesState;
+/**
+ * Checks isLintableFilename.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLintableFilename();
+ * ```
+ */
+declare const isLintableFilename: (filename: string) => boolean;
+/**
+ * Determines whether a file should be checked.
+ * @param filename Absolute filename.
+ * @param folders Folder glob patterns.
+ * @param names Allowed barrel names.
+ * @returns True when the file should be linted.
+ * @example
+ * ```typescript
+ * const ok = shouldLintFile(filename, folders, names);
+ * ```
+ */
+declare const shouldLintFile: (filename: string, folders: string[], names: string[]) => boolean;
+export { getOptions, isLintableFilename, shouldLintFile };
+export type { ConsistentBarrelFilesState };
+//# sourceMappingURL=consistent-barrel-files-options.d.ts.map

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-barrel-files-options.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/consistent-barrel-files-options.ts"],"names":[],"mappings":"AAWA,qCAAqC;AACrC,UAAU,0BAA0B;IAClC,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,yBAAyB;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB;AAoDD;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,0BAQF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OACG,CAAC;AAoCnD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,cAAc,GAClB,UAAU,MAAM,EAChB,SAAS,MAAM,EAAE,EACjB,OAAO,MAAM,EAAE,KACd,OAUF,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC;AAC1D,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/architecture/consistent-barrel-files/consistent-barrel-files-options.js

@@ -0,0 +1,126 @@
+import { minimatch } from "minimatch";
+import path from "node:path";
+/** Default value used by this module. */
+const DEFAULT_BARREL_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+/** Default folder globs for barrel file checks. */
+const DEFAULT_FOLDER_GLOBS = ["src/**"];
+/**
+ * Normalizes normalizeNames.
+ * @param names Input names value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeNames();
+ * ```
+ */
+const normalizeNames = (names) => {
+    if (Array.isArray(names)) {
+        return names
+            .filter((name) => typeof name === "string")
+            .map((name) => name.trim())
+            .filter((name) => name.length > 0);
+    }
+    if (typeof names === "string") {
+        const trimmed = names.trim();
+        return trimmed.length === 0 ? [] : [trimmed];
+    }
+    return [...DEFAULT_BARREL_NAMES];
+};
+/**
+ * Normalizes normalizeFolders.
+ * @param folders Input folders value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeFolders();
+ * ```
+ */
+const normalizeFolders = (folders) => {
+    if (Array.isArray(folders)) {
+        return folders
+            .filter((folder) => typeof folder === "string")
+            .map((folder) => folder.trim())
+            .filter((folder) => folder.length > 0);
+    }
+    if (typeof folders === "string") {
+        const trimmed = folders.trim();
+        return trimmed.length === 0 ? [] : [trimmed];
+    }
+    return [...DEFAULT_FOLDER_GLOBS];
+};
+/**
+ * Builds normalized rule options from raw input.
+ * @param options Raw rule options array.
+ * @returns Normalized rule options.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+const getOptions = (options) => {
+    const rawOptions = options[0];
+    const enforce = rawOptions?.enforce ?? true;
+    const folders = normalizeFolders(rawOptions?.folders);
+    const names = normalizeNames(rawOptions?.names);
+    const namesKey = names.toSorted().join("|");
+    return { enforce, folders, names, namesKey, namesSet: new Set(names) };
+};
+/**
+ * Checks isLintableFilename.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLintableFilename();
+ * ```
+ */
+const isLintableFilename = (filename) => filename.length > 0 && path.isAbsolute(filename);
+/**
+ * Normalizes normalizeRelativePath.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeRelativePath();
+ * ```
+ */
+const normalizeRelativePath = (filename) => path.relative(process.cwd(), filename).split(path.sep).join("/");
+/**
+ * Checks isPathInFolders.
+ * @param filename Input filename value.
+ * @param folders Input folders value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isPathInFolders();
+ * ```
+ */
+const isPathInFolders = (filename, folders) => {
+    const relativePath = normalizeRelativePath(filename);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return false;
+    }
+    return folders.some((folder) => minimatch(relativePath, folder, { dot: true }));
+};
+/**
+ * Determines whether a file should be checked.
+ * @param filename Absolute filename.
+ * @param folders Folder glob patterns.
+ * @param names Allowed barrel names.
+ * @returns True when the file should be linted.
+ * @example
+ * ```typescript
+ * const ok = shouldLintFile(filename, folders, names);
+ * ```
+ */
+const shouldLintFile = (filename, folders, names) => {
+    if (folders.length === 0) {
+        return false;
+    }
+    if (!isPathInFolders(filename, folders)) {
+        return false;
+    }
+    return names.length > 0;
+};
+export { getOptions, isLintableFilename, shouldLintFile };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"consistent-barrel-files-options.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/consistent-barrel-files-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { minimatch } from \"minimatch\";\nimport path from \"node:path\";\n\nimport type { ConsistentBarrelFilesOptions } from \"./types\";\n\n/** Default value used by this module. */\nconst DEFAULT_BARREL_NAMES = [\"index.ts\", \"index.tsx\", \"index.js\", \"index.jsx\"];\n\n/** Default folder globs for barrel file checks. */\nconst DEFAULT_FOLDER_GLOBS = [\"src/**\"];\n\n/** Type definition for rule data. */\ninterface ConsistentBarrelFilesState {\n  /** Enforce field value. */\n  enforce: boolean;\n\n  /** Folders field value. */\n  folders: string[];\n\n  /** Names field value. */\n  names: string[];\n\n  /** NamesKey field value. */\n  namesKey: string;\n\n  /** NamesSet field value. */\n  namesSet: Set<string>;\n}\n\n/**\n * Normalizes normalizeNames.\n * @param names Input names value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeNames();\n * ```\n */\nconst normalizeNames = (names: unknown): string[] => {\n  if (Array.isArray(names)) {\n    return names\n      .filter((name): name is string => typeof name === \"string\")\n      .map((name) => name.trim())\n      .filter((name) => name.length > 0);\n  }\n\n  if (typeof names === \"string\") {\n    const trimmed = names.trim();\n    return trimmed.length === 0 ? [] : [trimmed];\n  }\n\n  return [...DEFAULT_BARREL_NAMES];\n};\n\n/**\n * Normalizes normalizeFolders.\n * @param folders Input folders value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeFolders();\n * ```\n */\nconst normalizeFolders = (folders: unknown): string[] => {\n  if (Array.isArray(folders)) {\n    return folders\n      .filter((folder): folder is string => typeof folder === \"string\")\n      .map((folder) => folder.trim())\n      .filter((folder) => folder.length > 0);\n  }\n\n  if (typeof folders === \"string\") {\n    const trimmed = folders.trim();\n    return trimmed.length === 0 ? [] : [trimmed];\n  }\n\n  return [...DEFAULT_FOLDER_GLOBS];\n};\n\n/**\n * Builds normalized rule options from raw input.\n * @param options Raw rule options array.\n * @returns Normalized rule options.\n * @example\n * ```typescript\n * const state = getOptions([{}]);\n * ```\n */\nconst getOptions = (\n  options: readonly unknown[],\n): ConsistentBarrelFilesState => {\n  const rawOptions = options[0] as ConsistentBarrelFilesOptions | undefined;\n  const enforce = rawOptions?.enforce ?? true;\n  const folders = normalizeFolders(rawOptions?.folders);\n  const names = normalizeNames(rawOptions?.names);\n  const namesKey = names.toSorted().join(\"|\");\n\n  return { enforce, folders, names, namesKey, namesSet: new Set(names) };\n};\n\n/**\n * Checks isLintableFilename.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isLintableFilename();\n * ```\n */\nconst isLintableFilename = (filename: string): boolean =>\n  filename.length > 0 && path.isAbsolute(filename);\n\n/**\n * Normalizes normalizeRelativePath.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeRelativePath();\n * ```\n */\nconst normalizeRelativePath = (filename: string): string =>\n  path.relative(process.cwd(), filename).split(path.sep).join(\"/\");\n\n/**\n * Checks isPathInFolders.\n * @param filename Input filename value.\n * @param folders Input folders value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isPathInFolders();\n * ```\n */\nconst isPathInFolders = (filename: string, folders: string[]): boolean => {\n  const relativePath = normalizeRelativePath(filename);\n\n  if (relativePath.startsWith(\"..\") || path.isAbsolute(relativePath)) {\n    return false;\n  }\n\n  return folders.some((folder) =>\n    minimatch(relativePath, folder, { dot: true }),\n  );\n};\n\n/**\n * Determines whether a file should be checked.\n * @param filename Absolute filename.\n * @param folders Folder glob patterns.\n * @param names Allowed barrel names.\n * @returns True when the file should be linted.\n * @example\n * ```typescript\n * const ok = shouldLintFile(filename, folders, names);\n * ```\n */\nconst shouldLintFile = (\n  filename: string,\n  folders: string[],\n  names: string[],\n): boolean => {\n  if (folders.length === 0) {\n    return false;\n  }\n\n  if (!isPathInFolders(filename, folders)) {\n    return false;\n  }\n\n  return names.length > 0;\n};\n\nexport { getOptions, isLintableFilename, shouldLintFile };\nexport type { ConsistentBarrelFilesState };\n"]}

package/dist/architecture/consistent-barrel-files/exports-only-rule-test-utilities.d.ts

@@ -0,0 +1,40 @@
+import type * as ESTree from "estree";
+import type { BarrelFilesExportsOnlyOptions } from "./types";
+/** Type definition for rule data. */
+interface RuleReport {
+    /** MessageId helper value. */
+    messageId: string | undefined;
+}
+/** Type definition for rule data. */
+interface TemporaryRunner {
+    /** RunDefaultIndex field value. */
+    runDefaultIndex: (body: ESTree.Program["body"]) => RuleReport[];
+    /** RunTemporaryFeature field value. */
+    runTemporaryFeature: (body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+    /** RunTemporaryIndex field value. */
+    runTemporaryIndex: (body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+}
+/**
+ * Runs the rule against the provided AST body.
+ * @param filename Target filename.
+ * @param body AST program body.
+ * @param options Rule options when provided.
+ * @returns The captured rule reports.
+ * @example
+ * ```typescript
+ * const reports = runRule("index.ts", createBody());
+ * ```
+ */
+declare const runRule: (filename: string, body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+/**
+ * Creates temporary file runners for the rule.
+ * @param temporaryDirectories Directories created during the run.
+ * @returns Helpers for running the rule in temp folders.
+ * @example
+ * ```typescript
+ * const runner = createTemporaryRunner([]);
+ * ```
+ */
+declare const createTemporaryRunner: (temporaryDirectories: string[]) => TemporaryRunner;
+export { createTemporaryRunner, runRule };
+//# sourceMappingURL=exports-only-rule-test-utilities.d.ts.map

package/dist/architecture/consistent-barrel-files/exports-only-rule-test-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports-only-rule-test-utilities.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/exports-only-rule-test-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAKtC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AA0B7D,qCAAqC;AACrC,UAAU,UAAU;IAClB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAiBD,qCAAqC;AACrC,UAAU,eAAe;IACvB,mCAAmC;IACnC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;IAEhE,uCAAuC;IACvC,mBAAmB,EAAE,CACnB,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,6BAA6B,KACpC,UAAU,EAAE,CAAC;IAElB,qCAAqC;IACrC,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,6BAA6B,KACpC,UAAU,EAAE,CAAC;CACnB;AAkCD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,OAAO,GACX,UAAU,MAAM,EAChB,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,UAAU,6BAA6B,KACtC,UAAU,EAeZ,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,sBAAsB,MAAM,EAAE,KAC7B,eAmCF,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,CAAC"}