@pyreon/core 0.24.5 → 0.24.6

package/src/tests/map-array.test.ts

@@ -1,313 +0,0 @@
-import { mapArray } from '../map-array'
-
-describe('mapArray', () => {
-  describe('basic mapping', () => {
-    test('maps all items on first call', () => {
-      const mapped = mapArray(
-        () => [1, 2, 3],
-        (item) => item,
-        (item) => item * 10,
-      )
-      expect(mapped()).toEqual([10, 20, 30])
-    })
-
-    test('returns empty array for empty source', () => {
-      const mapped = mapArray(
-        () => [],
-        (item: number) => item,
-        (item) => item * 10,
-      )
-      expect(mapped()).toEqual([])
-    })
-
-    test('maps single item', () => {
-      const mapped = mapArray(
-        () => [42],
-        (item) => item,
-        (item) => `value-${item}`,
-      )
-      expect(mapped()).toEqual(['value-42'])
-    })
-  })
-
-  describe('caching behavior', () => {
-    test('caches results — map function called once per key', () => {
-      let callCount = 0
-      const items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      // Second call — all cached
-      mapped()
-      expect(callCount).toBe(3)
-
-      // Third call — still cached
-      mapped()
-      expect(callCount).toBe(3)
-    })
-
-    test('only maps new keys when items are added', () => {
-      let callCount = 0
-      let items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      items = [1, 2, 3, 4, 5]
-      mapped()
-      expect(callCount).toBe(5) // only 4 and 5 are new
-    })
-
-    test('does not re-map when items are removed', () => {
-      let callCount = 0
-      let items = [1, 2, 3, 4, 5]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(5)
-
-      items = [1, 3, 5] // remove 2 and 4
-      const result = mapped()
-      expect(result).toEqual([10, 30, 50])
-      expect(callCount).toBe(5) // no new calls
-    })
-  })
-
-  describe('key eviction', () => {
-    test('evicted keys are re-mapped when they return', () => {
-      let callCount = 0
-      let items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      // Remove key 2
-      items = [1, 3]
-      mapped()
-      expect(callCount).toBe(3) // no new mapping
-
-      // Re-add key 2 — should re-map since it was evicted
-      items = [1, 2, 3]
-      mapped()
-      expect(callCount).toBe(4) // key 2 re-mapped
-    })
-
-    test('evicts all keys when source becomes empty', () => {
-      let callCount = 0
-      let items: number[] = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      items = []
-      mapped()
-      expect(callCount).toBe(3)
-
-      // All keys were evicted — re-adding requires re-mapping
-      items = [1, 2, 3]
-      mapped()
-      expect(callCount).toBe(6)
-    })
-  })
-
-  describe('reordering', () => {
-    test('reordered items use cached values (no re-mapping)', () => {
-      let callCount = 0
-      let items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      items = [3, 1, 2]
-      const result = mapped()
-      expect(result).toEqual([30, 10, 20])
-      expect(callCount).toBe(3) // no new calls
-    })
-
-    test('reverse order uses cached values', () => {
-      let callCount = 0
-      let items = [1, 2, 3, 4]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return `item-${item}`
-        },
-      )
-
-      mapped()
-      items = [4, 3, 2, 1]
-      const result = mapped()
-      expect(result).toEqual(['item-4', 'item-3', 'item-2', 'item-1'])
-      expect(callCount).toBe(4) // initial 4 only
-    })
-  })
-
-  describe('string keys', () => {
-    test('works with string keys from objects', () => {
-      interface User {
-        id: string
-        name: string
-      }
-      let callCount = 0
-      let users: User[] = [
-        { id: 'a', name: 'Alice' },
-        { id: 'b', name: 'Bob' },
-      ]
-      const mapped = mapArray(
-        () => users,
-        (u) => u.id,
-        (u) => {
-          callCount++
-          return u.name.toUpperCase()
-        },
-      )
-
-      expect(mapped()).toEqual(['ALICE', 'BOB'])
-      expect(callCount).toBe(2)
-
-      // Add new user
-      users = [
-        { id: 'a', name: 'Alice' },
-        { id: 'b', name: 'Bob' },
-        { id: 'c', name: 'Charlie' },
-      ]
-      expect(mapped()).toEqual(['ALICE', 'BOB', 'CHARLIE'])
-      expect(callCount).toBe(3)
-    })
-  })
-
-  describe('mixed additions and removals', () => {
-    test('simultaneous add and remove', () => {
-      let callCount = 0
-      let items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      // Remove 2, add 4
-      items = [1, 3, 4]
-      const result = mapped()
-      expect(result).toEqual([10, 30, 40])
-      expect(callCount).toBe(4) // only key 4 is new
-    })
-
-    test('complete replacement of all items', () => {
-      let callCount = 0
-      let items = [1, 2, 3]
-      const mapped = mapArray(
-        () => items,
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      mapped()
-      expect(callCount).toBe(3)
-
-      items = [4, 5, 6]
-      const result = mapped()
-      expect(result).toEqual([40, 50, 60])
-      expect(callCount).toBe(6) // all new
-    })
-  })
-
-  describe('duplicate keys', () => {
-    test('duplicate keys in source share the same cached value', () => {
-      let callCount = 0
-      const mapped = mapArray(
-        () => [1, 1, 2],
-        (item) => item,
-        (item) => {
-          callCount++
-          return item * 10
-        },
-      )
-
-      const result = mapped()
-      // Key 1 mapped once, key 2 mapped once
-      expect(callCount).toBe(2)
-      // Both occurrences of key 1 get the same cached value
-      expect(result).toEqual([10, 10, 20])
-    })
-  })
-
-  describe('map function receives correct item', () => {
-    test('map receives the item, not the key', () => {
-      const received: Array<{ id: number; val: string }> = []
-      const items = [
-        { id: 1, val: 'a' },
-        { id: 2, val: 'b' },
-      ]
-      const mapped = mapArray(
-        () => items,
-        (item) => item.id,
-        (item) => {
-          received.push(item)
-          return item.val
-        },
-      )
-      mapped()
-      expect(received).toEqual(items)
-    })
-  })
-})

