@fictjs/runtime 0.0.2

package/src/effect.ts

@@ -0,0 +1,83 @@
+import {
+  getCurrentRoot,
+  handleError,
+  registerRootCleanup,
+  runCleanupList,
+  withEffectCleanups,
+} from './lifecycle'
+import { effect } from './signal'
+import type { Cleanup } from './types'
+
+export type Effect = () => void | Cleanup
+
+export function createEffect(fn: Effect): () => void {
+  let cleanups: Cleanup[] = []
+  const rootForError = getCurrentRoot()
+
+  const run = () => {
+    runCleanupList(cleanups)
+    const bucket: Cleanup[] = []
+    withEffectCleanups(bucket, () => {
+      try {
+        const maybeCleanup = fn()
+        if (typeof maybeCleanup === 'function') {
+          bucket.push(maybeCleanup)
+        }
+      } catch (err) {
+        if (handleError(err, { source: 'effect' }, rootForError)) {
+          return
+        }
+        throw err
+      }
+    })
+    cleanups = bucket
+  }
+
+  const disposeEffect = effect(run)
+  const teardown = () => {
+    runCleanupList(cleanups)
+    disposeEffect()
+  }
+
+  registerRootCleanup(teardown)
+
+  return teardown
+}
+
+export const $effect = createEffect
+
+export function createRenderEffect(fn: Effect): () => void {
+  let cleanup: Cleanup | undefined
+  const rootForError = getCurrentRoot()
+
+  const run = () => {
+    if (cleanup) {
+      cleanup()
+      cleanup = undefined
+    }
+    try {
+      const maybeCleanup = fn()
+      if (typeof maybeCleanup === 'function') {
+        cleanup = maybeCleanup
+      }
+    } catch (err) {
+      if (handleError(err, { source: 'effect' }, rootForError)) {
+        return
+      }
+      throw err
+    }
+  }
+
+  const disposeEffect = effect(run)
+  const teardown = () => {
+    if (cleanup) {
+      cleanup()
+      cleanup = undefined
+    }
+    disposeEffect()
+  }
+
+  registerRootCleanup(teardown)
+
+  return teardown
+}

package/src/error-boundary.ts

@@ -0,0 +1,118 @@
+import { createElement } from './dom'
+import { createEffect } from './effect'
+import {
+  createRootContext,
+  destroyRoot,
+  flushOnMount,
+  pushRoot,
+  popRoot,
+  registerErrorHandler,
+} from './lifecycle'
+import { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'
+import { createSignal } from './signal'
+import type { BaseProps, FictNode } from './types'
+
+interface ErrorBoundaryProps extends BaseProps {
+  fallback: FictNode | ((err: unknown) => FictNode)
+  onError?: (err: unknown) => void
+  resetKeys?: unknown | (() => unknown)
+}
+
+export function ErrorBoundary(props: ErrorBoundaryProps): FictNode {
+  const fragment = document.createDocumentFragment()
+  const marker = document.createComment('fict:error-boundary')
+  fragment.appendChild(marker)
+
+  const currentView = createSignal<FictNode | null>(props.children ?? null)
+
+  let cleanup: (() => void) | undefined
+  let activeNodes: Node[] = []
+  let renderingFallback = false
+
+  const toView = (err: unknown | null): FictNode | null => {
+    if (err != null) {
+      return typeof props.fallback === 'function'
+        ? (props.fallback as (e: unknown) => FictNode)(err)
+        : props.fallback
+    }
+    return props.children ?? null
+  }
+
+  const renderValue = (value: FictNode | null) => {
+    if (cleanup) {
+      cleanup()
+      cleanup = undefined
+    }
+    if (activeNodes.length) {
+      removeNodes(activeNodes)
+      activeNodes = []
+    }
+
+    if (value == null || value === false) {
+      return
+    }
+
+    const root = createRootContext()
+    const prev = pushRoot(root)
+    let nodes: Node[] = []
+    try {
+      const output = createElement(value)
+      nodes = toNodeArray(output)
+      const parentNode = marker.parentNode as (ParentNode & Node) | null
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker)
+      }
+    } catch (err) {
+      popRoot(prev)
+      flushOnMount(root)
+      destroyRoot(root)
+      // Fall back immediately on render errors, avoid infinite recursion
+      if (renderingFallback) {
+        throw err
+      }
+      renderingFallback = true
+      try {
+        renderValue(toView(err))
+      } finally {
+        renderingFallback = false
+      }
+      props.onError?.(err)
+      return
+    }
+    popRoot(prev)
+    flushOnMount(root)
+
+    cleanup = () => {
+      destroyRoot(root)
+      removeNodes(nodes)
+    }
+    activeNodes = nodes
+  }
+
+  createEffect(() => {
+    const value = currentView()
+    renderValue(value)
+  })
+
+  registerErrorHandler(err => {
+    renderValue(toView(err))
+    props.onError?.(err)
+    return true
+  })
+
+  if (props.resetKeys !== undefined) {
+    const isGetter =
+      typeof props.resetKeys === 'function' && (props.resetKeys as () => unknown).length === 0
+    const getter = isGetter ? (props.resetKeys as () => unknown) : undefined
+    let prev = isGetter ? getter!() : props.resetKeys
+    createEffect(() => {
+      const next = getter ? getter() : props.resetKeys
+      if (prev !== next) {
+        prev = next
+        renderValue(toView(null))
+      }
+    })
+  }
+
+  return fragment
+}

