@codeperfect/eslint-plugin 2.4.0 → 2.6.0

package/dist/domain/architecture/no-unused-exports/no-unused-exports-record-utilities.js

@@ -0,0 +1,44 @@
+/**
+ * Converts one unknown value into an indexable record.
+ * @param value Candidate value.
+ * @returns Record view when the value is object-like.
+ * @example
+ * ```typescript
+ * const record = asRecord({ type: "Identifier" });
+ * ```
+ */
+const asRecord = (value) => value !== null && typeof value === "object"
+    ? value
+    : void 0;
+/**
+ * Reads one array property from an object-like value.
+ * @param value Candidate object.
+ * @param key Lookup key used to read the property.
+ * @returns Array value when present.
+ * @example
+ * ```typescript
+ * const items = readArrayProperty({ elements: [1, 2] }, "elements");
+ * ```
+ */
+const readArrayProperty = (value, key) => {
+    const record = asRecord(value);
+    const property = record?.[key];
+    return Array.isArray(property) ? property : void 0;
+};
+/**
+ * Reads one string property from an object-like value.
+ * @param value Candidate object.
+ * @param key Lookup key used to read the property.
+ * @returns String value when present.
+ * @example
+ * ```typescript
+ * const name = readStringProperty({ name: "feature" }, "name");
+ * ```
+ */
+const readStringProperty = (value, key) => {
+    const record = asRecord(value);
+    const property = record?.[key];
+    return typeof property === "string" ? property : void 0;
+};
+export { asRecord, readArrayProperty, readStringProperty };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.d.ts

@@ -0,0 +1,59 @@
+import * as ts from "typescript";
+/**
+ * Normalizes an absolute file path for safe equality checks.
+ * @param inputPath Candidate path.
+ * @returns Normalized absolute path suitable for cross-platform comparisons.
+ * @example
+ * ```typescript
+ * const comparable = toComparableAbsolutePath("/repo/src/feature.ts");
+ * ```
+ */
+declare const toComparableAbsolutePath: (inputPath: string) => string;
+/**
+ * Checks whether two symbols reference the same declaration site.
+ * @param left Left-hand symbol candidate.
+ * @param right Right-hand symbol candidate.
+ * @returns True when both symbols identify the same declaration.
+ * @example
+ * ```typescript
+ * const same = isSameSymbol(left, right);
+ * ```
+ */
+declare const isSameSymbol: (left: ts.Symbol, right: ts.Symbol) => boolean;
+/**
+ * Resolves one symbol to its canonical target.
+ * @param symbol Candidate symbol.
+ * @param checker TypeScript checker.
+ * @returns Resolved canonical symbol.
+ * @example
+ * ```typescript
+ * const resolved = resolveCanonicalSymbol(symbol, checker);
+ * ```
+ */
+declare const resolveCanonicalSymbol: (symbol: ts.Symbol, checker: ts.TypeChecker) => ts.Symbol;
+/**
+ * Resolves one exported symbol by name from a source file.
+ * @param program TypeScript program.
+ * @param sourceFilename Source file path.
+ * @param exportedName Public name exposed by the module export list.
+ * @returns Symbol when found.
+ * @example
+ * ```typescript
+ * const symbol = getExportedSymbol(program, sourceFilename, "feature");
+ * ```
+ */
+declare const getExportedSymbol: (program: ts.Program, sourceFilename: string, exportedName: string) => ts.Symbol | undefined;
+/**
+ * Checks whether one source file exports the target symbol.
+ * @param sourceFile Source file that may expose the symbol.
+ * @param checker TypeScript checker.
+ * @param targetSymbol Symbol being classified.
+ * @returns True when one module export resolves to the target symbol.
+ * @example
+ * ```typescript
+ * const exposed = sourceFileExportsSymbol(sourceFile, checker, targetSymbol);
+ * ```
+ */
+declare const sourceFileExportsSymbol: (sourceFile: ts.SourceFile, checker: ts.TypeChecker, targetSymbol: ts.Symbol) => boolean;
+export { getExportedSymbol, isSameSymbol, resolveCanonicalSymbol, sourceFileExportsSymbol, toComparableAbsolutePath, };
+//# sourceMappingURL=no-unused-exports-symbol-utilities.d.ts.map

