@pyreon/core 0.24.4 → 0.24.6

package/src/tests/props.test.ts

@@ -1,250 +0,0 @@
-import { createUniqueId, mergeProps, splitProps } from '../props'
-
-describe('splitProps', () => {
-  test('splits known keys from rest', () => {
-    const props = { label: 'Hi', icon: 'star', class: 'btn', id: 'x' }
-    const [own, html] = splitProps(props, ['label', 'icon'])
-    expect(own).toEqual({ label: 'Hi', icon: 'star' })
-    expect(html).toEqual({ class: 'btn', id: 'x' })
-  })
-
-  test('preserves getters', () => {
-    let count = 0
-    const props = Object.defineProperty({} as Record<string, unknown>, 'value', {
-      get: () => ++count,
-      enumerable: true,
-      configurable: true,
-    })
-    const [own] = splitProps(props, ['value'])
-    expect(own.value).toBe(1)
-    expect(own.value).toBe(2) // getter called again
-  })
-
-  test('handles empty keys array', () => {
-    const props = { a: 1, b: 2 }
-    const [own, rest] = splitProps(props, [])
-    expect(own).toEqual({})
-    expect(rest).toEqual({ a: 1, b: 2 })
-  })
-})
-
-describe('mergeProps', () => {
-  test('later sources override earlier', () => {
-    const result = mergeProps({ a: 1, b: 2 }, { b: 3, c: 4 })
-    expect(result).toEqual({ a: 1, b: 3, c: 4 })
-  })
-
-  test("undefined values don't override defined", () => {
-    const result = mergeProps({ size: 'md' }, { size: undefined as string | undefined })
-    expect(result.size).toBe('md')
-  })
-
-  test('preserves getters from sources', () => {
-    let count = 0
-    const source = Object.defineProperty({} as Record<string, unknown>, 'val', {
-      get: () => ++count,
-      enumerable: true,
-      configurable: true,
-    })
-    const result = mergeProps({ val: 0 }, source)
-    expect(result.val).toBe(1)
-    expect(result.val).toBe(2)
-  })
-
-  test('getter returning undefined falls back to previous value', () => {
-    let override: string | undefined
-    const source = Object.defineProperty({} as Record<string, unknown>, 'size', {
-      get: () => override,
-      enumerable: true,
-      configurable: true,
-    })
-    const result = mergeProps({ size: 'md' }, source)
-    expect(result.size).toBe('md') // getter returns undefined, fallback
-
-    override = 'lg'
-    expect(result.size).toBe('lg') // getter returns value
-  })
-})
-
-describe('mergeProps — edge cases', () => {
-  test('mixed getter/static value merging across 3+ sources', () => {
-    let dynamicSize = 'sm'
-    const source1 = { size: 'md', variant: 'primary' }
-    const source2 = Object.defineProperty({} as Record<string, unknown>, 'size', {
-      get: () => dynamicSize,
-      enumerable: true,
-      configurable: true,
-    })
-    const source3 = { color: 'red' }
-    const result = mergeProps(source1, source2, source3)
-    expect(result.size).toBe('sm')
-    dynamicSize = 'xl'
-    expect(result.size).toBe('xl')
-    expect((result as Record<string, unknown>).variant).toBe('primary')
-    expect((result as Record<string, unknown>).color).toBe('red')
-  })
-
-  test('getter returning undefined falling through multiple levels of defaults', () => {
-    let level2: string | undefined
-    let level1: string | undefined
-    const defaults = { theme: 'light' }
-    const mid = Object.defineProperty({} as Record<string, unknown>, 'theme', {
-      get: () => level1,
-      enumerable: true,
-      configurable: true,
-    })
-    const top = Object.defineProperty({} as Record<string, unknown>, 'theme', {
-      get: () => level2,
-      enumerable: true,
-      configurable: true,
-    })
-    const result = mergeProps(defaults, mid, top)
-    // Both getters return undefined — falls back to "light"
-    expect(result.theme).toBe('light')
-    // Mid-level getter returns value — top still undefined, falls to mid
-    level1 = 'dark'
-    expect(result.theme).toBe('dark')
-    // Top-level getter returns value — wins
-    level2 = 'system'
-    expect(result.theme).toBe('system')
-  })
-
-  test('mergeProps with no sources (empty call)', () => {
-    const result = mergeProps()
-    expect(result).toEqual({})
-  })
-
-  test('later source static value overriding earlier getter', () => {
-    const dynamic = 'from-getter'
-    const getterSource = Object.defineProperty({} as Record<string, unknown>, 'val', {
-      get: () => dynamic,
-      enumerable: true,
-      configurable: true,
-    })
-    const staticSource = { val: 'static-wins' }
-    const result = mergeProps(getterSource, staticSource)
-    // Static value should override getter
-    expect(result.val).toBe('static-wins')
-  })
-
-  test('later source static undefined does not override earlier getter', () => {
-    let dynamic = 'from-getter'
-    const getterSource = Object.defineProperty({} as Record<string, unknown>, 'val', {
-      get: () => dynamic,
-      enumerable: true,
-      configurable: true,
-    })
-    const staticSource = { val: undefined }
-    const result = mergeProps(getterSource, staticSource)
-    // Static undefined — getter should still be used
-    expect(result.val).toBe('from-getter')
-    dynamic = 'updated'
-    expect(result.val).toBe('updated')
-  })
-})
-
-describe('splitProps — getter reactivity', () => {
-  test('preserves getter reactivity through multiple reads', () => {
-    let count = 0
-    const props = Object.defineProperty({ other: 'x' } as Record<string, unknown>, 'value', {
-      get: () => ++count,
-      enumerable: true,
-      configurable: true,
-    })
-    const [own, rest] = splitProps(props, ['value'])
-    expect(own.value).toBe(1)
-    expect(own.value).toBe(2)
-    expect(own.value).toBe(3)
-    // rest should not include the getter key
-    expect(rest).toEqual({ other: 'x' })
-  })
-})
-
-describe('mergeProps — non-configurable getter sources (regression)', () => {
-  // Regression: when a source object has a getter defined via
-  // Object.defineProperty without an explicit `configurable: true`,
-  // configurable defaults to false. mergeProps forwarded the descriptor as-is,
-  // so a later source overriding the same key crashed with
-  // "Cannot redefine property". Real-world trigger: defineProperty-based
-  // observables, some test mocks, some Proxy getter wrappers.
-  test('mergeProps handles getters without explicit configurable flag', () => {
-    const a: Record<string, unknown> = {}
-    Object.defineProperty(a, 'x', { get: () => 1, enumerable: true })
-    const b = { x: 2 }
-    expect(() => mergeProps(a, b)).not.toThrow()
-    expect(mergeProps(a, b).x).toBe(2)
-  })
-
-  test('mergeProps result properties are configurable (can be overridden later)', () => {
-    const a: Record<string, unknown> = {}
-    Object.defineProperty(a, 'x', { get: () => 1, enumerable: true })
-    const b = { y: 'b' }
-    const merged = mergeProps(a, b)
-    expect(() =>
-      Object.defineProperty(merged, 'x', { value: 42, enumerable: true, configurable: true }),
-    ).not.toThrow()
-    expect(() =>
-      Object.defineProperty(merged, 'y', { value: 99, enumerable: true, configurable: true }),
-    ).not.toThrow()
-  })
-
-  test('splitProps result properties are configurable (can be overridden later)', () => {
-    const a: Record<string, unknown> = { other: 'x' }
-    Object.defineProperty(a, 'v', { get: () => 1, enumerable: true })
-    const [own, rest] = splitProps(a, ['v'])
-    expect(() =>
-      Object.defineProperty(own, 'v', { value: 42, enumerable: true, configurable: true }),
-    ).not.toThrow()
-    expect(() =>
-      Object.defineProperty(rest, 'other', {
-        value: 'y',
-        enumerable: true,
-        configurable: true,
-      }),
-    ).not.toThrow()
-  })
-})
-
-describe('splitProps / mergeProps — symbol keys (regression)', () => {
-  // Regression: Object.keys silently drops symbol-keyed properties, so any
-  // Symbol.for('pyreon.reactiveProp')-branded prop or user-supplied symbol
-  // key would disappear from both picked and rest. Use Reflect.ownKeys.
-  test('splitProps preserves symbol-keyed properties in rest', () => {
-    const SYM = Symbol('marker')
-    const props = { label: 'x', [SYM]: 'branded' } as Record<string | symbol, unknown>
-    const [own, rest] = splitProps(props as { label: string }, ['label'])
-    expect(own.label).toBe('x')
-    expect((rest as Record<symbol, unknown>)[SYM]).toBe('branded')
-  })
-
-  test('splitProps moves a symbol key to picked when it is named in keys', () => {
-    const SYM = Symbol('marker')
-    const props = { label: 'x', [SYM]: 'branded' } as Record<string | symbol, unknown>
-    const [own, rest] = splitProps(
-      props as { label: string; [SYM]: string },
-      ['label', SYM] as Array<'label' | typeof SYM>,
-    )
-    expect((own as Record<symbol, unknown>)[SYM]).toBe('branded')
-    expect((rest as Record<symbol, unknown>)[SYM]).toBeUndefined()
-  })
-
-  test('mergeProps preserves symbol-keyed properties from every source', () => {
-    const A = Symbol('a')
-    const B = Symbol('b')
-    const src1 = { [A]: 1 } as Record<string | symbol, unknown>
-    const src2 = { [B]: 2 } as Record<string | symbol, unknown>
-    const merged = mergeProps(src1, src2) as Record<string | symbol, unknown>
-    expect(merged[A]).toBe(1)
-    expect(merged[B]).toBe(2)
-  })
-})
-
-describe('createUniqueId', () => {
-  test('returns incrementing IDs', () => {
-    const id1 = createUniqueId()
-    const id2 = createUniqueId()
-    expect(id1).toMatch(/^pyreon-\d+$/)
-    expect(id2).toMatch(/^pyreon-\d+$/)
-    expect(id1).not.toBe(id2)
-  })
-})

