@codeperfect/eslint-plugin 2.11.0 → 3.1.0

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

@@ -0,0 +1,101 @@
+import path from "node:path";
+import * as ts from "typescript";
+import { isPublicApiFile, isTestFile, } from "../no-unused-exports/no-unused-exports-options.js";
+import { isSameSymbol, resolveCanonicalSymbol, sourceFileExportsSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+/**
+ * Checks whether a symbol is nested within an exported API type.
+ * @param type Type shape of an exported value or type.
+ * @param targetSymbol Symbol being searched for.
+ * @param checker TypeScript type checker.
+ * @param location Node used to resolve property types.
+ * @param visitedTypes Types already checked on this search path.
+ * @param depth Remaining nested property depth.
+ * @returns True when the target occurs in the exported type shape.
+ * @example
+ * ```typescript
+ * const exposed = typeContainsSymbol(type, member, checker, sourceFile, new Set(), 2);
+ * ```
+ */
+const typeContainsSymbol = (type, targetSymbol, checker, location, visitedTypes, depth) => {
+    if (depth < 0 || visitedTypes.has(type)) {
+        return false;
+    }
+    visitedTypes.add(type);
+    for (const property of checker.getPropertiesOfType(type)) {
+        if (isSameSymbol(resolveCanonicalSymbol(property, checker), targetSymbol) ||
+            typeContainsSymbol(checker.getTypeOfSymbolAtLocation(property, location), targetSymbol, checker, location, visitedTypes, depth - 1)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Checks whether a member is reachable from a configured public API export.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param memberSymbol Member symbol being checked.
+ * @returns True when an API export exposes the member.
+ * @example
+ * ```typescript
+ * const exposed = isPublicApiMember(program, state, repoRoot, memberSymbol);
+ * ```
+ */
+const isPublicApiMember = (program, state, repoRoot, memberSymbol) => {
+    const checker = program.getTypeChecker();
+    const targetSymbol = resolveCanonicalSymbol(memberSymbol, checker);
+    const normalizedRoot = path.resolve(repoRoot);
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const filename = path.resolve(sourceFile.fileName);
+        if (!isPublicApiFile(filename, state, normalizedRoot) ||
+            isTestFile(filename, state, normalizedRoot)) {
+            continue;
+        }
+        const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+        if (moduleSymbol === void 0) {
+            continue;
+        }
+        for (const exportedSymbol of checker.getExportsOfModule(moduleSymbol)) {
+            const canonicalExport = resolveCanonicalSymbol(exportedSymbol, checker);
+            if (isSameSymbol(canonicalExport, targetSymbol) ||
+                typeContainsSymbol(checker.getTypeOfSymbolAtLocation(canonicalExport, sourceFile), targetSymbol, checker, sourceFile, new Set(), 3)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+/**
+ * Checks whether a host is exported from a configured public API file.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param hostSymbol Host declaration symbol.
+ * @returns True when the host is exposed by a non-test API file.
+ * @example
+ * ```typescript
+ * const isPublic = isPublicApiHost(program, state, repoRoot, hostSymbol);
+ * ```
+ */
+const isPublicApiHost = (program, state, repoRoot, hostSymbol) => {
+    if (hostSymbol === void 0) {
+        return false;
+    }
+    const checker = program.getTypeChecker();
+    const normalizedRoot = path.resolve(repoRoot);
+    const canonicalHost = resolveCanonicalSymbol(hostSymbol, checker);
+    return program.getSourceFiles().some((sourceFile) => {
+        if (sourceFile.isDeclarationFile) {
+            return false;
+        }
+        const filename = path.resolve(sourceFile.fileName);
+        return (isPublicApiFile(filename, state, normalizedRoot) &&
+            !isTestFile(filename, state, normalizedRoot) &&
+            sourceFileExportsSymbol(sourceFile, checker, canonicalHost));
+    });
+};
+export { isPublicApiHost, isPublicApiMember };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-public-api-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-public-api-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\";\n\nimport {\n  isPublicApiFile,\n  isTestFile,\n} from \"../no-unused-exports/no-unused-exports-options\";\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n  sourceFileExportsSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\n\n/**\n * Checks whether a symbol is nested within an exported API type.\n * @param type Type shape of an exported value or type.\n * @param targetSymbol Symbol being searched for.\n * @param checker TypeScript type checker.\n * @param location Node used to resolve property types.\n * @param visitedTypes Types already checked on this search path.\n * @param depth Remaining nested property depth.\n * @returns True when the target occurs in the exported type shape.\n * @example\n * ```typescript\n * const exposed = typeContainsSymbol(type, member, checker, sourceFile, new Set(), 2);\n * ```\n */\nconst typeContainsSymbol = (\n  type: ts.Type,\n  targetSymbol: ts.Symbol,\n  checker: ts.TypeChecker,\n  location: ts.Node,\n  visitedTypes: Set<ts.Type>,\n  depth: number,\n): boolean => {\n  if (depth < 0 || visitedTypes.has(type)) {\n    return false;\n  }\n\n  visitedTypes.add(type);\n\n  for (const property of checker.getPropertiesOfType(type)) {\n    if (\n      isSameSymbol(resolveCanonicalSymbol(property, checker), targetSymbol) ||\n      typeContainsSymbol(\n        checker.getTypeOfSymbolAtLocation(property, location),\n        targetSymbol,\n        checker,\n        location,\n        visitedTypes,\n        depth - 1,\n      )\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Checks whether a member is reachable from a configured public API export.\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 memberSymbol Member symbol being checked.\n * @returns True when an API export exposes the member.\n * @example\n * ```typescript\n * const exposed = isPublicApiMember(program, state, repoRoot, memberSymbol);\n * ```\n */\nconst isPublicApiMember = (\n  program: ts.Program,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  memberSymbol: ts.Symbol,\n): boolean => {\n  const checker = program.getTypeChecker();\n  const targetSymbol = resolveCanonicalSymbol(memberSymbol, checker);\n  const normalizedRoot = path.resolve(repoRoot);\n\n  for (const sourceFile of program.getSourceFiles()) {\n    if (sourceFile.isDeclarationFile) {\n      continue;\n    }\n\n    const filename = path.resolve(sourceFile.fileName);\n\n    if (\n      !isPublicApiFile(filename, state, normalizedRoot) ||\n      isTestFile(filename, state, normalizedRoot)\n    ) {\n      continue;\n    }\n\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n\n    if (moduleSymbol === void 0) {\n      continue;\n    }\n\n    for (const exportedSymbol of checker.getExportsOfModule(moduleSymbol)) {\n      const canonicalExport = resolveCanonicalSymbol(exportedSymbol, checker);\n\n      if (\n        isSameSymbol(canonicalExport, targetSymbol) ||\n        typeContainsSymbol(\n          checker.getTypeOfSymbolAtLocation(canonicalExport, sourceFile),\n          targetSymbol,\n          checker,\n          sourceFile,\n          new Set(),\n          3,\n        )\n      ) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n\n/**\n * Checks whether a host is exported from a configured public API file.\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 hostSymbol Host declaration symbol.\n * @returns True when the host is exposed by a non-test API file.\n * @example\n * ```typescript\n * const isPublic = isPublicApiHost(program, state, repoRoot, hostSymbol);\n * ```\n */\nconst isPublicApiHost = (\n  program: ts.Program,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  hostSymbol: ts.Symbol | undefined,\n): boolean => {\n  if (hostSymbol === void 0) {\n    return false;\n  }\n\n  const checker = program.getTypeChecker();\n  const normalizedRoot = path.resolve(repoRoot);\n  const canonicalHost = resolveCanonicalSymbol(hostSymbol, checker);\n\n  return program.getSourceFiles().some((sourceFile) => {\n    if (sourceFile.isDeclarationFile) {\n      return false;\n    }\n\n    const filename = path.resolve(sourceFile.fileName);\n\n    return (\n      isPublicApiFile(filename, state, normalizedRoot) &&\n      !isTestFile(filename, state, normalizedRoot) &&\n      sourceFileExportsSymbol(sourceFile, checker, canonicalHost)\n    );\n  });\n};\n\nexport { isPublicApiHost, isPublicApiMember };\n"]}

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

@@ -0,0 +1,28 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether an object property is supplied to a typed call boundary.
+ * @param node Candidate property assignment.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @returns True when an external call contract accepts the member shape.
+ * @example
+ * ```typescript
+ * const used = isCallArgumentMember(node, checker, member);
+ * ```
+ */
+declare const isCallArgumentMember: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember) => boolean;
+/**
+ * Checks whether a property value is forwarded into an external object contract.
+ * @param node Candidate outer object property.
+ * @param checker TypeScript type checker.
+ * @param member Member whose host value is being forwarded.
+ * @returns True when the receiving property accepts the host shape.
+ * @example
+ * ```typescript
+ * const used = isObjectContractHandoff(node, checker, member);
+ * ```
+ */
+declare const isObjectContractHandoff: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember) => boolean;
+export { isCallArgumentMember, isObjectContractHandoff };
+//# sourceMappingURL=member-usage-handoff-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-handoff-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-handoff-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AA0FnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,oBAAoB,GACxB,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,KACnB,OA8BF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,uBAAuB,GAC3B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,KACnB,OAkDF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -0,0 +1,125 @@
+import * as ts from "typescript";
+import { getContextualPropertyType, isMemberHandoff, } from "./member-usage-type-utilities.js";
+/**
+ * Finds a call argument's resolved parameter type.
+ * @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 contextual property comes from an external declaration.
+ * @param objectType Contextual type of the containing object literal.
+ * @param propertyName Property name in the object literal.
+ * @param checker TypeScript type checker.
+ * @returns True when the contract is declared outside the project source.
+ * @example
+ * ```typescript
+ * const external = isExternalPropertyContract(objectType, "docs", checker);
+ * ```
+ */
+const isExternalPropertyContract = (objectType, propertyName, checker) => {
+    const property = objectType === void 0
+        ? void 0
+        : checker.getPropertyOfType(objectType, propertyName);
+    return (property?.declarations?.some((declaration) => declaration.getSourceFile().isDeclarationFile) ?? false);
+};
+/**
+ * Checks whether a call resolves to a declaration with a local implementation.
+ * @param call Call expression to inspect.
+ * @param checker TypeScript type checker.
+ * @returns True when the resolved declaration has a body.
+ * @example
+ * ```typescript
+ * const implemented = hasCallImplementation(call, checker);
+ * ```
+ */
+const hasCallImplementation = (call, checker) => {
+    const declaration = checker.getResolvedSignature(call)?.getDeclaration();
+    return (declaration !== void 0 &&
+        "body" in declaration &&
+        declaration.body !== void 0);
+};
+/**
+ * Checks whether an object property is supplied to a typed call boundary.
+ * @param node Candidate property assignment.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @returns True when an external call contract accepts the member shape.
+ * @example
+ * ```typescript
+ * const used = isCallArgumentMember(node, checker, member);
+ * ```
+ */
+const isCallArgumentMember = (node, checker, member) => {
+    if (!ts.isPropertyAssignment(node) ||
+        (!ts.isIdentifier(node.name) && !ts.isStringLiteralLike(node.name)) ||
+        !ts.isObjectLiteralExpression(node.parent)) {
+        return false;
+    }
+    const call = node.parent.parent;
+    if (!ts.isCallExpression(call) ||
+        hasCallImplementation(call, checker) ||
+        !call.arguments.some((argument) => argument === node.parent)) {
+        return false;
+    }
+    const targetType = getCallArgumentType(call, node.parent, checker);
+    return (node.name.text === member.memberName &&
+        isMemberHandoff(checker.getTypeAtLocation(node.parent), targetType, member, checker));
+};
+/**
+ * Checks whether a property value is forwarded into an external object contract.
+ * @param node Candidate outer object property.
+ * @param checker TypeScript type checker.
+ * @param member Member whose host value is being forwarded.
+ * @returns True when the receiving property accepts the host shape.
+ * @example
+ * ```typescript
+ * const used = isObjectContractHandoff(node, checker, member);
+ * ```
+ */
+const isObjectContractHandoff = (node, checker, member) => {
+    if (ts.isPropertyAssignment(node) &&
+        ts.isObjectLiteralExpression(node.parent)) {
+        const name = node.name;
+        if (!ts.isIdentifier(name) && !ts.isStringLiteralLike(name)) {
+            return false;
+        }
+        const objectType = checker.getContextualType(node.parent);
+        if (!isExternalPropertyContract(objectType, name.text, checker)) {
+            return false;
+        }
+        const sourceType = checker.getTypeAtLocation(node.initializer);
+        const targetType = getContextualPropertyType(objectType, name.text, node, checker);
+        return isMemberHandoff(sourceType, targetType, member, checker);
+    }
+    if (ts.isShorthandPropertyAssignment(node) &&
+        ts.isObjectLiteralExpression(node.parent)) {
+        const objectType = checker.getContextualType(node.parent);
+        if (!isExternalPropertyContract(objectType, node.name.text, checker)) {
+            return false;
+        }
+        const sourceType = checker.getTypeAtLocation(node.name);
+        const targetType = getContextualPropertyType(objectType, node.name.text, node, checker);
+        return isMemberHandoff(sourceType, targetType, member, checker);
+    }
+    return false;
+};
+export { isCallArgumentMember, isObjectContractHandoff };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-handoff-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-handoff-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  getContextualPropertyType,\n  isMemberHandoff,\n} from \"./member-usage-type-utilities\";\n\n/**\n * Finds a call argument's resolved parameter type.\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 contextual property comes from an external declaration.\n * @param objectType Contextual type of the containing object literal.\n * @param propertyName Property name in the object literal.\n * @param checker TypeScript type checker.\n * @returns True when the contract is declared outside the project source.\n * @example\n * ```typescript\n * const external = isExternalPropertyContract(objectType, \"docs\", checker);\n * ```\n */\nconst isExternalPropertyContract = (\n  objectType: ts.Type | undefined,\n  propertyName: string,\n  checker: ts.TypeChecker,\n): boolean => {\n  const property =\n    objectType === void 0\n      ? void 0\n      : checker.getPropertyOfType(objectType, propertyName);\n\n  return (\n    property?.declarations?.some(\n      (declaration) => declaration.getSourceFile().isDeclarationFile,\n    ) ?? false\n  );\n};\n\n/**\n * Checks whether a call resolves to a declaration with a local implementation.\n * @param call Call expression to inspect.\n * @param checker TypeScript type checker.\n * @returns True when the resolved declaration has a body.\n * @example\n * ```typescript\n * const implemented = hasCallImplementation(call, checker);\n * ```\n */\nconst hasCallImplementation = (\n  call: ts.CallExpression,\n  checker: ts.TypeChecker,\n): boolean => {\n  const declaration = checker.getResolvedSignature(call)?.getDeclaration();\n\n  return (\n    declaration !== void 0 &&\n    \"body\" in declaration &&\n    declaration.body !== void 0\n  );\n};\n\n/**\n * Checks whether an object property is supplied to a typed call boundary.\n * @param node Candidate property assignment.\n * @param checker TypeScript type checker.\n * @param member Member whose usage is being checked.\n * @returns True when an external call contract accepts the member shape.\n * @example\n * ```typescript\n * const used = isCallArgumentMember(node, checker, member);\n * ```\n */\nconst isCallArgumentMember = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    !ts.isPropertyAssignment(node) ||\n    (!ts.isIdentifier(node.name) && !ts.isStringLiteralLike(node.name)) ||\n    !ts.isObjectLiteralExpression(node.parent)\n  ) {\n    return false;\n  }\n\n  const call = node.parent.parent;\n\n  if (\n    !ts.isCallExpression(call) ||\n    hasCallImplementation(call, checker) ||\n    !call.arguments.some((argument) => argument === node.parent)\n  ) {\n    return false;\n  }\n\n  const targetType = getCallArgumentType(call, node.parent, checker);\n\n  return (\n    node.name.text === member.memberName &&\n    isMemberHandoff(\n      checker.getTypeAtLocation(node.parent),\n      targetType,\n      member,\n      checker,\n    )\n  );\n};\n\n/**\n * Checks whether a property value is forwarded into an external object contract.\n * @param node Candidate outer object property.\n * @param checker TypeScript type checker.\n * @param member Member whose host value is being forwarded.\n * @returns True when the receiving property accepts the host shape.\n * @example\n * ```typescript\n * const used = isObjectContractHandoff(node, checker, member);\n * ```\n */\nconst isObjectContractHandoff = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    ts.isPropertyAssignment(node) &&\n    ts.isObjectLiteralExpression(node.parent)\n  ) {\n    const name = node.name;\n\n    if (!ts.isIdentifier(name) && !ts.isStringLiteralLike(name)) {\n      return false;\n    }\n\n    const objectType = checker.getContextualType(node.parent);\n\n    if (!isExternalPropertyContract(objectType, name.text, checker)) {\n      return false;\n    }\n\n    const sourceType = checker.getTypeAtLocation(node.initializer);\n    const targetType = getContextualPropertyType(\n      objectType,\n      name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(sourceType, targetType, member, checker);\n  }\n\n  if (\n    ts.isShorthandPropertyAssignment(node) &&\n    ts.isObjectLiteralExpression(node.parent)\n  ) {\n    const objectType = checker.getContextualType(node.parent);\n\n    if (!isExternalPropertyContract(objectType, node.name.text, checker)) {\n      return false;\n    }\n\n    const sourceType = checker.getTypeAtLocation(node.name);\n    const targetType = getContextualPropertyType(\n      objectType,\n      node.name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(sourceType, targetType, member, checker);\n  }\n\n  return false;\n};\n\nexport { isCallArgumentMember, isObjectContractHandoff };\n"]}

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

