@pyreon/core 0.24.4 → 0.24.6

package/src/tests/compat-marker.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isNativeCompat, NATIVE_COMPAT_MARKER, nativeCompat } from '../compat-marker'
-
-describe('NATIVE_COMPAT_MARKER', () => {
-  it('is the same registry symbol regardless of how it is referenced', () => {
-    // Symbol.for(...) registry contract — every consumer that uses the same
-    // string key (compat layers reading it, framework packages writing it)
-    // gets the SAME symbol identity. Changing the string is a breaking
-    // change to the marker contract.
-    expect(NATIVE_COMPAT_MARKER).toBe(Symbol.for('pyreon:native-compat'))
-  })
-
-  it('is a `symbol`-typed value', () => {
-    expect(typeof NATIVE_COMPAT_MARKER).toBe('symbol')
-  })
-})
-
-describe('nativeCompat', () => {
-  it('attaches the marker to a function and returns the same reference', () => {
-    function RouterView() {
-      return null
-    }
-    const marked = nativeCompat(RouterView)
-    expect(marked).toBe(RouterView)
-    expect((RouterView as unknown as Record<symbol, boolean>)[NATIVE_COMPAT_MARKER]).toBe(true)
-  })
-
-  it('is idempotent — applying twice yields the same property state', () => {
-    const Component = () => null
-    nativeCompat(Component)
-    nativeCompat(Component)
-    expect((Component as unknown as Record<symbol, boolean>)[NATIVE_COMPAT_MARKER]).toBe(true)
-  })
-
-  it('passes non-function values through unchanged', () => {
-    // Defensive: callers may pipe variables of unknown shape (e.g. lazy
-    // imports that resolve to objects, or null during HMR boundary
-    // teardown). The helper must be safe regardless.
-    expect(nativeCompat(null as unknown)).toBe(null)
-    expect(nativeCompat(undefined as unknown)).toBe(undefined)
-    const obj = { foo: 'bar' }
-    expect(nativeCompat(obj)).toBe(obj)
-    expect((obj as unknown as Record<symbol, boolean>)[NATIVE_COMPAT_MARKER]).toBeUndefined()
-  })
-
-  it('preserves the function signature for typed callers', () => {
-    // The generic `T` flows through unchanged so framework component
-    // exports keep their typed callable shape after wrapping.
-    const Typed = (props: { name: string }): string => `hello ${props.name}`
-    const marked: typeof Typed = nativeCompat(Typed)
-    expect(marked({ name: 'world' })).toBe('hello world')
-  })
-})
-
-describe('isNativeCompat', () => {
-  it('returns true for a marked function', () => {
-    const Comp = nativeCompat(() => null)
-    expect(isNativeCompat(Comp)).toBe(true)
-  })
-
-  it('returns false for an unmarked function', () => {
-    expect(isNativeCompat(() => null)).toBe(false)
-  })
-
-  it('returns false for non-function inputs', () => {
-    expect(isNativeCompat(null)).toBe(false)
-    expect(isNativeCompat(undefined)).toBe(false)
-    expect(isNativeCompat('string')).toBe(false)
-    expect(isNativeCompat(42)).toBe(false)
-    expect(isNativeCompat({ [NATIVE_COMPAT_MARKER]: true })).toBe(false)
-  })
-
-  it('returns false when the marker is set to a non-true value', () => {
-    // Defensive against accidental shape mismatch — only `=== true` qualifies.
-    function Comp() {
-      return null
-    }
-    ;(Comp as unknown as Record<symbol, unknown>)[NATIVE_COMPAT_MARKER] = 1
-    expect(isNativeCompat(Comp)).toBe(false)
-    ;(Comp as unknown as Record<symbol, unknown>)[NATIVE_COMPAT_MARKER] = 'yes'
-    expect(isNativeCompat(Comp)).toBe(false)
-  })
-
-  it('reads the same registry symbol that nativeCompat writes', () => {
-    // Cross-side contract: a function marked here is detectable by
-    // someone who looked up the symbol via `Symbol.for('pyreon:native-compat')`
-    // independently — without importing NATIVE_COMPAT_MARKER from this module.
-    const Comp = nativeCompat(function Comp() {
-      return null
-    })
-    const externallyDiscoveredSymbol = Symbol.for('pyreon:native-compat')
-    expect(
-      (Comp as unknown as Record<symbol, boolean>)[externallyDiscoveredSymbol],
-    ).toBe(true)
-  })
-})

