@pyreon/core 0.24.5 → 0.24.6

package/src/tests/extract-props-overloads.types.test.ts

@@ -1,135 +0,0 @@
-/**
- * Compile-time type tests for `ExtractProps` multi-overload narrowing.
- *
- * Regression: pre-fix, `ExtractProps<T>` collapsed multi-overload functions
- * to the LAST overload's props — TS's overload-resolution-against-conditional-
- * types semantics. Multi-overload primitives (Iterator / List / Element in
- * `@pyreon/elements`) silently downgraded their public prop surface to the
- * loosest overload when wrapped through `rocketstyle()` / `attrs()`. The
- * fix matches up to 4 call signatures via pattern matching and produces the
- * UNION of every overload's first-argument type.
- *
- * Mirrors vitus-labs PR #222. Kept in sync across the 4 copies in
- * `@pyreon/core`, `@pyreon/elements`, `@pyreon/attrs`, and `@pyreon/rocketstyle`
- * — the canonical reference test lives here.
- */
-
-import { describe, expectTypeOf, it } from 'vitest'
-import type { ComponentFn, ExtractProps, VNodeChild } from '../index'
-
-describe('ExtractProps — single-overload functions still work', () => {
-  it('extracts props from a ComponentFn<P>', () => {
-    type Greet = ComponentFn<{ name: string }>
-    expectTypeOf<ExtractProps<Greet>>().toEqualTypeOf<{ name: string }>()
-  })
-
-  it('extracts props from a bare (props: P) => any signature', () => {
-    type Fn = (props: { count: number }) => string
-    expectTypeOf<ExtractProps<Fn>>().toEqualTypeOf<{ count: number }>()
-  })
-
-  it('passes through a non-function shape unchanged', () => {
-    type Props = { id: string; value: number }
-    expectTypeOf<ExtractProps<Props>>().toEqualTypeOf<Props>()
-  })
-})
-
-describe('ExtractProps — multi-overload narrowing (load-bearing assertions)', () => {
-  it('unions both arms of a 2-overload function', () => {
-    interface TwoOverloads {
-      (props: { kind: 'a'; value: number }): VNodeChild
-      (props: { kind: 'b'; value: string }): VNodeChild
-    }
-    type Props = ExtractProps<TwoOverloads>
-    // Both shapes appear in the extracted union.
-    expectTypeOf<Props>().toEqualTypeOf<
-      { kind: 'a'; value: number } | { kind: 'b'; value: string }
-    >()
-  })
-
-  it('unions all three arms of a 3-overload function (Iterator/List/Element shape)', () => {
-    interface ThreeOverloads {
-      (props: { mode: 'simple'; data: string[] }): VNodeChild
-      (props: { mode: 'object'; data: { id: number }[] }): VNodeChild
-      (props: { mode: 'children'; children: unknown }): VNodeChild
-    }
-    type Props = ExtractProps<ThreeOverloads>
-    expectTypeOf<Props>().toEqualTypeOf<
-      | { mode: 'simple'; data: string[] }
-      | { mode: 'object'; data: { id: number }[] }
-      | { mode: 'children'; children: unknown }
-    >()
-  })
-
-  it('unions all four arms of a 4-overload function', () => {
-    interface FourOverloads {
-      (props: { variant: 'a' }): VNodeChild
-      (props: { variant: 'b' }): VNodeChild
-      (props: { variant: 'c' }): VNodeChild
-      (props: { variant: 'd' }): VNodeChild
-    }
-    type Props = ExtractProps<FourOverloads>
-    expectTypeOf<Props>().toEqualTypeOf<
-      { variant: 'a' } | { variant: 'b' } | { variant: 'c' } | { variant: 'd' }
-    >()
-  })
-})
-
-describe('ExtractProps — bisect-load-bearing: pre-fix shape would FAIL these', () => {
-  /**
-   * If `ExtractProps<T>` were reverted to `T extends ComponentFn<infer P> ? P : T`,
-   * each of these would extract only the LAST overload's props and the
-   * `toEqualTypeOf<union>` check would fail at compile time. This is the
-   * structural anchor — the load-bearing regression guard.
-   */
-
-  it('a 2-overload function MUST extract BOTH arms (not just the last)', () => {
-    interface OverloadedComp {
-      (props: { mode: 'a'; valueA: number }): VNodeChild
-      (props: { mode: 'b'; valueB: string }): VNodeChild
-    }
-    // The first arm `{ mode: 'a'; valueA: number }` must be present in the
-    // union. Pre-fix, the conditional collapsed to just the LAST arm.
-    type Props = ExtractProps<OverloadedComp>
-    // Assignability check: both shapes must be assignable to the extracted type.
-    const a: Props = { mode: 'a', valueA: 1 }
-    const b: Props = { mode: 'b', valueB: 'x' }
-    void a
-    void b
-  })
-
-  it("a 3-overload Iterator-shaped surface MUST surface SimpleProps + ObjectProps + ChildrenProps", () => {
-    // Synthetic Iterator overload-shape — mirrors the real
-    // `@pyreon/elements` Iterator. The structural failure mode pre-fix:
-    // `ExtractProps<typeof Iterator>` returned just `ChildrenProps`, so any
-    // HOC wrapping (rocketstyle, attrs) lost the SimpleProps + ObjectProps
-    // surfaces from the public typed API.
-    type SimpleItem = ComponentFn<{ value: string }>
-    type ObjectItem = ComponentFn<{ id: number }>
-    interface IteratorLike {
-      <T extends string | number>(props: {
-        data: T[]
-        component: SimpleItem
-        valueName?: string
-      }): VNodeChild
-      <T extends { id: number }>(props: {
-        data: T[]
-        component: ObjectItem
-      }): VNodeChild
-      (props: { children: VNodeChild }): VNodeChild
-    }
-    type Props = ExtractProps<IteratorLike>
-
-    const noopSimple: SimpleItem = () => null
-    const noopObject: ObjectItem = () => null
-    // SimpleProps arm assignable:
-    const simple: Props = { data: ['a', 'b'], component: noopSimple, valueName: 'text' }
-    // ObjectProps arm assignable:
-    const obj: Props = { data: [{ id: 1 }], component: noopObject }
-    // ChildrenProps arm assignable:
-    const ch: Props = { children: null }
-    void simple
-    void obj
-    void ch
-  })
-})