package/src/hooks.ts

@@ -0,0 +1,72 @@
+import { createEffect } from './effect'
+import { createMemo } from './memo'
+import { createSignal, type SignalAccessor, type ComputedAccessor } from './signal'
+
+interface HookContext {
+  slots: unknown[]
+  cursor: number
+}
+
+const ctxStack: HookContext[] = []
+
+export function __fictUseContext(): HookContext {
+  if (ctxStack.length === 0) {
+    const ctx: HookContext = { slots: [], cursor: 0 }
+    ctxStack.push(ctx)
+    return ctx
+  }
+  const ctx = ctxStack[ctxStack.length - 1]!
+  ctx.cursor = 0
+  return ctx
+}
+
+export function __fictPushContext(): HookContext {
+  const ctx: HookContext = { slots: [], cursor: 0 }
+  ctxStack.push(ctx)
+  return ctx
+}
+
+export function __fictPopContext(): void {
+  ctxStack.pop()
+}
+
+export function __fictResetContext(): void {
+  ctxStack.length = 0
+}
+
+export function __fictUseSignal<T>(ctx: HookContext, initial: T, slot?: number): SignalAccessor<T> {
+  const index = slot ?? ctx.cursor++
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createSignal(initial)
+  }
+  return ctx.slots[index] as SignalAccessor<T>
+}
+
+export function __fictUseMemo<T>(
+  ctx: HookContext,
+  fn: () => T,
+  slot?: number,
+): ComputedAccessor<T> {
+  const index = slot ?? ctx.cursor++
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createMemo(fn)
+  }
+  return ctx.slots[index] as ComputedAccessor<T>
+}
+
+export function __fictUseEffect(ctx: HookContext, fn: () => void, slot?: number): void {
+  const index = slot ?? ctx.cursor++
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createEffect(fn)
+  }
+}
+
+export function __fictRender<T>(ctx: HookContext, fn: () => T): T {
+  ctxStack.push(ctx)
+  ctx.cursor = 0
+  try {
+    return fn()
+  } finally {
+    ctxStack.pop()
+  }
+}

package/src/index.ts

