@pyreon/core 0.24.4 → 0.24.6

package/src/tests/cx.test.ts

@@ -1,70 +0,0 @@
-import { cx } from '../style'
-
-describe('cx', () => {
-  test('returns empty string for falsy values', () => {
-    expect(cx(null)).toBe('')
-    expect(cx(undefined)).toBe('')
-    expect(cx(false)).toBe('')
-    expect(cx(true)).toBe('')
-  })
-
-  test('passes through strings', () => {
-    expect(cx('foo bar')).toBe('foo bar')
-  })
-
-  test('converts numbers to strings', () => {
-    expect(cx(42)).toBe('42')
-  })
-
-  test('filters and joins arrays', () => {
-    expect(cx(['foo', false, 'bar', null, 'baz'])).toBe('foo bar baz')
-  })
-
-  test('resolves object keys with truthy values', () => {
-    expect(cx({ active: true, hidden: false, bold: true })).toBe('active bold')
-  })
-
-  test('resolves object values that are functions', () => {
-    expect(cx({ active: () => true, hidden: () => false })).toBe('active')
-  })
-
-  test('handles nested arrays and objects', () => {
-    expect(cx(['base', { active: true }, ['nested', { deep: true }]])).toBe(
-      'base active nested deep',
-    )
-  })
-
-  test('handles empty inputs', () => {
-    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/defer.test.ts

@@ -1,359 +0,0 @@
-import { signal } from '@pyreon/reactivity'
-import { _setupIdleTrigger, _setupVisibleTrigger, Defer } from '../defer'
-import { Fragment, h } from '../h'
-import type { ComponentFn, Props, VNode } from '../types'
-
-// Helper: pull the render-callback out of Defer's returned VNode shape.
-// `when` and `idle` modes return a Fragment whose `children[0]` is a
-// thunk. `visible` mode returns a div whose `children[0]` is the same
-// thunk. Both shapes return the same `renderContent` accessor.
-function getRenderThunk(vnode: VNode): () => unknown {
-  const children = vnode.children as unknown[]
-  const thunk = children[0]
-  if (typeof thunk !== 'function') throw new Error('Expected render thunk')
-  return thunk as () => unknown
-}
-
-describe('Defer — common shape', () => {
-  test('returns a VNode (Fragment or wrapper div per trigger mode)', () => {
-    const result = Defer({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      when: () => false,
-    })
-    expect(result).toBeDefined()
-    expect((result as VNode).type).toBe(Fragment)
-  })
-
-  test('renders fallback before chunk resolves', () => {
-    const fallback = h('span', null, 'loading…')
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}), // never resolves
-      when: () => true,
-      fallback,
-    })
-    expect(getRenderThunk(vnode)()).toBe(fallback)
-  })
-
-  test('renders null when no fallback and chunk has not resolved', () => {
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      when: () => true,
-    })
-    expect(getRenderThunk(vnode)()).toBeNull()
-  })
-})
-
-describe('Defer — when (signal-driven)', () => {
-  test('does NOT load chunk while when is false', () => {
-    let calls = 0
-    const chunkFn = () => {
-      calls++
-      return Promise.resolve({ default: (() => null) as ComponentFn<Props> })
-    }
-    const flag = signal(false)
-    Defer<Props>({ chunk: chunkFn, when: flag })
-    expect(calls).toBe(0)
-  })
-
-  test('loads chunk when when flips to true', async () => {
-    const Inner: ComponentFn<{ msg: string }> = (p) => h('div', null, p.msg)
-    let calls = 0
-    const chunkFn = () => {
-      calls++
-      return Promise.resolve({ default: Inner })
-    }
-    const flag = signal(false)
-    const vnode = Defer<{ msg: string }>({
-      chunk: chunkFn,
-      when: flag,
-      children: (Comp) => h(Comp, { msg: 'hi' }),
-    })
-    expect(calls).toBe(0)
-    flag.set(true)
-    // Effect schedules synchronously; chunk fetch is microtask-resolved.
-    expect(calls).toBe(1)
-    await new Promise((r) => setTimeout(r, 0))
-    const result = getRenderThunk(vnode)() as VNode
-    expect(result.type).toBe(Inner)
-    expect(result.props).toEqual({ msg: 'hi' })
-  })
-
-  test('loads chunk EXACTLY ONCE when signal oscillates', async () => {
-    let calls = 0
-    const chunkFn = () => {
-      calls++
-      return Promise.resolve({ default: (() => null) as ComponentFn<Props> })
-    }
-    const flag = signal(false)
-    Defer<Props>({ chunk: chunkFn, when: flag })
-    flag.set(true)
-    flag.set(false)
-    flag.set(true)
-    flag.set(false)
-    flag.set(true)
-    await new Promise((r) => setTimeout(r, 0))
-    expect(calls).toBe(1)
-  })
-
-  test('accepts component re-exports without default wrapper', async () => {
-    const Inner: ComponentFn = () => h('span', null, 'ok')
-    const flag = signal(true)
-    const vnode = Defer<Props>({
-      chunk: () => Promise.resolve(Inner), // bare ComponentFn
-      when: flag,
-      children: (Comp) => h(Comp, {}),
-    })
-    await new Promise((r) => setTimeout(r, 0))
-    const result = getRenderThunk(vnode)() as VNode
-    expect(result.type).toBe(Inner)
-  })
-
-  test('throws when chunk() rejects (Suspense-style error propagation)', async () => {
-    const consoleSpy = (() => {
-      const orig = console.error
-      console.error = () => {} // silence dev-mode error log
-      return () => {
-        console.error = orig
-      }
-    })()
-    try {
-      const flag = signal(true)
-      const vnode = Defer<Props>({
-        chunk: () => Promise.reject(new Error('chunk boom')),
-        when: flag,
-      })
-      await new Promise((r) => setTimeout(r, 0))
-      expect(() => getRenderThunk(vnode)()).toThrow('chunk boom')
-    } finally {
-      consoleSpy()
-    }
-  })
-
-  test('renders default <Comp /> when children render-prop omitted', async () => {
-    const Inner: ComponentFn = () => h('div', null, 'no-children-prop')
-    const flag = signal(true)
-    const vnode = Defer<Props>({
-      chunk: () => Promise.resolve({ default: Inner }),
-      when: flag,
-    })
-    await new Promise((r) => setTimeout(r, 0))
-    const result = getRenderThunk(vnode)() as VNode
-    expect(result.type).toBe(Inner)
-    expect(result.props).toEqual({})
-  })
-})
-
-describe('Defer — on="visible"', () => {
-  test('returns a div wrapper with data-pyreon-defer="visible"', () => {
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      on: 'visible',
-    })
-    expect((vnode as VNode).type).toBe('div')
-    expect((vnode as VNode).props['data-pyreon-defer']).toBe('visible')
-  })
-
-  test('uses display: contents so wrapper is layout-transparent', () => {
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      on: 'visible',
-    })
-    expect((vnode as VNode).props.style).toBe('display: contents')
-  })
-
-  test('default rootMargin is 200px (not exposed via prop spread)', () => {
-    // The rootMargin is consumed by onMount; we can't directly observe
-    // it from the returned VNode. This test documents the default and
-    // would catch a regression in the constant.
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      on: 'visible',
-    })
-    // Wrapper has the structural attrs but no rootMargin leak to DOM.
-    expect((vnode as VNode).props.rootMargin).toBeUndefined()
-  })
-})
-
-describe('Defer — on="idle"', () => {
-  test('returns a Fragment (no wrapper element)', () => {
-    const vnode = Defer<Props>({
-      chunk: () => new Promise<{ default: ComponentFn<Props> }>(() => {}),
-      on: 'idle',
-    })
-    expect((vnode as VNode).type).toBe(Fragment)
-  })
-})
-
-// Browser-API helpers extracted from the onMount callbacks so they're
-// directly testable without happy-dom (core tests run in Node). The
-// onMount wrappers in `defer.ts` just delegate to these.
-describe('_setupIdleTrigger', () => {
-  // Use `Reflect.has` + property descriptors instead of plain assignment
-  // so the restore is symmetric — if the global wasn't defined at test
-  // start (Node), `delete` cleanly returns to the original state.
-  const orig = {
-    ric: (globalThis as { requestIdleCallback?: unknown }).requestIdleCallback,
-    cic: (globalThis as { cancelIdleCallback?: unknown }).cancelIdleCallback,
-  }
-  afterEach(() => {
-    if (orig.ric === undefined) delete (globalThis as { requestIdleCallback?: unknown }).requestIdleCallback
-    else (globalThis as { requestIdleCallback?: unknown }).requestIdleCallback = orig.ric
-    if (orig.cic === undefined) delete (globalThis as { cancelIdleCallback?: unknown }).cancelIdleCallback
-    else (globalThis as { cancelIdleCallback?: unknown }).cancelIdleCallback = orig.cic
-  })
-
-  test('uses requestIdleCallback when available', () => {
-    let captured: (() => void) | null = null
-    ;(globalThis as { requestIdleCallback?: unknown }).requestIdleCallback = (
-      cb: () => void,
-    ): number => {
-      captured = cb
-      return 42
-    }
-    let cancelledId: number | null = null
-    ;(globalThis as { cancelIdleCallback?: unknown }).cancelIdleCallback = (
-      id: number,
-    ): void => {
-      cancelledId = id
-    }
-    const startLoad = () => {}
-    const teardown = _setupIdleTrigger(startLoad)
-    expect(captured).toBe(startLoad)
-    teardown()
-    expect(cancelledId).toBe(42)
-  })
-
-  test('teardown is no-op when cancelIdleCallback is missing', () => {
-    ;(globalThis as { requestIdleCallback?: unknown }).requestIdleCallback = (
-      _cb: () => void,
-    ): number => 99
-    delete (globalThis as { cancelIdleCallback?: unknown }).cancelIdleCallback
-    const teardown = _setupIdleTrigger(() => {})
-    expect(() => teardown()).not.toThrow()
-  })
-
-  test('falls back to setTimeout when requestIdleCallback is absent', async () => {
-    delete (globalThis as { requestIdleCallback?: unknown }).requestIdleCallback
-    let loaded = false
-    const teardown = _setupIdleTrigger(() => {
-      loaded = true
-    })
-    // setTimeout(fn, 1) fires after a tick — await to observe.
-    await new Promise((r) => setTimeout(r, 5))
-    expect(loaded).toBe(true)
-    teardown() // safe to call after the timer fired
-  })
-
-  test('setTimeout fallback cancels via clearTimeout when teardown fires before tick', () => {
-    delete (globalThis as { requestIdleCallback?: unknown }).requestIdleCallback
-    let loaded = false
-    const teardown = _setupIdleTrigger(() => {
-      loaded = true
-    })
-    teardown() // cancel before the timer fires
-    return new Promise<void>((r) =>
-      setTimeout(() => {
-        expect(loaded).toBe(false)
-        r()
-      }, 10),
-    )
-  })
-})
-
-describe('_setupVisibleTrigger', () => {
-  const origObs = (globalThis as { IntersectionObserver?: unknown }).IntersectionObserver
-  afterEach(() => {
-    if (origObs === undefined) delete (globalThis as { IntersectionObserver?: unknown }).IntersectionObserver
-    else (globalThis as { IntersectionObserver?: unknown }).IntersectionObserver = origObs
-  })
-
-  test('loads immediately when el is null', () => {
-    let loaded = false
-    const teardown = _setupVisibleTrigger(null, () => {
-      loaded = true
-    }, '200px')
-    expect(loaded).toBe(true)
-    expect(typeof teardown).toBe('function')
-  })
-
-  test('loads immediately when IntersectionObserver is unavailable', () => {
-    delete (globalThis as { IntersectionObserver?: unknown }).IntersectionObserver
-    // Pass a stub element; without the global the trigger should bail early.
-    const stubEl = {} as unknown as HTMLElement
-    let loaded = false
-    _setupVisibleTrigger(stubEl, () => {
-      loaded = true
-    }, '200px')
-    expect(loaded).toBe(true)
-  })
-
-  test('creates an observer with the configured rootMargin', () => {
-    let capturedOptions: IntersectionObserverInit | undefined
-    let observed: Element | null = null
-    let disconnected = false
-    class StubObserver {
-      callback: IntersectionObserverCallback
-      constructor(cb: IntersectionObserverCallback, opts?: IntersectionObserverInit) {
-        this.callback = cb
-        capturedOptions = opts
-      }
-      observe(el: Element) {
-        observed = el
-      }
-      disconnect() {
-        disconnected = true
-      }
-      unobserve() {}
-      takeRecords() {
-        return []
-      }
-    }
-    ;(globalThis as { IntersectionObserver?: unknown }).IntersectionObserver = StubObserver
-    const stubEl = { tagName: 'DIV' } as unknown as HTMLElement
-    const teardown = _setupVisibleTrigger(stubEl, () => {}, '300px')
-    expect(observed).toBe(stubEl)
-    expect(capturedOptions?.rootMargin).toBe('300px')
-    teardown()
-    expect(disconnected).toBe(true)
-  })
-
-  test('fires startLoad on intersection, then disconnects', () => {
-    let captured: IntersectionObserverCallback | null = null
-    let disconnected = false
-    class StubObserver {
-      constructor(cb: IntersectionObserverCallback) {
-        captured = cb
-      }
-      observe() {}
-      disconnect() {
-        disconnected = true
-      }
-      unobserve() {}
-      takeRecords() {
-        return []
-      }
-    }
-    ;(globalThis as { IntersectionObserver?: unknown }).IntersectionObserver = StubObserver
-    let loaded = false
-    const stubEl = {} as unknown as HTMLElement
-    _setupVisibleTrigger(stubEl, () => {
-      loaded = true
-    }, '0px')
-
-    // Simulate non-intersecting entry — should NOT fire.
-    captured!(
-      [{ isIntersecting: false } as unknown as IntersectionObserverEntry],
-      {} as IntersectionObserver,
-    )
-    expect(loaded).toBe(false)
-    expect(disconnected).toBe(false)
-
-    // Simulate intersecting entry — fires and disconnects.
-    captured!(
-      [{ isIntersecting: true } as unknown as IntersectionObserverEntry],
-      {} as IntersectionObserver,
-    )
-    expect(loaded).toBe(true)
-    expect(disconnected).toBe(true)
-  })
-})