@@ -0,0 +1,29 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether a property read uses a structurally related host shape.
+ * @param node Candidate read node.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @returns True when the read resolves through a structural contract.
+ * @example
+ * ```typescript
+ * const used = isStructuralPropertyRead(node, checker, member);
+ * ```
+ */
+declare const isStructuralPropertyRead: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember) => boolean;
+/**
+ * Checks whether a computed property access resolves to a member symbol.
+ * @param node Candidate element access expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @param relatedSymbols Member and contract symbols accepted as usage.
+ * @returns True when a resolved key selects the member.
+ * @example
+ * ```typescript
+ * const used = isComputedMemberRead(node, checker, member, relatedSymbols);
+ * ```
+ */
+declare const isComputedMemberRead: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember, relatedSymbols: ts.Symbol[]) => boolean;
+export { isComputedMemberRead, isStructuralPropertyRead };
+//# sourceMappingURL=member-usage-reference-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-reference-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-reference-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AA8DnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,KACnB,OAQF,CAAC;AAyBF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,oBAAoB,GACxB,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,EACpB,gBAAgB,EAAE,CAAC,MAAM,EAAE,KAC1B,OAqBF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,108 @@
+import * as ts from "typescript";
+import { isSameSymbol } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+import { hasCompatibleMemberShape } from "./member-usage-type-utilities.js";
+/**
+ * Gets the source type and key for a property read or destructuring use.
+ * @param node Candidate member-name node.
+ * @param checker TypeScript type checker.
+ * @returns Access details when the node reads a property.
+ * @example
+ * ```typescript
+ * const access = getPropertyAccess(node, checker);
+ * ```
+ */
+const getPropertyAccess = (node, checker) => {
+    const parent = node.parent;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+        return {
+            name: parent.name.text,
+            sourceType: checker.getTypeAtLocation(parent.expression),
+        };
+    }
+    if (ts.isBindingElement(parent) &&
+        (parent.name === node || parent.propertyName === node) &&
+        ts.isObjectBindingPattern(parent.parent)) {
+        const owner = parent.parent.parent;
+        const sourceType = ts.isVariableDeclaration(owner)
+            ? owner.initializer === void 0
+                ? void 0
+                : checker.getTypeAtLocation(owner.initializer)
+            : ts.isParameter(owner)
+                ? checker.getTypeAtLocation(owner)
+                : void 0;
+        const nameNode = parent.propertyName ?? parent.name;
+        return sourceType === void 0
+            ? void 0
+            : ts.isIdentifier(nameNode) || ts.isStringLiteralLike(nameNode)
+                ? { name: nameNode.text, sourceType }
+                : void 0;
+    }
+    return void 0;
+};
+/**
+ * Checks whether a property read uses a structurally related host shape.
+ * @param node Candidate read node.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @returns True when the read resolves through a structural contract.
+ * @example
+ * ```typescript
+ * const used = isStructuralPropertyRead(node, checker, member);
+ * ```
+ */
+const isStructuralPropertyRead = (node, checker, member) => {
+    const access = getPropertyAccess(node, checker);
+    return (access !== void 0 &&
+        access.name === member.memberName &&
+        hasCompatibleMemberShape(access.sourceType, member, checker));
+};
+/**
+ * Gets the literal string keys represented by a TypeScript key type.
+ * @param type Key type from an element access expression.
+ * @returns Literal keys represented by the type.
+ * @example
+ * ```typescript
+ * const keys = getStringLiteralKeys(keyType);
+ * ```
+ */
+const getStringLiteralKeys = (type) => {
+    if (type.isUnionOrIntersection()) {
+        return type.types.flatMap((part) => getStringLiteralKeys(part));
+    }
+    if ((type.flags & ts.TypeFlags.StringLiteral) !== 0) {
+        return [type.value];
+    }
+    return (type.flags & ts.TypeFlags.NumberLiteral) === 0
+        ? []
+        : [type.value.toFixed(0)];
+};
+/**
+ * Checks whether a computed property access resolves to a member symbol.
+ * @param node Candidate element access expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose usage is being checked.
+ * @param relatedSymbols Member and contract symbols accepted as usage.
+ * @returns True when a resolved key selects the member.
+ * @example
+ * ```typescript
+ * const used = isComputedMemberRead(node, checker, member, relatedSymbols);
+ * ```
+ */
+const isComputedMemberRead = (node, checker, member, relatedSymbols) => {
+    if (!ts.isElementAccessExpression(node)) {
+        return false;
+    }
+    const objectType = checker.getTypeAtLocation(node.expression);
+    const keyType = checker.getTypeAtLocation(node.argumentExpression);
+    return getStringLiteralKeys(keyType).some((name) => {
+        if (name !== member.memberName) {
+            return false;
+        }
+        const property = checker.getPropertyOfType(objectType, name);
+        return (property !== void 0 &&
+            (relatedSymbols.some((symbol) => isSameSymbol(symbol, property)) ||
+                hasCompatibleMemberShape(objectType, member, checker)));
+    });
+};
+export { isComputedMemberRead, isStructuralPropertyRead };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-reference-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-reference-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { isSameSymbol } from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\nimport { hasCompatibleMemberShape } from \"./member-usage-type-utilities\";\n\n/** Source type and name for a property access or destructuring read. */\ninterface PropertyAccessDetails {\n  /** Property name selected by the access. */\n  name: string;\n\n  /** Type of the object whose property is read. */\n  sourceType: ts.Type;\n}\n\n/**\n * Gets the source type and key for a property read or destructuring use.\n * @param node Candidate member-name node.\n * @param checker TypeScript type checker.\n * @returns Access details when the node reads a property.\n * @example\n * ```typescript\n * const access = getPropertyAccess(node, checker);\n * ```\n */\nconst getPropertyAccess = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n): PropertyAccessDetails | undefined => {\n  const parent = node.parent;\n\n  if (ts.isPropertyAccessExpression(parent) && parent.name === node) {\n    return {\n      name: parent.name.text,\n      sourceType: checker.getTypeAtLocation(parent.expression),\n    };\n  }\n\n  if (\n    ts.isBindingElement(parent) &&\n    (parent.name === node || parent.propertyName === node) &&\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    const nameNode = parent.propertyName ?? parent.name;\n\n    return sourceType === void 0\n      ? void 0\n      : ts.isIdentifier(nameNode) || ts.isStringLiteralLike(nameNode)\n        ? { name: nameNode.text, sourceType }\n        : void 0;\n  }\n\n  return void 0;\n};\n\n/**\n * Checks whether a property read uses a structurally related host shape.\n * @param node Candidate read node.\n * @param checker TypeScript type checker.\n * @param member Member whose usage is being checked.\n * @returns True when the read resolves through a structural contract.\n * @example\n * ```typescript\n * const used = isStructuralPropertyRead(node, checker, member);\n * ```\n */\nconst isStructuralPropertyRead = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  const access = getPropertyAccess(node, checker);\n\n  return (\n    access !== void 0 &&\n    access.name === member.memberName &&\n    hasCompatibleMemberShape(access.sourceType, member, checker)\n  );\n};\n\n/**\n * Gets the literal string keys represented by a TypeScript key type.\n * @param type Key type from an element access expression.\n * @returns Literal keys represented by the type.\n * @example\n * ```typescript\n * const keys = getStringLiteralKeys(keyType);\n * ```\n */\nconst getStringLiteralKeys = (type: ts.Type): string[] => {\n  if (type.isUnionOrIntersection()) {\n    return type.types.flatMap((part) => getStringLiteralKeys(part));\n  }\n\n  if ((type.flags & ts.TypeFlags.StringLiteral) !== 0) {\n    return [(type as ts.StringLiteralType).value];\n  }\n\n  return (type.flags & ts.TypeFlags.NumberLiteral) === 0\n    ? []\n    : [(type as ts.NumberLiteralType).value.toFixed(0)];\n};\n\n/**\n * Checks whether a computed property access resolves to a member symbol.\n * @param node Candidate element access expression.\n * @param checker TypeScript type checker.\n * @param member Member whose usage is being checked.\n * @param relatedSymbols Member and contract symbols accepted as usage.\n * @returns True when a resolved key selects the member.\n * @example\n * ```typescript\n * const used = isComputedMemberRead(node, checker, member, relatedSymbols);\n * ```\n */\nconst isComputedMemberRead = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  relatedSymbols: ts.Symbol[],\n): boolean => {\n  if (!ts.isElementAccessExpression(node)) {\n    return false;\n  }\n\n  const objectType = checker.getTypeAtLocation(node.expression);\n  const keyType = checker.getTypeAtLocation(node.argumentExpression);\n\n  return getStringLiteralKeys(keyType).some((name) => {\n    if (name !== member.memberName) {\n      return false;\n    }\n\n    const property = checker.getPropertyOfType(objectType, name);\n\n    return (\n      property !== void 0 &&\n      (relatedSymbols.some((symbol) => isSameSymbol(symbol, property)) ||\n        hasCompatibleMemberShape(objectType, member, checker))\n    );\n  });\n};\n\nexport { isComputedMemberRead, isStructuralPropertyRead };\n"]}

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

