@pyreon/core 0.24.4 → 0.24.6

package/src/error-boundary.ts

@@ -1,90 +0,0 @@
-import { signal } from '@pyreon/reactivity'
-import { nativeCompat } from './compat-marker'
-import { popErrorBoundary, pushErrorBoundary } from './component'
-import { onUnmount } from './lifecycle'
-import { reportError } from './telemetry'
-import type { VNodeChild, VNodeChildAtom } from './types'
-
-// Dev-mode gate: see `pyreon/no-process-dev-gate` lint rule for why this
-// uses `import.meta.env.DEV` instead of `typeof process !== 'undefined'`.
-const __DEV__ = process.env.NODE_ENV !== 'production'
-
-/**
- * ErrorBoundary — catches errors thrown by child components and renders a
- * fallback UI instead of crashing the whole tree.
- *
- * Also reports caught errors to any registered telemetry handlers.
- *
- * How error propagation works:
- * ErrorBoundary pushes a handler onto the module-level boundary stack
- * synchronously during its own setup (before children are mounted).
- * When mountComponent catches a child error, it calls dispatchToErrorBoundary()
- * which invokes the innermost boundary's handler.
- *
- * Usage:
- *   h(ErrorBoundary, {
- *     fallback: (err) => h("p", null, `Error: ${err}`),
- *     children: h(MyComponent, null),
- *   })
- *
- *   // or with JSX:
- *   <ErrorBoundary fallback={(err) => <p>Error: {String(err)}</p>}>
- *     <MyComponent />
- *   </ErrorBoundary>
- */
-export function ErrorBoundary(props: {
-  /**
-   * Rendered when a child throws. Receives the caught error and a `reset`
-   * function — calling `reset()` clears the error and re-renders children.
-   */
-  fallback: (err: unknown, reset: () => void) => VNodeChild
-  children?: VNodeChild
-}): VNodeChild {
-  if (__DEV__ && typeof props.fallback !== 'function') {
-    // oxlint-disable-next-line no-console
-    console.warn(
-      '[Pyreon] <ErrorBoundary> expects `fallback` to be a function: (err, reset) => VNode. ' +
-        `Received ${typeof props.fallback}.`,
-    )
-  }
-
-  const error = signal<unknown>(null)
-  const reset = () => error.set(null)
-
-  const handler = (err: unknown): boolean => {
-    if (error.peek() !== null) return false // already in error state — let outer boundary catch it
-    // Synchronous signal write. The handler fires from inside mountComponent's
-    // catch, which is itself inside the boundary's own mountReactive effect
-    // run (the run that mounted the throwing child). The batch system's
-    // two-tier flush handles this correctly: this `error.set(err)` enqueues
-    // the boundary's run into the effects queue's nextPass (since the run is
-    // currently being visited), and the next pass fires it to swap to the
-    // fallback subtree. See packages/core/reactivity/src/batch.ts for the
-    // multi-pass effect drain contract.
-    error.set(err)
-    reportError({ component: 'ErrorBoundary', phase: 'render', error: err, timestamp: Date.now() })
-    return true
-  }
-
-  // Push synchronously — before children are mounted — so child errors see this boundary
-  pushErrorBoundary(handler)
-  // Identity-based pop: pass our own handler reference. Sibling boundaries
-  // can unmount in any order driven by the renderer (keyed `<For>` removal
-  // of a non-last item, `<Show>` flipping on the FIRST of N siblings, route
-  // nav, etc.) — without passing the handler reference, the position-based
-  // `pop()` would remove the WRONG boundary's handler. Same bug class as
-  // #725 (`popContext()` orphaning provider frames under reactive remount).
-  onUnmount(() => popErrorBoundary(handler))
-
-  return (): VNodeChildAtom => {
-    const err = error()
-    if (err != null) return props.fallback(err, reset) as VNodeChildAtom
-    const ch = props.children
-    return (typeof ch === 'function' ? ch() : ch) as VNodeChildAtom
-  }
-}
-
-// Mark as native so compat-mode jsx() runtimes (react/preact/vue/solid-compat)
-// skip wrapCompatComponent — ErrorBoundary uses pushErrorBoundary/onUnmount,
-// which need Pyreon's setup frame (compat wrapping breaks dispatchToErrorBoundary).
-nativeCompat(ErrorBoundary)

