@pyreon/compiler 0.24.5 → 0.24.6

package/src/tests/runtime/signals.test.ts

@@ -1,129 +0,0 @@
-// @vitest-environment happy-dom
-/// <reference lib="dom" />
-import { computed, signal } from '@pyreon/reactivity'
-import { describe, expect, it } from 'vitest'
-import { flush } from '@pyreon/test-utils/browser'
-import { compileAndMount } from './harness'
-
-/**
- * Compiler-runtime tests — signal patterns in JSX.
- *
- * The #352 signal-method auto-call bug surfaced because the compiler
- * couldn't tell `signal.set(x)` (call on the signal as object) from
- * `signal()` (call the signal to read). The fix added scope-aware
- * detection. This file pins down the matrix: bare reference, function
- * call, member call, accessor wrapper, computed — in different positions.
- */
-
-describe('compiler-runtime — signals', () => {
-  it('signal in text position is reactive', async () => {
-    const name = signal('alice')
-    const { container, unmount } = compileAndMount(
-      `<div><span id="s">{name()}</span></div>`,
-      { name },
-    )
-    expect(container.querySelector('#s')!.textContent).toBe('alice')
-    name.set('bob')
-    await flush()
-    expect(container.querySelector('#s')!.textContent).toBe('bob')
-    unmount()
-  })
-
-  it('signal.method() in event handler does not auto-call signal', () => {
-    const x = signal(0)
-    const { container, unmount } = compileAndMount(
-      `<div><button id="b" onClick={() => x.set(99)}>set</button></div>`,
-      { x },
-    )
-    container.querySelector<HTMLButtonElement>('#b')!.click()
-    expect(x()).toBe(99)
-    unmount()
-  })
-
-  it('signal.update() in event handler does not auto-call signal', () => {
-    const x = signal(10)
-    const { container, unmount } = compileAndMount(
-      `<div><button id="b" onClick={() => x.update((v) => v * 2)}>x2</button></div>`,
-      { x },
-    )
-    const btn = container.querySelector<HTMLButtonElement>('#b')!
-    btn.click()
-    btn.click()
-    expect(x()).toBe(40)
-    unmount()
-  })
-
-  it('signal.peek() in event handler does not auto-call signal', () => {
-    const x = signal(7)
-    const out = { value: 0 }
-    const { container, unmount } = compileAndMount(
-      `<div><button id="b" onClick={() => { out.value = x.peek() }}>read</button></div>`,
-      { x, out },
-    )
-    container.querySelector<HTMLButtonElement>('#b')!.click()
-    expect(out.value).toBe(7)
-    unmount()
-  })
-
-  it('computed value reflected in DOM updates when source changes', async () => {
-    const a = signal(2)
-    const b = signal(3)
-    const sum = computed(() => a() + b())
-    const { container, unmount } = compileAndMount(
-      `<div><span id="s">{sum()}</span></div>`,
-      { sum },
-    )
-    expect(container.querySelector('#s')!.textContent).toBe('5')
-    a.set(10)
-    await flush()
-    expect(container.querySelector('#s')!.textContent).toBe('13')
-    unmount()
-  })
-
-  it('explicit accessor wrapper preserves reactivity', async () => {
-    const x = signal('hi')
-    const { container, unmount } = compileAndMount(
-      `<div><span id="s">{() => x()}</span></div>`,
-      { x },
-    )
-    expect(container.querySelector('#s')!.textContent).toBe('hi')
-    x.set('hey')
-    await flush()
-    expect(container.querySelector('#s')!.textContent).toBe('hey')
-    unmount()
-  })
-
-  it('signal in attribute position is reactive', async () => {
-    const cls = signal('a')
-    const { container, unmount } = compileAndMount(
-      `<div><span id="s" class={cls()}>x</span></div>`,
-      { cls },
-    )
-    expect(container.querySelector('#s')!.className).toBe('a')
-    cls.set('b')
-    await flush()
-    expect(container.querySelector('#s')!.className).toBe('b')
-    unmount()
-  })
-
-  it('multiple signals on the same element track independently', async () => {
-    const txt = signal('hello')
-    const cls = signal('a')
-    const { container, unmount } = compileAndMount(
-      `<div><span id="s" class={cls()}>{txt()}</span></div>`,
-      { txt, cls },
-    )
-    const span = container.querySelector('#s')!
-    expect(span.textContent).toBe('hello')
-    expect(span.className).toBe('a')
-    txt.set('world')
-    await flush()
-    expect(span.textContent).toBe('world')
-    expect(span.className).toBe('a')
-    cls.set('b')
-    await flush()
-    expect(span.textContent).toBe('world')
-    expect(span.className).toBe('b')
-    unmount()
-  })
-})

