@pyreon/core 0.11.4 → 0.11.6

package/src/tests/suspense.test.ts

@@ -1,49 +1,49 @@
-import { Fragment, h } from "../h"
-import { Suspense } from "../suspense"
-import type { ComponentFn, VNodeChild } from "../types"
+import { Fragment, h } from '../h'
+import { Suspense } from '../suspense'
+import type { ComponentFn, VNodeChild } from '../types'
 
-describe("Suspense", () => {
-  test("returns a Fragment VNode", () => {
+describe('Suspense', () => {
+  test('returns a Fragment VNode', () => {
     const node = Suspense({
-      fallback: h("div", null, "loading"),
-      children: h("div", null, "content"),
+      fallback: h('div', null, 'loading'),
+      children: h('div', null, 'content'),
     })
     expect(node.type).toBe(Fragment)
   })
 
-  test("Fragment contains a single reactive getter child", () => {
+  test('Fragment contains a single reactive getter child', () => {
     const node = Suspense({
-      fallback: h("span", null, "loading"),
-      children: h("div", null, "content"),
+      fallback: h('span', null, 'loading'),
+      children: h('div', null, 'content'),
     })
     expect(node.children).toHaveLength(1)
-    expect(typeof node.children[0]).toBe("function")
+    expect(typeof node.children[0]).toBe('function')
   })
 
-  test("renders children when not loading (plain VNode)", () => {
-    const child = h("div", null, "loaded")
+  test('renders children when not loading (plain VNode)', () => {
+    const child = h('div', null, 'loaded')
     const node = Suspense({
-      fallback: h("span", null, "loading"),
+      fallback: h('span', null, 'loading'),
       children: child,
     })
     const getter = node.children[0] as () => VNodeChild
     expect(getter()).toBe(child)
   })
 
-  test("renders children when child type has no __loading", () => {
-    const regularComp: ComponentFn = () => h("div", null)
+  test('renders children when child type has no __loading', () => {
+    const regularComp: ComponentFn = () => h('div', null)
     const child = h(regularComp, null)
     const node = Suspense({
-      fallback: "loading",
+      fallback: 'loading',
       children: child,
     })
     const getter = node.children[0] as () => VNodeChild
     expect(getter()).toBe(child)
   })
 
-  test("renders fallback when child __loading() is true", () => {
-    const fallback = h("span", null, "loading...")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & {
+  test('renders fallback when child __loading() is true', () => {
+    const fallback = h('span', null, 'loading...')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
       __loading: () => boolean
     }
     lazyFn.__loading = () => true
@@ -54,9 +54,9 @@ describe("Suspense", () => {
     expect(getter()).toBe(fallback)
   })
 
-  test("renders children when __loading() is false", () => {
-    const fallback = h("span", null, "loading...")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & {
+  test('renders children when __loading() is false', () => {
+    const fallback = h('span', null, 'loading...')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
       __loading: () => boolean
     }
     lazyFn.__loading = () => false
@@ -67,19 +67,19 @@ describe("Suspense", () => {
     expect(getter()).toBe(child)
   })
 
-  test("handles function children (reactive getter)", () => {
-    const child = h("div", null, "content")
+  test('handles function children (reactive getter)', () => {
+    const child = h('div', null, 'content')
     const node = Suspense({
-      fallback: h("span", null, "loading"),
+      fallback: h('span', null, 'loading'),
       children: () => child,
     })
     const getter = node.children[0] as () => VNodeChild
     expect(getter()).toBe(child)
   })
 
-  test("evaluates function fallback", () => {
-    const fbNode = h("div", null, "fb")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & {
+  test('evaluates function fallback', () => {
+    const fbNode = h('div', null, 'fb')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
       __loading: () => boolean
     }
     lazyFn.__loading = () => true
@@ -90,44 +90,44 @@ describe("Suspense", () => {
     expect(getter()).toBe(fbNode)
   })
 
-  test("handles null/undefined children", () => {
-    const node = Suspense({ fallback: "loading" })
+  test('handles null/undefined children', () => {
+    const node = Suspense({ fallback: 'loading' })
     const getter = node.children[0] as () => VNodeChild
     // undefined children — not a VNode, not loading
     expect(getter()).toBeUndefined()
   })
 
-  test("handles string children", () => {
-    const node = Suspense({ fallback: "loading", children: "text content" })
+  test('handles string children', () => {
+    const node = Suspense({ fallback: 'loading', children: 'text content' })
     const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe("text content")
+    expect(getter()).toBe('text content')
   })
 
-  test("handles array children (not loading)", () => {
-    const children = [h("a", null), h("b", null)]
+  test('handles array children (not loading)', () => {
+    const children = [h('a', null), h('b', null)]
     const node = Suspense({
-      fallback: "loading",
+      fallback: 'loading',
       children: children as unknown as VNodeChild,
     })
     const getter = node.children[0] as () => VNodeChild
     expect(getter()).toBe(children)
   })
 
-  test("warns when fallback prop is missing", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
-    Suspense({ fallback: undefined as unknown as VNodeChild, children: "x" })
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<Suspense>"))
+  test('warns when fallback prop is missing', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    Suspense({ fallback: undefined as unknown as VNodeChild, children: 'x' })
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<Suspense>'))
     warnSpy.mockRestore()
   })
 
-  test("transition from loading to loaded", () => {
+  test('transition from loading to loaded', () => {
     let isLoading = true
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & {
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
       __loading: () => boolean
     }
     lazyFn.__loading = () => isLoading
     const child = h(lazyFn, null)
-    const fallback = h("span", null, "loading")
+    const fallback = h('span', null, 'loading')
 
     const node = Suspense({ fallback, children: child })
     const getter = node.children[0] as () => VNodeChild

package/src/tests/telemetry.test.ts

@@ -1,17 +1,17 @@
-import type { ErrorContext } from "../telemetry"
-import { registerErrorHandler, reportError } from "../telemetry"
+import type { ErrorContext } from '../telemetry'
+import { registerErrorHandler, reportError } from '../telemetry'
 
-describe("registerErrorHandler", () => {
-  test("registers handler that receives error context", () => {
+describe('registerErrorHandler', () => {
+  test('registers handler that receives error context', () => {
     const contexts: ErrorContext[] = []
     const unsub = registerErrorHandler((ctx) => {
       contexts.push(ctx)
     })
 
     const ctx: ErrorContext = {
-      component: "TestComp",
-      phase: "render",
-      error: new Error("test"),
+      component: 'TestComp',
+      phase: 'render',
+      error: new Error('test'),
       timestamp: 1234567890,
     }
     reportError(ctx)
@@ -21,28 +21,28 @@ describe("registerErrorHandler", () => {
     unsub()
   })
 
-  test("returns unregister function", () => {
+  test('returns unregister function', () => {
     let count = 0
     const unsub = registerErrorHandler(() => {
       count++
     })
 
-    reportError({ component: "A", phase: "setup", error: "e1", timestamp: 0 })
+    reportError({ component: 'A', phase: 'setup', error: 'e1', timestamp: 0 })
     expect(count).toBe(1)
 
     unsub()
 
-    reportError({ component: "B", phase: "render", error: "e2", timestamp: 0 })
+    reportError({ component: 'B', phase: 'render', error: 'e2', timestamp: 0 })
     expect(count).toBe(1) // not called after unregister
   })
 
-  test("multiple handlers are all called", () => {
+  test('multiple handlers are all called', () => {
     let count = 0
     const unsub1 = registerErrorHandler(() => count++)
     const unsub2 = registerErrorHandler(() => count++)
     const unsub3 = registerErrorHandler(() => count++)
 
-    reportError({ component: "X", phase: "mount", error: "err", timestamp: 0 })
+    reportError({ component: 'X', phase: 'mount', error: 'err', timestamp: 0 })
     expect(count).toBe(3)
 
     unsub1()
@@ -50,12 +50,12 @@ describe("registerErrorHandler", () => {
     unsub3()
   })
 
-  test("handler errors are swallowed — subsequent handlers still called", () => {
+  test('handler errors are swallowed — subsequent handlers still called', () => {
     let secondCalled = false
     let thirdCalled = false
 
     const unsub1 = registerErrorHandler(() => {
-      throw new Error("handler crash")
+      throw new Error('handler crash')
     })
     const unsub2 = registerErrorHandler(() => {
       secondCalled = true
@@ -66,7 +66,7 @@ describe("registerErrorHandler", () => {
 
     // Should not throw
     expect(() =>
-      reportError({ component: "Y", phase: "unmount", error: "err", timestamp: 0 }),
+      reportError({ component: 'Y', phase: 'unmount', error: 'err', timestamp: 0 }),
     ).not.toThrow()
     expect(secondCalled).toBe(true)
     expect(thirdCalled).toBe(true)
@@ -76,64 +76,64 @@ describe("registerErrorHandler", () => {
     unsub3()
   })
 
-  test("unregistering one handler does not affect others", () => {
+  test('unregistering one handler does not affect others', () => {
     const calls: string[] = []
-    const unsub1 = registerErrorHandler(() => calls.push("a"))
-    const unsub2 = registerErrorHandler(() => calls.push("b"))
-    const unsub3 = registerErrorHandler(() => calls.push("c"))
+    const unsub1 = registerErrorHandler(() => calls.push('a'))
+    const unsub2 = registerErrorHandler(() => calls.push('b'))
+    const unsub3 = registerErrorHandler(() => calls.push('c'))
 
     unsub2() // remove middle handler
 
-    reportError({ component: "Z", phase: "effect", error: "e", timestamp: 0 })
-    expect(calls).toEqual(["a", "c"])
+    reportError({ component: 'Z', phase: 'effect', error: 'e', timestamp: 0 })
+    expect(calls).toEqual(['a', 'c'])
 
     unsub1()
     unsub3()
   })
 })
 
-describe("reportError", () => {
-  test("no-op when no handlers registered", () => {
+describe('reportError', () => {
+  test('no-op when no handlers registered', () => {
     // Should not throw
     expect(() =>
-      reportError({ component: "None", phase: "setup", error: "err", timestamp: 0 }),
+      reportError({ component: 'None', phase: 'setup', error: 'err', timestamp: 0 }),
     ).not.toThrow()
   })
 
-  test("passes full ErrorContext to handler", () => {
+  test('passes full ErrorContext to handler', () => {
     let received: ErrorContext | null = null
     const unsub = registerErrorHandler((ctx) => {
       received = ctx
     })
 
     const ctx: ErrorContext = {
-      component: "MyComp",
-      phase: "render",
-      error: new Error("detail"),
+      component: 'MyComp',
+      phase: 'render',
+      error: new Error('detail'),
       timestamp: 999,
-      props: { a: 1, b: "two" },
+      props: { a: 1, b: 'two' },
     }
     reportError(ctx)
 
     expect(received).not.toBeNull()
-    expect(received!.component).toBe("MyComp")
-    expect(received!.phase).toBe("render")
+    expect(received!.component).toBe('MyComp')
+    expect(received!.phase).toBe('render')
     expect(received!.error).toBeInstanceOf(Error)
     expect(received!.timestamp).toBe(999)
-    expect(received!.props).toEqual({ a: 1, b: "two" })
+    expect(received!.props).toEqual({ a: 1, b: 'two' })
 
     unsub()
   })
 
-  test("handles all phase types", () => {
-    const phases: ErrorContext["phase"][] = ["setup", "render", "mount", "unmount", "effect"]
+  test('handles all phase types', () => {
+    const phases: ErrorContext['phase'][] = ['setup', 'render', 'mount', 'unmount', 'effect']
     const seen: string[] = []
     const unsub = registerErrorHandler((ctx) => {
       seen.push(ctx.phase)
     })
 
     for (const phase of phases) {
-      reportError({ component: "X", phase, error: "e", timestamp: 0 })
+      reportError({ component: 'X', phase, error: 'e', timestamp: 0 })
     }
     expect(seen).toEqual(phases)