@barefootjs/test 0.26.0 → 0.26.2

package/dist/index.js

@@ -188803,6 +188803,15 @@ var EVAL_MATH_METHODS = new Set([
   "ceil",
   "round"
 ]);
+function identifierPath(callee) {
+  if (callee.kind === "identifier")
+    return callee.name;
+  if (callee.kind === "member" && !callee.computed) {
+    const head = identifierPath(callee.object);
+    return head ? `${head}.${callee.property}` : null;
+  }
+  return null;
+}
 
 // ../jsx/src/prop-rewrite.ts
 var import_typescript5 = __toESM(require_typescript(), 1);
@@ -198789,12 +198798,37 @@ function collectClassTokens(attrValue, resolved, ctx) {
     return [];
   const isDynamic = attrValue.kind === "expression" || attrValue.kind === "spread";
   if (isDynamic) {
+    if (attrValue.kind === "expression" && attrValue.parsed?.kind === "conditional") {
+      const value2 = resolveParsedClass(attrValue.parsed, ctx);
+      return value2 === null ? [] : splitClassTokens(value2);
+    }
     const value = resolveClassValue(resolved, ctx);
     if (value !== null)
       return splitClassTokens(value);
   }
   return splitClassTokens(resolved);
 }
+function resolveParsedClass(expr, ctx) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.literalType === "string" ? String(expr.value) : null;
+    case "identifier":
+      return ctx.cmap.get(expr.name) ?? ctx.defaults.get(expr.name) ?? null;
+    case "member": {
+      const path = identifierPath(expr);
+      return path === null ? null : ctx.cmap.get(path) ?? null;
+    }
+    case "conditional": {
+      const whenTrue = resolveParsedClass(expr.consequent, ctx);
+      const whenFalse = resolveParsedClass(expr.alternate, ctx);
+      if (whenTrue === null && whenFalse === null)
+        return null;
+      return [whenTrue, whenFalse].filter((v) => v !== null).join(" ");
+    }
+    default:
+      return null;
+  }
+}
 function substituteInterpolations(value, ctx) {
   return value.replace(/\$\{([^}]+)\}/g, (raw, expr) => {
     const trimmed = expr.trim();
@@ -198844,6 +198878,14 @@ function resolveTemplateAttr(tl, ctx) {
 function resolveConstants(constants3) {
   const resolved = new Map;
   for (const c of constants3) {
+    if (c.parsed?.kind === "object-literal") {
+      for (const prop of c.parsed.properties) {
+        const value2 = resolveObjectPropValue(prop.value, resolved);
+        if (value2 !== null)
+          resolved.set(`${c.name}.${prop.key}`, value2);
+      }
+      continue;
+    }
     if (!c.value)
       continue;
     if (c.valueBranches) {
@@ -198868,6 +198910,31 @@ function resolveConstants(constants3) {
   }
   return resolved;
 }
+function resolveObjectPropValue(expr, resolved) {
+  if (expr.kind === "literal" && expr.literalType === "string") {
+    return String(expr.value);
+  }
+  if (expr.kind === "identifier") {
+    return resolved.get(expr.name) ?? null;
+  }
+  if (expr.kind === "template-literal") {
+    const strs = [];
+    for (const part of expr.parts) {
+      if (part.type === "string") {
+        strs.push(part.value);
+        continue;
+      }
+      if (part.expr.kind !== "identifier")
+        return null;
+      const value = resolved.get(part.expr.name);
+      if (value === undefined)
+        return null;
+      strs.push(value);
+    }
+    return strs.join("");
+  }
+  return null;
+}
 function tryResolve(raw, resolved) {
   const value = raw.trim();
   if (value.startsWith("'") && value.endsWith("'") && !value.slice(1, -1).includes("'")) {

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;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"}
+{"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,EAEX,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/dist/resolve-constants.d.ts

@@ -7,17 +7,25 @@
  * (from ternary initializers), those are used directly instead of
  * re-parsing from the string representation.
  */
+import type { ParsedExpr } from '@barefootjs/jsx';
 /**
  * Build a map of constant name → resolved string value.
  * Resolves string literals, template literals, array.join() patterns,
  * and plain identifier references. When `valueBranches` is present
  * (from ternary initializers), each branch is resolved and merged
- * with union semantics. Record lookups, function expressions, and
- * other complex values are skipped.
+ * with union semantics. An object-literal const with string-literal,
+ * template-literal, or bare-identifier-valued properties (`const rowClass
+ * = { active: \`${base} row-active\`, plain: base }`) additionally seeds
+ * member-path
+ * keys (`rowClass.active` → `'row row-active'`) so a member-access
+ * className (`className={rowClass.active}`, or a ternary arm) resolves
+ * through the same lookup (#2354, template-literal values #2360).
+ * Function expressions and other complex property values are skipped.
  */
 export declare function resolveConstants(constants: Array<{
     name: string;
     value?: string;
     valueBranches?: string[];
+    parsed?: ParsedExpr;
 }>): Map<string, string>;
 //# sourceMappingURL=resolve-constants.d.ts.map

package/dist/resolve-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-constants.d.ts","sourceRoot":"","sources":["../src/resolve-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GAC3E,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BrB"}
+{"version":3,"file":"resolve-constants.d.ts","sourceRoot":"","sources":["../src/resolve-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC,GAChG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CrB"}

package/package.json

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

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

@@ -18,8 +18,9 @@ import type {
   IRProvider,
   IRAsync,
   IRMetadata,
+  ParsedExpr,
 } from '@barefootjs/jsx'
-import { resolveSetters, buildLocalFunctionSetterMap, type SetterRef, type FnSetterResolution } from '@barefootjs/jsx'
+import { resolveSetters, buildLocalFunctionSetterMap, identifierPath, type SetterRef, type FnSetterResolution } from '@barefootjs/jsx'
 
 type IRAttribute = IRElement['attrs'][number]
 type AttrValue = IRAttribute['value']
@@ -500,8 +501,17 @@ function splitClassTokens(value: string): string[] {
  *   - `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`.
+ * and literal prop defaults. A bare `className={cond ? a : b}` ternary
+ * (no backticks) is walked structurally through the attr's `parsed`
+ * tree — the `expression`-kind analogue of the `template` branch's
+ * `ternary` part handling — so both arms union with the same semantics,
+ * and an unresolvable ternary yields `[]` rather than leaking its own
+ * operator tokens (`?`/`:`) and member fragments as class names (#2354).
+ * A non-ternary expression keeps the historical fallback: a resolved
+ * value splits into tokens, otherwise the raw source passes through
+ * (an unresolvable bare identifier surfaces as its name — a proxy some
+ * tests assert on). Anything still carrying a `${...}` interpolation is
+ * dropped by `splitClassTokens`.
  */
 function collectClassTokens(attrValue: AttrValue, resolved: string | boolean | null, ctx: ConvertContext): string[] {
   if (attrValue.kind === 'template') {
@@ -519,12 +529,53 @@ function collectClassTokens(attrValue: AttrValue, resolved: string | boolean | n
 
   const isDynamic = attrValue.kind === 'expression' || attrValue.kind === 'spread'
   if (isDynamic) {
+    // Bare `className={cond ? a : b}`: no backticks, so it never becomes a
+    // structured `template` attr. Walk the parsed ternary and union both
+    // arms — resolving identifier / member-access branches through the
+    // same cmap as everything else. A CSS class can never contain the
+    // `?`/`:` operator tokens the old raw-source fallback leaked here, so
+    // an unresolvable ternary suppresses to `[]` instead (#2354).
+    if (attrValue.kind === 'expression' && attrValue.parsed?.kind === 'conditional') {
+      const value = resolveParsedClass(attrValue.parsed, ctx)
+      return value === null ? [] : splitClassTokens(value)
+    }
     const value = resolveClassValue(resolved, ctx)
     if (value !== null) return splitClassTokens(value)
   }
   return splitClassTokens(resolved)
 }
 
+/**
+ * Reduce a parsed className expression to its resolved class string, or
+ * `null` when no branch resolves. Handles the shapes a className ternary
+ * reaches for: string literals, local-const / prop-default identifiers,
+ * object-property member access (`rowClass.active`, resolved through the
+ * member-path keys `resolveConstants` seeds), and nested ternaries. Both
+ * arms of a ternary union (matching the `template` ternary part and the
+ * intermediate-const `valueBranches` handling), since the IR can't pick a
+ * concrete arm without the runtime condition. (#2354)
+ */
+function resolveParsedClass(expr: ParsedExpr, ctx: ConvertContext): string | null {
+  switch (expr.kind) {
+    case 'literal':
+      return expr.literalType === 'string' ? String(expr.value) : null
+    case 'identifier':
+      return ctx.cmap.get(expr.name) ?? ctx.defaults.get(expr.name) ?? null
+    case 'member': {
+      const path = identifierPath(expr)
+      return path === null ? null : ctx.cmap.get(path) ?? null
+    }
+    case 'conditional': {
+      const whenTrue = resolveParsedClass(expr.consequent, ctx)
+      const whenFalse = resolveParsedClass(expr.alternate, ctx)
+      if (whenTrue === null && whenFalse === null) return null
+      return [whenTrue, whenFalse].filter((v): v is string => v !== null).join(' ')
+    }
+    default:
+      return null
+  }
+}
+
 /**
  * Replace `${ident}` interpolations with a resolved const or a literal
  * prop default; unresolvable spans are kept verbatim so the caller's

package/src/resolve-constants.ts

@@ -8,20 +8,43 @@
  * re-parsing from the string representation.
  */
 
+import type { ParsedExpr } from '@barefootjs/jsx'
+
 /**
  * Build a map of constant name → resolved string value.
  * Resolves string literals, template literals, array.join() patterns,
  * and plain identifier references. When `valueBranches` is present
  * (from ternary initializers), each branch is resolved and merged
- * with union semantics. Record lookups, function expressions, and
- * other complex values are skipped.
+ * with union semantics. An object-literal const with string-literal,
+ * template-literal, or bare-identifier-valued properties (`const rowClass
+ * = { active: \`${base} row-active\`, plain: base }`) additionally seeds
+ * member-path
+ * keys (`rowClass.active` → `'row row-active'`) so a member-access
+ * className (`className={rowClass.active}`, or a ternary arm) resolves
+ * through the same lookup (#2354, template-literal values #2360).
+ * Function expressions and other complex property values are skipped.
  */
 export function resolveConstants(
-  constants: Array<{ name: string; value?: string; valueBranches?: string[] }>
+  constants: Array<{ name: string; value?: string; valueBranches?: string[]; parsed?: ParsedExpr }>
 ): Map<string, string> {
   const resolved = new Map<string, string>()
 
   for (const c of constants) {
+    // Object-literal const: expose each resolvable property as a
+    // `name.key` member-path key. The object's OWN bare identifier
+    // (`c.name` referenced directly, e.g. `className={rowClass}`) stays
+    // unresolved — an object is not a class string — matching prior
+    // behavior; this is unrelated to a resolvable identifier-valued
+    // PROPERTY (`{ plain: base }`), handled by resolveObjectPropValue
+    // below (Copilot review, PR #2361).
+    if (c.parsed?.kind === 'object-literal') {
+      for (const prop of c.parsed.properties) {
+        const value = resolveObjectPropValue(prop.value, resolved)
+        if (value !== null) resolved.set(`${c.name}.${prop.key}`, value)
+      }
+      continue
+    }
+
     if (!c.value) continue
 
     // When the analyzer provides structured branch info, resolve each
@@ -47,6 +70,56 @@ export function resolveConstants(
   return resolved
 }
 
+/**
+ * Resolve one object-literal property's value to a string, for the
+ * `name.key` member-path seeding above. Supports the same shapes as
+ * `tryResolve` — string literal, template literal, plain identifier
+ * reference — but walks the already-structured `ParsedExpr` (available
+ * here, unlike `tryResolve`'s raw-string input) instead of re-parsing
+ * with a regex, and is stricter about "unresolvable": `tryResolve`'s
+ * template-literal branch folds an unresolved `${...}` to `''` (its
+ * caller only ever uses that for the whole-constant case, where a
+ * partial string is an acceptable degrade), but a property value here
+ * returns `null` for the whole property instead — seeding `name.key`
+ * with a misleadingly partial class string would be worse than not
+ * seeding it at all. A bare identifier property (`{ plain: base }`) and
+ * an interpolated identifier inside a template literal both resolve
+ * against `resolved` — safe because `resolveConstants` processes
+ * `constants` in declaration order, so a module-scope const referenced
+ * inside a later object literal's property is already in the map
+ * (#2360). Anything else (a nested object/array, a call, a binary
+ * expression, ...) is left unresolved, same posture as `tryResolve`
+ * skipping "complex values".
+ */
+function resolveObjectPropValue(expr: ParsedExpr, resolved: Map<string, string>): string | null {
+  if (expr.kind === 'literal' && expr.literalType === 'string') {
+    return String(expr.value)
+  }
+  if (expr.kind === 'identifier') {
+    return resolved.get(expr.name) ?? null
+  }
+  if (expr.kind === 'template-literal') {
+    const strs: string[] = []
+    for (const part of expr.parts) {
+      if (part.type === 'string') {
+        strs.push(part.value)
+        continue
+      }
+      // An interpolation that isn't a plain identifier reference (a
+      // conditional, a member access, ...), or one that IS an identifier
+      // but doesn't resolve, makes the whole template unresolved — don't
+      // fold it to '' and seed a partial, misleadingly "resolved" string
+      // (Copilot review, PR #2361).
+      if (part.expr.kind !== 'identifier') return null
+      const value = resolved.get(part.expr.name)
+      if (value === undefined) return null
+      strs.push(value)
+    }
+    return strs.join('')
+  }
+  return null
+}
+
 function tryResolve(raw: string, resolved: Map<string, string>): string | null {
   const value = raw.trim()