package/dist/domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-symbol-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;;;GAQG;AACH,QAAA,MAAM,wBAAwB,GAAI,WAAW,MAAM,KAAG,MAIrD,CAAC;AAsBF;;;;;;;;;GASG;AACH,QAAA,MAAM,YAAY,GAAI,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,KAAG,OAezD,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,sBAAsB,GAC1B,QAAQ,EAAE,CAAC,MAAM,EACjB,SAAS,EAAE,CAAC,WAAW,KACtB,EAAE,CAAC,MAUL,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,SAAS,EAAE,CAAC,OAAO,EACnB,gBAAgB,MAAM,EACtB,cAAc,MAAM,KACnB,EAAE,CAAC,MAAM,GAAG,SA6Bd,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,uBAAuB,GAC3B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,WAAW,EACvB,cAAc,EAAE,CAAC,MAAM,KACtB,OAgBF,CAAC;AAEF,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,GACzB,CAAC"}

package/dist/domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.js

@@ -0,0 +1,133 @@
+import path from "node:path";
+import * as ts from "typescript";
+/**
+ * Normalizes an absolute file path for safe equality checks.
+ * @param inputPath Candidate path.
+ * @returns Normalized absolute path suitable for cross-platform comparisons.
+ * @example
+ * ```typescript
+ * const comparable = toComparableAbsolutePath("/repo/src/feature.ts");
+ * ```
+ */
+const toComparableAbsolutePath = (inputPath) => {
+    const absolutePath = path.normalize(path.resolve(inputPath));
+    return absolutePath.toLowerCase();
+};
+/**
+ * Builds declaration-site keys for symbol identity matching.
+ * @param symbol Symbol being compared.
+ * @returns Declaration keys describing where this symbol is declared.
+ * @example
+ * ```typescript
+ * const keys = getDeclarationKeys(symbol);
+ * ```
+ */
+const getDeclarationKeys = (symbol) => {
+    const declarations = symbol.declarations ?? [];
+    return new Set(declarations.map((declaration) => {
+        const sourceFilename = declaration.getSourceFile().fileName;
+        return `${sourceFilename}:${String(declaration.pos)}:${String(declaration.end)}`;
+    }));
+};
+/**
+ * Checks whether two symbols reference the same declaration site.
+ * @param left Left-hand symbol candidate.
+ * @param right Right-hand symbol candidate.
+ * @returns True when both symbols identify the same declaration.
+ * @example
+ * ```typescript
+ * const same = isSameSymbol(left, right);
+ * ```
+ */
+const isSameSymbol = (left, right) => {
+    if (left === right) {
+        return true;
+    }
+    const leftKeys = getDeclarationKeys(left);
+    const rightKeys = getDeclarationKeys(right);
+    for (const key of leftKeys) {
+        if (rightKeys.has(key)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Resolves one symbol to its canonical target.
+ * @param symbol Candidate symbol.
+ * @param checker TypeScript checker.
+ * @returns Resolved canonical symbol.
+ * @example
+ * ```typescript
+ * const resolved = resolveCanonicalSymbol(symbol, checker);
+ * ```
+ */
+const resolveCanonicalSymbol = (symbol, checker) => {
+    if ((symbol.flags & ts.SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    try {
+        return checker.getAliasedSymbol(symbol);
+    }
+    catch {
+        return symbol;
+    }
+};
+/**
+ * Resolves one exported symbol by name from a source file.
+ * @param program TypeScript program.
+ * @param sourceFilename Source file path.
+ * @param exportedName Public name exposed by the module export list.
+ * @returns Symbol when found.
+ * @example
+ * ```typescript
+ * const symbol = getExportedSymbol(program, sourceFilename, "feature");
+ * ```
+ */
+const getExportedSymbol = (program, sourceFilename, exportedName) => {
+    const checker = program.getTypeChecker();
+    const sourceFile = program
+        .getSourceFiles()
+        .find((file) => toComparableAbsolutePath(file.fileName) ===
+        toComparableAbsolutePath(sourceFilename));
+    if (sourceFile === void 0) {
+        return void 0;
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (moduleSymbol === void 0) {
+        return void 0;
+    }
+    const exportedSymbol = checker
+        .getExportsOfModule(moduleSymbol)
+        .find((symbol) => symbol.getName() === exportedName);
+    if (exportedSymbol === void 0) {
+        return void 0;
+    }
+    return resolveCanonicalSymbol(exportedSymbol, checker);
+};
+/**
+ * Checks whether one source file exports the target symbol.
+ * @param sourceFile Source file that may expose the symbol.
+ * @param checker TypeScript checker.
+ * @param targetSymbol Symbol being classified.
+ * @returns True when one module export resolves to the target symbol.
+ * @example
+ * ```typescript
+ * const exposed = sourceFileExportsSymbol(sourceFile, checker, targetSymbol);
+ * ```
+ */
+const sourceFileExportsSymbol = (sourceFile, checker, targetSymbol) => {
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (moduleSymbol === void 0) {
+        return false;
+    }
+    for (const exportedSymbol of checker.getExportsOfModule(moduleSymbol)) {
+        const resolvedSymbol = resolveCanonicalSymbol(exportedSymbol, checker);
+        if (isSameSymbol(resolvedSymbol, targetSymbol)) {
+            return true;
+        }
+    }
+    return false;
+};
+export { getExportedSymbol, isSameSymbol, resolveCanonicalSymbol, sourceFileExportsSymbol, toComparableAbsolutePath, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-exports-symbol-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"node:path\";\nimport * as ts from \"typescript\";\n\n/**\n * Normalizes an absolute file path for safe equality checks.\n * @param inputPath Candidate path.\n * @returns Normalized absolute path suitable for cross-platform comparisons.\n * @example\n * ```typescript\n * const comparable = toComparableAbsolutePath(\"/repo/src/feature.ts\");\n * ```\n */\nconst toComparableAbsolutePath = (inputPath: string): string => {\n  const absolutePath = path.normalize(path.resolve(inputPath));\n\n  return absolutePath.toLowerCase();\n};\n\n/**\n * Builds declaration-site keys for symbol identity matching.\n * @param symbol Symbol being compared.\n * @returns Declaration keys describing where this symbol is declared.\n * @example\n * ```typescript\n * const keys = getDeclarationKeys(symbol);\n * ```\n */\nconst getDeclarationKeys = (symbol: ts.Symbol): Set<string> => {\n  const declarations = symbol.declarations ?? [];\n\n  return new Set(\n    declarations.map((declaration) => {\n      const sourceFilename = declaration.getSourceFile().fileName;\n      return `${sourceFilename}:${String(declaration.pos)}:${String(declaration.end)}`;\n    }),\n  );\n};\n\n/**\n * Checks whether two symbols reference the same declaration site.\n * @param left Left-hand symbol candidate.\n * @param right Right-hand symbol candidate.\n * @returns True when both symbols identify the same declaration.\n * @example\n * ```typescript\n * const same = isSameSymbol(left, right);\n * ```\n */\nconst isSameSymbol = (left: ts.Symbol, right: ts.Symbol): boolean => {\n  if (left === right) {\n    return true;\n  }\n\n  const leftKeys = getDeclarationKeys(left);\n  const rightKeys = getDeclarationKeys(right);\n\n  for (const key of leftKeys) {\n    if (rightKeys.has(key)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Resolves one symbol to its canonical target.\n * @param symbol Candidate symbol.\n * @param checker TypeScript checker.\n * @returns Resolved canonical symbol.\n * @example\n * ```typescript\n * const resolved = resolveCanonicalSymbol(symbol, checker);\n * ```\n */\nconst resolveCanonicalSymbol = (\n  symbol: ts.Symbol,\n  checker: ts.TypeChecker,\n): ts.Symbol => {\n  if ((symbol.flags & ts.SymbolFlags.Alias) === 0) {\n    return symbol;\n  }\n\n  try {\n    return checker.getAliasedSymbol(symbol);\n  } catch {\n    return symbol;\n  }\n};\n\n/**\n * Resolves one exported symbol by name from a source file.\n * @param program TypeScript program.\n * @param sourceFilename Source file path.\n * @param exportedName Public name exposed by the module export list.\n * @returns Symbol when found.\n * @example\n * ```typescript\n * const symbol = getExportedSymbol(program, sourceFilename, \"feature\");\n * ```\n */\nconst getExportedSymbol = (\n  program: ts.Program,\n  sourceFilename: string,\n  exportedName: string,\n): ts.Symbol | undefined => {\n  const checker = program.getTypeChecker();\n  const sourceFile = program\n    .getSourceFiles()\n    .find(\n      (file) =>\n        toComparableAbsolutePath(file.fileName) ===\n        toComparableAbsolutePath(sourceFilename),\n    );\n\n  if (sourceFile === void 0) {\n    return void 0;\n  }\n\n  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n\n  if (moduleSymbol === void 0) {\n    return void 0;\n  }\n\n  const exportedSymbol = checker\n    .getExportsOfModule(moduleSymbol)\n    .find((symbol) => symbol.getName() === exportedName);\n\n  if (exportedSymbol === void 0) {\n    return void 0;\n  }\n\n  return resolveCanonicalSymbol(exportedSymbol, checker);\n};\n\n/**\n * Checks whether one source file exports the target symbol.\n * @param sourceFile Source file that may expose the symbol.\n * @param checker TypeScript checker.\n * @param targetSymbol Symbol being classified.\n * @returns True when one module export resolves to the target symbol.\n * @example\n * ```typescript\n * const exposed = sourceFileExportsSymbol(sourceFile, checker, targetSymbol);\n * ```\n */\nconst sourceFileExportsSymbol = (\n  sourceFile: ts.SourceFile,\n  checker: ts.TypeChecker,\n  targetSymbol: ts.Symbol,\n): boolean => {\n  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n\n  if (moduleSymbol === void 0) {\n    return false;\n  }\n\n  for (const exportedSymbol of checker.getExportsOfModule(moduleSymbol)) {\n    const resolvedSymbol = resolveCanonicalSymbol(exportedSymbol, checker);\n\n    if (isSameSymbol(resolvedSymbol, targetSymbol)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nexport {\n  getExportedSymbol,\n  isSameSymbol,\n  resolveCanonicalSymbol,\n  sourceFileExportsSymbol,\n  toComparableAbsolutePath,\n};\n"]}

package/dist/domain/architecture/no-unused-exports/{no-unused-exports-utilities.d.ts → no-unused-exports-usage-utilities.d.ts}

@@ -1,26 +1,5 @@
-import type { AST, Rule } from "eslint";
 import * as ts from "typescript";
 import type { ExportedElement, ExportUsage, NoUnusedExportsState } from "./types.js";
-/**
- * Resolves TypeScript parser services program when available.
- * @param context Rule context.
- * @returns TypeScript program when available.
- * @example
- * ```typescript
- * const program = getTypeScriptProgram(context);
- * ```
- */
-declare const getTypeScriptProgram: (context: Rule.RuleContext) => ts.Program | undefined;
-/**
- * Collects exported elements from one program body.
- * @param body Program body statements.
- * @returns Exported elements in declaration order.
- * @example
- * ```typescript
- * const exported = collectExportedElements(program.body);
- * ```
- */
-declare const collectExportedElements: (body: AST.Program["body"]) => ExportedElement[];
 /**
  * Collects concrete usages of one exported element across the program.
  * @param program TypeScript program.
@@ -45,5 +24,5 @@ declare const collectCrossFileUsages: (program: ts.Program, sourceFilename: stri
  * ```
  */
 declare const classifyExportUsage: (usages: ExportUsage[]) => "production" | "test-only" | "unused";
-export { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, };
-//# sourceMappingURL=no-unused-exports-utilities.d.ts.map
+export { classifyExportUsage, collectCrossFileUsages };
+//# sourceMappingURL=no-unused-exports-usage-utilities.d.ts.map

package/dist/domain/architecture/no-unused-exports/no-unused-exports-usage-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-usage-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-usage-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAuEjB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,sBAAsB,GAC1B,SAAS,EAAE,CAAC,OAAO,EACnB,gBAAgB,MAAM,EACtB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,iBAAiB,eAAe,KAC/B,WAAW,EAoDb,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GACvB,QAAQ,WAAW,EAAE,KACpB,YAAY,GAAG,WAAW,GAAG,QAY/B,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-exports/no-unused-exports-usage-utilities.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import * as ts from "typescript";
+import { isConcreteUsageIdentifier } from "./no-unused-exports-identifier-utilities.js";
+import { isTestFile } from "./no-unused-exports-options.js";
+import { collectPublicApiExposureUsages } from "./no-unused-exports-public-api-usage-utilities.js";
+import { getExportedSymbol, isSameSymbol, resolveCanonicalSymbol, toComparableAbsolutePath, } from "./no-unused-exports-symbol-utilities.js";
+/**
+ * Appends concrete usages from one source file into the accumulator.
+ * @param sourceFile Source file to scan.
+ * @param checker TypeScript checker.
+ * @param targetSymbol Export symbol being classified.
+ * @param exportedElement Export metadata.
+ * @param consumerIsTestFile Whether source file is a test file.
+ * @param usages Mutable usage accumulator.
+ * @example
+ * ```typescript
+ * collectConcreteUsagesFromSourceFile(sourceFile, checker, targetSymbolKey, exportedElement, false, usages);
+ * ```
+ */
+const collectConcreteUsagesFromSourceFile = (sourceFile, checker, targetSymbol, exportedElement, consumerIsTestFile, usages) => {
+    const visitNode = (node) => {
+        if (!ts.isIdentifier(node)) {
+            ts.forEachChild(node, visitNode);
+            return;
+        }
+        if (!isConcreteUsageIdentifier(node, exportedElement.exportKind)) {
+            ts.forEachChild(node, visitNode);
+            return;
+        }
+        const isShorthandName = ts.isShorthandPropertyAssignment(node.parent) &&
+            node.parent.name === node;
+        const candidateSymbol = isShorthandName
+            ? checker.getShorthandAssignmentValueSymbol(node.parent)
+            : checker.getSymbolAtLocation(node);
+        if (candidateSymbol === void 0) {
+            ts.forEachChild(node, visitNode);
+            return;
+        }
+        const resolvedSymbol = resolveCanonicalSymbol(candidateSymbol, checker);
+        if (!isSameSymbol(resolvedSymbol, targetSymbol)) {
+            ts.forEachChild(node, visitNode);
+            return;
+        }
+        usages.push({ isTestFile: consumerIsTestFile });
+        ts.forEachChild(node, visitNode);
+    };
+    visitNode(sourceFile);
+};
+/**
+ * Collects concrete usages of one exported element across the program.
+ * @param program TypeScript program.
+ * @param sourceFilename Source filename where export is defined.
+ * @param state Normalized rule options.
+ * @param repoRoot Absolute repository root used for test-file classification.
+ * @param exportedElement Exported element to classify.
+ * @returns Concrete usages for the exported element.
+ * @example
+ * ```typescript
+ * const usages = collectCrossFileUsages(program, "/repo/src/feature.ts", state, "/repo", exportedElement);
+ * ```
+ */
+const collectCrossFileUsages = (program, sourceFilename, state, repoRoot, exportedElement) => {
+    const checker = program.getTypeChecker();
+    const targetSymbol = getExportedSymbol(program, sourceFilename, exportedElement.exportedName);
+    if (targetSymbol === void 0) {
+        return [];
+    }
+    const normalizedSourceFilename = toComparableAbsolutePath(sourceFilename);
+    const normalizedRepoRoot = path.resolve(repoRoot);
+    const usages = collectPublicApiExposureUsages(program, sourceFilename, state, repoRoot, targetSymbol);
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const consumerFilename = path.resolve(sourceFile.fileName);
+        const normalizedConsumerFilename = toComparableAbsolutePath(consumerFilename);
+        if (normalizedConsumerFilename === normalizedSourceFilename) {
+            continue;
+        }
+        const isConsumerTestFile = isTestFile(consumerFilename, state, normalizedRepoRoot);
+        collectConcreteUsagesFromSourceFile(sourceFile, checker, targetSymbol, exportedElement, isConsumerTestFile, usages);
+    }
+    return usages;
+};
+/**
+ * Classifies one exported name based on cross-file usages.
+ * @param usages Collected usages.
+ * @returns Classification label.
+ * @example
+ * ```typescript
+ * const classification = classifyExportUsage("feature", usages);
+ * ```
+ */
+const classifyExportUsage = (usages) => {
+    if (usages.length === 0) {
+        return "unused";
+    }
+    for (const usage of usages) {
+        if (!usage.isTestFile) {
+            return "production";
+        }
+    }
+    return "test-only";
+};
+export { classifyExportUsage, collectCrossFileUsages };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-exports-usage-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-usage-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type {\n  ExportedElement,\n  ExportUsage,\n  NoUnusedExportsState,\n} from \"./types\";\n\nimport { isConcreteUsageIdentifier } from \"./no-unused-exports-identifier-utilities\";\nimport { isTestFile } from \"./no-unused-exports-options\";\nimport { collectPublicApiExposureUsages } from \"./no-unused-exports-public-api-usage-utilities\";\nimport {\n  getExportedSymbol,\n  isSameSymbol,\n  resolveCanonicalSymbol,\n  toComparableAbsolutePath,\n} from \"./no-unused-exports-symbol-utilities\";\n\n/**\n * Appends concrete usages from one source file into the accumulator.\n * @param sourceFile Source file to scan.\n * @param checker TypeScript checker.\n * @param targetSymbol Export symbol being classified.\n * @param exportedElement Export metadata.\n * @param consumerIsTestFile Whether source file is a test file.\n * @param usages Mutable usage accumulator.\n * @example\n * ```typescript\n * collectConcreteUsagesFromSourceFile(sourceFile, checker, targetSymbolKey, exportedElement, false, usages);\n * ```\n */\nconst collectConcreteUsagesFromSourceFile = (\n  sourceFile: ts.SourceFile,\n  checker: ts.TypeChecker,\n  targetSymbol: ts.Symbol,\n  exportedElement: ExportedElement,\n  consumerIsTestFile: boolean,\n  usages: ExportUsage[],\n): void => {\n  const visitNode = (node: ts.Node): void => {\n    if (!ts.isIdentifier(node)) {\n      ts.forEachChild(node, visitNode);\n      return;\n    }\n\n    if (!isConcreteUsageIdentifier(node, exportedElement.exportKind)) {\n      ts.forEachChild(node, visitNode);\n      return;\n    }\n\n    const isShorthandName =\n      ts.isShorthandPropertyAssignment(node.parent) &&\n      node.parent.name === node;\n\n    const candidateSymbol = isShorthandName\n      ? checker.getShorthandAssignmentValueSymbol(node.parent)\n      : checker.getSymbolAtLocation(node);\n\n    if (candidateSymbol === void 0) {\n      ts.forEachChild(node, visitNode);\n      return;\n    }\n\n    const resolvedSymbol = resolveCanonicalSymbol(candidateSymbol, checker);\n\n    if (!isSameSymbol(resolvedSymbol, targetSymbol)) {\n      ts.forEachChild(node, visitNode);\n      return;\n    }\n\n    usages.push({ isTestFile: consumerIsTestFile });\n    ts.forEachChild(node, visitNode);\n  };\n\n  visitNode(sourceFile);\n};\n\n/**\n * Collects concrete usages of one exported element across the program.\n * @param program TypeScript program.\n * @param sourceFilename Source filename where export is defined.\n * @param state Normalized rule options.\n * @param repoRoot Absolute repository root used for test-file classification.\n * @param exportedElement Exported element to classify.\n * @returns Concrete usages for the exported element.\n * @example\n * ```typescript\n * const usages = collectCrossFileUsages(program, \"/repo/src/feature.ts\", state, \"/repo\", exportedElement);\n * ```\n */\nconst collectCrossFileUsages = (\n  program: ts.Program,\n  sourceFilename: string,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  exportedElement: ExportedElement,\n): ExportUsage[] => {\n  const checker = program.getTypeChecker();\n  const targetSymbol = getExportedSymbol(\n    program,\n    sourceFilename,\n    exportedElement.exportedName,\n  );\n\n  if (targetSymbol === void 0) {\n    return [];\n  }\n\n  const normalizedSourceFilename = toComparableAbsolutePath(sourceFilename);\n  const normalizedRepoRoot = path.resolve(repoRoot);\n  const usages: ExportUsage[] = collectPublicApiExposureUsages(\n    program,\n    sourceFilename,\n    state,\n    repoRoot,\n    targetSymbol,\n  );\n\n  for (const sourceFile of program.getSourceFiles()) {\n    if (sourceFile.isDeclarationFile) {\n      continue;\n    }\n\n    const consumerFilename = path.resolve(sourceFile.fileName);\n    const normalizedConsumerFilename =\n      toComparableAbsolutePath(consumerFilename);\n\n    if (normalizedConsumerFilename === normalizedSourceFilename) {\n      continue;\n    }\n\n    const isConsumerTestFile = isTestFile(\n      consumerFilename,\n      state,\n      normalizedRepoRoot,\n    );\n\n    collectConcreteUsagesFromSourceFile(\n      sourceFile,\n      checker,\n      targetSymbol,\n      exportedElement,\n      isConsumerTestFile,\n      usages,\n    );\n  }\n\n  return usages;\n};\n\n/**\n * Classifies one exported name based on cross-file usages.\n * @param usages Collected usages.\n * @returns Classification label.\n * @example\n * ```typescript\n * const classification = classifyExportUsage(\"feature\", usages);\n * ```\n */\nconst classifyExportUsage = (\n  usages: ExportUsage[],\n): \"production\" | \"test-only\" | \"unused\" => {\n  if (usages.length === 0) {\n    return \"unused\";\n  }\n\n  for (const usage of usages) {\n    if (!usage.isTestFile) {\n      return \"production\";\n    }\n  }\n\n  return \"test-only\";\n};\n\nexport { classifyExportUsage, collectCrossFileUsages };\n"]}

package/dist/domain/architecture/no-unused-exports/rule.js

@@ -1,6 +1,8 @@
 import path from "node:path";
+import { collectExportedElements } from "./no-unused-exports-declaration-utilities.js";
+import { getTypeScriptProgram } from "./no-unused-exports-identifier-utilities.js";
 import { DEFAULT_PUBLIC_API_FILES, DEFAULT_TEST_FILE_PATTERNS, getOptions, isLintableFilename, isPublicApiFile, } from "./no-unused-exports-options.js";
-import { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, } from "./no-unused-exports-utilities.js";
+import { classifyExportUsage, collectCrossFileUsages, } from "./no-unused-exports-usage-utilities.js";
 /** ESLint rule flagging exports unused in production code. */
 const noUnusedExportsRule = {
     create(context) {
@@ -79,4 +81,4 @@ const noUnusedExportsRule = {
     },
 };
 export { noUnusedExportsRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/core/index.d.ts

@@ -1,3 +1,4 @@
 export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { noUselessDelegationRule } from "./no-useless-delegation/index.js";
 export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/domain/core/index.js

@@ -1,3 +1,4 @@
 export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { noUselessDelegationRule } from "./no-useless-delegation/index.js";
 export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnNcIjtcbmV4cG9ydCB7IHByZWZlckludGVyZmFjZVR5cGVzUnVsZSB9IGZyb20gXCIuL3ByZWZlci1pbnRlcmZhY2UtdHlwZXNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnNcIjtcbmV4cG9ydCB7IG5vVXNlbGVzc0RlbGVnYXRpb25SdWxlIH0gZnJvbSBcIi4vbm8tdXNlbGVzcy1kZWxlZ2F0aW9uXCI7XG5leHBvcnQgeyBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUgfSBmcm9tIFwiLi9wcmVmZXItaW50ZXJmYWNlLXR5cGVzXCI7XG4iXX0=

package/dist/domain/core/no-multiple-declarators/rule-utilities.d.ts

@@ -0,0 +1,58 @@
+import type { Rule } from "eslint";
+import type { FixableVariableDeclarationNode, RangedVariableDeclaratorNode, SourceCodeAccess, VariableDeclarationNode, VariableDeclaratorNode } from "./types.js";
+/**
+ * Gets the source access wrapper from the ESLint context.
+ * @param context Rule execution context.
+ * @returns Source access helpers used by the fixer.
+ * @example
+ * ```typescript
+ * const sourceCode = getSourceCode(context);
+ * ```
+ */
+declare const getSourceCode: (context: Rule.RuleContext) => SourceCodeAccess;
+/**
+ * Reads the full source text for the active file.
+ * @param sourceCode Source access wrapper.
+ * @returns Full source text.
+ * @example
+ * ```typescript
+ * const sourceText = getSourceText(sourceCode);
+ * ```
+ */
+declare const getSourceText: (sourceCode: SourceCodeAccess) => string;
+/**
+ * Collects ranged declarators when every declarator exposes a range.
+ * @param declarations Declarators from the declaration node.
+ * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.
+ * @example
+ * ```typescript
+ * const ranged = getRangedDeclarations(node.declarations ?? []);
+ * ```
+ */
+declare const getRangedDeclarations: (declarations: readonly VariableDeclaratorNode[]) => readonly RangedVariableDeclaratorNode[] | undefined;
+/**
+ * Determines whether a declaration can be safely rewritten.
+ * @param node Declaration node to inspect.
+ * @param declarations Declarators within the declaration.
+ * @param sourceText Full source text.
+ * @returns Whether the declaration is safe to autofix.
+ * @example
+ * ```typescript
+ * const fixable = canFix(node, declarations, sourceText);
+ * ```
+ */
+declare const canFix: (node: VariableDeclarationNode, declarations: readonly VariableDeclaratorNode[], sourceText: string) => boolean;
+/**
+ * Converts declarators into separate declaration statements.
+ * @param node Fixable declaration node.
+ * @param declarations Declarators that should be split.
+ * @param sourceCode Source access wrapper.
+ * @returns Replacement text for the full declaration.
+ * @example
+ * ```typescript
+ * const replacement = buildReplacement(node, declarations, sourceCode);
+ * ```
+ */
+declare const buildReplacement: (node: FixableVariableDeclarationNode, declarations: readonly RangedVariableDeclaratorNode[], sourceCode: SourceCodeAccess) => string;
+export { buildReplacement, canFix, getRangedDeclarations, getSourceCode, getSourceText, };
+//# sourceMappingURL=rule-utilities.d.ts.map

package/dist/domain/core/no-multiple-declarators/rule-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EACV,8BAA8B,EAG9B,4BAA4B,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAejB;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,SAAS,IAAI,CAAC,WAAW,KAAG,gBACA,CAAC;AAEpD;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,YAAY,gBAAgB,KAAG,MACwB,CAAC;AA6I/E;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,cAAc,SAAS,sBAAsB,EAAE,KAC9C,SAAS,4BAA4B,EAAE,GAAG,SAY5C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,MAAM,GACV,MAAM,uBAAuB,EAC7B,cAAc,SAAS,sBAAsB,EAAE,EAC/C,YAAY,MAAM,KACjB,OAiBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,gBAAgB,GACpB,MAAM,8BAA8B,EACpC,cAAc,SAAS,4BAA4B,EAAE,EACrD,YAAY,gBAAgB,KAC3B,MAQF,CAAC;AAEF,OAAO,EACL,gBAAgB,EAChB,MAAM,EACN,qBAAqB,EACrB,aAAa,EACb,aAAa,GACd,CAAC"}