package/src/tests/native-marker-error-boundary.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isNativeCompat } from '../compat-marker'
-import { ErrorBoundary } from '../error-boundary'
-
-// Marker-presence assertion (PR 3 lock-in). Bisect-verified: removing the
-// `nativeCompat(ErrorBoundary)` call fails this test with
-// `expected false to be true`.
-describe('native-compat marker — @pyreon/core', () => {
-  it('ErrorBoundary is marked native', () => {
-    expect(isNativeCompat(ErrorBoundary)).toBe(true)
-  })
-})

package/src/tests/portal.test.ts

@@ -1,48 +0,0 @@
-import { h } from '../h'
-import { Portal, PortalSymbol } from '../portal'
-import type { VNode } from '../types'
-
-describe('Portal', () => {
-  test('returns VNode with PortalSymbol type', () => {
-    const fakeTarget = {} as Element
-    const node = Portal({ target: fakeTarget, children: h('div', null) })
-    expect(node.type).toBe(PortalSymbol)
-  })
-
-  test('VNode has null key', () => {
-    const node = Portal({ target: {} as Element, children: 'content' })
-    expect(node.key).toBeNull()
-  })
-
-  test('VNode has empty children array', () => {
-    const node = Portal({ target: {} as Element, children: 'content' })
-    expect(node.children).toEqual([])
-  })
-
-  test('props contain target and children', () => {
-    const fakeTarget = {} as Element
-    const child = h('span', null, 'content')
-    const node = Portal({ target: fakeTarget, children: child })
-    const props = node.props as unknown as { target: Element; children: VNode }
-    expect(props.target).toBe(fakeTarget)
-    expect(props.children).toBe(child)
-  })
-
-  test('PortalSymbol is a unique symbol', () => {
-    expect(typeof PortalSymbol).toBe('symbol')
-    expect(PortalSymbol.toString()).toContain('pyreon.Portal')
-  })
-
-  test('string children are stored in props', () => {
-    const node = Portal({ target: {} as Element, children: 'text content' })
-    const props = node.props as unknown as { children: string }
-    expect(props.children).toBe('text content')
-  })
-
-  test('multiple VNode children via fragment', () => {
-    const children = h('div', null, h('span', null, 'a'), h('span', null, 'b'))
-    const node = Portal({ target: {} as Element, children })
-    const props = node.props as unknown as { children: VNode }
-    expect((props.children as VNode).type).toBe('div')
-  })
-})

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

