@barefootjs/jsx 0.31.9 → 0.32.0

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

@@ -103,6 +103,211 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.n).toEqual({ value: 0 })
   })
 
+  test('self-derived signal collision (#2669, shape A): entry stays a PROP entry, not the evaluated signal value', () => {
+    // `props.label` and the signal getter `label` share a name — the
+    // bare-props-arg form is the only shape where this collides (a
+    // destructured-arg `function C({ label })` + `const [label] = ...`
+    // is a JS redeclaration error, so it can't happen there). The
+    // emitted template reads the stash var `label` as the RAW caller
+    // prop and OVERWRITES it with the derived signal value under that
+    // SAME name (`{% set label = (label if label is defined else
+    // 'Default') %}`). Seeding the stash with the pre-fix `{ value:
+    // 'Default' }` (the EVALUATED signal value, discarding `propName`)
+    // means a caller-passed `label` can never win — production seeds
+    // 'Default', the template sees a non-none value, and keeps it. The
+    // fix: this entry must stay a PROP entry (`propName` set, `value:
+    // null`) so the template's own `?? 'Default'` guard supplies the
+    // real fallback, and a caller-supplied prop still wins via
+    // `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived signal collision (#2669, shape B): non-idempotent derivation must not seed the pre-fix double-applied value', () => {
+    // `(props.count ?? 1) * 2` is NOT idempotent: seeding the stash with
+    // the pre-fix EVALUATED value (2, for no caller prop) makes the
+    // template's own recompute apply the `* 2` a second time (`2 * 2 =
+    // 4`) — wrong even with no caller props at all. Pin that the entry
+    // is the RAW-prop shape (`value: null`), not `{ value: 2 }`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { count?: number }) {
+        const [count, setCount] = createSignal((props.count ?? 1) * 2)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ propName: 'count', value: null })
+  })
+
+  test('self-derived memo collision (#2669): the same rule applies to a memo whose computation derives from a same-named prop', () => {
+    // Same collision, memo flavor: `createMemo(() => (props.label ??
+    // 'Default') + n())` — the memo's OWN name (`label`) is the
+    // template variable the emitted template both reads (raw prop) and
+    // overwrites (derived memo value). `n` is an unrelated ordinary
+    // signal and must be unaffected (plain `{ value }` entry, no
+    // `propName`).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [n, setN] = createSignal(0)
+        const label = createMemo(() => (props.label ?? 'Default') + n())
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+    expect(defaults?.n).toEqual({ value: 0 })
+  })
+
+  test('NON-self-derived collision (#2669, shape C — out of scope, must be unchanged): signal value still wins, no `propName`', () => {
+    // Same-named `label` getter and `label` prop, but the signal's OWN
+    // initializer does NOT derive from `props.label` (it's a plain
+    // string literal) — the JSX body separately reads `label()` AND
+    // `props.label`. That's a template-variable-ALIASING defect (both
+    // expressions lower to the same template variable, so no seeding
+    // choice can be right for both readers) — a different bug, tracked
+    // separately, and this fix must leave it byte-identical: the entry
+    // stays the plain evaluated-signal-value shape with no `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal('sig')
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: 'sig' })
+  })
+
+  test('self-derived signal collision THROUGH a component-scope const (#2685 review): entry stays a PROP entry', () => {
+    // One hop of pure indirection past #2669's shape A: `referencesOwnProp`
+    // (built on `collectPropRefs`) only saw a DIRECT `props.<name>` access
+    // in the initializer — a `const mid = props.label` sitting between the
+    // prop read and `createSignal(mid ?? 'Default')` defeated the
+    // detection, so this entry regressed to the pre-#2669 `{ value:
+    // 'Default' }` shape (no `propName`) even after the #2669 fix landed.
+    // Same fix, widened: `collectPropRefsTransitive` now looks through
+    // component-scope const locals.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const [label, setLabel] = createSignal(mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived memo collision THROUGH a component-scope const (#2685 review)', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const label = createMemo(() => mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('multi-hop const chain resolves transitively (#2685 review): `const a = props.x; const b = a`', () => {
+    // Two hops of indirection (`b` reads `a`, `a` reads `props.x`) — the
+    // signal here is named `count`, a DIFFERENT name from the prop `x`, so
+    // this exercises the bare-props safety net's transitive resolution
+    // (not the self-derivation `propName` collision path above): `x` must
+    // still be seeded, or the template-stash adapters' bare-scalar
+    // recompute for `x` aborts at render time (#1297/#2126).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 1 })
+    expect(defaults?.x).toEqual({ propName: 'x', value: null })
+  })
+
+  test('safety-net seeding sees a prop through a component-scope const (#2685 review)', () => {
+    // The #1297/#2126 bare-props safety net (`collectPropRefs` at the
+    // bottom of `extractSsrDefaults`) only saw a DIRECT `props.X` access
+    // too — this is that same gap, single hop: `const mid = props.initial;
+    // createSignal(mid ?? 0)` misses seeding `initial`, which is a
+    // `Global symbol "$initial" requires explicit package name` render
+    // abort on Perl-strict backends. `count` (the signal's own name) is
+    // unrelated to `initial`, so this is NOT the self-collision path —
+    // purely the safety net.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Counter(props: { initial?: number }) {
+        const mid = props.initial
+        const [count, setCount] = createSignal(mid ?? 0)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 0 })
+    expect(defaults?.initial).toEqual({ propName: 'initial', value: null })
+  })
+
+  test('NEGATIVE (#2685 review): a const NOT derived from props keeps the signal-wins behavior', () => {
+    // Same-named `label` getter and `label` prop, wrapped in a const — but
+    // the const's OWN value doesn't read `props` at all, so
+    // `collectPropRefsTransitive` must NOT report a collision here. Must
+    // stay the plain evaluated-signal-value shape with no `propName` — the
+    // const-chain widening only ever ADDS prop references it finds by
+    // actually walking through `props.X`, never invents one.
+    //
+    // (The value resolves to `null`, not `'sig'`: `tryStaticEval` doesn't
+    // bind component-scope const locals into its evaluation `bindings` —
+    // see the signal loop's `bindings` comment above — so `mid` itself is
+    // unresolved for VALUE purposes independent of this fix; only the
+    // separate `propName`-detection walk this test is pinning follows the
+    // const chain.)
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = 'sig'
+        const [label, setLabel] = createSignal(mid)
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: null })
+  })
+
   test('aliased destructured prop (#2460): `propName` is the CALLER-facing key, not the local binding', () => {
     // `{ n: count }` — the caller passes `n`, the template variable (and
     // stash entry key) is the local binding `count`. The manifest
@@ -302,6 +507,31 @@ describe('deriveStashFromDefaults', () => {
     expect(deriveStashFromDefaults(defaults, { n: 0 })).toEqual({ count: 0 })
   })
 
+  test('self-derived signal collision (#2669): the caller-supplied prop now wins, and an absent prop falls back to null', () => {
+    // End-to-end proof of the fix's effect at the `deriveStashFromDefaults`
+    // layer: run the real `extractSsrDefaults` output for shape A through
+    // the seeding function. Pre-fix, this entry was `{ value: 'Default' }`
+    // (propName-less) so a caller's `label: 'Hello'` was IGNORED —
+    // `deriveStashFromDefaults` had no `propName` to resolve against and
+    // always used the static value. Post-fix the entry is a PROP entry, so
+    // the caller's value wins, and an absent prop resolves to the RAW
+    // fallback `null` (not the old evaluated `'Default'`) — the emitted
+    // template's own `?? 'Default'` guard supplies the real default from
+    // there.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+    const defaults = extractSsrDefaults(metadata)!
+
+    expect(deriveStashFromDefaults(defaults, { label: 'Hello' })).toEqual({ label: 'Hello' })
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ label: null })
+  })
+
   test('propName-less entry (signal / memo local): always uses the static value', () => {
     // A caller cannot override an internal signal/memo by construction —
     // even a same-named caller prop must not leak in.

package/src/__tests__/ssr-seed-plan.test.ts

@@ -209,4 +209,76 @@ describe('computeSsrSeedPlan', () => {
       expect(on.frees).toEqual(['props'])
     }
   })
+
+  test('prop-derived signal init THROUGH a component-scope const (#2685 review): still derived, resolves to the prop free', () => {
+    // Pre-fix, `mid` (a component-scope const, not part of `baseScope`)
+    // was a free identifier `classify` couldn't find in `available`, so
+    // this step fell to `opaque` — no adapter emits an in-template
+    // recompute for it at all (a DIFFERENT, worse-than-#2669 defect: even
+    // with `propName` restored on the manifest side, an absent caller prop
+    // would render permanently empty instead of the signal's own
+    // `'Default'`). `resolveThroughLocalConsts` inlines `mid` to
+    // `props.defaultOn` before classification, so this now derives exactly
+    // like the direct-access form above.
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Toggle(props: { defaultOn?: boolean }) {
+        const mid = props.defaultOn
+        const [on, setOn] = createSignal(mid ?? false)
+        return <button aria-pressed={on()}>t</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('derived')
+    if (on.kind === 'derived') {
+      expect(on.origin).toBe('signal')
+      // The RESOLVED free set names `props` (what the inlined form reads),
+      // never the intermediate const `mid` — a consumer emitting `on`'s
+      // seed line never needs to know `mid` existed.
+      expect(on.frees).toEqual(['props'])
+    }
+  })
+
+  test('multi-hop const chain THROUGH TWO component-scope consts (#2685 review): still derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const count = step(plan, 'count')
+    expect(count.kind).toBe('derived')
+    if (count.kind === 'derived') {
+      expect(count.frees).toEqual(['props'])
+    }
+  })
+
+  test('const chain that bottoms out on an UNAVAILABLE name → opaque (fails safe, not a wrong substitution)', () => {
+    // `mid` inlines to `laterMemo`, a memo declared AFTER `on` in source —
+    // per the plan's ordering guarantee, `laterMemo` is not yet in
+    // `available` when `on` is classified, so this must stay `opaque`
+    // exactly like a direct forward-reference would (mirrors the existing
+    // "forward reference … → opaque" case above, one hop of const
+    // indirection removed).
+    const plan = planFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C() {
+        const mid = laterMemo()
+        const [on, setOn] = createSignal(mid ?? false)
+        const laterMemo = createMemo(() => true)
+        return <button aria-pressed={on()}>{laterMemo()}</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('opaque')
+  })
 })

