@codeperfect/eslint-plugin 3.1.0 → 3.2.0

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

@@ -1 +1 @@
-{"version":3,"file":"member-public-api-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-public-api-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AA2DvE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB,GACrB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,cAAc,EAAE,CAAC,MAAM,KACtB,OA6CF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,YAAY,EAAE,CAAC,MAAM,GAAG,SAAS,KAChC,OAsBF,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"member-public-api-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-public-api-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAwEvE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB,GACrB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,cAAc,EAAE,CAAC,MAAM,KACtB,OAsDF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,YAAY,EAAE,CAAC,MAAM,GAAG,SAAS,KAChC,OAsBF,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,CAAC"}

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

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

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

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+/**
+ * Checks whether an expression can be traced back to a symbol.
+ * @param expression Expression to inspect.
+ * @param targetSymbol Symbol whose value flow is followed.
+ * @param checker TypeScript type checker.
+ * @param visitedExpressions Expressions already inspected.
+ * @returns True when the expression derives from the target symbol.
+ * @example
+ * ```typescript
+ * const forwarded = expressionReferencesSymbol(value, symbol, checker);
+ * ```
+ */
+declare const expressionReferencesSymbol: (expression: ts.Expression, targetSymbol: ts.Symbol, checker: ts.TypeChecker, visitedExpressions?: Set<ts.Node>) => boolean;
+export { expressionReferencesSymbol };
+//# sourceMappingURL=member-usage-expression-reference-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-expression-reference-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-expression-reference-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAOjC;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,0BAA0B,GAC9B,YAAY,EAAE,CAAC,UAAU,EACzB,cAAc,EAAE,CAAC,MAAM,EACvB,SAAS,EAAE,CAAC,WAAW,EACvB,qBAAoB,GAAG,CAAC,EAAE,CAAC,IAAI,CAAa,KAC3C,OAyJF,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,77 @@
+import * as ts from "typescript";
+import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+/**
+ * Checks whether an expression can be traced back to a symbol.
+ * @param expression Expression to inspect.
+ * @param targetSymbol Symbol whose value flow is followed.
+ * @param checker TypeScript type checker.
+ * @param visitedExpressions Expressions already inspected.
+ * @returns True when the expression derives from the target symbol.
+ * @example
+ * ```typescript
+ * const forwarded = expressionReferencesSymbol(value, symbol, checker);
+ * ```
+ */
+const expressionReferencesSymbol = (expression, targetSymbol, checker, visitedExpressions = new Set()) => {
+    if (visitedExpressions.has(expression)) {
+        return false;
+    }
+    visitedExpressions.add(expression);
+    if (ts.isIdentifier(expression)) {
+        const symbol = ts.isShorthandPropertyAssignment(expression.parent)
+            ? checker.getShorthandAssignmentValueSymbol(expression.parent)
+            : checker.getSymbolAtLocation(expression);
+        if (symbol !== void 0 &&
+            isSameSymbol(resolveCanonicalSymbol(symbol, checker), resolveCanonicalSymbol(targetSymbol, checker))) {
+            return true;
+        }
+        const declaration = symbol?.valueDeclaration;
+        if (declaration !== void 0 && ts.isVariableDeclaration(declaration)) {
+            return (declaration.initializer !== void 0 &&
+                expressionReferencesSymbol(declaration.initializer, targetSymbol, checker, visitedExpressions));
+        }
+        if (declaration !== void 0 &&
+            ts.isBindingElement(declaration) &&
+            ts.isObjectBindingPattern(declaration.parent)) {
+            const owner = declaration.parent.parent;
+            return (ts.isVariableDeclaration(owner) &&
+                owner.initializer !== void 0 &&
+                expressionReferencesSymbol(owner.initializer, targetSymbol, checker, visitedExpressions));
+        }
+        return false;
+    }
+    if (ts.isAsExpression(expression) ||
+        ts.isNonNullExpression(expression) ||
+        ts.isParenthesizedExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isTypeAssertionExpression(expression)) {
+        return expressionReferencesSymbol(expression.expression, targetSymbol, checker, visitedExpressions);
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        return expressionReferencesSymbol(expression.expression, targetSymbol, checker, visitedExpressions);
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        return expressionReferencesSymbol(expression.expression, targetSymbol, checker, visitedExpressions);
+    }
+    if (ts.isCallExpression(expression)) {
+        return expression.arguments.some((argument) => expressionReferencesSymbol(argument, targetSymbol, checker, visitedExpressions));
+    }
+    if (ts.isConditionalExpression(expression)) {
+        return (expressionReferencesSymbol(expression.whenTrue, targetSymbol, checker, visitedExpressions) ||
+            expressionReferencesSymbol(expression.whenFalse, targetSymbol, checker, visitedExpressions));
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        return expression.properties.some((property) => {
+            return ts.isSpreadAssignment(property)
+                ? expressionReferencesSymbol(property.expression, targetSymbol, checker, visitedExpressions)
+                : (ts.isPropertyAssignment(property) &&
+                    expressionReferencesSymbol(property.initializer, targetSymbol, checker, visitedExpressions)) ||
+                    (ts.isShorthandPropertyAssignment(property) &&
+                        expressionReferencesSymbol(property.name, targetSymbol, checker, visitedExpressions));
+        });
+    }
+    return (ts.isArrayLiteralExpression(expression) &&
+        expression.elements.some((element) => expressionReferencesSymbol(element, targetSymbol, checker, visitedExpressions)));
+};
+export { expressionReferencesSymbol };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-expression-reference-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-expression-reference-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\n\n/**\n * Checks whether an expression can be traced back to a symbol.\n * @param expression Expression to inspect.\n * @param targetSymbol Symbol whose value flow is followed.\n * @param checker TypeScript type checker.\n * @param visitedExpressions Expressions already inspected.\n * @returns True when the expression derives from the target symbol.\n * @example\n * ```typescript\n * const forwarded = expressionReferencesSymbol(value, symbol, checker);\n * ```\n */\nconst expressionReferencesSymbol = (\n  expression: ts.Expression,\n  targetSymbol: ts.Symbol,\n  checker: ts.TypeChecker,\n  visitedExpressions: Set<ts.Node> = new Set(),\n): boolean => {\n  if (visitedExpressions.has(expression)) {\n    return false;\n  }\n  visitedExpressions.add(expression);\n\n  if (ts.isIdentifier(expression)) {\n    const symbol = ts.isShorthandPropertyAssignment(expression.parent)\n      ? checker.getShorthandAssignmentValueSymbol(expression.parent)\n      : checker.getSymbolAtLocation(expression);\n\n    if (\n      symbol !== void 0 &&\n      isSameSymbol(\n        resolveCanonicalSymbol(symbol, checker),\n        resolveCanonicalSymbol(targetSymbol, checker),\n      )\n    ) {\n      return true;\n    }\n\n    const declaration = symbol?.valueDeclaration;\n    if (declaration !== void 0 && ts.isVariableDeclaration(declaration)) {\n      return (\n        declaration.initializer !== void 0 &&\n        expressionReferencesSymbol(\n          declaration.initializer,\n          targetSymbol,\n          checker,\n          visitedExpressions,\n        )\n      );\n    }\n    if (\n      declaration !== void 0 &&\n      ts.isBindingElement(declaration) &&\n      ts.isObjectBindingPattern(declaration.parent)\n    ) {\n      const owner = declaration.parent.parent;\n\n      return (\n        ts.isVariableDeclaration(owner) &&\n        owner.initializer !== void 0 &&\n        expressionReferencesSymbol(\n          owner.initializer,\n          targetSymbol,\n          checker,\n          visitedExpressions,\n        )\n      );\n    }\n\n    return false;\n  }\n\n  if (\n    ts.isAsExpression(expression) ||\n    ts.isNonNullExpression(expression) ||\n    ts.isParenthesizedExpression(expression) ||\n    ts.isSatisfiesExpression(expression) ||\n    ts.isTypeAssertionExpression(expression)\n  ) {\n    return expressionReferencesSymbol(\n      expression.expression,\n      targetSymbol,\n      checker,\n      visitedExpressions,\n    );\n  }\n\n  if (ts.isPropertyAccessExpression(expression)) {\n    return expressionReferencesSymbol(\n      expression.expression,\n      targetSymbol,\n      checker,\n      visitedExpressions,\n    );\n  }\n\n  if (ts.isElementAccessExpression(expression)) {\n    return expressionReferencesSymbol(\n      expression.expression,\n      targetSymbol,\n      checker,\n      visitedExpressions,\n    );\n  }\n\n  if (ts.isCallExpression(expression)) {\n    return expression.arguments.some((argument) =>\n      expressionReferencesSymbol(\n        argument,\n        targetSymbol,\n        checker,\n        visitedExpressions,\n      ),\n    );\n  }\n\n  if (ts.isConditionalExpression(expression)) {\n    return (\n      expressionReferencesSymbol(\n        expression.whenTrue,\n        targetSymbol,\n        checker,\n        visitedExpressions,\n      ) ||\n      expressionReferencesSymbol(\n        expression.whenFalse,\n        targetSymbol,\n        checker,\n        visitedExpressions,\n      )\n    );\n  }\n\n  if (ts.isObjectLiteralExpression(expression)) {\n    return expression.properties.some((property) => {\n      return ts.isSpreadAssignment(property)\n        ? expressionReferencesSymbol(\n            property.expression,\n            targetSymbol,\n            checker,\n            visitedExpressions,\n          )\n        : (ts.isPropertyAssignment(property) &&\n            expressionReferencesSymbol(\n              property.initializer,\n              targetSymbol,\n              checker,\n              visitedExpressions,\n            )) ||\n            (ts.isShorthandPropertyAssignment(property) &&\n              expressionReferencesSymbol(\n                property.name,\n                targetSymbol,\n                checker,\n                visitedExpressions,\n              ));\n    });\n  }\n\n  return (\n    ts.isArrayLiteralExpression(expression) &&\n    expression.elements.some((element) =>\n      expressionReferencesSymbol(\n        element,\n        targetSymbol,\n        checker,\n        visitedExpressions,\n      ),\n    )\n  );\n};\n\nexport { expressionReferencesSymbol };\n"]}

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

@@ -1,8 +1,8 @@
 import * as ts from "typescript";
 import type { PublicMember } from "./member-declaration-utilities.js";
 /**
- * Checks whether an object property is supplied to a typed call boundary.
- * @param node Candidate property assignment.
+ * 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.

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

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

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

@@ -1,28 +1,6 @@
 import * as ts from "typescript";
-import { getContextualPropertyType, isMemberHandoff, } from "./member-usage-type-utilities.js";
-/**
- * Finds a call argument's resolved parameter type.
- * @param call Call expression containing the argument.
- * @param argument Argument expression to inspect.
- * @param checker TypeScript type checker.
- * @returns Parameter type when TypeScript resolves the call.
- * @example
- * ```typescript
- * const parameterType = getCallArgumentType(call, argument, checker);
- * ```
- */
-const getCallArgumentType = (call, argument, checker) => {
-    const contextualType = checker.getContextualType(argument);
-    if (contextualType !== void 0) {
-        return contextualType;
-    }
-    const argumentIndex = call.arguments.indexOf(argument);
-    const signature = checker.getResolvedSignature(call);
-    const parameter = signature === void 0 ? void 0 : signature.parameters[argumentIndex];
-    return parameter === void 0
-        ? void 0
-        : checker.getTypeOfSymbolAtLocation(parameter, call);
-};
+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.
@@ -57,8 +35,49 @@ const hasCallImplementation = (call, checker) => {
         declaration.body !== void 0);
 };
 /**
- * Checks whether an object property is supplied to a typed call boundary.
- * @param node Candidate property assignment.
+ * 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.
@@ -68,20 +87,23 @@ const hasCallImplementation = (call, checker) => {
  * ```
  */
 const isCallArgumentMember = (node, checker, member) => {
-    if (!ts.isPropertyAssignment(node) ||
-        (!ts.isIdentifier(node.name) && !ts.isStringLiteralLike(node.name)) ||
-        !ts.isObjectLiteralExpression(node.parent)) {
+    if (!ts.isCallExpression(node) || hasCallImplementation(node, checker)) {
         return false;
     }
-    const call = node.parent.parent;
-    if (!ts.isCallExpression(call) ||
-        hasCallImplementation(call, checker) ||
-        !call.arguments.some((argument) => argument === node.parent)) {
-        return false;
-    }
-    const targetType = getCallArgumentType(call, node.parent, checker);
-    return (node.name.text === member.memberName &&
-        isMemberHandoff(checker.getTypeAtLocation(node.parent), targetType, member, checker));
+    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.
@@ -102,24 +124,28 @@ const isObjectContractHandoff = (node, checker, member) => {
             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 sourceType = checker.getTypeAtLocation(node.initializer);
         const targetType = getContextualPropertyType(objectType, name.text, node, checker);
-        return isMemberHandoff(sourceType, targetType, member, 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 sourceType = checker.getTypeAtLocation(node.name);
         const targetType = getContextualPropertyType(objectType, node.name.text, node, checker);
-        return isMemberHandoff(sourceType, targetType, member, 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  getContextualPropertyType,\n  isMemberHandoff,\n} from \"./member-usage-type-utilities\";\n\n/**\n * Finds a call argument's resolved parameter type.\n * @param call Call expression containing the argument.\n * @param argument Argument expression to inspect.\n * @param checker TypeScript type checker.\n * @returns Parameter type when TypeScript resolves the call.\n * @example\n * ```typescript\n * const parameterType = getCallArgumentType(call, argument, checker);\n * ```\n */\nconst getCallArgumentType = (\n  call: ts.CallExpression,\n  argument: ts.Expression,\n  checker: ts.TypeChecker,\n): ts.Type | undefined => {\n  const contextualType = checker.getContextualType(argument);\n\n  if (contextualType !== void 0) {\n    return contextualType;\n  }\n\n  const argumentIndex = call.arguments.indexOf(argument);\n  const signature = checker.getResolvedSignature(call);\n  const parameter =\n    signature === void 0 ? void 0 : signature.parameters[argumentIndex];\n\n  return parameter === void 0\n    ? void 0\n    : checker.getTypeOfSymbolAtLocation(parameter, call);\n};\n\n/**\n * Checks whether a contextual property comes from an external declaration.\n * @param objectType Contextual type of the containing object literal.\n * @param propertyName Property name in the object literal.\n * @param checker TypeScript type checker.\n * @returns True when the contract is declared outside the project source.\n * @example\n * ```typescript\n * const external = isExternalPropertyContract(objectType, \"docs\", checker);\n * ```\n */\nconst isExternalPropertyContract = (\n  objectType: ts.Type | undefined,\n  propertyName: string,\n  checker: ts.TypeChecker,\n): boolean => {\n  const property =\n    objectType === void 0\n      ? void 0\n      : checker.getPropertyOfType(objectType, propertyName);\n\n  return (\n    property?.declarations?.some(\n      (declaration) => declaration.getSourceFile().isDeclarationFile,\n    ) ?? false\n  );\n};\n\n/**\n * Checks whether a call resolves to a declaration with a local implementation.\n * @param call Call expression to inspect.\n * @param checker TypeScript type checker.\n * @returns True when the resolved declaration has a body.\n * @example\n * ```typescript\n * const implemented = hasCallImplementation(call, checker);\n * ```\n */\nconst hasCallImplementation = (\n  call: ts.CallExpression,\n  checker: ts.TypeChecker,\n): boolean => {\n  const declaration = checker.getResolvedSignature(call)?.getDeclaration();\n\n  return (\n    declaration !== void 0 &&\n    \"body\" in declaration &&\n    declaration.body !== void 0\n  );\n};\n\n/**\n * Checks whether an object property is supplied to a typed call boundary.\n * @param node Candidate property assignment.\n * @param checker TypeScript type checker.\n * @param member Member whose usage is being checked.\n * @returns True when an external call contract accepts the member shape.\n * @example\n * ```typescript\n * const used = isCallArgumentMember(node, checker, member);\n * ```\n */\nconst isCallArgumentMember = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    !ts.isPropertyAssignment(node) ||\n    (!ts.isIdentifier(node.name) && !ts.isStringLiteralLike(node.name)) ||\n    !ts.isObjectLiteralExpression(node.parent)\n  ) {\n    return false;\n  }\n\n  const call = node.parent.parent;\n\n  if (\n    !ts.isCallExpression(call) ||\n    hasCallImplementation(call, checker) ||\n    !call.arguments.some((argument) => argument === node.parent)\n  ) {\n    return false;\n  }\n\n  const targetType = getCallArgumentType(call, node.parent, checker);\n\n  return (\n    node.name.text === member.memberName &&\n    isMemberHandoff(\n      checker.getTypeAtLocation(node.parent),\n      targetType,\n      member,\n      checker,\n    )\n  );\n};\n\n/**\n * Checks whether a property value is forwarded into an external object contract.\n * @param node Candidate outer object property.\n * @param checker TypeScript type checker.\n * @param member Member whose host value is being forwarded.\n * @returns True when the receiving property accepts the host shape.\n * @example\n * ```typescript\n * const used = isObjectContractHandoff(node, checker, member);\n * ```\n */\nconst isObjectContractHandoff = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    ts.isPropertyAssignment(node) &&\n    ts.isObjectLiteralExpression(node.parent)\n  ) {\n    const name = node.name;\n\n    if (!ts.isIdentifier(name) && !ts.isStringLiteralLike(name)) {\n      return false;\n    }\n\n    const objectType = checker.getContextualType(node.parent);\n\n    if (!isExternalPropertyContract(objectType, name.text, checker)) {\n      return false;\n    }\n\n    const sourceType = checker.getTypeAtLocation(node.initializer);\n    const targetType = getContextualPropertyType(\n      objectType,\n      name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(sourceType, targetType, member, checker);\n  }\n\n  if (\n    ts.isShorthandPropertyAssignment(node) &&\n    ts.isObjectLiteralExpression(node.parent)\n  ) {\n    const objectType = checker.getContextualType(node.parent);\n\n    if (!isExternalPropertyContract(objectType, node.name.text, checker)) {\n      return false;\n    }\n\n    const sourceType = checker.getTypeAtLocation(node.name);\n    const targetType = getContextualPropertyType(\n      objectType,\n      node.name.text,\n      node,\n      checker,\n    );\n\n    return isMemberHandoff(sourceType, targetType, member, checker);\n  }\n\n  return false;\n};\n\nexport { isCallArgumentMember, isObjectContractHandoff };\n"]}
+//# 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"}