@pyreon/core 0.11.2 → 0.11.4

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

@@ -0,0 +1,157 @@
+import { _resetIdCounter, createUniqueId, mergeProps, splitProps } from "../props"
+
+describe("createUniqueId — extended", () => {
+  test("returns pyreon- prefixed string", () => {
+    const id = createUniqueId()
+    expect(id).toMatch(/^pyreon-\d+$/)
+  })
+
+  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)
+    expect(num2).toBe(num1 + 1)
+    expect(num3).toBe(num2 + 1)
+  })
+
+  test("all IDs are unique", () => {
+    const ids = new Set<string>()
+    for (let i = 0; i < 100; i++) {
+      ids.add(createUniqueId())
+    }
+    expect(ids.size).toBe(100)
+  })
+})
+
+describe("_resetIdCounter", () => {
+  test("resets the counter so IDs restart", () => {
+    // Generate some IDs to advance counter
+    createUniqueId()
+    createUniqueId()
+
+    _resetIdCounter()
+
+    const id = createUniqueId()
+    expect(id).toBe("pyreon-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")
+  })
+})
+
+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])
+    expect(Object.keys(own)).toEqual([])
+    expect(rest).toEqual({ a: 1, b: 2 })
+  })
+
+  test("all keys in picked leaves rest empty", () => {
+    const props = { x: 10, y: 20 }
+    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", () => {
+    let count = 0
+    const props = {} as Record<string, unknown>
+    Object.defineProperty(props, "reactive", {
+      get: () => ++count,
+      enumerable: true,
+      configurable: true,
+    })
+    Object.defineProperty(props, "other", {
+      value: "static",
+      enumerable: true,
+      configurable: true,
+    })
+
+    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"])
+    expect(own.a).toBeUndefined()
+    expect((rest as Record<string, unknown>).b).toBe("defined")
+  })
+})
+
+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", () => {
+    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("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"
+    const getterSrc = {} as Record<string, unknown>
+    Object.defineProperty(getterSrc, "val", {
+      get: () => dynamic,
+      enumerable: true,
+      configurable: true,
+    })
+    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")
+  })
+
+  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", {
+      get: () => g1val,
+      enumerable: true,
+      configurable: true,
+    })
+
+    const src2 = {} as Record<string, unknown>
+    Object.defineProperty(src2, "x", {
+      get: () => g2val,
+      enumerable: true,
+      configurable: true,
+    })
+
+    const result = mergeProps(src1, src2)
+    expect(result.x).toBe("g2")
+
+    g2val = undefined
+    expect(result.x).toBe("g1")
+
+    g1val = undefined
+    expect(result.x).toBeUndefined()
+  })
+})

package/src/tests/ref.test.ts

@@ -0,0 +1,70 @@
+import type { Ref, RefCallback, RefProp } from "../ref"
+import { createRef } from "../ref"
+
+describe("createRef", () => {
+  test("returns object with current = null", () => {
+    const ref = createRef()
+    expect(ref.current).toBeNull()
+  })
+
+  test("current is mutable", () => {
+    const ref = createRef<number>()
+    ref.current = 42
+    expect(ref.current).toBe(42)
+  })
+
+  test("typed ref — HTMLElement", () => {
+    const ref = createRef<HTMLDivElement>()
+    expect(ref.current).toBeNull()
+    // In real code, runtime-dom sets this after mount
+    ref.current = {} as HTMLDivElement
+    expect(ref.current).not.toBeNull()
+  })
+
+  test("typed ref — string", () => {
+    const ref = createRef<string>()
+    ref.current = "hello"
+    expect(ref.current).toBe("hello")
+  })
+
+  test("can be reset to null", () => {
+    const ref = createRef<number>()
+    ref.current = 99
+    expect(ref.current).toBe(99)
+    ref.current = null
+    expect(ref.current).toBeNull()
+  })
+
+  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", () => {
+    const ref = createRef()
+    expect(Object.keys(ref)).toEqual(["current"])
+  })
+
+  test("ref object shape matches Ref interface", () => {
+    const ref: Ref<number> = createRef<number>()
+    expect("current" in ref).toBe(true)
+    expect(ref.current).toBeNull()
+  })
+})
+
+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")
+  })
+
+  test("object ref can be assigned to RefProp", () => {
+    const ref = createRef<HTMLElement>()
+    const prop: RefProp<HTMLElement> = ref
+    expect(typeof prop).toBe("object")
+    expect(prop).toBe(ref)
+  })
+})

