@pyreon/core 0.11.4 → 0.11.6

package/src/style.ts

@@ -3,50 +3,50 @@
 // CSS properties where numeric values are unitless (e.g. `opacity: 0.5`, `zIndex: 10`).
 // All other numeric values get "px" appended automatically (e.g. `height: 100` → `"100px"`).
 export const CSS_UNITLESS = new Set([
-  "animationIterationCount",
-  "aspectRatio",
-  "borderImageOutset",
-  "borderImageSlice",
-  "borderImageWidth",
-  "boxFlex",
-  "boxFlexGroup",
-  "boxOrdinalGroup",
-  "columnCount",
-  "columns",
-  "flex",
-  "flexGrow",
-  "flexPositive",
-  "flexShrink",
-  "flexNegative",
-  "flexOrder",
-  "gridArea",
-  "gridRow",
-  "gridRowEnd",
-  "gridRowSpan",
-  "gridRowStart",
-  "gridColumn",
-  "gridColumnEnd",
-  "gridColumnSpan",
-  "gridColumnStart",
-  "fontWeight",
-  "lineClamp",
-  "lineHeight",
-  "opacity",
-  "order",
-  "orphans",
-  "scale",
-  "tabSize",
-  "widows",
-  "zIndex",
-  "zoom",
-  "fillOpacity",
-  "floodOpacity",
-  "stopOpacity",
-  "strokeDasharray",
-  "strokeDashoffset",
-  "strokeMiterlimit",
-  "strokeOpacity",
-  "strokeWidth",
+  'animationIterationCount',
+  'aspectRatio',
+  'borderImageOutset',
+  'borderImageSlice',
+  'borderImageWidth',
+  'boxFlex',
+  'boxFlexGroup',
+  'boxOrdinalGroup',
+  'columnCount',
+  'columns',
+  'flex',
+  'flexGrow',
+  'flexPositive',
+  'flexShrink',
+  'flexNegative',
+  'flexOrder',
+  'gridArea',
+  'gridRow',
+  'gridRowEnd',
+  'gridRowSpan',
+  'gridRowStart',
+  'gridColumn',
+  'gridColumnEnd',
+  'gridColumnSpan',
+  'gridColumnStart',
+  'fontWeight',
+  'lineClamp',
+  'lineHeight',
+  'opacity',
+  'order',
+  'orphans',
+  'scale',
+  'tabSize',
+  'widows',
+  'zIndex',
+  'zoom',
+  'fillOpacity',
+  'floodOpacity',
+  'stopOpacity',
+  'strokeDasharray',
+  'strokeDashoffset',
+  'strokeMiterlimit',
+  'strokeOpacity',
+  'strokeWidth',
 ])
 
 // ─── Class utilities ─────────────────────────────────────────────────────────
