@pyreon/core 0.24.4 → 0.24.6

package/src/tests/telemetry.test.ts

@@ -1,297 +0,0 @@
-import { clearReactiveTrace, signal } from '@pyreon/reactivity'
-import type { ErrorContext } from '../telemetry'
-import { registerErrorHandler, reportError } from '../telemetry'
-
-describe('registerErrorHandler', () => {
-  test('registers handler that receives error context', () => {
-    const contexts: ErrorContext[] = []
-    const unsub = registerErrorHandler((ctx) => {
-      contexts.push(ctx)
-    })
-
-    const ctx: ErrorContext = {
-      component: 'TestComp',
-      phase: 'render',
-      error: new Error('test'),
-      timestamp: 1234567890,
-    }
-    reportError(ctx)
-    expect(contexts).toHaveLength(1)
-    expect(contexts[0]).toBe(ctx)
-
-    unsub()
-  })
-
-  test('returns unregister function', () => {
-    let count = 0
-    const unsub = registerErrorHandler(() => {
-      count++
-    })
-
-    reportError({ component: 'A', phase: 'setup', error: 'e1', timestamp: 0 })
-    expect(count).toBe(1)
-
-    unsub()
-
-    reportError({ component: 'B', phase: 'render', error: 'e2', timestamp: 0 })
-    expect(count).toBe(1) // not called after unregister
-  })
-
-  test('multiple handlers are all called', () => {
-    let count = 0
-    const unsub1 = registerErrorHandler(() => count++)
-    const unsub2 = registerErrorHandler(() => count++)
-    const unsub3 = registerErrorHandler(() => count++)
-
-    reportError({ component: 'X', phase: 'mount', error: 'err', timestamp: 0 })
-    expect(count).toBe(3)
-
-    unsub1()
-    unsub2()
-    unsub3()
-  })
-
-  test('handler errors are swallowed — subsequent handlers still called', () => {
-    let secondCalled = false
-    let thirdCalled = false
-
-    const unsub1 = registerErrorHandler(() => {
-      throw new Error('handler crash')
-    })
-    const unsub2 = registerErrorHandler(() => {
-      secondCalled = true
-    })
-    const unsub3 = registerErrorHandler(() => {
-      thirdCalled = true
-    })
-
-    // Should not throw
-    expect(() =>
-      reportError({ component: 'Y', phase: 'unmount', error: 'err', timestamp: 0 }),
-    ).not.toThrow()
-    expect(secondCalled).toBe(true)
-    expect(thirdCalled).toBe(true)
-
-    unsub1()
-    unsub2()
-    unsub3()
-  })
-
-  test('unregistering one handler does not affect others', () => {
-    const calls: string[] = []
-    const unsub1 = registerErrorHandler(() => calls.push('a'))
-    const unsub2 = registerErrorHandler(() => calls.push('b'))
-    const unsub3 = registerErrorHandler(() => calls.push('c'))
-
-    unsub2() // remove middle handler
-
-    reportError({ component: 'Z', phase: 'effect', error: 'e', timestamp: 0 })
-    expect(calls).toEqual(['a', 'c'])
-
-    unsub1()
-    unsub3()
-  })
-})
-
-describe('reportError', () => {
-  test('no-op when no handlers registered', () => {
-    // Should not throw
-    expect(() =>
-      reportError({ component: 'None', phase: 'setup', error: 'err', timestamp: 0 }),
-    ).not.toThrow()
-  })
-
-  test('passes full ErrorContext to handler', () => {
-    let received: ErrorContext | null = null
-    const unsub = registerErrorHandler((ctx) => {
-      received = ctx
-    })
-
-    const ctx: ErrorContext = {
-      component: 'MyComp',
-      phase: 'render',
-      error: new Error('detail'),
-      timestamp: 999,
-      props: { a: 1, b: 'two' },
-    }
-    reportError(ctx)
-
-    expect(received).not.toBeNull()
-    expect(received!.component).toBe('MyComp')
-    expect(received!.phase).toBe('render')
-    expect(received!.error).toBeInstanceOf(Error)
-    expect(received!.timestamp).toBe(999)
-    expect(received!.props).toEqual({ a: 1, b: 'two' })
-
-    unsub()
-  })
-
-  test('handles all phase types', () => {
-    const phases: ErrorContext['phase'][] = ['setup', 'render', 'mount', 'unmount', 'effect']
-    const seen: string[] = []
-    const unsub = registerErrorHandler((ctx) => {
-      seen.push(ctx.phase)
-    })
-
-    for (const phase of phases) {
-      reportError({ component: 'X', phase, error: 'e', timestamp: 0 })
-    }
-    expect(seen).toEqual(phases)
-
-    unsub()
-  })
-})
-
-// ─── Regression: reactivity effect errors reach core's registerErrorHandler ──
-//
-// Pre-fix: `@pyreon/reactivity` had its own `setErrorHandler` API that drove
-// effect errors to `console.error`. `@pyreon/core`'s `registerErrorHandler`
-// captured component / mount / render / unmount errors only — effect errors
-// never reached it. Sentry/Datadog wiring missed the entire reactive surface.
-//
-// Post-fix: `registerErrorHandler` installs a `globalThis.__pyreon_report_error__`
-// bridge. Reactivity's effect-error path forwards through that bridge, so
-// effect errors flow into the same `reportError` pipeline as component
-// errors with phase='effect'.
-describe('registerErrorHandler — reactivity bridge (regression)', () => {
-  test('effect() errors forward into registered telemetry handler', async () => {
-    // Use a clean global state. The bridge install is idempotent within one
-    // global; re-importing reactivity here re-uses the same module instance.
-    const { effect, signal } = await import('@pyreon/reactivity')
-
-    const captured: ErrorContext[] = []
-    const unsub = registerErrorHandler((ctx) => captured.push(ctx))
-
-    const trigger = signal(0)
-    effect(() => {
-      if (trigger() > 0) throw new Error('boom in effect')
-    })
-
-    // Trigger the throw
-    trigger.set(1)
-    await new Promise<void>((r) => queueMicrotask(() => r()))
-
-    // Captured exactly once — through the bridge.
-    expect(captured).toHaveLength(1)
-    expect(captured[0]?.phase).toBe('effect')
-    expect(captured[0]?.component).toBe('Effect')
-    expect((captured[0]?.error as Error).message).toBe('boom in effect')
-
-    unsub()
-  })
-
-  test('multiple handlers all receive forwarded effect errors', async () => {
-    const { effect, signal } = await import('@pyreon/reactivity')
-
-    let count1 = 0
-    let count2 = 0
-    const unsub1 = registerErrorHandler(() => count1++)
-    const unsub2 = registerErrorHandler(() => count2++)
-
-    const trigger = signal(0)
-    effect(() => {
-      if (trigger() > 0) throw new Error('boom')
-    })
-    trigger.set(1)
-    await new Promise<void>((r) => queueMicrotask(() => r()))
-
-    expect(count1).toBe(1)
-    expect(count2).toBe(1)
-
-    unsub1()
-    unsub2()
-  })
-})
-
-describe('reportError — reactiveTrace enrichment', () => {
-  beforeEach(() => clearReactiveTrace())
-
-  test('attaches recent signal writes to the error context (dev)', () => {
-    const s = signal(0, { name: 'enrichTest' })
-    s.set(1)
-    s.set(2)
-
-    let captured: ErrorContext | undefined
-    const unsub = registerErrorHandler((ctx) => {
-      captured = ctx
-    })
-    reportError({
-      component: 'C',
-      phase: 'render',
-      error: new Error('boom'),
-      timestamp: Date.now(),
-    })
-    unsub()
-
-    expect(captured?.reactiveTrace).toBeDefined()
-    expect(captured!.reactiveTrace).toHaveLength(2)
-    expect(captured!.reactiveTrace![0]).toMatchObject({
-      name: 'enrichTest',
-      prev: '0',
-      next: '1',
-    })
-    expect(captured!.reactiveTrace![1]).toMatchObject({ prev: '1', next: '2' })
-  })
-
-  test('does not overwrite a caller-supplied reactiveTrace', () => {
-    const s = signal(0, { name: 'x' })
-    s.set(99)
-
-    let captured: ErrorContext | undefined
-    const unsub = registerErrorHandler((ctx) => {
-      captured = ctx
-    })
-    const supplied = [{ name: 'manual', prev: 'a', next: 'b', timestamp: 1 }]
-    reportError({
-      component: 'C',
-      phase: 'effect',
-      error: new Error('boom'),
-      timestamp: Date.now(),
-      reactiveTrace: supplied,
-    })
-    unsub()
-
-    expect(captured!.reactiveTrace).toBe(supplied)
-  })
-
-  test('no trace field when there were no signal writes', () => {
-    let captured: ErrorContext | undefined
-    const unsub = registerErrorHandler((ctx) => {
-      captured = ctx
-    })
-    reportError({
-      component: 'C',
-      phase: 'mount',
-      error: new Error('boom'),
-      timestamp: Date.now(),
-    })
-    unsub()
-
-    // Empty buffer → field stays undefined (don't attach a noisy []).
-    expect(captured?.reactiveTrace).toBeUndefined()
-  })
-
-  test('the effect-error bridge path is also enriched', () => {
-    const s = signal('idle', { name: 'phase' })
-    s.set('running')
-
-    let captured: ErrorContext | undefined
-    const unsub = registerErrorHandler((ctx) => {
-      captured = ctx
-    })
-    // Drive the reactivity → core bridge the same way an effect throw does.
-    const bridge = (
-      globalThis as { __pyreon_report_error__?: (e: unknown, p: 'effect') => void }
-    ).__pyreon_report_error__
-    bridge?.(new Error('effect boom'), 'effect')
-    unsub()
-
-    expect(captured?.component).toBe('Effect')
-    expect(captured?.reactiveTrace).toBeDefined()
-    expect(captured!.reactiveTrace![0]).toMatchObject({
-      name: 'phase',
-      prev: '"idle"',
-      next: '"running"',
-    })
-  })
-})