package/src/tests/dynamic.test.ts

@@ -1,87 +0,0 @@
-import { Dynamic } from '../dynamic'
-import { h } from '../h'
-import type { ComponentFn, VNode, VNodeChild } from '../types'
-
-describe('Dynamic', () => {
-  test('renders component function', () => {
-    const Greeting: ComponentFn = (props) => h('span', null, (props as { name: string }).name)
-    const result = Dynamic({ component: Greeting, name: 'world' })
-    expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe(Greeting)
-    expect((result as VNode).props).toEqual({ name: 'world' })
-  })
-
-  test('renders string element', () => {
-    const result = Dynamic({ component: 'div', class: 'box', id: 'main' })
-    expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe('div')
-    expect((result as VNode).props).toEqual({ class: 'box', id: 'main' })
-  })
-
-  test('strips component prop from rest props', () => {
-    const result = Dynamic({ component: 'span', id: 'x' })
-    expect((result as VNode).props.component).toBeUndefined()
-    expect((result as VNode).props.id).toBe('x')
-  })
-
-  test('returns null for empty string component', () => {
-    const result = Dynamic({ component: '' })
-    expect(result).toBeNull()
-  })
-
-  test('warns when component prop is falsy', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    Dynamic({ component: '' })
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<Dynamic>'))
-    warnSpy.mockRestore()
-  })
-
-  test('passes all extra props to the rendered component', () => {
-    const Comp: ComponentFn = (props) => h('div', null, JSON.stringify(props))
-    const result = Dynamic({
-      component: Comp,
-      a: 1,
-      b: 'two',
-      c: true,
-    })
-    expect((result as VNode).props).toEqual({ a: 1, b: 'two', c: true })
-  })
-
-  test('renders with no extra props', () => {
-    const result = Dynamic({ component: 'br' })
-    expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe('br')
-  })
-
-  test('does not leak children as a prop on string-tag mount', () => {
-    // Regression: for string `component`, runtime-dom forwards every prop
-    // key to setAttribute. If `children` stayed in props it crashed at
-    // mount with `setAttribute('children', ...)`. The fix re-emits them
-    // as h() rest args, landing them in vnode.children.
-    const result = Dynamic({ component: 'h3', children: 'hello' })
-    expect((result as VNode).type).toBe('h3')
-    expect((result as VNode).props.children).toBeUndefined()
-    expect((result as VNode).children).toEqual(['hello'])
-  })
-
-  test('flattens array children to vnode.children', () => {
-    const a = h('span', null, 'a')
-    const b = h('span', null, 'b')
-    const result = Dynamic({ component: 'div', children: [a, b] })
-    expect((result as VNode).props.children).toBeUndefined()
-    expect((result as VNode).children).toHaveLength(2)
-  })
-
-  test('component children still reach props.children at mount', () => {
-    // For component (not string), the merge happens at mount via
-    // mergeChildrenIntoProps — verified end-to-end by mount tests in
-    // runtime-dom. Here we just confirm the vnode shape is correct so the
-    // merge will fire (children must be on vnode.children, not props).
-    const Comp: ComponentFn = (props) =>
-      h('div', null, (props as { children?: VNodeChild }).children ?? null)
-    const result = Dynamic({ component: Comp, children: 'hi' })
-    expect((result as VNode).type).toBe(Comp)
-    expect((result as VNode).props.children).toBeUndefined()
-    expect((result as VNode).children).toEqual(['hi'])
-  })
-})

