@codeperfect/eslint-plugin 3.1.0 → 3.2.0

package/dist/domain/architecture/no-unused-public-members/member-usage-type-utilities.js

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { carriesMember } from "./member-usage-value-utilities.js";
 /**
  * Gets the declared type of the host that owns a public member.
  * @param member Member whose host type is needed.
@@ -34,7 +35,6 @@ const hasCompatibleMemberShape = (valueType, member, checker) => {
     const observedProperty = checker.getPropertyOfType(observedType, member.memberName);
     return (hostProperty !== void 0 &&
         observedProperty !== void 0 &&
-        checker.isTypeAssignableTo(observedType, hostType) &&
         checker.isTypeAssignableTo(hostType, observedType));
 };
 /**
@@ -57,40 +57,96 @@ const getContextualPropertyType = (objectType, propertyName, location, checker)
         ? void 0
         : checker.getTypeOfSymbolAtLocation(property, location);
 };
+/**
+ * Gets the resolved parameter type for a call argument.
+ * @param call Call expression containing the argument.
+ * @param argument Argument expression to inspect.
+ * @param checker TypeScript type checker.
+ * @returns Parameter type when TypeScript resolves the call.
+ * @example
+ * ```typescript
+ * const parameterType = getCallArgumentType(call, argument, checker);
+ * ```
+ */
+const getCallArgumentType = (call, argument, checker) => {
+    const contextualType = checker.getContextualType(argument);
+    if (contextualType !== void 0) {
+        return contextualType;
+    }
+    const argumentIndex = call.arguments.indexOf(argument);
+    const signature = checker.getResolvedSignature(call);
+    const parameter = signature === void 0 ? void 0 : signature.parameters[argumentIndex];
+    return parameter === void 0
+        ? void 0
+        : checker.getTypeOfSymbolAtLocation(parameter, call);
+};
+/**
+ * Checks whether a method declaration contains only a contract.
+ * @param declaration Candidate method declaration.
+ * @returns True when the declaration has no implementation body.
+ * @example
+ * ```typescript
+ * const declarationOnly = isDeclarationOnlyMethod(declaration);
+ * ```
+ */
+const isDeclarationOnlyMethod = (declaration) => ts.isCallSignatureDeclaration(declaration) ||
+    ts.isFunctionTypeNode(declaration) ||
+    ts.isMethodSignature(declaration) ||
+    (ts.isMethodDeclaration(declaration) && declaration.body === void 0);
+/**
+ * Resolves a named property or the string-index contract accepting it.
+ * @param type Object type whose member is being forwarded.
+ * @param member Member supplying the property name and type location.
+ * @param checker TypeScript type checker.
+ * @returns Explicit property type or string-index value type.
+ * @example
+ * ```typescript
+ * const valueType = getPropertyOrIndexType(type, member, checker);
+ * ```
+ */
+const getPropertyOrIndexType = (type, member, checker) => {
+    const property = checker.getPropertyOfType(type, member.memberName);
+    return property === void 0
+        ? checker.getIndexTypeOfType(type, ts.IndexKind.String)
+        : checker.getTypeOfSymbolAtLocation(property, member.declaration);
+};
 /**
  * Checks whether a typed handoff carries a member into a compatible contract.
- * @param sourceType Type of the value being forwarded.
+ * @param sourceExpression Value being forwarded.
  * @param targetType Type expected at the receiving boundary.
  * @param member Member whose usage is being checked.
  * @param checker TypeScript type checker.
  * @returns True when the receiving contract accepts the corresponding member.
  * @example
  * ```typescript
- * const used = isMemberHandoff(sourceType, targetType, member, checker);
+ * const used = isMemberHandoff(expression, targetType, member, checker);
  * ```
  */
