kiru 0.48.3 → 0.50.0-preview.0

package/src/components/suspense.ts

@@ -0,0 +1,193 @@
+import { requestUpdate } from "../scheduler.js"
+import { renderMode } from "../globals.js"
+import {
+  cleanupHook,
+  depsRequireChange,
+  useHook,
+  useId,
+} from "../hooks/index.js"
+import { __DEV__ } from "../env.js"
+import { getCurrentVNode } from "../utils/index.js"
+import { $SUSPENSE_THROW, PREFETCHED_DATA_EVENT } from "../constants.js"
+import { Signal, useSignal } from "../signals/index.js"
+
+export type { SuspenseProps, UsePromiseState }
+export { Suspense, isSuspenseThrowValue, usePromise }
+
+type StatefulPromiseValues<T extends readonly Kiru.StatefulPromise<unknown>[]> =
+  {
+    [I in keyof T]: T[I] extends Kiru.StatefulPromise<infer V> ? V : never
+  }
+
+type SuspenseChildrenArgs<
+  T extends Kiru.StatefulPromise<any> | Kiru.StatefulPromise<any>[]
+> = T extends Kiru.StatefulPromise<any>[]
+  ? StatefulPromiseValues<T>
+  : [T extends Kiru.StatefulPromise<infer V> ? V : never]
+
+interface SuspenseProps<
+  T extends Kiru.StatefulPromise<any> | Kiru.StatefulPromise<any>[]
+> {
+  data: T
+  children: (...data: SuspenseChildrenArgs<T>) => JSX.Element
+  fallback?: JSX.Element
+}
+
+function Suspense<
+  const T extends
+    | Kiru.StatefulPromise<unknown>
+    | Kiru.StatefulPromise<unknown>[]
+>({ data, children, fallback }: SuspenseProps<T>) {
+  const promiseArray: Kiru.StatefulPromise<unknown>[] = Array.isArray(data)
+    ? data
+    : [data]
+
+  switch (renderMode.current) {
+    case "stream":
+    case "string":
+      throw {
+        fallback,
+        pendingData: promiseArray,
+        [$SUSPENSE_THROW]: true,
+      } satisfies SuspenseThrowValue
+
+    case "dom":
+    case "hydrate":
+      for (const p of promiseArray) {
+        if (p.state === "rejected") throw p.error
+        if (p.state === "pending") {
+          const n = getCurrentVNode()!
+          Promise.allSettled(promiseArray).then(() => requestUpdate(n))
+          return fallback
+        }
+      }
+      const values = promiseArray.map((p) => p.value) as SuspenseChildrenArgs<T>
+
+      return children(...values)
+  }
+}
+
+interface SuspenseThrowValue {
+  fallback?: JSX.Element
+  pendingData?: Kiru.StatefulPromise<unknown>[]
+  [$SUSPENSE_THROW]: true
+}
+
+/**
+ * Returns true if the value was thrown by a Suspense component.
+ */
+function isSuspenseThrowValue(value: unknown): value is SuspenseThrowValue {
+  return typeof value === "object" && !!value && $SUSPENSE_THROW in value
+}
+
+interface PromiseResolveEventDetail<T> {
+  id: string
+  data?: T
+  error?: string
+}
+
+function resolveHydrationPromise<T>(
+  id: string,
+  signal: AbortSignal
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const prefetchCache: Map<string, { data?: T; error?: string }> = // @ts-ignore
+      (window[PREFETCHED_DATA_EVENT] ??= new Map())
+
+    const existing = prefetchCache.get(id)
+    if (existing) {
+      const { data, error } = existing
+      prefetchCache.delete(id)
+      if (error) return reject(error)
+      return resolve(data!)
+    }
+
+    const onDataEvent = (event: Event) => {
+      const { detail } = event as CustomEvent<PromiseResolveEventDetail<T>>
+      if (detail.id === id) {
+        prefetchCache.delete(id)
+        window.removeEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+        const { data, error } = detail
+        if (error) return reject(error)
+        resolve(data!)
+      }
+    }
+
+    console.log("listening for prefetch event")
+    window.addEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+    signal.addEventListener("abort", () => {
+      window.removeEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+      reject()
+    })
+  })
+}
+
+const nodeToPromiseIndex = new WeakMap<Kiru.VNode, number>()
+
+interface UsePromiseContext {
+  signal: AbortSignal
+}
+
+interface UsePromiseState<T> {
+  data: Kiru.StatefulPromise<T>
+  refresh: () => void
+  pending: Signal<boolean>
+}
+
+function usePromise<T>(
+  callback: (ctx: UsePromiseContext) => Promise<T>,
+  deps: unknown[]
+): UsePromiseState<T> {
+  const id = useId()
+  const pending = useSignal(true)
+
+  return useHook(
+    "usePromise",
+    {} as {
+      promise: Kiru.StatefulPromise<T>
+      abortController?: AbortController
+      deps?: unknown[]
+    },
+    ({ hook, isInit, vNode }) => {
+      if (isInit || depsRequireChange(deps, hook.deps)) {
+        pending.value = true
+        hook.deps = deps
+        cleanupHook(hook)
+
+        const controller = (hook.abortController = new AbortController())
+        hook.cleanup = () => controller.abort()
+
+        const index = nodeToPromiseIndex.get(vNode) ?? 0
+        nodeToPromiseIndex.set(vNode, index + 1)
+
+        const promiseId = `${id}:data:${index}`
+        const state: Kiru.PromiseState<T> = { id: promiseId, state: "pending" }
+        const promise =
+          renderMode.current === "hydrate"
+            ? resolveHydrationPromise<T>(promiseId, controller.signal)
+            : callback({ signal: controller.signal })
+
+        const p = (hook.promise = Object.assign(promise, state))
+        p.then((value) => {
+          p.state = "fulfilled"
+          p.value = value
+        })
+          .catch((error) => {
+            p.state = "rejected"
+            p.error = error instanceof Error ? error : new Error(error)
+          })
+          .finally(() => {
+            pending.value = false
+          })
+      }
+      return {
+        data: hook.promise,
+        refresh: () => {
+          hook.deps = undefined
+          requestUpdate(vNode)
+        },
+        pending,
+      }
+    }
+  )
+}