package/src/tests/runtime/whitespace.test.ts

@@ -1,106 +0,0 @@
-// @vitest-environment happy-dom
-/// <reference lib="dom" />
-import { signal } from '@pyreon/reactivity'
-import { describe, expect, it } from 'vitest'
-import { flush } from '@pyreon/test-utils/browser'
-import { compileAndMount } from './harness'
-
-/**
- * Compiler-runtime tests — JSX text/expression whitespace handling.
- *
- * The #352 whitespace bug stripped same-line spaces adjacent to
- * expressions: `<p>doubled: {x}</p>` rendered "doubled:0" instead of
- * "doubled: 0". The fix implements React/Babel's
- * `cleanJSXElementLiteralChild` algorithm. This file pins down the
- * matrix: same-line text±expression, multi-line text, fragments,
- * leading/trailing/internal whitespace.
- */
-
-describe('compiler-runtime — JSX whitespace', () => {
-  it('preserves trailing space before expression on same line', async () => {
-    const x = signal(7)
-    const { container, unmount } = compileAndMount(
-      `<div><p id="p">doubled: {x()}</p></div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent).toBe('doubled: 7')
-    unmount()
-  })
-
-  // Regression: when an expression sits BETWEEN static text segments
-  // on the same line, the compiler used to append the dynamic text
-  // node to the parent's children AFTER all static text via
-  // `appendChild`. Whitespace was preserved correctly (#352), but
-  // positioning was wrong:
-  //   `<p>{x()} remaining</p>` → template `<p> remaining</p>` +
-  //   appended text → renders as " remaining3" instead of "3 remaining".
-  // Fix: extend `analyzeChildren.useMixed` to fire whenever ≥2 of
-  // {element, text, expression} are present (not just element+nonElement).
-  // Then placeholder-based positional mounting puts the dynamic text in
-  // the right slot via `replaceChild`.
-  it('preserves leading space after expression on same line', async () => {
-    const x = signal(3)
-    const { container, unmount } = compileAndMount(
-      `<div><p id="p">{x()} remaining</p></div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent).toBe('3 remaining')
-    unmount()
-  })
-
-  it('preserves spaces on BOTH sides of expression', async () => {
-    const x = signal('cat')
-    const { container, unmount } = compileAndMount(
-      `<div><p id="p">a {x()} b</p></div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent).toBe('a cat b')
-    unmount()
-  })
-
-  it('multi-line JSX with indentation collapses correctly', async () => {
-    const x = signal('inner')
-    // Multi-line JSX expression. Whitespace inside the JSX literal between
-    // <p> and {x()} is treated by React/Babel cleanJSX as "indentation"
-    // and collapses; same for between {x()} and </p>.
-    const { container, unmount } = compileAndMount(
-      `<div>
-        <p id="p">
-          {x()}
-        </p>
-      </div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent?.trim()).toBe('inner')
-    unmount()
-  })
-
-  it('reactive text updates without losing surrounding whitespace', async () => {
-    const x = signal(0)
-    const { container, unmount } = compileAndMount(
-      `<div><p id="p">count: {x()} items</p></div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent).toBe('count: 0 items')
-    x.set(42)
-    await flush()
-    expect(container.querySelector('#p')!.textContent).toBe('count: 42 items')
-    unmount()
-  })
-
-  it('reactive text at end of paragraph updates correctly', async () => {
-    // The expression-at-END shape works because the dynamic text node is
-    // appended to the parent — which happens to match the source order
-    // when there's no text after.
-    const x = signal(0)
-    const { container, unmount } = compileAndMount(
-      `<div><p id="p">count: {x()}</p></div>`,
-      { x },
-    )
-    expect(container.querySelector('#p')!.textContent).toBe('count: 0')
-    x.set(42)
-    await flush()
-    expect(container.querySelector('#p')!.textContent).toBe('count: 42')
-    unmount()
-  })
-})

package/src/tests/signal-autocall-shadow.test.ts

@@ -1,86 +0,0 @@
-/**
- * Compiler hardening — Round 11 (REAL bug, FIXED + bisect-verified).
- *
- * The signal-auto-call rewrite (`autoCallSignals` → `findSignalIdents`,
- * jsx.ts) inserts `()` after every active-signal-named identifier. Its
- * skip-list handled MemberExpr / VarDeclarator / Property-key|shorthand but
- * NOT callback parameter binding positions, and `findSignalIdents` did its
- * OWN scope-blind recursive walk over the wrapped expression. So a
- * destructured/plain callback param reusing a signal's name was wrongly
- * auto-called:
- *
- *   const x = signal(0)
- *   <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul>
- *     →  …map(({x}) => <li>{x()}</li>)   // x is the map item (1) → 1()
- *                                        // → runtime TypeError
- *
- * Trigger: an inline object/array literal in the expr whose property name
- * collides with a signal makes `referencesSignalVar` fire, invoking the
- * scope-blind `autoCallSignals` over the whole expression. This is the exact
- * signal twin of R2's prop-derived scope-blind inlining.
- *
- * Fix: `findSignalIdents` is now block-accurate scope-aware (mirrors R2's
- * `findIdents`): a `scopeBoundSignals(node)` collects signal-named bindings a
- * scope introduces (params incl. nested/destructured patterns, nested const,
- * catch/loop vars), threaded through a `shadowed` set with enter/leave so a
- * shadowed name is never auto-called. Legitimate (non-shadowed) signal reads
- * still auto-call — proven by the CONTROL specs.
- *
- * Bisect: drop `&& !shadowed.has(node.name)` from the `findSignalIdents`
- * active-signal guard → the SHADOW specs fail (emit `{x()}` / `id()`); the
- * CONTROL specs stay green (no over-suppression). Restore → all pass.
- */
-import { parseSync } from 'oxc-parser'
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
-const parses = (o: string): boolean => {
-  try {
-    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
-  } catch {
-    return false
-  }
-}
-
-describe('Round 11 — signal auto-call respects lexical shadowing', () => {
-  it('destructured-shorthand callback param shadowing a signal is NOT auto-called', () => {
-    const out = emit(`function C(){ const x = signal(0); return <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul> }`)
-    expect(parses(out)).toBe(true)
-    expect(out).not.toContain('{x()}')
-    expect(out).toContain('({x}) => <li>{x}</li>')
-  })
-
-  it('destructured param shadowing a signal in a filter predicate is NOT auto-called', () => {
-    const out = emit(`function C(){ const id = signal(0); return <ul>{[{id:1}].filter(({id}) => id > 0).map(r => <li>{r}</li>)}</ul> }`)
-    expect(parses(out)).toBe(true)
-    expect(out).not.toMatch(/\(\{id\}\) => id\(\)/)
-  })
-
-  it('renamed destructured value param shadowing a signal is NOT auto-called', () => {
-    const out = emit(`function C(){ const v = signal(0); return <ul>{[{k:1}].map(({k: v}) => <li>{v}</li>)}</ul> }`)
-    expect(out).not.toContain('{v()}')
-  })
-
-  it('plain callback param shadowing a signal is NOT auto-called', () => {
-    const out = emit(`function C(){ const s = signal(0); return <ul>{[1].map(s => <li>{s}</li>)}</ul> }`)
-    expect(out).not.toContain('{s()}')
-  })
-
-  // ── CONTROL: legitimate signal reads MUST still auto-call ──
-  it('CONTROL: a direct non-shadowed signal child still auto-calls', () => {
-    expect(emit(`function C(){ const s = signal(0); return <div>{s}</div> }`)).toContain('__t0.data = s()')
-  })
-
-  it('CONTROL: a non-shadowed signal SIBLING of a shadowing callback still auto-calls', () => {
-    const out = emit(`function C(){ const s = signal(0); return <div>{[1].map(s => <i>{s}</i>)}<b>{s}</b></div> }`)
-    expect(out).not.toContain('<i>{s()}</i>') // the shadowing param — not called
-    expect(out).toContain('__t0.data = s()') // the real signal sibling — called
-  })
-
-  it('CONTROL: signal.set in a handler is not auto-called but its arg is', () => {
-    const out = emit(`function C(){ const s = signal(0); return <button onClick={() => s.set(s() + 1)}>{s}</button> }`)
-    expect(out).toContain('s.set(s() + 1)')
-    expect(out).toContain('__t0.data = s()')
-  })
-})

package/src/tests/sourcemap-fidelity.test.ts

@@ -1,77 +0,0 @@
-/**
- * Compiler hardening — Round 12 (REAL high-impact gap, FIXED + bisect).
- *
- * Pre-fix: `transformJSX` emitted NO source map and its string-slice
- * substitutions shifted line counts (template emission expands one-line JSX
- * into a multi-line `_tpl(...)` factory). `@pyreon/vite-plugin` returned
- * `{ code, map: null }`, so every runtime stack frame / debugger breakpoint
- * in every Pyreon component mislocated — app-wide, in every project.
- *
- * Fix: `transformJSX_JS` applies its existing disjoint `{start,end,text}`
- * replacement set through MagicString (`update`/`appendLeft`) and the
- * generated preamble via `prepend`. `toString()` is byte-identical to the
- * old concatenation — proven by the full ~1240-test suite + the 180
- * native-equivalence tests, which assert exact emitted strings and all stay
- * green — while `generateMap()` now yields a correct V3 map. `prepend`
- * shifts every mapping by the preamble's line count, so original positions
- * resolve to the correct OUTPUT line despite the line-shift.
- *
- * Bisect: revert the MagicString block to the slice/join + chained-prepend
- * assembly → `map` is `undefined` and these specs fail; restore → pass. The
- * byte-identical guarantee is itself bisect-covered by the rest of the suite
- * (any drift fails an exact-string assertion somewhere).
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-// Edit-correctness oracle is the rest of the compiler suite: the full
-// ~1240-test + 180 native-equivalence corpus asserts EXACT emitted strings,
-// so any byte drift from the MagicString assembly fails there. Map *math*
-// (segment offsets through `update`/`appendLeft`/`prepend`) is magic-string's
-// — the battle-tested generator vite/rollup/svelte rely on; not re-derived
-// here. These specs assert the gap is closed (a valid, content-embedded V3
-// map is produced and serializes for Vite) and the no-op contract.
-
-const MULTILINE = `function C(props) {
-  return (
-    <section>
-      <h1>{props.title}</h1>
-      <p>{props.body}</p>
-    </section>
-  )
-}`
-
-describe('Round 12 — sourcemap fidelity (fixed)', () => {
-  it('a transforming compile now produces a V3 source map', () => {
-    const r = transformJSX_JS(MULTILINE, 'C.tsx')
-    expect(r.map).toBeDefined()
-    expect(r.map!.version).toBe(3)
-    expect(r.map!.sources).toContain('C.tsx')
-    expect(r.map!.mappings.length).toBeGreaterThan(0)
-  })
-
-  it('the map embeds original content and is JSON/`toString`-serializable for Vite', () => {
-    const r = transformJSX_JS(MULTILINE, 'C.tsx')
-    expect(r.map!.sourcesContent?.[0]).toBe(MULTILINE)
-    const json = JSON.parse(r.map!.toString())
-    expect(json.version).toBe(3)
-    expect(json.mappings).toBe(r.map!.mappings)
-  })
-
-  it('output still line-shifts — but the map now accounts for it (the whole point)', () => {
-    const r = transformJSX_JS(MULTILINE, 'C.tsx')
-    // Template emission still expands lines (unchanged codegen)…
-    expect(r.code.split('\n').length).toBeGreaterThan(MULTILINE.split('\n').length)
-    // …and the segment mappings are non-trivial (multi-segment, i.e. the
-    // preamble + per-replacement remapping is recorded, not an empty/identity
-    // map that would silently mislocate like before).
-    expect(r.map!.mappings).toMatch(/[;,]/)
-    expect(r.map!.names).toBeInstanceOf(Array)
-  })
-
-  it('a no-op compile (nothing to transform) returns no map (code is unchanged)', () => {
-    const r = transformJSX_JS(`const x = 1`, 'plain.ts')
-    expect(r.map).toBeUndefined()
-    expect(r.code).toBe(`const x = 1`)
-  })
-})