@codeperfect/eslint-plugin 3.1.0 → 3.2.1

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

@@ -0,0 +1,151 @@
+import * as ts from "typescript";
+import { expressionReferencesSymbol } from "./member-usage-expression-reference-utilities.js";
+import { isDeclarationOnlyMethod } from "./member-usage-type-utilities.js";
+import { expressionCarriesMemberValue } from "./member-usage-value-utilities.js";
+/**
+ * Checks whether a local call forwards a member-bearing value to an HTTP body.
+ * @param node Candidate local call expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being transmitted.
+ * @returns True when the argument reaches an opaque request body contract.
+ * @example
+ * ```typescript
+ * const transmitted = isLocalCallArgumentTransmitted(call, checker, member);
+ * ```
+ */
+const isLocalCallArgumentTransmitted = (node, checker, member) => {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+    const declaration = checker.getResolvedSignature(node)?.getDeclaration();
+    if (!hasFunctionBody(declaration)) {
+        return false;
+    }
+    return node.arguments.some((argument, argumentIndex) => {
+        const parameter = declaration.parameters[Math.min(argumentIndex, declaration.parameters.length - 1)];
+        const parameterSymbol = parameter === void 0 || !ts.isIdentifier(parameter.name)
+            ? void 0
+            : checker.getSymbolAtLocation(parameter.name);
+        const carries = expressionCarriesMemberValue(argument, checker, member);
+        const reachesBody = parameterSymbol !== void 0 &&
+            localParameterReachesRequestBody(declaration, parameterSymbol, checker, new Map());
+        return parameterSymbol !== void 0 && carries && reachesBody;
+    });
+};
+/**
+ * Checks whether a local parameter reaches a declared HTTP request body.
+ * @param declaration Local function containing the parameter.
+ * @param parameterSymbol Parameter symbol whose value is traced.
+ * @param checker TypeScript type checker.
+ * @param visitedDeclarations Function declarations already inspected.
+ * @returns True when the parameter reaches an opaque request body.
+ * @example
+ * ```typescript
+ * const reachesBody = localParameterReachesRequestBody(
+ *   declaration,
+ *   parameterSymbol,
+ *   checker,
+ *   new Set(),
+ * );
+ * ```
+ */
+const localParameterReachesRequestBody = (declaration, parameterSymbol, checker, visitedDeclarations) => {
+    if (!hasFunctionBody(declaration)) {
+        return false;
+    }
+    const visitedParameters = visitedDeclarations.get(declaration) ?? new Set();
+    if (visitedParameters.has(parameterSymbol)) {
+        return false;
+    }
+    visitedParameters.add(parameterSymbol);
+    visitedDeclarations.set(declaration, visitedParameters);
+    const inspect = (node) => {
+        if (ts.isCallExpression(node)) {
+            const isBody = isOpaqueRequestBodyHandoff(node, parameterSymbol, checker);
+            if (isBody) {
+                return true;
+            }
+            const nestedDeclaration = checker
+                .getResolvedSignature(node)
+                ?.getDeclaration();
+            if (hasFunctionBody(nestedDeclaration)) {
+                for (const [argumentIndex, argument] of node.arguments.entries()) {
+                    const references = expressionReferencesSymbol(argument, parameterSymbol, checker);
+                    if (!references) {
+                        continue;
+                    }
+                    const nestedParameter = nestedDeclaration.parameters[Math.min(argumentIndex, nestedDeclaration.parameters.length - 1)];
+                    const nestedParameterSymbol = nestedParameter === void 0 || !ts.isIdentifier(nestedParameter.name)
+                        ? void 0
+                        : checker.getSymbolAtLocation(nestedParameter.name);
+                    if (nestedParameterSymbol !== void 0 &&
+                        localParameterReachesRequestBody(nestedDeclaration, nestedParameterSymbol, checker, visitedDeclarations)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return ts.forEachChild(node, inspect);
+    };
+    return inspect(declaration.body) === true;
+};
+/**
+ * Checks whether a request call sends the traced parameter as opaque body data.
+ * @param call Candidate call expression.
+ * @param parameterSymbol Parameter symbol whose value is traced.
+ * @param checker TypeScript type checker.
+ * @returns True when a declaration-only request method accepts the value as body.
+ * @example
+ * ```typescript
+ * const opaque = isOpaqueRequestBodyHandoff(call, parameterSymbol, checker);
+ * ```
+ */
+const isOpaqueRequestBodyHandoff = (call, parameterSymbol, checker) => {
+    const declaration = checker.getResolvedSignature(call)?.getDeclaration();
+    if (declaration === void 0 ||
+        !isDeclarationOnlyMethod(declaration) ||
+        !ts.isPropertyAccessExpression(call.expression) ||
+        call.expression.name.text !== "request") {
+        return false;
+    }
+    return call.arguments.some((argument) => {
+        if (!ts.isObjectLiteralExpression(argument)) {
+            return false;
+        }
+        const optionsType = checker.getContextualType(argument);
+        const requestOptionsType = optionsType === void 0 ? void 0 : checker.getNonNullableType(optionsType);
+        const bodyProperty = requestOptionsType === void 0
+            ? void 0
+            : checker.getPropertyOfType(requestOptionsType, "body");
+        if (bodyProperty === void 0) {
+            return false;
+        }
+        const bodyType = checker.getTypeOfSymbolAtLocation(bodyProperty, argument);
+        if ((bodyType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0) {
+            return false;
+        }
+        return argument.properties.some((property) => {
+            return ts.isPropertyAssignment(property) &&
+                ts.isIdentifier(property.name) &&
+                property.name.text === "body"
+                ? expressionReferencesSymbol(property.initializer, parameterSymbol, checker)
+                : ts.isShorthandPropertyAssignment(property) &&
+                    property.name.text === "body" &&
+                    expressionReferencesSymbol(property.name, parameterSymbol, checker);
+        });
+    });
+};
+/**
+ * Narrows a function-like declaration to one with a body.
+ * @param declaration Candidate call signature declaration.
+ * @returns Whether the declaration has a function body.
+ * @example
+ * ```typescript
+ * if (hasFunctionBody(declaration)) inspect(declaration.body);
+ * ```
+ */
+const hasFunctionBody = (declaration) => declaration !== void 0 &&
+    "body" in declaration &&
+    declaration.body !== void 0;
+export { isLocalCallArgumentTransmitted };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-local-flow-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-local-flow-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { expressionReferencesSymbol } from \"./member-usage-expression-reference-utilities\";\nimport { isDeclarationOnlyMethod } from \"./member-usage-type-utilities\";\nimport { expressionCarriesMemberValue } from \"./member-usage-value-utilities\";\n\n/**\n * Checks whether a local call forwards a member-bearing value to an HTTP body.\n * @param node Candidate local call expression.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being transmitted.\n * @returns True when the argument reaches an opaque request body contract.\n * @example\n * ```typescript\n * const transmitted = isLocalCallArgumentTransmitted(call, checker, member);\n * ```\n */\nconst isLocalCallArgumentTransmitted = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (!ts.isCallExpression(node)) {\n    return false;\n  }\n\n  const declaration = checker.getResolvedSignature(node)?.getDeclaration();\n  if (!hasFunctionBody(declaration)) {\n    return false;\n  }\n\n  return node.arguments.some((argument, argumentIndex) => {\n    const parameter =\n      declaration.parameters[\n        Math.min(argumentIndex, declaration.parameters.length - 1)\n      ];\n    const parameterSymbol =\n      parameter === void 0 || !ts.isIdentifier(parameter.name)\n        ? void 0\n        : checker.getSymbolAtLocation(parameter.name);\n\n    const carries = expressionCarriesMemberValue(argument, checker, member);\n    const reachesBody =\n      parameterSymbol !== void 0 &&\n      localParameterReachesRequestBody(\n        declaration,\n        parameterSymbol,\n        checker,\n        new Map(),\n      );\n    return parameterSymbol !== void 0 && carries && reachesBody;\n  });\n};\n\n/**\n * Checks whether a local parameter reaches a declared HTTP request body.\n * @param declaration Local function containing the parameter.\n * @param parameterSymbol Parameter symbol whose value is traced.\n * @param checker TypeScript type checker.\n * @param visitedDeclarations Function declarations already inspected.\n * @returns True when the parameter reaches an opaque request body.\n * @example\n * ```typescript\n * const reachesBody = localParameterReachesRequestBody(\n *   declaration,\n *   parameterSymbol,\n *   checker,\n *   new Set(),\n * );\n * ```\n */\nconst localParameterReachesRequestBody = (\n  declaration: ts.SignatureDeclaration,\n  parameterSymbol: ts.Symbol,\n  checker: ts.TypeChecker,\n  visitedDeclarations: Map<ts.SignatureDeclaration, Set<ts.Symbol>>,\n): boolean => {\n  if (!hasFunctionBody(declaration)) {\n    return false;\n  }\n\n  const visitedParameters =\n    visitedDeclarations.get(declaration) ?? new Set<ts.Symbol>();\n  if (visitedParameters.has(parameterSymbol)) {\n    return false;\n  }\n  visitedParameters.add(parameterSymbol);\n  visitedDeclarations.set(declaration, visitedParameters);\n\n  const inspect = (node: ts.Node): true | undefined => {\n    if (ts.isCallExpression(node)) {\n      const isBody = isOpaqueRequestBodyHandoff(node, parameterSymbol, checker);\n      if (isBody) {\n        return true;\n      }\n\n      const nestedDeclaration = checker\n        .getResolvedSignature(node)\n        ?.getDeclaration();\n      if (hasFunctionBody(nestedDeclaration)) {\n        for (const [argumentIndex, argument] of node.arguments.entries()) {\n          const references = expressionReferencesSymbol(\n            argument,\n            parameterSymbol,\n            checker,\n          );\n          if (!references) {\n            continue;\n          }\n\n          const nestedParameter =\n            nestedDeclaration.parameters[\n              Math.min(argumentIndex, nestedDeclaration.parameters.length - 1)\n            ];\n          const nestedParameterSymbol =\n            nestedParameter === void 0 || !ts.isIdentifier(nestedParameter.name)\n              ? void 0\n              : checker.getSymbolAtLocation(nestedParameter.name);\n\n          if (\n            nestedParameterSymbol !== void 0 &&\n            localParameterReachesRequestBody(\n              nestedDeclaration,\n              nestedParameterSymbol,\n              checker,\n              visitedDeclarations,\n            )\n          ) {\n            return true;\n          }\n        }\n      }\n    }\n\n    return ts.forEachChild(node, inspect);\n  };\n\n  return inspect(declaration.body) === true;\n};\n\n/**\n * Checks whether a request call sends the traced parameter as opaque body data.\n * @param call Candidate call expression.\n * @param parameterSymbol Parameter symbol whose value is traced.\n * @param checker TypeScript type checker.\n * @returns True when a declaration-only request method accepts the value as body.\n * @example\n * ```typescript\n * const opaque = isOpaqueRequestBodyHandoff(call, parameterSymbol, checker);\n * ```\n */\nconst isOpaqueRequestBodyHandoff = (\n  call: ts.CallExpression,\n  parameterSymbol: ts.Symbol,\n  checker: ts.TypeChecker,\n): boolean => {\n  const declaration = checker.getResolvedSignature(call)?.getDeclaration();\n\n  if (\n    declaration === void 0 ||\n    !isDeclarationOnlyMethod(declaration) ||\n    !ts.isPropertyAccessExpression(call.expression) ||\n    call.expression.name.text !== \"request\"\n  ) {\n    return false;\n  }\n\n  return call.arguments.some((argument) => {\n    if (!ts.isObjectLiteralExpression(argument)) {\n      return false;\n    }\n\n    const optionsType = checker.getContextualType(argument);\n    const requestOptionsType =\n      optionsType === void 0 ? void 0 : checker.getNonNullableType(optionsType);\n    const bodyProperty =\n      requestOptionsType === void 0\n        ? void 0\n        : checker.getPropertyOfType(requestOptionsType, \"body\");\n    if (bodyProperty === void 0) {\n      return false;\n    }\n\n    const bodyType = checker.getTypeOfSymbolAtLocation(bodyProperty, argument);\n    if ((bodyType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0) {\n      return false;\n    }\n\n    return argument.properties.some((property) => {\n      return ts.isPropertyAssignment(property) &&\n        ts.isIdentifier(property.name) &&\n        property.name.text === \"body\"\n        ? expressionReferencesSymbol(\n            property.initializer,\n            parameterSymbol,\n            checker,\n          )\n        : ts.isShorthandPropertyAssignment(property) &&\n            property.name.text === \"body\" &&\n            expressionReferencesSymbol(property.name, parameterSymbol, checker);\n    });\n  });\n};\n\n/**\n * Narrows a function-like declaration to one with a body.\n * @param declaration Candidate call signature declaration.\n * @returns Whether the declaration has a function body.\n * @example\n * ```typescript\n * if (hasFunctionBody(declaration)) inspect(declaration.body);\n * ```\n */\nconst hasFunctionBody = (\n  declaration: ts.SignatureDeclaration | undefined,\n): declaration is ts.SignatureDeclaration & { body: ts.ConciseBody } =>\n  declaration !== void 0 &&\n  \"body\" in declaration &&\n  declaration.body !== void 0;\n\nexport { isLocalCallArgumentTransmitted };\n"]}

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

@@ -1 +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"}
+{"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;AA+DnE;;;;;;;;;;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,OAuCF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -1,5 +1,5 @@
 import * as ts from "typescript";
-import { isSameSymbol } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+import { isSameSymbol, resolveCanonicalSymbol, } 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.
@@ -24,9 +24,7 @@ const getPropertyAccess = (node, checker) => {
         ts.isObjectBindingPattern(parent.parent)) {
         const owner = parent.parent.parent;
         const sourceType = ts.isVariableDeclaration(owner)
-            ? owner.initializer === void 0
-                ? void 0
-                : checker.getTypeAtLocation(owner.initializer)
+            ? checker.getTypeAtLocation(owner.initializer ?? owner.name)
             : ts.isParameter(owner)
                 ? checker.getTypeAtLocation(owner)
                 : void 0;
@@ -94,6 +92,15 @@ const isComputedMemberRead = (node, checker, member, relatedSymbols) => {
     }
     const objectType = checker.getTypeAtLocation(node.expression);
     const keyType = checker.getTypeAtLocation(node.argumentExpression);
+    if ((keyType.flags & ts.TypeFlags.String) !== 0 &&
+        ts.isVariableDeclaration(member.hostDeclaration) &&
+        member.hostSymbol !== void 0) {
+        const accessedSymbol = checker.getSymbolAtLocation(node.expression);
+        if (accessedSymbol !== void 0 &&
+            isSameSymbol(resolveCanonicalSymbol(accessedSymbol, checker), resolveCanonicalSymbol(member.hostSymbol, checker))) {
+            return true;
+        }
+    }
     return getStringLiteralKeys(keyType).some((name) => {
         if (name !== member.memberName) {
             return false;
@@ -105,4 +112,4 @@ const isComputedMemberRead = (node, checker, member, relatedSymbols) => {
     });
 };
 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":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC,OAAO,EAAE,YAAY,EAAE,MAAM,yDAAyD,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAWzE;;;;;;;;;GASG;AACH,MAAM,iBAAiB,GAAG,CACxB,IAAa,EACb,OAAuB,EACY,EAAE;IACrC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAE3B,IAAI,EAAE,CAAC,0BAA0B,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAClE,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI;YACtB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,UAAU,CAAC;SACzD,CAAC;IACJ,CAAC;IAED,IACE,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAC3B,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,IAAI,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC;QACtD,EAAE,CAAC,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,EACxC,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QACnC,MAAM,UAAU,GAAG,EAAE,CAAC,qBAAqB,CAAC,KAAK,CAAC;YAChD,CAAC,CAAC,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC;gBAC5B,CAAC,CAAC,KAAK,CAAC;gBACR,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,WAAW,CAAC;YAChD,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;gBACrB,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC;gBAClC,CAAC,CAAC,KAAK,CAAC,CAAC;QACb,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,IAAI,CAAC;QAEpD,OAAO,UAAU,KAAK,KAAK,CAAC;YAC1B,CAAC,CAAC,KAAK,CAAC;YACR,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC;gBAC7D,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE;gBACrC,CAAC,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;IAED,OAAO,KAAK,CAAC,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,wBAAwB,GAAG,CAC/B,IAAa,EACb,OAAuB,EACvB,MAAoB,EACX,EAAE;IACX,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAEhD,OAAO,CACL,MAAM,KAAK,KAAK,CAAC;QACjB,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,UAAU;QACjC,wBAAwB,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAC7D,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,CAAC,IAAa,EAAY,EAAE;IACvD,IAAI,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO,CAAE,IAA6B,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC;QACpD,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,CAAE,IAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,oBAAoB,GAAG,CAC3B,IAAa,EACb,OAAuB,EACvB,MAAoB,EACpB,cAA2B,EAClB,EAAE;IACX,IAAI,CAAC,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9D,MAAM,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAEnE,OAAO,oBAAoB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACjD,IAAI,IAAI,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAE7D,OAAO,CACL,QAAQ,KAAK,KAAK,CAAC;YACnB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAC9D,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CACzD,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,CAAC","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"]}
+//# 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 {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} 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      ? checker.getTypeAtLocation(owner.initializer ?? owner.name)\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  if (\n    (keyType.flags & ts.TypeFlags.String) !== 0 &&\n    ts.isVariableDeclaration(member.hostDeclaration) &&\n    member.hostSymbol !== void 0\n  ) {\n    const accessedSymbol = checker.getSymbolAtLocation(node.expression);\n\n    if (\n      accessedSymbol !== void 0 &&\n      isSameSymbol(\n        resolveCanonicalSymbol(accessedSymbol, checker),\n        resolveCanonicalSymbol(member.hostSymbol, checker),\n      )\n    ) {\n      return true;\n    }\n  }\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-serialization-utilities.d.ts

@@ -0,0 +1,30 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether a local call serializes the value supplied to a parameter.
+ * @param node Candidate local call expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being consumed.
+ * @param program TypeScript project program.
+ * @returns True when the argument is traced into standard JSON serialization.
+ * @example
+ * ```typescript
+ * const used = isLocalCallArgumentSerialized(node, checker, member, program);
+ * ```
+ */
+declare const isLocalCallArgumentSerialized: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember, program: ts.Program) => boolean;
+/**
+ * Checks whether an operation copies or serializes a member-bearing value.
+ * @param node Candidate spread or call expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being consumed.
+ * @param program TypeScript program used to identify standard library declarations.
+ * @returns True when the operation consumes the object's own properties.
+ * @example
+ * ```typescript
+ * const used = isWholeObjectRead(node, checker, member, program);
+ * ```
+ */
+declare const isWholeObjectRead: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember, program: ts.Program) => boolean;
+export { isLocalCallArgumentSerialized, isWholeObjectRead };
+//# sourceMappingURL=member-usage-serialization-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-serialization-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-serialization-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AASnE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,6BAA6B,GACjC,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,OAAO,KAClB,OAsDF,CAAC;AAmCF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB,GACrB,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,OAAO,KAClB,OA8BF,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,iBAAiB,EAAE,CAAC"}

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

@@ -0,0 +1,107 @@
+import * as ts from "typescript";
+import { expressionReferencesSymbol } from "./member-usage-expression-reference-utilities.js";
+import { carriesMember, containsSerializedMember, expressionCarriesMemberValue, } from "./member-usage-value-utilities.js";
+/**
+ * Checks whether a local call serializes the value supplied to a parameter.
+ * @param node Candidate local call expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being consumed.
+ * @param program TypeScript project program.
+ * @returns True when the argument is traced into standard JSON serialization.
+ * @example
+ * ```typescript
+ * const used = isLocalCallArgumentSerialized(node, checker, member, program);
+ * ```
+ */
+const isLocalCallArgumentSerialized = (node, checker, member, program) => {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+    const declaration = checker.getResolvedSignature(node)?.getDeclaration();
+    if (declaration === void 0 ||
+        !("body" in declaration) ||
+        declaration.body === void 0 ||
+        !ts.isBlock(declaration.body) ||
+        declaration.parameters.length === 0) {
+        return false;
+    }
+    const body = declaration.body;
+    return node.arguments.some((argument, argumentIndex) => {
+        const parameter = declaration.parameters[Math.min(argumentIndex, declaration.parameters.length - 1)];
+        const parameterSymbol = parameter === void 0 || !ts.isIdentifier(parameter.name)
+            ? void 0
+            : checker.getSymbolAtLocation(parameter.name);
+        if (parameterSymbol === void 0 ||
+            !expressionCarriesMemberValue(argument, checker, member)) {
+            return false;
+        }
+        const isSerializedParameter = (candidate) => {
+            if (candidate !== declaration && ts.isFunctionLike(candidate)) {
+                return void 0;
+            }
+            return ts.isCallExpression(candidate) &&
+                isStandardJsonStringifyCall(candidate, checker, program) &&
+                candidate.arguments.length === 1 &&
+                candidate.arguments[0] !== void 0 &&
+                expressionReferencesSymbol(candidate.arguments[0], parameterSymbol, checker)
+                ? true
+                : ts.forEachChild(candidate, isSerializedParameter);
+        };
+        return isSerializedParameter(body) === true;
+    });
+};
+/**
+ * Checks whether a call resolves to standard-library JSON.stringify.
+ * @param node Candidate call expression.
+ * @param checker TypeScript type checker.
+ * @param program TypeScript project used to identify standard declarations.
+ * @returns True when the call is the standard JSON serializer.
+ * @example
+ * ```typescript
+ * const isJson = isStandardJsonStringifyCall(node, checker, program);
+ * ```
+ */
+const isStandardJsonStringifyCall = (node, checker, program) => {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+    const declaration = checker.getResolvedSignature(node)?.getDeclaration();
+    return (declaration !== void 0 &&
+        ts.isMethodSignature(declaration) &&
+        ts.isIdentifier(declaration.name) &&
+        declaration.name.text === "stringify" &&
+        ts.isInterfaceDeclaration(declaration.parent) &&
+        declaration.parent.name.text === "JSON" &&
+        program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+};
+/**
+ * Checks whether an operation copies or serializes a member-bearing value.
+ * @param node Candidate spread or call expression.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being consumed.
+ * @param program TypeScript program used to identify standard library declarations.
+ * @returns True when the operation consumes the object's own properties.
+ * @example
+ * ```typescript
+ * const used = isWholeObjectRead(node, checker, member, program);
+ * ```
+ */
+const isWholeObjectRead = (node, checker, member, program) => {
+    if (ts.isClassDeclaration(member.hostDeclaration) &&
+        !ts.isPropertyDeclaration(member.declaration)) {
+        return false;
+    }
+    if (ts.isSpreadAssignment(node)) {
+        return carriesMember(node.expression, checker, member);
+    }
+    if (!ts.isCallExpression(node) || node.arguments.length !== 1) {
+        return false;
+    }
+    const argument = node.arguments[0];
+    return (isStandardJsonStringifyCall(node, checker, program) &&
+        argument !== void 0 &&
+        (carriesMember(argument, checker, member) ||
+            containsSerializedMember(checker.getTypeAtLocation(argument), checker, member, new Set(), 5)));
+};
+export { isLocalCallArgumentSerialized, isWholeObjectRead };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-serialization-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-serialization-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { expressionReferencesSymbol } from \"./member-usage-expression-reference-utilities\";\nimport {\n  carriesMember,\n  containsSerializedMember,\n  expressionCarriesMemberValue,\n} from \"./member-usage-value-utilities\";\n\n/**\n * Checks whether a local call serializes the value supplied to a parameter.\n * @param node Candidate local call expression.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being consumed.\n * @param program TypeScript project program.\n * @returns True when the argument is traced into standard JSON serialization.\n * @example\n * ```typescript\n * const used = isLocalCallArgumentSerialized(node, checker, member, program);\n * ```\n */\nconst isLocalCallArgumentSerialized = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  program: ts.Program,\n): boolean => {\n  if (!ts.isCallExpression(node)) {\n    return false;\n  }\n\n  const declaration = checker.getResolvedSignature(node)?.getDeclaration();\n  if (\n    declaration === void 0 ||\n    !(\"body\" in declaration) ||\n    declaration.body === void 0 ||\n    !ts.isBlock(declaration.body) ||\n    declaration.parameters.length === 0\n  ) {\n    return false;\n  }\n  const body = declaration.body;\n\n  return node.arguments.some((argument, argumentIndex) => {\n    const parameter =\n      declaration.parameters[\n        Math.min(argumentIndex, declaration.parameters.length - 1)\n      ];\n    const parameterSymbol =\n      parameter === void 0 || !ts.isIdentifier(parameter.name)\n        ? void 0\n        : checker.getSymbolAtLocation(parameter.name);\n\n    if (\n      parameterSymbol === void 0 ||\n      !expressionCarriesMemberValue(argument, checker, member)\n    ) {\n      return false;\n    }\n\n    const isSerializedParameter = (candidate: ts.Node): true | undefined => {\n      if (candidate !== declaration && ts.isFunctionLike(candidate)) {\n        return void 0;\n      }\n\n      return ts.isCallExpression(candidate) &&\n        isStandardJsonStringifyCall(candidate, checker, program) &&\n        candidate.arguments.length === 1 &&\n        candidate.arguments[0] !== void 0 &&\n        expressionReferencesSymbol(\n          candidate.arguments[0],\n          parameterSymbol,\n          checker,\n        )\n        ? true\n        : ts.forEachChild(candidate, isSerializedParameter);\n    };\n\n    return isSerializedParameter(body) === true;\n  });\n};\n\n/**\n * Checks whether a call resolves to standard-library JSON.stringify.\n * @param node Candidate call expression.\n * @param checker TypeScript type checker.\n * @param program TypeScript project used to identify standard declarations.\n * @returns True when the call is the standard JSON serializer.\n * @example\n * ```typescript\n * const isJson = isStandardJsonStringifyCall(node, checker, program);\n * ```\n */\nconst isStandardJsonStringifyCall = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  program: ts.Program,\n): boolean => {\n  if (!ts.isCallExpression(node)) {\n    return false;\n  }\n\n  const declaration = checker.getResolvedSignature(node)?.getDeclaration();\n\n  return (\n    declaration !== void 0 &&\n    ts.isMethodSignature(declaration) &&\n    ts.isIdentifier(declaration.name) &&\n    declaration.name.text === \"stringify\" &&\n    ts.isInterfaceDeclaration(declaration.parent) &&\n    declaration.parent.name.text === \"JSON\" &&\n    program.isSourceFileDefaultLibrary(declaration.getSourceFile())\n  );\n};\n\n/**\n * Checks whether an operation copies or serializes a member-bearing value.\n * @param node Candidate spread or call expression.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being consumed.\n * @param program TypeScript program used to identify standard library declarations.\n * @returns True when the operation consumes the object's own properties.\n * @example\n * ```typescript\n * const used = isWholeObjectRead(node, checker, member, program);\n * ```\n */\nconst isWholeObjectRead = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  program: ts.Program,\n): boolean => {\n  if (\n    ts.isClassDeclaration(member.hostDeclaration) &&\n    !ts.isPropertyDeclaration(member.declaration)\n  ) {\n    return false;\n  }\n\n  if (ts.isSpreadAssignment(node)) {\n    return carriesMember(node.expression, checker, member);\n  }\n\n  if (!ts.isCallExpression(node) || node.arguments.length !== 1) {\n    return false;\n  }\n\n  const argument = node.arguments[0];\n\n  return (\n    isStandardJsonStringifyCall(node, checker, program) &&\n    argument !== void 0 &&\n    (carriesMember(argument, checker, member) ||\n      containsSerializedMember(\n        checker.getTypeAtLocation(argument),\n        checker,\n        member,\n        new Set(),\n        5,\n      ))\n  );\n};\n\nexport { isLocalCallArgumentSerialized, isWholeObjectRead };\n"]}

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

@@ -25,18 +25,40 @@ declare const hasCompatibleMemberShape: (valueType: ts.Type, member: PublicMembe
  * ```
  */
 declare const getContextualPropertyType: (objectType: ts.Type | undefined, propertyName: string, location: ts.Node, checker: ts.TypeChecker) => ts.Type | undefined;
+/**
+ * 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);
+ * ```
+ */
+declare const getCallArgumentType: (call: ts.CallExpression, argument: ts.Expression, checker: ts.TypeChecker) => ts.Type | undefined;
+/**
+ * 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);
+ * ```
+ */
+declare const isDeclarationOnlyMethod: (declaration: ts.Node) => boolean;
 /**
  * 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);
  * ```
  */
-declare const isMemberHandoff: (sourceType: ts.Type | undefined, targetType: ts.Type | undefined, member: PublicMember, checker: ts.TypeChecker) => boolean;
-export { getContextualPropertyType, hasCompatibleMemberShape, isMemberHandoff };
+declare const isMemberHandoff: (sourceExpression: ts.Expression, targetType: ts.Type | undefined, member: PublicMember, checker: ts.TypeChecker) => boolean;
+export { getCallArgumentType, getContextualPropertyType, hasCompatibleMemberShape, isDeclarationOnlyMethod, isMemberHandoff, };
 //# sourceMappingURL=member-usage-type-utilities.d.ts.map

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

@@ -1 +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"}
+{"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;AA0BnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,WAAW,EAAE,CAAC,IAAI,EAClB,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,WAAW,KACtB,OAgBF,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;;;;;;;;;;GAUG;AACH,QAAA,MAAM,mBAAmB,GACvB,MAAM,EAAE,CAAC,cAAc,EACvB,UAAU,EAAE,CAAC,UAAU,EACvB,SAAS,EAAE,CAAC,WAAW,KACtB,EAAE,CAAC,IAAI,GAAG,SAeZ,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAAI,aAAa,EAAE,CAAC,IAAI,KAAG,OAIc,CAAC;AAyBvE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,kBAAkB,EAAE,CAAC,UAAU,EAC/B,YAAY,EAAE,CAAC,IAAI,GAAG,SAAS,EAC/B,QAAQ,YAAY,EACpB,SAAS,EAAE,CAAC,WAAW,KACtB,OAgDF,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,GAChB,CAAC"}