@barefootjs/mojolicious 0.17.0 → 0.17.1

package/src/adapter/memo/seed.ts

@@ -13,13 +13,10 @@ import {
   type ComponentIR,
   type ContextConsumer,
   collectContextConsumers,
-  extractArrowBodyExpression,
-  isSupported,
-  parseExpression,
+  computeSsrSeedPlan,
 } from '@barefootjs/jsx'
 
 import type { MojoMemoContext } from '../emit-context.ts'
-import { referencedVarsAreAvailable } from '../lib/ir-scope.ts'
 
 /** Perl literal for a context-consumer's `createContext` default. */
 export function contextDefaultPerl(c: ContextConsumer): string {
@@ -49,78 +46,28 @@ export function generateContextConsumerSeed(ir: ComponentIR): string {
 }
 
 /**
- * Seed memos whose SSR default is `null` (not statically evaluable) by
- * computing them in-template from the already-seeded prop / signal vars.
- * Targets the prop-derived memo shape (`createMemo(() => props.value * 10)`)
- * that the static `extractSsrDefaults` evaluator can't fold — without this
- * the memo's `$x` renders empty (the reason `props-reactivity-comparison`
- * was skipped). Only emitted when the lowered expression references vars the
- * template already has in scope (props params + signals + prior memos), so a
- * memo over an out-of-scope binding stays on the null path rather than
- * tripping Perl strict mode. (#1297)
+ * Emit `% my $<name> = <perl>;` seed lines for every `derived` step of the
+ * backend-neutral SSR seed plan — the scope/availability/ordering analysis
+ * lives in `computeSsrSeedPlan` (packages/jsx/src/ssr-seed-plan.ts); this
+ * only lowers each step's expression to Perl and applies the two
+ * backend-specific emit guards: skip an empty lowering, and skip a lowering
+ * that references no `$var` at all (a constant init/body — e.g. a `derived`
+ * step with empty `frees` — keeps the existing static ssr-defaults seed
+ * instead). `env-reader` and `opaque` steps emit nothing (the runtime
+ * supplies the reader, or the adapter's ssr-defaults path already covers it).
+ * (#1297, #2075)
  */
 export function generateDerivedMemoSeed(ctx: MojoMemoContext, ir: ComponentIR): string {
-  const memos = ir.metadata.memos ?? []
-  const signals = ir.metadata.signals ?? []
-  if (memos.length === 0 && signals.length === 0) return ''
-  // Props seed first; each signal/memo adds its own name as it lands so a
-  // later one can reference an earlier one.
-  const available = new Set<string>(ir.metadata.propsParams.map(p => p.name))
+  // Package G attached this to metadata at compile time; the `??` fallback
+  // only covers hand-built metadata in older tests that predate the attached
+  // plan — same shared function, so there's no divergence from the compiler.
+  const plan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata)
   const lines: string[] = []
-
-  // Prop/signal-derived signals (`createSignal(props.defaultOn ?? false)`):
-  // a loop-child render receives no stash seed for the signal, so its `$on`
-  // would trip strict mode; and even when an entry render seeds it, the
-  // static default can't capture the per-call prop. Seed it in-template from
-  // the passed prop — but ONLY when the init lowers cleanly AND references an
-  // in-scope var (i.e. it's genuinely derived). Object/array/constant inits
-  // (`createSignal({…})`, `createSignal([…])`, `createSignal('b')`) keep the
-  // existing ssr-defaults seeding, so the spread / loop fixtures are
-  // untouched.
-  for (const signal of signals) {
-    const perl = tryLowerToPerl(ctx, signal.initialValue, available)
-    if (perl !== null) lines.push(`% my $${signal.getter} = ${perl};`)
-    available.add(signal.getter)
-  }
-
-  for (const memo of memos) {
-    // Seed every memo whose body lowers cleanly — not just the ones whose
-    // static SSR default is null. A statically-foldable prop-derived memo
-    // (`createMemo(() => props.disabled ?? false)` → default `false`)
-    // still depends on the per-call prop: the static stash seed bakes in
-    // the absent-prop fold, so a caller passing `disabled => 1` would
-    // render the default branch (#1897, select's disabled item). The
-    // in-template recomputation reads the prop lexical the stash already
-    // seeded, so it's correct per call; block-bodied arrows /
-    // out-of-scope references fall back to the static ssr-defaults seed.
-    const body = extractArrowBodyExpression(memo.computation)
-    if (body !== null) {
-      const perl = tryLowerToPerl(ctx, body, available)
-      if (perl !== null) lines.push(`% my $${memo.name} = ${perl};`)
-    }
-    available.add(memo.name)
+  for (const step of plan.steps) {
+    if (step.kind !== 'derived') continue
+    const perl = ctx.convertExpressionToPerl(step.expr, step.parsed)
+    if (perl === '' || !/\$[A-Za-z_]\w*/.test(perl)) continue
+    lines.push(`% my $${step.name} = ${perl};`)
   }
   return lines.length > 0 ? lines.join('\n') + '\n' : ''
 }
-
-/**
- * Lower a signal init / memo body to Perl for an in-template SSR seed, or
- * `null` when it shouldn't be seeded this way. Returns null — without
- * recording a BF101 — when the expression isn't a supported shape
- * (`isSupported` pre-check, so object/array literals don't fail the build),
- * when the lowering references no in-scope var (a constant — keep the
- * existing ssr-defaults seeding), or when it references an out-of-scope
- * binding. (#1297)
- */
-export function tryLowerToPerl(
-  ctx: MojoMemoContext,
-  expr: string,
-  available: ReadonlySet<string>,
-): string | null {
-  const trimmed = expr.trim()
-  if (!trimmed) return null
-  if (!isSupported(parseExpression(trimmed)).supported) return null
-  const perl = ctx.convertExpressionToPerl(trimmed)
-  if (perl === '' || !/\$[A-Za-z_]\w*/.test(perl)) return null
-  return referencedVarsAreAvailable(perl, available) ? perl : null
-}

package/src/adapter/mojo-adapter.ts

@@ -695,8 +695,15 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   // ===========================================================================
 
   renderLoop(loop: IRLoop): string {
-    // Client-only loops: skip SSR rendering entirely
-    if (loop.clientOnly) return ''
+    // clientOnly loops must not render items at SSR time, but must still emit
+    // the `loop:`/`/loop:` boundary marker pair (Hono and Go parity) so the
+    // client runtime's mapArray() can locate the insertion anchor when
+    // hydrating the array. Without the markers, mapArray() resolves
+    // anchor = null and appends after sibling markers (#872). The marker id
+    // disambiguates sibling `.map()` calls under the same parent (#1087).
+    if (loop.clientOnly) {
+      return `<%== bf->comment("loop:${loop.markerId}") %><%== bf->comment("/loop:${loop.markerId}") %>`
+    }
 
     // An array/object-destructure loop param (`([emoji, users]) => ...`
     // or `({ name, age }) => ...`) lowers to invalid Perl — the adapter
@@ -1389,13 +1396,22 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     // now lowering `.length` on a higher-order object to
     // `scalar(@{...})`, the canonical
     // `x.tags.filter(t => t.active).length > 0` shape lowers
-    // cleanly. Predicates that combine a nested higher-order with
-    // something OTHER than `.length` (e.g. `.includes`, `.join`)
-    // still fall back to whatever the emitter produces — most of
-    // those would yield runtime errors in Perl, which is the user's
-    // signal to refactor. Wholesale refusal would also block the
-    // canonical case the issue exists to enable.
-    return emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap, n => this._isStringValueName(n)))
+    // cleanly, and nested `filter` / `every` / `some` lower to real
+    // inline `grep` forms. The shapes the emitter can only DEGRADE
+    // (nested `find*`, sort / reduce / flatMap inside a predicate)
+    // surface BF101 through the hook below instead of silently
+    // rewriting the predicate (#2038). Wholesale refusal would block
+    // the canonical case #1443 exists to enable, so the gate lives at
+    // the exact degrade points inside `MojoFilterEmitter.callbackMethod`.
+    return emitParsedExpr(
+      expr,
+      new MojoFilterEmitter(
+        param,
+        localVarMap,
+        n => this._isStringValueName(n),
+        (message, reason) => this._recordExprBF101(message, reason),
+      ),
+    )
   }
 
   // ===========================================================================