@codeperfect/eslint-plugin 2.4.0 → 2.6.0

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

@@ -0,0 +1,187 @@
+import { collectPatternIdentifierNames, getExportSpecifierLocalName, getExportSpecifierName, } from "./no-unused-exports-pattern-utilities.js";
+import { asRecord, readArrayProperty, readStringProperty, } from "./no-unused-exports-record-utilities.js";
+/** Declaration statement types that own one named `id` property. */
+const NAMED_DECLARATION_TYPES = new Set([
+    "ClassDeclaration",
+    "FunctionDeclaration",
+    "TSEnumDeclaration",
+    "TSInterfaceDeclaration",
+    "TSTypeAliasDeclaration",
+]);
+/**
+ * Records variable declarator names as value declarations.
+ * @param declarationNames Map from declared name to declaration metadata.
+ * @param declarations Variable declarator candidates.
+ * @param statement Owning statement used for diagnostics.
+ * @example
+ * ```typescript
+ * addVariableDeclaratorNames(declarationNames, declarations, statement);
+ * ```
+ */
+const addVariableDeclaratorNames = (declarationNames, declarations, statement) => {
+    for (const declaration of declarations) {
+        const declarationRecord = asRecord(declaration);
+        if (declarationRecord === void 0) {
+            continue;
+        }
+        const patternNames = collectPatternIdentifierNames(declarationRecord["id"]);
+        for (const name of patternNames) {
+            declarationNames.set(name, { kind: "value", node: statement });
+        }
+    }
+};
+/**
+ * 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 (NAMED_DECLARATION_TYPES.has(declarationCandidateType)) {
+            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;
+        }
+        addVariableDeclaratorNames(declarationNames, declarations, statement);
+    }
+    return declarationNames;
+};
+/**
+ * Adds exported elements described by one export declaration site.
+ * @param exportedElements Mutable exported-element accumulator.
+ * @param statement Named export statement being inspected.
+ * @example
+ * ```typescript
+ * addDeclarationExportElements(exportedElements, statement);
+ * ```
+ */
+const addDeclarationExportElements = (exportedElements, statement) => {
+    const declaration = asRecord(statement.declaration);
+    if (readStringProperty(declaration, "type") === "VariableDeclaration") {
+        const variableDeclarations = readArrayProperty(declaration, "declarations");
+        if (variableDeclarations !== void 0) {
+            for (const variable of variableDeclarations) {
+                const patternNames = collectPatternIdentifierNames(asRecord(variable)?.["id"]);
+                for (const name of patternNames) {
+                    exportedElements.push({
+                        exportedName: name,
+                        exportKind: "value",
+                        node: statement,
+                    });
+                }
+            }
+        }
+        return;
+    }
+    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,
+        });
+    }
+};
+/**
+ * Adds exported elements for the specifiers of one named export statement.
+ * @param exportedElements Mutable exported-element accumulator.
+ * @param localDeclarationNames Locally declared names for specifier lookup.
+ * @param statement Named export statement being inspected.
+ * @example
+ * ```typescript
+ * addSpecifierExportElements(exportedElements, localDeclarationNames, statement);
+ * ```
+ */
+const addSpecifierExportElements = (exportedElements, localDeclarationNames, statement) => {
+    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,
+            });
+        }
+    }
+};
+/**
+ * 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) {
+            addDeclarationExportElements(exportedElements, statement);
+            continue;
+        }
+        addSpecifierExportElements(exportedElements, localDeclarationNames, statement);
+    }
+    return exportedElements;
+};
+export { collectExportedElements };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-exports-declaration-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-declaration-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport type { ExportedElement, ExportKind } from \"./types\";\n\nimport {\n  collectPatternIdentifierNames,\n  getExportSpecifierLocalName,\n  getExportSpecifierName,\n} from \"./no-unused-exports-pattern-utilities\";\nimport {\n  asRecord,\n  readArrayProperty,\n  readStringProperty,\n} from \"./no-unused-exports-record-utilities\";\n\n/** Declaration statement types that own one named `id` property. */\nconst NAMED_DECLARATION_TYPES = new Set([\n  \"ClassDeclaration\",\n  \"FunctionDeclaration\",\n  \"TSEnumDeclaration\",\n  \"TSInterfaceDeclaration\",\n  \"TSTypeAliasDeclaration\",\n]);\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 * Records variable declarator names as value declarations.\n * @param declarationNames Map from declared name to declaration metadata.\n * @param declarations Variable declarator candidates.\n * @param statement Owning statement used for diagnostics.\n * @example\n * ```typescript\n * addVariableDeclaratorNames(declarationNames, declarations, statement);\n * ```\n */\nconst addVariableDeclaratorNames = (\n  declarationNames: Map<string, LocalDeclaration>,\n  declarations: readonly unknown[],\n  statement: AST.Program[\"body\"][number],\n): void => {\n  for (const declaration of declarations) {\n    const declarationRecord = asRecord(declaration);\n\n    if (declarationRecord === void 0) {\n      continue;\n    }\n\n    const patternNames = collectPatternIdentifierNames(declarationRecord[\"id\"]);\n\n    for (const name of patternNames) {\n      declarationNames.set(name, { kind: \"value\", node: statement });\n    }\n  }\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 (NAMED_DECLARATION_TYPES.has(declarationCandidateType)) {\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    addVariableDeclaratorNames(declarationNames, declarations, statement);\n  }\n\n  return declarationNames;\n};\n\n/**\n * Adds exported elements described by one export declaration site.\n * @param exportedElements Mutable exported-element accumulator.\n * @param statement Named export statement being inspected.\n * @example\n * ```typescript\n * addDeclarationExportElements(exportedElements, statement);\n * ```\n */\nconst addDeclarationExportElements = (\n  exportedElements: ExportedElement[],\n  statement: ESTree.ExportNamedDeclaration,\n): void => {\n  const declaration = asRecord(statement.declaration);\n\n  if (readStringProperty(declaration, \"type\") === \"VariableDeclaration\") {\n    const variableDeclarations = readArrayProperty(declaration, \"declarations\");\n\n    if (variableDeclarations !== void 0) {\n      for (const variable of variableDeclarations) {\n        const patternNames = collectPatternIdentifierNames(\n          asRecord(variable)?.[\"id\"],\n        );\n\n        for (const name of patternNames) {\n          exportedElements.push({\n            exportedName: name,\n            exportKind: \"value\",\n            node: statement,\n          });\n        }\n      }\n    }\n\n    return;\n  }\n\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/**\n * Adds exported elements for the specifiers of one named export statement.\n * @param exportedElements Mutable exported-element accumulator.\n * @param localDeclarationNames Locally declared names for specifier lookup.\n * @param statement Named export statement being inspected.\n * @example\n * ```typescript\n * addSpecifierExportElements(exportedElements, localDeclarationNames, statement);\n * ```\n */\nconst addSpecifierExportElements = (\n  exportedElements: ExportedElement[],\n  localDeclarationNames: ReadonlyMap<string, LocalDeclaration>,\n  statement: ESTree.ExportNamedDeclaration,\n): void => {\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/**\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      addDeclarationExportElements(exportedElements, statement);\n\n      continue;\n    }\n\n    addSpecifierExportElements(\n      exportedElements,\n      localDeclarationNames,\n      statement,\n    );\n  }\n\n  return exportedElements;\n};\n\nexport { collectExportedElements };\n"]}

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

