@barefootjs/jsx 0.31.1 → 0.31.3

package/src/__tests__/multi-return-sibling-diagnostic.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Regression tests for #2556: a `'use client'` file where a component
+ * references a same-file sibling whose body is a multi-return JSX dispatch
+ * (`switch` / `if`-`else` chain) previously compiled clean with ZERO
+ * diagnostics, but the sibling produced no template — so the emitted
+ * `renderChild`/`initChild`/`createComponent` call referenced a component
+ * name with nothing registered under it, throwing
+ * `ReferenceError: <Name> is not defined` at SSR/hydrate time.
+ *
+ * Root cause: `listComponentFunctions`'s #932 "preserve verbatim helper"
+ * bypass is gated on `!hasUseClient` — in a `'use client'` file, a
+ * multi-return sibling like `NavIcon` below IS added to `componentNames`
+ * and asked to compile as a standalone component. But `visitComponentBody`
+ * only folds `if`/`else`-chain multi-return bodies into `conditionalReturns`
+ * (#1401); a top-level `switch` statement is preserved as a verbatim init
+ * statement instead, so `ctx.jsxReturn` stays null and
+ * `compileMultipleComponents`'s Pass-1 loop silently `continue`s past it —
+ * no entry, no template, no error. Meanwhile the referencing sibling's IR
+ * still holds a `component` reference to the dropped name.
+ *
+ * Fix: BF048 detects this structurally — after Pass 1, any name in
+ * `componentNames` that did not make it into `entries` is cross-referenced
+ * against every compiled sibling's IR component-reference graph (the same
+ * walk `@bf-child` import markers use, `collectComponentNamesFromIR`). A
+ * hit fails the compile instead of shipping a silent `ReferenceError`.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+describe('Sibling multi-return JSX dispatch produces no template in a client file (#2556)', () => {
+  // Higher timeout: `.map()` in the source trips `needsTypeBasedDetection`,
+  // and building the one-time `ts.Program` for BF023/BF024's nullable-key
+  // check is slow the first time the TS API is touched in a fresh process
+  // (e.g. this file run in isolation) — well past bun's 5s default.
+  test('BF048: .map() loop child referencing a switch-dispatch sibling fails the compile', () => {
+    const source = `
+      "use client"
+      import { createSignal } from '@barefootjs/client'
+      function NavIcon({ name }: { name: string }) {
+        switch (name) {
+          case 'home': return <svg><path d="M1"/></svg>
+          case 'bell': return <svg><path d="M2"/></svg>
+          default: return null
+        }
+      }
+      export function Shell() {
+        const [n, setN] = createSignal(0)
+        return (
+          <nav onClick={() => setN(n() + 1)}>
+            {['home', 'bell'].map(item => <NavIcon key={item} name={item} />)}
+          </nav>
+        )
+      }
+    `
+
+    const result = compileJSX(source, 'Shell.tsx', { adapter })
+    const errs = result.errors.filter(e => e.severity === 'error')
+    expect(errs.length).toBeGreaterThan(0)
+    const bf048 = errs.find(e => e.code === 'BF048')
+    expect(bf048).toBeDefined()
+    expect(bf048!.message).toContain('NavIcon')
+    expect(bf048!.message).toContain('Shell')
+    expect(bf048!.message).toMatch(/did not compile to a template/)
+  }, 20000)
+
+  test('BF048: direct JSX tag (non-loop) referencing a switch-dispatch sibling fails the compile', () => {
+    const source = `
+      "use client"
+      import { createSignal } from '@barefootjs/client'
+      function StatusIcon({ status }: { status: string }) {
+        switch (status) {
+          case 'ok': return <span class="ok">OK</span>
+          case 'err': return <span class="err">ERR</span>
+          default: return null
+        }
+      }
+      export function Panel() {
+        const [n, setN] = createSignal(0)
+        return <div onClick={() => setN(n() + 1)}><StatusIcon status="ok" /></div>
+      }
+    `
+
+    const result = compileJSX(source, 'Panel.tsx', { adapter })
+    const errs = result.errors.filter(e => e.severity === 'error')
+    const bf048 = errs.find(e => e.code === 'BF048')
+    expect(bf048).toBeDefined()
+    expect(bf048!.message).toContain('StatusIcon')
+  })
+
+  test('legal neighbor: the identical switch-dispatch shape in a non-"use client" file compiles clean (#932)', () => {
+    // Same shape as the failing case above, but without the 'use client'
+    // directive: `listComponentFunctions`'s #932 bypass keeps NavIcon OFF
+    // `componentNames` entirely, so it is preserved verbatim in the marked
+    // template rather than compiled (and dropped) as a component. BF048
+    // must not fire here.
+    const source = `
+      function NavIcon({ name }: { name: string }) {
+        switch (name) {
+          case 'home': return <svg><path d="M1"/></svg>
+          case 'bell': return <svg><path d="M2"/></svg>
+          default: return null
+        }
+      }
+      export function Shell() {
+        return (
+          <nav>
+            {['home', 'bell'].map(item => <NavIcon key={item} name={item} />)}
+          </nav>
+        )
+      }
+    `
+
+    const result = compileJSX(source, 'Shell.tsx', { adapter })
+    const errs = result.errors.filter(e => e.severity === 'error')
+    expect(errs.filter(e => e.code === 'BF048')).toHaveLength(0)
+    expect(errs).toHaveLength(0)
+
+    const markedTemplate = result.files.find(f => f.type === 'markedTemplate')
+    expect(markedTemplate).toBeDefined()
+    expect(markedTemplate!.content).toContain('function NavIcon')
+  })
+
+  test('legal neighbor: a non-"use client" file never trips BF048, even when a sibling lands in componentNames', () => {
+    // The #932 bypass only skips NON-exported multi-return functions, so an
+    // exported switch-dispatch sibling in a non-client file IS in
+    // `componentNames` and produces no entry — the same set-difference shape
+    // BF048 keys on. But the diagnostic's premise (the 'use client' branch
+    // of #932, `ReferenceError` at hydrate time) doesn't apply outside
+    // client files, so BF048 is gated on a compiled client entry and must
+    // stay silent here.
+    const source = `
+      export function NavIcon({ name }: { name: string }) {
+        switch (name) {
+          case 'home': return <svg><path d="M1"/></svg>
+          case 'bell': return <svg><path d="M2"/></svg>
+          default: return null
+        }
+      }
+      export function Shell() {
+        return (
+          <nav>
+            {['home', 'bell'].map(item => <NavIcon key={item} name={item} />)}
+          </nav>
+        )
+      }
+    `
+
+    const result = compileJSX(source, 'Shell.tsx', { adapter })
+    const errs = result.errors.filter(e => e.severity === 'error')
+    expect(errs.filter(e => e.code === 'BF048')).toHaveLength(0)
+  })
+
+  test('legal neighbor: a "use client" sibling whose multi-return body DOES compile (if/else chain, #1401) stays clean', () => {
+    // if/else-if chains fold into `conditionalReturns` (#1401) and produce
+    // a real ternary template, so the sibling ends up in `entries` and the
+    // reference resolves. BF048 must not fire.
+    const source = `
+      "use client"
+      import { createSignal } from '@barefootjs/client'
+      function Badge({ kind }: { kind: string }) {
+        if (kind === 'ok') return <span class="ok">ok</span>
+        if (kind === 'warn') return <span class="warn">warn</span>
+        return <span class="err">err</span>
+      }
+      export function Panel() {
+        const [n, setN] = createSignal(0)
+        return (
+          <div onClick={() => setN(n() + 1)}>
+            <Badge kind="ok" />
+          </div>
+        )
+      }
+    `
+
+    const result = compileJSX(source, 'Panel.tsx', { adapter })
+    const errs = result.errors.filter(e => e.severity === 'error')
+    expect(errs.filter(e => e.code === 'BF048')).toHaveLength(0)
+
+    const clientJs = result.files.find(f => f.type === 'clientJs')
+    expect(clientJs).toBeDefined()
+    // Both the Panel and Badge components' hydrate() registrations exist
+    // with real templates — the sibling reference resolves. Badge is a
+    // non-exported sibling so its runtime key is file-scoped
+    // (`Badge__<hash>`); match on the `name: 'Badge'` metadata instead of
+    // the registry key.
+    expect(clientJs!.content).toMatch(/hydrate\('Badge[^']*',\s*\{[^}]*template:/s)
+    expect(clientJs!.content).toContain("name: 'Badge'")
+  })
+
+  test('legal neighbor: single-component "use client" multi-return root (#1401) is unaffected', () => {
+    // Only one component in the file, so `compileJSX` never enters the
+    // multi-component path where BF048 is computed at all.
+    const source = `
+      "use client"
+      import { createSignal } from '@barefootjs/client'
+      export function Toggle(props: { asChild?: boolean }) {
+        const [open, setOpen] = createSignal(false)
+        if (props.asChild) {
+          return <span onClick={() => setOpen(!open())}>child</span>
+        }
+        return <button onClick={() => setOpen(!open())}>toggle</button>
+      }
+    `
+
+    const result = compileJSX(source, 'Toggle.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+    const clientJs = result.files.find(f => f.type === 'clientJs')
+    expect(clientJs).toBeDefined()
+    expect(clientJs!.content).toContain('template:')
+  })
+
+  test('legal neighbor: a component-scope local JSX factory does not trip BF048', () => {
+    // `listComponentFunctions` recurses into function bodies, so a local
+    // factory like `Inner` below lands in `componentNames` and produces no
+    // standalone template — but its call sites are handled by the
+    // JSX-function-inlining pass, not `createComponent`, so it is NOT the
+    // dropped-sibling shape. BF048's uncompiled-sibling set is restricted
+    // to module top-level declarations precisely so this stays legal (the
+    // first BF048 cut flagged it and broke the ir-dynamic-tag corpus).
+    // Two components so the multi-component path (where BF048 runs) engages.
+    const source = `
+      "use client"
+      import { createSignal } from '@barefootjs/client'
+      export function Demo() {
+        const Inner = () => <span>x</span>
+        const [n, setN] = createSignal(0)
+        return <div onClick={() => setN(n() + 1)}><Inner /></div>
+      }
+      export function Other() {
+        return <p>other</p>
+      }
+    `
+
+    const result = compileJSX(source, 'demo.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  })
+})

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

@@ -13,7 +13,8 @@
 //     computations that derive from those signals (`count() * 2`).
 
 import { describe, test, expect } from 'bun:test'
-import { extractSsrDefaults } from '../ssr-defaults'
+import { extractSsrDefaults, deriveStashFromDefaults } from '../ssr-defaults'
+import type { SsrDefault } from '../ssr-defaults'
 import { analyzeComponent } from '../analyzer'
 import { buildMetadata } from '../compiler'
 
@@ -253,3 +254,125 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.classes).toEqual({ value: 'a b c d  tail' })
   })
 })
