@pyreon/core 0.11.5 → 0.11.6

package/src/tests/lifecycle.test.ts

@@ -5,25 +5,25 @@ import {
   onUnmount,
   onUpdate,
   setCurrentHooks,
-} from "../lifecycle"
-import type { LifecycleHooks } from "../types"
+} from '../lifecycle'
+import type { LifecycleHooks } from '../types'
 
-describe("setCurrentHooks / getCurrentHooks", () => {
+describe('setCurrentHooks / getCurrentHooks', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("getCurrentHooks returns null by default", () => {
+  test('getCurrentHooks returns null by default', () => {
     expect(getCurrentHooks()).toBeNull()
   })
 
-  test("setCurrentHooks sets the current hooks context", () => {
+  test('setCurrentHooks sets the current hooks context', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     expect(getCurrentHooks()).toBe(hooks)
   })
 
-  test("setCurrentHooks(null) clears the context", () => {
+  test('setCurrentHooks(null) clears the context', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     expect(getCurrentHooks()).toBe(hooks)
@@ -32,12 +32,12 @@ describe("setCurrentHooks / getCurrentHooks", () => {
   })
 })
 
-describe("onMount", () => {
+describe('onMount', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("registers callback on current hooks", () => {
+  test('registers callback on current hooks', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     const fn = () => undefined
@@ -46,7 +46,7 @@ describe("onMount", () => {
     expect(hooks.mount[0]).toBe(fn)
   })
 
-  test("multiple onMount calls accumulate", () => {
+  test('multiple onMount calls accumulate', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     onMount(() => undefined)
@@ -55,20 +55,20 @@ describe("onMount", () => {
     expect(hooks.mount).toHaveLength(3)
   })
 
-  test("warns when called outside component setup", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('warns when called outside component setup', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onMount(() => {})
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onMount() called outside component setup"),
+      expect.stringContaining('onMount() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 
-  test("is a no-op outside component setup (no crash)", () => {
+  test('is a no-op outside component setup (no crash)', () => {
     expect(() => onMount(() => {})).not.toThrow()
   })
 
-  test("accepts callback returning cleanup function", () => {
+  test('accepts callback returning cleanup function', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     const cleanup = () => {}
@@ -77,7 +77,7 @@ describe("onMount", () => {
     expect(hooks.mount[0]!()).toBe(cleanup)
   })
 
-  test("accepts callback returning void", () => {
+  test('accepts callback returning void', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     onMount(() => {})
@@ -86,12 +86,12 @@ describe("onMount", () => {
   })
 })
 
-describe("onUnmount", () => {
+describe('onUnmount', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("registers callback on current hooks", () => {
+  test('registers callback on current hooks', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     const fn = () => {}
@@ -100,22 +100,22 @@ describe("onUnmount", () => {
     expect(hooks.unmount[0]).toBe(fn)
   })
 
-  test("warns when called outside component setup", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('warns when called outside component setup', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onUnmount(() => {})
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onUnmount() called outside component setup"),
+      expect.stringContaining('onUnmount() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 })
 
-describe("onUpdate", () => {
+describe('onUpdate', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("registers callback on current hooks", () => {
+  test('registers callback on current hooks', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     const fn = () => {}
@@ -124,22 +124,22 @@ describe("onUpdate", () => {
     expect(hooks.update[0]).toBe(fn)
   })
 
-  test("warns when called outside component setup", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('warns when called outside component setup', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onUpdate(() => {})
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onUpdate() called outside component setup"),
+      expect.stringContaining('onUpdate() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 })
 
-describe("onErrorCaptured", () => {
+describe('onErrorCaptured', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("registers callback on current hooks", () => {
+  test('registers callback on current hooks', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     const fn = () => true
@@ -148,16 +148,16 @@ describe("onErrorCaptured", () => {
     expect(hooks.error[0]).toBe(fn)
   })
 
-  test("warns when called outside component setup", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('warns when called outside component setup', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     onErrorCaptured(() => true)
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onErrorCaptured() called outside component setup"),
+      expect.stringContaining('onErrorCaptured() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 
-  test("registered handler receives the error", () => {
+  test('registered handler receives the error', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
     let captured: unknown = null
@@ -166,18 +166,18 @@ describe("onErrorCaptured", () => {
       return true
     })
     // Simulate calling the handler
-    const testError = new Error("test")
+    const testError = new Error('test')
     hooks.error[0]!(testError)
     expect(captured).toBe(testError)
   })
 })
 
-describe("lifecycle hooks interaction", () => {
+describe('lifecycle hooks interaction', () => {
   afterEach(() => {
     setCurrentHooks(null)
   })
 
-  test("all hook types can be registered in same context", () => {
+  test('all hook types can be registered in same context', () => {
     const hooks: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     setCurrentHooks(hooks)
 
@@ -192,7 +192,7 @@ describe("lifecycle hooks interaction", () => {
     expect(hooks.error).toHaveLength(1)
   })
 
-  test("hooks from different setCurrentHooks calls go to different stores", () => {
+  test('hooks from different setCurrentHooks calls go to different stores', () => {
     const hooks1: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
     const hooks2: LifecycleHooks = { mount: [], unmount: [], update: [], error: [] }
 

package/src/tests/map-array.test.ts

@@ -1,8 +1,8 @@
-import { mapArray } from "../map-array"
+import { mapArray } from '../map-array'
 
-describe("mapArray", () => {
-  describe("basic mapping", () => {
-    test("maps all items on first call", () => {
+describe('mapArray', () => {
+  describe('basic mapping', () => {
+    test('maps all items on first call', () => {
       const mapped = mapArray(
         () => [1, 2, 3],
         (item) => item,
@@ -11,7 +11,7 @@ describe("mapArray", () => {
       expect(mapped()).toEqual([10, 20, 30])
     })
 
-    test("returns empty array for empty source", () => {
+    test('returns empty array for empty source', () => {
       const mapped = mapArray(
         () => [],
         (item: number) => item,
@@ -20,18 +20,18 @@ describe("mapArray", () => {
       expect(mapped()).toEqual([])
     })
 
-    test("maps single item", () => {
+    test('maps single item', () => {
       const mapped = mapArray(
         () => [42],
         (item) => item,
         (item) => `value-${item}`,
       )
-      expect(mapped()).toEqual(["value-42"])
+      expect(mapped()).toEqual(['value-42'])
     })
   })
 
-  describe("caching behavior", () => {
-    test("caches results — map function called once per key", () => {
+  describe('caching behavior', () => {
+    test('caches results — map function called once per key', () => {
       let callCount = 0
       const items = [1, 2, 3]
       const mapped = mapArray(
@@ -55,7 +55,7 @@ describe("mapArray", () => {
       expect(callCount).toBe(3)
     })
 
-    test("only maps new keys when items are added", () => {
+    test('only maps new keys when items are added', () => {
       let callCount = 0
       let items = [1, 2, 3]
       const mapped = mapArray(
@@ -75,7 +75,7 @@ describe("mapArray", () => {
       expect(callCount).toBe(5) // only 4 and 5 are new
     })
 
-    test("does not re-map when items are removed", () => {
+    test('does not re-map when items are removed', () => {
       let callCount = 0
       let items = [1, 2, 3, 4, 5]
       const mapped = mapArray(
@@ -97,8 +97,8 @@ describe("mapArray", () => {
     })
   })
 
-  describe("key eviction", () => {
-    test("evicted keys are re-mapped when they return", () => {
+  describe('key eviction', () => {
+    test('evicted keys are re-mapped when they return', () => {
       let callCount = 0
       let items = [1, 2, 3]
       const mapped = mapArray(
@@ -124,7 +124,7 @@ describe("mapArray", () => {
       expect(callCount).toBe(4) // key 2 re-mapped
     })
 
-    test("evicts all keys when source becomes empty", () => {
+    test('evicts all keys when source becomes empty', () => {
       let callCount = 0
       let items: number[] = [1, 2, 3]
       const mapped = mapArray(
@@ -150,8 +150,8 @@ describe("mapArray", () => {
     })
   })
 
-  describe("reordering", () => {
-    test("reordered items use cached values (no re-mapping)", () => {
+  describe('reordering', () => {
+    test('reordered items use cached values (no re-mapping)', () => {
       let callCount = 0
       let items = [1, 2, 3]
       const mapped = mapArray(
@@ -172,7 +172,7 @@ describe("mapArray", () => {
       expect(callCount).toBe(3) // no new calls
     })
 
-    test("reverse order uses cached values", () => {
+    test('reverse order uses cached values', () => {
       let callCount = 0
       let items = [1, 2, 3, 4]
       const mapped = mapArray(
@@ -187,21 +187,21 @@ describe("mapArray", () => {
       mapped()
       items = [4, 3, 2, 1]
       const result = mapped()
-      expect(result).toEqual(["item-4", "item-3", "item-2", "item-1"])
+      expect(result).toEqual(['item-4', 'item-3', 'item-2', 'item-1'])
       expect(callCount).toBe(4) // initial 4 only
     })
   })
 
-  describe("string keys", () => {
-    test("works with string keys from objects", () => {
+  describe('string keys', () => {
+    test('works with string keys from objects', () => {
       interface User {
         id: string
         name: string
       }
       let callCount = 0
       let users: User[] = [
-        { id: "a", name: "Alice" },
-        { id: "b", name: "Bob" },
+        { id: 'a', name: 'Alice' },
+        { id: 'b', name: 'Bob' },
       ]
       const mapped = mapArray(
         () => users,
@@ -212,22 +212,22 @@ describe("mapArray", () => {
         },
       )
 
-      expect(mapped()).toEqual(["ALICE", "BOB"])
+      expect(mapped()).toEqual(['ALICE', 'BOB'])
       expect(callCount).toBe(2)
 
       // Add new user
       users = [
-        { id: "a", name: "Alice" },
-        { id: "b", name: "Bob" },
-        { id: "c", name: "Charlie" },
+        { id: 'a', name: 'Alice' },
+        { id: 'b', name: 'Bob' },
+        { id: 'c', name: 'Charlie' },
       ]
-      expect(mapped()).toEqual(["ALICE", "BOB", "CHARLIE"])
+      expect(mapped()).toEqual(['ALICE', 'BOB', 'CHARLIE'])
       expect(callCount).toBe(3)
     })
   })
 
-  describe("mixed additions and removals", () => {
-    test("simultaneous add and remove", () => {
+  describe('mixed additions and removals', () => {
+    test('simultaneous add and remove', () => {
       let callCount = 0
       let items = [1, 2, 3]
       const mapped = mapArray(
@@ -249,7 +249,7 @@ describe("mapArray", () => {
       expect(callCount).toBe(4) // only key 4 is new
     })
 
-    test("complete replacement of all items", () => {
+    test('complete replacement of all items', () => {
       let callCount = 0
       let items = [1, 2, 3]
       const mapped = mapArray(
@@ -271,8 +271,8 @@ describe("mapArray", () => {
     })
   })
 
-  describe("duplicate keys", () => {
-    test("duplicate keys in source share the same cached value", () => {
+  describe('duplicate keys', () => {
+    test('duplicate keys in source share the same cached value', () => {
       let callCount = 0
       const mapped = mapArray(
         () => [1, 1, 2],
@@ -291,12 +291,12 @@ describe("mapArray", () => {
     })
   })
 
-  describe("map function receives correct item", () => {
-    test("map receives the item, not the key", () => {
+  describe('map function receives correct item', () => {
+    test('map receives the item, not the key', () => {
       const received: Array<{ id: number; val: string }> = []
       const items = [
-        { id: 1, val: "a" },
-        { id: 2, val: "b" },
+        { id: 1, val: 'a' },
+        { id: 2, val: 'b' },
       ]
       const mapped = mapArray(
         () => items,

package/src/tests/portal.test.ts

@@ -1,48 +1,48 @@
-import { h } from "../h"
-import { Portal, PortalSymbol } from "../portal"
-import type { VNode } from "../types"
+import { h } from '../h'
+import { Portal, PortalSymbol } from '../portal'
+import type { VNode } from '../types'
 
-describe("Portal", () => {
-  test("returns VNode with PortalSymbol type", () => {
+describe('Portal', () => {
+  test('returns VNode with PortalSymbol type', () => {
     const fakeTarget = {} as Element
-    const node = Portal({ target: fakeTarget, children: h("div", null) })
+    const node = Portal({ target: fakeTarget, children: h('div', null) })
     expect(node.type).toBe(PortalSymbol)
   })
 
-  test("VNode has null key", () => {
-    const node = Portal({ target: {} as Element, children: "content" })
+  test('VNode has null key', () => {
+    const node = Portal({ target: {} as Element, children: 'content' })
     expect(node.key).toBeNull()
   })
 
-  test("VNode has empty children array", () => {
-    const node = Portal({ target: {} as Element, children: "content" })
+  test('VNode has empty children array', () => {
+    const node = Portal({ target: {} as Element, children: 'content' })
     expect(node.children).toEqual([])
   })
 
-  test("props contain target and children", () => {
+  test('props contain target and children', () => {
     const fakeTarget = {} as Element
-    const child = h("span", null, "content")
+    const child = h('span', null, 'content')
     const node = Portal({ target: fakeTarget, children: child })
     const props = node.props as unknown as { target: Element; children: VNode }
     expect(props.target).toBe(fakeTarget)
     expect(props.children).toBe(child)
   })
 
-  test("PortalSymbol is a unique symbol", () => {
-    expect(typeof PortalSymbol).toBe("symbol")
-    expect(PortalSymbol.toString()).toContain("pyreon.Portal")
+  test('PortalSymbol is a unique symbol', () => {
+    expect(typeof PortalSymbol).toBe('symbol')
+    expect(PortalSymbol.toString()).toContain('pyreon.Portal')
   })
 
-  test("string children are stored in props", () => {
-    const node = Portal({ target: {} as Element, children: "text content" })
+  test('string children are stored in props', () => {
+    const node = Portal({ target: {} as Element, children: 'text content' })
     const props = node.props as unknown as { children: string }
-    expect(props.children).toBe("text content")
+    expect(props.children).toBe('text content')
   })
 
-  test("multiple VNode children via fragment", () => {
-    const children = h("div", null, h("span", null, "a"), h("span", null, "b"))
+  test('multiple VNode children via fragment', () => {
+    const children = h('div', null, h('span', null, 'a'), h('span', null, 'b'))
     const node = Portal({ target: {} as Element, children })
     const props = node.props as unknown as { children: VNode }
-    expect((props.children as VNode).type).toBe("div")
+    expect((props.children as VNode).type).toBe('div')
   })
 })