@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/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/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.ts"],"names":[],"mappings":"AASA,qCAAqC;AACrC,UAAU,0BAA0B;IAClC,gCAAgC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IAExB,mCAAmC;IACnC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE7B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,0BAYF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OACf,CAAC;AAkBjC;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAAI,UAAU,MAAM,EAAE,cAAc,MAAM,EAAE,KAAG,OAMlE,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC;AAC1D,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,64 @@
+import path from "node:path";
+import { isLintableModuleFile, normalizeAllowedBarrelNames, } from "./barrel-file-utilities.js";
+/**
+ * Builds normalized rule options from raw rule input.
+ * @param options Raw rule options.
+ * @returns The normalized rule state.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+const getOptions = (options) => {
+    const rawOptions = options[0];
+    const enforce = rawOptions?.enforce ?? true;
+    const allowedNames = normalizeAllowedBarrelNames(rawOptions?.allowedNames);
+    const allowedNamesKey = allowedNames.toSorted().join("|");
+    return {
+        allowedNames,
+        allowedNamesKey,
+        allowedNamesSet: new Set(allowedNames),
+        enforce,
+    };
+};
+/**
+ * Determines whether a filename is eligible for linting.
+ * @param filename Filename to inspect.
+ * @returns True when the filename is a lintable module file.
+ * @example
+ * ```typescript
+ * const lintable = isLintableFilename(`${cwd()}/src/index.ts`);
+ * ```
+ */
+const isLintableFilename = (filename) => isLintableModuleFile(filename);
+/**
+ * Checks whether a path is nested inside a src directory.
+ * @param filename Filename to inspect.
+ * @returns True when the file path contains a src path segment.
+ * @example
+ * ```typescript
+ * const inSrc = isInSourceDirectory(`${cwd()}/src/index.ts`);
+ * ```
+ */
+const isInSourceDirectory = (filename) => {
+    const normalizedPath = path.normalize(filename);
+    const pathSegments = normalizedPath.split(path.sep).filter(Boolean);
+    return pathSegments.includes("src");
+};
+/**
+ * Determines whether the rule should lint a file.
+ * @param filename Filename to inspect.
+ * @param allowedNames Allowed barrel names for the rule run.
+ * @returns True when the file should be checked.
+ * @example
+ * ```typescript
+ * const shouldLint = shouldLintFile(`${cwd()}/src/index.ts`, ["index"]);
+ * ```
+ */
+const shouldLintFile = (filename, allowedNames) => {
+    return (isLintableFilename(filename) &&
+        isInSourceDirectory(filename) &&
+        allowedNames.length > 0);
+};
+export { getOptions, isLintableFilename, shouldLintFile };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,4 @@
 import type * as ESTree from "estree";
