@barefootjs/xslate 0.17.0 → 0.18.0

package/dist/index.js

@@ -187291,23 +187291,24 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression3,
+  parseExpression as parseExpression2,
   stringifyParsedExpr as stringifyParsedExpr2,
   exprToString,
   parseProviderObjectLiteral,
   parseStyleObjectEntries,
-  isSupported as isSupported2,
+  isSupported,
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
   collectModuleStringConsts,
-  isLowerableObjectRestDestructure,
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
   queryHrefArgs,
-  sortComparatorFromArrow as sortComparatorFromArrow2
+  isValidHelperId,
+  sortComparatorFromArrow as sortComparatorFromArrow2,
+  isLowerableLoopDestructure
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187417,13 +187418,6 @@ function collectRootScopeNodes(node) {
   visit(node);
   return out;
 }
-function referencedVarsAreAvailable(expr, available) {
-  for (const m of expr.matchAll(/\$([A-Za-z_]\w*)/g)) {
-    if (!available.has(m[1]))
-      return false;
-  }
-  return true;
-}
 
 // src/adapter/expr/array-method.ts
 import {
@@ -187593,6 +187587,13 @@ function renderFlatMapEval(recv, body, param, emit) {
   const env = emitEvalEnvArg(body, [param], emit);
   return `$bf.flat_map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
 }
+function renderMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `$bf.map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
+}
 function renderSortMethod(recv, c) {
   const keyHashes = c.keys.map((k) => {
     const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
@@ -187600,7 +187601,10 @@ function renderSortMethod(recv, c) {
   });
   return `$bf.sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
 }
-function renderFlatMethod(recv, depth) {
+function renderFlatMethod(recv, depth, emit) {
+  if (typeof depth === "object") {
+    return `$bf.flat_dynamic(${recv}, ${emit(depth.expr)})`;
+  }
   const d = depth === "infinity" ? -1 : depth;
   return `$bf.flat(${recv}, ${d})`;
 }
@@ -187625,10 +187629,12 @@ class XslateFilterEmitter {
   param;
   localVarMap;
   isStringName;
-  constructor(param, localVarMap, isStringName = () => false) {
+  onUnsupported;
+  constructor(param, localVarMap, isStringName = () => false, onUnsupported) {
     this.param = param;
     this.localVarMap = localVarMap;
     this.isStringName = isStringName;
+    this.onUnsupported = onUnsupported;
   }
   identifier(name) {
     if (name === this.param)
@@ -187699,6 +187705,7 @@ class XslateFilterEmitter {
     return `(${l} // ${r})`;
   }
   callbackMethod(method, object, _arrow, _restArgs, emit) {
+    this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Kolon scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
     return emit(object);
   }
   arrayLiteral(elements, emit) {
@@ -187708,7 +187715,7 @@ class XslateFilterEmitter {
     return renderArrayMethod(method, object, args, emit);
   }
   flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
+    return renderFlatMethod(emit(object), depth, emit);
   }
   conditional(_test, _consequent, _alternate) {
     return "1";
@@ -187859,6 +187866,13 @@ class XslateTopLevelEmitter {
       this.ctx._recordExprBF101(`'.flatMap(...)' projection is outside the Xslate adapter's evaluable surface`, `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`);
       return "''";
     }
+    if (method === "map") {
+      const evalForm = renderMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`'.map(...)' projection is outside the Xslate adapter's evaluable surface`, `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`);
+      return "''";
+    }
     return recv;
   }
   _emitPredicateCallback(call, arrayExpr, emit) {
@@ -187901,7 +187915,7 @@ class XslateTopLevelEmitter {
     return renderArrayMethod(method, object, args, emit);
   }
   flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
+    return renderFlatMethod(emit(object), depth, emit);
   }
   conditional(test, consequent, alternate, emit) {
     return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
@@ -187932,8 +187946,8 @@ class XslateTopLevelEmitter {
   unsupported(_raw, _reason) {
     return "''";
   }
-  objectLiteral(_properties, _raw, _emit) {
-    return "''";
+  objectLiteral(properties, _raw, _emit) {
+    return properties.length === 0 ? "{}" : "''";
   }
 }
 
@@ -188092,9 +188106,7 @@ function recordIndexAccessToKolon(ctx, val) {
 // src/adapter/memo/seed.ts
 import {
   collectContextConsumers,
-  extractArrowBodyExpression,
-  isSupported,
-  parseExpression as parseExpression2
+  computeSsrSeedPlan
 } from "@barefootjs/jsx";
 function contextDefaultKolon(c) {
   const d = c.defaultValue;
@@ -188115,44 +188127,22 @@ function generateContextConsumerSeed(ir) {
 `;
 }
 function generateDerivedMemoSeed(ctx, ir) {
-  const memos = ir.metadata.memos ?? [];
-  const signals = ir.metadata.signals ?? [];
-  if (memos.length === 0 && signals.length === 0)
-    return "";
-  const available = new Set(ir.metadata.propsParams.map((p) => p.name));
+  const plan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata);
   const lines = [];
-  for (const signal of signals) {
-    const kolon = tryLowerToKolon(ctx, signal.initialValue, available);
-    const refsSelf = kolon !== null && new RegExp(`\\$${signal.getter}\\b`).test(kolon);
-    if (kolon !== null && !refsSelf)
-      lines.push(`: my $${signal.getter} = ${kolon};`);
-    available.add(signal.getter);
-  }
-  for (const memo of memos) {
-    const body = extractArrowBodyExpression(memo.computation);
-    if (body !== null) {
-      const kolon = tryLowerToKolon(ctx, body, available);
-      const refsSelf = kolon !== null && new RegExp(`\\$${memo.name}\\b`).test(kolon);
-      if (kolon !== null && !refsSelf)
-        lines.push(`: my $${memo.name} = ${kolon};`);
-    }
-    available.add(memo.name);
+  for (const step of plan.steps) {
+    if (step.kind !== "derived")
+      continue;
+    const kolon = ctx.convertExpressionToKolon(step.expr, step.parsed);
+    if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
+      continue;
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon))
+      continue;
+    lines.push(`: my $${step.name} = ${kolon};`);
   }
   return lines.length > 0 ? lines.join(`
 `) + `
 ` : "";
 }
-function tryLowerToKolon(ctx, expr, available) {
-  const trimmed = expr.trim();
-  if (!trimmed)
-    return null;
-  if (!isSupported(parseExpression2(trimmed)).supported)
-    return null;
-  const kolon = ctx.convertExpressionToKolon(trimmed);
-  if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
-    return null;
-  return referencedVarsAreAvailable(kolon, available) ? kolon : null;
-}
 
 // src/adapter/value/parsed-literal.ts
 import { evalStringArrayJoin } from "@barefootjs/jsx";
@@ -188188,6 +188178,17 @@ function collectStringValueNames(ir) {
 }
 
 // src/adapter/xslate-adapter.ts
+function kolonSegmentAccessor(base, segments) {
+  let expr = base;
+  for (const seg of segments) {
+    expr += seg.kind === "field" ? seg.isIdent ? `.${seg.key}` : `[${kolonHashKey(seg.key)}]` : `[${seg.index}]`;
+  }
+  return expr;
+}
+function kolonStringLiteral(s) {
+  return `'${escapeKolonSingleQuoted(s)}'`;
+}
+
 class XslateAdapter extends BaseAdapter {
   name = "xslate";
   extension = ".tx";
@@ -188452,24 +188453,41 @@ ${whenTrue}
     return `<: $bf.comment("cond-start:${condId}") | mark_raw :>${content}<: $bf.comment("cond-end:${condId}") | mark_raw :>`;
   }
   renderLoop(loop) {
-    if (loop.clientOnly)
-      return "";
+    if (loop.clientOnly) {
+      return `<: $bf.comment("loop:${loop.markerId}") | mark_raw :><: $bf.comment("/loop:${loop.markerId}") | mark_raw :>`;
+    }
     const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
-    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
+    const supportableDestructure = destructure && isLowerableLoopDestructure(loop);
     if (destructure && !supportableDestructure) {
       this.errors.push({
         code: "BF104",
         severity: "error",
-        message: `Loop callback uses an array/object destructure pattern (\`${loop.param}\`) that the Xslate adapter cannot lower — Kolon \`for LIST -> $item\` binds a single scalar and can't unpack a tuple.`,
+        message: `Loop callback uses a destructure pattern (\`${loop.param}\`) that the Xslate adapter cannot lower — see the diagnostic detail for the specific shape.`,
         loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
         suggestion: {
           message: `Options:
-` + `  1. Rename the parameter to a single name and access tuple elements with index syntax in the body (e.g. \`entry => entry[0]\` instead of \`([k, v]) => ...\`).
-` + `  2. Mark the loop position as @client-only so the destructure runs in JS on the client.
-` + `  3. Move the loop into a primitive that the adapter registers explicitly.`
+` + `  1. If this is an object-rest binding (\`{ ...rest }\`), only reading \`rest.field\` or spreading \`{...rest}\` onto an intrinsic element lowers — other uses (passing \`rest\` to a function, rendering it as text) need the client runtime.
+` + `  2. If this is chained \`.filter().map(({ ... }) => ...)\`, hoist the destructure into a variable inside the callback body instead.
+` + `  3. Mark the loop position as @client-only so the destructure runs in JS on the client.
+` + `  4. Move the loop into a primitive that the adapter registers explicitly.`
         }
       });
     }
+    const arrayName = loop.array.trim();
+    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+      const arrayConst = (this.localConstants ?? []).find((c) => c.name === arrayName);
+      if (arrayConst && !arrayConst.isModule && this._resolveLiteralConst(arrayName) === null) {
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Loop array \`${arrayName}\` is a local computed value (\`${arrayConst.value}\`) that the Xslate adapter cannot bind as a template variable — only numeric/string-literal locals inline at their use site.`,
+          loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message: "Pre-compute the array server-side and pass it as a prop, or mark the loop position as @client-only so it runs in JS on the client."
+          }
+        });
+      }
+    }
     const rawArray = this.convertExpressionToKolon(loop.array);
     let array = rawArray;
     if (loop.sortComparator) {
@@ -188491,7 +188509,15 @@ ${whenTrue}
     }
     if (supportableDestructure) {
       for (const b of loop.paramBindings ?? []) {
-        indexLocalLines.push(b.rest ? `: my $${b.name} = $${loopVar};` : `: my $${b.name} = $${loopVar}${b.path};`);
+        const parent = kolonSegmentAccessor(`$${loopVar}`, b.segments ?? []);
+        if (b.rest?.kind === "object") {
+          const exclude = b.rest.exclude.map((k) => kolonStringLiteral(k.key)).join(", ");
+          indexLocalLines.push(`: my $${b.name} = $bf.omit(${parent}, [${exclude}]);`);
+        } else if (b.rest?.kind === "array") {
+          indexLocalLines.push(`: my $${b.name} = $bf.slice(${parent}, ${b.rest.from}, nil);`);
+        } else {
+          indexLocalLines.push(`: my $${b.name} = ${kolonSegmentAccessor(`$${loopVar}`, b.segments ?? [])};`);
+        }
       }
     }
     const prevInLoop = this.inLoop;
@@ -188547,8 +188573,32 @@ ${childrenUnderLoop}` : childrenUnderLoop;
     emitBooleanShorthand: (_value, name) => `${kolonHashKey(name)} => 1`,
     emitJsxChildren: () => ""
   };
+  componentPropSegmentEntries(segments) {
+    const last = segments[segments.length - 1];
+    if (last && last.kind === "entries")
+      return last.parts;
+    const seg = { kind: "entries", parts: [] };
+    segments.push(seg);
+    return seg.parts;
+  }
+  combineComponentPropSegments(segments) {
+    let acc = null;
+    for (const seg of segments) {
+      if (seg.kind === "entries") {
+        if (seg.parts.length === 0)
+          continue;
+        const text = `{ ${seg.parts.join(", ")} }`;
+        acc = acc === null ? text : `${acc}.merge(${text})`;
+      } else {
+        const text = `(${seg.expr} // {})`;
+        acc = acc === null ? text : `${acc}.merge(${text})`;
+      }
+    }
+    return acc ?? "{}";
+  }
   renderComponent(comp) {
-    const propParts = [];
+    const segments = [{ kind: "entries", parts: [] }];
+    const currentEntries = () => this.componentPropSegmentEntries(segments);
     for (const p of comp.props) {
       if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
         continue;
@@ -188556,27 +188606,19 @@ ${childrenUnderLoop}` : childrenUnderLoop;
         const trimmed = p.value.expr.trim();
         if (this.propsObjectName && this.propsObjectName === trimmed) {
           for (const pp of this.propsParams) {
-            propParts.push(`${pp.name} => $${pp.name}`);
+            currentEntries().push(`${pp.name} => $${pp.name}`);
           }
           continue;
         }
-        this.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Spread props (\`{...${trimmed}}\`) on a child component cannot be lowered to Kolon — Kolon hashref method args can't splat a runtime hash into named entries.`,
-          loc: comp.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-          suggestion: {
-            message: "Pass the child component its props explicitly rather than spreading a runtime object."
-          }
-        });
+        segments.push({ kind: "spread", expr: this.convertExpressionToKolon(p.value.expr) });
         continue;
       }
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
       if (lowered)
