@codeperfect/eslint-plugin 1.0.0

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

@@ -0,0 +1,90 @@
+import { SourceCode } from "eslint";
+import path from "node:path";
+import { noReexportsOutsideBarrelsRule } from "./no-reexports-outside-barrels-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: "no-reexports-outside-barrels",
+    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("feature.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 = noReexportsOutsideBarrelsRule.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 runDefaultFeature = (body) => runForTemporaryFile({ body, filename: "feature.ts", root: "src" });
+    const runTemporaryFeature = (body, options) => runForTemporaryFile({
+        body,
+        filename: "feature.ts",
+        root: "tmp",
+        ...(options === void 0 ? {} : { options }),
+    });
+    const runTemporaryIndex = (body, options) => runForTemporaryFile({
+        body,
+        filename: "index.ts",
+        root: "tmp",
+        ...(options === void 0 ? {} : { options }),
+    });
+    return { runDefaultFeature, runTemporaryFeature, runTemporaryIndex };
+};
+export { createTemporaryRunner, runRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-reexports-outside-barrels-test-utilities.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-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 { NoReexportsOutsideBarrelsOptions } from \"./types\";\n\nimport { noReexportsOutsideBarrelsRule } from \"./no-reexports-outside-barrels-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?: NoReexportsOutsideBarrelsOptions;\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?: NoReexportsOutsideBarrelsOptions;\n\n  /** Root field value. */\n  root: \"src\" | \"tmp\";\n}\n\n/** Type definition for rule data. */\ninterface TemporaryRunner {\n  /** RunDefaultFeature field value. */\n  runDefaultFeature: (body: ESTree.Program[\"body\"]) => RuleReport[];\n\n  /** RunTemporaryFeature field value. */\n  runTemporaryFeature: (\n    body: ESTree.Program[\"body\"],\n    options?: NoReexportsOutsideBarrelsOptions,\n  ) => RuleReport[];\n\n  /** RunTemporaryIndex field value. */\n  runTemporaryIndex: (\n    body: ESTree.Program[\"body\"],\n    options?: NoReexportsOutsideBarrelsOptions,\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: \"no-reexports-outside-barrels\",\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(\"feature.ts\", createBody());\n * ```\n */\nconst runRule = (\n  filename: string,\n  body: ESTree.Program[\"body\"],\n  options?: NoReexportsOutsideBarrelsOptions,\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 = noReexportsOutsideBarrelsRule.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 runDefaultFeature = (body: ESTree.Program[\"body\"]): RuleReport[] =>\n    runForTemporaryFile({ body, filename: \"feature.ts\", root: \"src\" });\n\n  const runTemporaryFeature = (\n    body: ESTree.Program[\"body\"],\n    options?: NoReexportsOutsideBarrelsOptions,\n  ): RuleReport[] =>\n    runForTemporaryFile({\n      body,\n      filename: \"feature.ts\",\n      root: \"tmp\",\n      ...(options === void 0 ? {} : { options }),\n    });\n\n  const runTemporaryIndex = (\n    body: ESTree.Program[\"body\"],\n    options?: NoReexportsOutsideBarrelsOptions,\n  ): RuleReport[] =>\n    runForTemporaryFile({\n      body,\n      filename: \"index.ts\",\n      root: \"tmp\",\n      ...(options === void 0 ? {} : { options }),\n    });\n\n  return { runDefaultFeature, runTemporaryFeature, runTemporaryIndex };\n};\n\nexport { createTemporaryRunner, runRule };\n"]}

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

