@pyreon/ui-core 0.11.1 → 0.11.2

package/src/__tests__/isEqual.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest"
+import isEqual from "../isEqual"
+
+describe("isEqual", () => {
+  // Primitives
+  it("should return true for identical primitives", () => {
+    expect(isEqual(1, 1)).toBe(true)
+    expect(isEqual("a", "a")).toBe(true)
+    expect(isEqual(true, true)).toBe(true)
+  })
+
+  it("should return false for different primitives", () => {
+    expect(isEqual(1, 2)).toBe(false)
+    expect(isEqual("a", "b")).toBe(false)
+    expect(isEqual(true, false)).toBe(false)
+  })
+
+  it("should handle NaN", () => {
+    expect(isEqual(NaN, NaN)).toBe(true)
+  })
+
+  it("should distinguish 0 and -0", () => {
+    expect(isEqual(0, -0)).toBe(false)
+  })
+
+  // Null / undefined
+  it("should return true for null === null and undefined === undefined", () => {
+    expect(isEqual(null, null)).toBe(true)
+    expect(isEqual(undefined, undefined)).toBe(true)
+  })
+
+  it("should return false for null vs undefined", () => {
+    expect(isEqual(null, undefined)).toBe(false)
+  })
+
+  it("should return false for null vs object", () => {
+    expect(isEqual(null, {})).toBe(false)
+    expect(isEqual({}, null)).toBe(false)
+  })
+
+  // Objects
+  it("should return true for deeply equal objects", () => {
+    expect(isEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+  })
+
+  it("should return true regardless of key order", () => {
+    expect(isEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true)
+  })
+
+  it("should return false for objects with different values", () => {
+    expect(isEqual({ a: 1 }, { a: 2 })).toBe(false)
+  })
+
+  it("should return false for objects with different keys", () => {
+    expect(isEqual({ a: 1 }, { b: 1 })).toBe(false)
+  })
+
+  it("should return false for objects with different key counts", () => {
+    expect(isEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+  })
+
+  // Nested objects
+  it("should deeply compare nested objects", () => {
+    const a = { a: { b: { c: 1 } } }
+    expect(isEqual(a, { a: { b: { c: 1 } } })).toBe(true)
+    expect(isEqual(a, { a: { b: { c: 2 } } })).toBe(false)
+  })
+
+  it("should handle nested key order differences", () => {
+    expect(isEqual({ x: { b: 2, a: 1 }, y: 3 }, { y: 3, x: { a: 1, b: 2 } })).toBe(true)
+  })
+
+  // Arrays
+  it("should return true for identical arrays", () => {
+    expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+  })
+
+  it("should return false for arrays with different values", () => {
+    expect(isEqual([1, 2], [1, 3])).toBe(false)
+  })
+
+  it("should return false for arrays with different lengths", () => {
+    expect(isEqual([1, 2], [1, 2, 3])).toBe(false)
+  })
+
+  it("should not treat array and object as equal", () => {
+    expect(isEqual([1], { 0: 1 })).toBe(false)
+    expect(isEqual({ 0: 1 }, [1])).toBe(false)
+  })
+
+  // Mixed nested
+  it("should deeply compare arrays of objects", () => {
+    expect(isEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 2 }])).toBe(true)
+    expect(isEqual([{ a: 1 }], [{ a: 2 }])).toBe(false)
+  })
+
+  it("should deeply compare objects with array values", () => {
+    expect(isEqual({ a: [1, 2] }, { a: [1, 2] })).toBe(true)
+    expect(isEqual({ a: [1, 2] }, { a: [1, 3] })).toBe(false)
+  })
+
+  // Same reference
+  it("should return true for the same reference", () => {
+    const obj = { a: 1 }
+    expect(isEqual(obj, obj)).toBe(true)
+  })
+
+  // Type mismatches
+  it("should return false for different types", () => {
+    expect(isEqual(1, "1")).toBe(false)
+    expect(isEqual([], {})).toBe(false)
+    expect(isEqual(0, false)).toBe(false)
+  })
+})

package/src/__tests__/render.test.tsx

@@ -0,0 +1,72 @@
+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")
+}
+
+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()
+  })
+
+  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")
+  })
+
+  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 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")
+  })
+
+  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" })
+    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" })
+    // 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"))
+    const result = renderFn(frag as any)
+    expect(result).toBe(frag)
+  })
+
+  it("should return plain object as-is (fallback branch)", () => {
+    // Plain objects are not valid elements, not primitives, not arrays
+    const obj = { foo: "bar" }
+    expect(renderFn(obj as any)).toBe(obj)
+  })
+})

package/src/__tests__/useStableValue.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it, vi } from "vitest"
+
+// ---------------------------------------------------------------------------
+// Minimal signal mock that stores state across calls
+// ---------------------------------------------------------------------------
+vi.mock("@pyreon/reactivity", () => ({
+  signal: <T>(initial: T) => {
+    let value = initial
+    const sig = (() => value) as (() => T) & {
+      set: (v: T) => void
+      update: (fn: (c: T) => T) => void
+      peek: () => T
+      subscribe: (listener: () => void) => () => void
+      direct: (updater: () => void) => () => void
+      label: string | undefined
+      debug: () => { name: string | undefined; value: T; subscriberCount: number }
+    }
+    sig.set = (v: T) => {
+      value = v
+    }
+    sig.update = (fn: (c: T) => T) => {
+      value = fn(value)
+    }
+    sig.peek = () => value
+    sig.subscribe = () => () => {
+      /* noop */
+    }
+    sig.direct = () => () => {
+      /* noop */
+    }
+    sig.label = undefined
+    sig.debug = () => ({ name: undefined, value, subscriberCount: 0 })
+    return sig
+  },
+}))
+
+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")
+    })
+
+    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", () => {
+      const result = useStableValue(true)
+      expect(result).toBe(true)
+    })
+
+    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" }
+      const result = useStableValue(obj)
+      expect(result).toEqual({ a: 1, b: "two" })
+    })
+
+    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)
+      expect(result).toEqual(obj1)
+    })
+  })
+
+  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", () => {
+      const arr = [
+        [1, 2],
+        [3, 4],
+      ]
+      const result = useStableValue(arr)
+      expect(result).toEqual([
+        [1, 2],
+        [3, 4],
+      ])
+    })
+  })
+
+  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", () => {
+      const complex = {
+        nested: { deep: { value: 42 } },
+        arr: [1, [2, 3]],
+      }
+      const result = useStableValue(complex)
+      expect(result).toEqual(complex)
+    })
+  })
+})