@@ -0,0 +1,184 @@
+// ============================================================================
+// Core Reactive Primitives
+// ============================================================================
+
+export { createSignal, createSelector, type Signal, $state } from './signal'
+export { createStore, type Store } from './store'
+export { createMemo, type Memo, $memo } from './memo'
+export { createEffect, createRenderEffect, type Effect, $effect } from './effect'
+export {
+  __fictUseContext,
+  __fictPushContext,
+  __fictPopContext,
+  __fictUseSignal,
+  __fictUseMemo,
+  __fictUseEffect,
+  __fictRender,
+  __fictResetContext,
+} from './hooks'
+export {
+  createVersionedSignal,
+  type VersionedSignal,
+  type VersionedSignalOptions,
+} from './versioned-signal'
+
+// Props helpers
+export {
+  __fictProp,
+  __fictProp as prop,
+  __fictPropsRest,
+  mergeProps,
+  useProp,
+  createPropsProxy,
+} from './props'
+
+// ============================================================================
+// Lifecycle
+// ============================================================================
+
+export { onMount, onDestroy, onCleanup, createRoot } from './lifecycle'
+
+// Ref utilities
+export { createRef } from './ref'
+
+// ============================================================================
+// Scheduler / Utilities
+// ============================================================================
+
+export { batch, untrack } from './scheduler'
+export { setCycleProtectionOptions } from './cycle-guard'
+
+// Transition API for priority scheduling
+export { startTransition, useTransition, useDeferredValue } from './scheduler'
+
+// ============================================================================
+// JSX Runtime
+// ============================================================================
+
+export type { JSX } from './jsx'
+export { Fragment } from './jsx'
+
+// ============================================================================
+// DOM Rendering
+// ============================================================================
+
+export { createElement, render, template } from './dom'
+export { ErrorBoundary } from './error-boundary'
+export { Suspense, createSuspenseToken } from './suspense'
+
+// ============================================================================
+// Reactive DOM Bindings
+// ============================================================================
+
+export {
+  // Core binding utilities
+  createTextBinding,
+  createChildBinding,
+  createAttributeBinding,
+  createStyleBinding,
+  createClassBinding,
+  // Low-level binding helpers (for direct DOM manipulation)
+  bindText,
+  bindAttribute,
+  bindStyle,
+  bindClass,
+  bindEvent,
+  bindProperty,
+  bindRef,
+  insert,
+  // Event delegation
+  delegateEvents,
+  clearDelegatedEvents,
+  addEventListener,
+  // Spread props
+  spread,
+  assign,
+  classList,
+  // Reactive detection
+  isReactive,
+  // Advanced bindings
+  createConditional,
+  createList,
+  createPortal,
+  createShow,
+  // Utility functions
+  unwrap,
+  unwrapPrimitive,
+} from './binding'
+
+// Constants for DOM handling
+export {
+  Properties,
+  ChildProperties,
+  Aliases,
+  getPropAlias,
+  BooleanAttributes,
+  SVGElements,
+  SVGNamespace,
+  DelegatedEvents,
+  UnitlessStyles,
+} from './constants'
+
+// Reconcile algorithm
+export { default as reconcileArrays } from './reconcile'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type {
+  MaybeReactive,
+  BindingHandle,
+  KeyFn,
+  CreateElementFn,
+  AttributeSetter,
+} from './binding'
+
+export type {
+  FictNode,
+  FictVNode,
+  DOMElement,
+  Cleanup,
+  Component,
+  BaseProps,
+  PropsWithChildren,
+  Ref,
+  RefCallback,
+  RefObject,
+  StyleProp,
+  ClassProp,
+  EventHandler,
+  ErrorInfo,
+  SuspenseToken,
+} from './types'
+
+// Devtools hook (optional)
+export { getDevtoolsHook, type FictDevtoolsHook } from './devtools'
+
+// ============================================================================
+// List Helpers (for compiler-generated code)
+// ============================================================================
+
+export {
+  // DOM manipulation primitives
+  moveNodesBefore,
+  removeNodes,
+  insertNodesBefore,
+  moveMarkerBlock,
+  destroyMarkerBlock,
+  // Keyed list container
+  createKeyedListContainer,
+  // Block creation
+  createKeyedBlock,
+  // High-level list binding (for compiler-generated code)
+  createKeyedList,
+  // Utilities
+  toNodeArray,
+  getFirstNodeAfter,
+  isNodeBetweenMarkers,
+  // Types
+  type KeyedBlock,
+  type KeyedListContainer,
+  type KeyedListBinding,
+  type MarkerBlock,
+} from './list-helpers'

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,2 @@
+export { jsx, jsxs, jsxDEV, Fragment } from './jsx'
+export type { JSX } from './jsx'

package/src/jsx-runtime.ts

@@ -0,0 +1,2 @@
+export { jsx, jsxs, jsxDEV, Fragment } from './jsx'
+export type { JSX } from './jsx'