@@ -0,0 +1,65 @@
+import type { AST } from "eslint";
+/** Type definition for rule data. */
+interface NoReexportsOutsideBarrelsState {
+    /** Folders field value. */
+    folders: string[];
+    /** Names field value. */
+    names: string[];
+    /** NamesSet field value. */
+    namesSet: Set<string>;
+}
+/**
+ * Builds the rule options state from raw options.
+ * @param options Raw rule options.
+ * @returns Normalized rule options.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+declare const getOptions: (options: readonly unknown[]) => NoReexportsOutsideBarrelsState;
+/**
+ * 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);
+ * ```
+ */
+declare const shouldLintFile: (filename: string, options: NoReexportsOutsideBarrelsState) => boolean;
+/**
+ * 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);
+ * ```
+ */
+declare const isBarrelFile: (filename: string, options: NoReexportsOutsideBarrelsState) => boolean;
+/**
+ * Collects imported identifiers from the program body.
+ * @param body Program body statements.
+ * @returns Set of local imported identifiers.
+ * @example
+ * ```typescript
+ * const names = collectImportedNames(program.body);
+ * ```
+ */
+declare const collectImportedNames: (body: AST.Program["body"]) => Set<string>;
+/**
+ * Checks whether an export specifier references an imported identifier.
+ * @param statement Export named declaration statement.
+ * @param importedNames Set of imported identifiers.
+ * @returns True when any export specifier references an import.
+ * @example
+ * ```typescript
+ * const ok = hasImportedExport(statement, names);
+ * ```
+ */
+declare const hasImportedExport: (statement: AST.Program["body"][number], importedNames: Set<string>) => boolean;
+export { collectImportedNames, getOptions, hasImportedExport, isBarrelFile, shouldLintFile, };
+//# sourceMappingURL=no-reexports-outside-barrels-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-reexports-outside-barrels-utilities.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAalC,qCAAqC;AACrC,UAAU,8BAA8B;IACtC,2BAA2B;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,yBAAyB;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,4BAA4B;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB;AA4BD;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,8BAMF,CAAC;AAgDF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAUF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,YAAY,GAChB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAEF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GAAI,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KAAG,GAAG,CAAC,MAAM,CAYnE,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,iBAAiB,GACrB,WAAW,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EACtC,eAAe,GAAG,CAAC,MAAM,CAAC,KACzB,OAcF,CAAC;AAEF,OAAO,EACL,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,CAAC"}

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

@@ -0,0 +1,154 @@
+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 non-barrel re-export 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) => {
+    return options.namesSet.has(path.basename(filename));
+};
+/**
+ * Collects imported identifiers from the program body.
+ * @param body Program body statements.
+ * @returns Set of local imported identifiers.
+ * @example
+ * ```typescript
+ * const names = collectImportedNames(program.body);
+ * ```
+ */
+const collectImportedNames = (body) => {
+    const importedNames = new Set();
+    for (const statement of body) {
+        if (statement.type === "ImportDeclaration") {
+            for (const specifier of statement.specifiers) {
+                importedNames.add(specifier.local.name);
+            }
+        }
+    }
+    return importedNames;
+};
+/**
+ * Checks whether an export specifier references an imported identifier.
+ * @param statement Export named declaration statement.
+ * @param importedNames Set of imported identifiers.
+ * @returns True when any export specifier references an import.
+ * @example
+ * ```typescript
+ * const ok = hasImportedExport(statement, names);
+ * ```
+ */
+const hasImportedExport = (statement, importedNames) => {
+    if (statement.type !== "ExportNamedDeclaration" ||
+        (statement.source !== null && statement.source !== void 0) ||
+        (statement.declaration !== null && statement.declaration !== void 0)) {
+        return false;
+    }
+    return statement.specifiers.some((specifier) => specifier.local.type === "Identifier" &&
+        importedNames.has(specifier.local.name));
+};
+export { collectImportedNames, getOptions, hasImportedExport, isBarrelFile, shouldLintFile, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-reexports-outside-barrels-utilities.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST } from \"eslint\";\n\nimport { minimatch } from \"minimatch\";\nimport path from \"node:path\";\n\nimport type { NoReexportsOutsideBarrelsOptions } 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 non-barrel re-export checks. */\nconst DEFAULT_FOLDER_GLOBS = [\"src/*/**\"];\n\n/** Type definition for rule data. */\ninterface NoReexportsOutsideBarrelsState {\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): NoReexportsOutsideBarrelsState => {\n  const rawOptions = options[0] as NoReexportsOutsideBarrelsOptions | 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: NoReexportsOutsideBarrelsState,\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: NoReexportsOutsideBarrelsState,\n): boolean => {\n  return options.namesSet.has(path.basename(filename));\n};\n\n/**\n * Collects imported identifiers from the program body.\n * @param body Program body statements.\n * @returns Set of local imported identifiers.\n * @example\n * ```typescript\n * const names = collectImportedNames(program.body);\n * ```\n */\nconst collectImportedNames = (body: AST.Program[\"body\"]): Set<string> => {\n  const importedNames = new Set<string>();\n\n  for (const statement of body) {\n    if (statement.type === \"ImportDeclaration\") {\n      for (const specifier of statement.specifiers) {\n        importedNames.add(specifier.local.name);\n      }\n    }\n  }\n\n  return importedNames;\n};\n\n/**\n * Checks whether an export specifier references an imported identifier.\n * @param statement Export named declaration statement.\n * @param importedNames Set of imported identifiers.\n * @returns True when any export specifier references an import.\n * @example\n * ```typescript\n * const ok = hasImportedExport(statement, names);\n * ```\n */\nconst hasImportedExport = (\n  statement: AST.Program[\"body\"][number],\n  importedNames: Set<string>,\n): boolean => {\n  if (\n    statement.type !== \"ExportNamedDeclaration\" ||\n    (statement.source !== null && statement.source !== void 0) ||\n    (statement.declaration !== null && statement.declaration !== void 0)\n  ) {\n    return false;\n  }\n\n  return statement.specifiers.some(\n    (specifier) =>\n      specifier.local.type === \"Identifier\" &&\n      importedNames.has(specifier.local.name),\n  );\n};\n\nexport {\n  collectImportedNames,\n  getOptions,\n  hasImportedExport,\n  isBarrelFile,\n  shouldLintFile,\n};\n"]}

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