@@ -0,0 +1,42 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether a value type carries a structurally corresponding member.
+ * @param valueType Type of the value being inspected.
+ * @param member Member whose host shape is required.
+ * @param checker TypeScript type checker.
+ * @returns True when TypeScript relates the value and host shapes.
+ * @example
+ * ```typescript
+ * const matches = hasCompatibleMemberShape(valueType, member, checker);
+ * ```
+ */
+declare const hasCompatibleMemberShape: (valueType: ts.Type, member: PublicMember, checker: ts.TypeChecker) => boolean;
+/**
+ * Gets the property type supplied by an object's contextual contract.
+ * @param objectType Expected shape for the object literal.
+ * @param propertyName Property name in the object literal.
+ * @param location Node used to resolve the property type.
+ * @param checker TypeScript type checker.
+ * @returns Contextual property type when one is declared.
+ * @example
+ * ```typescript
+ * const type = getContextualPropertyType(objectType, "docs", node, checker);
+ * ```
+ */
+declare const getContextualPropertyType: (objectType: ts.Type | undefined, propertyName: string, location: ts.Node, checker: ts.TypeChecker) => ts.Type | undefined;
+/**
+ * Checks whether a typed handoff carries a member into a compatible contract.
+ * @param sourceType Type of the 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);
+ * ```
+ */
+declare const isMemberHandoff: (sourceType: ts.Type | undefined, targetType: ts.Type | undefined, member: PublicMember, checker: ts.TypeChecker) => boolean;
+export { getContextualPropertyType, hasCompatibleMemberShape, isMemberHandoff };
+//# sourceMappingURL=member-usage-type-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-type-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-type-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAwBnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,WAAW,EAAE,CAAC,IAAI,EAClB,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,WAAW,KACtB,OAiBF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,yBAAyB,GAC7B,YAAY,EAAE,CAAC,IAAI,GAAG,SAAS,EAC/B,cAAc,MAAM,EACpB,UAAU,EAAE,CAAC,IAAI,EACjB,SAAS,EAAE,CAAC,WAAW,KACtB,EAAE,CAAC,IAAI,GAAG,SASZ,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,YAAY,EAAE,CAAC,IAAI,GAAG,SAAS,EAC/B,YAAY,EAAE,CAAC,IAAI,GAAG,SAAS,EAC/B,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,WAAW,KACtB,OA8CF,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,eAAe,EAAE,CAAC"}

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