package/src/tests/show.test.ts

@@ -0,0 +1,238 @@
+import { h } from "../h"
+import { Match, MatchSymbol, Show, Switch } from "../show"
+import type { VNodeChild } from "../types"
+
+describe("Show", () => {
+  test("returns a reactive getter (function)", () => {
+    const result = Show({ when: () => true, children: "visible" })
+    expect(typeof result).toBe("function")
+  })
+
+  test("getter returns children when condition is truthy", () => {
+    const getter = Show({ when: () => true, children: "visible" }) as unknown as () => VNodeChild
+    expect(getter()).toBe("visible")
+  })
+
+  test("getter returns null when condition is falsy and no fallback", () => {
+    const getter = Show({ when: () => false, children: "hidden" }) as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("getter returns fallback when condition is falsy", () => {
+    const fb = h("span", null, "fallback")
+    const getter = Show({
+      when: () => false,
+      fallback: fb,
+      children: "main",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe(fb)
+  })
+
+  test("reacts to condition changes", () => {
+    let flag = true
+    const getter = Show({
+      when: () => flag,
+      children: "yes",
+      fallback: "no",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("yes")
+    flag = false
+    expect(getter()).toBe("no")
+    flag = true
+    expect(getter()).toBe("yes")
+  })
+
+  test("returns null for undefined children when truthy", () => {
+    const getter = Show({ when: () => true }) as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("returns null for undefined fallback when falsy", () => {
+    const getter = Show({ when: () => false, children: "x" }) as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("VNode children are preserved as-is", () => {
+    const child = h("div", null, "content")
+    const getter = Show({ when: () => true, children: child }) as unknown as () => VNodeChild
+    expect(getter()).toBe(child)
+  })
+
+  test("truthiness: non-empty string", () => {
+    const getter = Show({
+      when: () => "truthy-string",
+      children: "shown",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("shown")
+  })
+
+  test("truthiness: 0 is falsy", () => {
+    const getter = Show({
+      when: () => 0,
+      children: "shown",
+      fallback: "hidden",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("hidden")
+  })
+
+  test("truthiness: empty string is falsy", () => {
+    const getter = Show({
+      when: () => "",
+      children: "shown",
+      fallback: "hidden",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("hidden")
+  })
+
+  test("truthiness: null is falsy", () => {
+    const getter = Show({
+      when: () => null,
+      children: "shown",
+      fallback: "hidden",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("hidden")
+  })
+
+  test("truthiness: object is truthy", () => {
+    const getter = Show({
+      when: () => ({ a: 1 }),
+      children: "shown",
+    }) as unknown as () => VNodeChild
+    expect(getter()).toBe("shown")
+  })
+})
+
+describe("Match", () => {
+  test("returns null (marker-only component)", () => {
+    const result = Match({ when: () => true, children: "content" })
+    expect(result).toBeNull()
+  })
+
+  test("MatchSymbol is a unique symbol", () => {
+    expect(typeof MatchSymbol).toBe("symbol")
+    expect(MatchSymbol.toString()).toContain("pyreon.Match")
+  })
+})
+
+describe("Switch", () => {
+  test("renders first truthy Match branch", () => {
+    const result = Switch({
+      children: [
+        h(Match, { when: () => false }, "first"),
+        h(Match, { when: () => true }, "second"),
+        h(Match, { when: () => true }, "third"),
+      ],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("second")
+  })
+
+  test("renders fallback when no match", () => {
+    const fb = h("p", null, "404")
+    const result = Switch({
+      fallback: fb,
+      children: [h(Match, { when: () => false }, "a"), h(Match, { when: () => false }, "b")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe(fb)
+  })
+
+  test("returns null when no match and no fallback", () => {
+    const result = Switch({
+      children: [h(Match, { when: () => false }, "a")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("handles single child (not array)", () => {
+    const result = Switch({
+      children: h(Match, { when: () => true }, "only"),
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("only")
+  })
+
+  test("handles no children", () => {
+    const result = Switch({})
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("handles null/undefined children", () => {
+    const result = Switch({ children: null as unknown as VNodeChild })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBeNull()
+  })
+
+  test("skips non-Match VNode children", () => {
+    const result = Switch({
+      fallback: "default",
+      children: [h("div", null, "not-a-match"), h(Match, { when: () => true }, "found")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("found")
+  })
+
+  test("skips non-object children (strings, null)", () => {
+    const result = Switch({
+      fallback: "default",
+      children: [
+        null as unknown as VNodeChild,
+        "string-child" as unknown as VNodeChild,
+        h(Match, { when: () => true }, "found"),
+      ],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("found")
+  })
+
+  test("reacts to condition changes", () => {
+    let a = false
+    let b = false
+    const result = Switch({
+      fallback: "none",
+      children: [h(Match, { when: () => a }, "A"), h(Match, { when: () => b }, "B")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("none")
+    b = true
+    expect(getter()).toBe("B")
+    a = true
+    expect(getter()).toBe("A") // first match wins
+    b = false
+    expect(getter()).toBe("A")
+    a = false
+    expect(getter()).toBe("none")
+  })
+
+  test("Match with multiple children returns array", () => {
+    const result = Switch({
+      children: [h(Match, { when: () => true }, "child1", "child2")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    const value = getter()
+    expect(Array.isArray(value)).toBe(true)
+    expect(value).toEqual(["child1", "child2"])
+  })
+
+  test("Match with zero vnode.children falls back to props.children", () => {
+    const matchVNode = {
+      type: Match,
+      props: { when: () => true, children: "from-props" },
+      children: [],
+      key: null,
+    } as unknown as VNodeChild
+    const result = Switch({ children: [matchVNode] })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("from-props")
+  })
+
+  test("Match with single vnode.children returns it directly (not array)", () => {
+    const result = Switch({
+      children: [h(Match, { when: () => true }, "single")],
+    })
+    const getter = result as unknown as () => VNodeChild
+    expect(getter()).toBe("single")
+  })
+})

package/src/tests/style.test.ts

@@ -0,0 +1,157 @@
+import { CSS_UNITLESS, cx, normalizeStyleValue, toKebabCase } from "../style"
+
+// cx() is extensively tested in cx.test.ts — these tests cover toKebabCase,
+// normalizeStyleValue, and CSS_UNITLESS which are used by runtime-dom/runtime-server.
+
+describe("toKebabCase", () => {
+  test("converts camelCase to kebab-case", () => {
+    expect(toKebabCase("backgroundColor")).toBe("background-color")
+  })
+
+  test("handles single uppercase letter", () => {
+    expect(toKebabCase("zIndex")).toBe("z-index")
+  })
+
+  test("handles multiple uppercase letters", () => {
+    expect(toKebabCase("borderTopLeftRadius")).toBe("border-top-left-radius")
+  })
+
+  test("returns lowercase string unchanged", () => {
+    expect(toKebabCase("color")).toBe("color")
+  })
+
+  test("handles empty string", () => {
+    expect(toKebabCase("")).toBe("")
+  })
+
+  test("handles consecutive uppercase (treated individually)", () => {
+    expect(toKebabCase("MSTransform")).toBe("-m-s-transform")
+  })
+
+  test("handles leading lowercase with single word", () => {
+    expect(toKebabCase("opacity")).toBe("opacity")
+  })
+})
+
+describe("normalizeStyleValue", () => {
+  test("appends px to numbers for non-unitless properties", () => {
+    expect(normalizeStyleValue("width", 100)).toBe("100px")
+    expect(normalizeStyleValue("height", 50)).toBe("50px")
+    expect(normalizeStyleValue("padding", 0)).toBe("0px")
+    expect(normalizeStyleValue("marginTop", 20)).toBe("20px")
+  })
+
+  test("does not append px to unitless properties", () => {
+    expect(normalizeStyleValue("opacity", 0.5)).toBe("0.5")
+    expect(normalizeStyleValue("zIndex", 10)).toBe("10")
+    expect(normalizeStyleValue("flexGrow", 1)).toBe("1")
+    expect(normalizeStyleValue("fontWeight", 700)).toBe("700")
+    expect(normalizeStyleValue("lineHeight", 1.5)).toBe("1.5")
+    expect(normalizeStyleValue("order", 3)).toBe("3")
+    expect(normalizeStyleValue("columns", 2)).toBe("2")
+    expect(normalizeStyleValue("flex", 1)).toBe("1")
+    expect(normalizeStyleValue("scale", 2)).toBe("2")
+    expect(normalizeStyleValue("widows", 2)).toBe("2")
+    expect(normalizeStyleValue("orphans", 3)).toBe("3")
+  })
+
+  test("passes through string values unchanged", () => {
+    expect(normalizeStyleValue("width", "100%")).toBe("100%")
+    expect(normalizeStyleValue("color", "red")).toBe("red")
+    expect(normalizeStyleValue("display", "flex")).toBe("flex")
+  })
+
+  test("converts non-string/non-number to string", () => {
+    expect(normalizeStyleValue("display", null)).toBe("null")
+    expect(normalizeStyleValue("display", undefined)).toBe("undefined")
+    expect(normalizeStyleValue("display", true)).toBe("true")
+  })
+
+  test("handles zero correctly for non-unitless props", () => {
+    expect(normalizeStyleValue("margin", 0)).toBe("0px")
+  })
+
+  test("handles negative numbers", () => {
+    expect(normalizeStyleValue("marginLeft", -10)).toBe("-10px")
+    expect(normalizeStyleValue("zIndex", -1)).toBe("-1")
+  })
+})
+
+describe("CSS_UNITLESS", () => {
+  test("is a Set", () => {
+    expect(CSS_UNITLESS).toBeInstanceOf(Set)
+  })
+
+  test("contains common unitless properties", () => {
+    expect(CSS_UNITLESS.has("opacity")).toBe(true)
+    expect(CSS_UNITLESS.has("zIndex")).toBe(true)
+    expect(CSS_UNITLESS.has("fontWeight")).toBe(true)
+    expect(CSS_UNITLESS.has("lineHeight")).toBe(true)
+    expect(CSS_UNITLESS.has("flex")).toBe(true)
+    expect(CSS_UNITLESS.has("flexGrow")).toBe(true)
+    expect(CSS_UNITLESS.has("flexShrink")).toBe(true)
+    expect(CSS_UNITLESS.has("order")).toBe(true)
+    expect(CSS_UNITLESS.has("columnCount")).toBe(true)
+    expect(CSS_UNITLESS.has("animationIterationCount")).toBe(true)
+  })
+
+  test("contains SVG unitless properties", () => {
+    expect(CSS_UNITLESS.has("fillOpacity")).toBe(true)
+    expect(CSS_UNITLESS.has("floodOpacity")).toBe(true)
+    expect(CSS_UNITLESS.has("stopOpacity")).toBe(true)
+    expect(CSS_UNITLESS.has("strokeOpacity")).toBe(true)
+    expect(CSS_UNITLESS.has("strokeWidth")).toBe(true)
+    expect(CSS_UNITLESS.has("strokeMiterlimit")).toBe(true)
+    expect(CSS_UNITLESS.has("strokeDasharray")).toBe(true)
+    expect(CSS_UNITLESS.has("strokeDashoffset")).toBe(true)
+  })
+
+  test("does not contain properties that need units", () => {
+    expect(CSS_UNITLESS.has("width")).toBe(false)
+    expect(CSS_UNITLESS.has("height")).toBe(false)
+    expect(CSS_UNITLESS.has("margin")).toBe(false)
+    expect(CSS_UNITLESS.has("padding")).toBe(false)
+    expect(CSS_UNITLESS.has("fontSize")).toBe(false)
+    expect(CSS_UNITLESS.has("borderWidth")).toBe(false)
+    expect(CSS_UNITLESS.has("top")).toBe(false)
+    expect(CSS_UNITLESS.has("left")).toBe(false)
+  })
+})
+
+describe("cx — additional edge cases", () => {
+  test("object with all false values", () => {
+    expect(cx({ a: false, b: false, c: false })).toBe("")
+  })
+
+  test("object with null and undefined values", () => {
+    expect(cx({ a: null, b: undefined, c: true })).toBe("c")
+  })
+
+  test("mixed array of numbers, strings, and objects", () => {
+    expect(cx([1, "two", { three: true, four: false }])).toBe("1 two three")
+  })
+
+  test("single-element array", () => {
+    expect(cx(["only"])).toBe("only")
+  })
+
+  test("number 0 in an array", () => {
+    expect(cx([0, "one"])).toBe("0 one")
+  })
+
+  test("boolean true in array is filtered", () => {
+    expect(cx([true, "visible"])).toBe("visible")
+  })
+
+  test("nested empty arrays", () => {
+    expect(cx([[], [[]], [[[]]]])).toBe("")
+  })
+
+  test("object with function returning false", () => {
+    expect(cx({ hidden: () => false })).toBe("")
+  })
+
+  test("single key object", () => {
+    expect(cx({ active: true })).toBe("active")
+  })
+})