@@ -0,0 +1,11 @@
+import type { Rule } from "eslint";
+/**
+ * ESLint rule requiring consistent barrel file usage by folder.
+ * @example
+ * ```typescript
+ * const rule = consistentBarrelFilesRule;
+ * ```
+ */
+declare const consistentBarrelFilesRule: Rule.RuleModule;
+export { consistentBarrelFilesRule };
+//# sourceMappingURL=rule.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { buildListenerForFile } from "./consistent-barrel-files-listeners";
+import { getOptions, isLintableFilename, } from "./consistent-barrel-files-options";
+/**
+ * ESLint rule requiring consistent barrel file usage by folder.
+ * @example
+ * ```typescript
+ * const rule = consistentBarrelFilesRule;
+ * ```
+ */
+const consistentBarrelFilesRule = {
+    create(context) {
+        const { filename, options } = context;
+        if (!isLintableFilename(filename)) {
+            return {};
+        }
+        return buildListenerForFile(context, filename, getOptions(options));
+    },
+    meta: {
+        docs: createRuleDocumentation("consistent-barrel-files", "Enforce or forbid barrel files with consistent, allowed names."),
+        messages: {
+            forbiddenBarrel: "Barrel files are forbidden. Remove the barrel file '{{name}}'.",
+            missingBarrel: "Each folder must include a barrel file named one of: {{names}}.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    enforce: { type: "boolean" },
+                    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 { consistentBarrelFilesRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/architecture/consistent-barrel-files/test-helpers.d.ts

@@ -0,0 +1,141 @@
+import type { AST } from "eslint";
+import type * as ESTree from "estree";
+/**
+ * Creates a temporary repo directory under the given root.
+ * @param root Root folder for temp files.
+ * @returns The generated directory path.
+ * @example
+ * ```typescript
+ * const directory = createRepoDirectory("tmp");
+ * ```
+ */
+declare const createRepoDirectory: (root: "src" | "tmp") => string;
+/**
+ * Creates a program wrapper around the supplied AST body.
+ * @param body Program body statements.
+ * @returns The AST program.
+ * @example
+ * ```typescript
+ * const program = createProgram([]);
+ * ```
+ */
+declare const createProgram: (body: ESTree.Program["body"]) => AST.Program;
+/**
+ * Creates an ESTree export specifier.
+ * @param localName Local identifier name.
+ * @param exportedName Exported identifier name.
+ * @returns Export specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createExportSpecifier("feature");
+ * ```
+ */
+declare const createExportSpecifier: (localName: string, exportedName?: string) => ESTree.ExportSpecifier;
+/**
+ * Creates an ESTree import specifier.
+ * @param localName Local identifier name.
+ * @param importedName Imported identifier name.
+ * @returns Import specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createImportSpecifier("feature");
+ * ```
+ */
+declare const createImportSpecifier: (localName: string, importedName?: string) => ESTree.ImportSpecifier;
+/**
+ * Creates an ESTree import default specifier.
+ * @param localName Local identifier name.
+ * @returns Import default specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createImportDefaultSpecifier("feature");
+ * ```
+ */
+declare const createImportDefaultSpecifier: (localName: string) => ESTree.ImportDefaultSpecifier;
+/**
+ * Creates an import declaration for test fixtures.
+ * @param specifiers Specifiers to include.
+ * @returns Import declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createImportDeclaration([createImportSpecifier("feature")]);
+ * ```
+ */
+declare const createImportDeclaration: (specifiers?: ESTree.ImportDeclaration["specifiers"]) => ESTree.ImportDeclaration;
+/**
+ * Creates an export-all declaration for test fixtures.
+ * @returns The export-all declaration node.
+ * @example
+ * ```typescript
+ * const node = createExportAll();
+ * ```
+ */
+declare const createExportAll: () => ESTree.ExportAllDeclaration;
+/**
+ * Creates a named export-from declaration for test fixtures.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportNamedFrom();
+ * ```
+ */
+declare const createExportNamedFrom: () => ESTree.ExportNamedDeclaration;
+/**
+ * Creates a named export with a local declaration.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportWithDeclaration();
+ * ```
+ */
+declare const createExportWithDeclaration: () => ESTree.ExportNamedDeclaration;
+/**
+ * Creates a named export without a source value.
+ * @param specifiers Export specifiers to include.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportWithoutSource([createExportSpecifier("feature")]);
+ * ```
+ */
+declare const createExportWithoutSource: (specifiers?: ESTree.ExportSpecifier[]) => ESTree.ExportNamedDeclaration;
+/**
+ * Creates a default export for an identifier.
+ * @param name Identifier to export.
+ * @returns Export default declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportDefaultIdentifier("feature");
+ * ```
+ */
+declare const createExportDefaultIdentifier: (name: string) => ESTree.ExportDefaultDeclaration;
+/**
+ * Collects statements into a program body array.
+ * @param statements Statements to include in the program.
+ * @returns The program body array.
+ * @example
+ * ```typescript
+ * const body = createBody(createImportDeclaration());
+ * ```
+ */
+declare const createBody: (...statements: ESTree.Program["body"][number][]) => ESTree.Program["body"];
+/**
+ * Writes a barrel file to the given path.
+ * @param filePath Path for the barrel file.
+ * @example
+ * ```typescript
+ * writeBarrel("/tmp/index.ts");
+ * ```
+ */
+declare const writeBarrel: (filePath: string) => void;
+/**
+ * Writes a feature file to the given path.
+ * @param filePath Path for the feature file.
+ * @example
+ * ```typescript
+ * writeFeature("/tmp/feature.ts");
+ * ```
+ */
+declare const writeFeature: (filePath: string) => void;
+export { createBody, createExportAll, createExportDefaultIdentifier, createExportNamedFrom, createExportSpecifier, createExportWithDeclaration, createExportWithoutSource, createImportDeclaration, createImportDefaultSpecifier, createImportSpecifier, createProgram, createRepoDirectory, writeBarrel, writeFeature, };
+//# sourceMappingURL=test-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAKtC;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,MAAM,KAAK,GAAG,KAAK,KAAG,MAIlD,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAG,GAAG,CAAC,OAWxD,CAAC;AA8BH;;;;;;;;;GASG;AACH,QAAA,MAAM,qBAAqB,GACzB,WAAW,MAAM,EACjB,qBAAwB,KACvB,MAAM,CAAC,eAK2B,CAAC;AAEtC;;;;;;;;;GASG;AACH,QAAA,MAAM,qBAAqB,GACzB,WAAW,MAAM,EACjB,qBAAwB,KACvB,MAAM,CAAC,eAK2B,CAAC;AAEtC;;;;;;;;GAQG;AACH,QAAA,MAAM,4BAA4B,GAChC,WAAW,MAAM,KAChB,MAAM,CAAC,sBAIkC,CAAC;AAE7C;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAC3B,aAAY,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAM,KACtD,MAAM,CAAC,iBAM6B,CAAC;AAExC;;;;;;;GAOG;AACH,QAAA,MAAM,eAAe,QAAO,MAAM,CAAC,oBAMO,CAAC;AAE3C;;;;;;;GAOG;AACH,QAAA,MAAM,qBAAqB,QAAO,MAAM,CAAC,sBAMG,CAAC;AAE7C;;;;;;;GAOG;AACH,QAAA,MAAM,2BAA2B,QAAO,MAAM,CAAC,sBAa9C,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,yBAAyB,GAC7B,aAAY,MAAM,CAAC,eAAe,EAAO,KACxC,MAAM,CAAC,sBAKkC,CAAC;AAE7C;;;;;;;;GAQG;AACH,QAAA,MAAM,6BAA6B,GACjC,MAAM,MAAM,KACX,MAAM,CAAC,wBAIoC,CAAC;AAE/C;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,GAAG,YAAY,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,KAC9C,MAAM,CAAC,OAAO,CAAC,MAAM,CAAe,CAAC;AAExC;;;;;;;GAOG;AACH,QAAA,MAAM,WAAW,GAAI,UAAU,MAAM,KAAG,IAEvC,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU,MAAM,KAAG,IAExC,CAAC;AAEF,OAAO,EACL,UAAU,EACV,eAAe,EACf,6BAA6B,EAC7B,qBAAqB,EACrB,qBAAqB,EACrB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EACrB,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,YAAY,GACb,CAAC"}