@@ -62,17 +62,17 @@ export type ClassValue =
   | Record<string, boolean | null | undefined | (() => boolean)>
 
 function cxObject(obj: Record<string, boolean | null | undefined | (() => boolean)>): string {
-  let result = ""
+  let result = ''
   for (const key in obj) {
     const v = obj[key]
-    const truthy = typeof v === "function" ? v() : v
+    const truthy = typeof v === 'function' ? v() : v
     if (truthy) result = result ? `${result} ${key}` : key
   }
   return result
 }
 
 function cxArray(arr: ClassValue[]): string {
-  let result = ""
+  let result = ''
   for (const item of arr) {
     const resolved = cx(item)
     if (resolved) result = result ? `${result} ${resolved}` : resolved
@@ -82,9 +82,9 @@ function cxArray(arr: ClassValue[]): string {
 
 /** Resolve a ClassValue into a flat class string (like clsx/cx). */
 export function cx(value: ClassValue): string {
-  if (value == null || value === false || value === true) return ""
-  if (typeof value === "string") return value
-  if (typeof value === "number") return String(value)
+  if (value == null || value === false || value === true) return ''
+  if (typeof value === 'string') return value
+  if (typeof value === 'number') return String(value)
   if (Array.isArray(value)) return cxArray(value)
   return cxObject(value)
 }
@@ -98,5 +98,5 @@ export function toKebabCase(str: string): string {
 
 /** Normalize a style value — appends "px" to numbers for non-unitless properties. */
 export function normalizeStyleValue(key: string, value: unknown): string {
-  return typeof value === "number" && !CSS_UNITLESS.has(key) ? `${value}px` : String(value)
+  return typeof value === 'number' && !CSS_UNITLESS.has(key) ? `${value}px` : String(value)
 }

package/src/suspense.ts

@@ -1,7 +1,7 @@
-import { Fragment, h } from "./h"
-import type { Props, VNode, VNodeChild } from "./types"
+import { Fragment, h } from './h'
+import type { Props, VNode, VNodeChild } from './types'
 
-const __DEV__ = typeof process !== "undefined" && process.env.NODE_ENV !== "production"
+const __DEV__ = typeof process !== 'undefined' && process.env.NODE_ENV !== 'production'
 
 /** Internal marker attached to lazy()-wrapped components */
 export type LazyComponent<P extends Props = Props> = ((props: P) => VNodeChild) & {
@@ -25,25 +25,25 @@ export function Suspense(props: { fallback: VNodeChild; children?: VNodeChild })
   if (__DEV__ && props.fallback === undefined) {
     // biome-ignore lint/suspicious/noConsole: dev-only warning
     console.warn(
-      "[Pyreon] <Suspense> is missing a `fallback` prop. Provide fallback UI to show while loading.",
+      '[Pyreon] <Suspense> is missing a `fallback` prop. Provide fallback UI to show while loading.',
     )
   }
 
   return h(Fragment, null, () => {
     const ch = props.children
-    const childNode = typeof ch === "function" ? ch() : ch
+    const childNode = typeof ch === 'function' ? ch() : ch
 
     // Check if the child is a VNode whose type is a lazy component still loading
     const isLoading =
       childNode != null &&
-      typeof childNode === "object" &&
+      typeof childNode === 'object' &&
       !Array.isArray(childNode) &&
-      typeof (childNode as VNode).type === "function" &&
+      typeof (childNode as VNode).type === 'function' &&
       ((childNode as VNode).type as unknown as LazyComponent).__loading?.()
 
     if (isLoading) {
       const fb = props.fallback
-      return typeof fb === "function" ? fb() : fb
+      return typeof fb === 'function' ? fb() : fb
     }
     return childNode
   })

package/src/telemetry.ts

@@ -16,7 +16,7 @@ export interface ErrorContext {
   /** Component function name, or "Anonymous" */
   component: string
   /** Lifecycle phase where the error occurred */
-  phase: "setup" | "render" | "mount" | "unmount" | "effect"
+  phase: 'setup' | 'render' | 'mount' | 'unmount' | 'effect'
   /** The thrown value */
   error: unknown
   /** Unix timestamp (ms) */

package/src/tests/component.test.ts

@@ -5,28 +5,28 @@ import {
   propagateError,
   pushErrorBoundary,
   runWithHooks,
-} from "../component"
-import { h } from "../h"
-import { onErrorCaptured, onMount, onUnmount, onUpdate } from "../lifecycle"
-import type { ComponentFn, LifecycleHooks, VNode } from "../types"
+} 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)
+describe('defineComponent', () => {
+  test('returns the exact same function (identity)', () => {
+    const fn: ComponentFn = () => h('div', null)
     expect(defineComponent(fn)).toBe(fn)
   })
 
-  test("preserves typed props", () => {
+  test('preserves typed props', () => {
     const Comp = defineComponent<{ count: number }>((props) => {
-      return h("span", null, String(props.count))
+      return h('span', null, String(props.count))
     })
     const node = Comp({ count: 10 })
-    expect((node as VNode).type).toBe("span")
+    expect((node as VNode).type).toBe('span')
   })
 })
 
-describe("runWithHooks", () => {
-  test("captures all lifecycle hook types", () => {
+describe('runWithHooks', () => {
+  test('captures all lifecycle hook types', () => {
     const mountFn = () => undefined
     const unmountFn = () => {}
     const updateFn = () => {}
@@ -37,7 +37,7 @@ describe("runWithHooks", () => {
       onUnmount(unmountFn)
       onUpdate(updateFn)
       onErrorCaptured(errorFn)
-      return h("div", null)
+      return h('div', null)
     }
 
     const { vnode, hooks } = runWithHooks(Comp, {})
@@ -48,51 +48,51 @@ describe("runWithHooks", () => {
     expect(hooks.error).toContain(errorFn)
   })
 
-  test("returns null vnode for component returning null", () => {
+  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('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)
+  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(() => {})
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onMount(() => {})
     expect(warnSpy).toHaveBeenCalled()
     warnSpy.mockRestore()
   })
 
-  test("clears hooks context even when component throws", () => {
+  test('clears hooks context even when component throws', () => {
     const Comp: ComponentFn = () => {
-      throw new Error("boom")
+      throw new Error('boom')
     }
-    expect(() => runWithHooks(Comp, {})).toThrow("boom")
+    expect(() => runWithHooks(Comp, {})).toThrow('boom')
     // Should still be cleared
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onMount(() => {})
     expect(warnSpy).toHaveBeenCalled()
     warnSpy.mockRestore()
   })
 
-  test("passes props to component function", () => {
+  test('passes props to component function', () => {
     let received: unknown = null
     runWithHooks(
       ((props: { msg: string }) => {
         received = props
         return null
       }) as ComponentFn,
-      { msg: "hello" },
+      { msg: 'hello' },
     )
-    expect(received).toEqual({ msg: "hello" })
+    expect(received).toEqual({ msg: 'hello' })
   })
 
-  test("captures multiple hooks of same type", () => {
+  test('captures multiple hooks of same type', () => {
     const Comp: ComponentFn = () => {
       onMount(() => undefined)
       onMount(() => undefined)
@@ -105,8 +105,8 @@ describe("runWithHooks", () => {
     expect(hooks.unmount).toHaveLength(2)
   })
 
-  test("empty hooks when component registers none", () => {
-    const { hooks } = runWithHooks(() => h("div", null), {})
+  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)
@@ -114,38 +114,38 @@ describe("runWithHooks", () => {
   })
 })
 
-describe("propagateError", () => {
-  test("returns true when handler returns true", () => {
+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)
+    expect(propagateError(new Error('test'), hooks)).toBe(true)
   })
 
-  test("returns false when no handlers", () => {
+  test('returns false when no handlers', () => {
     const hooks: LifecycleHooks = {
       mount: [],
       unmount: [],
       update: [],
       error: [],
     }
-    expect(propagateError(new Error("test"), hooks)).toBe(false)
+    expect(propagateError(new Error('test'), hooks)).toBe(false)
   })
 
-  test("returns false when handler returns undefined", () => {
+  test('returns false when handler returns undefined', () => {
     const hooks: LifecycleHooks = {
       mount: [],
       unmount: [],
       update: [],
       error: [() => undefined],
     }
-    expect(propagateError(new Error("test"), hooks)).toBe(false)
+    expect(propagateError(new Error('test'), hooks)).toBe(false)
   })
 
-  test("stops at first handler returning true", () => {
+  test('stops at first handler returning true', () => {
     let secondCalled = false
     const hooks: LifecycleHooks = {
       mount: [],
@@ -159,11 +159,11 @@ describe("propagateError", () => {
         },
       ],
     }
-    expect(propagateError("err", hooks)).toBe(true)
+    expect(propagateError('err', hooks)).toBe(true)
     expect(secondCalled).toBe(false)
   })
 
-  test("continues to next handler when first returns undefined", () => {
+  test('continues to next handler when first returns undefined', () => {
     const calls: number[] = []
     const hooks: LifecycleHooks = {
       mount: [],
@@ -180,11 +180,11 @@ describe("propagateError", () => {
         },
       ],
     }
-    expect(propagateError("err", hooks)).toBe(true)
+    expect(propagateError('err', hooks)).toBe(true)
     expect(calls).toEqual([1, 2])
   })
 
-  test("passes the error to each handler", () => {
+  test('passes the error to each handler', () => {
     const errors: unknown[] = []
     const hooks: LifecycleHooks = {
       mount: [],
@@ -201,37 +201,37 @@ describe("propagateError", () => {
         },
       ],
     }
-    const testErr = new Error("propagated")
+    const testErr = new Error('propagated')
     propagateError(testErr, hooks)
     expect(errors).toEqual([testErr, testErr])
   })
 })
 
-describe("pushErrorBoundary / popErrorBoundary / dispatchToErrorBoundary", () => {
+describe('pushErrorBoundary / popErrorBoundary / dispatchToErrorBoundary', () => {
   afterEach(() => {
     // Clean up any leftover boundaries — pop until empty
     // dispatchToErrorBoundary returns false when stack is empty
-    while (dispatchToErrorBoundary("cleanup-probe")) {
+    while (dispatchToErrorBoundary('cleanup-probe')) {
       popErrorBoundary()
     }
   })
 
-  test("dispatches to the most recently pushed boundary", () => {
+  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")
+    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('returns false when no boundary is registered', () => {
+    expect(dispatchToErrorBoundary('no-boundary')).toBe(false)
   })
 
-  test("nested boundaries — innermost catches first", () => {
+  test('nested boundaries — innermost catches first', () => {
     const caught: string[] = []
     pushErrorBoundary((err) => {
       caught.push(`outer: ${err}`)
@@ -241,17 +241,17 @@ describe("pushErrorBoundary / popErrorBoundary / dispatchToErrorBoundary", () =>
       caught.push(`inner: ${err}`)
       return true
     })
-    dispatchToErrorBoundary("test")
-    expect(caught).toEqual(["inner: test"])
+    dispatchToErrorBoundary('test')
+    expect(caught).toEqual(['inner: test'])
     popErrorBoundary()
 
     // After popping inner, outer should catch
-    dispatchToErrorBoundary("test2")
-    expect(caught).toEqual(["inner: test", "outer: test2"])
+    dispatchToErrorBoundary('test2')
+    expect(caught).toEqual(['inner: test', 'outer: test2'])
     popErrorBoundary()
   })
 
-  test("boundary handler returning false does not propagate to outer", () => {
+  test('boundary handler returning false does not propagate to outer', () => {
     // dispatchToErrorBoundary only calls the innermost handler
     let outerCalled = false
     pushErrorBoundary(() => {
@@ -259,23 +259,23 @@ describe("pushErrorBoundary / popErrorBoundary / dispatchToErrorBoundary", () =>
       return true
     })
     pushErrorBoundary(() => false)
-    const result = dispatchToErrorBoundary("test")
+    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", () => {
+  test('push and pop maintain stack correctly', () => {
     const results: boolean[] = []
     pushErrorBoundary(() => true)
     pushErrorBoundary(() => true)
     pushErrorBoundary(() => true)
     popErrorBoundary()
     popErrorBoundary()
-    results.push(dispatchToErrorBoundary("x"))
+    results.push(dispatchToErrorBoundary('x'))
     popErrorBoundary()
-    results.push(dispatchToErrorBoundary("y"))
+    results.push(dispatchToErrorBoundary('y'))
     expect(results).toEqual([true, false])
   })
 })