package/src/tests/compat-shared.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { mapCompatDomProps, shallowEqualProps } from '../compat-shared'
-
-describe('shallowEqualProps', () => {
-  it('equal for same-key same-value objects', () => {
-    expect(shallowEqualProps({ a: 1, b: 'x' }, { a: 1, b: 'x' })).toBe(true)
-  })
-
-  it('not equal when a value differs', () => {
-    expect(shallowEqualProps({ a: 1 }, { a: 2 })).toBe(false)
-  })
-
-  it('not equal when key counts differ', () => {
-    expect(shallowEqualProps({ a: 1 }, { a: 1, b: 2 })).toBe(false)
-  })
-
-  it('uses Object.is semantics (NaN equal, ±0 distinct)', () => {
-    expect(shallowEqualProps({ n: NaN }, { n: NaN })).toBe(true)
-    expect(shallowEqualProps({ z: 0 }, { z: -0 })).toBe(false)
-  })
-
-  it('empty objects are equal', () => {
-    expect(shallowEqualProps({}, {})).toBe(true)
-  })
-})
-
-describe('mapCompatDomProps', () => {
-  it('no-op for component (non-string) type', () => {
-    const Comp = () => null
-    const p: Record<string, unknown> = { className: 'x', htmlFor: 'y' }
-    mapCompatDomProps(p, Comp)
-    expect(p).toEqual({ className: 'x', htmlFor: 'y' })
-  })
-
-  it('className → class, htmlFor → for', () => {
-    const p: Record<string, unknown> = { className: 'btn', htmlFor: 'email' }
-    mapCompatDomProps(p, 'label')
-    expect(p).toEqual({ class: 'btn', for: 'email' })
-  })
-
-  it('onChange → onInput on input/textarea/select', () => {
-    for (const tag of ['input', 'textarea', 'select']) {
-      const fn = () => {}
-      const p: Record<string, unknown> = { onChange: fn }
-      mapCompatDomProps(p, tag)
-      expect(p).toEqual({ onInput: fn })
-    }
-  })
-
-  it('onChange does not clobber an explicit onInput', () => {
-    const onChange = () => {}
-    const onInput = () => {}
-    const p: Record<string, unknown> = { onChange, onInput }
-    mapCompatDomProps(p, 'input')
-    expect(p).toEqual({ onInput })
-  })
-
-  it('onChange left alone on non-form elements', () => {
-    const onChange = () => {}
-    const p: Record<string, unknown> = { onChange }
-    mapCompatDomProps(p, 'div')
-    expect(p).toEqual({ onChange })
-  })
-
-  it('autoFocus → autofocus', () => {
-    const p: Record<string, unknown> = { autoFocus: true }
-    mapCompatDomProps(p, 'input')
-    expect(p).toEqual({ autofocus: true })
-  })
-
-  it('defaultValue/defaultChecked → value/checked only when uncontrolled', () => {
-    const a: Record<string, unknown> = { defaultValue: 'd', defaultChecked: true }
-    mapCompatDomProps(a, 'input')
-    expect(a).toEqual({ value: 'd', checked: true })
-
-    const b: Record<string, unknown> = {
-      defaultValue: 'd',
-      value: 'controlled',
-      defaultChecked: true,
-      checked: false,
-    }
-    mapCompatDomProps(b, 'input')
-    expect(b).toEqual({
-      defaultValue: 'd',
-      value: 'controlled',
-      defaultChecked: true,
-      checked: false,
-    })
-  })
-
-  it('strips authoring-only props with no DOM equivalent', () => {
-    const p: Record<string, unknown> = {
-      suppressHydrationWarning: true,
-      suppressContentEditableWarning: true,
-    }
-    mapCompatDomProps(p, 'div')
-    expect(p).toEqual({})
-  })
-})

