@barefootjs/test 0.25.0 → 0.26.1

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);
@@ -191421,6 +191430,37 @@ function extractFreeIdentifiersFromNode(node) {
   visit2(node);
   return ids;
 }
+function extractFreeTypeIdentifiersFromNode(node) {
+  const ids = new Set;
+  const boundTypeParams = new Set;
+  function rootName(name) {
+    return import_typescript8.default.isQualifiedName(name) ? rootName(name.left) : name;
+  }
+  function visit2(n) {
+    if (import_typescript8.default.isTypeReferenceNode(n)) {
+      const name = rootName(n.typeName).text;
+      if (!boundTypeParams.has(name))
+        ids.add(name);
+    }
+    if (import_typescript8.default.isTypeQueryNode(n)) {
+      const name = rootName(n.exprName).text;
+      if (!boundTypeParams.has(name))
+        ids.add(name);
+    }
+    if (import_typescript8.default.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
+      const names = n.typeParameters.map((p) => p.name.text);
+      for (const p of names)
+        boundTypeParams.add(p);
+      import_typescript8.default.forEachChild(n, visit2);
+      for (const p of names)
+        boundTypeParams.delete(p);
+      return;
+    }
+    import_typescript8.default.forEachChild(n, visit2);
+  }
+  visit2(node);
+  return ids;
+}
 function initializerShapeContainsJsx(node) {
   let found = false;
   function visit2(n) {
@@ -192243,16 +192283,17 @@ function buildEntryImportIndex(sf, filePath) {
       continue;
     if (!import_typescript8.default.isStringLiteral(stmt.moduleSpecifier))
       continue;
-    if (stmt.importClause?.isTypeOnly)
-      continue;
     const src = stmt.moduleSpecifier.text;
     const targetKey = src.startsWith("./") || src.startsWith("../") ? resolveRelativeImportToFile(src, filePath) ?? "unresolved:" + src : src;
+    const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
     const namedBindings = stmt.importClause?.namedBindings;
     if (namedBindings && import_typescript8.default.isNamedImports(namedBindings)) {
       for (const el of namedBindings.elements) {
-        if (el.isTypeOnly)
-          continue;
-        index.set(el.name.text, { targetKey, exportedName: (el.propertyName ?? el.name).text });
+        index.set(el.name.text, {
+          targetKey,
+          exportedName: (el.propertyName ?? el.name).text,
+          isTypeOnly: wholeTypeOnly || el.isTypeOnly
+        });
       }
     }
   }
@@ -192282,6 +192323,9 @@ function collectEntryBindingNames(sf) {
     if ((import_typescript8.default.isFunctionDeclaration(node) || import_typescript8.default.isClassDeclaration(node) || import_typescript8.default.isEnumDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
+    if ((import_typescript8.default.isTypeAliasDeclaration(node) || import_typescript8.default.isInterfaceDeclaration(node)) && node.name) {
+      names.add(node.name.text);
+    }
     if (import_typescript8.default.isFunctionLike(node)) {
       for (const p of node.parameters) {
         const out = [];
@@ -192477,7 +192521,11 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
           const required = [];
           const pending = [];
           let declinedEntry = null;
-          for (const ref of capture.importedRefs) {
+          const allRefs = [
+            ...capture.importedRefs.map((r) => ({ ...r, isTypeOnly: false })),
+            ...capture.importedTypeRefs.map((r) => ({ ...r, isTypeOnly: true }))
+          ];
+          for (const ref of allRefs) {
             let specifier;
             let targetKey;
             if (ref.source.startsWith("./") || ref.source.startsWith("../")) {
@@ -192497,7 +192545,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
               targetKey = ref.source;
             }
             const existing = entryImportIndex.get(ref.localName);
-            if (existing && existing.targetKey === targetKey && existing.exportedName === ref.exportedName) {
+            if (existing && existing.targetKey === targetKey && existing.exportedName === ref.exportedName && (ref.isTypeOnly || !existing.isTypeOnly)) {
               continue;
             }
             const planned = plannedInjections.get(ref.localName);
@@ -192511,7 +192559,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
               break;
             }
             pending.push([ref.localName, { targetKey, exportedName: ref.exportedName }]);
-            required.push({ localName: ref.localName, exportedName: ref.exportedName, specifier });
+            required.push({ localName: ref.localName, exportedName: ref.exportedName, specifier, isTypeOnly: ref.isTypeOnly || undefined });
           }
           if (declinedEntry) {
             result.declined.set(spec.local, declinedEntry);
@@ -192531,6 +192579,8 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
 }
 function collectHelperModuleValueBindings(sf) {
   const local = new Set;
+  const localTypes = new Set;
+  const importedTypes = new Map;
   const imported = new Map;
   for (const stmt of sf.statements) {
     if (import_typescript8.default.isVariableStatement(stmt)) {
@@ -192546,35 +192596,41 @@ function collectHelperModuleValueBindings(sf) {
       local.add(stmt.name.text);
       continue;
     }
+    if ((import_typescript8.default.isTypeAliasDeclaration(stmt) || import_typescript8.default.isInterfaceDeclaration(stmt)) && stmt.name) {
+      localTypes.add(stmt.name.text);
+      continue;
+    }
     if (import_typescript8.default.isImportDeclaration(stmt)) {
-      if (stmt.importClause?.isTypeOnly)
-        continue;
       if (!import_typescript8.default.isStringLiteral(stmt.moduleSpecifier))
         continue;
       const src = stmt.moduleSpecifier.text;
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime")
         continue;
+      const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
       if (stmt.importClause?.name)
-        local.add(stmt.importClause.name.text);
+        (wholeTypeOnly ? localTypes : local).add(stmt.importClause.name.text);
       const namedBindings = stmt.importClause?.namedBindings;
       if (namedBindings && import_typescript8.default.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) {
-          if (el.isTypeOnly)
-            continue;
-          imported.set(el.name.text, { source: src, exportedName: (el.propertyName ?? el.name).text });
+          const entry = { source: src, exportedName: (el.propertyName ?? el.name).text };
+          if (wholeTypeOnly || el.isTypeOnly)
+            importedTypes.set(el.name.text, entry);
+          else
+            imported.set(el.name.text, entry);
         }
       }
       if (namedBindings && import_typescript8.default.isNamespaceImport(namedBindings)) {
-        local.add(namedBindings.name.text);
+        (wholeTypeOnly ? localTypes : local).add(namedBindings.name.text);
       }
     }
   }
-  return { local, imported };
+  return { local, imported, localTypes, importedTypes };
 }
 function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   if (!fn.body)
-    return { captured: [], importedRefs: [] };
+    return { captured: [], importedRefs: [], importedTypeRefs: [] };
   const free = extractFreeIdentifiersFromNode(fn.body);
+  const freeTypes = extractFreeTypeIdentifiersFromNode(fn.body);
   const exclude = new Set(info.params);
   for (const b of info.localBindings)
     exclude.add(b);
@@ -192583,8 +192639,12 @@ function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   for (const p of REACTIVE_PRIMITIVES)
     exclude.add(p);
   exclude.add(selfName);
+  if (fn.typeParameters)
+    for (const p of fn.typeParameters)
+      exclude.add(p.name.text);
   const captured = [];
   const importedRefs = [];
+  const importedTypeRefs = [];
   for (const id of free) {
     if (exclude.has(id))
       continue;
@@ -192596,9 +192656,28 @@ function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
     if (imp)
       importedRefs.push({ localName: id, source: imp.source, exportedName: imp.exportedName });
   }
+  for (const id of freeTypes) {
+    if (exclude.has(id))
+      continue;
+    if (free.has(id))
+      continue;
+    if (moduleBindings.localTypes.has(id) || moduleBindings.local.has(id)) {
+      captured.push(id);
+      continue;
+    }
+    const typeImp = moduleBindings.importedTypes.get(id);
+    if (typeImp) {
+      importedTypeRefs.push({ localName: id, source: typeImp.source, exportedName: typeImp.exportedName });
+      continue;
+    }
+    const valueImp = moduleBindings.imported.get(id);
+    if (valueImp)
+      importedRefs.push({ localName: id, source: valueImp.source, exportedName: valueImp.exportedName });
+  }
   captured.sort();
   importedRefs.sort((a, b) => a.localName < b.localName ? -1 : 1);
-  return { captured, importedRefs };
+  importedTypeRefs.sort((a, b) => a.localName < b.localName ? -1 : 1);
+  return { captured, importedRefs, importedTypeRefs };
 }
 function detectReactiveFactory(node, sourceFile, filePath) {
   if (!node.body || !node.name)
@@ -192937,20 +193016,44 @@ function rewriteFactoryCallsInSource(source, prescan) {
   if (edits.length === 0)
     return source;
   const importsBySpecifier = new Map;
+  const typeImportsBySpecifier = new Map;
   for (const f of inlinedFactories) {
     for (const r of f.requiredImports ?? []) {
-      let names = importsBySpecifier.get(r.specifier);
+      const bySpecifier = r.isTypeOnly ? typeImportsBySpecifier : importsBySpecifier;
+      let names = bySpecifier.get(r.specifier);
       if (!names) {
         names = new Map;
-        importsBySpecifier.set(r.specifier, names);
+        bySpecifier.set(r.specifier, names);
       }
       names.set(r.localName, r.exportedName);
     }
   }
-  if (importsBySpecifier.size > 0) {
-    const lines = [...importsBySpecifier].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([spec, names]) => {
+  for (const [spec, typeNames] of typeImportsBySpecifier) {
+    const valueNames = importsBySpecifier.get(spec);
+    if (!valueNames)
+      continue;
+    for (const local of [...typeNames.keys()]) {
+      if (valueNames.has(local))
+        typeNames.delete(local);
+    }
+    if (typeNames.size === 0)
+      typeImportsBySpecifier.delete(spec);
+  }
+  if (importsBySpecifier.size > 0 || typeImportsBySpecifier.size > 0) {
+    const buildLine = (names, keyword, spec) => {
       const specifiers = [...names].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([local, exported]) => exported === local ? local : `${exported} as ${local}`);
-      return `import { ${specifiers.join(", ")} } from '${spec}'`;
+      return `import ${keyword}{ ${specifiers.join(", ")} } from '${spec}'`;
+    };
+    const allSpecifiers = new Set([...importsBySpecifier.keys(), ...typeImportsBySpecifier.keys()]);
+    const lines = [...allSpecifiers].sort().flatMap((spec) => {
+      const out2 = [];
+      const valueNames = importsBySpecifier.get(spec);
+      if (valueNames)
+        out2.push(buildLine(valueNames, "", spec));
+      const typeNames = typeImportsBySpecifier.get(spec);
+      if (typeNames)
+        out2.push(buildLine(typeNames, "type ", spec));
+      return out2;
     });
     const at = factoryImportInsertionOffset(sourceFile);
     edits.push({ start: at, end: at, replacement: at === 0 ? lines.join(`
@@ -193530,6 +193633,20 @@ function resolveFreeRefs(node, env) {
 
 // ../jsx/src/to-locale-date-lowering.ts
 var TO_LOCALE_TZ_RE = /^(?:UTC|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+var tzProbeCache = new Map;
+function isBuildResolvableTimeZone(value) {
+  const cached = tzProbeCache.get(value);
+  if (cached !== undefined)
+    return cached;
+  let verified;
+  try {
+    verified = new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone === value;
+  } catch {
+    verified = false;
+  }
+  tzProbeCache.set(value, verified);
+  return verified;
+}
 var PROBE_UTC = new Date(Date.UTC(2001, 1, 3));
 var formatCache = new Map;
 var namesCache = new Map;
@@ -193768,7 +193885,7 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
       return null;
     const value = String(prop.value.value);
     if (prop.key === "timeZone") {
-      if (!TO_LOCALE_TZ_RE.test(value))
+      if (!TO_LOCALE_TZ_RE.test(value) && !isBuildResolvableTimeZone(value))
         return null;
       tz = value;
     } else {
@@ -198681,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();
@@ -198736,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) {
+        if (prop.value.kind === "literal" && prop.value.literalType === "string") {
+          resolved.set(`${c.name}.${prop.key}`, String(prop.value.value));
+        }
+      }
+      continue;
+    }
     if (!c.value)
       continue;
     if (c.valueBranches) {

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,23 @@
  * (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-valued
+ * properties (`const rowClass = { active: 'row row-active', plain: 'row' }`)
+ * 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). Function
+ * expressions and other complex 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;;;;;;;;;;;GAWG;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,CAuCrB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.25.0",
+  "version": "0.26.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.25.0"
+    "@barefootjs/jsx": "0.26.1"
   },
   "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,38 @@
  * 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-valued
+ * properties (`const rowClass = { active: 'row row-active', plain: 'row' }`)
+ * 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). Function
+ * expressions and other complex 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 string-valued property as a
+    // `name.key` member-path key. The bare identifier stays unresolved
+    // (an object is not a class string), matching prior behavior.
+    if (c.parsed?.kind === 'object-literal') {
+      for (const prop of c.parsed.properties) {
+        if (prop.value.kind === 'literal' && prop.value.literalType === 'string') {
+          resolved.set(`${c.name}.${prop.key}`, String(prop.value.value))
+        }
+      }
+      continue
+    }
+
     if (!c.value) continue
 
     // When the analyzer provides structured branch info, resolve each