@codeperfect/eslint-plugin 3.0.0 → 3.2.0

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

@@ -0,0 +1,151 @@
+import * as ts from "typescript";
+import { getCallArgumentType, getContextualPropertyType, isDeclarationOnlyMethod, isMemberHandoff, } from "./member-usage-type-utilities.js";
+import { expressionCarriesMemberValue } from "./member-usage-value-utilities.js";
+/**
+ * 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 opaque value property is passed to a method contract.
+ * @param objectLiteral Object literal passed to the method.
+ * @param propertyName Property carrying the value.
+ * @param valueExpression Value assigned to the property.
+ * @param objectType Contextual type of the object literal.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being handed off.
+ * @returns True when a declaration-only method receives the member as opaque data.
+ * @example
+ * ```typescript
+ * const handedOff = isOpaqueMethodContractHandoff(
+ *   objectLiteral,
+ *   "payload",
+ *   value,
+ *   type,
+ *   checker,
+ *   member,
+ * );
+ * ```
+ */
+const isOpaqueMethodContractHandoff = (objectLiteral, propertyName, valueExpression, objectType, checker, member) => {
+    const call = objectLiteral.parent;
+    const declaration = ts.isCallExpression(call)
+        ? checker.getResolvedSignature(call)?.getDeclaration()
+        : void 0;
+    if (!ts.isCallExpression(call) ||
+        !call.arguments.includes(objectLiteral) ||
+        declaration === void 0 ||
+        !isDeclarationOnlyMethod(declaration)) {
+        return false;
+    }
+    const targetType = getContextualPropertyType(objectType, propertyName, objectLiteral, checker);
+    const isHttpRequestBody = propertyName === "body" &&
+        ts.isPropertyAccessExpression(call.expression) &&
+        call.expression.name.text === "request";
+    return (targetType !== void 0 &&
+        ((targetType.flags & ts.TypeFlags.Unknown) !== 0 ||
+            (isHttpRequestBody && (targetType.flags & ts.TypeFlags.Any) !== 0)) &&
+        expressionCarriesMemberValue(valueExpression, checker, member));
+};
+/**
+ * Checks whether a value is supplied to a typed external call boundary.
+ * @param node Candidate call expression.
+ * @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.isCallExpression(node) || hasCallImplementation(node, checker)) {
+        return false;
+    }
+    const declaration = checker.getResolvedSignature(node)?.getDeclaration();
+    return (declaration !== void 0 &&
+        node.arguments.some((argument) => {
+            const argumentType = getCallArgumentType(node, argument, checker);
+            const isOpaqueJsonBody = isDeclarationOnlyMethod(declaration) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === "json" &&
+                node.arguments[0] === argument &&
+                argumentType !== void 0 &&
+                (argumentType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
+            return ((isOpaqueJsonBody &&
+                expressionCarriesMemberValue(argument, checker, member)) ||
+                isMemberHandoff(argument, argumentType, 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 (isOpaqueMethodContractHandoff(node.parent, name.text, node.initializer, objectType, checker, member)) {
+            return true;
+        }
+        if (!isExternalPropertyContract(objectType, name.text, checker)) {
+            return false;
+        }
+        const targetType = getContextualPropertyType(objectType, name.text, node, checker);
+        return isMemberHandoff(node.initializer, targetType, member, checker);
+    }
+    if (ts.isShorthandPropertyAssignment(node) &&
+        ts.isObjectLiteralExpression(node.parent)) {
+        const objectType = checker.getContextualType(node.parent);
+        if (isOpaqueMethodContractHandoff(node.parent, node.name.text, node.name, objectType, checker, member)) {
+            return true;
+        }
+        if (!isExternalPropertyContract(objectType, node.name.text, checker)) {
+            return false;
+        }
+        const targetType = getContextualPropertyType(objectType, node.name.text, node, checker);
+        return isMemberHandoff(node.name, 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  getCallArgumentType,\n  getContextualPropertyType,\n  isDeclarationOnlyMethod,\n  isMemberHandoff,\n} from \"./member-usage-type-utilities\";\nimport { expressionCarriesMemberValue } from \"./member-usage-value-utilities\";\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 opaque value property is passed to a method contract.\n * @param objectLiteral Object literal passed to the method.\n * @param propertyName Property carrying the value.\n * @param valueExpression Value assigned to the property.\n * @param objectType Contextual type of the object literal.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being handed off.\n * @returns True when a declaration-only method receives the member as opaque data.\n * @example\n * ```typescript\n * const handedOff = isOpaqueMethodContractHandoff(\n *   objectLiteral,\n *   \"payload\",\n *   value,\n *   type,\n *   checker,\n *   member,\n * );\n * ```\n */\nconst isOpaqueMethodContractHandoff = (\n  objectLiteral: ts.ObjectLiteralExpression,\n  propertyName: string,\n  valueExpression: ts.Expression,\n  objectType: ts.Type | undefined,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  const call = objectLiteral.parent;\n  const declaration = ts.isCallExpression(call)\n    ? checker.getResolvedSignature(call)?.getDeclaration()\n    : void 0;\n\n  if (\n    !ts.isCallExpression(call) ||\n    !call.arguments.includes(objectLiteral) ||\n    declaration === void 0 ||\n    !isDeclarationOnlyMethod(declaration)\n  ) {\n    return false;\n  }\n\n  const targetType = getContextualPropertyType(\n    objectType,\n    propertyName,\n    objectLiteral,\n    checker,\n  );\n  const isHttpRequestBody =\n    propertyName === \"body\" &&\n    ts.isPropertyAccessExpression(call.expression) &&\n    call.expression.name.text === \"request\";\n\n  return (\n    targetType !== void 0 &&\n    ((targetType.flags & ts.TypeFlags.Unknown) !== 0 ||\n      (isHttpRequestBody && (targetType.flags & ts.TypeFlags.Any) !== 0)) &&\n    expressionCarriesMemberValue(valueExpression, checker, member)\n  );\n};\n\n/**\n * Checks whether a value is supplied to a typed external call boundary.\n * @param node Candidate call expression.\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 (!ts.isCallExpression(node) || hasCallImplementation(node, checker)) {\n    return false;\n  }\n\n  const declaration = checker.getResolvedSignature(node)?.getDeclaration();\n\n  return (\n    declaration !== void 0 &&\n    node.arguments.some((argument) => {\n      const argumentType = getCallArgumentType(node, argument, checker);\n      const isOpaqueJsonBody =\n        isDeclarationOnlyMethod(declaration) &&\n        ts.isPropertyAccessExpression(node.expression) &&\n        node.expression.name.text === \"json\" &&\n        node.arguments[0] === argument &&\n        argumentType !== void 0 &&\n        (argumentType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;\n\n      return (\n        (isOpaqueJsonBody &&\n          expressionCarriesMemberValue(argument, checker, member)) ||\n        isMemberHandoff(argument, argumentType, member, checker)\n      );\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 (\n      isOpaqueMethodContractHandoff(\n        node.parent,\n        name.text,\n        node.initializer,\n        objectType,\n        checker,\n        member,\n      )\n    ) {\n      return true;\n    }\n\n    if (!isExternalPropertyContract(objectType, name.text, checker)) {\n      return false;\n    }\n\n    const targetType = getContextualPropertyType(\n      objectType,\n      name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(node.initializer, 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 (\n      isOpaqueMethodContractHandoff(\n        node.parent,\n        node.name.text,\n        node.name,\n        objectType,\n        checker,\n        member,\n      )\n    ) {\n      return true;\n    }\n\n    if (!isExternalPropertyContract(objectType, node.name.text, checker)) {\n      return false;\n    }\n\n    const targetType = getContextualPropertyType(\n      objectType,\n      node.name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(node.name, targetType, member, checker);\n  }\n\n  return false;\n};\n\nexport { isCallArgumentMember, isObjectContractHandoff };\n"]}

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

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-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);
+ * ```
+ */
+declare const isLocalCallArgumentTransmitted: (node: ts.Node, checker: ts.TypeChecker, member: PublicMember) => boolean;
+export { isLocalCallArgumentTransmitted };
+//# sourceMappingURL=member-usage-local-flow-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-local-flow-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-local-flow-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAMnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,8BAA8B,GAClC,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,YAAY,KACnB,OA+BF,CAAC;AAwKF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

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

@@ -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;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

@@ -0,0 +1,115 @@
+import * as ts from "typescript";
+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.
+ * @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)
+            ? checker.getTypeAtLocation(owner.initializer ?? owner.name)
+            : 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);
+    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;
+        }
+        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 {\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"}