-const isMemberHandoff = (sourceType, targetType, member, checker) => {
-    if (sourceType === void 0 || targetType === void 0) {
+const isMemberHandoff = (sourceExpression, targetType, member, checker) => {
+    if (targetType === void 0) {
         return false;
     }
     const hostType = checker.getNonNullableType(getMemberHostType(member, checker));
-    const forwardedType = checker.getNonNullableType(sourceType);
+    const forwardedType = checker.getNonNullableType(checker.getTypeAtLocation(sourceExpression));
     const receivingType = checker.getNonNullableType(targetType);
-    const hostProperty = checker.getPropertyOfType(hostType, member.memberName);
-    const forwardedProperty = checker.getPropertyOfType(forwardedType, member.memberName);
-    const receivingProperty = checker.getPropertyOfType(receivingType, member.memberName);
-    if (hostProperty === void 0 ||
-        forwardedProperty === void 0 ||
-        receivingProperty === void 0 ||
-        !(checker.isTypeAssignableTo(forwardedType, hostType) ||
-            checker.isTypeAssignableTo(hostType, forwardedType)) ||
-        !checker.isTypeAssignableTo(hostType, receivingType)) {
+    if (receivingType.isUnion()) {
+        return receivingType.types.some((part) => isMemberHandoff(sourceExpression, part, member, checker));
+    }
+    if (checker.getPropertyOfType(receivingType, member.memberName) === void 0 &&
+        !carriesMember(sourceExpression, checker, member)) {
         return false;
     }
-    const hostPropertyType = checker.getTypeOfSymbolAtLocation(hostProperty, member.declaration);
-    const receivingPropertyType = checker.getTypeOfSymbolAtLocation(receivingProperty, member.declaration);
-    return (checker.isTypeAssignableTo(hostPropertyType, receivingPropertyType) ||
-        checker.isTypeAssignableTo(receivingPropertyType, hostPropertyType));
+    const hostPropertyType = getPropertyOrIndexType(hostType, member, checker);
+    const forwardedPropertyType = getPropertyOrIndexType(forwardedType, member, checker);
+    const receivingPropertyType = getPropertyOrIndexType(receivingType, member, checker);
+    return (hostPropertyType !== void 0 &&
+        forwardedPropertyType !== void 0 &&
+        receivingPropertyType !== void 0 &&
+        (checker.isTypeAssignableTo(forwardedType, hostType) ||
+            checker.isTypeAssignableTo(hostType, forwardedType)) &&
+        checker.isTypeAssignableTo(hostType, receivingType) &&
+        (checker.isTypeAssignableTo(hostPropertyType, receivingPropertyType) ||
+            checker.isTypeAssignableTo(receivingPropertyType, hostPropertyType)));
 };
-export { getContextualPropertyType, hasCompatibleMemberShape, isMemberHandoff };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-type-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-type-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\n/**\n * Gets the declared type of the host that owns a public member.\n * @param member Member whose host type is needed.\n * @param checker TypeScript type checker.\n * @returns Host type used for structural usage checks.\n * @example\n * ```typescript\n * const hostType = getMemberHostType(member, checker);\n * ```\n */\nconst getMemberHostType = (\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): ts.Type => {\n  const declaration = member.hostDeclaration;\n  const location = ts.isVariableDeclaration(declaration)\n    ? declaration.name\n    : declaration;\n\n  return checker.getTypeAtLocation(location);\n};\n\n/**\n * Checks whether a value type carries a structurally corresponding member.\n * @param valueType Type of the value being inspected.\n * @param member Member whose host shape is required.\n * @param checker TypeScript type checker.\n * @returns True when TypeScript relates the value and host shapes.\n * @example\n * ```typescript\n * const matches = hasCompatibleMemberShape(valueType, member, checker);\n * ```\n */\nconst hasCompatibleMemberShape = (\n  valueType: ts.Type,\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): boolean => {\n  const hostType = checker.getNonNullableType(\n    getMemberHostType(member, checker),\n  );\n  const observedType = checker.getNonNullableType(valueType);\n  const hostProperty = checker.getPropertyOfType(hostType, member.memberName);\n  const observedProperty = checker.getPropertyOfType(\n    observedType,\n    member.memberName,\n  );\n\n  return (\n    hostProperty !== void 0 &&\n    observedProperty !== void 0 &&\n    checker.isTypeAssignableTo(observedType, hostType) &&\n    checker.isTypeAssignableTo(hostType, observedType)\n  );\n};\n\n/**\n * Gets the property type supplied by an object's contextual contract.\n * @param objectType Expected shape for the object literal.\n * @param propertyName Property name in the object literal.\n * @param location Node used to resolve the property type.\n * @param checker TypeScript type checker.\n * @returns Contextual property type when one is declared.\n * @example\n * ```typescript\n * const type = getContextualPropertyType(objectType, \"docs\", node, checker);\n * ```\n */\nconst getContextualPropertyType = (\n  objectType: ts.Type | undefined,\n  propertyName: string,\n  location: ts.Node,\n  checker: ts.TypeChecker,\n): ts.Type | undefined => {\n  const property =\n    objectType === void 0\n      ? void 0\n      : checker.getPropertyOfType(objectType, propertyName);\n\n  return property === void 0\n    ? void 0\n    : checker.getTypeOfSymbolAtLocation(property, location);\n};\n\n/**\n * Checks whether a typed handoff carries a member into a compatible contract.\n * @param sourceType Type of the value being forwarded.\n * @param targetType Type expected at the receiving boundary.\n * @param member Member whose usage is being checked.\n * @param checker TypeScript type checker.\n * @returns True when the receiving contract accepts the corresponding member.\n * @example\n * ```typescript\n * const used = isMemberHandoff(sourceType, targetType, member, checker);\n * ```\n */\nconst isMemberHandoff = (\n  sourceType: ts.Type | undefined,\n  targetType: ts.Type | undefined,\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): boolean => {\n  if (sourceType === void 0 || targetType === void 0) {\n    return false;\n  }\n\n  const hostType = checker.getNonNullableType(\n    getMemberHostType(member, checker),\n  );\n  const forwardedType = checker.getNonNullableType(sourceType);\n  const receivingType = checker.getNonNullableType(targetType);\n  const hostProperty = checker.getPropertyOfType(hostType, member.memberName);\n  const forwardedProperty = checker.getPropertyOfType(\n    forwardedType,\n    member.memberName,\n  );\n  const receivingProperty = checker.getPropertyOfType(\n    receivingType,\n    member.memberName,\n  );\n\n  if (\n    hostProperty === void 0 ||\n    forwardedProperty === void 0 ||\n    receivingProperty === void 0 ||\n    !(\n      checker.isTypeAssignableTo(forwardedType, hostType) ||\n      checker.isTypeAssignableTo(hostType, forwardedType)\n    ) ||\n    !checker.isTypeAssignableTo(hostType, receivingType)\n  ) {\n    return false;\n  }\n\n  const hostPropertyType = checker.getTypeOfSymbolAtLocation(\n    hostProperty,\n    member.declaration,\n  );\n  const receivingPropertyType = checker.getTypeOfSymbolAtLocation(\n    receivingProperty,\n    member.declaration,\n  );\n\n  return (\n    checker.isTypeAssignableTo(hostPropertyType, receivingPropertyType) ||\n    checker.isTypeAssignableTo(receivingPropertyType, hostPropertyType)\n  );\n};\n\nexport { getContextualPropertyType, hasCompatibleMemberShape, isMemberHandoff };\n"]}
+export { getCallArgumentType, getContextualPropertyType, hasCompatibleMemberShape, isDeclarationOnlyMethod, isMemberHandoff, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-type-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-type-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { carriesMember } from \"./member-usage-value-utilities\";\n\n/**\n * Gets the declared type of the host that owns a public member.\n * @param member Member whose host type is needed.\n * @param checker TypeScript type checker.\n * @returns Host type used for structural usage checks.\n * @example\n * ```typescript\n * const hostType = getMemberHostType(member, checker);\n * ```\n */\nconst getMemberHostType = (\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): ts.Type => {\n  const declaration = member.hostDeclaration;\n  const location = ts.isVariableDeclaration(declaration)\n    ? declaration.name\n    : declaration;\n\n  return checker.getTypeAtLocation(location);\n};\n\n/**\n * Checks whether a value type carries a structurally corresponding member.\n * @param valueType Type of the value being inspected.\n * @param member Member whose host shape is required.\n * @param checker TypeScript type checker.\n * @returns True when TypeScript relates the value and host shapes.\n * @example\n * ```typescript\n * const matches = hasCompatibleMemberShape(valueType, member, checker);\n * ```\n */\nconst hasCompatibleMemberShape = (\n  valueType: ts.Type,\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): boolean => {\n  const hostType = checker.getNonNullableType(\n    getMemberHostType(member, checker),\n  );\n  const observedType = checker.getNonNullableType(valueType);\n  const hostProperty = checker.getPropertyOfType(hostType, member.memberName);\n  const observedProperty = checker.getPropertyOfType(\n    observedType,\n    member.memberName,\n  );\n\n  return (\n    hostProperty !== void 0 &&\n    observedProperty !== void 0 &&\n    checker.isTypeAssignableTo(hostType, observedType)\n  );\n};\n\n/**\n * Gets the property type supplied by an object's contextual contract.\n * @param objectType Expected shape for the object literal.\n * @param propertyName Property name in the object literal.\n * @param location Node used to resolve the property type.\n * @param checker TypeScript type checker.\n * @returns Contextual property type when one is declared.\n * @example\n * ```typescript\n * const type = getContextualPropertyType(objectType, \"docs\", node, checker);\n * ```\n */\nconst getContextualPropertyType = (\n  objectType: ts.Type | undefined,\n  propertyName: string,\n  location: ts.Node,\n  checker: ts.TypeChecker,\n): ts.Type | undefined => {\n  const property =\n    objectType === void 0\n      ? void 0\n      : checker.getPropertyOfType(objectType, propertyName);\n\n  return property === void 0\n    ? void 0\n    : checker.getTypeOfSymbolAtLocation(property, location);\n};\n\n/**\n * Gets the resolved parameter type for a call argument.\n * @param call Call expression containing the argument.\n * @param argument Argument expression to inspect.\n * @param checker TypeScript type checker.\n * @returns Parameter type when TypeScript resolves the call.\n * @example\n * ```typescript\n * const parameterType = getCallArgumentType(call, argument, checker);\n * ```\n */\nconst getCallArgumentType = (\n  call: ts.CallExpression,\n  argument: ts.Expression,\n  checker: ts.TypeChecker,\n): ts.Type | undefined => {\n  const contextualType = checker.getContextualType(argument);\n\n  if (contextualType !== void 0) {\n    return contextualType;\n  }\n\n  const argumentIndex = call.arguments.indexOf(argument);\n  const signature = checker.getResolvedSignature(call);\n  const parameter =\n    signature === void 0 ? void 0 : signature.parameters[argumentIndex];\n\n  return parameter === void 0\n    ? void 0\n    : checker.getTypeOfSymbolAtLocation(parameter, call);\n};\n\n/**\n * Checks whether a method declaration contains only a contract.\n * @param declaration Candidate method declaration.\n * @returns True when the declaration has no implementation body.\n * @example\n * ```typescript\n * const declarationOnly = isDeclarationOnlyMethod(declaration);\n * ```\n */\nconst isDeclarationOnlyMethod = (declaration: ts.Node): boolean =>\n  ts.isCallSignatureDeclaration(declaration) ||\n  ts.isFunctionTypeNode(declaration) ||\n  ts.isMethodSignature(declaration) ||\n  (ts.isMethodDeclaration(declaration) && declaration.body === void 0);\n\n/**\n * Resolves a named property or the string-index contract accepting it.\n * @param type Object type whose member is being forwarded.\n * @param member Member supplying the property name and type location.\n * @param checker TypeScript type checker.\n * @returns Explicit property type or string-index value type.\n * @example\n * ```typescript\n * const valueType = getPropertyOrIndexType(type, member, checker);\n * ```\n */\nconst getPropertyOrIndexType = (\n  type: ts.Type,\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): ts.Type | undefined => {\n  const property = checker.getPropertyOfType(type, member.memberName);\n\n  return property === void 0\n    ? checker.getIndexTypeOfType(type, ts.IndexKind.String)\n    : checker.getTypeOfSymbolAtLocation(property, member.declaration);\n};\n\n/**\n * Checks whether a typed handoff carries a member into a compatible contract.\n * @param sourceExpression Value being forwarded.\n * @param targetType Type expected at the receiving boundary.\n * @param member Member whose usage is being checked.\n * @param checker TypeScript type checker.\n * @returns True when the receiving contract accepts the corresponding member.\n * @example\n * ```typescript\n * const used = isMemberHandoff(expression, targetType, member, checker);\n * ```\n */\nconst isMemberHandoff = (\n  sourceExpression: ts.Expression,\n  targetType: ts.Type | undefined,\n  member: PublicMember,\n  checker: ts.TypeChecker,\n): boolean => {\n  if (targetType === void 0) {\n    return false;\n  }\n\n  const hostType = checker.getNonNullableType(\n    getMemberHostType(member, checker),\n  );\n  const forwardedType = checker.getNonNullableType(\n    checker.getTypeAtLocation(sourceExpression),\n  );\n  const receivingType = checker.getNonNullableType(targetType);\n\n  if (receivingType.isUnion()) {\n    return receivingType.types.some((part) =>\n      isMemberHandoff(sourceExpression, part, member, checker),\n    );\n  }\n\n  if (\n    checker.getPropertyOfType(receivingType, member.memberName) === void 0 &&\n    !carriesMember(sourceExpression, checker, member)\n  ) {\n    return false;\n  }\n\n  const hostPropertyType = getPropertyOrIndexType(hostType, member, checker);\n  const forwardedPropertyType = getPropertyOrIndexType(\n    forwardedType,\n    member,\n    checker,\n  );\n  const receivingPropertyType = getPropertyOrIndexType(\n    receivingType,\n    member,\n    checker,\n  );\n\n  return (\n    hostPropertyType !== void 0 &&\n    forwardedPropertyType !== void 0 &&\n    receivingPropertyType !== void 0 &&\n    (checker.isTypeAssignableTo(forwardedType, hostType) ||\n      checker.isTypeAssignableTo(hostType, forwardedType)) &&\n    checker.isTypeAssignableTo(hostType, receivingType) &&\n    (checker.isTypeAssignableTo(hostPropertyType, receivingPropertyType) ||\n      checker.isTypeAssignableTo(receivingPropertyType, hostPropertyType))\n  );\n};\n\nexport {\n  getCallArgumentType,\n  getContextualPropertyType,\n  hasCompatibleMemberShape,\n  isDeclarationOnlyMethod,\n  isMemberHandoff,\n};\n"]}

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.d.ts

@@ -1,18 +1,22 @@
 import * as ts from "typescript";
 import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
 import type { PublicMember } from "./member-declaration-utilities.js";
+/** Framework-specific member usage detector supplied by an opt-in adapter. */
+type MemberUsageAdapter = (sourceFile: ts.SourceFile, checker: ts.TypeChecker, member: PublicMember) => boolean;
 /**
  * Checks whether a member has a concrete reference in production TypeScript.
  * @param program TypeScript project program.
  * @param state Normalized public API and test patterns.
  * @param repoRoot Root directory used for glob matching.
  * @param member Member whose production usage is being checked.
+ * @param usageAdapters Optional framework-specific usage detectors.
  * @returns True when production code references the member.
  * @example
  * ```typescript
  * const used = hasProductionUsage(program, state, repoRoot, member);
  * ```
  */
-declare const hasProductionUsage: (program: ts.Program, state: NoUnusedExportsState, repoRoot: string, member: PublicMember) => boolean;
+declare const hasProductionUsage: (program: ts.Program, state: NoUnusedExportsState, repoRoot: string, member: PublicMember, usageAdapters?: readonly MemberUsageAdapter[]) => boolean;
 export { hasProductionUsage };
+export type { MemberUsageAdapter };
 //# sourceMappingURL=member-usage-utilities.d.ts.map

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"member-usage-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAyFnE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,kBAAkB,GACtB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,QAAQ,YAAY,KACnB,OAuEF,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"member-usage-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAsBnE,8EAA8E;AAC9E,KAAK,kBAAkB,GAAG,CACxB,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,YAAY,KACjB,OAAO,CAAC;AA0Eb;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,kBAAkB,GACtB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,QAAQ,YAAY,EACpB,gBAAe,SAAS,kBAAkB,EAAO,KAChD,OA8EF,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAC9B,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.js

@@ -4,7 +4,9 @@ import { isTestFile } from "../no-unused-exports/no-unused-exports-options.js";
 import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
 import { collectHeritageMemberSymbols } from "./member-contract-utilities.js";
 import { isCallArgumentMember, isObjectContractHandoff, } from "./member-usage-handoff-utilities.js";
+import { isLocalCallArgumentTransmitted } from "./member-usage-local-flow-utilities.js";
 import { isComputedMemberRead, isStructuralPropertyRead, } from "./member-usage-reference-utilities.js";
+import { isLocalCallArgumentSerialized, isWholeObjectRead, } from "./member-usage-serialization-utilities.js";
 /**
  * Resolves destructured member names or direct reference symbols.
  * @param node Candidate reference node.
@@ -70,13 +72,14 @@ const isDeclarationName = (node) => {
  * @param state Normalized public API and test patterns.
  * @param repoRoot Root directory used for glob matching.
  * @param member Member whose production usage is being checked.
+ * @param usageAdapters Optional framework-specific usage detectors.
  * @returns True when production code references the member.
  * @example
  * ```typescript
  * const used = hasProductionUsage(program, state, repoRoot, member);
  * ```
  */
-const hasProductionUsage = (program, state, repoRoot, member) => {
+const hasProductionUsage = (program, state, repoRoot, member, usageAdapters = []) => {
     const checker = program.getTypeChecker();
     const relatedSymbols = [
         resolveCanonicalSymbol(member.memberSymbol, checker),
@@ -100,6 +103,9 @@ const hasProductionUsage = (program, state, repoRoot, member) => {
             isTestFile(filename, state, normalizedRoot)) {
             continue;
         }
+        if (usageAdapters.some((adapter) => adapter(sourceFile, checker, member))) {
+            return true;
+        }
         const findUsageSymbol = (node) => {
             if ((ts.isIdentifier(node) || ts.isStringLiteralLike(node)) &&
                 !isDeclarationName(node)) {
@@ -113,6 +119,9 @@ const hasProductionUsage = (program, state, repoRoot, member) => {
                 }
             }
             return isComputedMemberRead(node, checker, member, relatedSymbols) ||
+                isWholeObjectRead(node, checker, member, program) ||
+                isLocalCallArgumentSerialized(node, checker, member, program) ||
+                isLocalCallArgumentTransmitted(node, checker, member) ||
                 isCallArgumentMember(node, checker, member) ||
                 isObjectContractHandoff(node, checker, member)
                 ? member.memberSymbol
@@ -125,4 +134,4 @@ const hasProductionUsage = (program, state, repoRoot, member) => {
     return false;
 };
 export { hasProductionUsage };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type { NoUnusedExportsState } from \"../no-unused-exports/types\";\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { isTestFile } from \"../no-unused-exports/no-unused-exports-options\";\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\nimport { collectHeritageMemberSymbols } from \"./member-contract-utilities\";\nimport {\n  isCallArgumentMember,\n  isObjectContractHandoff,\n} from \"./member-usage-handoff-utilities\";\nimport {\n  isComputedMemberRead,\n  isStructuralPropertyRead,\n} from \"./member-usage-reference-utilities\";\n\n/**\n * Resolves destructured member names or direct reference symbols.\n * @param node Candidate reference node.\n * @param checker TypeScript type checker.\n * @returns Referenced member symbol when available.\n * @example\n * ```typescript\n * const symbol = getUsageSymbol(propertyIdentifier, checker);\n * ```\n */\nconst getUsageSymbol = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n): ts.Symbol | undefined => {\n  const parent = node.parent;\n\n  if (\n    ts.isIdentifier(node) &&\n    ts.isBindingElement(parent) &&\n    parent.name === node &&\n    parent.propertyName === void 0 &&\n    ts.isObjectBindingPattern(parent.parent)\n  ) {\n    const owner = parent.parent.parent;\n    const sourceType = ts.isVariableDeclaration(owner)\n      ? owner.initializer === void 0\n        ? void 0\n        : checker.getTypeAtLocation(owner.initializer)\n      : ts.isParameter(owner)\n        ? checker.getTypeAtLocation(owner)\n        : void 0;\n\n    return sourceType === void 0\n      ? checker.getSymbolAtLocation(node)\n      : checker.getPropertyOfType(sourceType, node.text);\n  }\n\n  return checker.getSymbolAtLocation(node);\n};\n\n/**\n * Identifies declaration names that are not member references.\n * @param node Candidate reference node.\n * @returns True when the node is only declaring a name.\n * @example\n * ```typescript\n * const declarationOnly = isDeclarationName(propertyName);\n * ```\n */\nconst isDeclarationName = (node: ts.Node): boolean => {\n  const parent = node.parent;\n\n  return (\n    ((ts.isPropertyDeclaration(parent) ||\n      ts.isMethodDeclaration(parent) ||\n      ts.isGetAccessorDeclaration(parent) ||\n      ts.isSetAccessorDeclaration(parent) ||\n      ts.isPropertySignature(parent) ||\n      ts.isMethodSignature(parent) ||\n      ts.isPropertyAssignment(parent) ||\n      ts.isShorthandPropertyAssignment(parent)) &&\n      parent.name === node) ||\n    (ts.isVariableDeclaration(parent) && parent.name === node) ||\n    ((ts.isClassDeclaration(parent) ||\n      ts.isInterfaceDeclaration(parent) ||\n      ts.isTypeAliasDeclaration(parent) ||\n      ts.isFunctionDeclaration(parent)) &&\n      parent.name === node) ||\n    (ts.isParameter(parent) && parent.name === node)\n  );\n};\n\n/**\n * Checks whether a member has a concrete reference in production TypeScript.\n * @param program TypeScript project program.\n * @param state Normalized public API and test patterns.\n * @param repoRoot Root directory used for glob matching.\n * @param member Member whose production usage is being checked.\n * @returns True when production code references the member.\n * @example\n * ```typescript\n * const used = hasProductionUsage(program, state, repoRoot, member);\n * ```\n */\nconst hasProductionUsage = (\n  program: ts.Program,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  member: PublicMember,\n): boolean => {\n  const checker = program.getTypeChecker();\n  const relatedSymbols = [\n    resolveCanonicalSymbol(member.memberSymbol, checker),\n    ...collectHeritageMemberSymbols(program, checker, member).map((symbol) =>\n      resolveCanonicalSymbol(symbol, checker),\n    ),\n  ];\n  const variableDeclaration = ts.isVariableDeclaration(member.hostDeclaration)\n    ? member.hostDeclaration\n    : void 0;\n\n  if (variableDeclaration !== void 0) {\n    const declaredType = checker.getTypeAtLocation(variableDeclaration.name);\n    const declaredMember = checker.getPropertyOfType(\n      declaredType,\n      member.memberName,\n    );\n\n    if (\n      declaredMember !== void 0 &&\n      relatedSymbols.every((symbol) => !isSameSymbol(symbol, declaredMember))\n    ) {\n      relatedSymbols.push(resolveCanonicalSymbol(declaredMember, checker));\n    }\n  }\n\n  const normalizedRoot = path.resolve(repoRoot);\n\n  for (const sourceFile of program.getSourceFiles()) {\n    const filename = path.resolve(sourceFile.fileName);\n\n    if (\n      sourceFile.isDeclarationFile ||\n      isTestFile(filename, state, normalizedRoot)\n    ) {\n      continue;\n    }\n\n    const findUsageSymbol = (node: ts.Node): ts.Symbol | undefined => {\n      if (\n        (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) &&\n        !isDeclarationName(node)\n      ) {\n        const candidate = getUsageSymbol(node, checker);\n\n        if (\n          candidate !== void 0 &&\n          relatedSymbols.some((symbol) => isSameSymbol(symbol, candidate))\n        ) {\n          return candidate;\n        }\n\n        if (isStructuralPropertyRead(node, checker, member)) {\n          return member.memberSymbol;\n        }\n      }\n\n      return isComputedMemberRead(node, checker, member, relatedSymbols) ||\n        isCallArgumentMember(node, checker, member) ||\n        isObjectContractHandoff(node, checker, member)\n        ? member.memberSymbol\n        : ts.forEachChild(node, findUsageSymbol);\n    };\n\n    if (findUsageSymbol(sourceFile) !== void 0) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nexport { hasProductionUsage };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type { NoUnusedExportsState } from \"../no-unused-exports/types\";\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { isTestFile } from \"../no-unused-exports/no-unused-exports-options\";\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\nimport { collectHeritageMemberSymbols } from \"./member-contract-utilities\";\nimport {\n  isCallArgumentMember,\n  isObjectContractHandoff,\n} from \"./member-usage-handoff-utilities\";\nimport { isLocalCallArgumentTransmitted } from \"./member-usage-local-flow-utilities\";\nimport {\n  isComputedMemberRead,\n  isStructuralPropertyRead,\n} from \"./member-usage-reference-utilities\";\nimport {\n  isLocalCallArgumentSerialized,\n  isWholeObjectRead,\n} from \"./member-usage-serialization-utilities\";\n\n/** Framework-specific member usage detector supplied by an opt-in adapter. */\ntype MemberUsageAdapter = (\n  sourceFile: ts.SourceFile,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n) => boolean;\n\n/**\n * Resolves destructured member names or direct reference symbols.\n * @param node Candidate reference node.\n * @param checker TypeScript type checker.\n * @returns Referenced member symbol when available.\n * @example\n * ```typescript\n * const symbol = getUsageSymbol(propertyIdentifier, checker);\n * ```\n */\nconst getUsageSymbol = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n): ts.Symbol | undefined => {\n  const parent = node.parent;\n\n  if (\n    ts.isIdentifier(node) &&\n    ts.isBindingElement(parent) &&\n    parent.name === node &&\n    parent.propertyName === void 0 &&\n    ts.isObjectBindingPattern(parent.parent)\n  ) {\n    const owner = parent.parent.parent;\n    const sourceType = ts.isVariableDeclaration(owner)\n      ? owner.initializer === void 0\n        ? void 0\n        : checker.getTypeAtLocation(owner.initializer)\n      : ts.isParameter(owner)\n        ? checker.getTypeAtLocation(owner)\n        : void 0;\n\n    return sourceType === void 0\n      ? checker.getSymbolAtLocation(node)\n      : checker.getPropertyOfType(sourceType, node.text);\n  }\n\n  return checker.getSymbolAtLocation(node);\n};\n\n/**\n * Identifies declaration names that are not member references.\n * @param node Candidate reference node.\n * @returns True when the node is only declaring a name.\n * @example\n * ```typescript\n * const declarationOnly = isDeclarationName(propertyName);\n * ```\n */\nconst isDeclarationName = (node: ts.Node): boolean => {\n  const parent = node.parent;\n\n  return (\n    ((ts.isPropertyDeclaration(parent) ||\n      ts.isMethodDeclaration(parent) ||\n      ts.isGetAccessorDeclaration(parent) ||\n      ts.isSetAccessorDeclaration(parent) ||\n      ts.isPropertySignature(parent) ||\n      ts.isMethodSignature(parent) ||\n      ts.isPropertyAssignment(parent) ||\n      ts.isShorthandPropertyAssignment(parent)) &&\n      parent.name === node) ||\n    (ts.isVariableDeclaration(parent) && parent.name === node) ||\n    ((ts.isClassDeclaration(parent) ||\n      ts.isInterfaceDeclaration(parent) ||\n      ts.isTypeAliasDeclaration(parent) ||\n      ts.isFunctionDeclaration(parent)) &&\n      parent.name === node) ||\n    (ts.isParameter(parent) && parent.name === node)\n  );\n};\n\n/**\n * Checks whether a member has a concrete reference in production TypeScript.\n * @param program TypeScript project program.\n * @param state Normalized public API and test patterns.\n * @param repoRoot Root directory used for glob matching.\n * @param member Member whose production usage is being checked.\n * @param usageAdapters Optional framework-specific usage detectors.\n * @returns True when production code references the member.\n * @example\n * ```typescript\n * const used = hasProductionUsage(program, state, repoRoot, member);\n * ```\n */\nconst hasProductionUsage = (\n  program: ts.Program,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  member: PublicMember,\n  usageAdapters: readonly MemberUsageAdapter[] = [],\n): boolean => {\n  const checker = program.getTypeChecker();\n  const relatedSymbols = [\n    resolveCanonicalSymbol(member.memberSymbol, checker),\n    ...collectHeritageMemberSymbols(program, checker, member).map((symbol) =>\n      resolveCanonicalSymbol(symbol, checker),\n    ),\n  ];\n  const variableDeclaration = ts.isVariableDeclaration(member.hostDeclaration)\n    ? member.hostDeclaration\n    : void 0;\n\n  if (variableDeclaration !== void 0) {\n    const declaredType = checker.getTypeAtLocation(variableDeclaration.name);\n    const declaredMember = checker.getPropertyOfType(\n      declaredType,\n      member.memberName,\n    );\n\n    if (\n      declaredMember !== void 0 &&\n      relatedSymbols.every((symbol) => !isSameSymbol(symbol, declaredMember))\n    ) {\n      relatedSymbols.push(resolveCanonicalSymbol(declaredMember, checker));\n    }\n  }\n\n  const normalizedRoot = path.resolve(repoRoot);\n\n  for (const sourceFile of program.getSourceFiles()) {\n    const filename = path.resolve(sourceFile.fileName);\n\n    if (\n      sourceFile.isDeclarationFile ||\n      isTestFile(filename, state, normalizedRoot)\n    ) {\n      continue;\n    }\n\n    if (usageAdapters.some((adapter) => adapter(sourceFile, checker, member))) {\n      return true;\n    }\n\n    const findUsageSymbol = (node: ts.Node): ts.Symbol | undefined => {\n      if (\n        (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) &&\n        !isDeclarationName(node)\n      ) {\n        const candidate = getUsageSymbol(node, checker);\n\n        if (\n          candidate !== void 0 &&\n          relatedSymbols.some((symbol) => isSameSymbol(symbol, candidate))\n        ) {\n          return candidate;\n        }\n\n        if (isStructuralPropertyRead(node, checker, member)) {\n          return member.memberSymbol;\n        }\n      }\n\n      return isComputedMemberRead(node, checker, member, relatedSymbols) ||\n        isWholeObjectRead(node, checker, member, program) ||\n        isLocalCallArgumentSerialized(node, checker, member, program) ||\n        isLocalCallArgumentTransmitted(node, checker, member) ||\n        isCallArgumentMember(node, checker, member) ||\n        isObjectContractHandoff(node, checker, member)\n        ? member.memberSymbol\n        : ts.forEachChild(node, findUsageSymbol);\n    };\n\n    if (findUsageSymbol(sourceFile) !== void 0) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nexport { hasProductionUsage };\nexport type { MemberUsageAdapter };\n"]}

package/dist/domain/architecture/no-unused-public-members/member-usage-value-utilities.d.ts

@@ -0,0 +1,43 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether an expression carries the member's declaration.
+ * @param expression Value being copied or serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be present.
+ * @param visitedExpressions Expressions already inspected across local return paths.
+ * @returns True when the expression carries this member rather than an unrelated matching shape.
+ * @example
+ * ```typescript
+ * const matches = carriesMember(expression, checker, member);
+ * ```
+ */
+declare const carriesMember: (expression: ts.Expression, checker: ts.TypeChecker, member: PublicMember, visitedExpressions?: Set<ts.Expression>) => boolean;
+/**
+ * Checks serialized property types without following method signatures.
+ * @param type Type whose enumerable data may be serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be reachable.
+ * @param visitedTypes Types already searched.
+ * @param depth Remaining nested data depth.
+ * @returns Whether the serialized data contains the member declaration.
+ * @example
+ * ```typescript
+ * const used = containsSerializedMember(type, checker, member, new Set(), 5);
+ * ```
+ */
+declare const containsSerializedMember: (type: ts.Type, checker: ts.TypeChecker, member: PublicMember, visitedTypes: Set<ts.Type>, depth: number) => boolean;
+/**
+ * Checks whether an expression contains a value carrying the member.
+ * @param expression Value expression to inspect.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being searched for.
+ * @returns True when the expression contains the member or its host value.
+ * @example
+ * ```typescript
+ * const carries = expressionCarriesMemberValue(value, checker, member);
+ * ```
+ */
+declare const expressionCarriesMemberValue: (expression: ts.Expression, checker: ts.TypeChecker, member: PublicMember) => boolean;
+export { carriesMember, containsSerializedMember, expressionCarriesMemberValue, };
+//# sourceMappingURL=member-usage-value-utilities.d.ts.map

package/dist/domain/architecture/no-unused-public-members/member-usage-value-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-value-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-value-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAOnE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,aAAa,GACjB,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,EACpB,qBAAoB,GAAG,CAAC,EAAE,CAAC,UAAU,CAAa,KACjD,OAiEF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,wBAAwB,GAC5B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,EACpB,cAAc,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAC1B,OAAO,MAAM,KACZ,OA8CF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,4BAA4B,GAChC,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,KACnB,OAmCF,CAAC;AAEF,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,4BAA4B,GAC7B,CAAC"}

package/dist/domain/architecture/no-unused-public-members/member-usage-value-utilities.js

@@ -0,0 +1,126 @@
+import * as ts from "typescript";
+import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+/**
+ * Checks whether an expression carries the member's declaration.
+ * @param expression Value being copied or serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be present.
+ * @param visitedExpressions Expressions already inspected across local return paths.
+ * @returns True when the expression carries this member rather than an unrelated matching shape.
+ * @example
+ * ```typescript
+ * const matches = carriesMember(expression, checker, member);
+ * ```
+ */
+const carriesMember = (expression, checker, member, visitedExpressions = new Set()) => {
+    if (visitedExpressions.has(expression)) {
+        return false;
+    }
+    visitedExpressions.add(expression);
+    const expressionSymbol = ts.isShorthandPropertyAssignment(expression.parent)
+        ? checker.getShorthandAssignmentValueSymbol(expression.parent)
+        : checker.getSymbolAtLocation(expression);
+    if (ts.isVariableDeclaration(member.hostDeclaration) &&
+        member.hostSymbol !== void 0 &&
+        expressionSymbol !== void 0 &&
+        isSameSymbol(resolveCanonicalSymbol(expressionSymbol, checker), resolveCanonicalSymbol(member.hostSymbol, checker))) {
+        return true;
+    }
+    const property = checker.getPropertyOfType(checker.getNonNullableType(checker.getTypeAtLocation(expression)), member.memberName);
+    const declaredProperty = checker.getPropertyOfType(checker.getTypeAtLocation(member.hostDeclaration), member.memberName);
+    if (property !== void 0 &&
+        (isSameSymbol(property, member.memberSymbol) ||
+            (declaredProperty !== void 0 && isSameSymbol(property, declaredProperty)))) {
+        return true;
+    }
+    if (!ts.isCallExpression(expression)) {
+        return false;
+    }
+    const declaration = checker
+        .getResolvedSignature(expression)
+        ?.getDeclaration();
+    const body = declaration !== void 0 && "body" in declaration ? declaration.body : void 0;
+    if (body === void 0) {
+        return false;
+    }
+    if (!ts.isBlock(body)) {
+        return carriesMember(body, checker, member, visitedExpressions);
+    }
+    const findReturnedMember = (node) => {
+        if (ts.isFunctionLike(node)) {
+            return false;
+        }
+        return ts.isReturnStatement(node)
+            ? node.expression !== void 0 &&
+                carriesMember(node.expression, checker, member, visitedExpressions)
+            : ts.forEachChild(node, findReturnedMember) === true;
+    };
+    return findReturnedMember(body);
+};
+/**
+ * Checks serialized property types without following method signatures.
+ * @param type Type whose enumerable data may be serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be reachable.
+ * @param visitedTypes Types already searched.
+ * @param depth Remaining nested data depth.
+ * @returns Whether the serialized data contains the member declaration.
+ * @example
+ * ```typescript
+ * const used = containsSerializedMember(type, checker, member, new Set(), 5);
+ * ```
+ */
+const containsSerializedMember = (type, checker, member, visitedTypes, depth) => {
+    if (depth < 0 || visitedTypes.has(type)) {
+        return false;
+    }
+    visitedTypes.add(type);
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((part) => containsSerializedMember(part, checker, member, visitedTypes, depth));
+    }
+    if ((type.flags & ts.TypeFlags.Object) === 0) {
+        return false;
+    }
+    const property = checker.getPropertyOfType(type, member.memberName);
+    if (property !== void 0 && isSameSymbol(property, member.memberSymbol)) {
+        return true;
+    }
+    const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+    return elementType === void 0
+        ? checker
+            .getPropertiesOfType(type)
+            .some((nestedProperty) => (nestedProperty.flags & ts.SymbolFlags.Method) === 0 &&
+            containsSerializedMember(checker.getTypeOfSymbolAtLocation(nestedProperty, member.declaration), checker, member, visitedTypes, depth - 1))
+        : containsSerializedMember(elementType, checker, member, visitedTypes, depth - 1);
+};
+/**
+ * Checks whether an expression contains a value carrying the member.
+ * @param expression Value expression to inspect.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being searched for.
+ * @returns True when the expression contains the member or its host value.
+ * @example
+ * ```typescript
+ * const carries = expressionCarriesMemberValue(value, checker, member);
+ * ```
+ */
+const expressionCarriesMemberValue = (expression, checker, member) => {
+    if (carriesMember(expression, checker, member) ||
+        containsSerializedMember(checker.getTypeAtLocation(expression), checker, member, new Set(), 5)) {
+        return true;
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        return expression.properties.some((property) => {
+            return ts.isSpreadAssignment(property)
+                ? expressionCarriesMemberValue(property.expression, checker, member)
+                : (ts.isPropertyAssignment(property) &&
+                    expressionCarriesMemberValue(property.initializer, checker, member)) ||
+                    (ts.isShorthandPropertyAssignment(property) &&
+                        expressionCarriesMemberValue(property.name, checker, member));
+        });
+    }
+    return (ts.isArrayLiteralExpression(expression) &&
+        expression.elements.some((element) => expressionCarriesMemberValue(element, checker, member)));
+};
+export { carriesMember, containsSerializedMember, expressionCarriesMemberValue, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-value-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-value-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\n\n/**\n * Checks whether an expression carries the member's declaration.\n * @param expression Value being copied or serialized.\n * @param checker TypeScript type checker.\n * @param member Member whose declaration must be present.\n * @param visitedExpressions Expressions already inspected across local return paths.\n * @returns True when the expression carries this member rather than an unrelated matching shape.\n * @example\n * ```typescript\n * const matches = carriesMember(expression, checker, member);\n * ```\n */\nconst carriesMember = (\n  expression: ts.Expression,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  visitedExpressions: Set<ts.Expression> = new Set(),\n): boolean => {\n  if (visitedExpressions.has(expression)) {\n    return false;\n  }\n  visitedExpressions.add(expression);\n\n  const expressionSymbol = ts.isShorthandPropertyAssignment(expression.parent)\n    ? checker.getShorthandAssignmentValueSymbol(expression.parent)\n    : checker.getSymbolAtLocation(expression);\n  if (\n    ts.isVariableDeclaration(member.hostDeclaration) &&\n    member.hostSymbol !== void 0 &&\n    expressionSymbol !== void 0 &&\n    isSameSymbol(\n      resolveCanonicalSymbol(expressionSymbol, checker),\n      resolveCanonicalSymbol(member.hostSymbol, checker),\n    )\n  ) {\n    return true;\n  }\n\n  const property = checker.getPropertyOfType(\n    checker.getNonNullableType(checker.getTypeAtLocation(expression)),\n    member.memberName,\n  );\n  const declaredProperty = checker.getPropertyOfType(\n    checker.getTypeAtLocation(member.hostDeclaration),\n    member.memberName,\n  );\n\n  if (\n    property !== void 0 &&\n    (isSameSymbol(property, member.memberSymbol) ||\n      (declaredProperty !== void 0 && isSameSymbol(property, declaredProperty)))\n  ) {\n    return true;\n  }\n\n  if (!ts.isCallExpression(expression)) {\n    return false;\n  }\n\n  const declaration = checker\n    .getResolvedSignature(expression)\n    ?.getDeclaration();\n  const body =\n    declaration !== void 0 && \"body\" in declaration ? declaration.body : void 0;\n  if (body === void 0) {\n    return false;\n  }\n  if (!ts.isBlock(body)) {\n    return carriesMember(body, checker, member, visitedExpressions);\n  }\n\n  const findReturnedMember = (node: ts.Node): boolean => {\n    if (ts.isFunctionLike(node)) {\n      return false;\n    }\n    return ts.isReturnStatement(node)\n      ? node.expression !== void 0 &&\n          carriesMember(node.expression, checker, member, visitedExpressions)\n      : ts.forEachChild(node, findReturnedMember) === true;\n  };\n\n  return findReturnedMember(body);\n};\n\n/**\n * Checks serialized property types without following method signatures.\n * @param type Type whose enumerable data may be serialized.\n * @param checker TypeScript type checker.\n * @param member Member whose declaration must be reachable.\n * @param visitedTypes Types already searched.\n * @param depth Remaining nested data depth.\n * @returns Whether the serialized data contains the member declaration.\n * @example\n * ```typescript\n * const used = containsSerializedMember(type, checker, member, new Set(), 5);\n * ```\n */\nconst containsSerializedMember = (\n  type: ts.Type,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  visitedTypes: Set<ts.Type>,\n  depth: number,\n): boolean => {\n  if (depth < 0 || visitedTypes.has(type)) {\n    return false;\n  }\n  visitedTypes.add(type);\n\n  if (type.isUnionOrIntersection()) {\n    return type.types.some((part) =>\n      containsSerializedMember(part, checker, member, visitedTypes, depth),\n    );\n  }\n\n  if ((type.flags & ts.TypeFlags.Object) === 0) {\n    return false;\n  }\n\n  const property = checker.getPropertyOfType(type, member.memberName);\n  if (property !== void 0 && isSameSymbol(property, member.memberSymbol)) {\n    return true;\n  }\n\n  const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);\n  return elementType === void 0\n    ? checker\n        .getPropertiesOfType(type)\n        .some(\n          (nestedProperty) =>\n            (nestedProperty.flags & ts.SymbolFlags.Method) === 0 &&\n            containsSerializedMember(\n              checker.getTypeOfSymbolAtLocation(\n                nestedProperty,\n                member.declaration,\n              ),\n              checker,\n              member,\n              visitedTypes,\n              depth - 1,\n            ),\n        )\n    : containsSerializedMember(\n        elementType,\n        checker,\n        member,\n        visitedTypes,\n        depth - 1,\n      );\n};\n\n/**\n * Checks whether an expression contains a value carrying the member.\n * @param expression Value expression to inspect.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being searched for.\n * @returns True when the expression contains the member or its host value.\n * @example\n * ```typescript\n * const carries = expressionCarriesMemberValue(value, checker, member);\n * ```\n */\nconst expressionCarriesMemberValue = (\n  expression: ts.Expression,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    carriesMember(expression, checker, member) ||\n    containsSerializedMember(\n      checker.getTypeAtLocation(expression),\n      checker,\n      member,\n      new Set(),\n      5,\n    )\n  ) {\n    return true;\n  }\n\n  if (ts.isObjectLiteralExpression(expression)) {\n    return expression.properties.some((property) => {\n      return ts.isSpreadAssignment(property)\n        ? expressionCarriesMemberValue(property.expression, checker, member)\n        : (ts.isPropertyAssignment(property) &&\n            expressionCarriesMemberValue(\n              property.initializer,\n              checker,\n              member,\n            )) ||\n            (ts.isShorthandPropertyAssignment(property) &&\n              expressionCarriesMemberValue(property.name, checker, member));\n    });\n  }\n\n  return (\n    ts.isArrayLiteralExpression(expression) &&\n    expression.elements.some((element) =>\n      expressionCarriesMemberValue(element, checker, member),\n    )\n  );\n};\n\nexport {\n  carriesMember,\n  containsSerializedMember,\n  expressionCarriesMemberValue,\n};\n"]}

package/dist/domain/architecture/no-unused-public-members/member-utilities.d.ts

@@ -1,6 +1,7 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
+import type { MemberUsageAdapter } from "./member-usage-utilities.js";
 type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
 /**
  * Collects unused direct public members from a linted source file.
@@ -9,13 +10,14 @@ type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
  * @param state Normalized public API and test patterns.
  * @param repoRoot Root directory used for glob matching.
  * @param parserServices TypeScript and ESTree node maps.
+ * @param usageAdapters Adapters that recognize usage outside TypeScript source.
  * @returns Members outside the public API with no production use.
  * @example
  * ```typescript
  * const unused = collectUnusedPublicMembers(sourceFile, program, state, repoRoot, services);
  * ```
  */
-declare const collectUnusedPublicMembers: (sourceFile: ts.SourceFile, program: ts.Program, state: NoUnusedExportsState, repoRoot: string, parserServices: ParserServices) => import("./member-declaration-utilities.js").PublicMember[];
+declare const collectUnusedPublicMembers: (sourceFile: ts.SourceFile, program: ts.Program, state: NoUnusedExportsState, repoRoot: string, parserServices: ParserServices, usageAdapters?: readonly MemberUsageAdapter[]) => import("./member-declaration-utilities.js").PublicMember[];
 /**
  * Finds the program source file matching an absolute lint filename.
  * @param program TypeScript project program.

package/dist/domain/architecture/no-unused-public-members/member-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"member-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AASvE,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,0BAA0B,GAC9B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,gBAAgB,cAAc,4DAU/B,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,EAAE,CAAC,OAAO,EACnB,UAAU,MAAM,KACf,EAAE,CAAC,UAAU,GAAG,SAOd,CAAC;AAEN;;;;;;;;GAQG;AACH,QAAA,MAAM,cAAc,GAAI,SAAS,EAAE,CAAC,OAAO,KAAG,MACD,CAAC;AAE9C,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"member-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASnE,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,0BAA0B,GAC9B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,gBAAgB,cAAc,EAC9B,gBAAe,SAAS,kBAAkB,EAAO,4DAUlD,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,EAAE,CAAC,OAAO,EACnB,UAAU,MAAM,KACf,EAAE,CAAC,UAAU,GAAG,SAOd,CAAC;AAEN;;;;;;;;GAQG;AACH,QAAA,MAAM,cAAc,GAAI,SAAS,EAAE,CAAC,OAAO,KAAG,MACD,CAAC;AAE9C,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,cAAc,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-public-members/member-utilities.js

@@ -11,17 +11,18 @@ import { hasProductionUsage } from "./member-usage-utilities.js";
  * @param state Normalized public API and test patterns.
  * @param repoRoot Root directory used for glob matching.
  * @param parserServices TypeScript and ESTree node maps.
+ * @param usageAdapters Adapters that recognize usage outside TypeScript source.
  * @returns Members outside the public API with no production use.
  * @example
  * ```typescript
  * const unused = collectUnusedPublicMembers(sourceFile, program, state, repoRoot, services);
  * ```
  */
-const collectUnusedPublicMembers = (sourceFile, program, state, repoRoot, parserServices) => {
+const collectUnusedPublicMembers = (sourceFile, program, state, repoRoot, parserServices, usageAdapters = []) => {
     const checker = program.getTypeChecker();
     return collectPublicMembers(sourceFile, checker, parserServices).filter((member) => !isPublicApiHost(program, state, repoRoot, member.hostSymbol) &&
         !isPublicApiMember(program, state, repoRoot, member.memberSymbol) &&
-        !hasProductionUsage(program, state, repoRoot, member));
+        !hasProductionUsage(program, state, repoRoot, member, usageAdapters));
 };
 /**
  * Finds the program source file matching an absolute lint filename.
@@ -48,4 +49,4 @@ const getProgramSourceFile = (program, filename) => program
  */
 const getProjectRoot = (program) => path.resolve(program.getCurrentDirectory());
 export { collectUnusedPublicMembers, getProgramSourceFile, getProjectRoot };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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