@pixel-point/toolcraft 0.0.16 → 0.0.17

package/templates/starter/src/app/starter-performance-test-utils.ts

@@ -5,6 +5,13 @@ import { fileURLToPath } from "node:url";
 import ts from "typescript";
 
 import { collectToolcraftSourceInventorySync } from "../../scripts/toolcraft-source-inventory.mjs";
+import {
+  collectToolcraftTypeScriptCallTargets,
+  collectToolcraftTypeScriptModuleBindings,
+  createToolcraftTypeScriptChecker,
+  getToolcraftTypeScriptImportedCallTarget,
+  unwrapToolcraftTypeScriptExpression,
+} from "../../scripts/toolcraft-typescript-analysis.mjs";
 
 import { sourceDefinesProductCanvasContent } from "./starter-acceptance.source-test-utils";
 import { starterSchema } from "./starter-schema";
@@ -15,6 +22,102 @@ export const routesDir = join(appDir, "../routes");
 export const e2eDir = join(appDir, "../../e2e");
 export const projectDir = join(appDir, "../..");
 
+export function createToolcraftTypeScriptSourceAnalysis(
+  source: string,
+  fileName: string,
+) {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const checker = createToolcraftTypeScriptChecker(sourceFile, ts);
+  const bindings = collectToolcraftTypeScriptModuleBindings(
+    sourceFile,
+    ts,
+    checker,
+  );
+  const callTargets = collectToolcraftTypeScriptCallTargets({
+    bindings,
+    checker,
+    sourceFile,
+    ts,
+  });
+  const importedCalls: Array<
+    Readonly<{
+      call: ts.CallExpression;
+      target: Readonly<{
+        importedName: string;
+        memberPath: string;
+        specifier: string;
+      }>;
+    }>
+  > = [];
+  function visit(node: ts.Node): void {
+    if (ts.isCallExpression(node)) {
+      const target = getToolcraftTypeScriptImportedCallTarget({
+        bindings,
+        checker,
+        expression: node.expression,
+        ts,
+      });
+      if (target) importedCalls.push(Object.freeze({ call: node, target }));
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return Object.freeze({
+    bindings,
+    callTargets,
+    checker,
+    importedCalls: Object.freeze(importedCalls),
+    sourceFile,
+  });
+}
+
+type ToolcraftTypeScriptSourceAnalysis = ReturnType<
+  typeof createToolcraftTypeScriptSourceAnalysis
+>;
+
+export function getToolcraftImportedBinding(
+  analysis: ToolcraftTypeScriptSourceAnalysis,
+  expression: ts.Expression | undefined,
+): Readonly<{ importedName: string; specifier: string }> | undefined {
+  if (!expression) return undefined;
+  const normalized = unwrapToolcraftTypeScriptExpression(expression, ts);
+  if (!ts.isIdentifier(normalized)) return undefined;
+  const symbol =
+    normalized.parent && ts.isShorthandPropertyAssignment(normalized.parent)
+      ? analysis.checker.getShorthandAssignmentValueSymbol(normalized.parent)
+      : analysis.checker.getSymbolAtLocation(normalized);
+  return analysis.bindings.importedBindingSymbols.find(
+    (candidate: { symbol: ts.Symbol }) => candidate.symbol === symbol,
+  )?.binding;
+}
+
+export function toolcraftExpressionReferencesImport(
+  analysis: ToolcraftTypeScriptSourceAnalysis,
+  expression: ts.Expression | undefined,
+  expected: Readonly<{ importedName: string; specifier: string }>,
+): boolean {
+  if (!expression) return false;
+  let found = false;
+  function visit(node: ts.Node): void {
+    if (found) return;
+    const binding = ts.isIdentifier(node)
+      ? getToolcraftImportedBinding(analysis, node)
+      : undefined;
+    found =
+      binding?.importedName === expected.importedName &&
+      binding.specifier === expected.specifier;
+    if (!found) ts.forEachChild(node, visit);
+  }
+  visit(expression);
+  return found;
+}
+
 export function playwrightConfigForbidsFocusedTests(): boolean {
   const sourceFile = ts.createSourceFile(
     "playwright.config.ts",