@barefootjs/test 0.16.0 → 0.17.1

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.16.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.16.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