@pyreon/compiler 0.24.5 → 0.24.6

package/src/tests/dynamic-collapse-emit.test.ts

@@ -1,192 +0,0 @@
-/**
- * PR 3 of the dynamic-prop partial-collapse build — the compiler EMIT
- * half: `tryRocketstyleCollapse` falls through to `tryDynamicCollapse`
- * when BOTH the full and the `on*`-handler-partial paths bail. Emits
- * `__rsCollapseDyn(html, [stride-2 classes], () => cond ? 0 : 1, () =>
- * __pyrMode() === "dark")` consumed by PR 1's runtime helper `_rsCollapseDyn`
- * (#765).
- *
- * Mirrors the existing `partial-collapse-emit.test.ts` harness exactly
- * (stubbed resolved-`sites` map — the resolver/plugin scan is PR 4's
- * gate; this proves the emit contract in isolation).
- *
- * Bisect-verify (PR body): revert the fallback chain
- * (`return tryPartialCollapse(...) || tryDynamicCollapse(...)` →
- * `return tryPartialCollapse(...)`) → the dynamic-emit specs fail
- * (`__rsCollapseDyn(` absent) while the FULL + PARTIAL specs still
- * pass (proving the dynamic fallthrough is the only delta).
- * Restore → all pass.
- */
-import { describe, expect, it } from 'vitest'
-import { rocketstyleCollapseKey, transformJSX } from '../jsx'
-
-// Per-value resolved sites — the dynamic emit looks up BOTH literals
-// via separate keys. `templateHtml` MUST be byte-identical across
-// values for the dispatcher to share one `_tpl` (cross-value template
-// parity bail).
-const TPL = '<button>Save</button>'
-
-const PRIMARY = {
-  templateHtml: TPL,
-  lightClass: 'pyr-pri-L',
-  darkClass: 'pyr-pri-D',
-  rules: ['.pyr-pri-L{color:red}', '.pyr-pri-D{color:darkred}'],
-  ruleKey: 'bundle-pri',
-}
-const SECONDARY = {
-  templateHtml: TPL,
-  lightClass: 'pyr-sec-L',
-  darkClass: 'pyr-sec-D',
-  rules: ['.pyr-sec-L{color:blue}', '.pyr-sec-D{color:darkblue}'],
-  ruleKey: 'bundle-sec',
-}
-
-function collapseOpt(
-  candidates: string[],
-  sites: Record<string, { templateHtml: string; lightClass: string; darkClass: string; rules: string[]; ruleKey: string }>,
-) {
-  return {
-    collapseRocketstyle: {
-      candidates: new Set(candidates),
-      sites: new Map(Object.entries(sites)),
-      mode: { name: 'useMode', source: '@pyreon/ui-core' },
-    },
-  }
-}
-
-describe('compiler — dynamic-prop collapse emission (PR 3, ternary-of-two-literals)', () => {
-  it('emits __rsCollapseDyn with stride-2 value-major classes + cond dispatcher', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary', size: 'medium' }, 'Save')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary', size: 'medium' }, 'Save')
-    const src =
-      'const x = <Button state={isPrimary ? "primary" : "secondary"} size="medium">Save</Button>'
-    const { code } = transformJSX(
-      src,
-      'A.tsx',
-      collapseOpt(['Button'], { [truthyKey]: PRIMARY, [falsyKey]: SECONDARY }),
-    )
-
-    // Stride-2 value-major class layout: `[v0_light, v0_dark, v1_light, v1_dark]`.
-    // v0 = consequent (cond → 0), v1 = alternate (cond → 1) — matches
-    // `_rsCollapseDyn` doc + bisect-verified in PR 1 (#765).
-    expect(code).toContain(
-      '__rsCollapseDyn("<button>Save</button>", ' +
-        '["pyr-pri-L","pyr-pri-D","pyr-sec-L","pyr-sec-D"], ' +
-        '() => (isPrimary) ? 0 : 1, ' +
-        '() => __pyrMode() === "dark")',
-    )
-  })
-
-  it('imports the _rsCollapseDyn helper (and NOT the full / H helpers when not used)', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'Go')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary' }, 'Go')
-    const src = 'const x = <Button state={c ? "primary" : "secondary"}>Go</Button>'
-    const { code } = transformJSX(
-      src,
-      'B.tsx',
-      collapseOpt(['Button'], { [truthyKey]: PRIMARY, [falsyKey]: SECONDARY }),
-    )
-    // Conditional import — dynamic-only modules pull `_rsCollapseDyn`
-    // ONLY (tree-shake-friendly per-feature granularity).
-    expect(code).toContain('import { _rsCollapseDyn as __rsCollapseDyn } from "@pyreon/runtime-dom";')
-    expect(code).not.toContain('_rsCollapse as __rsCollapse')
-    expect(code).not.toContain('_rsCollapseH as __rsCollapseH')
-  })
-
-  it('unions BOTH values\' rule bundles via injectRules (de-duped by ruleKey)', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'X')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary' }, 'X')
-    const src = 'const x = <Button state={c ? "primary" : "secondary"}>X</Button>'
-    const { code } = transformJSX(
-      src,
-      'C.tsx',
-      collapseOpt(['Button'], { [truthyKey]: PRIMARY, [falsyKey]: SECONDARY }),
-    )
-    // Each value's rule bundle injected separately (different ruleKeys
-    // ⇒ no dedupe). Same idempotent injectRules contract as the full
-    // path — styler dedupes by key at runtime.
-    expect(code).toContain('"bundle-pri"')
-    expect(code).toContain('"bundle-sec"')
-    expect(code).toContain('__rsSheet.injectRules(')
-  })
-
-  it('preserves complex cond source verbatim (paren-wrapped for safe re-emission)', () => {
-    const truthyKey = rocketstyleCollapseKey('Btn', { state: 'primary' }, 'Hi')
-    const falsyKey = rocketstyleCollapseKey('Btn', { state: 'danger' }, 'Hi')
-    const src = 'const x = <Btn state={user.role === "admin" ? "primary" : "danger"}>Hi</Btn>'
-    const { code } = transformJSX(
-      src,
-      'D.tsx',
-      collapseOpt(['Btn'], {
-        [truthyKey]: { ...PRIMARY },
-        [falsyKey]: { ...SECONDARY, lightClass: 'pyr-dng-L', darkClass: 'pyr-dng-D' },
-      }),
-    )
-    // The paren-wrap (`(user.role === "admin")`) keeps the cond a single
-    // expression — same shape as the on*-handler emit re-emits arrow bodies.
-    expect(code).toContain('() => (user.role === "admin") ? 0 : 1')
-  })
-
-  // ── Conservative-bail discipline ───────────────────────────────────────
-  it('BAILS when EITHER expanded site is missing from the resolved map', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'S')
-    // Only the truthy half resolved — falsy is absent (resolver returned
-    // null for that variant). Half-resolved ⇒ keep the normal mount.
-    const src = 'const x = <Button state={c ? "primary" : "secondary"}>S</Button>'
-    const { code } = transformJSX(
-      src,
-      'E.tsx',
-      collapseOpt(['Button'], { [truthyKey]: PRIMARY }),
-    )
-    expect(code).not.toContain('__rsCollapseDyn(')
-    // Normal mount preserved — `<Button …>` JSX still appears (or its
-    // standard `h()` form post-transform).
-  })
-
-  it('BAILS when the structural template diverges across values', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'D')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary' }, 'D')
-    const src = 'const x = <Button state={c ? "primary" : "secondary"}>D</Button>'
-    const { code } = transformJSX(
-      src,
-      'F.tsx',
-      collapseOpt(['Button'], {
-        [truthyKey]: { ...PRIMARY, templateHtml: '<button>D</button>' },
-        [falsyKey]: { ...SECONDARY, templateHtml: '<button data-extra>D</button>' }, // divergent
-      }),
-    )
-    expect(code).not.toContain('__rsCollapseDyn(')
-  })
-
-  it('BAILS when the dynamic site ALSO has on*-handlers (PR 3 scope: no-handler only)', () => {
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'H')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary' }, 'H')
-    const src =
-      'const x = <Button state={c ? "primary" : "secondary"} onClick={go}>H</Button>'
-    const { code } = transformJSX(
-      src,
-      'G.tsx',
-      collapseOpt(['Button'], { [truthyKey]: PRIMARY, [falsyKey]: SECONDARY }),
-    )
-    expect(code).not.toContain('__rsCollapseDyn(')
-    expect(code).not.toContain('__rsCollapseH(')
-  })
-
-  // ── Regression: FULL + on*-PARTIAL paths byte-unchanged ────────────────
-  it('FULL-collapse path byte-unchanged: no-handler literal site emits plain __rsCollapse', () => {
-    const key = rocketstyleCollapseKey('Button', { state: 'primary' }, 'Save')
-    const src = 'const x = <Button state="primary">Save</Button>'
-    const { code } = transformJSX(src, 'H.tsx', collapseOpt(['Button'], { [key]: PRIMARY }))
-    expect(code).toContain('__rsCollapse(')
-    expect(code).not.toContain('__rsCollapseH(')
-    expect(code).not.toContain('__rsCollapseDyn(')
-  })
-
-  it('PARTIAL on*-handler path byte-unchanged: literal site + handler emits __rsCollapseH', () => {
-    const key = rocketstyleCollapseKey('Button', { state: 'primary' }, 'Save')
-    const src = 'const x = <Button state="primary" onClick={go}>Save</Button>'
-    const { code } = transformJSX(src, 'I.tsx', collapseOpt(['Button'], { [key]: PRIMARY }))
-    expect(code).toContain('__rsCollapseH(')
-    expect(code).not.toContain('__rsCollapseDyn(')
-  })
-})