-        propParts.push(lowered);
+        currentEntries().push(lowered);
     }
     if (comp.slotId && !this.inLoop) {
-      propParts.push(`_bf_slot => '${comp.slotId}'`);
+      currentEntries().push(`_bf_slot => '${comp.slotId}'`);
     }
     const tplName = this.toTemplateName(comp.name);
     const effectiveChildren = comp.children.length > 0 ? comp.children : resolveJsxChildrenProp(comp.props);
@@ -188586,11 +188628,12 @@ ${childrenUnderLoop}` : childrenUnderLoop;
       const childrenBody = this.renderChildren(effectiveChildren);
       this.inLoop = prevInLoop;
       const macroName = `bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
-      const childrenEntry = `children => ${macroName}()`;
-      const allParts = [...propParts, childrenEntry];
-      return `<: macro ${macroName} -> () { :>${childrenBody}<: } :><: $bf.render_child('${tplName}', { ${allParts.join(", ")} }) | mark_raw :>`;
+      currentEntries().push(`children => ${macroName}()`);
+      const dict = this.combineComponentPropSegments(segments);
+      return `<: macro ${macroName} -> () { :>${childrenBody}<: } :><: $bf.render_child('${tplName}', ${dict}) | mark_raw :>`;
     }
-    const hashEntries = propParts.length > 0 ? `, { ${propParts.join(", ")} }` : "";
+    const isEmpty = segments.every((s) => s.kind === "entries" && s.parts.length === 0);
+    const hashEntries = isEmpty ? "" : `, ${this.combineComponentPropSegments(segments)}`;
     return `<: $bf.render_child('${tplName}'${hashEntries}) | mark_raw :>`;
   }
   childrenCaptureCounter = 0;
