@pyreon/core 0.11.5 → 0.11.6

package/src/tests/show.test.ts

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

package/src/tests/style.test.ts

@@ -1,157 +1,157 @@
-import { CSS_UNITLESS, cx, normalizeStyleValue, toKebabCase } from "../style"
+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")
+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 single uppercase letter', () => {
+    expect(toKebabCase('zIndex')).toBe('z-index')
   })
 
-  test("handles multiple uppercase letters", () => {
-    expect(toKebabCase("borderTopLeftRadius")).toBe("border-top-left-radius")
+  test('handles multiple uppercase letters', () => {
+    expect(toKebabCase('borderTopLeftRadius')).toBe('border-top-left-radius')
   })
 
-  test("returns lowercase string unchanged", () => {
-    expect(toKebabCase("color")).toBe("color")
+  test('returns lowercase string unchanged', () => {
+    expect(toKebabCase('color')).toBe('color')
   })
 
-  test("handles empty string", () => {
-    expect(toKebabCase("")).toBe("")
+  test('handles empty string', () => {
+    expect(toKebabCase('')).toBe('')
   })
 
-  test("handles consecutive uppercase (treated individually)", () => {
-    expect(toKebabCase("MSTransform")).toBe("-m-s-transform")
+  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")
+  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")
+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('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('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('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 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")
+  test('handles negative numbers', () => {
+    expect(normalizeStyleValue('marginLeft', -10)).toBe('-10px')
+    expect(normalizeStyleValue('zIndex', -1)).toBe('-1')
   })
 })
 
-describe("CSS_UNITLESS", () => {
-  test("is a Set", () => {
+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)
+  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("")
+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('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('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('single-element array', () => {
+    expect(cx(['only'])).toBe('only')
   })
 
-  test("number 0 in an array", () => {
-    expect(cx([0, "one"])).toBe("0 one")
+  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('boolean true in array is filtered', () => {
+    expect(cx([true, 'visible'])).toBe('visible')
   })
 
-  test("nested empty arrays", () => {
-    expect(cx([[], [[]], [[[]]]])).toBe("")
+  test('nested empty arrays', () => {
+    expect(cx([[], [[]], [[[]]]])).toBe('')
   })
 
-  test("object with function returning false", () => {
-    expect(cx({ hidden: () => false })).toBe("")
+  test('object with function returning false', () => {
+    expect(cx({ hidden: () => false })).toBe('')
   })
 
-  test("single key object", () => {
-    expect(cx({ active: true })).toBe("active")
+  test('single key object', () => {
+    expect(cx({ active: true })).toBe('active')
   })
 })