@pyreon/ui-core 0.11.4 → 0.11.6

package/src/__tests__/render.test.tsx

@@ -1,72 +1,72 @@
-import type { VNode } from "@pyreon/core"
-import { Fragment, h } from "@pyreon/core"
-import { describe, expect, it } from "vitest"
-import renderFn from "../render"
+import type { VNode } from '@pyreon/core'
+import { Fragment, h } from '@pyreon/core'
+import { describe, expect, it } from 'vitest'
+import renderFn from '../render'
 
 const TestComponent = (props: { label?: string }) => {
-  return h("span", { "data-testid": "test" }, props.label ?? "default")
+  return h('span', { 'data-testid': 'test' }, props.label ?? 'default')
 }
 
-describe("render", () => {
-  it("should return null for falsy content", () => {
+describe('render', () => {
+  it('should return null for falsy content', () => {
     expect(renderFn(null)).toBeNull()
     expect(renderFn(undefined)).toBeNull()
     expect(renderFn(false as any)).toBeNull()
-    expect(renderFn("" as any)).toBeNull()
+    expect(renderFn('' as any)).toBeNull()
   })
 
-  it("should render a component with props", () => {
-    const result = renderFn(TestComponent, { label: "hello" }) as VNode
+  it('should render a component with props', () => {
+    const result = renderFn(TestComponent, { label: 'hello' }) as VNode
     expect(result).toBeDefined()
     expect(result.type).toBe(TestComponent)
-    expect(result.props.label).toBe("hello")
+    expect(result.props.label).toBe('hello')
   })
 
-  it("should render a component without props", () => {
+  it('should render a component without props', () => {
     const result = renderFn(TestComponent) as VNode
     expect(result).toBeDefined()
     expect(result.type).toBe(TestComponent)
   })
 
-  it("should return string content as-is (treated as text)", () => {
-    expect(renderFn("div" as any)).toBe("div")
-    expect(renderFn("hello" as any)).toBe("hello")
+  it('should return string content as-is (treated as text)', () => {
+    expect(renderFn('div' as any)).toBe('div')
+    expect(renderFn('hello' as any)).toBe('hello')
   })
 
-  it("should return primitive values as-is", () => {
+  it('should return primitive values as-is', () => {
     expect(renderFn(42 as any)).toBe(42)
     expect(renderFn(true as any)).toBe(true)
-    expect(renderFn("text" as any)).toBe("text")
+    expect(renderFn('text' as any)).toBe('text')
   })
 
-  it("should return arrays as-is", () => {
-    const arr = [h("span", { key: "1" }, "a"), h("span", { key: "2" }, "b")]
+  it('should return arrays as-is', () => {
+    const arr = [h('span', { key: '1' }, 'a'), h('span', { key: '2' }, 'b')]
     expect(renderFn(arr as any)).toBe(arr)
   })
 
-  it("should return a VNode object without modification when no props", () => {
-    const vnode = h(TestComponent, { label: "original" })
+  it('should return a VNode object without modification when no props', () => {
+    const vnode = h(TestComponent, { label: 'original' })
     const result = renderFn(vnode as any)
     // VNode objects are returned as-is
     expect(result).toBe(vnode)
   })
 
-  it("should return a VNode object as-is even with props (VNode path does not merge)", () => {
-    const vnode = h(TestComponent, { label: "original" })
-    const result = renderFn(vnode as any, { label: "cloned" })
+  it('should return a VNode object as-is even with props (VNode path does not merge)', () => {
+    const vnode = h(TestComponent, { label: 'original' })
+    const result = renderFn(vnode as any, { label: 'cloned' })
     // In Pyreon's render, VNode objects hit the object branch and are returned as-is
     expect(result).toBe(vnode)
   })
 
-  it("should return fragment as-is", () => {
-    const frag = h(Fragment, null, h("span", null, "a"), h("span", null, "b"))
+  it('should return fragment as-is', () => {
+    const frag = h(Fragment, null, h('span', null, 'a'), h('span', null, 'b'))
     const result = renderFn(frag as any)
     expect(result).toBe(frag)
   })
 
-  it("should return plain object as-is (fallback branch)", () => {
+  it('should return plain object as-is (fallback branch)', () => {
     // Plain objects are not valid elements, not primitives, not arrays
-    const obj = { foo: "bar" }
+    const obj = { foo: 'bar' }
     expect(renderFn(obj as any)).toBe(obj)
   })
 })

package/src/__tests__/useStableValue.test.ts

@@ -1,9 +1,9 @@
-import { describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from 'vitest'
 
 // ---------------------------------------------------------------------------
 // Minimal signal mock that stores state across calls
 // ---------------------------------------------------------------------------
-vi.mock("@pyreon/reactivity", () => ({
+vi.mock('@pyreon/reactivity', () => ({
   signal: <T>(initial: T) => {
     let value = initial
     const sig = (() => value) as (() => T) & {
@@ -34,39 +34,39 @@ vi.mock("@pyreon/reactivity", () => ({
   },
 }))
 
-import useStableValue from "../useStableValue"
+import useStableValue from '../useStableValue'
 
-describe("useStableValue", () => {
-  describe("primitives", () => {
-    it("returns the value on first call with a string", () => {
-      const result = useStableValue("hello")
-      expect(result).toBe("hello")
+describe('useStableValue', () => {
+  describe('primitives', () => {
+    it('returns the value on first call with a string', () => {
+      const result = useStableValue('hello')
+      expect(result).toBe('hello')
     })
 
-    it("returns the value on first call with a number", () => {
+    it('returns the value on first call with a number', () => {
       const result = useStableValue(42)
       expect(result).toBe(42)
     })
 
-    it("returns the value on first call with a boolean", () => {
+    it('returns the value on first call with a boolean', () => {
       const result = useStableValue(true)
       expect(result).toBe(true)
     })
 
-    it("returns the value on first call with null", () => {
+    it('returns the value on first call with null', () => {
       const result = useStableValue(null)
       expect(result).toBeNull()
     })
   })
 
-  describe("objects", () => {
-    it("returns the object value", () => {
-      const obj = { a: 1, b: "two" }
+  describe('objects', () => {
+    it('returns the object value', () => {
+      const obj = { a: 1, b: 'two' }
       const result = useStableValue(obj)
-      expect(result).toEqual({ a: 1, b: "two" })
+      expect(result).toEqual({ a: 1, b: 'two' })
     })
 
-    it("returns same reference when called with deeply equal value", () => {
+    it('returns same reference when called with deeply equal value', () => {
       // Each call creates a new signal, so we verify the value is correct
       const obj1 = { x: 1, y: 2 }
       const result = useStableValue(obj1)
@@ -74,14 +74,14 @@ describe("useStableValue", () => {
     })
   })
 
-  describe("arrays", () => {
-    it("returns the array value", () => {
+  describe('arrays', () => {
+    it('returns the array value', () => {
       const arr = [1, 2, 3]
       const result = useStableValue(arr)
       expect(result).toEqual([1, 2, 3])
     })
 
-    it("handles nested arrays", () => {
+    it('handles nested arrays', () => {
       const arr = [
         [1, 2],
         [3, 4],
@@ -94,14 +94,14 @@ describe("useStableValue", () => {
     })
   })
 
-  describe("signal interaction", () => {
-    it("creates a signal with the initial value and returns peek()", () => {
-      const value = { key: "value" }
+  describe('signal interaction', () => {
+    it('creates a signal with the initial value and returns peek()', () => {
+      const value = { key: 'value' }
       const result = useStableValue(value)
       expect(result).toEqual(value)
     })
 
-    it("returns the initial value even for complex nested objects", () => {
+    it('returns the initial value even for complex nested objects', () => {
       const complex = {
         nested: { deep: { value: 42 } },
         arr: [1, [2, 3]],