@codeperfect/eslint-plugin 2.3.0 → 2.5.0

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

@@ -0,0 +1,78 @@
+import { asRecord, readArrayProperty, readStringProperty, } from "./no-unused-exports-record-utilities.js";
+/**
+ * Collects identifier names from one variable pattern.
+ * @param node Variable pattern candidate.
+ * @returns Identifier names declared by the pattern.
+ * @example
+ * ```typescript
+ * const names = collectPatternIdentifierNames(pattern);
+ * ```
+ */
+const collectPatternIdentifierNames = (node) => {
+    const pattern = asRecord(node);
+    if (pattern === void 0) {
+        return [];
+    }
+    const patternType = readStringProperty(pattern, "type");
+    if (patternType === "Identifier") {
+        const name = readStringProperty(pattern, "name");
+        return name === void 0 ? [] : [name];
+    }
+    if (patternType === "RestElement") {
+        return collectPatternIdentifierNames(pattern["argument"]);
+    }
+    if (patternType === "AssignmentPattern") {
+        return collectPatternIdentifierNames(pattern["left"]);
+    }
+    if (patternType === "ArrayPattern") {
+        const elements = readArrayProperty(pattern, "elements");
+        return elements === void 0
+            ? []
+            : elements.flatMap((element) => collectPatternIdentifierNames(element));
+    }
+    if (patternType === "ObjectPattern") {
+        const properties = readArrayProperty(pattern, "properties");
+        return properties === void 0
+            ? []
+            : properties.flatMap((property) => {
+                if (readStringProperty(property, "type") === "RestElement") {
+                    return collectPatternIdentifierNames(asRecord(property)?.["argument"]);
+                }
+                return collectPatternIdentifierNames(asRecord(property)?.["value"]);
+            });
+    }
+    return [];
+};
+/**
+ * Reads one export specifier name.
+ * @param specifier Export specifier candidate.
+ * @returns Exported name when available.
+ * @example
+ * ```typescript
+ * const name = getExportSpecifierName(specifier);
+ * ```
+ */
+const getExportSpecifierName = (specifier) => {
+    const candidate = asRecord(specifier);
+    const exportedName = readStringProperty(candidate?.["exported"], "name");
+    if (typeof exportedName === "string") {
+        return exportedName;
+    }
+    const localName = readStringProperty(candidate?.["local"], "name");
+    return typeof localName === "string" ? localName : void 0;
+};
+/**
+ * Reads one local export specifier name.
+ * @param specifier Export specifier candidate.
+ * @returns Local specifier name when available.
+ * @example
+ * ```typescript
+ * const name = getExportSpecifierLocalName(specifier);
+ * ```
+ */
+const getExportSpecifierLocalName = (specifier) => {
+    const candidate = asRecord(specifier);
+    return readStringProperty(candidate?.["local"], "name");
+};
+export { collectPatternIdentifierNames, getExportSpecifierLocalName, getExportSpecifierName, };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+import * as ts from "typescript";
+import type { ExportUsage, NoUnusedExportsState } from "./types.js";
+/**
+ * Collects public API exposure usages for one exported symbol.
+ * @param program TypeScript program.
+ * @param sourceFilename Source filename where export is defined.
+ * @param state Normalized rule options.
+ * @param repoRoot Absolute repository root used for file classification.
+ * @param targetSymbol Export symbol being classified.
+ * @returns Public API exposure usages for the exported symbol.
+ * @example
+ * ```typescript
+ * const usages = collectPublicApiExposureUsages(program, sourceFilename, state, repoRoot, targetSymbol);
+ * ```
+ */
+declare const collectPublicApiExposureUsages: (program: ts.Program, sourceFilename: string, state: NoUnusedExportsState, repoRoot: string, targetSymbol: ts.Symbol) => ExportUsage[];
+export { collectPublicApiExposureUsages };
+//# sourceMappingURL=no-unused-exports-public-api-usage-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-public-api-usage-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-public-api-usage-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAQjE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,8BAA8B,GAClC,SAAS,EAAE,CAAC,OAAO,EACnB,gBAAgB,MAAM,EACtB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,cAAc,EAAE,CAAC,MAAM,KACtB,WAAW,EAiCb,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

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

