@pyreon/core 0.11.5 → 0.11.6

package/src/tests/props-extended.test.ts

@@ -1,23 +1,23 @@
-import { _resetIdCounter, createUniqueId, mergeProps, splitProps } from "../props"
+import { _resetIdCounter, createUniqueId, mergeProps, splitProps } from '../props'
 
-describe("createUniqueId — extended", () => {
-  test("returns pyreon- prefixed string", () => {
+describe('createUniqueId — extended', () => {
+  test('returns pyreon- prefixed string', () => {
     const id = createUniqueId()
     expect(id).toMatch(/^pyreon-\d+$/)
   })
 
-  test("returns incrementing values", () => {
+  test('returns incrementing values', () => {
     const id1 = createUniqueId()
     const id2 = createUniqueId()
     const id3 = createUniqueId()
-    const num1 = Number.parseInt(id1.replace("pyreon-", ""), 10)
-    const num2 = Number.parseInt(id2.replace("pyreon-", ""), 10)
-    const num3 = Number.parseInt(id3.replace("pyreon-", ""), 10)
+    const num1 = Number.parseInt(id1.replace('pyreon-', ''), 10)
+    const num2 = Number.parseInt(id2.replace('pyreon-', ''), 10)
+    const num3 = Number.parseInt(id3.replace('pyreon-', ''), 10)
     expect(num2).toBe(num1 + 1)
     expect(num3).toBe(num2 + 1)
   })
 
-  test("all IDs are unique", () => {
+  test('all IDs are unique', () => {
     const ids = new Set<string>()
     for (let i = 0; i < 100; i++) {
       ids.add(createUniqueId())
@@ -26,8 +26,8 @@ describe("createUniqueId — extended", () => {
   })
 })
 
-describe("_resetIdCounter", () => {
-  test("resets the counter so IDs restart", () => {
+describe('_resetIdCounter', () => {
+  test('resets the counter so IDs restart', () => {
     // Generate some IDs to advance counter
     createUniqueId()
     createUniqueId()
@@ -35,121 +35,121 @@ describe("_resetIdCounter", () => {
     _resetIdCounter()
 
     const id = createUniqueId()
-    expect(id).toBe("pyreon-1")
+    expect(id).toBe('pyreon-1')
   })
 
-  test("subsequent calls after reset increment from 1", () => {
+  test('subsequent calls after reset increment from 1', () => {
     _resetIdCounter()
-    expect(createUniqueId()).toBe("pyreon-1")
-    expect(createUniqueId()).toBe("pyreon-2")
-    expect(createUniqueId()).toBe("pyreon-3")
+    expect(createUniqueId()).toBe('pyreon-1')
+    expect(createUniqueId()).toBe('pyreon-2')
+    expect(createUniqueId()).toBe('pyreon-3')
   })
 })
 
-describe("splitProps — extended", () => {
-  test("non-existent keys produce empty picked object", () => {
+describe('splitProps — extended', () => {
+  test('non-existent keys produce empty picked object', () => {
     const props = { a: 1, b: 2 }
-    const [own, rest] = splitProps(props, ["c" as keyof typeof props])
+    const [own, rest] = splitProps(props, ['c' as keyof typeof props])
     expect(Object.keys(own)).toEqual([])
     expect(rest).toEqual({ a: 1, b: 2 })
   })
 
-  test("all keys in picked leaves rest empty", () => {
+  test('all keys in picked leaves rest empty', () => {
     const props = { x: 10, y: 20 }
-    const [own, rest] = splitProps(props, ["x", "y"])
+    const [own, rest] = splitProps(props, ['x', 'y'])
     expect(own).toEqual({ x: 10, y: 20 })
     expect(Object.keys(rest)).toEqual([])
   })
 
-  test("preserves getter on rest side", () => {
+  test('preserves getter on rest side', () => {
     let count = 0
     const props = {} as Record<string, unknown>
-    Object.defineProperty(props, "reactive", {
+    Object.defineProperty(props, 'reactive', {
       get: () => ++count,
       enumerable: true,
       configurable: true,
     })
-    Object.defineProperty(props, "other", {
-      value: "static",
+    Object.defineProperty(props, 'other', {
+      value: 'static',
       enumerable: true,
       configurable: true,
     })
 
-    const [_own, rest] = splitProps(props, ["other"])
+    const [_own, rest] = splitProps(props, ['other'])
     expect((rest as Record<string, unknown>).reactive).toBe(1)
     expect((rest as Record<string, unknown>).reactive).toBe(2) // getter called again
   })
 
-  test("handles object with undefined values", () => {
-    const props = { a: undefined, b: "defined" }
-    const [own, rest] = splitProps(props, ["a"])
+  test('handles object with undefined values', () => {
+    const props = { a: undefined, b: 'defined' }
+    const [own, rest] = splitProps(props, ['a'])
     expect(own.a).toBeUndefined()
-    expect((rest as Record<string, unknown>).b).toBe("defined")
+    expect((rest as Record<string, unknown>).b).toBe('defined')
   })
 })
 
-describe("mergeProps — extended", () => {
-  test("single source returns copy", () => {
+describe('mergeProps — extended', () => {
+  test('single source returns copy', () => {
     const src = { a: 1, b: 2 }
     const result = mergeProps(src)
     expect(result).toEqual({ a: 1, b: 2 })
     expect(result).not.toBe(src) // should be a new object
   })
 
-  test("three sources merge correctly", () => {
+  test('three sources merge correctly', () => {
     const result = mergeProps({ a: 1 }, { b: 2 }, { c: 3 })
     expect(result).toEqual({ a: 1, b: 2, c: 3 })
   })
 
-  test("later defined value overrides earlier", () => {
-    const result = mergeProps({ x: "first" }, { x: "second" }, { x: "third" })
-    expect(result.x).toBe("third")
+  test('later defined value overrides earlier', () => {
+    const result = mergeProps({ x: 'first' }, { x: 'second' }, { x: 'third' })
+    expect(result.x).toBe('third')
   })
 
-  test("undefined in later source does not override earlier defined value", () => {
-    const result = mergeProps({ x: "keep" }, { x: undefined as string | undefined })
-    expect(result.x).toBe("keep")
+  test('undefined in later source does not override earlier defined value', () => {
+    const result = mergeProps({ x: 'keep' }, { x: undefined as string | undefined })
+    expect(result.x).toBe('keep')
   })
 
-  test("getter merging: later getter overrides earlier static when defined", () => {
-    let dynamic: string | undefined = "from-getter"
+  test('getter merging: later getter overrides earlier static when defined', () => {
+    let dynamic: string | undefined = 'from-getter'
     const getterSrc = {} as Record<string, unknown>
-    Object.defineProperty(getterSrc, "val", {
+    Object.defineProperty(getterSrc, 'val', {
       get: () => dynamic,
       enumerable: true,
       configurable: true,
     })
-    const result = mergeProps({ val: "static" }, getterSrc)
-    expect(result.val).toBe("from-getter")
+    const result = mergeProps({ val: 'static' }, getterSrc)
+    expect(result.val).toBe('from-getter')
 
     // When getter returns undefined, falls back to static
     dynamic = undefined
-    expect(result.val).toBe("static")
+    expect(result.val).toBe('static')
   })
 
-  test("two getters: later getter wins when defined, falls to earlier getter", () => {
-    let g1val: string | undefined = "g1"
-    let g2val: string | undefined = "g2"
+  test('two getters: later getter wins when defined, falls to earlier getter', () => {
+    let g1val: string | undefined = 'g1'
+    let g2val: string | undefined = 'g2'
 
     const src1 = {} as Record<string, unknown>
-    Object.defineProperty(src1, "x", {
+    Object.defineProperty(src1, 'x', {
       get: () => g1val,
       enumerable: true,
       configurable: true,
     })
 
     const src2 = {} as Record<string, unknown>
-    Object.defineProperty(src2, "x", {
+    Object.defineProperty(src2, 'x', {
       get: () => g2val,
       enumerable: true,
       configurable: true,
     })
 
     const result = mergeProps(src1, src2)
-    expect(result.x).toBe("g2")
+    expect(result.x).toBe('g2')
 
     g2val = undefined
-    expect(result.x).toBe("g1")
+    expect(result.x).toBe('g1')
 
     g1val = undefined
     expect(result.x).toBeUndefined()

package/src/tests/props.test.ts

@@ -1,26 +1,26 @@
-import { createUniqueId, mergeProps, splitProps } from "../props"
+import { createUniqueId, mergeProps, splitProps } from '../props'
 
-describe("splitProps", () => {
-  test("splits known keys from rest", () => {
-    const props = { label: "Hi", icon: "star", class: "btn", id: "x" }
-    const [own, html] = splitProps(props, ["label", "icon"])
-    expect(own).toEqual({ label: "Hi", icon: "star" })
-    expect(html).toEqual({ class: "btn", id: "x" })
+describe('splitProps', () => {
+  test('splits known keys from rest', () => {
+    const props = { label: 'Hi', icon: 'star', class: 'btn', id: 'x' }
+    const [own, html] = splitProps(props, ['label', 'icon'])
+    expect(own).toEqual({ label: 'Hi', icon: 'star' })
+    expect(html).toEqual({ class: 'btn', id: 'x' })
   })
 
-  test("preserves getters", () => {
+  test('preserves getters', () => {
     let count = 0
-    const props = Object.defineProperty({} as Record<string, unknown>, "value", {
+    const props = Object.defineProperty({} as Record<string, unknown>, 'value', {
       get: () => ++count,
       enumerable: true,
       configurable: true,
     })
-    const [own] = splitProps(props, ["value"])
+    const [own] = splitProps(props, ['value'])
     expect(own.value).toBe(1)
     expect(own.value).toBe(2) // getter called again
   })
 
-  test("handles empty keys array", () => {
+  test('handles empty keys array', () => {
     const props = { a: 1, b: 2 }
     const [own, rest] = splitProps(props, [])
     expect(own).toEqual({})
@@ -28,20 +28,20 @@ describe("splitProps", () => {
   })
 })
 
-describe("mergeProps", () => {
-  test("later sources override earlier", () => {
+describe('mergeProps', () => {
+  test('later sources override earlier', () => {
     const result = mergeProps({ a: 1, b: 2 }, { b: 3, c: 4 })
     expect(result).toEqual({ a: 1, b: 3, c: 4 })
   })
 
   test("undefined values don't override defined", () => {
-    const result = mergeProps({ size: "md" }, { size: undefined as string | undefined })
-    expect(result.size).toBe("md")
+    const result = mergeProps({ size: 'md' }, { size: undefined as string | undefined })
+    expect(result.size).toBe('md')
   })
 
-  test("preserves getters from sources", () => {
+  test('preserves getters from sources', () => {
     let count = 0
-    const source = Object.defineProperty({} as Record<string, unknown>, "val", {
+    const source = Object.defineProperty({} as Record<string, unknown>, 'val', {
       get: () => ++count,
       enumerable: true,
       configurable: true,
@@ -51,85 +51,85 @@ describe("mergeProps", () => {
     expect(result.val).toBe(2)
   })
 
-  test("getter returning undefined falls back to previous value", () => {
+  test('getter returning undefined falls back to previous value', () => {
     let override: string | undefined
-    const source = Object.defineProperty({} as Record<string, unknown>, "size", {
+    const source = Object.defineProperty({} as Record<string, unknown>, 'size', {
       get: () => override,
       enumerable: true,
       configurable: true,
     })
-    const result = mergeProps({ size: "md" }, source)
-    expect(result.size).toBe("md") // getter returns undefined, fallback
+    const result = mergeProps({ size: 'md' }, source)
+    expect(result.size).toBe('md') // getter returns undefined, fallback
 
-    override = "lg"
-    expect(result.size).toBe("lg") // getter returns value
+    override = 'lg'
+    expect(result.size).toBe('lg') // getter returns value
   })
 })
 
-describe("mergeProps — edge cases", () => {
-  test("mixed getter/static value merging across 3+ sources", () => {
-    let dynamicSize = "sm"
-    const source1 = { size: "md", variant: "primary" }
-    const source2 = Object.defineProperty({} as Record<string, unknown>, "size", {
+describe('mergeProps — edge cases', () => {
+  test('mixed getter/static value merging across 3+ sources', () => {
+    let dynamicSize = 'sm'
+    const source1 = { size: 'md', variant: 'primary' }
+    const source2 = Object.defineProperty({} as Record<string, unknown>, 'size', {
       get: () => dynamicSize,
       enumerable: true,
       configurable: true,
     })
-    const source3 = { color: "red" }
+    const source3 = { color: 'red' }
     const result = mergeProps(source1, source2, source3)
-    expect(result.size).toBe("sm")
-    dynamicSize = "xl"
-    expect(result.size).toBe("xl")
-    expect((result as Record<string, unknown>).variant).toBe("primary")
-    expect((result as Record<string, unknown>).color).toBe("red")
+    expect(result.size).toBe('sm')
+    dynamicSize = 'xl'
+    expect(result.size).toBe('xl')
+    expect((result as Record<string, unknown>).variant).toBe('primary')
+    expect((result as Record<string, unknown>).color).toBe('red')
   })
 
-  test("getter returning undefined falling through multiple levels of defaults", () => {
+  test('getter returning undefined falling through multiple levels of defaults', () => {
     let level2: string | undefined
     let level1: string | undefined
-    const defaults = { theme: "light" }
-    const mid = Object.defineProperty({} as Record<string, unknown>, "theme", {
+    const defaults = { theme: 'light' }
+    const mid = Object.defineProperty({} as Record<string, unknown>, 'theme', {
       get: () => level1,
       enumerable: true,
       configurable: true,
     })
-    const top = Object.defineProperty({} as Record<string, unknown>, "theme", {
+    const top = Object.defineProperty({} as Record<string, unknown>, 'theme', {
       get: () => level2,
       enumerable: true,
       configurable: true,
     })
     const result = mergeProps(defaults, mid, top)
     // Both getters return undefined — falls back to "light"
-    expect(result.theme).toBe("light")
+    expect(result.theme).toBe('light')
     // Mid-level getter returns value — top still undefined, falls to mid
-    level1 = "dark"
-    expect(result.theme).toBe("dark")
+    level1 = 'dark'
+    expect(result.theme).toBe('dark')
     // Top-level getter returns value — wins
-    level2 = "system"
-    expect(result.theme).toBe("system")
+    level2 = 'system'
+    expect(result.theme).toBe('system')
   })
 
-  test("mergeProps with no sources (empty call)", () => {
+  test('mergeProps with no sources (empty call)', () => {
     const result = mergeProps()
     expect(result).toEqual({})
   })
 
-  test("later source static value overriding earlier getter", () => {
-    const dynamic = "from-getter"
-    const getterSource = Object.defineProperty({} as Record<string, unknown>, "val", {
+  test('later source static value overriding earlier getter', () => {
+    const dynamic = 'from-getter'
+    const getterSource = Object.defineProperty({} as Record<string, unknown>, 'val', {
       get: () => dynamic,
       enumerable: true,
       configurable: true,
     })
-    const staticSource = { val: "static-wins" }
+    const staticSource = { val: 'static-wins' }
     const result = mergeProps(getterSource, staticSource)
     // Static value should override getter
-    expect(result.val).toBe("static-wins")
+    expect(result.val).toBe('static-wins')
   })
 
-  test("later source static undefined does not override earlier getter", () => {
-    let dynamic = "from-getter"
-    const getterSource = Object.defineProperty({} as Record<string, unknown>, "val", {
+  test('later source static undefined does not override earlier getter', () => {
+    let dynamic = 'from-getter'
+    const getterSource = Object.defineProperty({} as Record<string, unknown>, 'val', {
       get: () => dynamic,
       enumerable: true,
       configurable: true,
@@ -137,31 +137,31 @@ describe("mergeProps — edge cases", () => {
     const staticSource = { val: undefined }
     const result = mergeProps(getterSource, staticSource)
     // Static undefined — getter should still be used
-    expect(result.val).toBe("from-getter")
-    dynamic = "updated"
-    expect(result.val).toBe("updated")
+    expect(result.val).toBe('from-getter')
+    dynamic = 'updated'
+    expect(result.val).toBe('updated')
   })
 })
 
-describe("splitProps — getter reactivity", () => {
-  test("preserves getter reactivity through multiple reads", () => {
+describe('splitProps — getter reactivity', () => {
+  test('preserves getter reactivity through multiple reads', () => {
     let count = 0
-    const props = Object.defineProperty({ other: "x" } as Record<string, unknown>, "value", {
+    const props = Object.defineProperty({ other: 'x' } as Record<string, unknown>, 'value', {
       get: () => ++count,
       enumerable: true,
       configurable: true,
     })
-    const [own, rest] = splitProps(props, ["value"])
+    const [own, rest] = splitProps(props, ['value'])
     expect(own.value).toBe(1)
     expect(own.value).toBe(2)
     expect(own.value).toBe(3)
     // rest should not include the getter key
-    expect(rest).toEqual({ other: "x" })
+    expect(rest).toEqual({ other: 'x' })
   })
 })
 
-describe("createUniqueId", () => {
-  test("returns incrementing IDs", () => {
+describe('createUniqueId', () => {
+  test('returns incrementing IDs', () => {
     const id1 = createUniqueId()
     const id2 = createUniqueId()
     expect(id1).toMatch(/^pyreon-\d+$/)

package/src/tests/ref.test.ts

@@ -1,19 +1,19 @@
-import type { Ref, RefCallback, RefProp } from "../ref"
-import { createRef } from "../ref"
+import type { Ref, RefCallback, RefProp } from '../ref'
+import { createRef } from '../ref'
 
-describe("createRef", () => {
-  test("returns object with current = null", () => {
+describe('createRef', () => {
+  test('returns object with current = null', () => {
     const ref = createRef()
     expect(ref.current).toBeNull()
   })
 
-  test("current is mutable", () => {
+  test('current is mutable', () => {
     const ref = createRef<number>()
     ref.current = 42
     expect(ref.current).toBe(42)
   })
 
-  test("typed ref — HTMLElement", () => {
+  test('typed ref — HTMLElement', () => {
     const ref = createRef<HTMLDivElement>()
     expect(ref.current).toBeNull()
     // In real code, runtime-dom sets this after mount
@@ -21,13 +21,13 @@ describe("createRef", () => {
     expect(ref.current).not.toBeNull()
   })
 
-  test("typed ref — string", () => {
+  test('typed ref — string', () => {
     const ref = createRef<string>()
-    ref.current = "hello"
-    expect(ref.current).toBe("hello")
+    ref.current = 'hello'
+    expect(ref.current).toBe('hello')
   })
 
-  test("can be reset to null", () => {
+  test('can be reset to null', () => {
     const ref = createRef<number>()
     ref.current = 99
     expect(ref.current).toBe(99)
@@ -35,36 +35,36 @@ describe("createRef", () => {
     expect(ref.current).toBeNull()
   })
 
-  test("each createRef returns a unique object", () => {
+  test('each createRef returns a unique object', () => {
     const ref1 = createRef()
     const ref2 = createRef()
     expect(ref1).not.toBe(ref2)
   })
 
-  test("ref object has exactly one property", () => {
+  test('ref object has exactly one property', () => {
     const ref = createRef()
-    expect(Object.keys(ref)).toEqual(["current"])
+    expect(Object.keys(ref)).toEqual(['current'])
   })
 
-  test("ref object shape matches Ref interface", () => {
+  test('ref object shape matches Ref interface', () => {
     const ref: Ref<number> = createRef<number>()
-    expect("current" in ref).toBe(true)
+    expect('current' in ref).toBe(true)
     expect(ref.current).toBeNull()
   })
 })
 
-describe("RefCallback type (type-level verification)", () => {
-  test("callback ref can be assigned to RefProp", () => {
+describe('RefCallback type (type-level verification)', () => {
+  test('callback ref can be assigned to RefProp', () => {
     const callback: RefCallback<HTMLElement> = (_el) => {}
     // Type-level test: RefProp accepts both object ref and callback ref
     const prop: RefProp<HTMLElement> = callback
-    expect(typeof prop).toBe("function")
+    expect(typeof prop).toBe('function')
   })
 
-  test("object ref can be assigned to RefProp", () => {
+  test('object ref can be assigned to RefProp', () => {
     const ref = createRef<HTMLElement>()
     const prop: RefProp<HTMLElement> = ref
-    expect(typeof prop).toBe("object")
+    expect(typeof prop).toBe('object')
     expect(prop).toBe(ref)
   })
 })