package/src/for.ts

@@ -1,51 +0,0 @@
-import type { NativeItem, Props, VNode } from './types'
-
-/**
- * Symbol used as the VNode type for a For list — runtime-dom handles it
- * via mountFor, bypassing the generic VNode reconciler.
- */
-export const ForSymbol: unique symbol = Symbol('pyreon.For')
-
-export interface ForProps<T> {
-  /**
-   * The list to iterate. Accepts EITHER a function returning the array
-   * (preferred — keeps reactivity intact when the array comes from a
-   * signal accessor) OR the array directly (convenient for static lists
-   * or already-resolved arrays). The runtime in `runtime-dom/src/mount.ts`
-   * normalizes both shapes; this type matches the runtime so users aren't
-   * forced to write `each={() => items}` for a plain array.
-   *
-   * @example
-   * <For each={items}>{r => <li>{r.label}</li>}</For>           // static
-   * <For each={() => store.items()}>{r => <li>...</li>}</For>   // reactive
-   */
-  each: T[] | (() => T[])
-  /** Keying function — use `by` not `key` (JSX extracts `key` for VNode reconciliation). */
-  by: (item: T) => string | number
-  children: (item: T) => VNode | NativeItem
-  /**
-   * @deprecated Use `by` instead of `key`. In Pyreon, `<For>` uses `by` for keying.
-   * JSX reserves `key` for VNode reconciliation — it won't reach the component.
-   */
-  key?: never
-}
-
-/**
- * Efficient reactive list rendering.
- *
- * Unlike a plain `() => items().map(item => h(...))`, For never re-creates
- * VNodes for existing keys — only new keys invoke `children()`. Structural
- * mutations (swap, sort, filter) are O(n) key scan + O(k) DOM moves where k
- * is the number of actually displaced entries.
- *
- * Usage:
- *   <For each={items} by={r => r.id}>{r => <li>...</li>}</For>
- */
-export function For<T>(props: ForProps<T>): VNode {
-  return {
-    type: ForSymbol as unknown as string,
-    props: props as unknown as Props,
-    children: [],
-    key: null,
-  }
-}

package/src/h.ts

@@ -1,80 +0,0 @@
-import type { ComponentFn, Props, VNode, VNodeChild } from './types'
-
-/**
- * Marker for fragment nodes — renders children without a wrapper element.
- *
- * MUST use `Symbol.for(...)` (global registry, keyed by string), NOT
- * `Symbol(...)` (fresh per evaluation). `h.ts` is inlined into BOTH the
- * main `lib/index.js` and the `lib/jsx-runtime.js` published bundles —
- * each bundle's evaluation of a bare `Symbol(...)` would produce a
- * DISTINCT Symbol identity. JSX `<>` compiles to `jsx(Fragment, ...)` and
- * resolves to jsx-runtime's identity; `runtime-server` checks
- * `vnode.type === Fragment` against the main-entry identity. Mismatch
- * fell through to `renderElement` and crashed SSG with
- * `TypeError: Cannot convert a Symbol value to a string`.
- * `Symbol.for()` keys by string in a global registry shared across all
- * bundle evaluations — same identity everywhere.
- */
-export const Fragment: symbol = Symbol.for('Pyreon.Fragment')
-
-/**
- * Hyperscript function — the compiled output of JSX.
- * `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
- *
- * Generic on P so TypeScript validates props match the component's signature
- * at the call site, then stores the result in the loosely-typed VNode.
- */
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-export const EMPTY_PROPS: Props = {} as Props
-
-/** Makes `children` optional in P (if present) so it can be passed as rest args to h(). */
-type PropsWithOptionalChildren<P extends Props> = Omit<P, 'children'> &
-  ('children' extends keyof P ? { children?: P['children'] } : unknown)
-
-// Overload: component with typed props — children is optional in the props object
-// because it can be passed as rest args. Extra keys are allowed via `& Props`.
-export function h<P extends Props>(
-  type: ComponentFn<P>,
-  props: (PropsWithOptionalChildren<P> & Props) | null,
-  ...children: VNodeChild[]
-): VNode
-// Overload: intrinsic element, symbol, generic/dynamic component, or mixed union
-export function h(
-  type: string | ((p: any) => VNodeChild) | symbol,
-  props: Props | null,
-  ...children: VNodeChild[]
-): VNode
-export function h<P extends Props>(
-  type: string | ComponentFn<P> | symbol,
-  props: P | null,
-  ...children: VNodeChild[]
-): VNode {
-  return {
-    type: type as string | ComponentFn | symbol,
-    props: (props ?? EMPTY_PROPS) as Props,
-    children: normalizeChildren(children),
-    key: (props?.key as string | number | null) ?? null,
-  }
-}
-
-function normalizeChildren(children: VNodeChild[]): VNodeChild[] {
-  // Fast path: no nested arrays — return as-is without allocating
-  for (let i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return flattenChildren(children)
-    }
-  }
-  return children
-}
-
-function flattenChildren(children: VNodeChild[]): VNodeChild[] {
-  const result: VNodeChild[] = []
-  for (const child of children) {
-    if (Array.isArray(child)) {
-      result.push(...flattenChildren(child as VNodeChild[]))
-    } else {
-      result.push(child)
-    }
-  }
-  return result
-}