package/src/tests/dynamic-collapse-scan.test.ts

@@ -1,111 +0,0 @@
-/**
- * PR 3 of the dynamic-prop partial-collapse build — `scanCollapsibleSites`
- * extension. The plugin-side scan (`@pyreon/vite-plugin`) calls this to
- * learn WHICH (component, props, text) tuples need resolution. For
- * dynamic-prop sites it must expand into TWO `CollapsibleSite` entries
- * (one per literal value) so the resolver pre-renders both via the
- * existing SSR pipeline AND the compiler emit (PR 3 `tryDynamicCollapse`)
- * looks up both via identical key construction.
- *
- * Key invariant: the keys this scan emits must EQUAL the keys
- * `tryDynamicCollapse` computes from the same JSX — same load-bearing
- * separation as the existing full / on*-handler scan↔emit invariants
- * (`scanCollapsibleSites` ↔ `detectCollapsibleShape`).
- */
-import { describe, expect, it } from 'vitest'
-import { rocketstyleCollapseKey, scanCollapsibleSites } from '../jsx'
-
-const COLLAPSIBLE = new Set(['@pyreon/ui-components'])
-
-describe('scanCollapsibleSites — dynamic-prop expansion (PR 3)', () => {
-  it('expands a single ternary site into TWO CollapsibleSite entries (one per literal)', () => {
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const x = <Button state={cond ? "primary" : "secondary"} size="medium">Save</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'A.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(2)
-    const byState = new Map(sites.map((s) => [s.props.state, s]))
-    expect(byState.get('primary')!.props).toEqual({ state: 'primary', size: 'medium' })
-    expect(byState.get('secondary')!.props).toEqual({ state: 'secondary', size: 'medium' })
-    expect(byState.get('primary')!.childrenText).toBe('Save')
-    expect(byState.get('secondary')!.childrenText).toBe('Save')
-    // Both entries share the same component / source / importedName —
-    // only `props.state` differs.
-    expect(byState.get('primary')!.componentName).toBe('Button')
-    expect(byState.get('secondary')!.componentName).toBe('Button')
-  })
-
-  it('emits keys IDENTICAL to what tryDynamicCollapse will look up', () => {
-    // The cross-detector invariant: the scan and the emit MUST agree
-    // on the key for each expanded value. Drift would cause the emit
-    // to miss its own pre-resolved sites and bail to normal mount.
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const x = <Button state={c ? "primary" : "secondary"}>Go</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'B.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(2)
-    const truthyKey = rocketstyleCollapseKey('Button', { state: 'primary' }, 'Go')
-    const falsyKey = rocketstyleCollapseKey('Button', { state: 'secondary' }, 'Go')
-    const keys = sites.map((s) => s.key).sort()
-    expect(keys).toEqual([truthyKey, falsyKey].sort())
-  })
-
-  it('EXPANDS handler-combined dynamic sites too (handler-combined emit unlocks the 15.4% bucket)', () => {
-    // The follow-up emit (`__rsCollapseDynH` from `tryDynamicCollapse`)
-    // handles ternary-plus-handler sites via the combined runtime
-    // helper. The scan emits both literal-value expansions identically
-    // — handlers don't affect the resolver's input (componentName,
-    // props, childrenText). Handlers are re-attached by the runtime
-    // helper, not by the resolver.
-    //
-    // Previously the scan SKIPPED handler-combined sites (matching
-    // the PR 3 emit's no-handler scope); the follow-up lifts that
-    // restriction so the resolver pre-renders both values for
-    // handler-bearing sites too.
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const x = <Button state={c ? "primary" : "secondary"} onClick={go}>H</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'C.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(2)
-    const byState = new Map(sites.map((s) => [s.props.state, s]))
-    expect(byState.get('primary')!.childrenText).toBe('H')
-    expect(byState.get('secondary')!.childrenText).toBe('H')
-  })
-
-  it('does not double-emit when the FULL detector already claims the site (literal-only)', () => {
-    // A fully-literal site is the FULL-collapse shape — claimed by
-    // detectCollapsibleShape; the dynamic-fallthrough branch in the
-    // scan only runs when the full detector returned null.
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const x = <Button state="primary" size="medium">Save</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'D.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(1)
-    expect(sites[0]!.props).toEqual({ state: 'primary', size: 'medium' })
-  })
-
-  it('emits 4 entries for a module with 2 ternary sites (no dedupe across distinct sites)', () => {
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const a = <Button state={c1 ? "primary" : "secondary"}>A</Button>
-      const b = <Button state={c2 ? "danger" : "success"}>B</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'E.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(4)
-    const states = sites.map((s) => `${s.props.state}/${s.childrenText}`).sort()
-    expect(states).toEqual(['danger/B', 'primary/A', 'secondary/A', 'success/B'])
-  })
-
-  it('skips multi-ternary site entirely (separable scope, not this PR)', () => {
-    const src = `
-      import { Button } from '@pyreon/ui-components'
-      const x = <Button state={a ? "x" : "y"} size={b ? "small" : "large"}>S</Button>
-    `
-    const sites = scanCollapsibleSites(src, 'F.tsx', COLLAPSIBLE)
-    expect(sites).toHaveLength(0)
-  })
-})

