@pyreon/core 0.24.4 → 0.24.6

package/src/tests/show.test.ts

@@ -1,314 +0,0 @@
-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')
-  })
-
-  // Value-or-accessor normalization. Previously `when` was strictly an
-  // accessor; passing a value crashed with "props.when is not a function".
-  // The compiler's signal auto-call rewrites bare `when={mySignal}` to
-  // `when={mySignal()}` at the prop site, producing a value — so the
-  // framework now accepts both shapes defensively.
-  test('accepts boolean value (true)', () => {
-    const getter = Show({ when: true, children: 'shown' }) as unknown as () => VNodeChild
-    expect(getter()).toBe('shown')
-  })
-
-  test('accepts boolean value (false)', () => {
-    const getter = Show({
-      when: false,
-      children: 'shown',
-      fallback: 'hidden',
-    }) as unknown as () => VNodeChild
-    expect(getter()).toBe('hidden')
-  })
-
-  test('accepts truthy value (string)', () => {
-    const getter = Show({ when: 'yes', children: 'shown' }) as unknown as () => VNodeChild
-    expect(getter()).toBe('shown')
-  })
-
-  test('accepts falsy value (0)', () => {
-    const getter = Show({
-      when: 0,
-      children: 'shown',
-      fallback: 'hidden',
-    }) as unknown as () => VNodeChild
-    expect(getter()).toBe('hidden')
-  })
-
-  test('accepts undefined as falsy', () => {
-    const getter = Show({
-      when: undefined as unknown as boolean,
-      children: 'shown',
-      fallback: 'hidden',
-    }) as unknown as () => VNodeChild
-    expect(getter()).toBe('hidden')
-  })
-
-  test('accessor and value forms produce identical behavior', () => {
-    const valueGetter = Show({ when: true, children: 'x' }) as unknown as () => VNodeChild
-    const accessorGetter = Show({ when: () => true, children: 'x' }) as unknown as () => VNodeChild
-    expect(valueGetter()).toBe(accessorGetter())
-  })
-})
-
-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')
-  })
-
-  // Match `when` accepts value or accessor — same defensive normalization as Show.
-  test('Match accepts boolean value', () => {
-    const result = Switch({
-      fallback: 'none',
-      children: [h(Match, { when: true }, 'matched')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('matched')
-  })
-
-  test('Match with all-false boolean values renders fallback', () => {
-    const result = Switch({
-      fallback: 'none',
-      children: [h(Match, { when: false }, 'a'), h(Match, { when: false }, 'b')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('none')
-  })
-
-  test('Match mixes value and accessor branches in same Switch', () => {
-    const result = Switch({
-      fallback: 'none',
-      children: [h(Match, { when: false }, 'a'), h(Match, { when: () => true }, 'b')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('b')
-  })
-})

package/src/tests/style.test.ts

@@ -1,157 +0,0 @@
-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')
-  })
-})

package/src/tests/suspense.test.ts

@@ -1,139 +0,0 @@
-import { Fragment, h } from '../h'
-import { Suspense } from '../suspense'
-import type { ComponentFn, VNodeChild } from '../types'
-
-describe('Suspense', () => {
-  test('returns a Fragment VNode', () => {
-    const node = Suspense({
-      fallback: h('div', null, 'loading'),
-      children: h('div', null, 'content'),
-    })
-    expect(node.type).toBe(Fragment)
-  })
-
-  test('Fragment contains a single reactive getter child', () => {
-    const node = Suspense({
-      fallback: h('span', null, 'loading'),
-      children: h('div', null, 'content'),
-    })
-    expect(node.children).toHaveLength(1)
-    expect(typeof node.children[0]).toBe('function')
-  })
-
-  test('renders children when not loading (plain VNode)', () => {
-    const child = h('div', null, 'loaded')
-    const node = Suspense({
-      fallback: h('span', null, 'loading'),
-      children: child,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('renders children when child type has no __loading', () => {
-    const regularComp: ComponentFn = () => h('div', null)
-    const child = h(regularComp, null)
-    const node = Suspense({
-      fallback: 'loading',
-      children: child,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('renders fallback when child __loading() is true', () => {
-    const fallback = h('span', null, 'loading...')
-    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
-      __loading: () => boolean
-    }
-    lazyFn.__loading = () => true
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(fallback)
-  })
-
-  test('renders children when __loading() is false', () => {
-    const fallback = h('span', null, 'loading...')
-    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
-      __loading: () => boolean
-    }
-    lazyFn.__loading = () => false
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('handles function children (reactive getter)', () => {
-    const child = h('div', null, 'content')
-    const node = Suspense({
-      fallback: h('span', null, 'loading'),
-      children: () => child,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('evaluates function fallback', () => {
-    const fbNode = h('div', null, 'fb')
-    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
-      __loading: () => boolean
-    }
-    lazyFn.__loading = () => true
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback: () => fbNode, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(fbNode)
-  })
-
-  test('handles null/undefined children', () => {
-    const node = Suspense({ fallback: 'loading' })
-    const getter = node.children[0] as () => VNodeChild
-    // undefined children — not a VNode, not loading
-    expect(getter()).toBeUndefined()
-  })
-
-  test('handles string children', () => {
-    const node = Suspense({ fallback: 'loading', children: 'text content' })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe('text content')
-  })
-
-  test('handles array children (not loading)', () => {
-    const children = [h('a', null), h('b', null)]
-    const node = Suspense({
-      fallback: 'loading',
-      children: children as unknown as VNodeChild,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(children)
-  })
-
-  test('warns when fallback prop is missing', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    Suspense({ fallback: undefined as unknown as VNodeChild, children: 'x' })
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<Suspense>'))
-    warnSpy.mockRestore()
-  })
-
-  test('transition from loading to loaded', () => {
-    let isLoading = true
-    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & {
-      __loading: () => boolean
-    }
-    lazyFn.__loading = () => isLoading
-    const child = h(lazyFn, null)
-    const fallback = h('span', null, 'loading')
-
-    const node = Suspense({ fallback, children: child })
-    const getter = node.children[0] as () => VNodeChild
-
-    expect(getter()).toBe(fallback)
-    isLoading = false
-    expect(getter()).toBe(child)
-  })
-})