@@ -0,0 +1,45 @@
+import path from "node:path";
+import * as ts from "typescript";
+import { isPublicApiFile, isTestFile } from "./no-unused-exports-options.js";
+import { sourceFileExportsSymbol, toComparableAbsolutePath, } from "./no-unused-exports-symbol-utilities.js";
+/**
+ * Collects public API exposure usages for one exported symbol.
+ * @param program TypeScript program.
+ * @param sourceFilename Source filename where export is defined.
+ * @param state Normalized rule options.
+ * @param repoRoot Absolute repository root used for file classification.
+ * @param targetSymbol Export symbol being classified.
+ * @returns Public API exposure usages for the exported symbol.
+ * @example
+ * ```typescript
+ * const usages = collectPublicApiExposureUsages(program, sourceFilename, state, repoRoot, targetSymbol);
+ * ```
+ */
+const collectPublicApiExposureUsages = (program, sourceFilename, state, repoRoot, targetSymbol) => {
+    const checker = program.getTypeChecker();
+    const normalizedSourceFilename = toComparableAbsolutePath(sourceFilename);
+    const normalizedRepoRoot = path.resolve(repoRoot);
+    const usages = [];
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const publicApiFilename = path.resolve(sourceFile.fileName);
+        const normalizedPublicApiFilename = toComparableAbsolutePath(publicApiFilename);
+        if (normalizedPublicApiFilename === normalizedSourceFilename) {
+            continue;
+        }
+        if (!isPublicApiFile(publicApiFilename, state, normalizedRepoRoot)) {
+            continue;
+        }
+        if (!sourceFileExportsSymbol(sourceFile, checker, targetSymbol)) {
+            continue;
+        }
+        usages.push({
+            isTestFile: isTestFile(publicApiFilename, state, normalizedRepoRoot),
+        });
+    }
+    return usages;
+};
+export { collectPublicApiExposureUsages };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tdW51c2VkLWV4cG9ydHMtcHVibGljLWFwaS11c2FnZS11dGlsaXRpZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2FyY2hpdGVjdHVyZS9uby11bnVzZWQtZXhwb3J0cy9uby11bnVzZWQtZXhwb3J0cy1wdWJsaWMtYXBpLXVzYWdlLXV0aWxpdGllcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLElBQUksTUFBTSxXQUFXLENBQUM7QUFDN0IsT0FBTyxLQUFLLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFJakMsT0FBTyxFQUFFLGVBQWUsRUFBRSxVQUFVLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMxRSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLHdCQUF3QixHQUN6QixNQUFNLHNDQUFzQyxDQUFDO0FBRTlDOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILE1BQU0sOEJBQThCLEdBQUcsQ0FDckMsT0FBbUIsRUFDbkIsY0FBc0IsRUFDdEIsS0FBMkIsRUFDM0IsUUFBZ0IsRUFDaEIsWUFBdUIsRUFDUixFQUFFO0lBQ2pCLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQztJQUN6QyxNQUFNLHdCQUF3QixHQUFHLHdCQUF3QixDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzFFLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNsRCxNQUFNLE1BQU0sR0FBa0IsRUFBRSxDQUFDO0lBRWpDLEtBQUssTUFBTSxVQUFVLElBQUksT0FBTyxDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUM7UUFDbEQsSUFBSSxVQUFVLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUNqQyxTQUFTO1FBQ1gsQ0FBQztRQUVELE1BQU0saUJBQWlCLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDNUQsTUFBTSwyQkFBMkIsR0FDL0Isd0JBQXdCLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUU5QyxJQUFJLDJCQUEyQixLQUFLLHdCQUF3QixFQUFFLENBQUM7WUFDN0QsU0FBUztRQUNYLENBQUM7UUFFRCxJQUFJLENBQUMsZUFBZSxDQUFDLGlCQUFpQixFQUFFLEtBQUssRUFBRSxrQkFBa0IsQ0FBQyxFQUFFLENBQUM7WUFDbkUsU0FBUztRQUNYLENBQUM7UUFFRCxJQUFJLENBQUMsdUJBQXVCLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxZQUFZLENBQUMsRUFBRSxDQUFDO1lBQ2hFLFNBQVM7UUFDWCxDQUFDO1FBRUQsTUFBTSxDQUFDLElBQUksQ0FBQztZQUNWLFVBQVUsRUFBRSxVQUFVLENBQUMsaUJBQWlCLEVBQUUsS0FBSyxFQUFFLGtCQUFrQixDQUFDO1NBQ3JFLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUM7QUFFRixPQUFPLEVBQUUsOEJBQThCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwYXRoIGZyb20gXCJub2RlOnBhdGhcIjtcbmltcG9ydCAqIGFzIHRzIGZyb20gXCJ0eXBlc2NyaXB0XCI7XG5cbmltcG9ydCB0eXBlIHsgRXhwb3J0VXNhZ2UsIE5vVW51c2VkRXhwb3J0c1N0YXRlIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuaW1wb3J0IHsgaXNQdWJsaWNBcGlGaWxlLCBpc1Rlc3RGaWxlIH0gZnJvbSBcIi4vbm8tdW51c2VkLWV4cG9ydHMtb3B0aW9uc1wiO1xuaW1wb3J0IHtcbiAgc291cmNlRmlsZUV4cG9ydHNTeW1ib2wsXG4gIHRvQ29tcGFyYWJsZUFic29sdXRlUGF0aCxcbn0gZnJvbSBcIi4vbm8tdW51c2VkLWV4cG9ydHMtc3ltYm9sLXV0aWxpdGllc1wiO1xuXG4vKipcbiAqIENvbGxlY3RzIHB1YmxpYyBBUEkgZXhwb3N1cmUgdXNhZ2VzIGZvciBvbmUgZXhwb3J0ZWQgc3ltYm9sLlxuICogQHBhcmFtIHByb2dyYW0gVHlwZVNjcmlwdCBwcm9ncmFtLlxuICogQHBhcmFtIHNvdXJjZUZpbGVuYW1lIFNvdXJjZSBmaWxlbmFtZSB3aGVyZSBleHBvcnQgaXMgZGVmaW5lZC5cbiAqIEBwYXJhbSBzdGF0ZSBOb3JtYWxpemVkIHJ1bGUgb3B0aW9ucy5cbiAqIEBwYXJhbSByZXBvUm9vdCBBYnNvbHV0ZSByZXBvc2l0b3J5IHJvb3QgdXNlZCBmb3IgZmlsZSBjbGFzc2lmaWNhdGlvbi5cbiAqIEBwYXJhbSB0YXJnZXRTeW1ib2wgRXhwb3J0IHN5bWJvbCBiZWluZyBjbGFzc2lmaWVkLlxuICogQHJldHVybnMgUHVibGljIEFQSSBleHBvc3VyZSB1c2FnZXMgZm9yIHRoZSBleHBvcnRlZCBzeW1ib2wuXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogY29uc3QgdXNhZ2VzID0gY29sbGVjdFB1YmxpY0FwaUV4cG9zdXJlVXNhZ2VzKHByb2dyYW0sIHNvdXJjZUZpbGVuYW1lLCBzdGF0ZSwgcmVwb1Jvb3QsIHRhcmdldFN5bWJvbCk7XG4gKiBgYGBcbiAqL1xuY29uc3QgY29sbGVjdFB1YmxpY0FwaUV4cG9zdXJlVXNhZ2VzID0gKFxuICBwcm9ncmFtOiB0cy5Qcm9ncmFtLFxuICBzb3VyY2VGaWxlbmFtZTogc3RyaW5nLFxuICBzdGF0ZTogTm9VbnVzZWRFeHBvcnRzU3RhdGUsXG4gIHJlcG9Sb290OiBzdHJpbmcsXG4gIHRhcmdldFN5bWJvbDogdHMuU3ltYm9sLFxuKTogRXhwb3J0VXNhZ2VbXSA9PiB7XG4gIGNvbnN0IGNoZWNrZXIgPSBwcm9ncmFtLmdldFR5cGVDaGVja2VyKCk7XG4gIGNvbnN0IG5vcm1hbGl6ZWRTb3VyY2VGaWxlbmFtZSA9IHRvQ29tcGFyYWJsZUFic29sdXRlUGF0aChzb3VyY2VGaWxlbmFtZSk7XG4gIGNvbnN0IG5vcm1hbGl6ZWRSZXBvUm9vdCA9IHBhdGgucmVzb2x2ZShyZXBvUm9vdCk7XG4gIGNvbnN0IHVzYWdlczogRXhwb3J0VXNhZ2VbXSA9IFtdO1xuXG4gIGZvciAoY29uc3Qgc291cmNlRmlsZSBvZiBwcm9ncmFtLmdldFNvdXJjZUZpbGVzKCkpIHtcbiAgICBpZiAoc291cmNlRmlsZS5pc0RlY2xhcmF0aW9uRmlsZSkge1xuICAgICAgY29udGludWU7XG4gICAgfVxuXG4gICAgY29uc3QgcHVibGljQXBpRmlsZW5hbWUgPSBwYXRoLnJlc29sdmUoc291cmNlRmlsZS5maWxlTmFtZSk7XG4gICAgY29uc3Qgbm9ybWFsaXplZFB1YmxpY0FwaUZpbGVuYW1lID1cbiAgICAgIHRvQ29tcGFyYWJsZUFic29sdXRlUGF0aChwdWJsaWNBcGlGaWxlbmFtZSk7XG5cbiAgICBpZiAobm9ybWFsaXplZFB1YmxpY0FwaUZpbGVuYW1lID09PSBub3JtYWxpemVkU291cmNlRmlsZW5hbWUpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cblxuICAgIGlmICghaXNQdWJsaWNBcGlGaWxlKHB1YmxpY0FwaUZpbGVuYW1lLCBzdGF0ZSwgbm9ybWFsaXplZFJlcG9Sb290KSkge1xuICAgICAgY29udGludWU7XG4gICAgfVxuXG4gICAgaWYgKCFzb3VyY2VGaWxlRXhwb3J0c1N5bWJvbChzb3VyY2VGaWxlLCBjaGVja2VyLCB0YXJnZXRTeW1ib2wpKSB7XG4gICAgICBjb250aW51ZTtcbiAgICB9XG5cbiAgICB1c2FnZXMucHVzaCh7XG4gICAgICBpc1Rlc3RGaWxlOiBpc1Rlc3RGaWxlKHB1YmxpY0FwaUZpbGVuYW1lLCBzdGF0ZSwgbm9ybWFsaXplZFJlcG9Sb290KSxcbiAgICB9KTtcbiAgfVxuXG4gIHJldHVybiB1c2FnZXM7XG59O1xuXG5leHBvcnQgeyBjb2xsZWN0UHVibGljQXBpRXhwb3N1cmVVc2FnZXMgfTtcbiJdfQ==

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