package/src/tests/for.test.ts

@@ -1,117 +0,0 @@
-import { For, ForSymbol } from '../for'
-import { h } from '../h'
-import type { VNode } from '../types'
-
-describe('For', () => {
-  test('returns VNode with ForSymbol type', () => {
-    const node = For({
-      each: () => [1, 2, 3],
-      by: (item) => item,
-      children: (item) => h('li', null, String(item)),
-    })
-    expect(node.type).toBe(ForSymbol)
-  })
-
-  test('VNode has empty children array', () => {
-    const node = For({
-      each: () => [],
-      by: (item: number) => item,
-      children: (item) => h('span', null, String(item)),
-    })
-    expect(node.children).toEqual([])
-  })
-
-  test('VNode has null key', () => {
-    const node = For({
-      each: () => [1],
-      by: (item) => item,
-      children: (item) => h('li', null, String(item)),
-    })
-    expect(node.key).toBeNull()
-  })
-
-  test('props contain each, by, children functions', () => {
-    const eachFn = () => ['a', 'b']
-    const byFn = (item: string) => item
-    const childFn = (item: string) => h('span', null, item)
-    const node = For({ each: eachFn, by: byFn, children: childFn })
-
-    const props = node.props as unknown as {
-      each: typeof eachFn
-      by: typeof byFn
-      children: typeof childFn
-    }
-    expect(props.each).toBe(eachFn)
-    expect(props.by).toBe(byFn)
-    expect(props.children).toBe(childFn)
-  })
-
-  test('ForSymbol is a unique symbol', () => {
-    expect(typeof ForSymbol).toBe('symbol')
-    expect(ForSymbol.toString()).toContain('pyreon.For')
-  })
-
-  test('works with object items', () => {
-    interface Item {
-      id: number
-      name: string
-    }
-    const items: Item[] = [
-      { id: 1, name: 'one' },
-      { id: 2, name: 'two' },
-    ]
-    const node = For<Item>({
-      each: () => items,
-      by: (item) => item.id,
-      children: (item) => h('li', null, item.name),
-    })
-    expect(node.type).toBe(ForSymbol)
-    const props = node.props as unknown as { each: () => Item[] }
-    expect(props.each()).toBe(items)
-  })
-
-  test('works with string keys', () => {
-    const node = For({
-      each: () => [{ slug: 'hello' }, { slug: 'world' }],
-      by: (item) => item.slug,
-      children: (item) => h('div', null, item.slug),
-    })
-    expect(node.type).toBe(ForSymbol)
-  })
-
-  test('children function produces VNodes', () => {
-    const childFn = (n: number) => h('li', { key: n }, String(n))
-    const node = For({
-      each: () => [1, 2, 3],
-      by: (n) => n,
-      children: childFn,
-    })
-    const props = node.props as unknown as { children: typeof childFn }
-    const result = props.children(1)
-    expect((result as VNode).type).toBe('li')
-    expect((result as VNode).key).toBe(1)
-  })
-
-  // Regression: `ForProps.each` previously typed as `() => T[]` only.
-  // Users writing `<For each={items}>` (with `items: T[]` directly) hit
-  // a confusing TS error: `Type 'T[]' is not assignable to type
-  // '() => T[]'`. The runtime in `runtime-dom/src/mount.ts:144-147`
-  // already accepted both shapes — only the type was forcing the
-  // accessor form. Type now accepts `T[] | (() => T[])` so users with
-  // already-resolved arrays don't need to wrap them in a thunk just to
-  // satisfy the type.
-  test('each accepts T[] directly (not just () => T[])', () => {
-    // TypeScript-level test: this would not compile pre-fix.
-    const items = [1, 2, 3]
-    const childFn = (n: number): VNode => h('li', { key: n }, String(n))
-    const node = For<number>({ each: items, by: (n) => n, children: childFn })
-    expect(node.type).toBe(ForSymbol as unknown as string)
-    // Both shapes still work — function form continues to typecheck.
-    const node2 = For<number>({
-      each: () => items,
-      by: (n) => n,
-      children: childFn,
-    })
-    expect(node2.type).toBe(ForSymbol as unknown as string)
-  })
-})

