@barefootjs/jsx 0.9.6 → 0.10.1

package/dist/index.js

@@ -16775,8 +16775,41 @@ function extractSsrDefaults(metadata) {
     out[memo.name] = { value: resultToJsonable(value) };
     bindings[memo.name] = value;
   }
+  if (metadata.propsObjectName !== null) {
+    const referenced = new Set;
+    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) {
+      if (name in out)
+        continue;
+      out[name] = { propName: name, value: null };
+    }
+  }
   return Object.keys(out).length === 0 ? undefined : out;
 }
+function collectPropRefs(expr, propsObjectName, out) {
+  if (!expr || !expr.trim())
+    return;
+  const node = parseExpression2(expr);
+  if (!node)
+    return;
+  const visit3 = (n) => {
+    if (ts16.isPropertyAccessExpression(n) && ts16.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts16.isIdentifier(n.name)) {
+      out.add(n.name.text);
+      return;
+    }
+    ts16.forEachChild(n, visit3);
+  };
+  visit3(node);
+}
 function resultToJsonable(v) {
   if (v === UNRESOLVED)
     return null;

package/dist/ssr-defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAYD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAsE/F"}
+{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAYD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAmG/F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.9.6",
+  "version": "0.10.1",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.9.6"
+    "@barefootjs/shared": "0.10.1"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

package/src/__tests__/ssr-defaults.test.ts

@@ -58,6 +58,30 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.count).toEqual({ value: 99 })
   })
 
+  test('seeds a bare-props prop a signal initializer reads (`props.initial`)', () => {
+    // The #1297 prop-derived seeding lowers `createSignal(props.initial ?? 0)`
+    // to a *bare scalar* recompute in the template (`my $count = ($initial
+    // // 0)`), so `$initial` must be a stash var or Perl strict aborts with
+    // `Global symbol "$initial" requires explicit package name`. The
+    // bare-props-arg form previously skipped all props; this regression
+    // guards that the referenced prop is now seeded (as undef → the
+    // recompute's `?? 0` supplies the real fallback).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function Counter(props: { initial?: number }) {
+        const [count, setCount] = createSignal(props.initial ?? 0)
+        const doubled = createMemo(() => count() * 2)
+        return <p>{count()}{doubled()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 0 })
+    expect(defaults?.doubled).toEqual({ value: 0 })
+    expect(defaults?.initial).toEqual({ propName: 'initial', value: null })
+  })
+
   test('memo derived from a signal evaluates through the chain', () => {
     const metadata = metadataFor(`
       'use client'

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