-import type { BarrelFilesExportsOnlyOptions } from "./types";
 /** Type definition for rule data. */
 interface RuleReport {
     /** MessageId helper value. */
@@ -9,10 +8,12 @@ interface RuleReport {
 interface TemporaryRunner {
     /** RunDefaultIndex field value. */
     runDefaultIndex: (body: ESTree.Program["body"]) => RuleReport[];
+    /** RunTemporaryBarrel field value. */
+    runTemporaryBarrel: (filename: string, body: ESTree.Program["body"], options?: readonly unknown[]) => RuleReport[];
     /** RunTemporaryFeature field value. */
-    runTemporaryFeature: (body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+    runTemporaryFeature: (body: ESTree.Program["body"]) => RuleReport[];
     /** RunTemporaryIndex field value. */
-    runTemporaryIndex: (body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+    runTemporaryIndex: (body: ESTree.Program["body"]) => RuleReport[];
 }
 /**
  * Runs the rule against the provided AST body.
@@ -25,7 +26,7 @@ interface TemporaryRunner {
  * const reports = runRule("index.ts", createBody());
  * ```
  */
-declare const runRule: (filename: string, body: ESTree.Program["body"], options?: BarrelFilesExportsOnlyOptions) => RuleReport[];
+declare const runRule: (filename: string, body: ESTree.Program["body"], options?: readonly unknown[]) => RuleReport[];
 /**
  * Creates temporary file runners for the rule.
  * @param temporaryDirectories Directories created during the run.

package/dist/domain/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/domain/architecture/consistent-barrel-files/exports-only-rule-test-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AA8BtC,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,sCAAsC;IACtC,kBAAkB,EAAE,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,KACzB,UAAU,EAAE,CAAC;IAElB,uCAAuC;IACvC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;IAEpE,qCAAqC;IACrC,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;CACnE;AAkCD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,OAAO,GACX,UAAU,MAAM,EAChB,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAC5B,UAAS,SAAS,OAAO,EAAO,KAC/B,UAAU,EAeZ,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,sBAAsB,MAAM,EAAE,KAC7B,eA+BF,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,CAAC"}

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

@@ -0,0 +1,87 @@
+import { SourceCode } from "eslint";
+import path from "node:path";
+import { cwd } from "node:process";
+import { barrelFilesExportsOnlyRule } from "./exports-only-rule.js";
+import { createProgram, createRepoDirectory } from "./test-helpers.js";
+/**
+ * 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: cwd(),
+    filename: parameters.filename,
+    id: "barrel-files-exports-only",
+    languageOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+    },
+    options: 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,
+        options,
+        reports,
+        sourceCode,
+    });
+    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 runTemporaryBarrel = (filename, body, options = []) => runForTemporaryFile({ body, filename, options, root: "tmp" });
+    const runTemporaryIndex = (body) => runForTemporaryFile({ body, filename: "index.ts", root: "tmp" });
+    const runTemporaryFeature = (body) => runForTemporaryFile({ body, filename: "feature.ts", root: "tmp" });
+    return {
+        runDefaultIndex,
+        runTemporaryBarrel,
+        runTemporaryFeature,
+        runTemporaryIndex,
+    };
+};
+export { createTemporaryRunner, runRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exports-only-rule-test-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/exports-only-rule-test-utilities.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AA+DpE;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CACxB,UAAiC,EACf,EAAE,CACpB,CAAC;IACC,GAAG,EAAE,GAAG,EAAE;IACV,QAAQ,EAAE,UAAU,CAAC,QAAQ;IAC7B,EAAE,EAAE,2BAA2B;IAC/B,eAAe,EAAE;QACf,WAAW,EAAE,QAAQ;QACrB,UAAU,EAAE,QAAQ;KACrB;IACD,OAAO,EAAE,UAAU,CAAC,OAAO;IAC3B,aAAa,EAAE,EAAE;IACjB,UAAU,EAAE,KAAK,CAAC;IAClB,gBAAgB,EAAE,UAAU,CAAC,QAAQ;IACrC,MAAM,EAAE,CAAC,MAA6B,EAAQ,EAAE;QAC9C,MAAM,EAAE,SAAS,EAAE,GAAG,MAAuC,CAAC;QAC9D,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IACzC,CAAC;IACD,QAAQ,EAAE,EAAE;IACZ,UAAU,EAAE,UAAU,CAAC,UAAU;CAClC,CAAgC,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,MAAM,OAAO,GAAG,CACd,QAAgB,EAChB,IAA4B,EAC5B,UAA8B,EAAE,EAClB,EAAE;IAChB,MAAM,OAAO,GAAiB,EAAE,CAAC;IACjC,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3D,MAAM,OAAO,GAAG,iBAAiB,CAAC;QAChC,QAAQ;QACR,OAAO;QACP,OAAO;QACP,UAAU;KACX,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,0BAA0B,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7D,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAAC;IAE1C,eAAe,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAE1C,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAAG,CAC5B,oBAA8B,EACb,EAAE;IACnB,MAAM,mBAAmB,GAAG,CAAC,OAA6B,EAAgB,EAAE;QAC1E,MAAM,SAAS,GAAG,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAExD,OAAO,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEF,MAAM,eAAe,GAAG,CAAC,IAA4B,EAAgB,EAAE,CACrE,mBAAmB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAEnE,MAAM,kBAAkB,GAAG,CACzB,QAAgB,EAChB,IAA4B,EAC5B,UAA8B,EAAE,EAClB,EAAE,CAChB,mBAAmB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAEhE,MAAM,iBAAiB,GAAG,CAAC,IAA4B,EAAgB,EAAE,CACvE,mBAAmB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAEnE,MAAM,mBAAmB,GAAG,CAAC,IAA4B,EAAgB,EAAE,CACzE,mBAAmB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAErE,OAAO;QACL,eAAe;QACf,kBAAkB;QAClB,mBAAmB;QACnB,iBAAiB;KAClB,CAAC;AACJ,CAAC,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport { SourceCode } from \"eslint\";\nimport path from \"node:path\";\nimport { cwd } from \"node:process\";\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 field value. */\n  options: readonly unknown[];\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 field value. */\n  options?: readonly unknown[];\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  /** RunTemporaryBarrel field value. */\n  runTemporaryBarrel: (\n    filename: string,\n    body: ESTree.Program[\"body\"],\n    options?: readonly unknown[],\n  ) => RuleReport[];\n\n  /** RunTemporaryFeature field value. */\n  runTemporaryFeature: (body: ESTree.Program[\"body\"]) => RuleReport[];\n\n  /** RunTemporaryIndex field value. */\n  runTemporaryIndex: (body: ESTree.Program[\"body\"]) => 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: cwd(),\n    filename: parameters.filename,\n    id: \"barrel-files-exports-only\",\n    languageOptions: {\n      ecmaVersion: \"latest\",\n      sourceType: \"module\",\n    },\n    options: 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: readonly unknown[] = [],\n): RuleReport[] => {\n  const reports: RuleReport[] = [];\n  const sourceCode = new SourceCode(\"\", createProgram(body));\n  const context = createRuleContext({\n    filename,\n    options,\n    reports,\n    sourceCode,\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 runTemporaryBarrel = (\n    filename: string,\n    body: ESTree.Program[\"body\"],\n    options: readonly unknown[] = [],\n  ): RuleReport[] =>\n    runForTemporaryFile({ body, filename, options, root: \"tmp\" });\n\n  const runTemporaryIndex = (body: ESTree.Program[\"body\"]): RuleReport[] =>\n    runForTemporaryFile({ body, filename: \"index.ts\", root: \"tmp\" });\n\n  const runTemporaryFeature = (body: ESTree.Program[\"body\"]): RuleReport[] =>\n    runForTemporaryFile({ body, filename: \"feature.ts\", root: \"tmp\" });\n\n  return {\n    runDefaultIndex,\n    runTemporaryBarrel,\n    runTemporaryFeature,\n    runTemporaryIndex,\n  };\n};\n\nexport { createTemporaryRunner, runRule };\n"]}

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

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

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

@@ -0,0 +1,145 @@
+import { isBarrelFile, isLintableModuleFile, normalizeAllowedBarrelNames, } from "./barrel-file-utilities.js";
+/**
+ * Builds normalized rule options from raw input.
+ * @param options Raw rule options.
+ * @returns The normalized exports-only rule state.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+const getOptions = (options) => {
+    const rawOptions = options[0];
+    const allowedBarrelNames = normalizeAllowedBarrelNames(rawOptions?.allowedBarrelNames);
+    return {
+        allowedBarrelNames,
+        allowedBarrelNamesSet: new Set(allowedBarrelNames),
+    };
+};
+/**
+ * Determines whether a declaration is type-only.
+ * @param value Declaration candidate to inspect.
+ * @returns True when the declaration is type-only.
+ * @example
+ * ```typescript
+ * const ok = isTypeOnlyDeclaration({ type: "TSInterfaceDeclaration" });
+ * ```
+ */
+const isTypeOnlyDeclaration = (value) => {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const declarationType = value.type;
+    return (declarationType === "TSInterfaceDeclaration" ||
+        declarationType === "TSTypeAliasDeclaration");
+};
+/**
+ * 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 isTypeOnlyDeclaration(declaration);
+    }
+    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 (!isLintableModuleFile(filename) ||
+        !isBarrelFile(filename, options.allowedBarrelNamesSet)) {
+        return {};
+    }
+    return {
+        /**
+         * Reports the first invalid barrel statement in the program.
+         * @param node Program node to inspect.
+         * @example
+         * ```typescript
+         * listener.Program(programNode);
+         * ```
+         */
+        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 = {
+    /**
+     * Creates listeners for the current lint context.
+     * @param context ESLint rule context.
+     * @returns The listeners for the context.
+     * @example
+     * ```typescript
+     * const listeners = barrelFilesExportsOnlyRule.create(context);
+     * ```
+     */
+    create(context) {
+        return buildListenerForFile(context, context.filename, getOptions(context.options));
+    },
+    meta: {
+        defaultOptions: [{ allowedBarrelNames: ["index"] }],
+        docs: {
+            description: "Require barrel files to only contain re-export statements or type-only declarations.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/barrel-files-exports-only.md",
+        },
+        messages: {
+            invalidBarrelContent: "Barrel files must only contain re-export statements or type-only declarations.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowedBarrelNames: {
+                        description: "Allowed barrel basenames that should be treated as barrel files.",
+                        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/domain/architecture/consistent-barrel-files/exports-only-rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST, Rule } from \"eslint\";\n\nimport type { BarrelFilesExportsOnlyOptions } from \"./types\";\n\nimport {\n  isBarrelFile,\n  isLintableModuleFile,\n  normalizeAllowedBarrelNames,\n} from \"./barrel-file-utilities\";\n\n/** Stores normalized rule options for the exports-only rule. */\ninterface BarrelFilesExportsOnlyState {\n  /** Allowed barrel basenames for the current rule run. */\n  allowedBarrelNames: string[];\n  /** Allowed barrel basenames in set form for quick lookups. */\n  allowedBarrelNamesSet: Set<string>;\n}\n\n/** Describes a declaration-like value that may expose a `type` field. */\ninterface TypeOnlyDeclarationCandidate {\n  /** Candidate declaration type. */\n  type?: unknown;\n}\n\n/**\n * Builds normalized rule options from raw input.\n * @param options Raw rule options.\n * @returns The normalized exports-only rule state.\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 allowedBarrelNames = normalizeAllowedBarrelNames(\n    rawOptions?.allowedBarrelNames,\n  );\n\n  return {\n    allowedBarrelNames,\n    allowedBarrelNamesSet: new Set(allowedBarrelNames),\n  };\n};\n\n/**\n * Determines whether a declaration is type-only.\n * @param value Declaration candidate to inspect.\n * @returns True when the declaration is type-only.\n * @example\n * ```typescript\n * const ok = isTypeOnlyDeclaration({ type: \"TSInterfaceDeclaration\" });\n * ```\n */\nconst isTypeOnlyDeclaration = (value: unknown): boolean => {\n  if (value === null || typeof value !== \"object\") {\n    return false;\n  }\n\n  const declarationType = (value as TypeOnlyDeclarationCandidate).type;\n\n  return (\n    declarationType === \"TSInterfaceDeclaration\" ||\n    declarationType === \"TSTypeAliasDeclaration\"\n  );\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 isTypeOnlyDeclaration(declaration);\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: BarrelFilesExportsOnlyState,\n): Rule.RuleListener => {\n  if (\n    !isLintableModuleFile(filename) ||\n    !isBarrelFile(filename, options.allowedBarrelNamesSet)\n  ) {\n    return {};\n  }\n\n  return {\n    /**\n     * Reports the first invalid barrel statement in the program.\n     * @param node Program node to inspect.\n     * @example\n     * ```typescript\n     * listener.Program(programNode);\n     * ```\n     */\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  /**\n   * Creates listeners for the current lint context.\n   * @param context ESLint rule context.\n   * @returns The listeners for the context.\n   * @example\n   * ```typescript\n   * const listeners = barrelFilesExportsOnlyRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return buildListenerForFile(\n      context,\n      context.filename,\n      getOptions(context.options),\n    );\n  },\n  meta: {\n    defaultOptions: [{ allowedBarrelNames: [\"index\"] }],\n    docs: {\n      description:\n        \"Require barrel files to only contain re-export statements or type-only declarations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/barrel-files-exports-only.md\",\n    },\n    messages: {\n      invalidBarrelContent:\n        \"Barrel files must only contain re-export statements or type-only declarations.\",\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          allowedBarrelNames: {\n            description:\n              \"Allowed barrel basenames that should be treated as barrel files.\",\n            items: { type: \"string\" },\n            minItems: 1,\n            type: \"array\",\n          },\n        },\n        type: \"object\",\n      },\n    ],\n    type: \"problem\",\n  },\n};\n\nexport { barrelFilesExportsOnlyRule };\n"]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/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/domain/architecture/consistent-barrel-files/index.js

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

package/dist/domain/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/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,IAAI,EAAE,MAAM,QAAQ,CAAC;AAmExC;;;;;;GAMG;AACH,QAAA,MAAM,6BAA6B,EAAE,IAAI,CAAC,UAuCzC,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,CAAC"}

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

@@ -0,0 +1,90 @@
+import { collectImportedNames, getOptions, hasImportedExport, isBarrelFile, shouldLintFile, } from "./no-reexports-outside-barrels-utilities.js";
+/**
+ * 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: {
+        defaultOptions: [{ allowedBarrelNames: ["index"] }],
+        docs: {
+            description: "Require non-barrel files to export only locally defined values.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-reexports-outside-barrels.md",
+        },
+        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: {
+                    allowedBarrelNames: {
+                        description: "Allowed barrel basenames that should be exempt from the re-export restriction.",
+                        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 → domain/architecture}/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.d.ts

@@ -1,5 +1,5 @@
 import type * as ESTree from "estree";
-import type { NoReexportsOutsideBarrelsOptions } from "./types";
+import type { NoReexportsOutsideBarrelsOptions } from "./types.js";
 /** Type definition for rule data. */
 interface RuleReport {
     /** MessageId helper value. */

package/dist/domain/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/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-test-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAMtC,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"}

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

@@ -0,0 +1,91 @@
+import { SourceCode } from "eslint";
+import path from "node:path";
+import { cwd } from "node:process";
+import { noReexportsOutsideBarrelsRule } from "./no-reexports-outside-barrels-rule.js";
+import { createProgram, createRepoDirectory } from "./test-helpers.js";
+/**
+ * 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: 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/domain/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\";\nimport { cwd } from \"node:process\";\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: 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"]}