@pyreon/core 0.11.4 → 0.11.6

package/src/tests/h.test.ts

@@ -1,200 +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")
+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('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)
+    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")
+  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 })
+    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" })
+    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)
+    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 })
+    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"])
+  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('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)
+    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)
+    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")
+      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)
+    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[0]).toBe('text')
       expect(node.children[1]).toBe(42)
-      expect((node.children[2] as VNode).type).toBe("em")
+      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")
+      expect(typeof node.children[7]).toBe('function')
     })
 
-    test("function children (reactive getters) are preserved", () => {
-      const getter = () => "dynamic"
-      const node = h("div", null, getter)
+    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")
+      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)
+    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")])
+  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")
+      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 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('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", () => {
+    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"])
+      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"])
+    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" })
+  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")
+      expect(node.props.name).toBe('test')
     })
 
-    test("component with no props", () => {
-      const Comp: ComponentFn = () => h("div", null)
+    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", () => {
+    test('component with children rest args', () => {
       const Comp: ComponentFn = () => null
-      const node = h(Comp, { id: "x" }, "child1", "child2")
-      expect(node.children).toEqual(["child1", "child2"])
+      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")
+  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"])
+      expect(node.children).toEqual(['a', 'b'])
     })
 
-    test("Fragment with VNode children", () => {
-      const node = h(Fragment, null, h("span", null, "x"), h("em", null, "y"))
+    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")
+    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")
+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)
+  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")
+describe('Fragment', () => {
+  test('is a unique symbol', () => {
+    expect(typeof Fragment).toBe('symbol')
+    expect(Fragment.toString()).toContain('Pyreon.Fragment')
   })
 })

package/src/tests/jsx-compat.test.tsx

@@ -3,84 +3,84 @@
  * Uses h() directly since core's vitest config doesn't have JSX transform.
  * TypeScript already validates JSX types via typecheck (tsc --noEmit).
  */
-import { createRef, Fragment, h } from "../index"
+import { createRef, Fragment, h } from '../index'
 
-describe("JSX type compat (via h)", () => {
-  test("basic element", () => {
-    const el = h("div", { class: "hello" }, "world")
-    expect(el.type).toBe("div")
-    expect(el.props.class).toBe("hello")
+describe('JSX type compat (via h)', () => {
+  test('basic element', () => {
+    const el = h('div', { class: 'hello' }, 'world')
+    expect(el.type).toBe('div')
+    expect(el.props.class).toBe('hello')
   })
 
-  test("callback ref", () => {
+  test('callback ref', () => {
     let _captured: Element | null = null
     const el = h(
-      "div",
+      'div',
       {
         ref: (e: Element) => {
           _captured = e
         },
       },
-      "test",
+      'test',
     )
-    expect(typeof el.props.ref).toBe("function")
+    expect(typeof el.props.ref).toBe('function')
   })
 
-  test("object ref", () => {
+  test('object ref', () => {
     const myRef = createRef<HTMLDivElement>()
-    const el = h("div", { ref: myRef }, "test")
+    const el = h('div', { ref: myRef }, 'test')
     expect(el.props.ref).toBe(myRef)
   })
 
-  test("reactive class prop", () => {
-    const el = h("span", { class: () => "active" }, "hello")
-    expect(typeof el.props.class).toBe("function")
+  test('reactive class prop', () => {
+    const el = h('span', { class: () => 'active' }, 'hello')
+    expect(typeof el.props.class).toBe('function')
   })
 
-  test("input with typed props", () => {
-    const el = h("input", { type: "text", value: "test" })
-    expect(el.type).toBe("input")
-    expect(el.props.type).toBe("text")
+  test('input with typed props', () => {
+    const el = h('input', { type: 'text', value: 'test' })
+    expect(el.type).toBe('input')
+    expect(el.props.type).toBe('text')
   })
 
-  test("component with children", () => {
+  test('component with children', () => {
     const MyComp = (props: { name: string; children?: unknown }) => {
-      return h("div", null, String(props.name))
+      return h('div', null, String(props.name))
     }
-    const el = h(MyComp, { name: "test" }, "child")
-    expect(typeof el.type).toBe("function")
-    expect(el.props.name).toBe("test")
+    const el = h(MyComp, { name: 'test' }, 'child')
+    expect(typeof el.type).toBe('function')
+    expect(el.props.name).toBe('test')
   })
 
-  test("fragment", () => {
-    const el = h(Fragment, null, "fragment")
+  test('fragment', () => {
+    const el = h(Fragment, null, 'fragment')
     expect(el.type).toBe(Fragment)
   })
 
-  test("event handler", () => {
+  test('event handler', () => {
     const handler = vi.fn()
-    const el = h("button", { onClick: handler }, "click")
+    const el = h('button', { onClick: handler }, 'click')
     expect(el.props.onClick).toBe(handler)
   })
 
-  test("style as object", () => {
-    const el = h("div", { style: { color: "red" } }, "styled")
-    expect(el.props.style).toEqual({ color: "red" })
+  test('style as object', () => {
+    const el = h('div', { style: { color: 'red' } }, 'styled')
+    expect(el.props.style).toEqual({ color: 'red' })
   })
 
-  test("data attributes", () => {
-    const el = h("div", { "data-testid": "foo" }, "test")
-    expect(el.props["data-testid"]).toBe("foo")
+  test('data attributes', () => {
+    const el = h('div', { 'data-testid': 'foo' }, 'test')
+    expect(el.props['data-testid']).toBe('foo')
   })
 
-  test("aria attributes", () => {
-    const el = h("div", { "aria-label": "close", role: "button" })
-    expect(el.props["aria-label"]).toBe("close")
-    expect(el.props.role).toBe("button")
+  test('aria attributes', () => {
+    const el = h('div', { 'aria-label': 'close', role: 'button' })
+    expect(el.props['aria-label']).toBe('close')
+    expect(el.props.role).toBe('button')
   })
 
-  test("key prop", () => {
-    const el = h("li", { key: "item-1" }, "item")
-    expect(el.key).toBe("item-1")
+  test('key prop', () => {
+    const el = h('li', { key: 'item-1' }, 'item')
+    expect(el.key).toBe('item-1')
   })
 })

package/src/tests/lazy.test.ts

@@ -1,65 +1,65 @@
-import { h } from "../h"
-import { lazy } from "../lazy"
-import type { ComponentFn, Props, VNode } from "../types"
+import { h } from '../h'
+import { lazy } from '../lazy'
+import type { ComponentFn, Props, VNode } from '../types'
 
-describe("lazy", () => {
-  test("returns a LazyComponent with __loading flag", () => {
+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(typeof Comp).toBe('function')
+    expect(typeof Comp.__loading).toBe('function')
     expect(Comp.__loading()).toBe(true)
   })
 
-  test("__loading returns true while loading", () => {
+  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)", () => {
+  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)
+  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" })
+    const result = Comp({ name: 'test' })
     expect(result).not.toBeNull()
     expect((result as VNode).type).toBe(Inner)
-    expect((result as VNode).props).toEqual({ name: "test" })
+    expect((result as VNode).props).toEqual({ name: 'test' })
   })
 
-  test("throws on import error", async () => {
-    const Comp = lazy<Props>(() => Promise.reject(new Error("load failed")))
+  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")
+    expect(() => Comp({})).toThrow('load failed')
   })
 
-  test("wraps non-Error rejection in Error", async () => {
-    const Comp = lazy<Props>(() => Promise.reject("string-error"))
+  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")
+    expect(() => Comp({})).toThrow('string-error')
   })
 
-  test("wraps numeric rejection in Error", async () => {
+  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")
+    expect(() => Comp({})).toThrow('404')
   })
 
-  test("__loading is false after successful load", async () => {
+  test('__loading is false after successful load', async () => {
     const Inner: ComponentFn = () => null
     const Comp = lazy(() => Promise.resolve({ default: Inner }))
 
@@ -68,16 +68,16 @@ describe("lazy", () => {
     expect(Comp.__loading()).toBe(false)
   })
 
-  test("__loading is false after failed load", async () => {
-    const Comp = lazy<Props>(() => Promise.reject(new Error("fail")))
+  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")
+  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))
@@ -88,8 +88,8 @@ describe("lazy", () => {
     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))
+  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))