package/src/analyzer.ts

@@ -3429,6 +3429,82 @@ function collectKeysFromMembers(
   return keys
 }
 
+/**
+ * Decide whether a member's `TypeInfo` is admissible for
+ * `collectMemberTypes`'s destructured-parameter resolution (#2677 —
+ * widened from the original string/number/boolean-only gate).
+ *
+ * #2150 originally restricted the gate to string/number/boolean, because a
+ * non-primitive `TypeInfo` there used to mean "the typed adapters will emit
+ * an unchecked scalar assertion (`in.X.(int)`) that panics" for a shape the
+ * template layer had no representation for. That reasoning does NOT extend
+ * to a rich type with a CATALOGUED lowering (#2274: `Date` → the `date`
+ * helper): its propsParams `TypeInfo` is consumed only as call-site
+ * evidence for `resolveReceiverType` (rich-type-evidence.ts) — never
+ * emitted as a concrete field type (`typeInfoToGo`'s `interface` case falls
+ * through to `interface{}` for an unbacked host name exactly as `unknown`
+ * already did) — so there is no assertion to panic. Gating on
+ * `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
+ * wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
+ * `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
+ * lowering plugin exists for yet.
+ *
+ * Nor does it extend to a STRUCTURAL shape (`kind: 'array'` /
+ * `kind: 'object'`) any more. `typeNodeToTypeInfo` already builds these
+ * fully recursively (`elementType`, `properties`) — the same walk the
+ * `props`-object form (`extractPropsFromTypeMembers`) always got — and
+ * go-template's `emitSynthPropStructs` (#2674/#2676) synthesizes a real,
+ * json-tagged Go struct for any anonymous object type it reaches through
+ * `ir.metadata.propsParams[].type`, array-element positions included. A
+ * structural `TypeInfo` is representable today, so admitting it here no
+ * longer resurrects #2150 either — it lets `propsParams[].type` carry the
+ * SAME shape the props-object form already resolved, closing the
+ * asymmetry #2677 reports (`{ items }: { items: {...}[] }` degrading to
+ * `unknown` while `(props: { items: {...}[] })` resolved fully).
+ *
+ * `array`/`object` admit only when EVERY reachable leaf resolves — an
+ * array's element type and an object's every property type must pass this
+ * same check, recursively. A union, a function, or an un-catalogued named
+ * type reachable ANYWHERE inside the shape declines the WHOLE member (not
+ * just that one leaf): `collectMemberTypes` is an all-or-nothing gate per
+ * member, so a partially-resolvable structural type must still decline —
+ * per-field graceful degradation is `typeInfoToGo`'s job downstream, not
+ * this gate's.
+ *
+ * The `object` arm requires `properties` to be PRESENT, not merely falsy-
+ * coalesced to `[]` — an absent-members claim and a zero-members claim are
+ * different things, and `.every()` on a defaulted-to-`[]` array would admit
+ * both identically (vacuously `true`), which is the #2150 failure mode
+ * wearing a different hat: a concrete representation with no evidence
+ * behind it. `typeNodeToTypeInfo`'s `object` arm DOES omit `properties`
+ * entirely in its `synthetic` mode (the checker-driven `tsTypeToTypeInfo`
+ * path, used for e.g. `createMemo` inference off a resolved `ts.Type`,
+ * which has no source positions for `membersToProperties`' `getText()`).
+ * This gate's only caller (`collectMemberTypes`'s `fromMembers`) always
+ * calls the NON-synthetic 2-arg form, so `properties` is in practice always
+ * at least `[]` here today — but `isResolvableMemberType` is a module-level
+ * function, not a closure scoped to that one caller, so it guards the
+ * general case rather than trust a caller-specific invariant. A genuinely
+ * EMPTY object literal (`{}`, real zero members) DOES resolve — an empty
+ * synthesized struct is exactly as faithful a representation as the type
+ * itself claims, nothing is being guessed.
+ */
+function isResolvableMemberType(info: TypeInfo): boolean {
+  switch (info.kind) {
+    case 'primitive':
+      return info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean'
+    case 'interface':
+      return CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw))
+    case 'array':
+      return !!info.elementType && isResolvableMemberType(info.elementType)
+    case 'object':
+      return info.properties !== undefined && info.properties.every(prop => isResolvableMemberType(prop.type))
+    // Unions, functions, and `unknown` all decline — see docstring.
+    default:
+      return false
+  }
+}
+
 /**
  * Build a property-name -> { type, optional } map from a props type
  * annotation, for destructured params (`{ value }: Props`) so they carry the
@@ -3443,36 +3519,17 @@ function collectKeysFromMembers(
  *   degraded to `unknown` -> `interface{}` for attribute omission, because
  *   #2252's nullish-flip machinery supplies the nillable representation
  *   exactly where absence is semantically observable (#2259).
- * - Only PRIMITIVE members (string/number/boolean) resolve a type. Those are
- *   the types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
- *   that panics. Arrays/objects/functions are left as `unknown` because typed
- *   adapters lower them through interface{}-based helpers (`bf_flat`, spread,
- *   `bf_json`); giving them concrete types would break that lowering and is a
- *   larger, separate change.
+ * - A member resolves a type when it is a PRIMITIVE (string/number/boolean),
+ *   a CATALOGUED rich type (`Date`), or a STRUCTURAL shape (array/object)
+ *   built entirely out of those, recursively (#2677). Unions, functions, and
+ *   un-catalogued named types (`Map`, `Set`, …) are left as `unknown` — see
+ *   `isResolvableMemberType`'s own docstring for why the structural cases
+ *   are safe to admit and why those three still are not.
  */
 function collectMemberTypes(
   typeNode: ts.TypeNode,
   ctx: AnalyzerContext
 ): Map<string, { type: TypeInfo | null; optional: boolean }> | null {
-  // #2150 originally restricted this gate to string/number/boolean only,
-  // because a non-primitive TypeInfo here used to mean "the typed adapters
-  // will emit an unchecked scalar assertion (`in.X.(int)`) that panics" for
-  // a shape the template layer has no representation for. That reasoning
-  // does NOT extend to a rich type with a CATALOGUED lowering (#2274: `Date`
-  // → the `date` helper): its propsParams TypeInfo is consumed only as
-  // call-site evidence for `resolveReceiverType` (rich-type-evidence.ts) —
-  // never emitted as a concrete field type (`typeInfoToGo`'s `interface`
-  // case falls through to `interface{}` for an unbacked host name exactly
-  // as `unknown` already did) — so there is no assertion to panic. Gating on
-  // `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
-  // wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
-  // `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
-  // lowering plugin exists for yet.
-  const isResolvablePrimitive = (info: TypeInfo): boolean =>
-    (info.kind === 'primitive' &&
-      (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')) ||
-    (info.kind === 'interface' && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw)))
-
   const fromMembers = (
     members: ts.NodeArray<ts.TypeElement>
   ): Map<string, { type: TypeInfo | null; optional: boolean }> => {
@@ -3481,7 +3538,7 @@ function collectMemberTypes(
       if (ts.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null
         map.set(member.name.getText(ctx.sourceFile), {
-          type: info && isResolvablePrimitive(info) ? info : null,
+          type: info && isResolvableMemberType(info) ? info : null,
           optional: !!member.questionToken,
         })
       }

package/src/expression-parser.ts

@@ -3037,8 +3037,17 @@ function usesPerPath(name: string, expr: ParsedExpr): { min: number; max: number
  * leaves that inner reference untouched (it is the parameter, not the binding).
  * Mirrors the structural walk of `substituteDestructuredFields`; every
  * `ParsedExpr` kind is handled so a new kind surfaces as a compile error here.
+ *
+ * Exported for `computeSsrSeedPlan` (`ssr-seed-plan.ts`), which reuses this
+ * SAME let-inline step to resolve a signal/memo initializer through
+ * component-scope `const` locals sitting between it and the prop it reads
+ * (`const mid = props.label; createSignal(mid ?? 'Default')`) — the
+ * structural (never string-splicing) analogue of what `foldBlockToExpr`
+ * already does for a block-bodied memo's own internal `const`s, and of what
+ * the CSR client-JS emitter's `csrSubstitute` does over TS source text for
+ * the compiled JS domain (#2685 review).
  */
-function inlineBinding(
+export function inlineBinding(
   expr: ParsedExpr,
   name: string,
   value: ParsedExpr,

package/src/index.ts

@@ -97,7 +97,6 @@ export { emitParsedExpr, groupBinaryOperand, isStringTypedOperand, isStringConca
 export type { ParsedExprEmitter, HigherOrderMethod, ArrayMethod, SortMethod, LiteralType } from './adapters/parsed-expr-emitter.ts'
 export { collectLoopBoundNames } from './adapters/loop-bound-names.ts'
 export { derivesScopeFromSlot } from './adapters/child-scope.ts'
-export { evaluateSignalInit, tryEvaluateSignalInit, type SignalInitEvalResult } from './signal-init-eval.ts'
 export { evaluateStaticLiteral, isFullyStaticLiteral, resolveStaticLoopSource } from './static-literal.ts'
 export { importsSearchParams, searchParamsLocalNames, envSignalLocalNames, envSignalReaderFor, ENV_SIGNAL_READERS, queryHrefLocalNames, formatDateLocalNames, matchSearchParamsMethodCall } from './adapters/env-signal.ts'
 export type { EnvSignalReader } from './adapters/env-signal.ts'