@pyreon/ui-core 0.11.1 → 0.11.3

package/src/__tests__/hoistNonReactStatics.test.tsx

@@ -0,0 +1,166 @@
+import { describe, expect, it } from "vitest"
+import hoistNonReactStatics from "../hoistNonReactStatics"
+
+describe("hoistNonReactStatics", () => {
+  it("copies custom static properties from source to target", () => {
+    const Source = () => null
+    ;(Source as any).customStatic = "hello"
+    ;(Source as any).anotherStatic = 42
+
+    const Target = () => null
+
+    hoistNonReactStatics(Target, Source)
+
+    expect((Target as any).customStatic).toBe("hello")
+    expect((Target as any).anotherStatic).toBe(42)
+  })
+
+  it("does not copy component statics (displayName, defaultProps)", () => {
+    const Source = () => null
+    Source.displayName = "SourceComponent"
+    ;(Source as any).defaultProps = { bar: 1 }
+    ;(Source as any).customProp = "should copy"
+
+    const Target = () => null
+    Target.displayName = "TargetComponent"
+
+    hoistNonReactStatics(Target, Source)
+
+    expect(Target.displayName).toBe("TargetComponent")
+    expect((Target as any).defaultProps).toBeUndefined()
+    expect((Target as any).customProp).toBe("should copy")
+  })
+
+  it("does not copy known JS statics (name, length, prototype)", () => {
+    const Source = () => null
+    ;(Source as any).customProp = "value"
+
+    const Target = () => null
+    const originalName = Target.name
+
+    hoistNonReactStatics(Target, Source)
+
+    expect(Target.name).toBe(originalName)
+    expect((Target as any).customProp).toBe("value")
+  })
+
+  it("respects the excludeList", () => {
+    const Source = () => null
+    ;(Source as any).foo = "included"
+    ;(Source as any).bar = "excluded"
+    ;(Source as any).baz = "included"
+
+    const Target = () => null
+
+    hoistNonReactStatics(Target, Source, { bar: true })
+
+    expect((Target as any).foo).toBe("included")
+    expect((Target as any).bar).toBeUndefined()
+    expect((Target as any).baz).toBe("included")
+  })
+
+  it("returns the target component", () => {
+    const Source = () => null
+    const Target = () => null
+
+    const result = hoistNonReactStatics(Target, Source)
+    expect(result).toBe(Target)
+  })
+
+  it("handles string source (HTML tag) gracefully", () => {
+    const Target = () => null
+
+    const result = hoistNonReactStatics(Target, "div" as any)
+    expect(result).toBe(Target)
+  })
+
+  it("copies symbol-keyed properties", () => {
+    const sym = Symbol("custom")
+    const Source = () => null
+    ;(Source as any)[sym] = "symbol value"
+
+    const Target = () => null
+
+    hoistNonReactStatics(Target, Source)
+
+    expect((Target as any)[sym]).toBe("symbol value")
+  })
+
+  it("copies getters and setters via property descriptors", () => {
+    const Source = () => null
+    let value = 0
+    Object.defineProperty(Source, "counter", {
+      get: () => value,
+      set: (v) => {
+        value = v
+      },
+      enumerable: true,
+      configurable: true,
+    })
+
+    const Target = () => null
+
+    hoistNonReactStatics(Target, Source)
+
+    expect((Target as any).counter).toBe(0)
+    ;(Target as any).counter = 5
+    expect((Target as any).counter).toBe(5)
+    // shares the same backing variable
+    expect((Source as any).counter).toBe(5)
+  })
+
+  it("does not throw on non-configurable target properties", () => {
+    const Source = () => null
+    ;(Source as any).locked = "source value"
+
+    const Target = () => null
+    Object.defineProperty(Target, "locked", {
+      value: "target value",
+      writable: false,
+      configurable: false,
+    })
+
+    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
+    expect((Target as any).locked).toBe("target value")
+  })
+
+  it("hoists statics from prototype chain", () => {
+    function Base() {
+      // constructor stub
+    }
+    Base.prototype = Object.create(null)
+    ;(Base as any).inheritedStatic = "from base"
+
+    function Source() {
+      // constructor stub
+    }
+    Source.prototype = Object.create(null)
+    Object.setPrototypeOf(Source, Base)
+    ;(Source as any).ownStatic = "from source"
+
+    const Target = () => null
+
+    hoistNonReactStatics(Target, Source as any)
+
+    expect((Target as any).ownStatic).toBe("from source")
+    expect((Target as any).inheritedStatic).toBe("from base")
+  })
+
+  it("works with components that have no custom statics", () => {
+    const Source = () => null
+    const Target = () => null
+
+    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
+  })
+
+  it("stops prototype recursion at Object.prototype", () => {
+    const Source = () => null
+    ;(Source as any).custom = "value"
+    // Source's prototype is Function.prototype which has proto Object.prototype
+    // The recursion should walk up and stop at Object.prototype
+
+    const Target = () => null
+    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
+    expect((Target as any).custom).toBe("value")
+  })
+})

package/src/__tests__/isEmpty.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest"
+import isEmpty from "../isEmpty"
+
+describe("isEmpty", () => {
+  it("should return true for null", () => {
+    expect(isEmpty(null)).toBe(true)
+  })
+
+  it("should return true for undefined", () => {
+    expect(isEmpty(undefined)).toBe(true)
+  })
+
+  it("should return true for empty object", () => {
+    expect(isEmpty({})).toBe(true)
+  })
+
+  it("should return true for empty array", () => {
+    expect(isEmpty([])).toBe(true)
+  })
+
+  it("should return false for non-empty object", () => {
+    expect(isEmpty({ a: 1 })).toBe(false)
+  })
+
+  it("should return false for non-empty array", () => {
+    expect(isEmpty([1])).toBe(false)
+  })
+
+  it("should return false for array with falsy values", () => {
+    expect(isEmpty([0, null, undefined])).toBe(false)
+  })
+
+  it("should return false for object with falsy values", () => {
+    expect(isEmpty({ a: 0, b: null })).toBe(false)
+  })
+
+  it("should return true for Object.create(null) with no properties", () => {
+    expect(isEmpty(Object.create(null))).toBe(true)
+  })
+
+  it("should return false for Object.create(null) with properties", () => {
+    const obj = Object.create(null)
+    obj.a = 1
+    expect(isEmpty(obj)).toBe(false)
+  })
+
+  it("should return true for non-object truthy primitives", () => {
+    // Covers typeof param !== 'object' branch
+    expect(isEmpty(42 as any)).toBe(true)
+    expect(isEmpty("hello" as any)).toBe(true)
+    expect(isEmpty(true as any)).toBe(true)
+  })
+})

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)
+    })
+  })
+})