package/src/tests/reactive-context.test.ts

@@ -1,69 +0,0 @@
-import { signal } from '@pyreon/reactivity'
-import { runWithHooks } from '../component'
-import { createReactiveContext, popContext, provide, useContext } from '../context'
-
-// Coverage for `createReactiveContext` — previously untested public API.
-describe('createReactiveContext', () => {
-  test('default accessor returns the default value when no provider', () => {
-    const Ctx = createReactiveContext<'light' | 'dark'>('light')
-    const getter = useContext(Ctx)
-    expect(typeof getter).toBe('function')
-    expect(getter()).toBe('light')
-  })
-
-  test('consumer re-reads the latest signal value through the provided accessor', () => {
-    const Ctx = createReactiveContext<'light' | 'dark'>('light')
-    const mode = signal<'light' | 'dark'>('light')
-
-    const seen: Array<'light' | 'dark'> = []
-
-    // provide() registers an onUnmount, so it must run under runWithHooks.
-    const { hooks } = runWithHooks(() => {
-      provide(Ctx, () => mode())
-      const getter = useContext(Ctx)
-      seen.push(getter())
-      mode.set('dark')
-      seen.push(getter())
-      return null
-    }, {})
-
-    expect(seen).toEqual(['light', 'dark'])
-
-    // Unmount the provider — outside the scope, useContext returns the default.
-    for (const fn of hooks.unmount!) fn()
-    const outerGetter = useContext(Ctx)
-    expect(outerGetter()).toBe('light')
-  })
-
-  test('nested providers shadow the outer provider, and the outer is restored after unmount', () => {
-    const Ctx = createReactiveContext<string>('default')
-
-    const outerRun = runWithHooks(() => {
-      provide(Ctx, () => 'outer')
-      const outerGetter = useContext(Ctx)
-      expect(outerGetter()).toBe('outer')
-
-      const innerRun = runWithHooks(() => {
-        provide(Ctx, () => 'inner')
-        const innerGetter = useContext(Ctx)
-        expect(innerGetter()).toBe('inner')
-        return null
-      }, {})
-      // Run the inner provider's unmount to pop its frame.
-      for (const fn of innerRun.hooks.unmount!) fn()
-
-      // Outer provider is restored.
-      expect(outerGetter()).toBe('outer')
-      return null
-    }, {})
-
-    // Clean up outer frame.
-    for (const fn of outerRun.hooks.unmount!) fn()
-
-    // After full teardown, useContext falls back to the default accessor.
-    expect(useContext(Ctx)()).toBe('default')
-
-    // Sanity — popContext on an already-empty stack should not crash.
-    popContext()
-  })
-})