package/src/tests/component.test.ts

@@ -1,281 +0,0 @@
-import {
-  defineComponent,
-  dispatchToErrorBoundary,
-  popErrorBoundary,
-  propagateError,
-  pushErrorBoundary,
-  runWithHooks,
-} from '../component'
-import { h } from '../h'
-import { onErrorCaptured, onMount, onUnmount, onUpdate } from '../lifecycle'
-import type { ComponentFn, LifecycleHooks, VNode } from '../types'
-
-describe('defineComponent', () => {
-  test('returns the exact same function (identity)', () => {
-    const fn: ComponentFn = () => h('div', null)
-    expect(defineComponent(fn)).toBe(fn)
-  })
-
-  test('preserves typed props', () => {
-    const Comp = defineComponent<{ count: number }>((props) => {
-      return h('span', null, String(props.count))
-    })
-    const node = Comp({ count: 10 })
-    expect((node as VNode).type).toBe('span')
-  })
-})
-
-describe('runWithHooks', () => {
-  test('captures all lifecycle hook types', () => {
-    const mountFn = () => undefined
-    const unmountFn = () => {}
-    const updateFn = () => {}
-    const errorFn = () => true
-
-    const Comp: ComponentFn = () => {
-      onMount(mountFn)
-      onUnmount(unmountFn)
-      onUpdate(updateFn)
-      onErrorCaptured(errorFn)
-      return h('div', null)
-    }
-
-    const { vnode, hooks } = runWithHooks(Comp, {})
-    expect(vnode).not.toBeNull()
-    expect(hooks.mount).toContain(mountFn)
-    expect(hooks.unmount).toContain(unmountFn)
-    expect(hooks.update).toContain(updateFn)
-    expect(hooks.error).toContain(errorFn)
-  })
-
-  test('returns null vnode for component returning null', () => {
-    const { vnode } = runWithHooks(() => null, {})
-    expect(vnode).toBeNull()
-  })
-
-  test('returns string vnode for component returning string', () => {
-    const { vnode } = runWithHooks(() => 'hello', {})
-    expect(vnode).toBe('hello')
-  })
-
-  test('clears hooks context after execution', () => {
-    const Comp: ComponentFn = () => h('div', null)
-    runWithHooks(Comp, {})
-    // After runWithHooks, lifecycle hooks should be no-ops
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    onMount(() => {})
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  test('clears hooks context even when component throws', () => {
-    const Comp: ComponentFn = () => {
-      throw new Error('boom')
-    }
-    expect(() => runWithHooks(Comp, {})).toThrow('boom')
-    // Should still be cleared
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    onMount(() => {})
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  test('passes props to component function', () => {
-    let received: unknown = null
-    runWithHooks(
-      ((props: { msg: string }) => {
-        received = props
-        return null
-      }) as ComponentFn,
-      { msg: 'hello' },
-    )
-    expect(received).toEqual({ msg: 'hello' })
-  })
-
-  test('captures multiple hooks of same type', () => {
-    const Comp: ComponentFn = () => {
-      onMount(() => undefined)
-      onMount(() => undefined)
-      onUnmount(() => {})
-      onUnmount(() => {})
-      return null
-    }
-    const { hooks } = runWithHooks(Comp, {})
-    expect(hooks.mount).toHaveLength(2)
-    expect(hooks.unmount).toHaveLength(2)
-  })
-
-  test('null hooks when component registers none (lazy allocation)', () => {
-    const { hooks } = runWithHooks(() => h('div', null), {})
-    expect(hooks.mount).toBeNull()
-    expect(hooks.unmount).toBeNull()
-    expect(hooks.update).toBeNull()
-    expect(hooks.error).toBeNull()
-  })
-})
-
-describe('propagateError', () => {
-  test('returns true when handler returns true', () => {
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [() => true],
-    }
-    expect(propagateError(new Error('test'), hooks)).toBe(true)
-  })
-
-  test('returns false when no handlers', () => {
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [],
-    }
-    expect(propagateError(new Error('test'), hooks)).toBe(false)
-  })
-
-  test('returns false when handler returns undefined', () => {
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [() => undefined],
-    }
-    expect(propagateError(new Error('test'), hooks)).toBe(false)
-  })
-
-  test('stops at first handler returning true', () => {
-    let secondCalled = false
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [
-        () => true,
-        () => {
-          secondCalled = true
-          return true
-        },
-      ],
-    }
-    expect(propagateError('err', hooks)).toBe(true)
-    expect(secondCalled).toBe(false)
-  })
-
-  test('continues to next handler when first returns undefined', () => {
-    const calls: number[] = []
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [
-        () => {
-          calls.push(1)
-          return undefined
-        },
-        () => {
-          calls.push(2)
-          return true
-        },
-      ],
-    }
-    expect(propagateError('err', hooks)).toBe(true)
-    expect(calls).toEqual([1, 2])
-  })
-
-  test('passes the error to each handler', () => {
-    const errors: unknown[] = []
-    const hooks: LifecycleHooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [
-        (err) => {
-          errors.push(err)
-          return undefined
-        },
-        (err) => {
-          errors.push(err)
-          return true
-        },
-      ],
-    }
-    const testErr = new Error('propagated')
-    propagateError(testErr, hooks)
-    expect(errors).toEqual([testErr, testErr])
-  })
-})
-
-describe('pushErrorBoundary / popErrorBoundary / dispatchToErrorBoundary', () => {
-  afterEach(() => {
-    // Clean up any leftover boundaries — pop until empty
-    // dispatchToErrorBoundary returns false when stack is empty
-    while (dispatchToErrorBoundary('cleanup-probe')) {
-      popErrorBoundary()
-    }
-  })
-
-  test('dispatches to the most recently pushed boundary', () => {
-    let caught: unknown = null
-    pushErrorBoundary((err) => {
-      caught = err
-      return true
-    })
-    expect(dispatchToErrorBoundary('test-error')).toBe(true)
-    expect(caught).toBe('test-error')
-    popErrorBoundary()
-  })
-
-  test('returns false when no boundary is registered', () => {
-    expect(dispatchToErrorBoundary('no-boundary')).toBe(false)
-  })
-
-  test('nested boundaries — innermost catches first', () => {
-    const caught: string[] = []
-    pushErrorBoundary((err) => {
-      caught.push(`outer: ${err}`)
-      return true
-    })
-    pushErrorBoundary((err) => {
-      caught.push(`inner: ${err}`)
-      return true
-    })
-    dispatchToErrorBoundary('test')
-    expect(caught).toEqual(['inner: test'])
-    popErrorBoundary()
-
-    // After popping inner, outer should catch
-    dispatchToErrorBoundary('test2')
-    expect(caught).toEqual(['inner: test', 'outer: test2'])
-    popErrorBoundary()
-  })
-
-  test('boundary handler returning false does not propagate to outer', () => {
-    // dispatchToErrorBoundary only calls the innermost handler
-    let outerCalled = false
-    pushErrorBoundary(() => {
-      outerCalled = true
-      return true
-    })
-    pushErrorBoundary(() => false)
-    const result = dispatchToErrorBoundary('test')
-    expect(result).toBe(false)
-    expect(outerCalled).toBe(false) // outer not called — only innermost is checked
-    popErrorBoundary()
-    popErrorBoundary()
-  })
-
-  test('push and pop maintain stack correctly', () => {
-    const results: boolean[] = []
-    pushErrorBoundary(() => true)
-    pushErrorBoundary(() => true)
-    pushErrorBoundary(() => true)
-    popErrorBoundary()
-    popErrorBoundary()
-    results.push(dispatchToErrorBoundary('x'))
-    popErrorBoundary()
-    results.push(dispatchToErrorBoundary('y'))
-    expect(results).toEqual([true, false])
-  })
-})