package/src/tests/element-valued-const-child.test.ts

@@ -1,61 +0,0 @@
-/**
- * Compiler hardening — Round 9 (REAL bug, FIXED + bisect-verified).
- *
- *   const header = <h1>T</h1>
- *   return <div>{header}<p>x</p></div>
- *
- * Pre-fix the compiler lowered the const to `_tpl(...)` (so it KNEW `header`
- * was a `NativeItem` element) yet still emitted
- * `document.createTextNode(header)` for the `{header}` child — `createTextNode`
- * string-coerces the NativeItem → "[object Object]" instead of the `<h1>`.
- * Only `props.children` / `own.children` reached the correct `_mountSlot`.
- *
- * Fix (jsx.ts): an `elementVars` set tracks `const`/`let` bindings whose
- * initializer is a JSX element/fragment (optionally parenthesized); a bare
- * `{el}` child of such a binding routes through `_mountSlot` — the same
- * general child-insert `props.children` uses. Tight by construction: only a
- * DIRECT JSX initializer reclassifies, so string/number/prop-derived/inline-
- * hoisted children keep their existing (correct) paths. Routing is safe even
- * under later same-name shadowing — `_mountSlot` renders strings/numbers
- * correctly too; the only cost of imprecision is skipping the text fast path.
- *
- * NOT contradicted by `jsx.test.ts:777` `createTextNode(label)` — that pins
- * the FREE undeclared identifier default (genuinely ambiguous); this fix only
- * fires when the binding's initializer is provably JSX.
- *
- * Bisect: revert the `isElementValuedIdent` clause in `processOneChild`
- * (jsx.ts) → the CONTRACT specs fail (emit reverts to `createTextNode(header)`)
- * while every CONTROL spec stays green (proving the fix doesn't touch the
- * text/reactive fast paths). Restore → all pass.
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
-const ELEMENT_CONST = `function C(){ const header = <h1>T</h1>; return <div>{header}<p>x</p></div> }`
-
-describe('Round 9 — element-valued const used as a bare JSX child', () => {
-  it('CONTROL: string/number const child still uses the correct text fast path', () => {
-    expect(emit(`function C(){ const t = 'T'; return <div>{t}<p>x</p></div> }`)).toContain('createTextNode(t)')
-    expect(emit(`function C(){ const n = 5; return <div>{n}</div> }`)).toContain('textContent = n')
-  })
-
-  it('CONTROL: an INLINE element child is correctly hoisted (not text-coerced)', () => {
-    const out = emit(`function C(){ return <div>{<h1>T</h1>}<p>x</p></div> }`)
-    expect(out).toMatch(/const _\$h\d+ =/)
-    expect(out).not.toMatch(/createTextNode\(_\$h\d+\)/)
-  })
-
-  it('CONTRACT: element-valued const child is mounted via _mountSlot, not text-coerced', () => {
-    const out = emit(ELEMENT_CONST)
-    expect(out).toContain('const header = _tpl("<h1>T</h1>"')
-    expect(out).not.toContain('createTextNode(header)')
-    expect(out).toMatch(/_mountSlot\(\s*header\b/)
-  })
-
-  it('CONTRACT: single bare element-const child, parenthesized init, and let all mount', () => {
-    expect(emit(`function C(){ const el = <span>hi</span>; return <div>{el}</div> }`)).toMatch(/_mountSlot\(\s*el\b/)
-    expect(emit(`function C(){ const el = (<b>x</b>); return <div>{el}</div> }`)).toMatch(/_mountSlot\(\s*el\b/)
-    expect(emit(`function C(){ let el = <a/>; return <div>{el}</div> }`)).toMatch(/_mountSlot\(\s*el\b/)
-  })
-})

package/src/tests/falsy-child-characterization.test.ts

@@ -1,48 +0,0 @@
-/**
- * Compiler hardening — Round 3 (characterization, NOT a bug fix).
- *
- * Investigated: how the JSX transform emits falsy / boolean / null literal
- * children vs the JSX rendering contract (`true`/`false`/`null`/`undefined`
- * render nothing; `0` renders "0"; `''` renders empty).
- *
- * Finding: the patterns real code actually writes are CORRECT — a conditional
- * (`{c ? x : null}`) or short-circuit (`{c && <X/>}`) child is wrapped in a
- * `() =>` accessor and the null/boolean is filtered by runtime `mountChild`,
- * so nothing renders (Pyreon's documented `VNodeChildAtom` `&&` contract
- * holds). Only a CONTRIVED bare literal child (`<div>{false}</div>` — never
- * written in practice) takes the static path and emits `textContent = false`
- * → the DOM stringifies to "false". This is a spec divergence on input no one
- * writes; fixing it would touch the hot child-emission path for zero
- * real-world benefit, so the behavior is pinned here instead (any future
- * change to it must be deliberate, and this test will flag it).
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
-
-describe('Round 3 — conditional/short-circuit children are accessor-wrapped (the contract that matters)', () => {
-  it('ternary with a null branch is wrapped in an accessor (runtime filters null)', () => {
-    const out = emit(`function C(p){ return <div>{p.cond ? <a/> : null}</div> }`)
-    expect(out).toContain('() => p.cond ? <a/> : null')
-    expect(out).not.toContain('createTextNode(null)')
-  })
-
-  it('&& short-circuit is wrapped in an accessor (the documented && pattern)', () => {
-    const out = emit(`function C(p){ return <div>{p.show && <b/>}</div> }`)
-    expect(out).toContain('() => p.show && <b/>')
-    expect(out).not.toContain('createTextNode(false)')
-  })
-})
-
-describe('Round 3 — bare literal falsy children: pinned current behavior (contrived input)', () => {
-  it('numeric 0 child renders "0" (JSX-correct)', () => {
-    expect(emit(`function C(){ return <div>{0}</div> }`)).toContain('__root.textContent = 0')
-  })
-
-  // Pinned divergence: a bare `{false}` literal stringifies via textContent.
-  // Documented, not fixed — see file header for the rationale.
-  it('bare {false} literal takes the static textContent path (known, contrived)', () => {
-    expect(emit(`function C(){ return <div>{false}</div> }`)).toContain('__root.textContent = false')
-  })
-})