package/src/tests/reactive-props.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { makeReactiveProps, REACTIVE_PROP, _rp, _wrapSpread } from '../props'
-
-describe('makeReactiveProps', () => {
-  it('returns raw object when no reactive props exist (fast path)', () => {
-    const raw = { a: 1, b: 'hello', c: true }
-    const result = makeReactiveProps(raw)
-    // Must return the exact same object reference — no allocation
-    expect(result).toBe(raw)
-  })
-
-  it('returns raw when props contain non-branded functions', () => {
-    const fn = () => 42
-    const raw = { handler: fn, name: 'test' }
-    const result = makeReactiveProps(raw)
-    expect(result).toBe(raw)
-    // Non-branded function is preserved as-is
-    expect(result.handler).toBe(fn)
-  })
-
-  it('converts branded _rp() props to getter properties', () => {
-    let value = 10
-    const accessor = _rp(() => value)
-    const raw = { count: accessor, label: 'hello' }
-    const result = makeReactiveProps(raw)
-
-    // Must NOT be the same object (a new getter-backed object is created)
-    expect(result).not.toBe(raw)
-    // Getter reads the current value
-    expect(result.count).toBe(10)
-    value = 20
-    expect(result.count).toBe(20)
-    // Static props are copied as-is
-    expect(result.label).toBe('hello')
-  })
-
-  it('handles mixed reactive and static props', () => {
-    let x = 'a'
-    const raw = {
-      static1: 42,
-      reactive1: _rp(() => x),
-      static2: true,
-      nonBranded: () => 'plain function',
-    }
-    const result = makeReactiveProps(raw)
-
-    expect(result).not.toBe(raw)
-    expect(result.static1).toBe(42)
-    expect(result.static2).toBe(true)
-    expect(result.reactive1).toBe('a')
-    // Non-branded function is copied as a value, not converted to getter
-    expect(typeof result.nonBranded).toBe('function')
-    expect((result.nonBranded as () => string)()).toBe('plain function')
-
-    x = 'b'
-    expect(result.reactive1).toBe('b')
-  })
-
-  it('reactive prop getters are enumerable and configurable', () => {
-    const raw = { x: _rp(() => 1) }
-    const result = makeReactiveProps(raw)
-    const desc = Object.getOwnPropertyDescriptor(result, 'x')
-    expect(desc?.enumerable).toBe(true)
-    expect(desc?.configurable).toBe(true)
-    expect(typeof desc?.get).toBe('function')
-  })
-
-  it('handles empty props object', () => {
-    const raw = {}
-    const result = makeReactiveProps(raw)
-    expect(result).toBe(raw)
-  })
-})
-
-describe('_rp', () => {
-  it('brands a function with REACTIVE_PROP', () => {
-    const fn = () => 42
-    const branded = _rp(fn)
-    expect(branded).toBe(fn) // same function reference
-    expect((branded as any)[REACTIVE_PROP]).toBe(true)
-  })
-
-  it('branded function still callable', () => {
-    const branded = _rp(() => 'hello')
-    expect(branded()).toBe('hello')
-  })
-})
-
-describe('_wrapSpread', () => {
-  it('returns null/undefined unchanged (primitive guard)', () => {
-    expect(_wrapSpread(null)).toBe(null)
-    expect(_wrapSpread(undefined)).toBe(undefined)
-  })
-
-  it('returns source unchanged when no getter descriptors exist (fast path)', () => {
-    const source = { a: 1, b: 'x', c: true }
-    expect(_wrapSpread(source)).toBe(source)
-  })
-
-  it('returns source unchanged for empty objects', () => {
-    const source = {}
-    expect(_wrapSpread(source)).toBe(source)
-  })
-
-  it('wraps getter-shaped reactive props as _rp-branded thunks', () => {
-    let liveValue = 'a'
-    const source = {} as Record<string, unknown>
-    Object.defineProperty(source, 'x', {
-      get: () => liveValue,
-      enumerable: true,
-      configurable: true,
-    })
-
-    const result = _wrapSpread(source) as Record<string, unknown>
-    expect(result).not.toBe(source) // new object allocated
-
-    const wrappedX = result.x as () => unknown
-    expect(typeof wrappedX).toBe('function')
-    expect((wrappedX as unknown as Record<symbol, unknown>)[REACTIVE_PROP]).toBe(true)
-
-    // Lazy read — each call reads the current source[x] getter value
-    expect(wrappedX()).toBe('a')
-    liveValue = 'b'
-    expect(wrappedX()).toBe('b') // live re-read, not captured
-  })
-
-  it('preserves data properties as-is when mixed with getters', () => {
-    const source = { plain: 'data' } as Record<string, unknown>
-    Object.defineProperty(source, 'reactive', {
-      get: () => 'live',
-      enumerable: true,
-      configurable: true,
-    })
-
-    const result = _wrapSpread(source) as Record<string, unknown>
-    expect(result.plain).toBe('data') // copied through
-    expect(typeof result.reactive).toBe('function') // wrapped as thunk
-  })
-
-  it('preserves Reflect.ownKeys symbol-keyed properties', () => {
-    const sym = Symbol('marker')
-    const source = { regular: 'x' } as Record<string | symbol, unknown>
-    Object.defineProperty(source, 'reactive', {
-      get: () => 'live',
-      enumerable: true,
-      configurable: true,
-    })
-    source[sym] = 'symbol-value'
-
-    const result = _wrapSpread(source) as Record<string | symbol, unknown>
-    expect(result.regular).toBe('x')
-    // Note: symbol keys go through Reflect.ownKeys; the wrap path indexes
-    // via `key as string` for type narrowing but the runtime carries them
-    // forward as data properties.
-    expect(typeof result.reactive).toBe('function')
-  })
-})