@@ -0,0 +1,26 @@
+import type { Rule } from "eslint";
+import * as ts from "typescript";
+import type { ExportKind } 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;
+/**
+ * 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");
+ * ```
+ */
+declare const isConcreteUsageIdentifier: (identifier: ts.Identifier, exportKind: ExportKind) => boolean;
+export { getTypeScriptProgram, isConcreteUsageIdentifier };
+//# sourceMappingURL=no-unused-exports-identifier-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-identifier-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-identifier-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,IAAI,CAAC,WAAW,KACxB,EAAE,CAAC,OAAO,GAAG,SAOf,CAAC;AAsEF;;;;;;;;;GASG;AACH,QAAA,MAAM,yBAAyB,GAC7B,YAAY,EAAE,CAAC,UAAU,EACzB,YAAY,UAAU,KACrB,OAQF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,CAAC"}

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

@@ -0,0 +1,95 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+/**
+ * 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;
+    }
+};
+/**
+ * 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 isInTypePosition = isTypePositionIdentifier(identifier);
+    return exportKind === "type" ? isInTypePosition : !isInTypePosition;
+};
+export { getTypeScriptProgram, isConcreteUsageIdentifier };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,32 @@
+/**
+ * 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);
+ * ```
+ */
+declare const collectPatternIdentifierNames: (node: unknown) => string[];
+/**
+ * Reads one export specifier name.
+ * @param specifier Export specifier candidate.
+ * @returns Exported name when available.
+ * @example
+ * ```typescript
+ * const name = getExportSpecifierName(specifier);
+ * ```
+ */
+declare const getExportSpecifierName: (specifier: unknown) => string | undefined;
+/**
+ * Reads one local export specifier name.
+ * @param specifier Export specifier candidate.
+ * @returns Local specifier name when available.
+ * @example
+ * ```typescript
+ * const name = getExportSpecifierLocalName(specifier);
+ * ```
+ */
+declare const getExportSpecifierLocalName: (specifier: unknown) => string | undefined;
+export { collectPatternIdentifierNames, getExportSpecifierLocalName, getExportSpecifierName, };
+//# sourceMappingURL=no-unused-exports-pattern-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-pattern-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-pattern-utilities.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,QAAA,MAAM,6BAA6B,GAAI,MAAM,OAAO,KAAG,MAAM,EA+C5D,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB,GAAI,WAAW,OAAO,KAAG,MAAM,GAAG,SAW7D,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,2BAA2B,GAC/B,WAAW,OAAO,KACjB,MAAM,GAAG,SAIX,CAAC;AAEF,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,sBAAsB,GACvB,CAAC"}

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,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

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"}