+
+// TS twin of the Ruby/Python/PHP/Perl/Rust `derive*FromDefaults` runtime
+// ports (#2524 SSR half). Matches `derive_vars_from_defaults`'s edge cases
+// exactly — see that Ruby method's docstring
+// (packages/adapter-erb/lib/barefoot_js.rb:337-360) for the reference
+// semantics this mirrors.
+describe('deriveStashFromDefaults', () => {
+  test('aliased prop: resolves the CALLER-facing propName, not the local key', () => {
+    // `{ n: count }` — extractSsrDefaults keys the entry by the LOCAL
+    // binding (`count`) with `propName: 'n'`. The caller supplies `n`.
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: null },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 7 })).toEqual({ count: 7 })
+  })
+
+  test('un-aliased prop: propName equals the local key, resolves the same way', () => {
+    const defaults: Record<string, SsrDefault> = {
+      n: { propName: 'n', value: null },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 7 })).toEqual({ n: 7 })
+  })
+
+  test('caller omits the prop: falls back to the static default value', () => {
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 3 },
+    }
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ count: 3 })
+  })
+
+  test('caller supplies null / undefined for the propName: falls back to the static value', () => {
+    // Mirrors every runtime port's "present AND defined" check — an
+    // explicit null/undefined caller value does not count as an override.
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 3 },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: null })).toEqual({ count: 3 })
+    expect(deriveStashFromDefaults(defaults, { n: undefined })).toEqual({ count: 3 })
+  })
+
+  test('caller supplies a falsy-but-defined propName value: the caller value wins', () => {
+    // `0` / `''` / `false` are legitimate override values, not "absent".
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 99 },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 0 })).toEqual({ count: 0 })
+  })
+
+  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.
+    const defaults: Record<string, SsrDefault> = {
+      doubled: { value: 10 },
+    }
+    expect(deriveStashFromDefaults(defaults, { doubled: 999 })).toEqual({ doubled: 10 })
+  })
+
+  test('isRestProps entry: prefers the caller-assembled rest bag under its OWN key', () => {
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(deriveStashFromDefaults(defaults, { rest: { href: '/x' } })).toEqual({
+      rest: { href: '/x' },
+    })
+  })
+
+  test('isRestProps entry: falls back to the static value (normally {}) when the caller supplied none', () => {
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ rest: {} })
+  })
+
+  test('isRestProps entry: an explicit `undefined` caller value still counts as supplied', () => {
+    // Unlike the ordinary propName branch (nullish check), the isRestProps
+    // branch tests presence via `in` — the rest bag is a caller-assembled
+    // aggregate, not a single scalar with a meaningful "absent" state, so
+    // an explicit `undefined` still wins over the static fallback instead
+    // of falling through to it.
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: { fallback: true } },
+    }
+    const result = deriveStashFromDefaults(defaults, { rest: undefined })
+    expect('rest' in result).toBe(true)
+    expect(result.rest).toBeUndefined()
+  })
+
+  test('a bare (non-object) entry passes through as-is', () => {
+    // Defensive parity with every runtime port's `ref($d) eq 'HASH'` /
+    // `isinstance(d, dict)` guard — never emitted by `extractSsrDefaults`
+    // itself, but a caller may hand this a manifest round-tripped through a
+    // generic JSON domain.
+    const defaults = { flag: true } as unknown as Record<string, SsrDefault>
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ flag: true })
+  })
+
+  test('a literal null entry hits the same non-object passthrough guard', () => {
+    // `d === null` is checked ALONGSIDE `typeof d !== 'object'` (not just
+    // the latter) — `typeof null === 'object'` in JS, so without the
+    // explicit `d === null` check a null entry would wrongly fall into the
+    // object-shaped branches below and throw reading `d.isRestProps`.
+    const defaults = { flag: null } as unknown as Record<string, SsrDefault>
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ flag: null })
+  })
+
+  test('mixed defaults map resolves every entry kind independently', () => {
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: null },
+      text: { propName: 'text', value: null },
+      doubled: { value: 0 },
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(
+      deriveStashFromDefaults(defaults, { n: 7, rest: { extra: 'x' } }),
+    ).toEqual({
+      count: 7,
+      text: null,
+      doubled: 0,
+      rest: { extra: 'x' },
+    })
+  })
+})