@@ -0,0 +1,96 @@
+import * as ts from "typescript";
+/**
+ * Gets the declared type of the host that owns a public member.
+ * @param member Member whose host type is needed.
+ * @param checker TypeScript type checker.
+ * @returns Host type used for structural usage checks.
+ * @example
+ * ```typescript
+ * const hostType = getMemberHostType(member, checker);
+ * ```
+ */
+const getMemberHostType = (member, checker) => {
+    const declaration = member.hostDeclaration;
+    const location = ts.isVariableDeclaration(declaration)
+        ? declaration.name
+        : declaration;
+    return checker.getTypeAtLocation(location);
+};
+/**
+ * Checks whether a value type carries a structurally corresponding member.
+ * @param valueType Type of the value being inspected.
+ * @param member Member whose host shape is required.
+ * @param checker TypeScript type checker.
+ * @returns True when TypeScript relates the value and host shapes.
+ * @example
+ * ```typescript
+ * const matches = hasCompatibleMemberShape(valueType, member, checker);
+ * ```
+ */
+const hasCompatibleMemberShape = (valueType, member, checker) => {
+    const hostType = checker.getNonNullableType(getMemberHostType(member, checker));
+    const observedType = checker.getNonNullableType(valueType);
+    const hostProperty = checker.getPropertyOfType(hostType, member.memberName);
+    const observedProperty = checker.getPropertyOfType(observedType, member.memberName);
+    return (hostProperty !== void 0 &&
+        observedProperty !== void 0 &&
+        checker.isTypeAssignableTo(observedType, hostType) &&
+        checker.isTypeAssignableTo(hostType, observedType));
+};
+/**
+ * Gets the property type supplied by an object's contextual contract.
+ * @param objectType Expected shape for the object literal.
+ * @param propertyName Property name in the object literal.
+ * @param location Node used to resolve the property type.
+ * @param checker TypeScript type checker.
+ * @returns Contextual property type when one is declared.
+ * @example
+ * ```typescript
+ * const type = getContextualPropertyType(objectType, "docs", node, checker);
+ * ```
+ */
+const getContextualPropertyType = (objectType, propertyName, location, checker) => {
+    const property = objectType === void 0
+        ? void 0
+        : checker.getPropertyOfType(objectType, propertyName);
+    return property === void 0
+        ? void 0
+        : checker.getTypeOfSymbolAtLocation(property, location);
+};
+/**
+ * Checks whether a typed handoff carries a member into a compatible contract.
+ * @param sourceType Type of the 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 isMemberHandoff = (sourceType, targetType, member, checker) => {
+    if (sourceType === void 0 || targetType === void 0) {
+        return false;
+    }
+    const hostType = checker.getNonNullableType(getMemberHostType(member, checker));
+    const forwardedType = checker.getNonNullableType(sourceType);
+    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)) {
+        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));
+};
+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"]}