@barefootjs/test 0.17.0 → 0.17.1

package/dist/index.js

@@ -187348,6 +187348,7 @@ function tsNodeToParsedExpr(node) {
 }
 var CALLBACK_METHODS = new Set([
   "filter",
+  "map",
   "every",
   "some",
   "find",
@@ -195464,6 +195465,9 @@ var JS_BUILTINS = new Set([
 var ENV_SIGNAL_CLIENT_FACTORY = {
   search: "createSearchParams"
 };
+var ENV_SIGNAL_READERS = new Map([
+  ["search", { key: "search", canonicalName: "searchParams", methods: new Set(["get"]) }]
+]);
 function queryHrefLocalNames(metadata) {
   const names = new Set;
   for (const imp of metadata.imports) {
@@ -195668,9 +195672,12 @@ var import_typescript15 = __toESM(require_typescript(), 1);
 var import_typescript16 = __toESM(require_typescript(), 1);
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
+
+// ../jsx/src/augment-inherited-props.ts
+var import_typescript17 = __toESM(require_typescript(), 1);
 // ../jsx/src/shared-program.ts
 init_path();
-var import_typescript17 = __toESM(require_typescript(), 1);
+var import_typescript18 = __toESM(require_typescript(), 1);
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -196184,9 +196191,9 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-var import_typescript18 = __toESM(require_typescript(), 1);
-// ../jsx/src/debug.ts
 var import_typescript19 = __toESM(require_typescript(), 1);
+// ../jsx/src/debug.ts
+var import_typescript20 = __toESM(require_typescript(), 1);
 function escapeForIdBoundary(name) {
   return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -196278,8 +196285,6 @@ function resolveSetters(handler, setterToSignal, fnSetters) {
   return refs;
 }
 // ../jsx/src/profiler.ts
-var import_typescript20 = __toESM(require_typescript(), 1);
-// ../jsx/src/augment-inherited-props.ts
 var import_typescript21 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/index.ts
@@ -196378,6 +196383,7 @@ function irNodeToTestNode(node, constantMap, metadata) {
   const cmap = constantMap ?? new Map;
   const setterToSignal = new Map;
   const fnSetters = new Map;
+  const defaults = new Map;
   if (metadata) {
     for (const s of metadata.signals) {
       if (s.setter)
@@ -196386,8 +196392,24 @@ function irNodeToTestNode(node, constantMap, metadata) {
     for (const [k, v] of buildLocalFunctionSetterMap(metadata, setterToSignal)) {
       fnSetters.set(k, v);
     }
+    for (const p of metadata.propsParams) {
+      const lit = p.defaultValue !== undefined ? parseLiteralDefault(p.defaultValue) : null;
+      if (lit !== null)
+        defaults.set(p.name, lit);
+    }
+  }
+  return convert(node, { cmap, setterToSignal, fnSetters, defaults });
+}
+function parseLiteralDefault(js) {
+  const v = js.trim();
+  if (v.startsWith("'") && v.endsWith("'") && !v.slice(1, -1).includes("'") || v.startsWith('"') && v.endsWith('"') && !v.slice(1, -1).includes('"')) {
+    return v.slice(1, -1);
   }
-  return convert(node, { cmap, setterToSignal, fnSetters });
+  if (/^-?\d+(\.\d+)?$/.test(v))
+    return v;
+  if (v === "true" || v === "false")
+    return v;
+  return null;
 }
 function convert(node, ctx) {
   switch (node.type) {
@@ -196396,7 +196418,7 @@ function convert(node, ctx) {
     case "text":
       return convertText(node);
     case "expression":
-      return convertExpression(node);
+      return convertExpression(node, ctx);
     case "conditional":
       return convertConditional(node, ctx);
     case "loop":
@@ -196426,19 +196448,9 @@ function convertElement(node, ctx) {
   let dataState = null;
   let classes = [];
   for (const attr of node.attrs) {
-    const value = resolveAttrValue(attr);
+    const value = resolveAttrValue(attr, ctx);
     if (attr.name === "className" || attr.name === "class") {
-      if (typeof value === "string") {
-        const isDynamic = attr.value.kind === "expression" || attr.value.kind === "template" || attr.value.kind === "spread";
-        if (isDynamic && ctx.cmap.size > 0) {
-          const resolved = resolveClassValue(value, ctx.cmap);
-          if (resolved !== null) {
-            classes = resolved.split(/\s+/).filter(Boolean);
-            continue;
-          }
-        }
-        classes = value.split(/\s+/).filter(Boolean);
-      }
+      classes = collectClassTokens(attr.value, value, ctx);
       continue;
     }
     if (attr.name === "role") {
@@ -196501,12 +196513,13 @@ function convertText(node) {
     componentName: null
   });
 }
-function convertExpression(node) {
+function convertExpression(node, ctx) {
+  const text = ctx.defaults.get(node.expr.trim()) ?? node.expr;
   return new TestNode({
     tag: null,
     type: "expression",
     children: [],
-    text: node.expr,
+    text,
     props: {},
     classes: [],
     role: null,
@@ -196571,7 +196584,7 @@ function convertComponent(node, ctx) {
         props[prop.name] = prop.value.expr;
         break;
       case "template":
-        props[prop.name] = resolveTemplateAttr(prop.value);
+        props[prop.name] = resolveTemplateAttr(prop.value, ctx);
         break;
       case "boolean-shorthand":
       case "boolean-attr":
@@ -196711,41 +196724,69 @@ function refsToHandler(refs) {
   }
   return { setters, via };
 }
-function resolveClassValue(value, cmap) {
-  if (cmap.has(value)) {
-    return cmap.get(value);
+function splitClassTokens(value) {
+  return value.split(/\s+/).filter((t) => t && !t.includes("${"));
+}
+function collectClassTokens(attrValue, resolved, ctx) {
+  if (attrValue.kind === "template") {
+    const joined = attrValue.parts.map((part) => {
+      if (part.type === "string")
+        return substituteInterpolations(part.value, ctx);
+      if (part.type === "ternary")
+        return `${part.whenTrue} ${part.whenFalse}`;
+      return Object.values(part.cases).join(" ");
+    }).join("");
+    return splitClassTokens(joined);
+  }
+  if (typeof resolved !== "string")
+    return [];
+  const isDynamic = attrValue.kind === "expression" || attrValue.kind === "spread";
+  if (isDynamic) {
+    const value = resolveClassValue(resolved, ctx);
+    if (value !== null)
+      return splitClassTokens(value);
+  }
+  return splitClassTokens(resolved);
+}
+function substituteInterpolations(value, ctx) {
+  return value.replace(/\$\{([^}]+)\}/g, (raw, expr) => {
+    const trimmed = expr.trim();
+    return ctx.cmap.get(trimmed) ?? ctx.defaults.get(trimmed) ?? raw;
+  });
+}
+function resolveClassValue(value, ctx) {
+  if (ctx.cmap.has(value)) {
+    return ctx.cmap.get(value);
+  }
+  if (ctx.defaults.has(value)) {
+    return ctx.defaults.get(value);
   }
   if (value.startsWith("`") && value.endsWith("`")) {
-    const inner = value.slice(1, -1);
-    return inner.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-      const trimmed = expr.trim();
-      return cmap.get(trimmed) ?? "";
-    });
+    return substituteInterpolations(value.slice(1, -1), ctx);
   }
   return null;
 }
-function resolveAttrValue(attr) {
+function resolveAttrValue(attr, ctx) {
   switch (attr.value.kind) {
     case "boolean-attr":
       return true;
     case "literal":
       return attr.value.value;
     case "expression":
-      return attr.value.expr;
     case "spread":
-      return attr.value.expr;
+      return ctx.defaults.get(attr.value.expr.trim()) ?? attr.value.expr;
     case "template":
-      return resolveTemplateAttr(attr.value);
+      return resolveTemplateAttr(attr.value, ctx);
     case "boolean-shorthand":
       return true;
     case "jsx-children":
       return null;
   }
 }
-function resolveTemplateAttr(tl) {
+function resolveTemplateAttr(tl, ctx) {
   return tl.parts.map((part) => {
     if (part.type === "string")
-      return part.value;
+      return substituteInterpolations(part.value, ctx);
     if (part.type === "ternary")
       return `{${part.condition}}`;
     return Object.values(part.cases).join(" ");

package/dist/ir-to-test-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir-to-test-node.d.ts","sourceRoot":"","sources":["../src/ir-to-test-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAYN,UAAU,EACX,MAAM,iBAAiB,CAAA;AAMxB,OAAO,EAAE,QAAQ,EAAqB,MAAM,gBAAgB,CAAA;AAQ5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,CAajH"}
+{"version":3,"file":"ir-to-test-node.d.ts","sourceRoot":"","sources":["../src/ir-to-test-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAYN,UAAU,EACX,MAAM,iBAAiB,CAAA;AAMxB,OAAO,EAAE,QAAQ,EAAqB,MAAM,gBAAgB,CAAA;AAU5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,CAuBjH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.17.0",
+  "version": "0.17.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.0"
+    "@barefootjs/jsx": "0.17.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0"

package/src/ir-to-test-node.ts

@@ -30,12 +30,15 @@ interface ConvertContext {
   cmap: Map<string, string>
   setterToSignal: Map<string, string>
   fnSetters: Map<string, FnSetterResolution[]>
+  /** Prop name → literal destructure-default value (`{ size = 'md' }` → `size: 'md'`). */
+  defaults: Map<string, string>
 }
 
 export function irNodeToTestNode(node: IRNode, constantMap?: Map<string, string>, metadata?: IRMetadata): TestNode {
   const cmap = constantMap ?? new Map<string, string>()
   const setterToSignal = new Map<string, string>()
   const fnSetters = new Map<string, FnSetterResolution[]>()
+  const defaults = new Map<string, string>()
   if (metadata) {
     for (const s of metadata.signals) {
       if (s.setter) setterToSignal.set(s.setter, s.getter)
@@ -43,8 +46,35 @@ export function irNodeToTestNode(node: IRNode, constantMap?: Map<string, string>
     for (const [k, v] of buildLocalFunctionSetterMap(metadata, setterToSignal)) {
       fnSetters.set(k, v)
     }
+    // renderToTest models the component compiled with NO incoming props,
+    // so a literal destructure default IS the statically-known value of
+    // that prop (#2069). Non-literal defaults (arrows, objects, computed
+    // expressions) stay unresolved — surfacing a stale expression string
+    // would be worse than the raw reference.
+    for (const p of metadata.propsParams) {
+      const lit = p.defaultValue !== undefined ? parseLiteralDefault(p.defaultValue) : null
+      if (lit !== null) defaults.set(p.name, lit)
+    }
   }
-  return convert(node, { cmap, setterToSignal, fnSetters })
+  return convert(node, { cmap, setterToSignal, fnSetters, defaults })
+}
+
+/**
+ * Parse a `ParamInfo.defaultValue` JS-text into a plain string when it is
+ * a self-contained literal: quoted string, number, or boolean. Returns
+ * null for anything else.
+ */
+function parseLiteralDefault(js: string): string | null {
+  const v = js.trim()
+  if (
+    (v.startsWith("'") && v.endsWith("'") && !v.slice(1, -1).includes("'")) ||
+    (v.startsWith('"') && v.endsWith('"') && !v.slice(1, -1).includes('"'))
+  ) {
+    return v.slice(1, -1)
+  }
+  if (/^-?\d+(\.\d+)?$/.test(v)) return v
+  if (v === 'true' || v === 'false') return v
+  return null
 }
 
 function convert(node: IRNode, ctx: ConvertContext): TestNode {
@@ -54,7 +84,7 @@ function convert(node: IRNode, ctx: ConvertContext): TestNode {
     case 'text':
       return convertText(node)
     case 'expression':
-      return convertExpression(node)
+      return convertExpression(node, ctx)
     case 'conditional':
       return convertConditional(node, ctx)
     case 'loop':
@@ -90,20 +120,10 @@ function convertElement(node: IRElement, ctx: ConvertContext): TestNode {
   let classes: string[] = []
 
   for (const attr of node.attrs) {
-    const value = resolveAttrValue(attr)
+    const value = resolveAttrValue(attr, ctx)
 
     if (attr.name === 'className' || attr.name === 'class') {
-      if (typeof value === 'string') {
-        const isDynamic = attr.value.kind === 'expression' || attr.value.kind === 'template' || attr.value.kind === 'spread'
-        if (isDynamic && ctx.cmap.size > 0) {
-          const resolved = resolveClassValue(value, ctx.cmap)
-          if (resolved !== null) {
-            classes = resolved.split(/\s+/).filter(Boolean)
-            continue
-          }
-        }
-        classes = value.split(/\s+/).filter(Boolean)
-      }
+      classes = collectClassTokens(attr.value, value, ctx)
       continue
     }
 
@@ -178,12 +198,20 @@ function convertText(node: IRText): TestNode {
 // Expression
 // ---------------------------------------------------------------------------
 
-function convertExpression(node: IRExpression): TestNode {
+function convertExpression(node: IRExpression, ctx: ConvertContext): TestNode {
+  // A bare reference to a defaulted prop (`<div>{label}</div>` with
+  // `{ label = 'Hello' }`) resolves to its literal default, so
+  // `findByText('Hello')` sees the zero-props render (#2069). Prop refs
+  // are flagged reactive (they update on parent re-render), so this
+  // keys off defaults-map membership, not the reactive flag: signal /
+  // memo reads are call expressions (`count()`), never bare identifiers,
+  // and keep their source text — wiring is the assertion surface there.
+  const text = ctx.defaults.get(node.expr.trim()) ?? node.expr
   return new TestNode({
     tag: null,
     type: 'expression',
     children: [],
-    text: node.expr,
+    text,
     props: {},
     classes: [],
     role: null,
@@ -265,7 +293,7 @@ function convertComponent(node: IRComponent, ctx: ConvertContext): TestNode {
         props[prop.name] = prop.value.expr
         break
       case 'template':
-        props[prop.name] = resolveTemplateAttr(prop.value)
+        props[prop.name] = resolveTemplateAttr(prop.value, ctx)
         break
       case 'boolean-shorthand':
       case 'boolean-attr':
@@ -450,19 +478,77 @@ function refsToHandler(refs: SetterRef[]): EventHandler {
   return { setters, via }
 }
 
-function resolveClassValue(value: string, cmap: Map<string, string>): string | null {
-  // Simple identifier lookup
-  if (cmap.has(value)) {
-    return cmap.get(value)!
+/**
+ * Split a resolved className value into tokens, dropping any span that
+ * still carries an unresolved runtime interpolation (`${className}`,
+ * `foo-${x}`). Those are dynamic passthroughs the IR can't evaluate —
+ * they aren't real class tokens, and leaking them verbatim pollutes
+ * `.classes` for exact-match assertions.
+ */
+function splitClassTokens(value: string): string[] {
+  return value.split(/\s+/).filter(t => t && !t.includes('${'))
+}
+
+/**
+ * Resolve a className attribute value into its class tokens.
+ *
+ * For a structured template attr the parts are walked directly so class
+ * collection keeps union semantics per part kind:
+ *   - `lookup` (`${MAP[KEY]}`) → every case's tokens (PR #2000)
+ *   - `ternary` (`cond ? 'on' : 'off'`) → both branches' tokens,
+ *     matching the intermediate-const `valueBranches` union (#525)
+ *   - `string` spans → literal text, with `${ident}` interpolations
+ *     substituted from resolved consts / literal prop defaults
+ * For expression attrs the value resolves through local consts (cmap)
+ * and literal prop defaults. Anything still carrying a `${...}`
+ * interpolation is dropped by `splitClassTokens`.
+ */
+function collectClassTokens(attrValue: AttrValue, resolved: string | boolean | null, ctx: ConvertContext): string[] {
+  if (attrValue.kind === 'template') {
+    const joined = attrValue.parts
+      .map(part => {
+        if (part.type === 'string') return substituteInterpolations(part.value, ctx)
+        if (part.type === 'ternary') return `${part.whenTrue} ${part.whenFalse}`
+        return Object.values(part.cases).join(' ')
+      })
+      .join('')
+    return splitClassTokens(joined)
+  }
+
+  if (typeof resolved !== 'string') return []
+
+  const isDynamic = attrValue.kind === 'expression' || attrValue.kind === 'spread'
+  if (isDynamic) {
+    const value = resolveClassValue(resolved, ctx)
+    if (value !== null) return splitClassTokens(value)
+  }
+  return splitClassTokens(resolved)
+}
+
+/**
+ * Replace `${ident}` interpolations with a resolved const or a literal
+ * prop default; unresolvable spans are kept verbatim so the caller's
+ * token filter can drop them.
+ */
+function substituteInterpolations(value: string, ctx: ConvertContext): string {
+  return value.replace(/\$\{([^}]+)\}/g, (raw, expr) => {
+    const trimmed = expr.trim()
+    return ctx.cmap.get(trimmed) ?? ctx.defaults.get(trimmed) ?? raw
+  })
+}
+
+function resolveClassValue(value: string, ctx: ConvertContext): string | null {
+  // Simple identifier lookup: a local const or a literal prop default.
+  if (ctx.cmap.has(value)) {
+    return ctx.cmap.get(value)!
+  }
+  if (ctx.defaults.has(value)) {
+    return ctx.defaults.get(value)!
   }
 
   // Template literal: `...${var}...`
   if (value.startsWith('`') && value.endsWith('`')) {
-    const inner = value.slice(1, -1)
-    return inner.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-      const trimmed = expr.trim()
-      return cmap.get(trimmed) ?? ''
-    })
+    return substituteInterpolations(value.slice(1, -1), ctx)
   }
 
   return null
@@ -472,18 +558,22 @@ function resolveClassValue(value: string, cmap: Map<string, string>): string | n
 // Attribute value resolution
 // ---------------------------------------------------------------------------
 
-function resolveAttrValue(attr: IRAttribute): string | boolean | null {
+function resolveAttrValue(attr: IRAttribute, ctx: ConvertContext): string | boolean | null {
   switch (attr.value.kind) {
     case 'boolean-attr':
       return true
     case 'literal':
       return attr.value.value
     case 'expression':
-      return attr.value.expr
     case 'spread':
-      return attr.value.expr
+      // A bare reference to a defaulted prop (`type={type}` with
+      // `{ type = 'button' }`) resolves to its literal default —
+      // renderToTest models the zero-props render, where the default
+      // IS the value (#2069). Anything non-bare keeps the expression
+      // text (the wiring-visible representation).
+      return ctx.defaults.get(attr.value.expr.trim()) ?? attr.value.expr
     case 'template':
-      return resolveTemplateAttr(attr.value)
+      return resolveTemplateAttr(attr.value, ctx)
     case 'boolean-shorthand':
       return true
     case 'jsx-children':
@@ -491,10 +581,12 @@ function resolveAttrValue(attr: IRAttribute): string | boolean | null {
   }
 }
 
-function resolveTemplateAttr(tl: TemplateAttr): string {
+function resolveTemplateAttr(tl: TemplateAttr, ctx: ConvertContext): string {
   return tl.parts
     .map(part => {
-      if (part.type === 'string') return part.value
+      // `${ident}` interpolations against a literal prop default
+      // resolve like local consts do (#2069).
+      if (part.type === 'string') return substituteInterpolations(part.value, ctx)
       if (part.type === 'ternary') return `{${part.condition}}`
       // `lookup` (`Record<T, string>[key]`) — the test framework
       // doesn't render against a specific key, so concatenate every