package/src/__tests__/staged-ir/08-relocate-unit.test.ts

@@ -20,6 +20,7 @@ function envWith(
     propsForLift: new Set(
       bindings.filter(([, k]) => k === 'prop').map(([n]) => n),
     ),
+    propSourceNames: options?.propSourceNames ?? new Map(),
     propsObjectName: options?.propsObjectName ?? 'props',
     allowFallback: options?.allowFallback ?? true,
   }

package/src/__tests__/staged-ir/11-template-primitive-registry.test.ts

@@ -35,6 +35,7 @@ function envWith(
     propsForLift: new Set(
       bindings.filter(([, k]) => k === 'prop').map(([n]) => n),
     ),
+    propSourceNames: options?.propSourceNames ?? new Map(),
     propsObjectName: options?.propsObjectName ?? 'props',
     allowFallback: options?.allowFallback ?? true,
     templatePrimitives: options?.templatePrimitives,

package/src/adapters/interface.ts

@@ -28,6 +28,17 @@ export interface TemplateSections {
    * component in a source file.
    */
   moduleConstants?: string
+  /**
+   * When true, the `moduleConstants` section already carries the module's
+   * EXPORTED value declarations (consts/functions, `export` keyword
+   * included) interleaved in source order — so the compiler must NOT
+   * re-emit them via `generateModuleExports` (only `export { … }`
+   * specifier blocks remain its job). JSX adapters set this; keeping the
+   * exported and non-exported declarations in one source-ordered section
+   * is what prevents a non-exported const that reads an exported one from
+   * being emitted above it (a module-load TDZ crash — #2570's input-otp).
+   */
+  moduleConstantsIncludeExports?: boolean
 }
 
 export interface AdapterOutput {