package/src/index.ts

@@ -1,80 +0,0 @@
-// @pyreon/core — component model, VNode types, lifecycle hooks
-
-export { defineComponent, dispatchToErrorBoundary, propagateError, runWithHooks } from './component'
-export { isNativeCompat, NATIVE_COMPAT_MARKER, nativeCompat } from './compat-marker'
-export { mapCompatDomProps, shallowEqualProps } from './compat-shared'
-export type { Context, ContextSnapshot, ReactiveContext } from './context'
-export {
-  captureContextStack,
-  createContext,
-  createReactiveContext,
-  getContextStackLength,
-  popContext,
-  provide,
-  pushContext,
-  removeContextFrame,
-  restoreContextStack,
-  setContextStackProvider,
-  useContext,
-  withContext,
-} from './context'
-export type { DynamicProps } from './dynamic'
-export { Dynamic } from './dynamic'
-export { ErrorBoundary } from './error-boundary'
-export type { ForProps } from './for'
-export { For, ForSymbol } from './for'
-export { EMPTY_PROPS, Fragment, h } from './h'
-export type {
-  AnchorAttributes,
-  ButtonAttributes,
-  CSSProperties,
-  FormAttributes,
-  ImgAttributes,
-  InputAttributes,
-  PyreonHTMLAttributes,
-  SelectAttributes,
-  StyleValue,
-  SvgAttributes,
-  TargetedEvent,
-  TextareaAttributes,
-} from './jsx-runtime'
-export type { DeferProps } from './defer'
-export { Defer } from './defer'
-export { lazy } from './lazy'
-export { onErrorCaptured, onMount, onUnmount, onUpdate } from './lifecycle'
-export { mapArray } from './map-array'
-export type { PortalProps } from './portal'
-export { Portal, PortalSymbol } from './portal'
-export {
-  _rp,
-  _wrapSpread,
-  createUniqueId,
-  makeReactiveProps,
-  mergeProps,
-  REACTIVE_PROP,
-  splitProps,
-} from './props'
-export type { Ref, RefCallback, RefProp } from './ref'
-export { createRef } from './ref'
-export type { MatchProps, ShowProps, SwitchProps } from './show'
-export { Match, MatchSymbol, Show, Switch } from './show'
-export type { ClassValue } from './style'
-export { CSS_UNITLESS, cx, normalizeStyleValue, toKebabCase } from './style'
-export type { LazyComponent } from './suspense'
-export { Suspense } from './suspense'
-export type { ErrorContext, ErrorHandler, ReactiveTraceEntry } from './telemetry'
-export { registerErrorHandler, reportError } from './telemetry'
-export type {
-  CleanupFn,
-  ComponentFn,
-  ComponentInstance,
-  ExtractProps,
-  HigherOrderComponent,
-  LifecycleHooks,
-  NativeItem,
-  Props,
-  VNode,
-  VNodeChild,
-  VNodeChildAccessor,
-  VNodeChildAtom,
-} from './types'

package/src/jsx-dev-runtime.ts

@@ -1,2 +0,0 @@
-// Dev runtime — same as production but bundlers may inject extra debug info
-export { Fragment, jsx as jsxDEV, jsxs } from './jsx-runtime'