@@ -188709,7 +188752,7 @@ ${name}="<: ${val} :>"
         if (localConst?.value !== undefined) {
           const initTrimmed = localConst.value.trim();
           if (!/^[A-Za-z_$][\w$]*$/.test(initTrimmed)) {
-            const resolved = conditionalSpreadToKolon(this.spreadCtx, parseExpression3(initTrimmed));
+            const resolved = conditionalSpreadToKolon(this.spreadCtx, parseExpression2(initTrimmed));
             if (resolved !== null) {
               return `<: $bf.spread_attrs(${resolved}) | mark_raw :>`;
             }
@@ -188727,7 +188770,7 @@ ${name}="<: ${val} :>"
     if (!entries)
       return null;
     for (const e of entries) {
-      if (e.kind === "expr" && !isSupported2(parseExpression3(e.expr)).supported)
+      if (e.kind === "expr" && !isSupported(parseExpression2(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.convertExpressionToKolon(e.expr)} :>`).join(";");
@@ -188763,7 +188806,7 @@ ${name}="<: ${val} :>"
     return `${BF_COND}="${condId}"`;
   }
   renderKolonFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
   }
   convertTemplateLiteralPartsToKolon(literalParts) {
     const parts = [];
@@ -188808,8 +188851,8 @@ ${name}="<: ${val} :>"
     const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe);
     if (!startsAsObjectLiteral && !hasTaggedTemplate)
       return false;
-    const parsed = parseExpression3(expr.trim());
-    const support = isSupported2(parsed);
+    const parsed = parseExpression2(expr.trim());
+    const support = isSupported(parsed);
     if (parsed.kind !== "unsupported" && support.supported)
       return false;
     const reason = support.reason ?? (parsed.kind === "unsupported" ? parsed.reason : undefined);
@@ -188856,7 +188899,7 @@ ${reason}` : "";
       const trimmed = expr.trim();
       if (trimmed === "")
         return "''";
-      parsed = parseExpression3(trimmed);
+      parsed = parseExpression2(trimmed);
     }
     if (parsed.kind === "call") {
       for (const matcher of this._loweringMatchers) {
@@ -188865,9 +188908,13 @@ ${reason}` : "";
           const qArgs = queryHrefArgs(node, (n) => this.renderParsedExprToKolon(n));
           return `$bf.query(${qArgs.join(", ")})`;
         }
+        if (node?.kind === "helper-call" && isValidHelperId(node.helper)) {
+          const argsX = node.args.map((a) => this.renderParsedExprToKolon(a));
+          return `$bf.${node.helper}(${argsX.join(", ")})`;
+        }
       }
     }
-    const support = isSupported2(parsed);
+    const support = isSupported(parsed);
     if (!support.supported) {
       this.errors.push({
         code: "BF101",
@@ -188895,7 +188942,7 @@ Options:
     return this.stringValueNames.has(name);
   }
   parseUndefinedAlternateTernary(expr) {
-    const parsed = parseExpression3(expr.trim());
+    const parsed = parseExpression2(expr.trim());
     if (parsed?.kind !== "conditional")
       return null;
     const alt = parsed.alternate;
@@ -188964,7 +189011,26 @@ Options:
   }
 }
 var xslateAdapter = new XslateAdapter;
+// src/conformance-pins.ts
+var conformancePins = {
+  "static-array-children": [{ code: "BF103", severity: "error" }],
+  "todo-app": [{ code: "BF103", severity: "error" }],
+  "todo-app-ssr": [{ code: "BF103", severity: "error" }],
+  "static-array-from-props": [{ code: "BF101", severity: "error" }],
+  "static-array-from-props-with-component": [
+    { code: "BF103", severity: "error" },
+    { code: "BF101", severity: "error" }
+  ],
+  "filter-nested-callback-predicate": [
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
+  ],
+  "filter-nested-find-predicate": [
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
+  ],
+  "array-map-function-reference": [{ code: "BF101", severity: "error" }]
+};
 export {
   xslateAdapter,
+  conformancePins,
   XslateAdapter
 };

package/lib/BarefootJS/Backend/Xslate.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Xslate;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.1";
 use strict;
 use warnings;
 use utf8;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/xslate",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Text::Xslate (Kolon) adapter for BarefootJS — compiles IR to .tx templates and ships the Xslate rendering backend; runs under any PSGI/Plack app",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,14 +55,14 @@
     "directory": "packages/adapter-xslate"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.17.0"
+    "@barefootjs/shared": "0.18.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.17.0",
+    "@barefootjs/jsx": "0.18.0",
     "typescript": "^5.0.0"
   }
 }