package/src/tests/error-boundary.test.ts

@@ -1,181 +0,0 @@
-import { dispatchToErrorBoundary, popErrorBoundary, runWithHooks } from '../component'
-import { ErrorBoundary } from '../error-boundary'
-import { h } from '../h'
-import type { VNodeChild } from '../types'
-
-describe('ErrorBoundary', () => {
-  // Clean up error boundary stack after each test
-  afterEach(() => {
-    // Pop all boundaries that tests may have left
-    while (dispatchToErrorBoundary('cleanup')) {
-      popErrorBoundary()
-    }
-  })
-
-  test('is a function', () => {
-    expect(typeof ErrorBoundary).toBe('function')
-  })
-
-  test('returns a reactive getter', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: 'child',
-      })
-      return null
-    }, {})
-    expect(typeof result).toBe('function')
-  })
-
-  test('renders children when no error', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: 'child content',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('child content')
-  })
-
-  test('renders function children by calling them', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: () => 'dynamic child',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('dynamic child')
-  })
-
-  test('renders VNode children', () => {
-    let result: VNodeChild = null
-    const child = h('div', null, 'content')
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: child,
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('registers unmount cleanup hook', () => {
-    const { hooks } = runWithHooks(() => {
-      ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: 'child',
-      })
-      return null
-    }, {})
-    expect(hooks.unmount!.length).toBeGreaterThanOrEqual(1)
-  })
-
-  test('warns when fallback is not a function', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    runWithHooks(() => {
-      ErrorBoundary({
-        fallback: 'not-a-function' as unknown as (err: unknown, reset: () => void) => VNodeChild,
-        children: 'child',
-      })
-      return null
-    }, {})
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<ErrorBoundary>'))
-    warnSpy.mockRestore()
-  })
-
-  test('dispatched error triggers fallback rendering', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Caught: ${err}`,
-        children: 'normal',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('normal')
-
-    dispatchToErrorBoundary(new Error('boom'))
-    expect(getter()).toBe('Caught: Error: boom')
-  })
-
-  test('fallback receives reset function that clears error', () => {
-    let result: VNodeChild = null
-    let capturedReset: (() => void) | undefined
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (_err, reset) => {
-          capturedReset = reset
-          return 'error-ui'
-        },
-        children: 'child',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('child')
-
-    dispatchToErrorBoundary('test-error')
-    expect(getter()).toBe('error-ui')
-    expect(capturedReset).toBeDefined()
-
-    capturedReset?.()
-    expect(getter()).toBe('child')
-  })
-
-  test('second error while already in error state is not handled', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: 'child',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-
-    // First error handled
-    expect(dispatchToErrorBoundary('first')).toBe(true)
-    expect(getter()).toBe('Error: first')
-
-    // Second error not handled (already in error state)
-    expect(dispatchToErrorBoundary('second')).toBe(false)
-    // Still showing first error
-    expect(getter()).toBe('Error: first')
-  })
-
-  test('after reset, new error can be caught again', () => {
-    let result: VNodeChild = null
-    let capturedReset: (() => void) | undefined
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err, reset) => {
-          capturedReset = reset
-          return `Error: ${err}`
-        },
-        children: 'child',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-
-    dispatchToErrorBoundary('first-error')
-    expect(getter()).toBe('Error: first-error')
-
-    capturedReset?.()
-    expect(getter()).toBe('child')
-
-    // Can catch new error after reset
-    expect(dispatchToErrorBoundary('second-error')).toBe(true)
-    expect(getter()).toBe('Error: second-error')
-  })
-})