@barefootjs/jsx 0.17.0 → 0.18.0

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

@@ -0,0 +1,212 @@
+// Backend-neutral SSR seed plan (`computeSsrSeedPlan`, attached to
+// `IRMetadata.ssrSeedPlan` by `buildMetadata`). The plan ports the
+// derived/opaque/env-reader scope analysis the template adapters' seed paths
+// perform, so these tests pin the decision rules against metadata built by
+// the real pipeline (`analyzeComponent` + `buildMetadata`).
+
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { buildMetadata } from '../compiler'
+import type { SsrSeedPlan, SsrSeedStep } from '../ssr-seed-plan'
+
+function planFor(source: string, componentName?: string): SsrSeedPlan {
+  const ctx = analyzeComponent(source, 'test.tsx', componentName)
+  const plan = buildMetadata(ctx).ssrSeedPlan
+  expect(plan).toBeDefined()
+  return plan!
+}
+
+function step(plan: SsrSeedPlan, name: string): SsrSeedStep {
+  const found = plan.steps.find(s => s.name === name)
+  expect(found).toBeDefined()
+  return found!
+}
+
+describe('computeSsrSeedPlan', () => {
+  test('env signal (aliased) → env-reader step; derived memo over it', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSearchParams } from '@barefootjs/client'
+      function List() {
+        const [sp] = createSearchParams()
+        const sort = createMemo(() => sp().get('sort') ?? 'date')
+        return <p>{sort()}</p>
+      }
+    `)
+
+    const sp = step(plan, 'sp')
+    expect(sp.kind).toBe('env-reader')
+    if (sp.kind === 'env-reader') {
+      expect(sp.reader.canonicalName).toBe('searchParams')
+      expect(sp.reader.key).toBe('search')
+    }
+
+    const sort = step(plan, 'sort')
+    expect(sort.kind).toBe('derived')
+    if (sort.kind === 'derived') {
+      expect(sort.origin).toBe('memo')
+      expect(sort.frees).toEqual(['sp'])
+      expect(sort.expr).toBe("sp().get('sort') ?? 'date'")
+      expect(sort.parsed).toBeDefined()
+    }
+  })
+
+  test('chained memos in a props-object component: declaration order, scope accumulates', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSearchParams } from '@barefootjs/client'
+      function List(props: { items: { tag: string; name: string }[] }) {
+        const [sp] = createSearchParams()
+        const tag = createMemo(() => sp().get('tag') ?? '')
+        const visible = createMemo(() => props.items.filter((p) => p.tag === tag()))
+        return <ul>{visible().map((i) => <li>{i.name}</li>)}</ul>
+      }
+    `)
+
+    expect(plan.baseScope).toContain('props')
+    expect(plan.steps.map(s => s.name)).toEqual(['sp', 'tag', 'visible'])
+
+    expect(step(plan, 'tag').kind).toBe('derived')
+    const visible = step(plan, 'visible')
+    expect(visible.kind).toBe('derived')
+    if (visible.kind === 'derived') {
+      for (const free of visible.frees) {
+        expect(['props', 'tag']).toContain(free)
+      }
+    }
+  })
+
+  test('forward reference to a later memo → opaque; the later memo itself is derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [n, setN] = createSignal(1)
+        const early = createMemo(() => late() + 1)
+        const late = createMemo(() => n() * 2)
+        return <p>{early()}</p>
+      }
+    `)
+
+    expect(step(plan, 'early').kind).toBe('opaque')
+    expect(step(plan, 'late').kind).toBe('derived')
+  })
+
+  test('self reference → opaque (name enters scope only after its own step)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C() {
+        const loop = createMemo(() => loop())
+        return <p>{loop()}</p>
+      }
+    `)
+
+    expect(step(plan, 'loop').kind).toBe('opaque')
+  })
+
+  test('shadowed callback param leaking as an outer free identifier → opaque', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C(props: { items: { ok: boolean }[] }) {
+        const bad = createMemo(() => props.items.filter((p) => p.ok) && p)
+        return <p>{bad()}</p>
+      }
+    `)
+
+    expect(step(plan, 'bad').kind).toBe('opaque')
+  })
+
+  test('module string const counts as base scope; memo referencing it is derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      const activeCls = 'text-bold'
+      function C() {
+        const [on, setOn] = createSignal(false)
+        const cls = createMemo(() => on() ? activeCls : 'text-dim')
+        return <p class={cls()}>x</p>
+      }
+    `, 'C')
+
+    expect(plan.baseScope).toContain('activeCls')
+    const cls = step(plan, 'cls')
+    expect(cls.kind).toBe('derived')
+    if (cls.kind === 'derived') {
+      expect(cls.frees).toContain('on')
+      expect(cls.frees).toContain('activeCls')
+    }
+  })
+
+  test('block-bodied memo → opaque (v1 gates to expression-bodied memos)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [on, setOn] = createSignal(false)
+        const label = createMemo(() => {
+          const v = on()
+          return v ? 'yes' : 'no'
+        })
+        return <p>{label()}</p>
+      }
+    `)
+
+    const label = step(plan, 'label')
+    expect(label.kind).toBe('opaque')
+    if (label.kind === 'opaque') expect(label.origin).toBe('memo')
+  })
+
+  test('unsupported body (object literal) → opaque', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [n, setN] = createSignal(1)
+        const obj = createMemo(() => ({ value: n() }))
+        return <p>{obj().value}</p>
+      }
+    `)
+
+    expect(step(plan, 'obj').kind).toBe('opaque')
+  })
+
+  test('literal signal init → derived with empty frees (constant-skip is emit-side)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [v, setV] = createSignal('b')
+        return <p>{v()}</p>
+      }
+    `)
+
+    const v = step(plan, 'v')
+    expect(v.kind).toBe('derived')
+    if (v.kind === 'derived') {
+      expect(v.origin).toBe('signal')
+      expect(v.frees).toEqual([])
+      expect(v.expr).toBe("'b'")
+    }
+  })
+
+  test('prop-derived signal init → derived with the prop free', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Toggle(props: { defaultOn?: boolean }) {
+        const [on, setOn] = createSignal(props.defaultOn ?? false)
+        return <button aria-pressed={on()}>t</button>
+      }
+    `)
+
+    expect(plan.baseScope).toContain('props')
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('derived')
+    if (on.kind === 'derived') {
+      expect(on.origin).toBe('signal')
+      expect(on.frees).toEqual(['props'])
+    }
+  })
+})

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