@@ -0,0 +1,34 @@
+/**
+ * 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" });
+ * ```
+ */
+declare const asRecord: (value: unknown) => Record<string, unknown> | undefined;
+/**
+ * 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");
+ * ```
+ */
+declare const readArrayProperty: (value: unknown, key: string) => undefined | unknown[];
+/**
+ * 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");
+ * ```
+ */
+declare const readStringProperty: (value: unknown, key: string) => string | undefined;
+export { asRecord, readArrayProperty, readStringProperty };
+//# sourceMappingURL=no-unused-exports-record-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-record-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-record-utilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,QAAA,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAGjD,CAAC;AAEb;;;;;;;;;GASG;AACH,QAAA,MAAM,iBAAiB,GACrB,OAAO,OAAO,EACd,KAAK,MAAM,KACV,SAAS,GAAG,OAAO,EAIrB,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,OAAO,OAAO,EACd,KAAK,MAAM,KACV,MAAM,GAAG,SAIX,CAAC;AAEF,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAC"}

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-usage-utilities.d.ts

@@ -0,0 +1,28 @@
+import * as ts from "typescript";
+import type { ExportedElement, ExportUsage, NoUnusedExportsState } from "./types.js";
+/**
+ * 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);
+ * ```
+ */
+declare const collectCrossFileUsages: (program: ts.Program, sourceFilename: string, state: NoUnusedExportsState, repoRoot: string, exportedElement: ExportedElement) => ExportUsage[];
+/**
+ * Classifies one exported name based on cross-file usages.
+ * @param usages Collected usages.
+ * @returns Classification label.
+ * @example
+ * ```typescript
+ * const classification = classifyExportUsage("feature", usages);
+ * ```
+ */
+declare const classifyExportUsage: (usages: ExportUsage[]) => "production" | "test-only" | "unused";
+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"]}