@pyreon/core 0.11.2 → 0.11.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/core",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Core component model and lifecycle for Pyreon",
   "license": "MIT",
   "repository": {
@@ -49,7 +49,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/reactivity": "^0.11.2"
+    "@pyreon/reactivity": "^0.11.4"
   },
   "publishConfig": {
     "access": "public"

package/src/tests/component.test.ts

@@ -0,0 +1,281 @@
+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("empty hooks when component registers none", () => {
+    const { hooks } = runWithHooks(() => h("div", null), {})
+    expect(hooks.mount).toHaveLength(0)
+    expect(hooks.unmount).toHaveLength(0)
+    expect(hooks.update).toHaveLength(0)
+    expect(hooks.error).toHaveLength(0)
+  })
+})
+
+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])
+  })
+})

package/src/tests/context.test.ts

@@ -0,0 +1,263 @@
+import { runWithHooks } from "../component"
+import {
+  createContext,
+  popContext,
+  provide,
+  pushContext,
+  setContextStackProvider,
+  useContext,
+  withContext,
+} from "../context"
+import type { ComponentFn, Props } from "../types"
+
+describe("createContext", () => {
+  test("returns context with unique symbol id", () => {
+    const ctx = createContext("default")
+    expect(typeof ctx.id).toBe("symbol")
+    expect(ctx.defaultValue).toBe("default")
+  })
+
+  test("each context has a unique id", () => {
+    const a = createContext(1)
+    const b = createContext(2)
+    expect(a.id).not.toBe(b.id)
+  })
+
+  test("undefined default value", () => {
+    const ctx = createContext<string | undefined>(undefined)
+    expect(ctx.defaultValue).toBeUndefined()
+  })
+
+  test("null default value", () => {
+    const ctx = createContext<null>(null)
+    expect(ctx.defaultValue).toBeNull()
+  })
+
+  test("object default value", () => {
+    const obj = { theme: "dark", lang: "en" }
+    const ctx = createContext(obj)
+    expect(ctx.defaultValue).toBe(obj)
+  })
+
+  test("function default value", () => {
+    const fn = () => 42
+    const ctx = createContext(fn)
+    expect(ctx.defaultValue).toBe(fn)
+  })
+})
+
+describe("useContext", () => {
+  test("returns default when no provider exists", () => {
+    const ctx = createContext("fallback")
+    expect(useContext(ctx)).toBe("fallback")
+  })
+
+  test("returns provided value from pushContext", () => {
+    const ctx = createContext("default")
+    pushContext(new Map([[ctx.id, "provided"]]))
+    expect(useContext(ctx)).toBe("provided")
+    popContext()
+  })
+
+  test("returns innermost value with nested pushContext", () => {
+    const ctx = createContext("default")
+    pushContext(new Map([[ctx.id, "outer"]]))
+    pushContext(new Map([[ctx.id, "inner"]]))
+    expect(useContext(ctx)).toBe("inner")
+    popContext()
+    expect(useContext(ctx)).toBe("outer")
+    popContext()
+  })
+
+  test("different contexts in same frame are independent", () => {
+    const ctxA = createContext("a-default")
+    const ctxB = createContext("b-default")
+    const frame = new Map<symbol, unknown>([
+      [ctxA.id, "a-value"],
+      [ctxB.id, "b-value"],
+    ])
+    pushContext(frame)
+    expect(useContext(ctxA)).toBe("a-value")
+    expect(useContext(ctxB)).toBe("b-value")
+    popContext()
+  })
+
+  test("context not in frame falls through to previous frame", () => {
+    const ctxA = createContext("a-default")
+    const ctxB = createContext("b-default")
+    pushContext(new Map([[ctxA.id, "a-outer"]]))
+    pushContext(new Map([[ctxB.id, "b-inner"]]))
+    // ctxA is not in the inner frame, should fall through to outer
+    expect(useContext(ctxA)).toBe("a-outer")
+    expect(useContext(ctxB)).toBe("b-inner")
+    popContext()
+    popContext()
+  })
+})
+
+describe("pushContext / popContext", () => {
+  test("push and pop maintain correct stack order", () => {
+    const ctx = createContext(0)
+    pushContext(new Map([[ctx.id, 1]]))
+    pushContext(new Map([[ctx.id, 2]]))
+    pushContext(new Map([[ctx.id, 3]]))
+    expect(useContext(ctx)).toBe(3)
+    popContext()
+    expect(useContext(ctx)).toBe(2)
+    popContext()
+    expect(useContext(ctx)).toBe(1)
+    popContext()
+    expect(useContext(ctx)).toBe(0) // default
+  })
+
+  test("popContext on empty stack warns in dev mode", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    popContext()
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("popContext() called on an empty context stack"),
+    )
+    warnSpy.mockRestore()
+  })
+})
+
+describe("withContext", () => {
+  test("provides value during callback execution", () => {
+    const ctx = createContext("default")
+    let captured = ""
+    withContext(ctx, "inside", () => {
+      captured = useContext(ctx)
+    })
+    expect(captured).toBe("inside")
+    // After withContext, should be back to default
+    expect(useContext(ctx)).toBe("default")
+  })
+
+  test("restores stack on normal completion", () => {
+    const ctx = createContext("default")
+    withContext(ctx, "temp", () => {
+      expect(useContext(ctx)).toBe("temp")
+    })
+    expect(useContext(ctx)).toBe("default")
+  })
+
+  test("restores stack even when callback throws", () => {
+    const ctx = createContext("safe")
+    try {
+      withContext(ctx, "dangerous", () => {
+        expect(useContext(ctx)).toBe("dangerous")
+        throw new Error("boom")
+      })
+    } catch {
+      // expected
+    }
+    expect(useContext(ctx)).toBe("safe")
+  })
+
+  test("nested withContext calls", () => {
+    const ctx = createContext(0)
+    withContext(ctx, 1, () => {
+      expect(useContext(ctx)).toBe(1)
+      withContext(ctx, 2, () => {
+        expect(useContext(ctx)).toBe(2)
+        withContext(ctx, 3, () => {
+          expect(useContext(ctx)).toBe(3)
+        })
+        expect(useContext(ctx)).toBe(2)
+      })
+      expect(useContext(ctx)).toBe(1)
+    })
+    expect(useContext(ctx)).toBe(0)
+  })
+
+  test("multiple contexts in nested withContext", () => {
+    const theme = createContext("light")
+    const lang = createContext("en")
+
+    withContext(theme, "dark", () => {
+      withContext(lang, "fr", () => {
+        expect(useContext(theme)).toBe("dark")
+        expect(useContext(lang)).toBe("fr")
+      })
+      expect(useContext(lang)).toBe("en")
+    })
+    expect(useContext(theme)).toBe("light")
+  })
+})
+
+describe("provide", () => {
+  test("pushes context and registers unmount cleanup", () => {
+    const ctx = createContext("default")
+    const { hooks } = runWithHooks(
+      (() => {
+        provide(ctx, "provided-value")
+        expect(useContext(ctx)).toBe("provided-value")
+        return null
+      }) as ComponentFn,
+      {} as Props,
+    )
+    // Context should still be available after runWithHooks
+    expect(useContext(ctx)).toBe("provided-value")
+    // unmount hooks should include the popContext cleanup
+    expect(hooks.unmount.length).toBeGreaterThanOrEqual(1)
+    // Running unmount cleans up
+    for (const fn of hooks.unmount) fn()
+    expect(useContext(ctx)).toBe("default")
+  })
+
+  test("multiple provides in same component", () => {
+    const ctxA = createContext("a")
+    const ctxB = createContext("b")
+    const { hooks } = runWithHooks(
+      (() => {
+        provide(ctxA, "A-value")
+        provide(ctxB, "B-value")
+        return null
+      }) as ComponentFn,
+      {} as Props,
+    )
+    expect(useContext(ctxA)).toBe("A-value")
+    expect(useContext(ctxB)).toBe("B-value")
+    // Clean up
+    for (const fn of hooks.unmount) fn()
+    expect(useContext(ctxA)).toBe("a")
+    expect(useContext(ctxB)).toBe("b")
+  })
+})
+
+describe("setContextStackProvider", () => {
+  test("overrides the stack provider", () => {
+    const customStack: Map<symbol, unknown>[] = []
+    const ctx = createContext("default")
+
+    setContextStackProvider(() => customStack)
+
+    customStack.push(new Map([[ctx.id, "custom"]]))
+    expect(useContext(ctx)).toBe("custom")
+    customStack.pop()
+    expect(useContext(ctx)).toBe("default")
+
+    // Restore default provider
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+
+  test("different providers see different stacks", () => {
+    const ctx = createContext("default")
+    const stack1: Map<symbol, unknown>[] = []
+    const stack2: Map<symbol, unknown>[] = []
+
+    setContextStackProvider(() => stack1)
+    pushContext(new Map([[ctx.id, "stack1-value"]]))
+    expect(useContext(ctx)).toBe("stack1-value")
+
+    // Switch to stack2 — should not see stack1's value
+    setContextStackProvider(() => stack2)
+    expect(useContext(ctx)).toBe("default")
+
+    // Clean up
+    setContextStackProvider(() => stack1)
+    popContext()
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+})

package/src/tests/dynamic.test.ts

@@ -0,0 +1,55 @@
+import { Dynamic } from "../dynamic"
+import { h } from "../h"
+import type { ComponentFn, VNode } from "../types"
+
+describe("Dynamic", () => {
+  test("renders component function", () => {
+    const Greeting: ComponentFn = (props) => h("span", null, (props as { name: string }).name)
+    const result = Dynamic({ component: Greeting, name: "world" })
+    expect(result).not.toBeNull()
+    expect((result as VNode).type).toBe(Greeting)
+    expect((result as VNode).props).toEqual({ name: "world" })
+  })
+
+  test("renders string element", () => {
+    const result = Dynamic({ component: "div", class: "box", id: "main" })
+    expect(result).not.toBeNull()
+    expect((result as VNode).type).toBe("div")
+    expect((result as VNode).props).toEqual({ class: "box", id: "main" })
+  })
+
+  test("strips component prop from rest props", () => {
+    const result = Dynamic({ component: "span", id: "x" })
+    expect((result as VNode).props.component).toBeUndefined()
+    expect((result as VNode).props.id).toBe("x")
+  })
+
+  test("returns null for empty string component", () => {
+    const result = Dynamic({ component: "" })
+    expect(result).toBeNull()
+  })
+
+  test("warns when component prop is falsy", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    Dynamic({ component: "" })
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<Dynamic>"))
+    warnSpy.mockRestore()
+  })
+
+  test("passes all extra props to the rendered component", () => {
+    const Comp: ComponentFn = (props) => h("div", null, JSON.stringify(props))
+    const result = Dynamic({
+      component: Comp,
+      a: 1,
+      b: "two",
+      c: true,
+    })
+    expect((result as VNode).props).toEqual({ a: 1, b: "two", c: true })
+  })
+
+  test("renders with no extra props", () => {
+    const result = Dynamic({ component: "br" })
+    expect(result).not.toBeNull()
+    expect((result as VNode).type).toBe("br")
+  })
+})