@@ -1,157 +0,0 @@
-import { _resetIdCounter, createUniqueId, mergeProps, splitProps } from '../props'
-
-describe('createUniqueId — extended', () => {
-  test('returns pyreon- prefixed string', () => {
-    const id = createUniqueId()
-    expect(id).toMatch(/^pyreon-\d+$/)
-  })
-
-  test('returns incrementing values', () => {
-    const id1 = createUniqueId()
-    const id2 = createUniqueId()
-    const id3 = createUniqueId()
-    const num1 = Number.parseInt(id1.replace('pyreon-', ''), 10)
-    const num2 = Number.parseInt(id2.replace('pyreon-', ''), 10)
-    const num3 = Number.parseInt(id3.replace('pyreon-', ''), 10)
-    expect(num2).toBe(num1 + 1)
-    expect(num3).toBe(num2 + 1)
-  })
-
-  test('all IDs are unique', () => {
-    const ids = new Set<string>()
-    for (let i = 0; i < 100; i++) {
-      ids.add(createUniqueId())
-    }
-    expect(ids.size).toBe(100)
-  })
-})
-
-describe('_resetIdCounter', () => {
-  test('resets the counter so IDs restart', () => {
-    // Generate some IDs to advance counter
-    createUniqueId()
-    createUniqueId()
-
-    _resetIdCounter()
-
-    const id = createUniqueId()
-    expect(id).toBe('pyreon-1')
-  })
-
-  test('subsequent calls after reset increment from 1', () => {
-    _resetIdCounter()
-    expect(createUniqueId()).toBe('pyreon-1')
-    expect(createUniqueId()).toBe('pyreon-2')
-    expect(createUniqueId()).toBe('pyreon-3')
-  })
-})
-
-describe('splitProps — extended', () => {
-  test('non-existent keys produce empty picked object', () => {
-    const props = { a: 1, b: 2 }
-    const [own, rest] = splitProps(props, ['c' as keyof typeof props])
-    expect(Object.keys(own)).toEqual([])
-    expect(rest).toEqual({ a: 1, b: 2 })
-  })
-
-  test('all keys in picked leaves rest empty', () => {
-    const props = { x: 10, y: 20 }
-    const [own, rest] = splitProps(props, ['x', 'y'])
-    expect(own).toEqual({ x: 10, y: 20 })
-    expect(Object.keys(rest)).toEqual([])
-  })
-
-  test('preserves getter on rest side', () => {
-    let count = 0
-    const props = {} as Record<string, unknown>
-    Object.defineProperty(props, 'reactive', {
-      get: () => ++count,
-      enumerable: true,
-      configurable: true,
-    })
-    Object.defineProperty(props, 'other', {
-      value: 'static',
-      enumerable: true,
-      configurable: true,
-    })
-
-    const [_own, rest] = splitProps(props, ['other'])
-    expect((rest as Record<string, unknown>).reactive).toBe(1)
-    expect((rest as Record<string, unknown>).reactive).toBe(2) // getter called again
-  })
-
-  test('handles object with undefined values', () => {
-    const props = { a: undefined, b: 'defined' }
-    const [own, rest] = splitProps(props, ['a'])
-    expect(own.a).toBeUndefined()
-    expect((rest as Record<string, unknown>).b).toBe('defined')
-  })
-})
-
-describe('mergeProps — extended', () => {
-  test('single source returns copy', () => {
-    const src = { a: 1, b: 2 }
-    const result = mergeProps(src)
-    expect(result).toEqual({ a: 1, b: 2 })
-    expect(result).not.toBe(src) // should be a new object
-  })
-
-  test('three sources merge correctly', () => {
-    const result = mergeProps({ a: 1 }, { b: 2 }, { c: 3 })
-    expect(result).toEqual({ a: 1, b: 2, c: 3 })
-  })
-
-  test('later defined value overrides earlier', () => {
-    const result = mergeProps({ x: 'first' }, { x: 'second' }, { x: 'third' })
-    expect(result.x).toBe('third')
-  })
-
-  test('undefined in later source does not override earlier defined value', () => {
-    const result = mergeProps({ x: 'keep' }, { x: undefined as string | undefined })
-    expect(result.x).toBe('keep')
-  })
-
-  test('getter merging: later getter overrides earlier static when defined', () => {
-    let dynamic: string | undefined = 'from-getter'
-    const getterSrc = {} as Record<string, unknown>
-    Object.defineProperty(getterSrc, 'val', {
-      get: () => dynamic,
-      enumerable: true,
-      configurable: true,
-    })
-    const result = mergeProps({ val: 'static' }, getterSrc)
-    expect(result.val).toBe('from-getter')
-
-    // When getter returns undefined, falls back to static
-    dynamic = undefined
-    expect(result.val).toBe('static')
-  })
-
-  test('two getters: later getter wins when defined, falls to earlier getter', () => {
-    let g1val: string | undefined = 'g1'
-    let g2val: string | undefined = 'g2'
-
-    const src1 = {} as Record<string, unknown>
-    Object.defineProperty(src1, 'x', {
-      get: () => g1val,
-      enumerable: true,
-      configurable: true,
-    })
-
-    const src2 = {} as Record<string, unknown>
-    Object.defineProperty(src2, 'x', {
-      get: () => g2val,
-      enumerable: true,
-      configurable: true,
-    })
-
-    const result = mergeProps(src1, src2)
-    expect(result.x).toBe('g2')
-
-    g2val = undefined
-    expect(result.x).toBe('g1')
-
-    g1val = undefined
-    expect(result.x).toBeUndefined()
-  })
-})