@pyreon/core 0.7.12 → 0.7.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/core",
-  "version": "0.7.12",
+  "version": "0.7.13",
   "description": "Core component model and lifecycle for Pyreon",
   "license": "MIT",
   "repository": {
@@ -49,7 +49,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/reactivity": "^0.7.12"
+    "@pyreon/reactivity": "^0.7.13"
   },
   "publishConfig": {
     "access": "public"

package/src/tests/cx.test.ts

@@ -38,4 +38,33 @@ describe("cx", () => {
     expect(cx([])).toBe("")
     expect(cx({})).toBe("")
   })
+
+  test("object where ALL values are functions returning booleans", () => {
+    expect(
+      cx({
+        active: () => true,
+        hidden: () => false,
+        bold: () => true,
+        italic: () => false,
+      }),
+    ).toBe("active bold")
+  })
+
+  test("deeply nested arrays (3+ levels)", () => {
+    expect(cx([[["level3", [["level5"]]]]])).toBe("level3 level5")
+  })
+
+  test("mixed: string, object with function, deeply nested array", () => {
+    expect(cx(["base", { active: () => true }, [["deeply-nested"]]])).toBe(
+      "base active deeply-nested",
+    )
+  })
+
+  test("empty string values are filtered", () => {
+    expect(cx(["foo", "", "bar", ""])).toBe("foo bar")
+  })
+
+  test("number 0 is a valid class name as string", () => {
+    expect(cx(0)).toBe("0")
+  })
 })

package/src/tests/props.test.ts

@@ -66,6 +66,100 @@ describe("mergeProps", () => {
   })
 })
 
+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 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")
+  })
+
+  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", {
+      get: () => level1,
+      enumerable: true,
+      configurable: true,
+    })
+    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")
+    // Mid-level getter returns value — top still undefined, falls to mid
+    level1 = "dark"
+    expect(result.theme).toBe("dark")
+    // Top-level getter returns value — wins
+    level2 = "system"
+    expect(result.theme).toBe("system")
+  })
+
+  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", {
+      get: () => dynamic,
+      enumerable: true,
+      configurable: true,
+    })
+    const staticSource = { val: "static-wins" }
+    const result = mergeProps(getterSource, staticSource)
+    // Static value should override getter
+    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", {
+      get: () => dynamic,
+      enumerable: true,
+      configurable: true,
+    })
+    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")
+  })
+})
+
+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", {
+      get: () => ++count,
+      enumerable: true,
+      configurable: true,
+    })
+    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" })
+  })
+})
+
 describe("createUniqueId", () => {
   test("returns incrementing IDs", () => {
     const id1 = createUniqueId()