@barefootjs/go-template 0.32.0 → 0.33.0

package/dist/vite.js

@@ -209,7 +209,7 @@ function convertNode(node, raw) {
           }
           if (n === undefined || Number.isNaN(n)) {
             const parsedDepth = convertNode(depthNode, raw);
-            if (checkSupport(parsedDepth).supported) {
+            if (checkSupport(parsedDepth, "rendered").supported) {
               depthExpr = parsedDepth;
               flatDepth = 1;
             } else {
@@ -303,10 +303,12 @@ function convertNode(node, raw) {
         const k = objectLiteralKeyName(prop.name);
         if (k === null)
           return { kind: "unsupported", raw, reason: `Unsupported syntax: ${ts.SyntaxKind[node.kind]}` };
-        properties.push({ key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
+        properties.push({ kind: "prop", key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
       } else if (ts.isShorthandPropertyAssignment(prop)) {
         const key = prop.name.text;
-        properties.push({ key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+        properties.push({ kind: "prop", key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+      } else if (ts.isSpreadAssignment(prop)) {
+        properties.push({ kind: "spread", expr: convertNode(prop.expression, raw) });
       } else {
         return { kind: "unsupported", raw, reason: `Unsupported syntax: ${ts.SyntaxKind[node.kind]}` };
       }
@@ -986,14 +988,26 @@ function getUnaryOperatorString(op) {
   }
 }
 function isSupported(expr) {
-  return checkSupport(expr);
+  return checkSupport(expr, "rendered");
 }
-function checkSupport(expr) {
+function isSupportedValue(expr) {
+  return checkSupport(expr, "value");
+}
+function checkSupport(expr, pos) {
   switch (expr.kind) {
     case "unsupported":
       return { supported: false, reason: expr.reason };
-    case "object-literal":
-      return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+    case "object-literal": {
+      if (pos !== "value") {
+        return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+      }
+      for (const prop of expr.properties) {
+        const propSupport = checkSupport(prop.kind === "spread" ? prop.expr : prop.value, pos);
+        if (!propSupport.supported)
+          return propSupport;
+      }
+      return { supported: true, level: "L2" };
+    }
     case "identifier":
       return { supported: true, level: "L1" };
     case "literal":
@@ -1003,7 +1017,7 @@ function checkSupport(expr) {
       return { supported: false, reason: "Standalone arrow functions / regex literals are not supported" };
     case "array-literal": {
       for (const el of expr.elements) {
-        const elSupport = checkSupport(el);
+        const elSupport = checkSupport(el, pos);
         if (!elSupport.supported)
           return elSupport;
       }
@@ -1016,16 +1030,16 @@ function checkSupport(expr) {
           reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported)
           return argSupport;
       }
       if (expr.method === "flat" && expr.depthExpr) {
-        const depthSupport = checkSupport(expr.depthExpr);
+        const depthSupport = checkSupport(expr.depthExpr, pos);
         if (!depthSupport.supported)
           return depthSupport;
       }
@@ -1034,10 +1048,10 @@ function checkSupport(expr) {
     case "call": {
       const cb = asCallbackMethodCall(expr);
       if (cb) {
-        const objSupport = checkSupport(cb.object);
+        const objSupport = checkSupport(cb.object, pos);
         if (!objSupport.supported)
           return objSupport;
-        const bodySupport = checkSupport(cb.arrow.body);
+        const bodySupport = checkSupport(cb.arrow.body, pos);
         if (!bodySupport.supported) {
           return {
             supported: false,
@@ -1046,13 +1060,13 @@ function checkSupport(expr) {
           };
         }
         for (const rest of cb.args) {
-          const restSupport = checkSupport(rest);
+          const restSupport = checkSupport(rest, pos);
           if (!restSupport.supported)
             return restSupport;
         }
         return { supported: true, level: "L5" };
       }
-      const calleeSupport = checkSupport(expr.callee);
+      const calleeSupport = checkSupport(expr.callee, pos);
       if (!calleeSupport.supported) {
         return calleeSupport;
       }
@@ -1071,7 +1085,7 @@ function checkSupport(expr) {
         return { supported: true, level: "L1" };
       }
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported) {
           return argSupport;
         }
@@ -1079,7 +1093,7 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "member": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported) {
         return objSupport;
       }
@@ -1089,19 +1103,19 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "index-access": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
-      const indexSupport = checkSupport(expr.index);
+      const indexSupport = checkSupport(expr.index, pos);
       if (!indexSupport.supported)
         return indexSupport;
       return { supported: true, level: "L2" };
     }
     case "binary": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       if (["===", "==", "!==", "!=", ">", "<", ">=", "<="].includes(expr.op)) {
@@ -1113,7 +1127,7 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unknown operator: ${expr.op}` };
     }
     case "unary": {
-      const argSupport = checkSupport(expr.argument);
+      const argSupport = checkSupport(expr.argument, pos);
       if (!argSupport.supported)
         return argSupport;
       if (expr.op === "!") {
@@ -1125,25 +1139,25 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unsupported unary operator: ${expr.op}` };
     }
     case "logical": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
       if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
         return { supported: true, level: "L4" };
       }
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       return { supported: true, level: "L4" };
     }
     case "conditional": {
-      const testSupport = checkSupport(expr.test);
+      const testSupport = checkSupport(expr.test, pos);
       if (!testSupport.supported)
         return testSupport;
-      const consSupport = checkSupport(expr.consequent);
+      const consSupport = checkSupport(expr.consequent, pos);
       if (!consSupport.supported)
         return consSupport;
-      const altSupport = checkSupport(expr.alternate);
+      const altSupport = checkSupport(expr.alternate, pos);
       if (!altSupport.supported)
         return altSupport;
       return { supported: true, level: "L4" };
@@ -1151,7 +1165,7 @@ function checkSupport(expr) {
     case "template-literal": {
       for (const part of expr.parts) {
         if (part.type === "expression") {
-          const partSupport = checkSupport(part.expr);
+          const partSupport = checkSupport(part.expr, pos);
           if (!partSupport.supported)
             return partSupport;
         }
@@ -1267,7 +1281,7 @@ function isPureInit(e, pureCallNames) {
     case "array-literal":
       return e.elements.every(pure);
     case "object-literal":
-      return e.properties.every((p) => pure(p.value));
+      return e.properties.every((p) => pure(p.kind === "spread" ? p.expr : p.value));
     case "call":
       return e.callee.kind === "identifier" && e.args.length === 0 && pureCallNames !== undefined && pureCallNames.has(e.callee.name);
     case "array-method":
@@ -1321,7 +1335,7 @@ function usesPerPath(name, expr) {
         }
         return add(walk(e.object), sum(e.args));
       case "object-literal":
-        return sum(e.properties.map((p) => p.value));
+        return sum(e.properties.map((p) => p.kind === "spread" ? p.expr : p.value));
       case "arrow":
         return walk(e.body).max > 0 ? { min: 0, max: Number.POSITIVE_INFINITY } : { min: 0, max: 0 };
     }
@@ -1387,7 +1401,7 @@ function inlineBinding(expr, name, value) {
       case "object-literal":
         return {
           kind: "object-literal",
-          properties: e.properties.map((p) => ({ ...p, value: walk(p.value, enclosing) })),
+          properties: e.properties.map((p) => p.kind === "spread" ? { ...p, expr: walk(p.expr, enclosing) } : { ...p, value: walk(p.value, enclosing) }),
           raw: e.raw
         };
       case "literal":
@@ -1597,7 +1611,7 @@ function materializeGetterCalls(expr, names) {
       return {
         kind: "object-literal",
         raw: expr.raw,
-        properties: expr.properties.map((p) => ({ ...p, value: rw(p.value) }))
+        properties: expr.properties.map((p) => p.kind === "spread" ? { ...p, expr: rw(p.expr) } : { ...p, value: rw(p.value) })
       };
     case "arrow":
       return { kind: "arrow", params: expr.params, body: rw(expr.body) };
@@ -1655,7 +1669,7 @@ function freeVarsInBody(body, params) {
         return;
       case "object-literal":
         for (const p of e.properties)
-          visit(p.value, bound);
+          visit(p.kind === "spread" ? p.expr : p.value, bound);
         return;
       case "array-method":
         if (e.method === "includes" || e.method === "join") {
@@ -1730,7 +1744,7 @@ function freeIdentifiers(expr) {
         return true;
       case "object-literal":
         for (const p of e.properties)
-          if (!visit(p.value, bound))
+          if (!visit(p.kind === "spread" ? p.expr : p.value, bound))
             return false;
         return true;
       case "arrow": {
@@ -1877,10 +1891,17 @@ function toEvalNode(e) {
     case "object-literal": {
       const properties = [];
       for (const p of e.properties) {
+        if (p.kind === "spread") {
+          const spreadExpr = toEvalNode(p.expr);
+          if (!spreadExpr)
+            return null;
+          properties.push({ kind: "spread", expr: spreadExpr });
+          continue;
+        }
         const value = toEvalNode(p.value);
         if (!value)
           return null;
-        properties.push({ key: p.key, value });
+        properties.push({ kind: "prop", key: p.key, value });
       }
       return { kind: "object-literal", properties };
     }
@@ -2985,6 +3006,8 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
   let tz = null;
   const probeOptions = {};
   for (const prop of options.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
       return null;
     const value = String(prop.value.value);
@@ -3918,7 +3941,7 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
 
 // ../jsx/src/ssr-seed-plan.ts
 function classify(name, origin, expr, parsed, available) {
-  if (!isSupported(parsed).supported)
+  if (!isSupportedValue(parsed).supported)
     return { kind: "opaque", name, origin };
   const frees = freeIdentifiers(parsed);
   if (frees === null)
@@ -3981,7 +4004,7 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, resolveThroughLocalConsts(parseExpression(expr), localConsts), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, resolveThroughLocalConsts(signal.parsed ?? parseExpression(`(${expr})`), localConsts), available));
     available.add(signal.getter);
   }
   for (const memo of metadata.memos) {
@@ -4605,6 +4628,26 @@ function isStringTypedOperand(expr, isStringName) {
 function isStringConcatBinary(op, left, right, isStringName) {
   return op === "+" && (isStringTypedOperand(left, isStringName) || isStringTypedOperand(right, isStringName));
 }
+function groupObjectLiteralSegments(properties, literalOf, emit) {
+  const segments = [];
+  let run = [];
+  const flushRun = () => {
+    if (run.length > 0) {
+      segments.push(literalOf(run));
+      run = [];
+    }
+  };
+  for (const p of properties) {
+    if (p.kind === "spread") {
+      flushRun();
+      segments.push(emit(p.expr));
+    } else {
+      run.push(p);
+    }
+  }
+  flushRun();
+  return segments;
+}
 function emitParsedExpr(expr, emitter) {
   const emit = (child) => emitParsedExpr(child, emitter);
   switch (expr.kind) {
@@ -4751,6 +4794,17 @@ function evaluateStaticLiteral(expr, bindings) {
     case "object-literal": {
       const out = {};
       for (const prop of expr.properties) {
+        if (prop.kind === "spread") {
+          const resolved2 = evaluateStaticLiteral(prop.expr, bindings);
+          if (!resolved2)
+            return null;
+          if (resolved2.value === null || resolved2.value === undefined)
+            continue;
+          if (typeof resolved2.value !== "object" || Array.isArray(resolved2.value))
+            return null;
+          Object.assign(out, resolved2.value);
+          continue;
+        }
         const resolved = evaluateStaticLiteral(prop.value, bindings);
         if (!resolved)
           return null;
@@ -4817,6 +4871,8 @@ function matchQueryHrefCall(callee, args, localNames) {
     return null;
   const triples = [];
   for (const p of obj.properties) {
+    if (p.kind === "spread")
+      return null;
     const v = p.value;
     if (v.kind === "conditional" && isOmitBranch(v.alternate)) {
       triples.push({ guard: v.test, key: p.key, value: v.consequent });
@@ -4980,6 +5036,8 @@ function htmlPropValue(parsed) {
   if (parsed.properties.length !== 1)
     return null;
   const [prop] = parsed.properties;
+  if (prop.kind === "spread")
+    return null;
   if (prop.key !== "__html")
     return null;
   return prop.value;
@@ -5849,7 +5907,7 @@ function isSubstituteSafeBody(body, paramNames) {
     if (n.kind === "identifier")
       return paramNames.has(n.name);
     if (n.kind === "object-literal") {
-      return n.properties.some((p) => p.shorthand && paramNames.has(p.key) || referencesParam(p.value));
+      return n.properties.some((p) => p.kind === "spread" ? referencesParam(p.expr) : p.shorthand && paramNames.has(p.key) || referencesParam(p.value));
     }
     let hit = false;
     forEachValueChild(n, (c) => {
@@ -6204,6 +6262,8 @@ function bakeInlineObjectAsGoMap(ctx, expr) {
     return null;
   const entries = [];
   for (const prop of expr.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.shorthand)
       return null;
     const go = prop.value.kind === "object-literal" ? bakeInlineObjectAsGoMap(ctx, prop.value) : parsedLiteralToGo(ctx, prop.value);
@@ -6259,6 +6319,8 @@ function parsedLiteralToGo(ctx, expr, typeInfo) {
       return null;
     const entries = [];
     for (const prop of expr.properties) {
+      if (prop.kind === "spread")
+        return null;
       const goField = structFields.get(prop.key);
       if (!goField)
         return null;
@@ -6380,6 +6442,8 @@ function objectLiteralToGoMap(ctx, expr) {
     return null;
   const entries = [];
   for (const prop of expr.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.shorthand)
       return null;
     const val = parsedLiteralToGo(ctx, prop.value);
@@ -6458,17 +6522,18 @@ function resolveMapJoinBaseAsGo(ctx, object, signals, propsParams) {
   }
   return null;
 }
-function mapJoinChainToGo(ctx, chain, signals, propsParams, propFallbackVars) {
-  const itemsGo = resolveMapJoinBaseAsGo(ctx, chain.object, signals, propsParams);
-  if (itemsGo === null)
+var CALLBACK_EVAL_FUNC = { map: "bf.MapEval", filter: "bf.FilterEval" };
+function callbackStepToGo(ctx, method, itemsGo, arrow, signals, propsParams, propFallbackVars) {
+  const evalFunc = CALLBACK_EVAL_FUNC[method];
+  if (!evalFunc)
     return null;
   const knownGetterNames = new Set(signals.map((s) => s.getter));
-  const materialized = materializeGetterCalls(chain.arrow.body, knownGetterNames);
+  const materialized = materializeGetterCalls(arrow.body, knownGetterNames);
   const projJSON = serializeParsedExpr(materialized);
   if (projJSON === null)
     return null;
-  const paramName = chain.arrow.params[0] ?? "_";
-  const freeVars = freeVarsInBody(materialized, new Set(chain.arrow.params));
+  const paramName = arrow.params[0] ?? "_";
+  const freeVars = freeVarsInBody(materialized, new Set(arrow.params));
   const envEntries = [];
   for (const name of freeVars) {
     const sig = signals.find((s) => s.getter === name);
@@ -6485,6 +6550,25 @@ function mapJoinChainToGo(ctx, chain, signals, propsParams, propFallbackVars) {
     envEntries.push(`${JSON.stringify(name)}: ${goExpr}`);
   }
   const envMap = `map[string]any{${envEntries.join(", ")}}`;
+  return `${evalFunc}(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap})`;
+}
+function resolveMapChainAsGo(ctx, expr, signals, propsParams, propFallbackVars) {
+  const cb = asCallbackMethodCall(expr);
+  if (cb && cb.method in CALLBACK_EVAL_FUNC) {
+    const innerGo = resolveMapChainAsGo(ctx, cb.object, signals, propsParams, propFallbackVars);
+    if (innerGo === null)
+      return null;
+    return callbackStepToGo(ctx, cb.method, innerGo, cb.arrow, signals, propsParams, propFallbackVars);
+  }
+  return resolveMapJoinBaseAsGo(ctx, expr, signals, propsParams);
+}
+function mapJoinChainToGo(ctx, chain, signals, propsParams, propFallbackVars) {
+  const itemsGo = resolveMapChainAsGo(ctx, chain.object, signals, propsParams, propFallbackVars);
+  if (itemsGo === null)
+    return null;
+  const mapGo = callbackStepToGo(ctx, "map", itemsGo, chain.arrow, signals, propsParams, propFallbackVars);
+  if (mapGo === null)
+    return null;
   let sepGo;
   if (!chain.sepArg) {
     sepGo = JSON.stringify(",");
@@ -6493,7 +6577,7 @@ function mapJoinChainToGo(ctx, chain, signals, propsParams, propFallbackVars) {
   } else {
     return null;
   }
-  return `bf.Join(bf.MapEval(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap}), ${sepGo})`;
+  return `bf.Join(${mapGo}, ${sepGo})`;
 }
 
 // src/adapter/memo/memo-type.ts
@@ -6780,6 +6864,8 @@ function computeObjectMemoInitialValue(ctx, memo) {
   const env = { searchParamsVars: new Set, params: new Map };
   const entries = [];
   for (const prop of retObj.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.shorthand)
       return null;
     if (prop.keyKind !== undefined && prop.keyKind !== "identifier" && prop.keyKind !== "string") {
@@ -6903,6 +6989,8 @@ function recordIndexInterpolationToGo(ctx, node, propNames, localKeyBindings) {
     return null;
   const entries = [];
   for (const prop of parsedConst.properties) {
+    if (prop.kind === "spread")
+      return null;
     const v = prop.value;
     if (v.kind === "literal" && v.literalType === "number") {
       entries.push({ key: prop.key, value: { kind: "number", text: v.raw ?? String(v.value) } });
@@ -7229,6 +7317,12 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
     if (concatGo !== null)
       return concatGo;
   }
+  const bareChain = matchMapJoinChain(body);
+  if (bareChain) {
+    const chainGo = mapJoinChainToGo(ctx, bareChain, signals, propsParams, propFallbackVars);
+    if (chainGo !== null)
+      return chainGo;
+  }
   return null;
 }
 function resolveStringConcatChainGo(ctx, expr, signals, propsParams, propFallbackVars, propRef) {
@@ -7400,7 +7494,7 @@ function collectPropsReadByCtorInit(body, propsObjectName, propNames) {
         return;
       case "object-literal":
         for (const p of e.properties)
-          visit(p.value, bound);
+          visit(p.kind === "spread" ? p.expr : p.value, bound);
         return;
       case "array-method":
         visit(e.object, bound);
@@ -7511,6 +7605,8 @@ function parsedObjectLiteralToGoMap(parsed) {
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.keyKind === "numeric")
       return null;
     const v = prop.value;
@@ -7635,6 +7731,8 @@ function conditionToGoBool(condition, ir) {
 function objectLiteralToGoSpreadMap(ctx, obj, ir) {
   const entries = [];
   for (const prop of obj.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.shorthand)
       return null;
     if (prop.keyKind === "numeric")
@@ -8449,6 +8547,8 @@ ${goFields.join(`
         return null;
       const seen = new Set;
       for (const prop of el.properties) {
+        if (prop.kind === "spread")
+          return null;
         if (prop.shorthand)
           return null;
         const key = prop.key;
@@ -9620,6 +9720,8 @@ ${goFields.join(`
       return null;
     const entries = [];
     for (const prop of parsed.properties) {
+      if (prop.kind === "spread")
+        return null;
       if (prop.shorthand)
         return null;
       const goVal = this.lowerProviderMapMemberValue(prop.value, propsParams);
@@ -10386,7 +10488,16 @@ ${goFields.join(`
     });
     return `bf_arr ${parts.join(" ")}`;
   }
-  objectLiteral(_properties, raw, _emit) {
+  objectLiteral(properties, raw, emit) {
+    if (properties.length > 0) {
+      const wrap = (rendered) => rendered.includes(" ") ? `(${rendered})` : rendered;
+      const literalOf = (run) => `bf_map ${run.map((p) => `"${escapeGoString(p.key)}" ${wrap(emit(p.value))}`).join(" ")}`;
+      if (!properties.some((p) => p.kind === "spread")) {
+        return literalOf(properties);
+      }
+      const segments = groupObjectLiteralSegments(properties, literalOf, (e) => wrap(emit(e)));
+      return `bf_merge ${segments.join(" ")}`;
+    }
     this.state.errors.push({
       code: "BF101",
       severity: "error",
@@ -11109,7 +11220,7 @@ ${goFields.join(`
       return null;
     const carried = constInfo.parsed;
     if (carried?.kind === "object-literal") {
-      const hit = carried.properties.find((prop) => prop.key === key);
+      const hit = carried.properties.find((prop) => prop.kind === "prop" && prop.key === key);
       if (hit && hit.value.kind === "literal") {
         if (hit.value.literalType === "string")
           return JSON.stringify(hit.value.value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.32.0"
+    "@barefootjs/shared": "0.33.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.32.0",
-    "@barefootjs/jsx": "0.32.0",
-    "@barefootjs/vite": "0.32.0",
+    "@barefootjs/client": "0.33.0",
+    "@barefootjs/jsx": "0.33.0",
+    "@barefootjs/vite": "0.33.0",
     "vite": "^6.0.0"
   }
 }

package/src/adapter/expr/helper-inline.ts

@@ -86,8 +86,10 @@ function isSubstituteSafeBody(body: ParsedExpr, paramNames: ReadonlySet<string>)
   const referencesParam = (n: ParsedExpr): boolean => {
     if (n.kind === 'identifier') return paramNames.has(n.name)
     if (n.kind === 'object-literal') {
-      return n.properties.some(
-        p => (p.shorthand && paramNames.has(p.key)) || referencesParam(p.value),
+      return n.properties.some(p =>
+        p.kind === 'spread'
+          ? referencesParam(p.expr)
+          : (p.shorthand && paramNames.has(p.key)) || referencesParam(p.value),
       )
     }
     let hit = false