@codeperfect/eslint-plugin 1.0.0

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

@@ -0,0 +1,90 @@
+import { SourceCode } from "eslint";
+import path from "node:path";
+import { barrelFilesExportsOnlyRule } from "./exports-only-rule";
+import { createProgram, createRepoDirectory } from "./test-helpers";
+/**
+ * Builds a rule context for running the rule.
+ * @param parameters Context parameters and report sink.
+ * @returns The ESLint rule context.
+ * @example
+ * ```typescript
+ * const context = createRuleContext({ filename, reports, sourceCode });
+ * ```
+ */
+const createRuleContext = (parameters) => ({
+    cwd: process.cwd(),
+    filename: parameters.filename,
+    id: "barrel-files-exports-only",
+    languageOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+    },
+    options: parameters.options === void 0 ? [] : [parameters.options],
+    parserOptions: {},
+    parserPath: void 0,
+    physicalFilename: parameters.filename,
+    report: (report) => {
+        const { messageId } = report;
+        parameters.reports.push({ messageId });
+    },
+    settings: {},
+    sourceCode: parameters.sourceCode,
+});
+/**
+ * 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());
+ * ```
+ */
+const runRule = (filename, body, options) => {
+    const reports = [];
+    const sourceCode = new SourceCode("", createProgram(body));
+    const context = createRuleContext({
+        filename,
+        reports,
+        sourceCode,
+        ...(options === void 0 ? {} : { options }),
+    });
+    const listeners = barrelFilesExportsOnlyRule.create(context);
+    const programListener = listeners.Program;
+    programListener?.(context.sourceCode.ast);
+    return reports;
+};
+/**
+ * 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([]);
+ * ```
+ */
+const createTemporaryRunner = (temporaryDirectories) => {
+    const runForTemporaryFile = (options) => {
+        const directory = createRepoDirectory(options.root);
+        temporaryDirectories.push(directory);
+        const filePath = path.join(directory, options.filename);
+        return runRule(filePath, options.body, options.options);
+    };
+    const runDefaultIndex = (body) => runForTemporaryFile({ body, filename: "index.ts", root: "src" });
+    const runTemporaryIndex = (body, options) => runForTemporaryFile({
+        body,
+        filename: "index.ts",
+        root: "tmp",
+        ...(options === void 0 ? {} : { options }),
+    });
+    const runTemporaryFeature = (body, options) => runForTemporaryFile({
+        body,
+        filename: "feature.ts",
+        root: "tmp",
+        ...(options === void 0 ? {} : { options }),
+    });
+    return { runDefaultIndex, runTemporaryFeature, runTemporaryIndex };
+};
+export { createTemporaryRunner, runRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exports-only-rule-test-utilities.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/exports-only-rule-test-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport { SourceCode } from \"eslint\";\nimport path from \"node:path\";\n\nimport type { BarrelFilesExportsOnlyOptions } from \"./types\";\n\nimport { barrelFilesExportsOnlyRule } from \"./exports-only-rule\";\nimport { createProgram, createRepoDirectory } from \"./test-helpers\";\n\n/** Type definition for rule data. */\ninterface ReportDescriptorWithMessageId {\n  /** MessageId field value. */\n  messageId?: string;\n}\n\n/** Type definition for rule data. */\ninterface RuleContextParameters {\n  /** Filename field value. */\n  filename: string;\n\n  /** Options helper value. */\n  options?: BarrelFilesExportsOnlyOptions;\n\n  /** Reports field value. */\n  reports: RuleReport[];\n\n  /** SourceCode field value. */\n  sourceCode: SourceCode;\n}\n\n/** Type definition for rule data. */\ninterface RuleReport {\n  /** MessageId helper value. */\n  messageId: string | undefined;\n}\n\n/** Type definition for rule data. */\ninterface TemporaryFileOptions {\n  /** Body field value. */\n  body: ESTree.Program[\"body\"];\n\n  /** Filename field value. */\n  filename: string;\n\n  /** Options helper value. */\n  options?: BarrelFilesExportsOnlyOptions;\n\n  /** Root field value. */\n  root: \"src\" | \"tmp\";\n}\n\n/** Type definition for rule data. */\ninterface TemporaryRunner {\n  /** RunDefaultIndex field value. */\n  runDefaultIndex: (body: ESTree.Program[\"body\"]) => RuleReport[];\n\n  /** RunTemporaryFeature field value. */\n  runTemporaryFeature: (\n    body: ESTree.Program[\"body\"],\n    options?: BarrelFilesExportsOnlyOptions,\n  ) => RuleReport[];\n\n  /** RunTemporaryIndex field value. */\n  runTemporaryIndex: (\n    body: ESTree.Program[\"body\"],\n    options?: BarrelFilesExportsOnlyOptions,\n  ) => RuleReport[];\n}\n\n/**\n * Builds a rule context for running the rule.\n * @param parameters Context parameters and report sink.\n * @returns The ESLint rule context.\n * @example\n * ```typescript\n * const context = createRuleContext({ filename, reports, sourceCode });\n * ```\n */\nconst createRuleContext = (\n  parameters: RuleContextParameters,\n): Rule.RuleContext =>\n  ({\n    cwd: process.cwd(),\n    filename: parameters.filename,\n    id: \"barrel-files-exports-only\",\n    languageOptions: {\n      ecmaVersion: \"latest\",\n      sourceType: \"module\",\n    },\n    options: parameters.options === void 0 ? [] : [parameters.options],\n    parserOptions: {},\n    parserPath: void 0,\n    physicalFilename: parameters.filename,\n    report: (report: Rule.ReportDescriptor): void => {\n      const { messageId } = report as ReportDescriptorWithMessageId;\n      parameters.reports.push({ messageId });\n    },\n    settings: {},\n    sourceCode: parameters.sourceCode,\n  }) as unknown as Rule.RuleContext;\n\n/**\n * Runs the rule against the provided AST body.\n * @param filename Target filename.\n * @param body AST program body.\n * @param options Rule options when provided.\n * @returns The captured rule reports.\n * @example\n * ```typescript\n * const reports = runRule(\"index.ts\", createBody());\n * ```\n */\nconst runRule = (\n  filename: string,\n  body: ESTree.Program[\"body\"],\n  options?: BarrelFilesExportsOnlyOptions,\n): RuleReport[] => {\n  const reports: RuleReport[] = [];\n  const sourceCode = new SourceCode(\"\", createProgram(body));\n  const context = createRuleContext({\n    filename,\n    reports,\n    sourceCode,\n    ...(options === void 0 ? {} : { options }),\n  });\n  const listeners = barrelFilesExportsOnlyRule.create(context);\n  const programListener = listeners.Program;\n\n  programListener?.(context.sourceCode.ast);\n\n  return reports;\n};\n\n/**\n * Creates temporary file runners for the rule.\n * @param temporaryDirectories Directories created during the run.\n * @returns Helpers for running the rule in temp folders.\n * @example\n * ```typescript\n * const runner = createTemporaryRunner([]);\n * ```\n */\nconst createTemporaryRunner = (\n  temporaryDirectories: string[],\n): TemporaryRunner => {\n  const runForTemporaryFile = (options: TemporaryFileOptions): RuleReport[] => {\n    const directory = createRepoDirectory(options.root);\n    temporaryDirectories.push(directory);\n    const filePath = path.join(directory, options.filename);\n\n    return runRule(filePath, options.body, options.options);\n  };\n\n  const runDefaultIndex = (body: ESTree.Program[\"body\"]): RuleReport[] =>\n    runForTemporaryFile({ body, filename: \"index.ts\", root: \"src\" });\n\n  const runTemporaryIndex = (\n    body: ESTree.Program[\"body\"],\n    options?: BarrelFilesExportsOnlyOptions,\n  ): RuleReport[] =>\n    runForTemporaryFile({\n      body,\n      filename: \"index.ts\",\n      root: \"tmp\",\n      ...(options === void 0 ? {} : { options }),\n    });\n\n  const runTemporaryFeature = (\n    body: ESTree.Program[\"body\"],\n    options?: BarrelFilesExportsOnlyOptions,\n  ): RuleReport[] =>\n    runForTemporaryFile({\n      body,\n      filename: \"feature.ts\",\n      root: \"tmp\",\n      ...(options === void 0 ? {} : { options }),\n    });\n\n  return { runDefaultIndex, runTemporaryFeature, runTemporaryIndex };\n};\n\nexport { createTemporaryRunner, runRule };\n"]}

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

