@codeperfect/eslint-plugin 2.0.0 → 2.2.0

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

@@ -0,0 +1,608 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import path from "node:path";
+import * as ts from "typescript";
+import { isPublicApiFile, isTestFile } from "./no-unused-exports-options.js";
+/**
+ * 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();
+};
+/**
+ * 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 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;
+};
+/**
+ * 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;
+};
+/**
+ * Resolves TypeScript parser services program when available.
+ * @param context Rule context.
+ * @returns TypeScript program when available.
+ * @example
+ * ```typescript
+ * const program = getTypeScriptProgram(context);
+ * ```
+ */
+const getTypeScriptProgram = (context) => {
+    try {
+        const services = ESLintUtils.getParserServices(context);
+        return services.program;
+    }
+    catch {
+        return void 0;
+    }
+};
+/**
+ * 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") {
+        return (readArrayProperty(pattern, "elements") ?? []).flatMap((element) => collectPatternIdentifierNames(element));
+    }
+    if (patternType === "ObjectPattern") {
+        return (readArrayProperty(pattern, "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");
+};
+/**
+ * Collects top-level declaration names owned by the current module.
+ * @param body Program body statements.
+ * @returns Map from locally declared name to its declaration metadata.
+ * @example
+ * ```typescript
+ * const declarations = collectLocalDeclarationNames(program.body);
+ * ```
+ */
+const collectLocalDeclarationNames = (body) => {
+    const declarationNames = new Map();
+    for (const statement of body) {
+        const declarationCandidate = statement.type === "ExportNamedDeclaration" &&
+            statement.declaration !== null &&
+            statement.declaration !== void 0
+            ? statement.declaration
+            : statement;
+        const declarationCandidateRecord = asRecord(declarationCandidate);
+        const declarationCandidateType = readStringProperty(declarationCandidate, "type");
+        if (declarationCandidateRecord === void 0 ||
+            declarationCandidateType === void 0) {
+            continue;
+        }
+        if (declarationCandidateType === "FunctionDeclaration" ||
+            declarationCandidateType === "ClassDeclaration" ||
+            declarationCandidateType === "TSEnumDeclaration" ||
+            declarationCandidateType === "TSInterfaceDeclaration" ||
+            declarationCandidateType === "TSTypeAliasDeclaration") {
+            const declarationName = readStringProperty(declarationCandidateRecord["id"], "name");
+            if (declarationName !== void 0) {
+                declarationNames.set(declarationName, {
+                    kind: declarationCandidateType === "TSInterfaceDeclaration" ||
+                        declarationCandidateType === "TSTypeAliasDeclaration"
+                        ? "type"
+                        : "value",
+                    node: statement,
+                });
+            }
+            continue;
+        }
+        if (declarationCandidateType !== "VariableDeclaration") {
+            continue;
+        }
+        const declarations = readArrayProperty(declarationCandidateRecord, "declarations");
+        if (declarations === void 0) {
+            continue;
+        }
+        for (const declaration of declarations) {
+            const declarationRecord = asRecord(declaration);
+            if (declarationRecord === void 0) {
+                continue;
+            }
+            for (const name of collectPatternIdentifierNames(declarationRecord["id"])) {
+                declarationNames.set(name, { kind: "value", node: statement });
+            }
+        }
+    }
+    return declarationNames;
+};
+/**
+ * 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);
+ * ```
+ */
+const collectExportedElements = (body) => {
+    const exportedElements = [];
+    const localDeclarationNames = collectLocalDeclarationNames(body);
+    for (const statement of body) {
+        if (statement.type === "ExportDefaultDeclaration") {
+            exportedElements.push({
+                exportedName: "default",
+                exportKind: "value",
+                node: statement,
+            });
+            continue;
+        }
+        if (statement.type !== "ExportNamedDeclaration") {
+            continue;
+        }
+        if (statement.source !== null && statement.source !== void 0) {
+            continue;
+        }
+        if (statement.declaration !== null && statement.declaration !== void 0) {
+            const declaration = asRecord(statement.declaration);
+            if (readStringProperty(declaration, "type") === "VariableDeclaration") {
+                for (const variable of readArrayProperty(declaration, "declarations") ??
+                    []) {
+                    for (const name of collectPatternIdentifierNames(asRecord(variable)?.["id"])) {
+                        exportedElements.push({
+                            exportedName: name,
+                            exportKind: "value",
+                            node: statement,
+                        });
+                    }
+                }
+            }
+            else {
+                const declarationName = readStringProperty(declaration?.["id"], "name");
+                const declarationType = readStringProperty(declaration, "type");
+                const exportKind = declarationType === "TSInterfaceDeclaration" ||
+                    declarationType === "TSTypeAliasDeclaration"
+                    ? "type"
+                    : "value";
+                if (typeof declarationName === "string") {
+                    exportedElements.push({
+                        exportedName: declarationName,
+                        exportKind,
+                        node: statement,
+                    });
+                }
+            }
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            const localName = getExportSpecifierLocalName(specifier);
+            const localDeclaration = localName === void 0 ? void 0 : localDeclarationNames.get(localName);
+            if (localDeclaration === void 0) {
+                continue;
+            }
+            const exportedName = getExportSpecifierName(specifier);
+            if (exportedName !== void 0) {
+                const statementExportKind = readStringProperty(statement, "exportKind");
+                const specifierExportKind = readStringProperty(specifier, "exportKind");
+                const isTypeOnlyExport = statementExportKind === "type" || specifierExportKind === "type";
+                exportedElements.push({
+                    exportedName,
+                    exportKind: isTypeOnlyExport ? "type" : localDeclaration.kind,
+                    node: localDeclaration.node,
+                });
+            }
+        }
+    }
+    return exportedElements;
+};
+/**
+ * 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;
+    }
+};
+/**
+ * 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 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;
+};
+/**
+ * Checks whether an identifier participates in one declaration/import/export site.
+ * @param identifier Identifier node to evaluate.
+ * @returns True when the identifier is declaration-only syntax.
+ * @example
+ * ```typescript
+ * const declaration = isDeclarationOnlyIdentifier(identifier);
+ * ```
+ */
+const isDeclarationOnlyIdentifier = (identifier) => {
+    const parent = identifier.parent;
+    return (ts.isImportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent) ||
+        ts.isImportEqualsDeclaration(parent) ||
+        ts.isExportSpecifier(parent) ||
+        ts.isTypeAliasDeclaration(parent) ||
+        ts.isInterfaceDeclaration(parent) ||
+        ts.isTypeParameterDeclaration(parent) ||
+        (ts.isVariableDeclaration(parent) && parent.name === identifier) ||
+        (ts.isFunctionDeclaration(parent) && parent.name === identifier) ||
+        (ts.isClassDeclaration(parent) && parent.name === identifier) ||
+        (ts.isParameter(parent) && parent.name === identifier));
+};
+/**
+ * Checks whether one identifier node appears under a type node.
+ * @param identifier Candidate identifier.
+ * @returns True when the identifier is inside type-only syntax.
+ * @example
+ * ```typescript
+ * const typePosition = isTypePositionIdentifier(identifier);
+ * ```
+ */
+const isTypePositionIdentifier = (identifier) => {
+    const visitNode = (current) => {
+        if (ts.isTypeQueryNode(current)) {
+            return false;
+        }
+        if (ts.isTypeNode(current)) {
+            return true;
+        }
+        if (ts.isExpressionStatement(current) ||
+            ts.isCallExpression(current) ||
+            ts.isPropertyAccessExpression(current) ||
+            ts.isElementAccessExpression(current) ||
+            ts.isVariableDeclaration(current) ||
+            ts.isReturnStatement(current)) {
+            return false;
+        }
+        if (ts.isSourceFile(current)) {
+            return false;
+        }
+        return visitNode(current.parent);
+    };
+    return visitNode(identifier);
+};
+/**
+ * Checks whether one identifier is one concrete usage candidate for the export kind.
+ * @param identifier Identifier node.
+ * @param exportKind Whether type-only or value usage is required.
+ * @returns True when the identifier can satisfy usage.
+ * @example
+ * ```typescript
+ * const concrete = isConcreteUsageIdentifier(identifier, "value");
+ * ```
+ */
+const isConcreteUsageIdentifier = (identifier, exportKind) => {
+    if (isDeclarationOnlyIdentifier(identifier)) {
+        return false;
+    }
+    const inTypePosition = isTypePositionIdentifier(identifier);
+    return exportKind === "type" ? inTypePosition : !inTypePosition;
+};
+/**
+ * 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 candidateSymbol = 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 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;
+};
+/**
+ * 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 consumerIsTestFile = isTestFile(consumerFilename, state, normalizedRepoRoot);
+        collectConcreteUsagesFromSourceFile(sourceFile, checker, targetSymbol, exportedElement, consumerIsTestFile, 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, collectExportedElements, getTypeScriptProgram, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-exports-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST, Rule } from \"eslint\";\n\nimport { ESLintUtils } from \"@typescript-eslint/utils\";\nimport path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type {\n  ExportedElement,\n  ExportKind,\n  ExportUsage,\n  NoUnusedExportsState,\n} from \"./types\";\n\nimport { isPublicApiFile, isTestFile } from \"./no-unused-exports-options\";\n\n/** Local top-level declaration discovered when collecting export sources. */\ninterface LocalDeclaration {\n  /** Export kind implied by the declaration. */\n  kind: ExportKind;\n\n  /** Declaration statement used for diagnostics. */\n  node: AST.Program[\"body\"][number];\n}\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 * Converts one unknown value into an indexable record.\n * @param value Candidate value.\n * @returns Record view when the value is object-like.\n * @example\n * ```typescript\n * const record = asRecord({ type: \"Identifier\" });\n * ```\n */\nconst asRecord = (value: unknown): Record<string, unknown> | undefined =>\n  value !== null && typeof value === \"object\"\n    ? (value as Record<string, unknown>)\n    : void 0;\n\n/**\n * Reads one string property from an object-like value.\n * @param value Candidate object.\n * @param key Lookup key used to read the property.\n * @returns String value when present.\n * @example\n * ```typescript\n * const name = readStringProperty({ name: \"feature\" }, \"name\");\n * ```\n */\nconst readStringProperty = (\n  value: unknown,\n  key: string,\n): string | undefined => {\n  const record = asRecord(value);\n  const property = record?.[key];\n  return typeof property === \"string\" ? property : void 0;\n};\n\n/**\n * Reads one array property from an object-like value.\n * @param value Candidate object.\n * @param key Lookup key used to read the property.\n * @returns Array value when present.\n * @example\n * ```typescript\n * const items = readArrayProperty({ elements: [1, 2] }, \"elements\");\n * ```\n */\nconst readArrayProperty = (\n  value: unknown,\n  key: string,\n): undefined | unknown[] => {\n  const record = asRecord(value);\n  const property = record?.[key];\n  return Array.isArray(property) ? property : void 0;\n};\n\n/**\n * Resolves TypeScript parser services program when available.\n * @param context Rule context.\n * @returns TypeScript program when available.\n * @example\n * ```typescript\n * const program = getTypeScriptProgram(context);\n * ```\n */\nconst getTypeScriptProgram = (\n  context: Rule.RuleContext,\n): ts.Program | undefined => {\n  try {\n    const services = ESLintUtils.getParserServices(context as never);\n    return services.program;\n  } catch {\n    return void 0;\n  }\n};\n\n/**\n * Collects identifier names from one variable pattern.\n * @param node Variable pattern candidate.\n * @returns Identifier names declared by the pattern.\n * @example\n * ```typescript\n * const names = collectPatternIdentifierNames(pattern);\n * ```\n */\nconst collectPatternIdentifierNames = (node: unknown): string[] => {\n  const pattern = asRecord(node);\n\n  if (pattern === void 0) {\n    return [];\n  }\n\n  const patternType = readStringProperty(pattern, \"type\");\n\n  if (patternType === \"Identifier\") {\n    const name = readStringProperty(pattern, \"name\");\n    return name === void 0 ? [] : [name];\n  }\n\n  if (patternType === \"RestElement\") {\n    return collectPatternIdentifierNames(pattern[\"argument\"]);\n  }\n\n  if (patternType === \"AssignmentPattern\") {\n    return collectPatternIdentifierNames(pattern[\"left\"]);\n  }\n\n  if (patternType === \"ArrayPattern\") {\n    return (readArrayProperty(pattern, \"elements\") ?? []).flatMap((element) =>\n      collectPatternIdentifierNames(element),\n    );\n  }\n\n  if (patternType === \"ObjectPattern\") {\n    return (readArrayProperty(pattern, \"properties\") ?? []).flatMap(\n      (property) => {\n        if (readStringProperty(property, \"type\") === \"RestElement\") {\n          return collectPatternIdentifierNames(\n            asRecord(property)?.[\"argument\"],\n          );\n        }\n\n        return collectPatternIdentifierNames(asRecord(property)?.[\"value\"]);\n      },\n    );\n  }\n\n  return [];\n};\n\n/**\n * Reads one export specifier name.\n * @param specifier Export specifier candidate.\n * @returns Exported name when available.\n * @example\n * ```typescript\n * const name = getExportSpecifierName(specifier);\n * ```\n */\nconst getExportSpecifierName = (specifier: unknown): string | undefined => {\n  const candidate = asRecord(specifier);\n  const exportedName = readStringProperty(candidate?.[\"exported\"], \"name\");\n\n  if (typeof exportedName === \"string\") {\n    return exportedName;\n  }\n\n  const localName = readStringProperty(candidate?.[\"local\"], \"name\");\n\n  return typeof localName === \"string\" ? localName : void 0;\n};\n\n/**\n * Reads one local export specifier name.\n * @param specifier Export specifier candidate.\n * @returns Local specifier name when available.\n * @example\n * ```typescript\n * const name = getExportSpecifierLocalName(specifier);\n * ```\n */\nconst getExportSpecifierLocalName = (\n  specifier: unknown,\n): string | undefined => {\n  const candidate = asRecord(specifier);\n\n  return readStringProperty(candidate?.[\"local\"], \"name\");\n};\n\n/**\n * Collects top-level declaration names owned by the current module.\n * @param body Program body statements.\n * @returns Map from locally declared name to its declaration metadata.\n * @example\n * ```typescript\n * const declarations = collectLocalDeclarationNames(program.body);\n * ```\n */\nconst collectLocalDeclarationNames = (\n  body: AST.Program[\"body\"],\n): Map<string, LocalDeclaration> => {\n  const declarationNames = new Map<string, LocalDeclaration>();\n\n  for (const statement of body) {\n    const declarationCandidate =\n      statement.type === \"ExportNamedDeclaration\" &&\n      statement.declaration !== null &&\n      statement.declaration !== void 0\n        ? statement.declaration\n        : statement;\n    const declarationCandidateRecord = asRecord(declarationCandidate);\n    const declarationCandidateType = readStringProperty(\n      declarationCandidate,\n      \"type\",\n    );\n\n    if (\n      declarationCandidateRecord === void 0 ||\n      declarationCandidateType === void 0\n    ) {\n      continue;\n    }\n\n    if (\n      declarationCandidateType === \"FunctionDeclaration\" ||\n      declarationCandidateType === \"ClassDeclaration\" ||\n      declarationCandidateType === \"TSEnumDeclaration\" ||\n      declarationCandidateType === \"TSInterfaceDeclaration\" ||\n      declarationCandidateType === \"TSTypeAliasDeclaration\"\n    ) {\n      const declarationName = readStringProperty(\n        declarationCandidateRecord[\"id\"],\n        \"name\",\n      );\n\n      if (declarationName !== void 0) {\n        declarationNames.set(declarationName, {\n          kind:\n            declarationCandidateType === \"TSInterfaceDeclaration\" ||\n            declarationCandidateType === \"TSTypeAliasDeclaration\"\n              ? \"type\"\n              : \"value\",\n          node: statement,\n        });\n      }\n\n      continue;\n    }\n\n    if (declarationCandidateType !== \"VariableDeclaration\") {\n      continue;\n    }\n\n    const declarations = readArrayProperty(\n      declarationCandidateRecord,\n      \"declarations\",\n    );\n\n    if (declarations === void 0) {\n      continue;\n    }\n\n    for (const declaration of declarations) {\n      const declarationRecord = asRecord(declaration);\n\n      if (declarationRecord === void 0) {\n        continue;\n      }\n\n      for (const name of collectPatternIdentifierNames(\n        declarationRecord[\"id\"],\n      )) {\n        declarationNames.set(name, { kind: \"value\", node: statement });\n      }\n    }\n  }\n\n  return declarationNames;\n};\n\n/**\n * Collects exported elements from one program body.\n * @param body Program body statements.\n * @returns Exported elements in declaration order.\n * @example\n * ```typescript\n * const exported = collectExportedElements(program.body);\n * ```\n */\nconst collectExportedElements = (\n  body: AST.Program[\"body\"],\n): ExportedElement[] => {\n  const exportedElements: ExportedElement[] = [];\n  const localDeclarationNames = collectLocalDeclarationNames(body);\n\n  for (const statement of body) {\n    if (statement.type === \"ExportDefaultDeclaration\") {\n      exportedElements.push({\n        exportedName: \"default\",\n        exportKind: \"value\",\n        node: statement,\n      });\n      continue;\n    }\n\n    if (statement.type !== \"ExportNamedDeclaration\") {\n      continue;\n    }\n\n    if (statement.source !== null && statement.source !== void 0) {\n      continue;\n    }\n\n    if (statement.declaration !== null && statement.declaration !== void 0) {\n      const declaration = asRecord(statement.declaration);\n\n      if (readStringProperty(declaration, \"type\") === \"VariableDeclaration\") {\n        for (const variable of readArrayProperty(declaration, \"declarations\") ??\n          []) {\n          for (const name of collectPatternIdentifierNames(\n            asRecord(variable)?.[\"id\"],\n          )) {\n            exportedElements.push({\n              exportedName: name,\n              exportKind: \"value\",\n              node: statement,\n            });\n          }\n        }\n      } else {\n        const declarationName = readStringProperty(declaration?.[\"id\"], \"name\");\n        const declarationType = readStringProperty(declaration, \"type\");\n        const exportKind: ExportKind =\n          declarationType === \"TSInterfaceDeclaration\" ||\n          declarationType === \"TSTypeAliasDeclaration\"\n            ? \"type\"\n            : \"value\";\n\n        if (typeof declarationName === \"string\") {\n          exportedElements.push({\n            exportedName: declarationName,\n            exportKind,\n            node: statement,\n          });\n        }\n      }\n\n      continue;\n    }\n\n    for (const specifier of statement.specifiers) {\n      const localName = getExportSpecifierLocalName(specifier);\n      const localDeclaration =\n        localName === void 0 ? void 0 : localDeclarationNames.get(localName);\n\n      if (localDeclaration === void 0) {\n        continue;\n      }\n\n      const exportedName = getExportSpecifierName(specifier);\n\n      if (exportedName !== void 0) {\n        const statementExportKind = readStringProperty(statement, \"exportKind\");\n        const specifierExportKind = readStringProperty(specifier, \"exportKind\");\n        const isTypeOnlyExport =\n          statementExportKind === \"type\" || specifierExportKind === \"type\";\n\n        exportedElements.push({\n          exportedName,\n          exportKind: isTypeOnlyExport ? \"type\" : localDeclaration.kind,\n          node: localDeclaration.node,\n        });\n      }\n    }\n  }\n\n  return exportedElements;\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 * 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 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\n/**\n * Checks whether an identifier participates in one declaration/import/export site.\n * @param identifier Identifier node to evaluate.\n * @returns True when the identifier is declaration-only syntax.\n * @example\n * ```typescript\n * const declaration = isDeclarationOnlyIdentifier(identifier);\n * ```\n */\nconst isDeclarationOnlyIdentifier = (identifier: ts.Identifier): boolean => {\n  const parent = identifier.parent;\n\n  return (\n    ts.isImportSpecifier(parent) ||\n    ts.isImportClause(parent) ||\n    ts.isNamespaceImport(parent) ||\n    ts.isImportEqualsDeclaration(parent) ||\n    ts.isExportSpecifier(parent) ||\n    ts.isTypeAliasDeclaration(parent) ||\n    ts.isInterfaceDeclaration(parent) ||\n    ts.isTypeParameterDeclaration(parent) ||\n    (ts.isVariableDeclaration(parent) && parent.name === identifier) ||\n    (ts.isFunctionDeclaration(parent) && parent.name === identifier) ||\n    (ts.isClassDeclaration(parent) && parent.name === identifier) ||\n    (ts.isParameter(parent) && parent.name === identifier)\n  );\n};\n\n/**\n * Checks whether one identifier node appears under a type node.\n * @param identifier Candidate identifier.\n * @returns True when the identifier is inside type-only syntax.\n * @example\n * ```typescript\n * const typePosition = isTypePositionIdentifier(identifier);\n * ```\n */\nconst isTypePositionIdentifier = (identifier: ts.Identifier): boolean => {\n  const visitNode = (current: ts.Node): boolean => {\n    if (ts.isTypeQueryNode(current)) {\n      return false;\n    }\n\n    if (ts.isTypeNode(current)) {\n      return true;\n    }\n\n    if (\n      ts.isExpressionStatement(current) ||\n      ts.isCallExpression(current) ||\n      ts.isPropertyAccessExpression(current) ||\n      ts.isElementAccessExpression(current) ||\n      ts.isVariableDeclaration(current) ||\n      ts.isReturnStatement(current)\n    ) {\n      return false;\n    }\n\n    if (ts.isSourceFile(current)) {\n      return false;\n    }\n\n    return visitNode(current.parent);\n  };\n\n  return visitNode(identifier);\n};\n\n/**\n * Checks whether one identifier is one concrete usage candidate for the export kind.\n * @param identifier Identifier node.\n * @param exportKind Whether type-only or value usage is required.\n * @returns True when the identifier can satisfy usage.\n * @example\n * ```typescript\n * const concrete = isConcreteUsageIdentifier(identifier, \"value\");\n * ```\n */\nconst isConcreteUsageIdentifier = (\n  identifier: ts.Identifier,\n  exportKind: ExportKind,\n): boolean => {\n  if (isDeclarationOnlyIdentifier(identifier)) {\n    return false;\n  }\n\n  const inTypePosition = isTypePositionIdentifier(identifier);\n\n  return exportKind === \"type\" ? inTypePosition : !inTypePosition;\n};\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 candidateSymbol = 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 public API exposure usages for one exported symbol.\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 file classification.\n * @param targetSymbol Export symbol being classified.\n * @returns Public API exposure usages for the exported symbol.\n * @example\n * ```typescript\n * const usages = collectPublicApiExposureUsages(program, sourceFilename, state, repoRoot, targetSymbol);\n * ```\n */\nconst collectPublicApiExposureUsages = (\n  program: ts.Program,\n  sourceFilename: string,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  targetSymbol: ts.Symbol,\n): ExportUsage[] => {\n  const checker = program.getTypeChecker();\n  const normalizedSourceFilename = toComparableAbsolutePath(sourceFilename);\n  const normalizedRepoRoot = path.resolve(repoRoot);\n  const usages: ExportUsage[] = [];\n\n  for (const sourceFile of program.getSourceFiles()) {\n    if (sourceFile.isDeclarationFile) {\n      continue;\n    }\n\n    const publicApiFilename = path.resolve(sourceFile.fileName);\n    const normalizedPublicApiFilename =\n      toComparableAbsolutePath(publicApiFilename);\n\n    if (normalizedPublicApiFilename === normalizedSourceFilename) {\n      continue;\n    }\n\n    if (!isPublicApiFile(publicApiFilename, state, normalizedRepoRoot)) {\n      continue;\n    }\n\n    if (!sourceFileExportsSymbol(sourceFile, checker, targetSymbol)) {\n      continue;\n    }\n\n    usages.push({\n      isTestFile: isTestFile(publicApiFilename, state, normalizedRepoRoot),\n    });\n  }\n\n  return usages;\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 consumerIsTestFile = isTestFile(\n      consumerFilename,\n      state,\n      normalizedRepoRoot,\n    );\n\n    collectConcreteUsagesFromSourceFile(\n      sourceFile,\n      checker,\n      targetSymbol,\n      exportedElement,\n      consumerIsTestFile,\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 {\n  classifyExportUsage,\n  collectCrossFileUsages,\n  collectExportedElements,\n  getTypeScriptProgram,\n};\n"]}