@@ -5,14 +5,25 @@
  * rejections for callees the adapter promises it can render in template
  * scope.
  *
+ * #2069 extends this with two more acceptance mechanisms, tested in the
+ * two `describe` blocks at the bottom of this file:
+ *   - `RelocateEnv.loweringMatchers` — a THIRD acceptance path alongside
+ *     `templatePrimitives` / `acceptsTemplateCall`, for calls a
+ *     `LoweringPlugin` recognises structurally (never string-keyed).
+ *   - `RelocateEnv.aliasTargets` — one-hop alias resolution, so
+ *     `const fmt = customSerialize; fmt(x)` keys/matches as
+ *     `customSerialize`, not `fmt`.
+ *
  * No adapter populates the registry yet — the wiring is exercised here
- * via hand-built env objects. Phase 3 will fill the Hono predicate.
+ * via hand-built env objects. Phase 3 filled the Hono predicate; #2069
+ * adds the plugin-matcher and alias seams.
  */
 
 import { describe, test, expect } from 'bun:test'
 import type { RelocateEnv } from '../../relocate'
 import { isInlinableInTemplate } from '../../relocate'
 import type { BindingKind } from '../../types'
+import type { LoweringMatcher } from '../../lowering-registry'
 
 function envWith(
   bindings: Array<[string, BindingKind]>,
@@ -28,6 +39,8 @@ function envWith(
     allowFallback: options?.allowFallback ?? true,
     templatePrimitives: options?.templatePrimitives,
     acceptsTemplateCall: options?.acceptsTemplateCall,
+    loweringMatchers: options?.loweringMatchers,
+    aliasTargets: options?.aliasTargets,
   }
 }
 
@@ -256,3 +269,220 @@ describe('isInlinableInTemplate — adapter-aware acceptance (#1187 phase 2)', (
     })
   })
 })
