@pyreon/core 0.11.4 → 0.11.6

package/src/tests/cx.test.ts

@@ -1,45 +1,45 @@
-import { cx } from "../style"
+import { cx } from '../style'
 
-describe("cx", () => {
-  test("returns empty string for falsy values", () => {
-    expect(cx(null)).toBe("")
-    expect(cx(undefined)).toBe("")
-    expect(cx(false)).toBe("")
-    expect(cx(true)).toBe("")
+describe('cx', () => {
+  test('returns empty string for falsy values', () => {
+    expect(cx(null)).toBe('')
+    expect(cx(undefined)).toBe('')
+    expect(cx(false)).toBe('')
+    expect(cx(true)).toBe('')
   })
 
-  test("passes through strings", () => {
-    expect(cx("foo bar")).toBe("foo bar")
+  test('passes through strings', () => {
+    expect(cx('foo bar')).toBe('foo bar')
   })
 
-  test("converts numbers to strings", () => {
-    expect(cx(42)).toBe("42")
+  test('converts numbers to strings', () => {
+    expect(cx(42)).toBe('42')
   })
 
-  test("filters and joins arrays", () => {
-    expect(cx(["foo", false, "bar", null, "baz"])).toBe("foo bar baz")
+  test('filters and joins arrays', () => {
+    expect(cx(['foo', false, 'bar', null, 'baz'])).toBe('foo bar baz')
   })
 
-  test("resolves object keys with truthy values", () => {
-    expect(cx({ active: true, hidden: false, bold: true })).toBe("active bold")
+  test('resolves object keys with truthy values', () => {
+    expect(cx({ active: true, hidden: false, bold: true })).toBe('active bold')
   })
 
-  test("resolves object values that are functions", () => {
-    expect(cx({ active: () => true, hidden: () => false })).toBe("active")
+  test('resolves object values that are functions', () => {
+    expect(cx({ active: () => true, hidden: () => false })).toBe('active')
   })
 
-  test("handles nested arrays and objects", () => {
-    expect(cx(["base", { active: true }, ["nested", { deep: true }]])).toBe(
-      "base active nested deep",
+  test('handles nested arrays and objects', () => {
+    expect(cx(['base', { active: true }, ['nested', { deep: true }]])).toBe(
+      'base active nested deep',
     )
   })
 
-  test("handles empty inputs", () => {
-    expect(cx([])).toBe("")
-    expect(cx({})).toBe("")
+  test('handles empty inputs', () => {
+    expect(cx([])).toBe('')
+    expect(cx({})).toBe('')
   })
 
-  test("object where ALL values are functions returning booleans", () => {
+  test('object where ALL values are functions returning booleans', () => {
     expect(
       cx({
         active: () => true,
@@ -47,24 +47,24 @@ describe("cx", () => {
         bold: () => true,
         italic: () => false,
       }),
-    ).toBe("active bold")
+    ).toBe('active bold')
   })
 
-  test("deeply nested arrays (3+ levels)", () => {
-    expect(cx([[["level3", [["level5"]]]]])).toBe("level3 level5")
+  test('deeply nested arrays (3+ levels)', () => {
+    expect(cx([[['level3', [['level5']]]]])).toBe('level3 level5')
   })
 
-  test("mixed: string, object with function, deeply nested array", () => {
-    expect(cx(["base", { active: () => true }, [["deeply-nested"]]])).toBe(
-      "base active deeply-nested",
+  test('mixed: string, object with function, deeply nested array', () => {
+    expect(cx(['base', { active: () => true }, [['deeply-nested']]])).toBe(
+      'base active deeply-nested',
     )
   })
 
-  test("empty string values are filtered", () => {
-    expect(cx(["foo", "", "bar", ""])).toBe("foo bar")
+  test('empty string values are filtered', () => {
+    expect(cx(['foo', '', 'bar', ''])).toBe('foo bar')
   })
 
-  test("number 0 is a valid class name as string", () => {
-    expect(cx(0)).toBe("0")
+  test('number 0 is a valid class name as string', () => {
+    expect(cx(0)).toBe('0')
   })
 })

package/src/tests/dynamic.test.ts

@@ -1,55 +1,55 @@
-import { Dynamic } from "../dynamic"
-import { h } from "../h"
-import type { ComponentFn, VNode } from "../types"
+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" })
+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" })
+    expect((result as VNode).props).toEqual({ name: 'world' })
   })
 
-  test("renders string element", () => {
-    const result = Dynamic({ component: "div", class: "box", id: "main" })
+  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" })
+    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" })
+  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")
+    expect((result as VNode).props.id).toBe('x')
   })
 
-  test("returns null for empty string component", () => {
-    const result = Dynamic({ component: "" })
+  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>"))
+  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))
+  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",
+      b: 'two',
       c: true,
     })
-    expect((result as VNode).props).toEqual({ 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" })
+  test('renders with no extra props', () => {
+    const result = Dynamic({ component: 'br' })
     expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe("br")
+    expect((result as VNode).type).toBe('br')
   })
 })

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

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

package/src/tests/for.test.ts

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