@barefootjs/jsx 0.10.0 → 0.11.0

package/src/ssr-defaults.ts

@@ -149,9 +149,74 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     bindings[memo.name] = value
   }
 
+  // Bare-props-arg form (`function Foo(props: Props)`): a signal / memo
+  // whose initializer reads `props.X` is lowered by template-stash
+  // adapters to a *bare scalar* recompute (`my $count = ($initial // 0)`,
+  // the #1297 prop-derived seeding) — not a `$props->{X}` hash read. That
+  // bare `$initial` has to exist in the stash or Perl's strict mode aborts
+  // the render with `Global symbol "$initial" requires explicit package
+  // name`. The top block skips bare-props props on the assumption they're
+  // only ever read via `$props->{X}`, which the prop-derived seeding
+  // violates — so seed every prop a signal / memo initializer references.
+  // Value is `null` (→ undef): the recompute's own `?? <literal>` supplies
+  // the real fallback, and a caller-passed prop still wins via `propName`.
+  if (metadata.propsObjectName !== null) {
+    const referenced = new Set<string>()
+    for (const sig of metadata.signals) {
+      if (!sig.getter || sig.isModule) continue
+      collectPropRefs(sig.initialValue, metadata.propsObjectName, referenced)
+    }
+    for (const memo of metadata.memos) {
+      if (memo.isModule) continue
+      collectPropRefs(memo.computation, metadata.propsObjectName, referenced)
+    }
+    for (const name of referenced) {
+      // Don't clobber a signal / memo (or already-seeded prop) of the same
+      // name — those carry a resolved value the recompute relies on.
+      if (name in out) continue
+      out[name] = { propName: name, value: null }
+    }
+  }
+
   return Object.keys(out).length === 0 ? undefined : out
 }
 
+/**
+ * Collect the first-level property name of every `propsObjectName.X` access
+ * within `expr` (e.g. `props.initial ?? 0` → `initial`). Used to seed the
+ * stash vars a template-stash adapter's bare-scalar signal/memo recompute
+ * references. A deeper chain (`props.a.b`) still contributes its *base*
+ * prop `a`: adapters lower that to `$a->{b}`, so the bare `$a` needs
+ * seeding just the same — the walk stops at the first
+ * `propsObjectName.<name>` match and collects `a` (not `b`).
+ */
+function collectPropRefs(
+  expr: string | undefined,
+  propsObjectName: string,
+  out: Set<string>,
+): void {
+  if (!expr || !expr.trim()) return
+  const node = parseExpression(expr)
+  if (!node) return
+  const visit = (n: ts.Node): void => {
+    if (
+      ts.isPropertyAccessExpression(n) &&
+      ts.isIdentifier(n.expression) &&
+      n.expression.text === propsObjectName &&
+      ts.isIdentifier(n.name)
+    ) {
+      // `propsObjectName.<name>` — collect <name> and stop. For a deeper
+      // chain (`props.a.b`) this node is the inner `props.a`, so we collect
+      // the base prop `a` (which lowers to `$a->{b}`); the outer `.b`
+      // access has no further `props.` reference to find.
+      out.add(n.name.text)
+      return
+    }
+    ts.forEachChild(n, visit)
+  }
+  visit(node)
+}
+
 function resultToJsonable(v: EvalResult): unknown {
   if (v === UNRESOLVED) return null
   if (v === undefined) return null

package/src/types.ts

@@ -1570,6 +1570,14 @@ export interface CompileOptions {
    * starting with `.`.
    */
   rewriteRelativeImport?: (importPath: string) => string
+  /**
+   * Profile mode (#1690, SR3). When true, the client-JS codegen emits
+   * IR-aligned `__bfId` arguments at reactive creation sites
+   * (`createSignal`/`createMemo`/`createEffect`) so a profiling run can join
+   * runtime events to IR nodes. Off by default — the emitted code is then
+   * byte-for-byte unchanged (SR8). Dev/profiling builds only.
+   */
+  profile?: boolean
 }
 
 export interface FileOutput {