package/src/tests/h.test.ts

@@ -1,221 +0,0 @@
-import { EMPTY_PROPS, Fragment, h } from '../h'
-import type { ComponentFn, VNode, VNodeChild } from '../types'
-
-describe('h() — VNode creation', () => {
-  describe('basic element creation', () => {
-    test('creates VNode with string tag', () => {
-      const node = h('div', null)
-      expect(node.type).toBe('div')
-      expect(node.props).toBe(EMPTY_PROPS)
-      expect(node.children).toEqual([])
-      expect(node.key).toBeNull()
-    })
-
-    test('creates VNode with props', () => {
-      const node = h('div', { id: 'main', class: 'container' })
-      expect(node.props.id).toBe('main')
-      expect(node.props.class).toBe('container')
-    })
-
-    test('null props becomes EMPTY_PROPS sentinel', () => {
-      const node1 = h('div', null)
-      const node2 = h('span', null)
-      // Both should use the same EMPTY_PROPS object (identity check)
-      expect(node1.props).toBe(node2.props)
-      expect(node1.props).toBe(EMPTY_PROPS)
-    })
-  })
-
-  describe('key extraction', () => {
-    test('extracts string key from props', () => {
-      const node = h('li', { key: 'item-1' })
-      expect(node.key).toBe('item-1')
-    })
-
-    test('extracts numeric key from props', () => {
-      const node = h('li', { key: 42 })
-      expect(node.key).toBe(42)
-    })
-
-    test('key is null when not provided', () => {
-      const node = h('div', { class: 'x' })
-      expect(node.key).toBeNull()
-    })
-
-    test('key is null for null props', () => {
-      const node = h('div', null)
-      expect(node.key).toBeNull()
-    })
-
-    test('key 0 is preserved (falsy but valid)', () => {
-      const node = h('li', { key: 0 })
-      expect(node.key).toBe(0)
-    })
-  })
-
-  describe('children handling', () => {
-    test('string children', () => {
-      const node = h('p', null, 'hello')
-      expect(node.children).toEqual(['hello'])
-    })
-
-    test('multiple string children', () => {
-      const node = h('p', null, 'hello', ' ', 'world')
-      expect(node.children).toEqual(['hello', ' ', 'world'])
-    })
-
-    test('number children', () => {
-      const node = h('span', null, 42)
-      expect(node.children).toEqual([42])
-    })
-
-    test('VNode children', () => {
-      const child = h('span', null, 'inner')
-      const parent = h('div', null, child)
-      expect(parent.children).toHaveLength(1)
-      expect((parent.children[0] as VNode).type).toBe('span')
-    })
-
-    test('mixed children types', () => {
-      const child = h('em', null)
-      const getter = () => 'reactive'
-      const node = h('div', null, 'text', 42, child, null, undefined, true, false, getter)
-      expect(node.children).toHaveLength(8)
-      expect(node.children[0]).toBe('text')
-      expect(node.children[1]).toBe(42)
-      expect((node.children[2] as VNode).type).toBe('em')
-      expect(node.children[3]).toBeNull()
-      expect(node.children[4]).toBeUndefined()
-      expect(node.children[5]).toBe(true)
-      expect(node.children[6]).toBe(false)
-      expect(typeof node.children[7]).toBe('function')
-    })
-
-    test('function children (reactive getters) are preserved', () => {
-      const getter = () => 'dynamic'
-      const node = h('div', null, getter)
-      expect(node.children).toHaveLength(1)
-      expect(typeof node.children[0]).toBe('function')
-      expect((node.children[0] as () => string)()).toBe('dynamic')
-    })
-
-    test('no children produces empty array', () => {
-      const node = h('br', null)
-      expect(node.children).toEqual([])
-    })
-  })
-
-  describe('children flattening', () => {
-    test('flattens single-level array children', () => {
-      const node = h('ul', null, [h('li', null, 'a'), h('li', null, 'b')])
-      expect(node.children).toHaveLength(2)
-      expect((node.children[0] as VNode).type).toBe('li')
-      expect((node.children[1] as VNode).type).toBe('li')
-    })
-
-    test('flattens deeply nested arrays', () => {
-      const node = h('div', null, [[['deep']]] as unknown as VNodeChild)
-      expect(node.children).toEqual(['deep'])
-    })
-
-    test('flattens mixed nested/flat children', () => {
-      const node = h('div', null, 'flat', ['nested-a', 'nested-b'] as unknown as VNodeChild)
-      expect(node.children).toEqual(['flat', 'nested-a', 'nested-b'])
-    })
-
-    test('fast path: no allocation when children have no nested arrays', () => {
-      // normalizeChildren returns as-is when no element is an array
-      const node = h('div', null, 'a', 'b', 'c')
-      expect(node.children).toEqual(['a', 'b', 'c'])
-      expect(node.children).toHaveLength(3)
-    })
-
-    test('flattens multiple levels of nesting', () => {
-      const node = h('div', null, [['a', ['b', ['c']]]] as unknown as VNodeChild)
-      expect(node.children).toEqual(['a', 'b', 'c'])
-    })
-  })
-
-  describe('component function type', () => {
-    test('accepts component function as type', () => {
-      const Comp: ComponentFn<{ name: string }> = (props) => h('span', null, props.name)
-      const node = h(Comp, { name: 'test' })
-      expect(node.type).toBe(Comp)
-      expect(node.props.name).toBe('test')
-    })
-
-    test('component with no props', () => {
-      const Comp: ComponentFn = () => h('div', null)
-      const node = h(Comp, null)
-      expect(node.type).toBe(Comp)
-      expect(node.props).toBe(EMPTY_PROPS)
-    })
-
-    test('component with children rest args', () => {
-      const Comp: ComponentFn = () => null
-      const node = h(Comp, { id: 'x' }, 'child1', 'child2')
-      expect(node.children).toEqual(['child1', 'child2'])
-    })
-  })
-
-  describe('symbol type (Fragment)', () => {
-    test('Fragment as type', () => {
-      const node = h(Fragment, null, 'a', 'b')
-      expect(node.type).toBe(Fragment)
-      expect(node.children).toEqual(['a', 'b'])
-    })
-
-    test('Fragment with VNode children', () => {
-      const node = h(Fragment, null, h('span', null, 'x'), h('em', null, 'y'))
-      expect(node.children).toHaveLength(2)
-    })
-
-    test('nested Fragments', () => {
-      const inner = h(Fragment, null, 'a', 'b')
-      const outer = h(Fragment, null, inner, 'c')
-      expect(outer.children).toHaveLength(2)
-      expect((outer.children[0] as VNode).type).toBe(Fragment)
-    })
-
-    // Regression: pre-fix, `Fragment` was `Symbol('Pyreon.Fragment')` — a
-    // fresh symbol per module evaluation. When `h.ts` got bundled into BOTH
-    // `lib/index.js` AND `lib/jsx-runtime.js` (each a separate published
-    // entry point), each bundle created a DISTINCT Symbol identity. JSX
-    // `<>` compiles to `jsx(Fragment, ...)` referring to jsx-runtime's
-    // Fragment; `runtime-server` checks `vnode.type === Fragment` against
-    // `@pyreon/core`'s main-entry Fragment. The two never matched →
-    // fell through to `renderElement` → tried to stringify the Symbol →
-    // SSG crashed with `TypeError: Cannot convert a Symbol value to
-    // a string`.
-    //
-    // Fix: use `Symbol.for('Pyreon.Fragment')` — the global registry keys
-    // by string, so all bundles inlining h.ts share the same identity.
-    //
-    // This test asserts the global-registry contract: Fragment IS
-    // retrievable from the registry. Bisect-verifiable: reverting h.ts to
-    // `Symbol(...)` makes this fail.
-    test('Fragment uses Symbol.for() for cross-bundle identity stability', () => {
-      expect(Fragment).toBe(Symbol.for('Pyreon.Fragment'))
-    })
-  })
-})
-
-describe('EMPTY_PROPS', () => {
-  test('is a plain object', () => {
-    expect(typeof EMPTY_PROPS).toBe('object')
-    expect(EMPTY_PROPS).not.toBeNull()
-  })
-
-  test('is the same reference for all null-prop VNodes', () => {
-    const a = h('div', null)
-    const b = h('span', null)
-    expect(a.props).toBe(b.props)
-  })
-})
-
-describe('Fragment', () => {
-  test('is a unique symbol', () => {
-    expect(typeof Fragment).toBe('symbol')
-    expect(Fragment.toString()).toContain('Pyreon.Fragment')
-  })
-})