@@ -0,0 +1,11 @@
+import type { Rule } from "eslint";
+/**
+ * ESLint rule enforcing re-export-only barrel files.
+ * @example
+ * ```typescript
+ * const rule = barrelFilesExportsOnlyRule;
+ * ```
+ */
+declare const barrelFilesExportsOnlyRule: Rule.RuleModule;
+export { barrelFilesExportsOnlyRule };
+//# sourceMappingURL=exports-only-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exports-only-rule.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/exports-only-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsOxC;;;;;;GAMG;AACH,QAAA,MAAM,0BAA0B,EAAE,IAAI,CAAC,UA+CtC,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/architecture/consistent-barrel-files/exports-only-rule.js

@@ -0,0 +1,218 @@
+import { minimatch } from "minimatch";
+import path from "node:path";
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+/** Default value used by this module. */
+const DEFAULT_BARREL_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+/** Default folder globs for barrel exports-only checks. */
+const DEFAULT_FOLDER_GLOBS = ["src/*/**"];
+/**
+ * Normalizes a string list option into a clean list.
+ * @param value Raw option value.
+ * @param defaults Default list when the option is empty.
+ * @returns Normalized string list.
+ * @example
+ * ```typescript
+ * const names = normalizeList("index.ts", ["index.ts"]);
+ * ```
+ */
+const normalizeList = (value, defaults) => {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length === 0 ? [] : [trimmed];
+    }
+    return [...defaults];
+};
+/**
+ * Builds the rule options state from raw options.
+ * @param options Raw rule options.
+ * @returns Normalized rule options.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+const getOptions = (options) => {
+    const rawOptions = options[0];
+    const folders = normalizeList(rawOptions?.folders, DEFAULT_FOLDER_GLOBS);
+    const names = normalizeList(rawOptions?.names, DEFAULT_BARREL_NAMES);
+    return { folders, names, namesSet: new Set(names) };
+};
+/**
+ * Checks whether the filename is valid for linting.
+ * @param filename Absolute filename.
+ * @returns True when the filename is lintable.
+ * @example
+ * ```typescript
+ * const ok = isLintableFilename("/repo/src/index.ts");
+ * ```
+ */
+const isLintableFilename = (filename) => filename.length > 0 && path.isAbsolute(filename);
+/**
+ * Normalizes a filename to a repo-relative path.
+ * @param filename Absolute filename.
+ * @returns Relative path using forward slashes.
+ * @example
+ * ```typescript
+ * const relative = normalizeRelativePath("/repo/src/index.ts");
+ * ```
+ */
+const normalizeRelativePath = (filename) => path.relative(process.cwd(), filename).split(path.sep).join("/");
+/**
+ * Checks whether a file path matches any configured folder globs.
+ * @param filename Absolute filename.
+ * @param folders Folder glob patterns.
+ * @returns True when the filename is within configured folders.
+ * @example
+ * ```typescript
+ * const ok = isPathInFolders("/repo/src/index.ts", ["src/**"]);
+ * ```
+ */
+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 linted by this rule.
+ * @param filename Absolute filename.
+ * @param options Normalized rule options.
+ * @returns True when the file should be checked.
+ * @example
+ * ```typescript
+ * const ok = shouldLintFile("/repo/src/index.ts", state);
+ * ```
+ */
+const shouldLintFile = (filename, options) => {
+    if (!isLintableFilename(filename)) {
+        return false;
+    }
+    if (options.folders.length === 0 || options.names.length === 0) {
+        return false;
+    }
+    return isPathInFolders(filename, options.folders);
+};
+/**
+ * Determines whether a file is a barrel file under the rule options.
+ * @param filename Absolute filename.
+ * @param options Normalized rule options.
+ * @returns True when the file is a barrel file.
+ * @example
+ * ```typescript
+ * const ok = isBarrelFile("/repo/src/index.ts", state);
+ * ```
+ */
+const isBarrelFile = (filename, options) => {
+    if (!shouldLintFile(filename, options)) {
+        return false;
+    }
+    return options.namesSet.has(path.basename(filename));
+};
+/**
+ * Checks whether a statement is allowed in a barrel file.
+ * @param statement Program statement node.
+ * @returns True when the statement is permitted.
+ * @example
+ * ```typescript
+ * const ok = isAllowedBarrelStatement(statement);
+ * ```
+ */
+const isAllowedBarrelStatement = (statement) => {
+    if (statement.type === "ExportAllDeclaration") {
+        return true;
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+        return false;
+    }
+    const declaration = statement.declaration ?? void 0;
+    if (declaration !== void 0) {
+        return false;
+    }
+    const source = statement.source ?? void 0;
+    return source !== void 0;
+};
+/**
+ * Builds a rule listener for the supplied file.
+ * @param context Rule execution context.
+ * @param filename Absolute filename to lint.
+ * @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) => {
+    if (!isBarrelFile(filename, options)) {
+        return {};
+    }
+    return {
+        Program(node) {
+            for (const statement of node.body) {
+                if (!isAllowedBarrelStatement(statement)) {
+                    context.report({
+                        messageId: "invalidBarrelContent",
+                        node: statement,
+                    });
+                    break;
+                }
+            }
+        },
+    };
+};
+/**
+ * ESLint rule enforcing re-export-only barrel files.
+ * @example
+ * ```typescript
+ * const rule = barrelFilesExportsOnlyRule;
+ * ```
+ */
+const barrelFilesExportsOnlyRule = {
+    create(context) {
+        return buildListenerForFile(context, context.filename, getOptions(context.options));
+    },
+    meta: {
+        docs: createRuleDocumentation("barrel-files-exports-only", "Require barrel files to only contain re-export statements."),
+        messages: {
+            invalidBarrelContent: "Barrel files must only re-export from other modules and contain no imports or declarations.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    folders: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                    names: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+};
+export { barrelFilesExportsOnlyRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exports-only-rule.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/exports-only-rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST, Rule } from \"eslint\";\n\nimport { minimatch } from \"minimatch\";\nimport path from \"node:path\";\n\nimport type { BarrelFilesExportsOnlyOptions } from \"./types\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\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 exports-only checks. */\nconst DEFAULT_FOLDER_GLOBS = [\"src/*/**\"];\n\n/** Type definition for rule data. */\ninterface BarrelFilesExportsOnlyState {\n  /** Folders field value. */\n  folders: string[];\n\n  /** Names field value. */\n  names: string[];\n\n  /** NamesSet field value. */\n  namesSet: Set<string>;\n}\n\n/**\n * Normalizes a string list option into a clean list.\n * @param value Raw option value.\n * @param defaults Default list when the option is empty.\n * @returns Normalized string list.\n * @example\n * ```typescript\n * const names = normalizeList(\"index.ts\", [\"index.ts\"]);\n * ```\n */\nconst normalizeList = (value: unknown, defaults: string[]): string[] => {\n  if (Array.isArray(value)) {\n    return value\n      .filter((entry): entry is string => typeof entry === \"string\")\n      .map((entry) => entry.trim())\n      .filter((entry) => entry.length > 0);\n  }\n\n  if (typeof value === \"string\") {\n    const trimmed = value.trim();\n    return trimmed.length === 0 ? [] : [trimmed];\n  }\n\n  return [...defaults];\n};\n\n/**\n * Builds the rule options state from raw options.\n * @param options Raw rule options.\n * @returns Normalized rule options.\n * @example\n * ```typescript\n * const state = getOptions([{}]);\n * ```\n */\nconst getOptions = (\n  options: readonly unknown[],\n): BarrelFilesExportsOnlyState => {\n  const rawOptions = options[0] as BarrelFilesExportsOnlyOptions | undefined;\n  const folders = normalizeList(rawOptions?.folders, DEFAULT_FOLDER_GLOBS);\n  const names = normalizeList(rawOptions?.names, DEFAULT_BARREL_NAMES);\n\n  return { folders, names, namesSet: new Set(names) };\n};\n\n/**\n * Checks whether the filename is valid for linting.\n * @param filename Absolute filename.\n * @returns True when the filename is lintable.\n * @example\n * ```typescript\n * const ok = isLintableFilename(\"/repo/src/index.ts\");\n * ```\n */\nconst isLintableFilename = (filename: string): boolean =>\n  filename.length > 0 && path.isAbsolute(filename);\n\n/**\n * Normalizes a filename to a repo-relative path.\n * @param filename Absolute filename.\n * @returns Relative path using forward slashes.\n * @example\n * ```typescript\n * const relative = normalizeRelativePath(\"/repo/src/index.ts\");\n * ```\n */\nconst normalizeRelativePath = (filename: string): string =>\n  path.relative(process.cwd(), filename).split(path.sep).join(\"/\");\n\n/**\n * Checks whether a file path matches any configured folder globs.\n * @param filename Absolute filename.\n * @param folders Folder glob patterns.\n * @returns True when the filename is within configured folders.\n * @example\n * ```typescript\n * const ok = isPathInFolders(\"/repo/src/index.ts\", [\"src/**\"]);\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 linted by this rule.\n * @param filename Absolute filename.\n * @param options Normalized rule options.\n * @returns True when the file should be checked.\n * @example\n * ```typescript\n * const ok = shouldLintFile(\"/repo/src/index.ts\", state);\n * ```\n */\nconst shouldLintFile = (\n  filename: string,\n  options: ReturnType<typeof getOptions>,\n): boolean => {\n  if (!isLintableFilename(filename)) {\n    return false;\n  }\n\n  if (options.folders.length === 0 || options.names.length === 0) {\n    return false;\n  }\n\n  return isPathInFolders(filename, options.folders);\n};\n\n/**\n * Determines whether a file is a barrel file under the rule options.\n * @param filename Absolute filename.\n * @param options Normalized rule options.\n * @returns True when the file is a barrel file.\n * @example\n * ```typescript\n * const ok = isBarrelFile(\"/repo/src/index.ts\", state);\n * ```\n */\nconst isBarrelFile = (\n  filename: string,\n  options: ReturnType<typeof getOptions>,\n): boolean => {\n  if (!shouldLintFile(filename, options)) {\n    return false;\n  }\n\n  return options.namesSet.has(path.basename(filename));\n};\n\n/**\n * Checks whether a statement is allowed in a barrel file.\n * @param statement Program statement node.\n * @returns True when the statement is permitted.\n * @example\n * ```typescript\n * const ok = isAllowedBarrelStatement(statement);\n * ```\n */\nconst isAllowedBarrelStatement = (\n  statement: AST.Program[\"body\"][number],\n): boolean => {\n  if (statement.type === \"ExportAllDeclaration\") {\n    return true;\n  }\n\n  if (statement.type !== \"ExportNamedDeclaration\") {\n    return false;\n  }\n\n  const declaration = statement.declaration ?? void 0;\n\n  if (declaration !== void 0) {\n    return false;\n  }\n\n  const source = statement.source ?? void 0;\n\n  return source !== void 0;\n};\n\n/**\n * Builds a rule listener for the supplied file.\n * @param context Rule execution context.\n * @param filename Absolute filename to lint.\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: ReturnType<typeof getOptions>,\n): Rule.RuleListener => {\n  if (!isBarrelFile(filename, options)) {\n    return {};\n  }\n\n  return {\n    Program(node: AST.Program): void {\n      for (const statement of node.body) {\n        if (!isAllowedBarrelStatement(statement)) {\n          context.report({\n            messageId: \"invalidBarrelContent\",\n            node: statement,\n          });\n          break;\n        }\n      }\n    },\n  };\n};\n\n/**\n * ESLint rule enforcing re-export-only barrel files.\n * @example\n * ```typescript\n * const rule = barrelFilesExportsOnlyRule;\n * ```\n */\nconst barrelFilesExportsOnlyRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return buildListenerForFile(\n      context,\n      context.filename,\n      getOptions(context.options),\n    );\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"barrel-files-exports-only\",\n      \"Require barrel files to only contain re-export statements.\",\n    ),\n    messages: {\n      invalidBarrelContent:\n        \"Barrel files must only re-export from other modules and contain no imports or declarations.\",\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          folders: {\n            oneOf: [\n              { type: \"string\" },\n              {\n                items: { type: \"string\" },\n                minItems: 1,\n                type: \"array\",\n              },\n            ],\n          },\n          names: {\n            oneOf: [\n              { type: \"string\" },\n              {\n                items: { type: \"string\" },\n                minItems: 1,\n                type: \"array\",\n              },\n            ],\n          },\n        },\n        type: \"object\",\n      },\n    ],\n    type: \"problem\",\n  },\n};\n\nexport { barrelFilesExportsOnlyRule };\n"]}

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

@@ -0,0 +1,5 @@
+export { barrelFilesExportsOnlyRule } from "./exports-only-rule";
+export { noReexportsOutsideBarrelsRule } from "./no-reexports-outside-barrels-rule";
+export { consistentBarrelFilesRule } from "./rule";
+export type { BarrelFilesExportsOnlyOptions, ConsistentBarrelFilesOptions, NoReexportsOutsideBarrelsOptions, } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC;AACnD,YAAY,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,gCAAgC,GACjC,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,4 @@
+export { barrelFilesExportsOnlyRule } from "./exports-only-rule";
+export { noReexportsOutsideBarrelsRule } from "./no-reexports-outside-barrels-rule";
+export { consistentBarrelFilesRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXJjaGl0ZWN0dXJlL2NvbnNpc3RlbnQtYmFycmVsLWZpbGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3BGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGJhcnJlbEZpbGVzRXhwb3J0c09ubHlSdWxlIH0gZnJvbSBcIi4vZXhwb3J0cy1vbmx5LXJ1bGVcIjtcbmV4cG9ydCB7IG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlIH0gZnJvbSBcIi4vbm8tcmVleHBvcnRzLW91dHNpZGUtYmFycmVscy1ydWxlXCI7XG5leHBvcnQgeyBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuZXhwb3J0IHR5cGUge1xuICBCYXJyZWxGaWxlc0V4cG9ydHNPbmx5T3B0aW9ucyxcbiAgQ29uc2lzdGVudEJhcnJlbEZpbGVzT3B0aW9ucyxcbiAgTm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc09wdGlvbnMsXG59IGZyb20gXCIuL3R5cGVzXCI7XG4iXX0=

package/dist/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "eslint";
+/**
+ * ESLint rule preventing re-exports outside barrel files.
+ * @example
+ * ```typescript
+ * const rule = noReexportsOutsideBarrelsRule;
+ * ```
+ */
+declare const noReexportsOutsideBarrelsRule: Rule.RuleModule;
+export { noReexportsOutsideBarrelsRule };
+//# sourceMappingURL=no-reexports-outside-barrels-rule.d.ts.map

package/dist/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reexports-outside-barrels-rule.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,IAAI,EAAE,MAAM,QAAQ,CAAC;AAoExC;;;;;;GAMG;AACH,QAAA,MAAM,6BAA6B,EAAE,IAAI,CAAC,UAiDzC,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,CAAC"}

package/dist/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.js

@@ -0,0 +1,100 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { collectImportedNames, getOptions, hasImportedExport, isBarrelFile, shouldLintFile, } from "./no-reexports-outside-barrels-utilities";
+/**
+ * Builds a rule listener for the supplied file.
+ * @param context Rule execution context.
+ * @param filename Absolute filename to lint.
+ * @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) => {
+    if (!shouldLintFile(filename, options) || isBarrelFile(filename, options)) {
+        return {};
+    }
+    return {
+        Program(node) {
+            const importedNames = collectImportedNames(node.body);
+            for (const statement of node.body) {
+                const isExportFrom = statement.type === "ExportAllDeclaration" ||
+                    (statement.type === "ExportNamedDeclaration" &&
+                        statement.source !== null &&
+                        statement.source !== void 0);
+                const isImportedDefaultExport = statement.type === "ExportDefaultDeclaration" &&
+                    statement.declaration.type === "Identifier" &&
+                    importedNames.has(statement.declaration.name);
+                if (isExportFrom) {
+                    context.report({
+                        messageId: "reexportNotAllowed",
+                        node: statement,
+                    });
+                }
+                else if (hasImportedExport(statement, importedNames)) {
+                    context.report({
+                        messageId: "reexportedImport",
+                        node: statement,
+                    });
+                }
+                else if (isImportedDefaultExport) {
+                    context.report({
+                        messageId: "reexportedImport",
+                        node: statement,
+                    });
+                }
+            }
+        },
+    };
+};
+/**
+ * ESLint rule preventing re-exports outside barrel files.
+ * @example
+ * ```typescript
+ * const rule = noReexportsOutsideBarrelsRule;
+ * ```
+ */
+const noReexportsOutsideBarrelsRule = {
+    create(context) {
+        return buildListenerForFile(context, context.filename, getOptions(context.options));
+    },
+    meta: {
+        docs: createRuleDocumentation("no-reexports-outside-barrels", "Require non-barrel files to export only locally defined values."),
+        messages: {
+            reexportedImport: "Non-barrel files must not export identifiers imported from other modules.",
+            reexportNotAllowed: "Non-barrel files must not re-export from other modules.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    folders: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                    names: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+};
+export { noReexportsOutsideBarrelsRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/architecture/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.d.ts

@@ -0,0 +1,40 @@
+import type * as ESTree from "estree";
+import type { NoReexportsOutsideBarrelsOptions } from "./types";
+/** Type definition for rule data. */
+interface RuleReport {
+    /** MessageId helper value. */
+    messageId: string | undefined;
+}
+/** Type definition for rule data. */
+interface TemporaryRunner {
+    /** RunDefaultFeature field value. */
+    runDefaultFeature: (body: ESTree.Program["body"]) => RuleReport[];
+    /** RunTemporaryFeature field value. */
+    runTemporaryFeature: (body: ESTree.Program["body"], options?: NoReexportsOutsideBarrelsOptions) => RuleReport[];
+    /** RunTemporaryIndex field value. */
+    runTemporaryIndex: (body: ESTree.Program["body"], options?: NoReexportsOutsideBarrelsOptions) => 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("feature.ts", createBody());
+ * ```
+ */
+declare const runRule: (filename: string, body: ESTree.Program["body"], options?: NoReexportsOutsideBarrelsOptions) => 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=no-reexports-outside-barrels-test-utilities.d.ts.map

package/dist/architecture/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reexports-outside-barrels-test-utilities.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAKtC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,SAAS,CAAC;AA0BhE,qCAAqC;AACrC,UAAU,UAAU;IAClB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAiBD,qCAAqC;AACrC,UAAU,eAAe;IACvB,qCAAqC;IACrC,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;IAElE,uCAAuC;IACvC,mBAAmB,EAAE,CACnB,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,gCAAgC,KACvC,UAAU,EAAE,CAAC;IAElB,qCAAqC;IACrC,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,gCAAgC,KACvC,UAAU,EAAE,CAAC;CACnB;AAkCD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,OAAO,GACX,UAAU,MAAM,EAChB,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,UAAU,gCAAgC,KACzC,UAAU,EAeZ,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,sBAAsB,MAAM,EAAE,KAC7B,eAmCF,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,CAAC"}