@barefootjs/test 0.17.1 → 0.18.1

package/dist/index.js

@@ -187437,6 +187437,7 @@ function convertNode(node, raw) {
       if (callee.property === "flat") {
         const depthNode = node.arguments[0];
         let flatDepth;
+        let depthExpr;
         if (depthNode === undefined) {
           flatDepth = 1;
         } else if (import_typescript.default.isIdentifier(depthNode) && depthNode.text === "Infinity") {
@@ -187449,16 +187450,23 @@ function convertNode(node, raw) {
             n = -Number(depthNode.operand.text);
           }
           if (n === undefined || Number.isNaN(n)) {
-            return {
-              kind: "unsupported",
-              raw,
-              reason: `\`.flat(depth)\` needs a literal integer or \`Infinity\` depth — a computed depth can't be resolved at template time. Use a literal depth, or pre-compute the value before the template.`
-            };
+            const parsedDepth = convertNode(depthNode, raw);
+            if (checkSupport(parsedDepth).supported) {
+              depthExpr = parsedDepth;
+              flatDepth = 1;
+            } else {
+              return {
+                kind: "unsupported",
+                raw,
+                reason: `\`.flat(depth)\` needs a literal integer, \`Infinity\`, or a supported dynamic depth expression — this depth can't be resolved. Use a literal depth, a supported expression (prop/signal/arithmetic), or pre-compute the value before the template.`
+              };
+            }
+          } else {
+            const truncated = Math.trunc(n);
+            flatDepth = truncated < 0 ? 0 : truncated;
           }
-          const truncated = Math.trunc(n);
-          flatDepth = truncated < 0 ? 0 : truncated;
         }
-        return { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
+        return depthExpr !== undefined ? { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth, depthExpr } : { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
       }
       if (callee.property === "toLowerCase") {
         return { kind: "array-method", method: "toLowerCase", object: callee.object, args };
@@ -188003,6 +188011,8 @@ function validateRestUsage(expr, restName, excludedTopKeys) {
         walk(e.object);
         for (const a of e.args)
           walk(a);
+        if (e.method === "flat" && e.depthExpr)
+          walk(e.depthExpr);
         return;
       case "literal":
       case "unsupported":
@@ -188088,6 +188098,8 @@ function collectIdentifiers(expr, out) {
     case "array-method":
       collectIdentifiers(expr.object, out);
       expr.args.forEach((e) => collectIdentifiers(e, out));
+      if (expr.method === "flat" && expr.depthExpr)
+        collectIdentifiers(expr.depthExpr, out);
       return;
     case "literal":
     case "regex":
@@ -188145,7 +188157,14 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         return { kind: "array-literal", elements: e.elements.map(walk) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object), args: e.args.map(walk) };
       case "literal":
@@ -188242,6 +188261,11 @@ function checkSupport(expr) {
         if (!argSupport.supported)
           return argSupport;
       }
+      if (expr.method === "flat" && expr.depthExpr) {
+        const depthSupport = checkSupport(expr.depthExpr);
+        if (!depthSupport.supported)
+          return depthSupport;
+      }
       return { supported: true, level: "L2" };
     }
     case "call": {
@@ -188341,6 +188365,9 @@ function checkSupport(expr) {
       const leftSupport = checkSupport(expr.left);
       if (!leftSupport.supported)
         return leftSupport;
+      if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
+        return { supported: true, level: "L4" };
+      }
       const rightSupport = checkSupport(expr.right);
       if (!rightSupport.supported)
         return rightSupport;
@@ -188535,7 +188562,10 @@ function usesPerPath(name, expr) {
       case "array-literal":
         return sum(e.elements);
       case "array-method":
-        return add(walk(e.object), e.method === "flat" ? { min: 0, max: 0 } : sum(e.args));
+        if (e.method === "flat") {
+          return add(walk(e.object), e.depthExpr ? walk(e.depthExpr) : { min: 0, max: 0 });
+        }
+        return add(walk(e.object), sum(e.args));
       case "object-literal":
         return sum(e.properties.map((p) => p.value));
       case "arrow":
@@ -188590,7 +188620,14 @@ function inlineBinding(expr, name, value) {
         return { kind: "array-literal", elements: e.elements.map((el) => walk(el, enclosing)) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object, enclosing), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object, enclosing),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr, enclosing) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "object-literal":
@@ -188726,6 +188763,9 @@ function stringifyParsedExpr(expr) {
       return `[${expr.elements.map(stringifyParsedExpr).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${stringifyParsedExpr(expr.object)}.flat(${stringifyParsedExpr(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${stringifyParsedExpr(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -189330,6 +189370,15 @@ function createAnalyzerContext(sourceFile, filePath) {
     checker: null,
     componentBodyBlock: null,
     getJS(node) {
+      let ownSourceFile;
+      try {
+        ownSourceFile = node.getSourceFile();
+      } catch {
+        ownSourceFile = undefined;
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile);
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges);
     }
   };
@@ -191306,6 +191355,7 @@ function extractProps(param, ctx) {
       loc: getSourceLocation(param, ctx.sourceFile, ctx.filePath),
       hasIgnoreDirective: ignored
     };
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null;
     for (const element of param.name.elements) {
       if (import_typescript8.default.isBindingElement(element) && import_typescript8.default.isIdentifier(element.name)) {
         const localName = element.name.text;
@@ -191314,10 +191364,12 @@ function extractProps(param, ctx) {
           ctx.restPropsName = localName;
           continue;
         }
+        const sourcePropName = element.propertyName && import_typescript8.default.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
+        const resolvedType = memberTypes?.get(sourcePropName) ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
         ctx.propsParams.push({
           name: localName,
-          type: { kind: "unknown", raw: "unknown" },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined
@@ -191378,6 +191430,37 @@ function collectKeysFromMembers(members, ctx) {
   }
   return keys;
 }
+function collectMemberTypes(typeNode, ctx) {
+  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean");
+  const fromMembers = (members) => {
+    const map = new Map;
+    for (const member of members) {
+      if (import_typescript8.default.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile);
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx.sourceFile), info);
+        }
+      }
+    }
+    return map;
+  };
+  if (import_typescript8.default.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members);
+  }
+  if (import_typescript8.default.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx.sourceFile);
+    const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
+    if (!typeDecl)
+      return null;
+    if (import_typescript8.default.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members);
+    }
+    if (import_typescript8.default.isTypeAliasDeclaration(typeDecl) && import_typescript8.default.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members);
+    }
+  }
+  return null;
+}
 function extractPropsFromType(typeNode, ctx) {
   if (import_typescript8.default.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
@@ -192034,6 +192117,38 @@ var AttrValueOf = {
   }
 };
 
+// ../jsx/src/module-exports.ts
+function formatParamWithType(p) {
+  const rest = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
+  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = new Set;
+  const queue = [];
+  for (const name of allNames) {
+    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+      reachable.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body = bodyMap.get(current) || "";
+    for (const name of allNames) {
+      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+        reachable.add(name);
+        queue.push(name);
+      }
+    }
+  }
+  return reachable;
+}
+
 // ../jsx/src/builtins.ts
 var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
 function isClientBuiltinName(name) {
@@ -193141,6 +193256,7 @@ function transformExpression(node, ctx) {
   return transformExpressionInner(expr, ctx, node, isClientOnly);
 }
 function transformExpressionInner(expr, ctx, node, isClientOnly) {
+  expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
   checkBareSignalOrMemoIdentifier(expr, ctx);
   if (import_typescript11.default.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
@@ -193682,11 +193798,10 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name };
 }
 function extractSortComparator(callback, _method, ctx) {
-  const unsupported = () => {
-    const raw = ctx.getJS(callback);
-    return {
-      result: null,
-      unsupportedReason: `Sort comparator '${raw}' is not a supported shape. Accepted:
+  const outerRaw = ctx.getJS(callback);
+  const unsupported = () => ({
+    result: null,
+    unsupportedReason: `Sort comparator '${outerRaw}' is not a supported shape. Accepted:
 ` + `  (a, b) => a - b
 ` + `  (a, b) => a.field - b.field
 ` + `  (a, b) => a.localeCompare(b)
@@ -193694,15 +193809,25 @@ function extractSortComparator(callback, _method, ctx) {
 ` + `  (a, b) => a.field > b.field ? 1 : a.field < b.field ? -1 : 0
 ` + `  any of the above '||'-chained for multi-key tie-breaks
 ` + `(reverse the operands for descending order).`
-    };
-  };
-  if (!import_typescript11.default.isArrowFunction(callback) && !import_typescript11.default.isFunctionExpression(callback)) {
+  });
+  let resolvedNode = callback;
+  if (import_typescript11.default.isIdentifier(callback)) {
+    const resolved = resolveSortComparatorIdentifier(callback.text, ctx);
+    if (!resolved) {
+      return {
+        result: null,
+        unsupportedReason: `Sort comparator '${outerRaw}' could not be resolved to a local function — ` + `declare it in the same file or inline it.`
+      };
+    }
+    resolvedNode = resolved;
+  }
+  if (!import_typescript11.default.isArrowFunction(resolvedNode) && !import_typescript11.default.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
     };
   }
-  const arrow = tsNodeToParsedExpr(callback);
+  const arrow = tsNodeToParsedExpr(resolvedNode);
   if (arrow.kind !== "arrow" || arrow.params.length !== 2)
     return unsupported();
   if (sortComparatorFromArrow(arrow) === null)
@@ -193716,6 +193841,21 @@ function extractSortComparator(callback, _method, ctx) {
     }
   };
 }
+function resolveSortComparatorIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
 function extractFilterPredicate(callback, ctx) {
   if (!import_typescript11.default.isArrowFunction(callback))
     return { result: null };
@@ -193788,7 +193928,7 @@ function extractLoopParamBindings(pattern) {
   const appendDotAccess = (prefix, key) => {
     return isIdent(key) ? `${prefix}.${key}` : `${prefix}[${JSON.stringify(key)}]`;
   };
-  const walk = (p, prefix) => {
+  const walk = (p, prefix, segments) => {
     if (unsupported)
       return;
     if (import_typescript11.default.isArrayBindingPattern(p)) {
@@ -193805,15 +193945,17 @@ function extractLoopParamBindings(pattern) {
           bindings.push({
             name: el.name.text,
             path: prefix,
-            rest: { kind: "array", from: index }
+            rest: { kind: "array", from: index },
+            segments
           });
           return;
         }
         const path = `${prefix}[${index}]`;
+        const nextSegments = [...segments, { kind: "index", index }];
         if (import_typescript11.default.isIdentifier(el.name)) {
-          bindings.push({ name: el.name.text, path });
+          bindings.push({ name: el.name.text, path, segments: nextSegments });
         } else {
-          walk(el.name, path);
+          walk(el.name, path, nextSegments);
         }
       }
       return;
@@ -193830,7 +193972,8 @@ function extractLoopParamBindings(pattern) {
         bindings.push({
           name: el.name.text,
           path: prefix,
-          rest: { kind: "object", exclude: collectedKeys }
+          rest: { kind: "object", exclude: collectedKeys },
+          segments
         });
         return;
       }
@@ -193853,17 +193996,19 @@ function extractLoopParamBindings(pattern) {
         unsupported = true;
         return;
       }
-      collectedKeys.push({ key: keyText, isIdent: isIdent(keyText) });
+      const keyIsIdent = isIdent(keyText);
+      collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path = appendDotAccess(prefix, keyText);
+      const nextSegments = [...segments, { kind: "field", key: keyText, isIdent: keyIsIdent }];
       if (import_typescript11.default.isIdentifier(el.name)) {
-        bindings.push({ name: el.name.text, path });
+        bindings.push({ name: el.name.text, path, segments: nextSegments });
       } else {
-        walk(el.name, path);
+        walk(el.name, path, nextSegments);
       }
     }
   };
   if (import_typescript11.default.isArrayBindingPattern(pattern) || import_typescript11.default.isObjectBindingPattern(pattern)) {
-    walk(pattern, "");
+    walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
     return bindings;
@@ -194632,6 +194777,7 @@ function getAttributeValue(attr, ctx) {
         expr = branchInit;
       }
     }
+    expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
     if (import_typescript11.default.isAwaitExpression(expr)) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
@@ -194767,6 +194913,14 @@ function findLocalConst(name, ctx) {
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
+function findLocalFunction(name, ctx) {
+  const matches = ctx.analyzer.localFunctions.filter((f) => f.name === name);
+  if (matches.length === 0)
+    return;
+  const fnScoped = matches.filter((f) => !f.isModule);
+  const pool = fnScoped.length > 0 ? fnScoped : matches;
+  return pool[pool.length - 1];
+}
 function isDynamicTagLocal(name, ctx) {
   if (!hasDynamicTagBinding(name, ctx.sourceFile))
     return false;
@@ -194861,6 +195015,147 @@ function parseConstInitializerImpl(c) {
 function astText(node) {
   return node.getText(node.getSourceFile());
 }
+var functionInfoExprCache = new WeakMap;
+function parseFunctionInfoAsExpr(fn) {
+  const cached = functionInfoExprCache.get(fn);
+  if (cached !== undefined)
+    return cached;
+  const result = parseFunctionInfoAsExprImpl(fn);
+  functionInfoExprCache.set(fn, result);
+  return result;
+}
+function parseFunctionInfoAsExprImpl(fn) {
+  if (!fn.body)
+    return null;
+  const params = fn.typedParams !== undefined ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
+  const body = fn.typedBody ?? fn.body;
+  const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body}`;
+  const sf = import_typescript11.default.createSourceFile("__bf_resolve_fn.ts", wrapped, import_typescript11.default.ScriptTarget.Latest, true, import_typescript11.default.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  return decl.initializer;
+}
+function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
+  if (!import_typescript11.default.isTaggedTemplateExpression(expr))
+    return expr;
+  if (!import_typescript11.default.isIdentifier(expr.tag))
+    return expr;
+  const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx);
+  if (!resolvedTag)
+    return expr;
+  if (!isInterleaveTagFunction(resolvedTag))
+    return expr;
+  const rewritten = buildUntaggedTemplateLiteral(expr, ctx);
+  return rewritten ?? expr;
+}
+function resolveInterleaveTagIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function isInterleaveTagFunction(fn) {
+  if (!import_typescript11.default.isArrowFunction(fn) && !import_typescript11.default.isFunctionExpression(fn))
+    return false;
+  if (fn.parameters.length !== 2)
+    return false;
+  const [partsParam, argsParam] = fn.parameters;
+  if (!import_typescript11.default.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
+    return false;
+  if (!import_typescript11.default.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
+    return false;
+  const parsed = tsNodeToParsedExpr(fn);
+  if (parsed.kind !== "arrow")
+    return false;
+  return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
+}
+function isInterleaveReduceCall(body, partsName, argsName) {
+  if (body.kind !== "call" || body.args.length !== 2)
+    return false;
+  const { callee, args } = body;
+  if (callee.kind !== "member" || callee.computed || callee.property !== "reduce")
+    return false;
+  if (callee.object.kind !== "identifier" || callee.object.name !== partsName)
+    return false;
+  const [callback, init] = args;
+  if (init.kind !== "literal" || init.literalType !== "string" || init.value !== "")
+    return false;
+  if (callback.kind !== "arrow" || callback.params.length !== 3)
+    return false;
+  const [acc, p, i2] = callback.params;
+  return isInterleaveReduceCallbackBody(callback.body, acc, p, i2, argsName);
+}
+function isInterleaveReduceCallbackBody(body, acc, p, i2, argsName) {
+  if (body.kind !== "binary" || body.op !== "+")
+    return false;
+  const { left, right } = body;
+  if (left.kind !== "binary" || left.op !== "+")
+    return false;
+  if (left.left.kind !== "identifier" || left.left.name !== acc)
+    return false;
+  if (left.right.kind !== "identifier" || left.right.name !== p)
+    return false;
+  return isInterleaveSpanExpr(right, i2, argsName);
+}
+function isInterleaveSpanExpr(expr, i2, argsName) {
+  let inner = expr;
+  if (inner.kind === "call" && inner.args.length === 1 && inner.callee.kind === "identifier" && inner.callee.name === "String") {
+    inner = inner.args[0];
+  }
+  if (inner.kind !== "logical" || inner.op !== "??")
+    return false;
+  if (inner.right.kind !== "literal" || inner.right.literalType !== "string" || inner.right.value !== "") {
+    return false;
+  }
+  const idx = inner.left;
+  if (idx.kind !== "index-access")
+    return false;
+  if (idx.object.kind !== "identifier" || idx.object.name !== argsName)
+    return false;
+  if (idx.index.kind !== "identifier" || idx.index.name !== i2)
+    return false;
+  return true;
+}
+function buildUntaggedTemplateLiteral(node, ctx) {
+  const template = node.template;
+  let text;
+  if (import_typescript11.default.isNoSubstitutionTemplateLiteral(template)) {
+    text = "`" + (template.rawText ?? template.text) + "`";
+  } else {
+    let body = template.head.rawText ?? template.head.text;
+    for (const span of template.templateSpans) {
+      const spanText = ctx.getJS(span.expression);
+      body += "${(" + spanText + ") ?? ''}";
+      body += span.literal.rawText ?? span.literal.text;
+    }
+    text = "`" + body + "`";
+  }
+  const wrapped = `const __bf_resolve_tagged__ = (${text})`;
+  const sf = import_typescript11.default.createSourceFile("__bf_resolve_tagged.tsx", wrapped, import_typescript11.default.ScriptTarget.Latest, true, import_typescript11.default.ScriptKind.TSX);
+  const stmt = sf.statements[0];
+  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  const result = import_typescript11.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!import_typescript11.default.isTemplateExpression(result) && !import_typescript11.default.isNoSubstitutionTemplateLiteral(result))
+    return null;
+  return result;
+}
 function parseTernary(expr, ctx) {
   const whenTrueValue = getStringValue(expr.whenTrue);
   const whenFalseValue = getStringValue(expr.whenFalse);
@@ -195336,6 +195631,18 @@ var import_typescript12 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/relocate.ts
 var import_typescript13 = __toESM(require_typescript(), 1);
+
+// ../jsx/src/lowering-registry.ts
+var plugins = [];
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0)
+    plugins[existing] = plugin;
+  else
+    plugins.push(plugin);
+}
+
+// ../jsx/src/relocate.ts
 var REGISTRY_SAFE_BINDING_KINDS = new Set([
   "global",
   "module-import",
@@ -195633,38 +195940,6 @@ class SourceMapGenerator {
   }
 }
 
-// ../jsx/src/module-exports.ts
-function formatParamWithType(p) {
-  const rest = p.isRest ? "..." : "";
-  const optional = p.optional ? "?" : "";
-  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
-  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
-  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
-}
-function findReachableNames(primaryRefs, declarations) {
-  const allNames = new Set(declarations.map((d) => d.name));
-  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
-  const reachable = new Set;
-  const queue = [];
-  for (const name of allNames) {
-    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
-      reachable.add(name);
-      queue.push(name);
-    }
-  }
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const body = bodyMap.get(current) || "";
-    for (const name of allNames) {
-      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
-        reachable.add(name);
-        queue.push(name);
-      }
-    }
-  }
-  return reachable;
-}
-
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
 var import_typescript15 = __toESM(require_typescript(), 1);
 
@@ -196163,15 +196438,6 @@ function isOmitBranch(node) {
   }
   return false;
 }
-// ../jsx/src/lowering-registry.ts
-var plugins = [];
-function registerLoweringPlugin(plugin) {
-  const existing = plugins.findIndex((p) => p.name === plugin.name);
-  if (existing >= 0)
-    plugins[existing] = plugin;
-  else
-    plugins.push(plugin);
-}
 // ../jsx/src/builtin-lowering-plugins.ts
 var queryHrefPlugin = {
   name: "queryHref",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.17.1"
+    "@barefootjs/jsx": "0.18.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0"