@pyreon/core 0.11.2 → 0.11.4

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

@@ -0,0 +1,181 @@
+import { dispatchToErrorBoundary, popErrorBoundary, runWithHooks } from "../component"
+import { ErrorBoundary } from "../error-boundary"
+import { h } from "../h"
+import type { VNodeChild } from "../types"
+
+describe("ErrorBoundary", () => {
+  // Clean up error boundary stack after each test
+  afterEach(() => {
+    // Pop all boundaries that tests may have left
+    while (dispatchToErrorBoundary("cleanup")) {
+      popErrorBoundary()
+    }
+  })
+
+  test("is a function", () => {
+    expect(typeof ErrorBoundary).toBe("function")
+  })
+
+  test("returns a reactive getter", () => {
+    let result: VNodeChild = null
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: "child",
+      })
+      return null
+    }, {})
+    expect(typeof result).toBe("function")
+  })
+
+  test("renders children when no error", () => {
+    let result: VNodeChild = null
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: "child content",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("child content")
+  })
+
+  test("renders function children by calling them", () => {
+    let result: VNodeChild = null
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: () => "dynamic child",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("dynamic child")
+  })
+
+  test("renders VNode children", () => {
+    let result: VNodeChild = null
+    const child = h("div", null, "content")
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: child,
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe(child)
+  })
+
+  test("registers unmount cleanup hook", () => {
+    const { hooks } = runWithHooks(() => {
+      ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: "child",
+      })
+      return null
+    }, {})
+    expect(hooks.unmount.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test("warns when fallback is not a function", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    runWithHooks(() => {
+      ErrorBoundary({
+        fallback: "not-a-function" as unknown as (err: unknown, reset: () => void) => VNodeChild,
+        children: "child",
+      })
+      return null
+    }, {})
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<ErrorBoundary>"))
+    warnSpy.mockRestore()
+  })
+
+  test("dispatched error triggers fallback rendering", () => {
+    let result: VNodeChild = null
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Caught: ${err}`,
+        children: "normal",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("normal")
+
+    dispatchToErrorBoundary(new Error("boom"))
+    expect(getter()).toBe("Caught: Error: boom")
+  })
+
+  test("fallback receives reset function that clears error", () => {
+    let result: VNodeChild = null
+    let capturedReset: (() => void) | undefined
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (_err, reset) => {
+          capturedReset = reset
+          return "error-ui"
+        },
+        children: "child",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("child")
+
+    dispatchToErrorBoundary("test-error")
+    expect(getter()).toBe("error-ui")
+    expect(capturedReset).toBeDefined()
+
+    capturedReset?.()
+    expect(getter()).toBe("child")
+  })
+
+  test("second error while already in error state is not handled", () => {
+    let result: VNodeChild = null
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err) => `Error: ${err}`,
+        children: "child",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+
+    // First error handled
+    expect(dispatchToErrorBoundary("first")).toBe(true)
+    expect(getter()).toBe("Error: first")
+
+    // Second error not handled (already in error state)
+    expect(dispatchToErrorBoundary("second")).toBe(false)
+    // Still showing first error
+    expect(getter()).toBe("Error: first")
+  })
+
+  test("after reset, new error can be caught again", () => {
+    let result: VNodeChild = null
+    let capturedReset: (() => void) | undefined
+    runWithHooks(() => {
+      result = ErrorBoundary({
+        fallback: (err, reset) => {
+          capturedReset = reset
+          return `Error: ${err}`
+        },
+        children: "child",
+      })
+      return null
+    }, {})
+    const getter = result as unknown as () => VNodeChild
+
+    dispatchToErrorBoundary("first-error")
+    expect(getter()).toBe("Error: first-error")
+
+    capturedReset?.()
+    expect(getter()).toBe("child")
+
+    // Can catch new error after reset
+    expect(dispatchToErrorBoundary("second-error")).toBe(true)
+    expect(getter()).toBe("Error: second-error")
+  })
+})

package/src/tests/for.test.ts

@@ -0,0 +1,94 @@
+import { For, ForSymbol } from "../for"
+import { h } from "../h"
+import type { VNode } from "../types"
+
+describe("For", () => {
+  test("returns VNode with ForSymbol type", () => {
+    const node = For({
+      each: () => [1, 2, 3],
+      by: (item) => item,
+      children: (item) => h("li", null, String(item)),
+    })
+    expect(node.type).toBe(ForSymbol)
+  })
+
+  test("VNode has empty children array", () => {
+    const node = For({
+      each: () => [],
+      by: (item: number) => item,
+      children: (item) => h("span", null, String(item)),
+    })
+    expect(node.children).toEqual([])
+  })
+
+  test("VNode has null key", () => {
+    const node = For({
+      each: () => [1],
+      by: (item) => item,
+      children: (item) => h("li", null, String(item)),
+    })
+    expect(node.key).toBeNull()
+  })
+
+  test("props contain each, by, children functions", () => {
+    const eachFn = () => ["a", "b"]
+    const byFn = (item: string) => item
+    const childFn = (item: string) => h("span", null, item)
+    const node = For({ each: eachFn, by: byFn, children: childFn })
+
+    const props = node.props as unknown as {
+      each: typeof eachFn
+      by: typeof byFn
+      children: typeof childFn
+    }
+    expect(props.each).toBe(eachFn)
+    expect(props.by).toBe(byFn)
+    expect(props.children).toBe(childFn)
+  })
+
+  test("ForSymbol is a unique symbol", () => {
+    expect(typeof ForSymbol).toBe("symbol")
+    expect(ForSymbol.toString()).toContain("pyreon.For")
+  })
+
+  test("works with object items", () => {
+    interface Item {
+      id: number
+      name: string
+    }
+    const items: Item[] = [
+      { id: 1, name: "one" },
+      { id: 2, name: "two" },
+    ]
+    const node = For<Item>({
+      each: () => items,
+      by: (item) => item.id,
+      children: (item) => h("li", null, item.name),
+    })
+    expect(node.type).toBe(ForSymbol)
+    const props = node.props as unknown as { each: () => Item[] }
+    expect(props.each()).toBe(items)
+  })
+
+  test("works with string keys", () => {
+    const node = For({
+      each: () => [{ slug: "hello" }, { slug: "world" }],
+      by: (item) => item.slug,
+      children: (item) => h("div", null, item.slug),
+    })
+    expect(node.type).toBe(ForSymbol)
+  })
+
+  test("children function produces VNodes", () => {
+    const childFn = (n: number) => h("li", { key: n }, String(n))
+    const node = For({
+      each: () => [1, 2, 3],
+      by: (n) => n,
+      children: childFn,
+    })
+    const props = node.props as unknown as { children: typeof childFn }
+    const result = props.children(1)
+    expect((result as VNode).type).toBe("li")
+    expect((result as VNode).key).toBe(1)
+  })
+})

package/src/tests/h.test.ts

@@ -0,0 +1,200 @@
+import { EMPTY_PROPS, Fragment, h } from "../h"
+import type { ComponentFn, VNode, VNodeChild } from "../types"
+
+describe("h() — VNode creation", () => {
+  describe("basic element creation", () => {
+    test("creates VNode with string tag", () => {
+      const node = h("div", null)
+      expect(node.type).toBe("div")
+      expect(node.props).toBe(EMPTY_PROPS)
+      expect(node.children).toEqual([])
+      expect(node.key).toBeNull()
+    })
+
+    test("creates VNode with props", () => {
+      const node = h("div", { id: "main", class: "container" })
+      expect(node.props.id).toBe("main")
+      expect(node.props.class).toBe("container")
+    })
+
+    test("null props becomes EMPTY_PROPS sentinel", () => {
+      const node1 = h("div", null)
+      const node2 = h("span", null)
+      // Both should use the same EMPTY_PROPS object (identity check)
+      expect(node1.props).toBe(node2.props)
+      expect(node1.props).toBe(EMPTY_PROPS)
+    })
+  })
+
+  describe("key extraction", () => {
+    test("extracts string key from props", () => {
+      const node = h("li", { key: "item-1" })
+      expect(node.key).toBe("item-1")
+    })
+
+    test("extracts numeric key from props", () => {
+      const node = h("li", { key: 42 })
+      expect(node.key).toBe(42)
+    })
+
+    test("key is null when not provided", () => {
+      const node = h("div", { class: "x" })
+      expect(node.key).toBeNull()
+    })
+
+    test("key is null for null props", () => {
+      const node = h("div", null)
+      expect(node.key).toBeNull()
+    })
+
+    test("key 0 is preserved (falsy but valid)", () => {
+      const node = h("li", { key: 0 })
+      expect(node.key).toBe(0)
+    })
+  })
+
+  describe("children handling", () => {
+    test("string children", () => {
+      const node = h("p", null, "hello")
+      expect(node.children).toEqual(["hello"])
+    })
+
+    test("multiple string children", () => {
+      const node = h("p", null, "hello", " ", "world")
+      expect(node.children).toEqual(["hello", " ", "world"])
+    })
+
+    test("number children", () => {
+      const node = h("span", null, 42)
+      expect(node.children).toEqual([42])
+    })
+
+    test("VNode children", () => {
+      const child = h("span", null, "inner")
+      const parent = h("div", null, child)
+      expect(parent.children).toHaveLength(1)
+      expect((parent.children[0] as VNode).type).toBe("span")
+    })
+
+    test("mixed children types", () => {
+      const child = h("em", null)
+      const getter = () => "reactive"
+      const node = h("div", null, "text", 42, child, null, undefined, true, false, getter)
+      expect(node.children).toHaveLength(8)
+      expect(node.children[0]).toBe("text")
+      expect(node.children[1]).toBe(42)
+      expect((node.children[2] as VNode).type).toBe("em")
+      expect(node.children[3]).toBeNull()
+      expect(node.children[4]).toBeUndefined()
+      expect(node.children[5]).toBe(true)
+      expect(node.children[6]).toBe(false)
+      expect(typeof node.children[7]).toBe("function")
+    })
+
+    test("function children (reactive getters) are preserved", () => {
+      const getter = () => "dynamic"
+      const node = h("div", null, getter)
+      expect(node.children).toHaveLength(1)
+      expect(typeof node.children[0]).toBe("function")
+      expect((node.children[0] as () => string)()).toBe("dynamic")
+    })
+
+    test("no children produces empty array", () => {
+      const node = h("br", null)
+      expect(node.children).toEqual([])
+    })
+  })
+
+  describe("children flattening", () => {
+    test("flattens single-level array children", () => {
+      const node = h("ul", null, [h("li", null, "a"), h("li", null, "b")])
+      expect(node.children).toHaveLength(2)
+      expect((node.children[0] as VNode).type).toBe("li")
+      expect((node.children[1] as VNode).type).toBe("li")
+    })
+
+    test("flattens deeply nested arrays", () => {
+      const node = h("div", null, [[["deep"]]] as unknown as VNodeChild)
+      expect(node.children).toEqual(["deep"])
+    })
+
+    test("flattens mixed nested/flat children", () => {
+      const node = h("div", null, "flat", ["nested-a", "nested-b"] as unknown as VNodeChild)
+      expect(node.children).toEqual(["flat", "nested-a", "nested-b"])
+    })
+
+    test("fast path: no allocation when children have no nested arrays", () => {
+      // normalizeChildren returns as-is when no element is an array
+      const node = h("div", null, "a", "b", "c")
+      expect(node.children).toEqual(["a", "b", "c"])
+      expect(node.children).toHaveLength(3)
+    })
+
+    test("flattens multiple levels of nesting", () => {
+      const node = h("div", null, [["a", ["b", ["c"]]]] as unknown as VNodeChild)
+      expect(node.children).toEqual(["a", "b", "c"])
+    })
+  })
+
+  describe("component function type", () => {
+    test("accepts component function as type", () => {
+      const Comp: ComponentFn<{ name: string }> = (props) => h("span", null, props.name)
+      const node = h(Comp, { name: "test" })
+      expect(node.type).toBe(Comp)
+      expect(node.props.name).toBe("test")
+    })
+
+    test("component with no props", () => {
+      const Comp: ComponentFn = () => h("div", null)
+      const node = h(Comp, null)
+      expect(node.type).toBe(Comp)
+      expect(node.props).toBe(EMPTY_PROPS)
+    })
+
+    test("component with children rest args", () => {
+      const Comp: ComponentFn = () => null
+      const node = h(Comp, { id: "x" }, "child1", "child2")
+      expect(node.children).toEqual(["child1", "child2"])
+    })
+  })
+
+  describe("symbol type (Fragment)", () => {
+    test("Fragment as type", () => {
+      const node = h(Fragment, null, "a", "b")
+      expect(node.type).toBe(Fragment)
+      expect(node.children).toEqual(["a", "b"])
+    })
+
+    test("Fragment with VNode children", () => {
+      const node = h(Fragment, null, h("span", null, "x"), h("em", null, "y"))
+      expect(node.children).toHaveLength(2)
+    })
+
+    test("nested Fragments", () => {
+      const inner = h(Fragment, null, "a", "b")
+      const outer = h(Fragment, null, inner, "c")
+      expect(outer.children).toHaveLength(2)
+      expect((outer.children[0] as VNode).type).toBe(Fragment)
+    })
+  })
+})
+
+describe("EMPTY_PROPS", () => {
+  test("is a plain object", () => {
+    expect(typeof EMPTY_PROPS).toBe("object")
+    expect(EMPTY_PROPS).not.toBeNull()
+  })
+
+  test("is the same reference for all null-prop VNodes", () => {
+    const a = h("div", null)
+    const b = h("span", null)
+    expect(a.props).toBe(b.props)
+  })
+})
+
+describe("Fragment", () => {
+  test("is a unique symbol", () => {
+    expect(typeof Fragment).toBe("symbol")
+    expect(Fragment.toString()).toContain("Pyreon.Fragment")
+  })
+})

package/src/tests/lazy.test.ts

@@ -0,0 +1,100 @@
+import { h } from "../h"
+import { lazy } from "../lazy"
+import type { ComponentFn, Props, VNode } from "../types"
+
+describe("lazy", () => {
+  test("returns a LazyComponent with __loading flag", () => {
+    const Comp = lazy<Props>(() => new Promise(() => {})) // never resolves
+    expect(typeof Comp).toBe("function")
+    expect(typeof Comp.__loading).toBe("function")
+    expect(Comp.__loading()).toBe(true)
+  })
+
+  test("__loading returns true while loading", () => {
+    const Comp = lazy<Props>(() => new Promise(() => {}))
+    expect(Comp.__loading()).toBe(true)
+  })
+
+  test("returns null while loading (component not yet available)", () => {
+    const Comp = lazy<Props>(() => new Promise(() => {}))
+    const result = Comp({})
+    expect(result).toBeNull()
+  })
+
+  test("resolves to the loaded component", async () => {
+    const Inner: ComponentFn<{ name: string }> = (props) => h("span", null, props.name)
+    const Comp = lazy(() => Promise.resolve({ default: Inner }))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(Comp.__loading()).toBe(false)
+    const result = Comp({ name: "test" })
+    expect(result).not.toBeNull()
+    expect((result as VNode).type).toBe(Inner)
+    expect((result as VNode).props).toEqual({ name: "test" })
+  })
+
+  test("throws on import error", async () => {
+    const Comp = lazy<Props>(() => Promise.reject(new Error("load failed")))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(Comp.__loading()).toBe(false)
+    expect(() => Comp({})).toThrow("load failed")
+  })
+
+  test("wraps non-Error rejection in Error", async () => {
+    const Comp = lazy<Props>(() => Promise.reject("string-error"))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(() => Comp({})).toThrow("string-error")
+  })
+
+  test("wraps numeric rejection in Error", async () => {
+    const Comp = lazy<Props>(() => Promise.reject(404))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(() => Comp({})).toThrow("404")
+  })
+
+  test("__loading is false after successful load", async () => {
+    const Inner: ComponentFn = () => null
+    const Comp = lazy(() => Promise.resolve({ default: Inner }))
+
+    expect(Comp.__loading()).toBe(true)
+    await new Promise((r) => setTimeout(r, 0))
+    expect(Comp.__loading()).toBe(false)
+  })
+
+  test("__loading is false after failed load", async () => {
+    const Comp = lazy<Props>(() => Promise.reject(new Error("fail")))
+
+    expect(Comp.__loading()).toBe(true)
+    await new Promise((r) => setTimeout(r, 0))
+    expect(Comp.__loading()).toBe(false)
+  })
+
+  test("multiple calls after load return consistent results", async () => {
+    const Inner: ComponentFn = () => h("div", null, "content")
+    const Comp = lazy(() => Promise.resolve({ default: Inner }))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    const result1 = Comp({})
+    const result2 = Comp({})
+    expect((result1 as VNode).type).toBe(Inner)
+    expect((result2 as VNode).type).toBe(Inner)
+  })
+
+  test("passes props through to loaded component via h()", async () => {
+    const Inner: ComponentFn<{ count: number }> = (props) => h("span", null, String(props.count))
+    const Comp = lazy(() => Promise.resolve({ default: Inner }))
+
+    await new Promise((r) => setTimeout(r, 0))
+
+    const result = Comp({ count: 42 })
+    expect((result as VNode).props).toEqual({ count: 42 })
+  })
+})