@pyreon/core 0.11.3 → 0.11.4

package/src/tests/lifecycle.test.ts

@@ -0,0 +1,208 @@
+import {
+  getCurrentHooks,
+  onErrorCaptured,
+  onMount,
+  onUnmount,
+  onUpdate,
+  setCurrentHooks,
+} from "../lifecycle"
+import type { LifecycleHooks } from "../types"
+
+describe("setCurrentHooks / getCurrentHooks", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("getCurrentHooks returns null by default", () => {
+    expect(getCurrentHooks()).toBeNull()
+  })
+
+  test("setCurrentHooks sets the current hooks context", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    expect(getCurrentHooks()).toBe(hooks)
+  })
+
+  test("setCurrentHooks(null) clears the context", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    expect(getCurrentHooks()).toBe(hooks)
+    setCurrentHooks(null)
+    expect(getCurrentHooks()).toBeNull()
+  })
+})
+
+describe("onMount", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("registers callback on current hooks", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    const fn = () => undefined
+    onMount(fn)
+    expect(hooks.mount).toHaveLength(1)
+    expect(hooks.mount[0]).toBe(fn)
+  })
+
+  test("multiple onMount calls accumulate", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    onMount(() => undefined)
+    onMount(() => undefined)
+    onMount(() => undefined)
+    expect(hooks.mount).toHaveLength(3)
+  })
+
+  test("warns when called outside component setup", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    onMount(() => {})
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("onMount() called outside component setup"),
+    )
+    warnSpy.mockRestore()
+  })
+
+  test("is a no-op outside component setup (no crash)", () => {
+    expect(() => onMount(() => {})).not.toThrow()
+  })
+
+  test("accepts callback returning cleanup function", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    const cleanup = () => {}
+    onMount(() => cleanup)
+    expect(hooks.mount).toHaveLength(1)
+    expect(hooks.mount[0]!()).toBe(cleanup)
+  })
+
+  test("accepts callback returning void", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    onMount(() => {})
+    expect(hooks.mount).toHaveLength(1)
+    expect(hooks.mount[0]!()).toBeUndefined()
+  })
+})
+
+describe("onUnmount", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("registers callback on current hooks", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    const fn = () => {}
+    onUnmount(fn)
+    expect(hooks.unmount).toHaveLength(1)
+    expect(hooks.unmount[0]).toBe(fn)
+  })
+
+  test("warns when called outside component setup", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    onUnmount(() => {})
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("onUnmount() called outside component setup"),
+    )
+    warnSpy.mockRestore()
+  })
+})
+
+describe("onUpdate", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("registers callback on current hooks", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    const fn = () => {}
+    onUpdate(fn)
+    expect(hooks.update).toHaveLength(1)
+    expect(hooks.update[0]).toBe(fn)
+  })
+
+  test("warns when called outside component setup", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    onUpdate(() => {})
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("onUpdate() called outside component setup"),
+    )
+    warnSpy.mockRestore()
+  })
+})
+
+describe("onErrorCaptured", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("registers callback on current hooks", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    const fn = () => true
+    onErrorCaptured(fn)
+    expect(hooks.error).toHaveLength(1)
+    expect(hooks.error[0]).toBe(fn)
+  })
+
+  test("warns when called outside component setup", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    onErrorCaptured(() => true)
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("onErrorCaptured() called outside component setup"),
+    )
+    warnSpy.mockRestore()
+  })
+
+  test("registered handler receives the error", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+    let captured: unknown = null
+    onErrorCaptured((err) => {
+      captured = err
+      return true
+    })
+    // Simulate calling the handler
+    const testError = new Error("test")
+    hooks.error[0]!(testError)
+    expect(captured).toBe(testError)
+  })
+})
+
+describe("lifecycle hooks interaction", () => {
+  afterEach(() => {
+    setCurrentHooks(null)
+  })
+
+  test("all hook types can be registered in same context", () => {
+    const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    setCurrentHooks(hooks)
+
+    onMount(() => undefined)
+    onUnmount(() => {})
+    onUpdate(() => {})
+    onErrorCaptured(() => true)
+
+    expect(hooks.mount).toHaveLength(1)
+    expect(hooks.unmount).toHaveLength(1)
+    expect(hooks.update).toHaveLength(1)
+    expect(hooks.error).toHaveLength(1)
+  })
+
+  test("hooks from different setCurrentHooks calls go to different stores", () => {
+    const hooks1: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+    const hooks2: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
+
+    setCurrentHooks(hooks1)
+    onMount(() => undefined)
+    setCurrentHooks(hooks2)
+    onMount(() => undefined)
+    onMount(() => undefined)
+
+    expect(hooks1.mount).toHaveLength(1)
+    expect(hooks2.mount).toHaveLength(2)
+  })
+})

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

@@ -0,0 +1,313 @@
+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/portal.test.ts

@@ -0,0 +1,48 @@
+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")
+  })
+})