package/src/tests/jsx-compat.test.tsx

@@ -1,86 +0,0 @@
-/**
- * JSX type compatibility test — verifies all JSX patterns produce correct VNodes.
- * Uses h() directly since core's vitest config doesn't have JSX transform.
- * TypeScript already validates JSX types via typecheck (tsc --noEmit).
- */
-import { createRef, Fragment, h } from '../index'
-
-describe('JSX type compat (via h)', () => {
-  test('basic element', () => {
-    const el = h('div', { class: 'hello' }, 'world')
-    expect(el.type).toBe('div')
-    expect(el.props.class).toBe('hello')
-  })
-
-  test('callback ref', () => {
-    let _captured: Element | null = null
-    const el = h(
-      'div',
-      {
-        ref: (e: Element) => {
-          _captured = e
-        },
-      },
-      'test',
-    )
-    expect(typeof el.props.ref).toBe('function')
-  })
-
-  test('object ref', () => {
-    const myRef = createRef<HTMLDivElement>()
-    const el = h('div', { ref: myRef }, 'test')
-    expect(el.props.ref).toBe(myRef)
-  })
-
-  test('reactive class prop', () => {
-    const el = h('span', { class: () => 'active' }, 'hello')
-    expect(typeof el.props.class).toBe('function')
-  })
-
-  test('input with typed props', () => {
-    const el = h('input', { type: 'text', value: 'test' })
-    expect(el.type).toBe('input')
-    expect(el.props.type).toBe('text')
-  })
-
-  test('component with children', () => {
-    const MyComp = (props: { name: string; children?: unknown }) => {
-      return h('div', null, String(props.name))
-    }
-    const el = h(MyComp, { name: 'test' }, 'child')
-    expect(typeof el.type).toBe('function')
-    expect(el.props.name).toBe('test')
-  })
-
-  test('fragment', () => {
-    const el = h(Fragment, null, 'fragment')
-    expect(el.type).toBe(Fragment)
-  })
-
-  test('event handler', () => {
-    const handler = vi.fn()
-    const el = h('button', { onClick: handler }, 'click')
-    expect(el.props.onClick).toBe(handler)
-  })
-
-  test('style as object', () => {
-    const el = h('div', { style: { color: 'red' } }, 'styled')
-    expect(el.props.style).toEqual({ color: 'red' })
-  })
-
-  test('data attributes', () => {
-    const el = h('div', { 'data-testid': 'foo' }, 'test')
-    expect(el.props['data-testid']).toBe('foo')
-  })
-
-  test('aria attributes', () => {
-    const el = h('div', { 'aria-label': 'close', role: 'button' })
-    expect(el.props['aria-label']).toBe('close')
-    expect(el.props.role).toBe('button')
-  })
-
-  test('key prop', () => {
-    const el = h('li', { key: 'item-1' }, 'item')
-    expect(el.key).toBe('item-1')
-  })
-})