package/src/types.ts

@@ -1,116 +0,0 @@
-/// <reference lib="dom" />
-
-// ─── VNode ────────────────────────────────────────────────────────────────────
-
-// Reactive getter returning a child — wraps dynamic expressions in `() =>`
-export type VNodeChildAtom = VNode | string | number | boolean | null | undefined
-/** Reactive accessor — TS checks this arm FIRST so `{() => cond && <X />}` resolves correctly */
-export type VNodeChildAccessor = () => VNodeChildAtom | VNodeChildAtom[]
-export type VNodeChild = VNodeChildAccessor | VNodeChildAtom | VNodeChildAtom[]
-
-export interface VNode {
-  /** Tag name, component function, or special symbol (Fragment) */
-  type: string | ComponentFn | symbol
-  props: Props
-  children: VNodeChild[]
-  key: string | number | null
-}
-
-// ─── Props ────────────────────────────────────────────────────────────────────
-
-export type Props = Record<string, unknown>
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-/**
- * A component is a plain function that runs ONCE.
- * It returns any renderable content and may call lifecycle hooks during setup.
- */
-export type ComponentFn<P extends Props = Props> = (props: P) => VNodeChild
-
-// ─── Utility types ───────────────────────────────────────────────────────────
-
-/**
- * Extract the props type from a component function, or pass through if already
- * a props type. **Multi-overload aware** — matches up to 4 call signatures and
- * produces the UNION of their first-argument types. A single-overload function
- * still works (the union of 4 copies of the same props type dedupes back to
- * the single shape).
- *
- * **Why this shape**. `T extends (props: infer P) => any ? P : never` only
- * captures the LAST overload of a multi-overload function — TS's overload-
- * resolution-against-conditional-types semantics. Multi-overload primitives
- * (Iterator, List, Element, etc.) need the union of every overload's props
- * to survive HOC wrapping (`rocketstyle()`, `attrs()`) without silently
- * downgrading the public prop surface to the loosest overload. Mirrors
- * vitus-labs PR #222.
- *
- * @example
- * function Iterator<T extends SimpleValue>(p: { data: T[]; valueName?: string }): VNodeChild
- * function Iterator<T extends ObjectValue>(p: { data: T[]; component: ComponentFn<T> }): VNodeChild
- * type Props = ExtractProps<typeof Iterator>
- * // → { data: SimpleValue[]; valueName?: string }
- * //  | { data: ObjectValue[]; component: ComponentFn<ObjectValue> }
- */
-export type ExtractProps<T> = T extends {
-  (props: infer P1, ...args: any): any
-  (props: infer P2, ...args: any): any
-  (props: infer P3, ...args: any): any
-  (props: infer P4, ...args: any): any
-}
-  ? P1 | P2 | P3 | P4
-  : T extends {
-        (props: infer P1, ...args: any): any
-        (props: infer P2, ...args: any): any
-        (props: infer P3, ...args: any): any
-      }
-    ? P1 | P2 | P3
-    : T extends {
-          (props: infer P1, ...args: any): any
-          (props: infer P2, ...args: any): any
-        }
-      ? P1 | P2
-      : T extends ComponentFn<infer P>
-        ? P
-        : T
-
-/** A higher-order component that wraps a component, optionally transforming its props. */
-export type HigherOrderComponent<HOP extends Props, P extends Props | undefined = undefined> = (
-  Component: ComponentFn<HOP>,
-) => ComponentFn<P extends undefined ? HOP : P>
-
-/**
- * Internal runtime handle created by the renderer for each mounted component.
- */
-export interface ComponentInstance {
-  vnode: VNode | null
-  /** Trigger a re-check / patch cycle (called by the renderer) */
-  update(): void
-  unmount(): void
-}
-
-// ─── Lifecycle hooks storage (attached per-instance by the renderer) ──────────
-
-// Cleanup function optionally returned by onMount hooks
-export type CleanupFn = () => void
-
-// ─── NativeItem ───────────────────────────────────────────────────────────────
-
-/**
- * Result of createTemplate() — a pre-cloned DOM element with its cleanup.
- * Handled directly by mountFor without going through the VNode reconciler,
- * saving 2 allocations per row vs the VNode wrapper path.
- */
-export interface NativeItem {
-  readonly __isNative: true
-  el: HTMLElement
-  cleanup: (() => void) | null
-}
-
-export interface LifecycleHooks {
-  mount: (() => CleanupFn | void | undefined)[] | null
-  unmount: (() => void)[] | null
-  update: (() => void)[] | null
-  /** Error handlers — return true to mark the error as handled (stops propagation). */
-  error: ((err: unknown) => boolean | undefined)[] | null
-}