@elench/testkit 0.1.61 → 0.1.63

package/lib/coverage/next-static-analysis.mjs

@@ -1,5 +1,6 @@
 import path from "path";
 import ts from "typescript";
+import { DYNAMIC_SEGMENT_TOKEN } from "./shared.mjs";
 
 const HTTP_WRAPPER_METHODS = {
   getJson: "GET",
@@ -23,13 +24,29 @@ export function analyzeNextPageFile({
   isServerActionFile,
   normalizeRoute,
 }) {
-  const sourceFile = createSourceFile(filePath, content);
-  const imports = collectImports(sourceFile, {
+  return analyzeNextRouteTree({
+    serviceName,
+    serviceRoot,
+    route,
+    rootFiles: [{ filePath, content }],
     readSourceFile,
-    resolveImportPath,
+    resolveImportPath: (fromFilePath, specifier) =>
+      fromFilePath === filePath ? resolveImportPath(specifier) : resolveImportToSourceFile(serviceRoot, fromFilePath, specifier),
     isServerActionFile,
+    normalizeRoute,
   });
-  const localFunctions = collectTopLevelFunctions(sourceFile);
+}
+
+export function analyzeNextRouteTree({
+  serviceName,
+  serviceRoot,
+  route,
+  rootFiles = [],
+  readSourceFile,
+  resolveImportPath,
+  isServerActionFile,
+  normalizeRoute,
+}) {
   const directRequests = [];
   const directServerActionRefs = [];
   const nodes = [];
@@ -37,163 +54,366 @@ export function analyzeNextPageFile({
   const surfacesByTargetValue = new Map();
   const actionNodeIds = new Set();
   const requestNodeIds = new Set();
-  const defaultPageComponent = findDefaultPageComponent(sourceFile, localFunctions);
-  const directPageAnalysis = defaultPageComponent
-    ? analyzeCallableLikeNode(defaultPageComponent, {
-        imports,
-        localFunctions,
-        normalizeRoute,
-      }, new Set(), { skipNestedFunctions: true })
-    : emptyActionAnalysis();
-
-  for (const request of directPageAnalysis.requests) {
-    const node = createClientRequestNode(serviceName, filePath, request, `page:${route}`);
-    if (!requestNodeIds.has(node.id)) {
-      requestNodeIds.add(node.id);
-      nodes.push(node);
+  const pageNodeId = `page_view:${serviceName}:${route}`;
+  const moduleCache = new Map();
+  const visitedExports = new Set();
+
+  const analyzerContext = {
+    serviceName,
+    serviceRoot,
+    route,
+    pageNodeId,
+    readSourceFile,
+    resolveImportPath,
+    isServerActionFile,
+    normalizeRoute,
+    moduleCache,
+    visitedExports,
+    state: {
+      nodes,
+      edges,
+      directRequests,
+      directServerActionRefs,
+      surfacesByTargetValue,
+      actionNodeIds,
+      requestNodeIds,
+    },
+  };
+
+  for (const rootFile of rootFiles) {
+    const rootContent =
+      typeof rootFile.content === "string"
+        ? rootFile.content
+        : readSourceFile(rootFile.filePath);
+    if (!rootContent) continue;
+    const moduleInfo = loadModuleInfo(rootFile.filePath, rootContent, analyzerContext);
+    analyzeModuleExport(moduleInfo, "default", analyzerContext);
+  }
+
+  return {
+    nodes: dedupeById(nodes),
+    edges: dedupeById(edges),
+    requests: directRequests,
+    serverActionRefs: dedupeServerActionRefs(directServerActionRefs),
+    surfacesByTargetValue,
+  };
+}
+
+export function extractHttpSuiteRequests(content, filePath = "suite.int.testkit.ts") {
+  const sourceFile = createSourceFile(filePath, content);
+  const requests = [];
+
+  const visit = (node) => {
+    if (ts.isCallExpression(node)) {
+      const request = resolveHttpRequestCall(node, { normalizeRoute: defaultNormalizeRoute });
+      if (request) requests.push(request);
     }
-    directRequests.push({
-      originNodeId: `page_view:${serviceName}:${route}`,
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return dedupeRequests(requests);
+}
+
+export function extractPlaywrightVisitedRoutes(content, filePath = "suite.pw.testkit.ts") {
+  const sourceFile = createSourceFile(filePath, content);
+  const routes = [];
+
+  const visit = (node) => {
+    if (ts.isCallExpression(node)) {
+      const route = resolveGotoRoute(node);
+      if (route) routes.push(route);
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return [...new Set(routes)];
+}
+
+function analyzeModuleExport(moduleInfo, contextExportName, analyzerContext) {
+  if (!moduleInfo) return;
+  const visitKey = `${moduleInfo.filePath}#${contextExportName}`;
+  if (analyzerContext.visitedExports.has(visitKey)) return;
+  analyzerContext.visitedExports.add(visitKey);
+
+  const callable = resolveModuleExportCallable(moduleInfo, contextExportName);
+  if (!callable) return;
+
+  const localFunctions = new Map(moduleInfo.topLevelFunctions);
+  for (const [name, node] of collectScopeLocalFunctions(callable)) {
+    localFunctions.set(name, node);
+  }
+
+  const actionAnalysis = analyzeCallableLikeNode(
+    callable,
+    {
+      imports: moduleInfo.imports,
+      localFunctions,
+      normalizeRoute: analyzerContext.normalizeRoute,
+      moduleLoader: (filePath) => loadModuleInfoFromFile(filePath, analyzerContext),
+      resolveImportedExport: resolveImportedExportCallable,
+      analyzeImportedCallable,
+    },
+    new Set(),
+    { skipNestedFunctions: true }
+  );
+
+  for (const request of actionAnalysis.requests) {
+    const node = createClientRequestNode(
+      analyzerContext.serviceName,
+      moduleInfo.filePath,
+      request,
+      `page:${analyzerContext.route}:${moduleInfo.filePath}`
+    );
+    if (!analyzerContext.state.requestNodeIds.has(node.id)) {
+      analyzerContext.state.requestNodeIds.add(node.id);
+      analyzerContext.state.nodes.push(node);
+    }
+    analyzerContext.state.directRequests.push({
+      originNodeId: analyzerContext.pageNodeId,
       node,
       method: request.method,
       path: request.path,
     });
-    edges.push({
-      id: `requests:page_view:${serviceName}:${route}:${node.id}`,
+    analyzerContext.state.edges.push({
+      id: `requests:${analyzerContext.pageNodeId}:${node.id}`,
       kind: "requests",
-      from: `page_view:${serviceName}:${route}`,
+      from: analyzerContext.pageNodeId,
       to: node.id,
       confidence: request.confidence,
     });
   }
 
-  for (const serverActionRef of directPageAnalysis.serverActionRefs) {
-    directServerActionRefs.push({
-      originNodeId: `page_view:${serviceName}:${route}`,
+  for (const serverActionRef of actionAnalysis.serverActionRefs) {
+    analyzerContext.state.directServerActionRefs.push({
+      originNodeId: analyzerContext.pageNodeId,
       ...serverActionRef,
     });
   }
 
-  walkJsx(sourceFile, (element, formContext) => {
+  walkJsx(callable, (element, formContext) => {
     const descriptor = describeSurface(element, formContext);
-    if (!descriptor) return formContext;
-
-    const surfaceKey = descriptor.target?.value || descriptor.actionName || `${descriptor.tagName}:${descriptor.line}`;
-    const surfaceId = `ui_surface:${serviceName}:${route}:${surfaceKey}`;
-    const surfaceNode = {
-      id: surfaceId,
-      kind: "ui_surface",
-      service: serviceName,
-      label: descriptor.label,
-      route,
-      filePath,
-      ...(descriptor.target ? { target: descriptor.target } : {}),
-      metadata: {
-        surfaceKind: descriptor.surfaceKind,
-        tagName: descriptor.tagName,
-      },
-    };
+    if (descriptor) {
+      const surfaceKey = descriptor.target?.value || descriptor.actionName || `${moduleInfo.filePath}:${descriptor.tagName}:${descriptor.line}`;
+      const surfaceId = `ui_surface:${analyzerContext.serviceName}:${analyzerContext.route}:${surfaceKey}`;
+      const surfaceNode = {
+        id: surfaceId,
+        kind: "ui_surface",
+        service: analyzerContext.serviceName,
+        label: descriptor.label,
+        route: analyzerContext.route,
+        filePath: moduleInfo.filePath,
+        ...(descriptor.target ? { target: descriptor.target } : {}),
+        metadata: {
+          surfaceKind: descriptor.surfaceKind,
+          tagName: descriptor.tagName,
+        },
+      };
 
-    nodes.push(surfaceNode);
-    edges.push({
-      id: `contains:page_view:${serviceName}:${route}:${surfaceId}`,
-      kind: "contains",
-      from: `page_view:${serviceName}:${route}`,
-      to: surfaceId,
-      confidence: "high",
-    });
+      analyzerContext.state.nodes.push(surfaceNode);
+      analyzerContext.state.edges.push({
+        id: `contains:${analyzerContext.pageNodeId}:${surfaceId}`,
+        kind: "contains",
+        from: analyzerContext.pageNodeId,
+        to: surfaceId,
+        confidence: "high",
+      });
 
-    if (descriptor.target?.kind === "testId") {
-      surfacesByTargetValue.set(descriptor.target.value, surfaceNode);
-    }
+      if (descriptor.target?.kind === "testId") {
+        analyzerContext.state.surfacesByTargetValue.set(descriptor.target.value, surfaceNode);
+      }
 
-    if (descriptor.actionBinding) {
-      const actionId = `ui_action:${serviceName}:${route}:${descriptor.actionBinding.key}`;
-      if (!actionNodeIds.has(actionId)) {
-        actionNodeIds.add(actionId);
-        nodes.push({
-          id: actionId,
-          kind: "ui_action",
-          service: serviceName,
-          label: descriptor.actionBinding.label,
-          route,
-          filePath,
-          metadata: {
-            bindingKind: descriptor.actionBinding.kind,
-            actionProp: descriptor.actionBinding.actionProp,
-          },
+      if (descriptor.actionBinding) {
+        const actionId = `ui_action:${analyzerContext.serviceName}:${analyzerContext.route}:${descriptor.actionBinding.key}`;
+        if (!analyzerContext.state.actionNodeIds.has(actionId)) {
+          analyzerContext.state.actionNodeIds.add(actionId);
+          analyzerContext.state.nodes.push({
+            id: actionId,
+            kind: "ui_action",
+            service: analyzerContext.serviceName,
+            label: descriptor.actionBinding.label,
+            route: analyzerContext.route,
+            filePath: moduleInfo.filePath,
+            metadata: {
+              bindingKind: descriptor.actionBinding.kind,
+              actionProp: descriptor.actionBinding.actionProp,
+            },
+          });
+        }
+
+        analyzerContext.state.edges.push({
+          id: `triggers:${surfaceId}:${actionId}`,
+          kind: "triggers",
+          from: surfaceId,
+          to: actionId,
+          confidence: descriptor.actionBinding.confidence,
         });
-      }
 
-      edges.push({
-        id: `triggers:${surfaceId}:${actionId}`,
-        kind: "triggers",
-        from: surfaceId,
-        to: actionId,
-        confidence: descriptor.actionBinding.confidence,
-      });
+        const bindingAnalysis = analyzeActionBinding(descriptor.actionBinding, {
+          imports: moduleInfo.imports,
+          localFunctions,
+          normalizeRoute: analyzerContext.normalizeRoute,
+          moduleLoader: (filePath) => loadModuleInfoFromFile(filePath, analyzerContext),
+          resolveImportedExport: resolveImportedExportCallable,
+          analyzeImportedCallable,
+        });
 
-      const actionAnalysis = analyzeActionBinding(descriptor.actionBinding, {
-        imports,
-        localFunctions,
-        normalizeRoute,
-      });
+        for (const request of bindingAnalysis.requests) {
+          const node = createClientRequestNode(
+            analyzerContext.serviceName,
+            moduleInfo.filePath,
+            request,
+            descriptor.actionBinding.key
+          );
+          if (!analyzerContext.state.requestNodeIds.has(node.id)) {
+            analyzerContext.state.requestNodeIds.add(node.id);
+            analyzerContext.state.nodes.push(node);
+          }
+          analyzerContext.state.directRequests.push({
+            originNodeId: actionId,
+            node,
+            method: request.method,
+            path: request.path,
+          });
+          analyzerContext.state.edges.push({
+            id: `requests:${actionId}:${node.id}`,
+            kind: "requests",
+            from: actionId,
+            to: node.id,
+            confidence: request.confidence,
+          });
+        }
 
-      for (const request of actionAnalysis.requests) {
-        const node = createClientRequestNode(serviceName, filePath, request, descriptor.actionBinding.key);
-        if (!requestNodeIds.has(node.id)) {
-          requestNodeIds.add(node.id);
-          nodes.push(node);
+        for (const serverActionRef of bindingAnalysis.serverActionRefs) {
+          analyzerContext.state.directServerActionRefs.push({
+            originNodeId: actionId,
+            ...serverActionRef,
+          });
         }
-        directRequests.push({
-          originNodeId: actionId,
-          node,
-          method: request.method,
-          path: request.path,
-        });
-        edges.push({
-          id: `requests:${actionId}:${node.id}`,
-          kind: "requests",
-          from: actionId,
-          to: node.id,
-          confidence: request.confidence,
-        });
       }
 
-      for (const serverActionRef of actionAnalysis.serverActionRefs) {
-        directServerActionRefs.push({
-          originNodeId: actionId,
-          ...serverActionRef,
-        });
-      }
+      return descriptor.formContext ?? formContext;
     }
 
-    return descriptor.formContext ?? formContext;
+    const componentRef = resolveImportedComponentRef(element, moduleInfo.imports);
+    if (componentRef) {
+      analyzeImportedComponent(componentRef, analyzerContext);
+    }
+    return formContext;
   });
+}
 
-  return {
-    nodes: dedupeById(nodes),
-    edges: dedupeById(edges),
-    requests: directRequests,
-    serverActionRefs: dedupeServerActionRefs(directServerActionRefs),
-    surfacesByTargetValue,
-  };
+function analyzeImportedComponent(componentRef, analyzerContext) {
+  const moduleInfo = loadModuleInfoFromFile(componentRef.filePath, analyzerContext);
+  if (!moduleInfo) return;
+  analyzeModuleExport(moduleInfo, componentRef.exportName, analyzerContext);
 }
 
-export function extractHttpSuiteRequests(content, filePath = "suite.int.testkit.ts") {
+function analyzeImportedCallable(imported, options, visited) {
+  if (!imported?.resolvedFilePath || imported.isServerAction || visited.has(imported.resolvedFilePath)) {
+    return emptyActionAnalysis();
+  }
+  const moduleInfo = options.moduleLoader(imported.resolvedFilePath);
+  if (!moduleInfo) return emptyActionAnalysis();
+  const callable = options.resolveImportedExport(moduleInfo, imported.importedName);
+  if (!callable) return emptyActionAnalysis();
+
+  const localFunctions = new Map(moduleInfo.topLevelFunctions);
+  for (const [name, node] of collectScopeLocalFunctions(callable)) {
+    localFunctions.set(name, node);
+  }
+
+  const nextVisited = new Set(visited);
+  nextVisited.add(imported.resolvedFilePath);
+  return analyzeCallableLikeNode(
+    callable,
+    {
+      imports: moduleInfo.imports,
+      localFunctions,
+      normalizeRoute: options.normalizeRoute,
+      moduleLoader: options.moduleLoader,
+      resolveImportedExport: options.resolveImportedExport,
+      analyzeImportedCallable,
+    },
+    nextVisited
+  );
+}
+
+function loadModuleInfoFromFile(filePath, analyzerContext) {
+  const cached = analyzerContext.moduleCache.get(filePath);
+  if (cached) return cached;
+  const content = analyzerContext.readSourceFile(filePath);
+  if (!content) return null;
+  return loadModuleInfo(filePath, content, analyzerContext);
+}
+
+function loadModuleInfo(filePath, content, analyzerContext) {
+  const cached = analyzerContext.moduleCache.get(filePath);
+  if (cached) return cached;
+
   const sourceFile = createSourceFile(filePath, content);
-  const requests = [];
+  const imports = collectImports(sourceFile, {
+    readSourceFile: analyzerContext.readSourceFile,
+    resolveImportPath: (specifier) => analyzerContext.resolveImportPath(filePath, specifier),
+    isServerActionFile: analyzerContext.isServerActionFile,
+  });
+  const topLevelFunctions = collectTopLevelFunctions(sourceFile);
+  const exports = collectExportedCallables(sourceFile, topLevelFunctions);
+  const moduleInfo = {
+    filePath,
+    sourceFile,
+    imports,
+    topLevelFunctions,
+    exports,
+    defaultExport: findDefaultPageComponent(sourceFile, topLevelFunctions),
+  };
+  analyzerContext.moduleCache.set(filePath, moduleInfo);
+  return moduleInfo;
+}
 
-  const visit = (node) => {
-    if (ts.isCallExpression(node)) {
-      const request = resolveHttpRequestCall(node, { normalizeRoute: defaultNormalizeRoute });
-      if (request) requests.push(request);
-    }
-    ts.forEachChild(node, visit);
+function resolveModuleExportCallable(moduleInfo, exportName) {
+  if (!moduleInfo) return null;
+  if (exportName === "default") return moduleInfo.defaultExport || null;
+  return moduleInfo.exports.get(exportName) || null;
+}
+
+function resolveImportedExportCallable(moduleInfo, importedName) {
+  if (!moduleInfo) return null;
+  if (importedName === "default") return moduleInfo.defaultExport || null;
+  return moduleInfo.exports.get(importedName) || null;
+}
+
+function resolveImportedComponentRef(node, imports) {
+  const opening = ts.isJsxElement(node) ? node.openingElement : node;
+  const tagName = opening.tagName.getText();
+  if (!/^[A-Z]/u.test(tagName)) return null;
+  const imported = imports.get(tagName);
+  if (!imported?.resolvedFilePath || imported.isServerAction) return null;
+  if (imported.resolvedFilePath.includes("/components/ui/")) return null;
+  return {
+    filePath: imported.resolvedFilePath,
+    exportName: imported.importedName,
   };
+}
 
-  visit(sourceFile);
-  return dedupeRequests(requests);
+function resolveGotoRoute(callExpression) {
+  const callee = callExpression.expression;
+  if (!ts.isPropertyAccessExpression(callee)) return null;
+  if (callee.name.text !== "goto") return null;
+  const pathArg = callExpression.arguments[0];
+  const literal = extractStringLiteral(pathArg);
+  if (!literal) return null;
+  if (/^https?:\/\//u.test(literal)) {
+    try {
+      const parsed = new URL(literal);
+      if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
+        return defaultNormalizeRoute(parsed.pathname.split("?")[0]);
+      }
+    } catch { /* ignore malformed */ }
+    return null;
+  }
+  return defaultNormalizeRoute(literal.split("?")[0]);
 }
 
 function walkJsx(sourceFile, visitor) {
@@ -324,6 +544,10 @@ function analyzeActionBinding(binding, options) {
       };
     }
 
+    if (imported?.resolvedFilePath) {
+      return options.analyzeImportedCallable(imported, options, new Set([imported.resolvedFilePath]));
+    }
+
     const localFunction = options.localFunctions.get(identifier);
     if (!localFunction) return emptyActionAnalysis();
     return analyzeCallableLikeNode(localFunction, options, new Set([identifier]));
@@ -361,6 +585,17 @@ function analyzeCallableLikeNode(node, options, visited = new Set(), settings =
           if (localCall) {
             for (const requestEntry of localCall.requests) requests.push(requestEntry);
             for (const serverActionRef of localCall.serverActionRefs) serverActionRefs.push(serverActionRef);
+          } else {
+            const importedCall = resolveImportedLocalCall(child, options, visited);
+            if (importedCall) {
+              for (const requestEntry of importedCall.requests) requests.push(requestEntry);
+              for (const serverActionRef of importedCall.serverActionRefs) serverActionRefs.push(serverActionRef);
+            } else {
+              for (const callbackAnalysis of resolveExecutedCallbackAnalyses(child, options, visited)) {
+                for (const requestEntry of callbackAnalysis.requests) requests.push(requestEntry);
+                for (const serverActionRef of callbackAnalysis.serverActionRefs) serverActionRefs.push(serverActionRef);
+              }
+            }
           }
         }
       }
@@ -393,6 +628,26 @@ function resolveLocalFunctionCall(callExpression, options, visited) {
   return analyzeCallableLikeNode(localFunction, options, nextVisited);
 }
 
+function resolveImportedLocalCall(callExpression, options, visited) {
+  const callee = callExpression.expression;
+  if (!ts.isIdentifier(callee)) return null;
+  const imported = options.imports.get(callee.text);
+  if (!imported?.resolvedFilePath || imported.isServerAction) return null;
+  return options.analyzeImportedCallable(imported, options, visited);
+}
+
+function resolveExecutedCallbackAnalyses(callExpression, options, visited) {
+  const callbacks = [];
+  const callee = callExpression.expression;
+  if (ts.isIdentifier(callee) && (callee.text === "useEffect" || callee.text === "useLayoutEffect")) {
+    const callbackArg = callExpression.arguments[0];
+    if (callbackArg && (ts.isArrowFunction(callbackArg) || ts.isFunctionExpression(callbackArg))) {
+      callbacks.push(analyzeCallableLikeNode(callbackArg, options, new Set(visited)));
+    }
+  }
+  return callbacks;
+}
+
 function resolveServerActionCall(callExpression, options) {
   const callee = callExpression.expression;
   if (!ts.isIdentifier(callee)) return null;
@@ -508,6 +763,58 @@ function collectTopLevelFunctions(sourceFile) {
   return functions;
 }
 
+function collectExportedCallables(sourceFile, topLevelFunctions) {
+  const exports = new Map();
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && hasExportModifier(statement.modifiers)) {
+      exports.set(statement.name.text, statement);
+      continue;
+    }
+
+    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement.modifiers)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+        exports.set(declaration.name.text, declaration.initializer);
+      } else if (ts.isIdentifier(declaration.initializer)) {
+        const referenced = topLevelFunctions.get(declaration.initializer.text);
+        if (referenced) exports.set(declaration.name.text, referenced);
+      }
+    }
+  }
+  return exports;
+}
+
+function collectScopeLocalFunctions(node) {
+  const functions = new Map();
+  const callableBody = "body" in node ? node.body : null;
+  if (!callableBody) return functions;
+
+  const visit = (child) => {
+    if (
+      child !== callableBody &&
+      (ts.isFunctionDeclaration(child) || ts.isArrowFunction(child) || ts.isFunctionExpression(child))
+    ) {
+      return;
+    }
+
+    if (ts.isFunctionDeclaration(child) && child.name) {
+      functions.set(child.name.text, child);
+    }
+
+    if (ts.isVariableDeclaration(child) && ts.isIdentifier(child.name) && child.initializer) {
+      if (ts.isArrowFunction(child.initializer) || ts.isFunctionExpression(child.initializer)) {
+        functions.set(child.name.text, child.initializer);
+      }
+    }
+
+    ts.forEachChild(child, visit);
+  };
+
+  visit(callableBody);
+  return functions;
+}
+
 function findDefaultPageComponent(sourceFile, localFunctions) {
   for (const statement of sourceFile.statements) {
     if (ts.isFunctionDeclaration(statement) && hasDefaultModifier(statement.modifiers)) {
@@ -526,6 +833,10 @@ function findDefaultPageComponent(sourceFile, localFunctions) {
   return null;
 }
 
+function hasExportModifier(modifiers) {
+  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
 function collectJsxAttributes(openingElement) {
   const attributes = {};
   for (const property of openingElement.attributes.properties) {
@@ -578,7 +889,7 @@ function flattenJsxText(children) {
 function extractRouteLiteral(node, normalizeRoute) {
   const literal = extractStringLiteral(node);
   if (!literal) return null;
-  return normalizeRoute(literal);
+  return normalizeRoute(literal.split("?")[0]);
 }
 
 function extractFetchMethod(node) {
@@ -596,6 +907,14 @@ function extractStringLiteral(node) {
   if (!node) return null;
   if (ts.isStringLiteralLike(node)) return node.text;
   if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isTemplateExpression(node)) {
+    let value = node.head.text;
+    for (const span of node.templateSpans) {
+      value += DYNAMIC_SEGMENT_TOKEN;
+      value += span.literal.text;
+    }
+    return value;
+  }
   return null;
 }