package/src/{transition.ts → components/transition.ts}

@@ -1,8 +1,8 @@
-import { useCallback } from "./hooks/useCallback.js"
-import { useEffect } from "./hooks/useEffect.js"
-import { useLayoutEffect } from "./hooks/useLayoutEffect.js"
-import { useRef } from "./hooks/useRef.js"
-import { useState } from "./hooks/useState.js"
+import { useCallback } from "../hooks/useCallback.js"
+import { useEffect } from "../hooks/useEffect.js"
+import { useLayoutEffect } from "../hooks/useLayoutEffect.js"
+import { useRef } from "../hooks/useRef.js"
+import { useState } from "../hooks/useState.js"
 
 export type TransitionState = "entering" | "entered" | "exiting" | "exited"
 interface TransitionProps {

package/src/constants.ts

@@ -6,9 +6,11 @@ export {
   $KIRU_ERROR,
   $HMR_ACCEPT,
   $MEMO,
+  $ERROR_BOUNDARY,
   $HYDRATION_BOUNDARY,
+  $SUSPENSE_THROW,
   CONSECUTIVE_DIRTY_LIMIT,
-  REGEX_UNIT,
+  PREFETCHED_DATA_EVENT,
   EVENT_PREFIX_REGEX,
   FLAG_UPDATE,
   FLAG_PLACEMENT,
@@ -19,7 +21,7 @@ export {
   FLAG_DIRTY,
 }
 
-export { voidElements, svgTags, booleanAttributes }
+export { voidElements, svgTags, booleanAttributes, snakeCaseAttributes }
 
 const $SIGNAL = Symbol.for("kiru.signal")
 const $CONTEXT = Symbol.for("kiru.context")
@@ -28,9 +30,12 @@ const $FRAGMENT = Symbol.for("kiru.fragment")
 const $KIRU_ERROR = Symbol.for("kiru.error")
 const $HMR_ACCEPT = Symbol.for("kiru.hmrAccept")
 const $MEMO = Symbol.for("kiru.memo")
+const $ERROR_BOUNDARY = Symbol.for("kiru.errorBoundary")
 const $HYDRATION_BOUNDARY = Symbol.for("kiru.hydrationBoundary")
+const $SUSPENSE_THROW = Symbol.for("kiru.suspenseThrow")
 
 const CONSECUTIVE_DIRTY_LIMIT = 50
+const PREFETCHED_DATA_EVENT = "kiru:prefetched"
 
 const FLAG_UPDATE = 1 << 1
 const FLAG_PLACEMENT = 1 << 2
@@ -40,17 +45,6 @@ const FLAG_MEMO = 1 << 5
 const FLAG_NOOP = 1 << 6
 const FLAG_DIRTY = 1 << 7
 
-const REGEX_UNIT = {
-  AMP_G: /&/g,
-  LT_G: /</g,
-  GT_G: />/g,
-  SQT_G: /'/g,
-  DBLQT_G: /"/g,
-  SLASH_G: /\//g,
-  SLASHN_SLASHR_G: /[\n\r]+/g,
-  ALPHA_UPPER_G: /[A-Z]/g,
-} as const
-
 const EVENT_PREFIX_REGEX = /^on:?/
 
 const voidElements = new Set([
@@ -155,3 +149,82 @@ const booleanAttributes = new Set([
   "translate",
   "wrap",
 ])
+
+const snakeCaseAttributes = new Map([
+  ["acceptCharset", "accept-charset"],
+  ["accentHeight", "accent-height"],
+  ["alignmentBaseline", "alignment-baseline"],
+  ["arabicForm", "arabic-form"],
+  ["baselineShift", "baseline-shift"],
+  ["capHeight", "cap-height"],
+  ["clipPath", "clip-path"],
+  ["clipRule", "clip-rule"],
+  ["colorInterpolation", "color-interpolation"],
+  ["colorInterpolationFilters", "color-interpolation-filters"],
+  ["colorProfile", "color-profile"],
+  ["colorRendering", "color-rendering"],
+  ["dominantBaseline", "dominant-baseline"],
+  ["enableBackground", "enable-background"],
+  ["fillOpacity", "fill-opacity"],
+  ["fillRule", "fill-rule"],
+  ["floodColor", "flood-color"],
+  ["floodOpacity", "flood-opacity"],
+  ["fontFamily", "font-family"],
+  ["fontSize", "font-size"],
+  ["fontSizeAdjust", "font-size-adjust"],
+  ["fontStretch", "font-stretch"],
+  ["fontStyle", "font-style"],
+  ["fontVariant", "font-variant"],
+  ["fontWeight", "font-weight"],
+  ["glyphName", "glyph-name"],
+  ["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
+  ["glyphOrientationVertical", "glyph-orientation-vertical"],
+  ["horizAdvX", "horiz-adv-x"],
+  ["horizOriginX", "horiz-origin-x"],
+  ["httpEquiv", "http-equiv"],
+  ["imageRendering", "image-rendering"],
+  ["letterSpacing", "letter-spacing"],
+  ["lightingColor", "lighting-color"],
+  ["markerEnd", "marker-end"],
+  ["markerMid", "marker-mid"],
+  ["markerStart", "marker-start"],
+  ["overlinePosition", "overline-position"],
+  ["overlineThickness", "overline-thickness"],
+  ["paintOrder", "paint-order"],
+  ["panose-1", "panose-1"],
+  ["pointerEvents", "pointer-events"],
+  ["renderingIntent", "rendering-intent"],
+  ["shapeRendering", "shape-rendering"],
+  ["stopColor", "stop-color"],
+  ["stopOpacity", "stop-opacity"],
+  ["strikethroughPosition", "strikethrough-position"],
+  ["strikethroughThickness", "strikethrough-thickness"],
+  ["strokeDasharray", "stroke-dasharray"],
+  ["strokeDashoffset", "stroke-dashoffset"],
+  ["strokeLinecap", "stroke-linecap"],
+  ["strokeLinejoin", "stroke-linejoin"],
+  ["strokeMiterlimit", "stroke-miterlimit"],
+  ["strokeOpacity", "stroke-opacity"],
+  ["strokeWidth", "stroke-width"],
+  ["textAnchor", "text-anchor"],
+  ["textDecoration", "text-decoration"],
+  ["textRendering", "text-rendering"],
+  ["transformOrigin", "transform-origin"],
+  ["underlinePosition", "underline-position"],
+  ["underlineThickness", "underline-thickness"],
+  ["unicodeBidi", "unicode-bidi"],
+  ["unicodeRange", "unicode-range"],
+  ["unitsPerEm", "units-per-em"],
+  ["vAlphabetic", "v-alphabetic"],
+  ["vHanging", "v-hanging"],
+  ["vIdeographic", "v-ideographic"],
+  ["vMathematical", "v-mathematical"],
+  ["vectorEffect", "vector-effect"],
+  ["vertAdvY", "vert-adv-y"],
+  ["vertOriginX", "vert-origin-x"],
+  ["vertOriginY", "vert-origin-y"],
+  ["wordSpacing", "word-spacing"],
+  ["writingMode", "writing-mode"],
+  ["xmlnsXlink", "xmlns:xlink"],
+  ["xHeight", "x-height"],
+])

package/src/context.ts

@@ -4,7 +4,7 @@ import { __DEV__ } from "./env.js"
 import { GenericHMRAcceptor } from "./hmr.js"
 import { useState } from "./hooks/useState.js"
 import { requestUpdate } from "./scheduler.js"
-import { traverseApply } from "./utils.js"
+import { traverseApply } from "./utils/index.js"
 
 export function createContext<T>(defaultValue: T): Kiru.Context<T> {
   const ctx: Kiru.Context<T> = {

package/src/customEvents.ts

@@ -1,22 +1,22 @@
-export class CustomEvents {
-  private constructor() {}
-
-  static on<K extends keyof Kiru.CustomEvents & string>(
-    type: K,
-    callback: (event: CustomEvent<Kiru.CustomEvents[K]>) => void
-  ) {
-    window.addEventListener(type, callback as unknown as EventListener)
-    return () =>
-      window.removeEventListener(type, callback as unknown as EventListener)
-  }
-
-  static dispatch<K extends keyof Kiru.CustomEvents & string>(
-    type: K,
-    detail: Kiru.CustomEvents[K],
-    target?: Element
-  ) {
-    ;(target || document).dispatchEvent(
-      new CustomEvent(type, { detail, bubbles: true })
-    )
-  }
-}
+export class CustomEvents {
+  private constructor() {}
+
+  static on<K extends keyof Kiru.CustomEvents & string>(
+    type: K,
+    callback: (event: CustomEvent<Kiru.CustomEvents[K]>) => void
+  ) {
+    window.addEventListener(type, callback as unknown as EventListener)
+    return () =>
+      window.removeEventListener(type, callback as unknown as EventListener)
+  }
+
+  static dispatch<K extends keyof Kiru.CustomEvents & string>(
+    type: K,
+    detail: Kiru.CustomEvents[K],
+    target?: Element
+  ) {
+    ;(target || document).dispatchEvent(
+      new CustomEvent(type, { detail, bubbles: true })
+    )
+  }
+}

package/src/dom.ts

@@ -4,7 +4,7 @@ import {
   propFilters,
   propToHtmlAttr,
   getVNodeAppContext,
-} from "./utils.js"
+} from "./utils/index.js"
 import {
   booleanAttributes,
   FLAG_PLACEMENT,
@@ -100,15 +100,14 @@ function createDom(vNode: DomVNode): SomeDom {
   return dom
 }
 function createTextNode(vNode: VNode): Text {
-  const nodeValue = vNode.props.nodeValue
-  if (Signal.isSignal(nodeValue)) {
-    const value = nodeValue.peek()
-    const textNode = document.createTextNode(value)
-    subTextNode(vNode, textNode, nodeValue)
-    return textNode
+  const { nodeValue } = vNode.props
+  if (!Signal.isSignal(nodeValue)) {
+    return document.createTextNode(nodeValue)
   }
 
-  const textNode = document.createTextNode(nodeValue)
+  const value = nodeValue.peek() ?? ""
+  const textNode = document.createTextNode(value)
+  subTextNode(vNode, textNode, nodeValue)
   return textNode
 }
 
@@ -720,9 +719,7 @@ function placeAndCommitNoopChildren(
     const nextSiblingDom = getNextSiblingDom(parent, node)
     const parentDom = node.dom
     if (nextSiblingDom) {
-      const [first, ...rest] = domChildren
-      parentDom.insertBefore(first, nextSiblingDom)
-      first.after(...rest)
+      nextSiblingDom.before(...domChildren)
     } else {
       parentDom.append(...domChildren)
     }

package/src/element.ts

@@ -1,6 +1,6 @@
 import { $FRAGMENT, $MEMO, FLAG_MEMO } from "./constants.js"
-import { isMemoFn } from "./memo.js"
-import { isValidElementKeyProp, isValidElementRefProp } from "./props.js"
+import { isMemoFn } from "./components/memo.js"
+import { isValidElementKeyProp, isValidElementRefProp } from "./utils/index.js"
 
 export function createElement<T extends Kiru.VNode["type"]>(
   type: T,

package/src/error.ts

@@ -1,6 +1,6 @@
 import { $KIRU_ERROR } from "./constants.js"
 import { __DEV__ } from "./env.js"
-import { findParent, noop } from "./utils.js"
+import { findParent, noop } from "./utils/index.js"
 
 type KiruErrorOptions =
   | string

package/src/form/index.ts

@@ -1,7 +1,10 @@
 import { __DEV__ } from "../env.js"
 import { Fragment } from "../element.js"
-import { generateRandomID } from "../generateId.js"
-import { safeStringify, shallowCompare } from "../utils.js"
+import {
+  safeStringify,
+  shallowCompare,
+  generateRandomID,
+} from "../utils/index.js"
 import { useEffect } from "../hooks/useEffect.js"
 import { useMemo } from "../hooks/useMemo.js"
 import { useRef } from "../hooks/useRef.js"

package/src/hmr.ts

@@ -1,6 +1,6 @@
 import { $HMR_ACCEPT } from "./constants.js"
 import { __DEV__ } from "./env.js"
-import { traverseApply } from "./utils.js"
+import { traverseApply } from "./utils/index.js"
 import { requestUpdate } from "./scheduler.js"
 import { Signal } from "./signals/base.js"
 import type { WatchEffect } from "./signals/watch.js"

package/src/hooks/useAsync.ts

@@ -1,6 +1,6 @@
 import { __DEV__ } from "../env.js"
-import { noop } from "../utils.js"
-import { depsRequireChange, sideEffectsEnabled, useHook } from "./utils.js"
+import { noop, sideEffectsEnabled } from "../utils/index.js"
+import { depsRequireChange, useHook } from "./utils.js"
 import type { AsyncTaskState } from "../types.utils.js"
 
 export type UseAsyncState<T> = AsyncTaskState<T, UseAsyncError> & {
@@ -48,7 +48,9 @@ export function useAsync<T>(
       deps,
       id: 0,
       task: null as any as InternalTaskState<T>,
-      load: noop as (func: (ctx: UseAsyncCallbackContext) => Promise<T>) => void,
+      load: noop as (
+        func: (ctx: UseAsyncCallbackContext) => Promise<T>
+      ) => void,
     },
     ({ hook, isInit, isHMR, update }) => {
       if (__DEV__) {

package/src/hooks/useCallback.ts

@@ -1,5 +1,6 @@
 import { __DEV__ } from "../env.js"
-import { depsRequireChange, useHook, sideEffectsEnabled } from "./utils.js"
+import { sideEffectsEnabled } from "../utils/index.js"
+import { depsRequireChange, useHook } from "./utils.js"
 
 /**
  * Creates a memoized callback function.

package/src/hooks/useEffect.ts

@@ -1,10 +1,6 @@
+import { sideEffectsEnabled } from "../utils/index.js"
 import { __DEV__ } from "../env.js"
-import {
-  cleanupHook,
-  depsRequireChange,
-  sideEffectsEnabled,
-  useHook,
-} from "./utils.js"
+import { cleanupHook, depsRequireChange, useHook } from "./utils.js"
 
 /**
  * Runs a function after the component is rendered, or when a value provided in the optional [dependency

package/src/hooks/useEffectEvent.ts

@@ -1,6 +1,7 @@
+import { sideEffectsEnabled } from "../utils/index.js"
 import { node } from "../globals.js"
 import { __DEV__ } from "../env.js"
-import { sideEffectsEnabled, useHook } from "./utils.js"
+import { useHook } from "./utils.js"
 
 /**
  * Wraps a function to be called within effects and other callbacks.

package/src/hooks/useLayoutEffect.ts

@@ -1,10 +1,6 @@
+import { sideEffectsEnabled } from "../utils/index.js"
 import { __DEV__ } from "../env.js"
-import {
-  cleanupHook,
-  depsRequireChange,
-  sideEffectsEnabled,
-  useHook,
-} from "./utils.js"
+import { cleanupHook, depsRequireChange, useHook } from "./utils.js"
 
 /**
  * Runs a function before the component is rendered, or when a value provided in the optional [dependency

package/src/hooks/useMemo.ts

@@ -1,5 +1,6 @@
+import { sideEffectsEnabled } from "../utils/index.js"
 import { __DEV__ } from "../env.js"
-import { depsRequireChange, sideEffectsEnabled, useHook } from "./utils.js"
+import { depsRequireChange, useHook } from "./utils.js"
 
 /**
  * Creates a memoized value that only changes when the [dependency

package/src/hooks/useReducer.ts

@@ -1,6 +1,6 @@
 import { __DEV__ } from "../env.js"
-import { noop } from "../utils.js"
-import { sideEffectsEnabled, useHook } from "./utils.js"
+import { noop, sideEffectsEnabled } from "../utils/index.js"
+import { useHook } from "./utils.js"
 
 /**
  * Creates 'dispatcher-driven' state.

package/src/hooks/useRef.ts

@@ -1,5 +1,6 @@
 import { __DEV__ } from "../env.js"
-import { sideEffectsEnabled, useHook } from "./utils.js"
+import { sideEffectsEnabled } from "../utils/index.js"
+import { useHook } from "./utils.js"
 
 /**
  * Creates a ref object. Useful for persisting values between renders or getting

package/src/hooks/useState.ts

@@ -1,6 +1,6 @@
 import { __DEV__ } from "../env.js"
-import { noop } from "../utils.js"
-import { sideEffectsEnabled, useHook } from "./utils.js"
+import { noop, sideEffectsEnabled } from "../utils/index.js"
+import { useHook } from "./utils.js"
 
 /**
  * Creates a stateful value, and returns the current value and a function to update it.

package/src/hooks/useSyncExternalStore.ts

@@ -1,7 +1,7 @@
 import { node } from "../globals.js"
 import { KiruError } from "../error.js"
-import { noop } from "../utils.js"
-import { sideEffectsEnabled, useHook } from "./utils.js"
+import { noop, sideEffectsEnabled } from "../utils/index.js"
+import { useHook } from "./utils.js"
 import { __DEV__ } from "../env.js"
 
 /**

package/src/hooks/useViewTransition.ts

@@ -1,7 +1,6 @@
 import { flushSync } from "../scheduler.js"
 import { node } from "../globals.js"
-import { noop } from "../utils.js"
-import { sideEffectsEnabled } from "./utils.js"
+import { noop, sideEffectsEnabled } from "../utils/index.js"
 
 /**
  * Allows you to easily use the [View Transition API](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition)

package/src/hooks/utils.ts

@@ -1,9 +1,8 @@
 import { KiruError } from "../error.js"
 import { __DEV__ } from "../env.js"
 import { hookIndex, node } from "../globals.js"
-import { noop } from "../utils.js"
+import { noop } from "../utils/index.js"
 import { requestUpdate } from "../scheduler.js"
-export { sideEffectsEnabled } from "../utils.js"
 export {
   cleanupHook,
   depsRequireChange,
@@ -158,6 +157,7 @@ function useHook<
         console.warn(
           `[kiru]: hooks must be called in the same order. Hook "${hookName}" was called in place of "${vNode.hookSig[index]}". Strange things may happen.`
         )
+        oldHook?.cleanup?.()
         vNode.hooks.length = index
         vNode.hookSig.length = index
         oldHook = undefined

package/src/index.ts

@@ -3,19 +3,17 @@ import { createKiruGlobalContext } from "./globalContext.js"
 
 export type * from "./types"
 export * from "./signals/index.js"
+export * from "./action.js"
 export * from "./appContext.js"
-export * from "./cloneVNode.js"
 export * from "./context.js"
 export * from "./customEvents.js"
 export * from "./element.js"
+export * from "./error.js"
 export * from "./hooks/index.js"
-export * from "./lazy.js"
-export { memo } from "./memo.js"
-export * from "./portal.js"
+export * from "./components/index.js"
 export * from "./renderToString.js"
 export { nextIdle, flushSync, requestUpdate } from "./scheduler.js"
 export * from "./store.js"
-export * from "./transition.js"
 
 if (__DEV__) {
   if ("window" in globalThis) {