package/src/tests/lazy.test.ts

@@ -1,100 +0,0 @@
-import { h } from '../h'
-import { lazy } from '../lazy'
-import type { ComponentFn, Props, VNode } from '../types'
-
-describe('lazy', () => {
-  test('returns a LazyComponent with __loading flag', () => {
-    const Comp = lazy<Props>(() => new Promise(() => {})) // never resolves
-    expect(typeof Comp).toBe('function')
-    expect(typeof Comp.__loading).toBe('function')
-    expect(Comp.__loading()).toBe(true)
-  })
-
-  test('__loading returns true while loading', () => {
-    const Comp = lazy<Props>(() => new Promise(() => {}))
-    expect(Comp.__loading()).toBe(true)
-  })
-
-  test('returns null while loading (component not yet available)', () => {
-    const Comp = lazy<Props>(() => new Promise(() => {}))
-    const result = Comp({})
-    expect(result).toBeNull()
-  })
-
-  test('resolves to the loaded component', async () => {
-    const Inner: ComponentFn<{ name: string }> = (props) => h('span', null, props.name)
-    const Comp = lazy(() => Promise.resolve({ default: Inner }))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    expect(Comp.__loading()).toBe(false)
-    const result = Comp({ name: 'test' })
-    expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe(Inner)
-    expect((result as VNode).props).toEqual({ name: 'test' })
-  })
-
-  test('throws on import error', async () => {
-    const Comp = lazy<Props>(() => Promise.reject(new Error('load failed')))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    expect(Comp.__loading()).toBe(false)
-    expect(() => Comp({})).toThrow('load failed')
-  })
-
-  test('wraps non-Error rejection in Error', async () => {
-    const Comp = lazy<Props>(() => Promise.reject('string-error'))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    expect(() => Comp({})).toThrow('string-error')
-  })
-
-  test('wraps numeric rejection in Error', async () => {
-    const Comp = lazy<Props>(() => Promise.reject(404))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    expect(() => Comp({})).toThrow('404')
-  })
-
-  test('__loading is false after successful load', async () => {
-    const Inner: ComponentFn = () => null
-    const Comp = lazy(() => Promise.resolve({ default: Inner }))
-
-    expect(Comp.__loading()).toBe(true)
-    await new Promise((r) => setTimeout(r, 0))
-    expect(Comp.__loading()).toBe(false)
-  })
-
-  test('__loading is false after failed load', async () => {
-    const Comp = lazy<Props>(() => Promise.reject(new Error('fail')))
-
-    expect(Comp.__loading()).toBe(true)
-    await new Promise((r) => setTimeout(r, 0))
-    expect(Comp.__loading()).toBe(false)
-  })
-
-  test('multiple calls after load return consistent results', async () => {
-    const Inner: ComponentFn = () => h('div', null, 'content')
-    const Comp = lazy(() => Promise.resolve({ default: Inner }))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    const result1 = Comp({})
-    const result2 = Comp({})
-    expect((result1 as VNode).type).toBe(Inner)
-    expect((result2 as VNode).type).toBe(Inner)
-  })
-
-  test('passes props through to loaded component via h()', async () => {
-    const Inner: ComponentFn<{ count: number }> = (props) => h('span', null, String(props.count))
-    const Comp = lazy(() => Promise.resolve({ default: Inner }))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    const result = Comp({ count: 42 })
-    expect((result as VNode).props).toEqual({ count: 42 })
-  })
-})