+
+/** A `LoweringMatcher` that recognises a bare-identifier call to `name`. */
+function matcherFor(name: string): LoweringMatcher {
+  return (callee, args) => {
+    if (callee.kind !== 'identifier' || callee.name !== name) return null
+    return { kind: 'helper-call', helper: 'test_helper', args }
+  }
+}
+
+describe('isInlinableInTemplate — loweringMatchers acceptance (#2069)', () => {
+  test('a call recognised by a registered matcher is accepted', () => {
+    const env = envWith(
+      [
+        ['customSerialize', 'module-import'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        loweringMatchers: [matcherFor('customSerialize')],
+      },
+    )
+    const r = isInlinableInTemplate('customSerialize(config)', env)
+    expect(r.ok).toBe(true)
+    expect(r.rewrittenValue).toContain('customSerialize')
+  })
+
+  test('without a matching matcher, the call is still rejected', () => {
+    const env = envWith(
+      [
+        ['customSerialize', 'module-import'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        loweringMatchers: [matcherFor('someOtherHelper')],
+      },
+    )
+    const r = isInlinableInTemplate('customSerialize(config)', env)
+    expect(r.ok).toBe(false)
+  })
+
+  test('templatePrimitives / acceptsTemplateCall / loweringMatchers are all independent acceptance paths', () => {
+    // Only the matcher accepts here — no string-keyed entry exists at all.
+    const env = envWith(
+      [
+        ['customSerialize', 'module-import'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        templatePrimitives: {},
+        acceptsTemplateCall: () => false,
+        loweringMatchers: [matcherFor('customSerialize')],
+      },
+    )
+    const r = isInlinableInTemplate('customSerialize(config)', env)
+    expect(r.ok).toBe(true)
+  })
+
+  describe('shadow guard applies to matcher acceptance too', () => {
+    test('a local binding shadowing the recognised name is refused', () => {
+      // `customSerialize` here is a component-local (e.g. reassigned from
+      // a prop), NOT the module import the plugin's `prepare()` resolved
+      // against. The matcher itself has no way to know this — the shadow
+      // guard in `isCallAcceptedByAdapter` is what keeps it from firing.
+      const env = envWith(
+        [
+          ['customSerialize', 'init-local'], // shadows the import
+          ['config', 'prop'],
+        ],
+        {
+          propsObjectName: null,
+          loweringMatchers: [matcherFor('customSerialize')],
+        },
+      )
+      const r = isInlinableInTemplate('customSerialize(config)', env)
+      expect(r.ok).toBe(false)
+    })
+
+    test('module-import / module-local bindings still activate the matcher', () => {
+      const env = envWith(
+        [
+          ['customSerialize', 'module-local'],
+          ['config', 'prop'],
+        ],
+        {
+          propsObjectName: null,
+          loweringMatchers: [matcherFor('customSerialize')],
+        },
+      )
+      const r = isInlinableInTemplate('customSerialize(config)', env)
+      expect(r.ok).toBe(true)
+    })
+  })
+})
+
+describe('isInlinableInTemplate — one-hop alias resolution (#2069 R2)', () => {
+  test('alias → registered builtin (templatePrimitives) is accepted', () => {
+    // const fmt = Math.floor; fmt(score)
+    const env = envWith(
+      [
+        ['fmt', 'init-local'],
+        ['Math', 'global'],
+        ['score', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['fmt', 'Math.floor']]),
+        templatePrimitives: {
+          'Math.floor': (args) => `Math.floor(${args[0]})`,
+        },
+      },
+    )
+    const r = isInlinableInTemplate('fmt(score)', env)
+    expect(r.ok).toBe(true)
+    expect(r.rewrittenValue).toContain('Math.floor')
+  })
+
+  test('aliased-namespace MEMBER callee resolves too (const m = Math; m.floor)', () => {
+    // The leftmost segment is spliced and the `.path` tail carried over —
+    // `m.floor(score)` keys the registry as `Math.floor` (Copilot review
+    // on #2097 pinned that this is intended, not bare-identifier-only).
+    const env = envWith(
+      [
+        ['m', 'init-local'],
+        ['Math', 'global'],
+        ['score', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['m', 'Math']]),
+        templatePrimitives: {
+          'Math.floor': (args) => `Math.floor(${args[0]})`,
+        },
+      },
+    )
+    const r = isInlinableInTemplate('m.floor(score)', env)
+    expect(r.ok).toBe(true)
+  })
+
+  test('alias → a loweringMatchers-recognised import is accepted', () => {
+    // const serialize = customSerialize; serialize(config)
+    const env = envWith(
+      [
+        ['serialize', 'init-local'],
+        ['customSerialize', 'module-import'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['serialize', 'customSerialize']]),
+        loweringMatchers: [matcherFor('customSerialize')],
+      },
+    )
+    const r = isInlinableInTemplate('serialize(config)', env)
+    expect(r.ok).toBe(true)
+    expect(r.rewrittenValue).toContain('customSerialize')
+  })
+
+  test('alias → alias chain is refused — only ONE hop is resolved', () => {
+    // const g = f (f is itself just another local, never resolved further)
+    const env = envWith(
+      [
+        ['g', 'init-local'],
+        ['f', 'init-local'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['g', 'f']]),
+        // Maximally permissive predicate — even this can't help, because
+        // the shadow guard rejects on `f`'s own (unsafe) binding kind
+        // before the predicate is ever consulted.
+        acceptsTemplateCall: () => true,
+      },
+    )
+    const r = isInlinableInTemplate('g(config)', env)
+    expect(r.ok).toBe(false)
+  })
+
+  test('alias → a non-import component-local helper is refused', () => {
+    // const h = helper (helper is a local function/const, not module-scope)
+    const env = envWith(
+      [
+        ['h', 'init-local'],
+        ['helper', 'init-local'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['h', 'helper']]),
+        acceptsTemplateCall: () => true,
+      },
+    )
+    const r = isInlinableInTemplate('h(config)', env)
+    expect(r.ok).toBe(false)
+  })
+
+  test('a plain non-alias init-local is unaffected by aliasTargets being present', () => {
+    // Baseline: aliasTargets has entries for OTHER names, but this
+    // reference isn't one of them — falls through to the ordinary
+    // init-local fallback, same as if aliasTargets were absent.
+    const env = envWith(
+      [
+        ['count', 'init-local'],
+        ['config', 'prop'],
+      ],
+      {
+        propsObjectName: null,
+        aliasTargets: new Map([['fmt', 'Math.floor']]),
+      },
+    )
+    const r = isInlinableInTemplate('count', env)
+    expect(r.ok).toBe(true) // fallback to 'undefined', not a rejection
+    expect(r.rewrittenValue).toBe('undefined')
+  })
+})