@barefootjs/go-template 0.18.7 → 0.19.1

package/dist/build.js

@@ -364,7 +364,7 @@ var init_path = __esm(() => {
 // src/adapter/go-template-adapter.ts
 import {
   BaseAdapter,
-  isBooleanAttr,
+  isBooleanAttr as isBooleanAttr2,
   parseExpression as parseExpression4,
   stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
@@ -706,6 +706,10 @@ class CompileState {
   hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
+  nullishConsumedPropNames = new Set;
+  omittableAttrConsumedPropNames = new Set;
+  textConsumedPropNames = new Set;
+  presenceCheckedPropNames = new Set;
   stringValueNames = new Set;
   rootScopeNodes = new Set;
   memoBackedLoopSlice = new Map;
@@ -1449,15 +1453,28 @@ function parsedLiteralToGo(ctx, expr, typeInfo) {
 
 // src/adapter/value/value-lowering.ts
 var EMPTY_PROP_FALLBACK_VARS = new Map;
+function nillableAwarePropRef(ctx, propName, expectedType) {
+  const fieldRef = `in.${capitalizeFieldName(propName)}`;
+  const scalar = expectedType.kind === "primitive" ? expectedType : expectedType.kind === "union" && expectedType.unionTypes?.length === 2 ? expectedType.unionTypes.find((t) => t.primitive !== "undefined" && t.primitive !== "null") : undefined;
+  if (ctx.state.nillablePropNames.has(propName) && scalar?.kind === "primitive") {
+    const goType = scalar.primitive === "boolean" ? "bool" : scalar.primitive === "number" ? "float64" : scalar.primitive === "string" ? "string" : null;
+    if (goType) {
+      const zero = goType === "bool" ? "false" : goType === "string" ? '""' : "0";
+      return `func() ${goType} { if v, ok := ${fieldRef}.(${goType}); ok { return v }; return ${zero} }()`;
+    }
+  }
+  return fieldRef;
+}
 function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
+  const propRef = (propName2) => nillableAwarePropRef(ctx, propName2, typeInfo);
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
     if (propsParams?.some((p) => p.name === value)) {
-      return `in.${capitalizeFieldName(value)}`;
+      return propRef(value);
     }
   }
-  const propName = ctx.extractPropNameFromInitialValue(value);
+  const propName = ctx.extractPropNameFromInitialValue(value, preParsed);
   if (propName && propsParams?.some((p) => p.name === propName)) {
-    return `in.${capitalizeFieldName(propName)}`;
+    return propRef(propName);
   }
   if (typeInfo.kind === "primitive") {
     if (typeInfo.primitive === "boolean") {
@@ -1524,19 +1541,20 @@ function objectLiteralToGoMap(ctx, expr) {
     return null;
   return `map[string]interface{}{${entries.join(", ")}}`;
 }
-function getSignalInitialValueAsGo(ctx, initialValue, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS) {
+function getSignalInitialValueAsGo(ctx, initialValue, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS, signalType) {
+  const propRef = (propName2) => signalType ? nillableAwarePropRef(ctx, propName2, signalType) : `in.${capitalizeFieldName(propName2)}`;
   if (propsParams.some((p) => p.name === initialValue)) {
     const hoisted = propFallbackVars.get(initialValue);
     if (hoisted)
       return hoisted.varName;
-    return `in.${capitalizeFieldName(initialValue)}`;
+    return propRef(initialValue);
   }
   const propName = ctx.extractPropNameFromInitialValue(initialValue);
   if (propName && propsParams.some((p) => p.name === propName)) {
     const hoisted = propFallbackVars.get(propName);
     if (hoisted)
       return hoisted.varName;
-    return `in.${capitalizeFieldName(propName)}`;
+    return propRef(propName);
   }
   if (/^-?\d+$/.test(initialValue)) {
     return initialValue;
@@ -2006,9 +2024,34 @@ var EMPTY_PROP_FALLBACK_VARS2 = new Map;
 function getterCallName(e) {
   return e.kind === "call" && e.callee.kind === "identifier" && e.args.length === 0 ? e.callee.name : null;
 }
+function isBooleanTypeInfo(t) {
+  if (t.kind === "primitive")
+    return t.primitive === "boolean";
+  if (t.kind === "union" && t.unionTypes?.length === 2) {
+    const scalar = t.unionTypes.find((u) => u.primitive !== "undefined" && u.primitive !== "null");
+    return scalar?.kind === "primitive" && scalar.primitive === "boolean";
+  }
+  return false;
+}
+function isBooleanTypedGetter(ctx, name, signals) {
+  const signal = signals.find((s) => s.getter === name);
+  if (signal)
+    return signal.type !== undefined && isBooleanTypeInfo(signal.type);
+  const memo = (ctx.state.currentMemos ?? []).find((m) => m.name === name);
+  return memo?.type !== undefined && isBooleanTypeInfo(memo.type);
+}
 function propsMemberName(e) {
   return e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === "props" ? e.property : null;
 }
+function propNameForPropsBinding(ctx, e) {
+  const propsObject = ctx.state.propsObjectName;
+  if (e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === propsObject) {
+    return e.property;
+  }
+  if (!propsObject && e.kind === "identifier")
+    return e.name;
+  return null;
+}
 function matchFilterArmMemo(ctx, body, signals, propsParams) {
   const cb = asCallbackMethodCall2(body);
   if (!cb || cb.method !== "filter")
@@ -2147,6 +2190,17 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
     if (propName)
       return propRef(propName);
   }
+  if (body.kind === "binary" && (body.op === "!==" || body.op === "!=" || body.op === "===" || body.op === "==")) {
+    const other = body.right.kind === "identifier" && body.right.name === "undefined" ? body.left : body.left.kind === "identifier" && body.left.name === "undefined" ? body.right : null;
+    const propName = other ? propNameForPropsBinding(ctx, other) : null;
+    if (propName) {
+      const param = propsParams.find((p) => p.name === propName);
+      if (param && ctx.state.nillablePropNames.has(propName)) {
+        const isNe = body.op === "!==" || body.op === "!=";
+        return `in.${capitalizeFieldName(propName)} ${isNe ? "!=" : "=="} nil`;
+      }
+    }
+  }
   if (body.kind === "conditional") {
     const condName = getterCallName(body.test);
     if (condName) {
@@ -2181,6 +2235,18 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
         }
       }
     }
+    if (condName) {
+      const tName = getterCallName(body.consequent);
+      const fName = getterCallName(body.alternate);
+      if (tName && fName && isBooleanTypedGetter(ctx, tName, signals) && isBooleanTypedGetter(ctx, fName, signals)) {
+        const condGo = resolveGetterValueAsGo(ctx, condName, signals, propsParams, propFallbackVars, resolving);
+        const tGo = resolveGetterValueAsGo(ctx, tName, signals, propsParams, propFallbackVars, resolving);
+        const fGo = resolveGetterValueAsGo(ctx, fName, signals, propsParams, propFallbackVars, resolving);
+        if (condGo !== null && tGo !== null && fGo !== null) {
+          return `func() bool { if ${condGo} { return ${tGo} }; return ${fGo} }()`;
+        }
+      }
+    }
   }
   if (body.kind === "binary" && ["*", "+", "-", "/"].includes(body.op) && body.right.kind === "literal" && body.right.literalType === "number" && typeof body.right.value === "number" && Number.isInteger(body.right.value) && body.right.value >= 0) {
     const operator = body.op;
@@ -2269,7 +2335,7 @@ function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFall
 function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVars, resolving = new Set) {
   const signal = signals.find((s) => s.getter === name);
   if (signal) {
-    return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
+    return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars, signal.type);
   }
   const memo = (ctx.state.currentMemos ?? []).find((m) => m.name === name);
   if (memo) {
@@ -2599,11 +2665,12 @@ function recordIndexAccessToGoMap(ctx, val, ir) {
 }
 
 // src/adapter/props/prop-types.ts
+import { isBooleanAttr } from "@barefootjs/jsx";
 function buildPropTypeOverrides(ctx, ir) {
   const overrides = new Map;
   for (const signal of ir.metadata.signals) {
     const propNames = [signal.initialValue];
-    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue);
+    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue, signal.parsed);
     if (extracted)
       propNames.push(extracted);
     for (const propName of propNames) {
@@ -2660,11 +2727,146 @@ function collectToFixedPropNames(root) {
   walk(root);
   return names;
 }
+var NULLISH_SCALAR_GO_TYPES = new Set(["string", "int", "float64", "bool"]);
+function collectNullishConsumedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null).map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const propNameOfLeft = (left) => {
+    if (left.kind === "identifier")
+      return left.name;
+    if (left.kind === "member" && !left.computed && left.object.kind === "identifier") {
+      if (left.object.name === propsObject)
+        return left.property;
+      return left.object.name;
+    }
+    return null;
+  };
+  const isZeroEquivalentLiteral = (right) => right.kind === "literal" && (right.value === "" || right.value === false || right.value === null || right.literalType === "number" && Number(right.value) === 0);
+  const walk = (node) => {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const rec = node;
+    if (rec.kind === "logical" && rec.op === "??" && rec.left && rec.right) {
+      const propName = propNameOfLeft(rec.left);
+      if (propName && optionalParams.has(propName) && !isZeroEquivalentLiteral(rec.right)) {
+        names.add(propName);
+      }
+    }
+    for (const value of Object.values(rec))
+      walk(value);
+  };
+  walk(ir.root);
+  for (const signal of ir.metadata.signals) {
+    const match = ctx.extractPropFallback(signal.initialValue, signal.parsed);
+    if (!match || !optionalParams.has(match.propName))
+      continue;
+    const f = match.goFallback;
+    if (f === '""' || f === "false" || f === "nil" || Number(f) === 0)
+      continue;
+    names.add(match.propName);
+  }
+  return names;
+}
+function collectOmittableAttrConsumedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null).map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const walk = (node) => {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const rec = node;
+    if (rec.type === "element" && Array.isArray(rec.attrs)) {
+      for (const attr of rec.attrs) {
+        if (attr.name === "class" || attr.name === "className" || attr.name === "style")
+          continue;
+        if (isBooleanAttr(attr.name))
+          continue;
+        if (attr.value?.kind !== "expression" || attr.value.presenceOrUndefined)
+          continue;
+        const bareId = String(attr.value.expr ?? "").trim();
+        const propName = propsObject && bareId.startsWith(`${propsObject}.`) ? bareId.slice(propsObject.length + 1) : bareId;
+        if (/^[A-Za-z_$][\w$]*$/.test(propName) && optionalParams.has(propName)) {
+          names.add(propName);
+        }
+      }
+    }
+    for (const value of Object.values(rec))
+      walk(value);
+  };
+  walk(ir.root);
+  return names;
+}
+function collectTextConsumedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null && p.type.kind === "primitive").map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const walk = (node) => {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const rec = node;
+    if (rec.type === "expression") {
+      const bareId = String(rec.expr ?? "").trim();
+      const propName = propsObject && bareId.startsWith(`${propsObject}.`) ? bareId.slice(propsObject.length + 1) : bareId;
+      if (/^[A-Za-z_$][\w$]*$/.test(propName) && optionalParams.has(propName)) {
+        names.add(propName);
+      }
+    }
+    for (const value of Object.values(rec))
+      walk(value);
+  };
+  walk(ir.root);
+  return names;
+}
+function collectPresenceCheckedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null && p.type.kind === "primitive").map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const isUndefinedCheck = (op) => op === "!==" || op === "!=" || op === "===" || op === "==";
+  for (const memo of ir.metadata.memos) {
+    const body = memo.parsed;
+    if (!body || body.kind !== "binary" || !isUndefinedCheck(body.op))
+      continue;
+    const other = body.right.kind === "identifier" && body.right.name === "undefined" ? body.left : body.left.kind === "identifier" && body.left.name === "undefined" ? body.right : null;
+    if (!other)
+      continue;
+    const propName = other.kind === "member" && !other.computed && other.object.kind === "identifier" && other.object.name === propsObject ? other.property : !propsObject && other.kind === "identifier" ? other.name : null;
+    if (propName && optionalParams.has(propName))
+      names.add(propName);
+  }
+  return names;
+}
 function resolvePropGoType(ctx, param, propTypeOverrides) {
   const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
   if (param.optional && ctx.state.localStructFields.has(base)) {
     return "map[string]interface{}";
   }
+  if (param.optional && param.type.kind === "primitive" && (ctx.state.nullishConsumedPropNames.has(param.name) || ctx.state.omittableAttrConsumedPropNames.has(param.name) || ctx.state.textConsumedPropNames.has(param.name) || ctx.state.presenceCheckedPropNames.has(param.name)) && NULLISH_SCALAR_GO_TYPES.has(base)) {
+    return "interface{}";
+  }
   return base;
 }
 function collectNillablePropNames(ctx, ir) {
@@ -2743,8 +2945,8 @@ class GoTemplateAdapter extends BaseAdapter {
     state: this.state,
     convertExpressionToGo: (jsExpr, out, preParsed) => this.convertExpressionToGo(jsExpr, out, preParsed),
     convertConditionToGo: (jsCondition, preParsed) => this.convertConditionToGo(jsCondition, preParsed),
-    extractPropNameFromInitialValue: (initialValue) => this.extractPropNameFromInitialValue(initialValue),
-    extractPropFallback: (initialValue) => this.extractPropFallback(initialValue),
+    extractPropNameFromInitialValue: (initialValue, preParsed) => this.extractPropNameFromInitialValue(initialValue, preParsed),
+    extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name)
   };
   get errors() {
@@ -2796,6 +2998,12 @@ class GoTemplateAdapter extends BaseAdapter {
     }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata);
     augmentInheritedPropAccesses(ir);
+    this.buildLocalTypeTables(ir, ir.metadata.componentName);
+    this.state.nullishConsumedPropNames = collectNullishConsumedPropNames(this.emitCtx, ir);
+    this.state.omittableAttrConsumedPropNames = collectOmittableAttrConsumedPropNames(this.emitCtx, ir);
+    this.state.textConsumedPropNames = collectTextConsumedPropNames(this.emitCtx, ir);
+    this.state.presenceCheckedPropNames = collectPresenceCheckedPropNames(this.emitCtx, ir);
+    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
   }
   generate(ir, options) {
     this.state.componentName = ir.metadata.componentName;
@@ -2804,7 +3012,6 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.templateVarCounter = 0;
     this.state.pendingChildrenDefines = [];
     this.primeCompileState(ir);
-    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
     this.state.stringValueNames = collectStringValueNames(ir);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
@@ -3323,10 +3530,18 @@ ${goFields.join(`
     this.emitStaticBodyWrappers(lines, ir, componentName, staticWithBody, emittedWrapperVars);
     const propFallbackVars = this.collectPropFallbackVars(ir);
     for (const [, info] of propFallbackVars) {
-      lines.push(`	${info.varName} := in.${info.fieldName}`);
-      lines.push(`	if ${info.varName} == ${info.zeroLiteral} {`);
-      lines.push(`		${info.varName} = ${info.goFallback}`);
-      lines.push(`	}`);
+      if (info.assertType) {
+        const deref = info.assertType === "int" ? `bf.ToInt(in.${info.fieldName})` : info.assertType === "float64" ? `bf.ToFloat64(in.${info.fieldName})` : `in.${info.fieldName}.(${info.assertType})`;
+        lines.push(`	var ${info.varName} ${info.assertType} = ${info.goFallback}`);
+        lines.push(`	if in.${info.fieldName} != nil {`);
+        lines.push(`		${info.varName} = ${deref}`);
+        lines.push(`	}`);
+      } else {
+        lines.push(`	${info.varName} := in.${info.fieldName}`);
+        lines.push(`	if ${info.varName} == ${info.zeroLiteral} {`);
+        lines.push(`		${info.varName} = ${info.goFallback}`);
+        lines.push(`	}`);
+      }
     }
     if (propFallbackVars.size > 0)
       lines.push("");
@@ -3406,7 +3621,7 @@ ${goFields.join(`
       const fieldName = capitalizeFieldName(signal.getter);
       if (propFieldNames.has(fieldName))
         continue;
-      const fallbackMatch = this.extractPropFallback(signal.initialValue);
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed);
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined;
       if (hoisted) {
         lines.push(`		${fieldName}: ${hoisted.varName},`);
@@ -4252,8 +4467,9 @@ ${goFields.join(`
     for (const nested of findNestedComponents(ir.root)) {
       localTaken.add(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
     }
+    const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir);
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue);
+      const match = this.extractPropFallback(signal.initialValue, signal.parsed);
       if (!match)
         continue;
       if (result.has(match.propName))
@@ -4264,6 +4480,8 @@ ${goFields.join(`
       if (goPropDefault(param.defaultValue) !== null)
         continue;
       const fieldName = capitalizeFieldName(match.propName);
+      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue);
+      const nullishLowered = NULLISH_SCALAR_GO_TYPES.has(concreteType) && resolvePropGoType(this.emitCtx, param, propTypeOverrides) === "interface{}";
       let zeroLiteral;
       if (match.goFallback === "true" || match.goFallback === "false") {
         zeroLiteral = "false";
@@ -4274,20 +4492,31 @@ ${goFields.join(`
       } else {
         continue;
       }
-      if (match.goFallback === zeroLiteral)
-        continue;
-      if (zeroLiteral === "0" && Number(match.goFallback) === 0)
-        continue;
+      if (!nullishLowered) {
+        if (match.goFallback === zeroLiteral)
+          continue;
+        if (zeroLiteral === "0" && Number(match.goFallback) === 0)
+          continue;
+      }
       let varName = match.propName;
       while (localTaken.has(varName) || GO_KEYWORDS.has(varName)) {
         varName += "_";
       }
       localTaken.add(varName);
-      result.set(match.propName, { varName, fieldName, goFallback: match.goFallback, zeroLiteral });
+      result.set(match.propName, {
+        varName,
+        fieldName,
+        goFallback: match.goFallback,
+        zeroLiteral,
+        ...nullishLowered ? { assertType: concreteType } : {}
+      });
     }
     return result;
   }
-  extractPropFallback(initialValue) {
+  extractPropFallback(initialValue, preParsed) {
+    const structural = preParsed ? this.extractPropFallbackFromParsed(preParsed) : null;
+    if (structural)
+      return structural;
     if (!this.state.propsObjectName)
       return null;
     const trimmed = initialValue.trim();
@@ -4301,9 +4530,38 @@ ${goFields.join(`
       return null;
     return { propName: m[1], goFallback };
   }
-  extractPropNameFromInitialValue(initialValue) {
-    if (!this.state.propsObjectName)
+  extractPropFallbackFromParsed(preParsed) {
+    if (preParsed.kind !== "logical" || preParsed.op !== "??")
+      return null;
+    const left = preParsed.left;
+    const propName = left.kind === "identifier" && !this.state.propsObjectName ? left.name : left.kind === "member" && !left.computed && left.object.kind === "identifier" && left.object.name === this.state.propsObjectName ? left.property : null;
+    if (!propName)
+      return null;
+    let right = preParsed.right;
+    let negate = "";
+    if (right.kind === "unary" && right.op === "-") {
+      negate = "-";
+      right = right.argument;
+    }
+    if (right.kind !== "literal")
+      return null;
+    if (negate && right.literalType !== "number")
+      return null;
+    if (right.literalType === "string") {
+      return { propName, goFallback: JSON.stringify(right.value) };
+    }
+    const goFallback = goPropDefault(negate + (right.raw ?? String(right.value)));
+    if (goFallback === null)
+      return null;
+    return { propName, goFallback };
+  }
+  extractPropNameFromInitialValue(initialValue, preParsed) {
+    if (!this.state.propsObjectName) {
+      if (preParsed?.kind === "logical" && (preParsed.op === "??" || preParsed.op === "||") && preParsed.left.kind === "identifier") {
+        return preParsed.left.name;
+      }
       return null;
+    }
     const trimmed = initialValue.trim();
     const name = this.state.propsObjectName;
     const direct = new RegExp(`^${name}\\.(\\w+)(?:\\s*(?:\\?\\?|\\|\\|)\\s*.+)?$`);
@@ -4427,10 +4685,22 @@ ${goFields.join(`
       }
       return goExpr;
     }
+    const finalExpr = this.textNillablePropNameOf(classify.parsed) !== null ? `bf_string ${wrapIfMultiToken(goExpr)}` : goExpr;
     if (expr.slotId) {
-      return `{{bfTextStart "${expr.slotId}"}}{{${goExpr}}}{{bfTextEnd}}`;
+      return `{{bfTextStart "${expr.slotId}"}}{{${finalExpr}}}{{bfTextEnd}}`;
     }
-    return `{{${goExpr}}}`;
+    return `{{${finalExpr}}}`;
+  }
+  textNillablePropNameOf(expr) {
+    if (!expr)
+      return null;
+    let name = null;
+    if (expr.kind === "identifier") {
+      name = expr.name;
+    } else if (expr.kind === "member" && !expr.computed && expr.object.kind === "identifier" && expr.object.name === this.state.propsObjectName) {
+      name = expr.property;
+    }
+    return name !== null && this.state.textConsumedPropNames.has(name) && this.state.nillablePropNames.has(name) ? name : null;
   }
   isTemplateFragment(go, kind) {
     return go.startsWith("{{") || kind === "template-literal";
@@ -4646,7 +4916,7 @@ ${goFields.join(`
     }
     const obj = emit(object);
     if (property === "length")
-      return `len ${obj}`;
+      return `bf_length ${wrapIfMultiToken(obj)}`;
     if (optional) {
       return `bf_get ${wrapIfMultiToken(obj)} ${JSON.stringify(goFieldNameForKey(property))}`;
     }
@@ -4715,8 +4985,24 @@ ${goFields.join(`
     const wrapRight = wrapIfMultiToken(emit(right));
     if (op === "&&")
       return `and ${wrapLeft} ${wrapRight}`;
+    if (op === "??" && this.nillablePropNameOf(left) !== null) {
+      return `bf_nullish ${wrapLeft} ${wrapRight}`;
+    }
     return `or ${wrapLeft} ${wrapRight}`;
   }
+  nillablePropNameOf(expr) {
+    let name = null;
+    if (expr.kind === "identifier") {
+      name = expr.name;
+    } else if (expr.kind === "member" && !expr.computed && expr.object.kind === "identifier") {
+      if (expr.object.name === this.state.propsObjectName) {
+        name = expr.property;
+      } else {
+        name = expr.object.name;
+      }
+    }
+    return name !== null && this.state.nullishConsumedPropNames.has(name) && this.state.nillablePropNames.has(name) ? name : null;
+  }
   conditional(test, consequent, alternate, emit) {
     const t = emit(test);
     const c = this.renderConditionalBranch(consequent);
@@ -5148,9 +5434,6 @@ ${goFields.join(`
   renderPredicateCondition(pred, param, datumField) {
     return this.renderFilterExpr(pred, param, new Map, datumField ?? undefined);
   }
-  needsParens(expr) {
-    return expr.kind === "logical" || expr.kind === "unary" || expr.kind === "conditional";
-  }
   splitPreamble(rendered) {
     if (!rendered.includes("{{"))
       return null;
@@ -5563,7 +5846,8 @@ ${goFields.join(`
           return plain(this.rootFieldRef(expr.callee.name));
         }
         if (expr.callee.kind === "identifier" && (identifierPath(expr.callee) ?? expr.callee.name) === "isValidElement" && expr.args.length === 1) {
-          return this.renderConditionExpr(expr.args[0]);
+          const inner = this.renderConditionExpr(expr.args[0]);
+          return { preamble: inner.preamble, expr: `(bf_is_element ${wrapIfMultiToken(inner.expr)})` };
         }
         if (expr.callee.kind === "identifier" && !this.templatePrimitives[identifierPath(expr.callee) ?? ""]) {
           const path = identifierPath(expr.callee) ?? expr.callee.name;
@@ -5680,9 +5964,9 @@ ${goFields.join(`
         const leftResult = this.renderConditionExpr(expr.left);
         const rightResult = this.renderConditionExpr(expr.right);
         const preamble = leftResult.preamble + rightResult.preamble;
-        const wrapLeft = this.needsParens(expr.left) ? `(${leftResult.expr})` : leftResult.expr;
-        const wrapRight = this.needsParens(expr.right) ? `(${rightResult.expr})` : rightResult.expr;
-        const result = expr.op === "&&" ? `and ${wrapLeft} ${wrapRight}` : `or ${wrapLeft} ${wrapRight}`;
+        const wrapLeft = wrapIfMultiToken(leftResult.expr);
+        const wrapRight = wrapIfMultiToken(rightResult.expr);
+        const result = expr.op === "&&" ? `and ${wrapLeft} ${wrapRight}` : expr.op === "??" && this.nillablePropNameOf(expr.left) !== null ? `bf_nullish ${wrapLeft} ${wrapRight}` : `or ${wrapLeft} ${wrapRight}`;
         return { preamble, expr: result };
       }
       case "conditional": {
@@ -6022,7 +6306,7 @@ ${children}`;
         if (css !== null)
           return `style="${css}"`;
       }
-      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+      if (isBooleanAttr2(name) || value.presenceOrUndefined) {
         const { condition: goCond, preamble } = this.convertConditionToGo(value.expr, value.parsed);
         const body = name.startsWith("aria-") ? `${name}="true"` : name;
         return `${preamble}{{if ${goCond}}}${body}{{end}}`;
@@ -6095,7 +6379,11 @@ ${children}`;
       if (e.kind === "expr" && !isSupported(parseExpression4(e.expr)).supported)
         return null;
     }
-    return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:{{${this.convertExpressionToGo(e.expr)}}}`).join(";");
+    const args = entries.flatMap((e) => [
+      JSON.stringify(e.cssKey),
+      e.kind === "literal" ? JSON.stringify(e.value) : wrapIfMultiToken(this.convertExpressionToGo(e.expr))
+    ]);
+    return `{{bf_style_object ${args.join(" ")}}}`;
   }
   renderAttributes(element) {
     const parts = [];