package/src/tests/ref.test.ts

@@ -1,70 +0,0 @@
-import type { Ref, RefCallback, RefProp } from '../ref'
-import { createRef } from '../ref'
-
-describe('createRef', () => {
-  test('returns object with current = null', () => {
-    const ref = createRef()
-    expect(ref.current).toBeNull()
-  })
-
-  test('current is mutable', () => {
-    const ref = createRef<number>()
-    ref.current = 42
-    expect(ref.current).toBe(42)
-  })
-
-  test('typed ref — HTMLElement', () => {
-    const ref = createRef<HTMLDivElement>()
-    expect(ref.current).toBeNull()
-    // In real code, runtime-dom sets this after mount
-    ref.current = {} as HTMLDivElement
-    expect(ref.current).not.toBeNull()
-  })
-
-  test('typed ref — string', () => {
-    const ref = createRef<string>()
-    ref.current = 'hello'
-    expect(ref.current).toBe('hello')
-  })
-
-  test('can be reset to null', () => {
-    const ref = createRef<number>()
-    ref.current = 99
-    expect(ref.current).toBe(99)
-    ref.current = null
-    expect(ref.current).toBeNull()
-  })
-
-  test('each createRef returns a unique object', () => {
-    const ref1 = createRef()
-    const ref2 = createRef()
-    expect(ref1).not.toBe(ref2)
-  })
-
-  test('ref object has exactly one property', () => {
-    const ref = createRef()
-    expect(Object.keys(ref)).toEqual(['current'])
-  })
-
-  test('ref object shape matches Ref interface', () => {
-    const ref: Ref<number> = createRef<number>()
-    expect('current' in ref).toBe(true)
-    expect(ref.current).toBeNull()
-  })
-})
-
-describe('RefCallback type (type-level verification)', () => {
-  test('callback ref can be assigned to RefProp', () => {
-    const callback: RefCallback<HTMLElement> = (_el) => {}
-    // Type-level test: RefProp accepts both object ref and callback ref
-    const prop: RefProp<HTMLElement> = callback
-    expect(typeof prop).toBe('function')
-  })
-
-  test('object ref can be assigned to RefProp', () => {
-    const ref = createRef<HTMLElement>()
-    const prop: RefProp<HTMLElement> = ref
-    expect(typeof prop).toBe('object')
-    expect(prop).toBe(ref)
-  })
-})