kiru 0.52.3 → 0.53.0

package/src/element.ts

@@ -1,46 +1,29 @@
-import { $FRAGMENT, $MEMO, FLAG_MEMO } from "./constants.js"
-import { isMemoFn } from "./components/memo.js"
-import { isValidElementKeyProp, isValidElementRefProp } from "./utils/index.js"
+import { $FRAGMENT } from "./constants.js"
+import { normalizeElementKey } from "./utils/index.js"
 
 export function createElement<T extends Kiru.VNode["type"]>(
   type: T,
   props: null | Record<string, unknown> = null,
   ...children: unknown[]
-): Kiru.VNode {
-  if ((type as any) === Fragment) {
-    return Fragment({ children: children as any, ...props })
-  }
-  const node: Kiru.VNode = {
-    type,
-    flags: 0,
-    index: 0,
-    depth: 0,
-    props: {},
-    parent: null,
-    sibling: null,
-    child: null,
-    prev: null,
-    deletions: null,
-  }
-  if (isMemoFn(type)) {
-    node.flags |= FLAG_MEMO
-    node.arePropsEqual = type[$MEMO].arePropsEqual
+): Kiru.Element {
+  if ((type as unknown) === Fragment) {
+    type = $FRAGMENT as T
   }
+  const p = props === null ? {} : props
+  const key = normalizeElementKey(p.key)
 
-  if (props !== null) {
-    const { key, ref, ...rest } = props
-    if (isValidElementKeyProp(key)) node.props.key = key.toString()
-    if (isValidElementRefProp(ref)) node.props.ref = ref
-    Object.assign(node.props, rest)
+  const len = children.length
+  if (len === 1) {
+    p.children = children[0]
+  } else if (len > 1) {
+    p.children = children
   }
 
-  const _children =
-    children.length === 1 ? children[0] : children.length > 1 ? children : null
-  if (_children !== null) {
-    node.props.children = _children
+  return {
+    type,
+    key,
+    props: p,
   }
-
-  return node
 }
 
 export function Fragment({
@@ -49,6 +32,10 @@ export function Fragment({
 }: {
   children: JSX.Children
   key?: JSX.ElementKey
-}): Kiru.VNode {
-  return createElement($FRAGMENT, key ? { key } : null, children)
+}): Kiru.Element {
+  return {
+    type: $FRAGMENT,
+    key: normalizeElementKey(key),
+    props: { children },
+  }
 }

package/src/globalContext.ts

@@ -6,6 +6,7 @@ import type { FileRouterController } from "./router/fileRouterController"
 import type { AppContext } from "./appContext"
 import type { Store } from "./store"
 import type { SWRCache } from "./swr"
+import type { requestUpdate } from "./index.js"
 
 export { createKiruGlobalContext, type GlobalKiruEvent, type KiruGlobalContext }
 
@@ -56,7 +57,7 @@ function createReactiveMap<V>(): ReactiveMap<V> {
 type Evt =
   | {
       name: "mount"
-      data?: undefined
+      data?: typeof requestUpdate
     }
   | {
       name: "unmount"
@@ -73,6 +74,10 @@ type Evt =
 
 type GlobalKiruEvent = Evt["name"]
 
+interface SchedulerInterface {
+  requestUpdate: (vNode: Kiru.VNode) => void
+}
+
 interface KiruGlobalContext {
   readonly apps: AppContext[]
   emit<T extends Evt>(event: T["name"], ctx: AppContext, data?: T["data"]): void
@@ -91,10 +96,15 @@ interface KiruGlobalContext {
   fileRouterInstance?: {
     current: FileRouterController | null
   }
+  getSchedulerInterface?: (app: AppContext) => SchedulerInterface | null
 }
 
 function createKiruGlobalContext(): KiruGlobalContext {
   const contexts = new Set<AppContext>()
+  const contextToSchedulerInterface = new WeakMap<
+    AppContext,
+    SchedulerInterface
+  >()
   const listeners = new Map<
     GlobalKiruEvent,
     Set<(ctx: AppContext, data?: Evt["data"]) => void>
@@ -134,14 +144,25 @@ function createKiruGlobalContext(): KiruGlobalContext {
   }
 
   // Initialize event listeners
-  on("mount", (ctx) => contexts.add(ctx))
-  on("unmount", (ctx) => contexts.delete(ctx))
+  on("mount", (ctx, requestUpdate) => {
+    contexts.add(ctx)
+    if (requestUpdate && typeof requestUpdate === "function") {
+      contextToSchedulerInterface.set(ctx, { requestUpdate })
+    }
+  })
+  on("unmount", (ctx) => {
+    contexts.delete(ctx)
+    contextToSchedulerInterface.delete(ctx)
+  })
 
   if (__DEV__) {
     globalContext.HMRContext = createHMRContext()
     globalContext.profilingContext = createProfilingContext()
     globalContext.stores = createReactiveMap()
     globalContext.fileRouterInstance = fileRouterInstance
+    globalContext.getSchedulerInterface = (app) => {
+      return contextToSchedulerInterface.get(app) ?? null
+    }
   }
 
   return globalContext

package/src/hooks/usePromise.ts

@@ -1,43 +1,36 @@
-import { PREFETCHED_DATA_EVENT } from "../constants.js"
+import { STREAMED_DATA_EVENT } from "../constants.js"
 import { __DEV__ } from "../env.js"
 import { hydrationMode, renderMode } from "../globals.js"
-import { requestUpdate } from "../scheduler.js"
 import { Signal, useSignal } from "../signals/base.js"
 import { cleanupHook, depsRequireChange, useHook } from "./utils.js"
 import { useId } from "./useId.js"
 
 export { usePromise }
-export type { UsePromiseCallbackContext, UsePromiseState }
 
 const nodeToPromiseIndex = new WeakMap<Kiru.VNode, number>()
 
-interface UsePromiseCallbackContext {
-  signal: AbortSignal
-}
-
-interface UsePromiseState<T> {
-  data: Kiru.StatefulPromise<T>
+type UsePromiseResult<T> = Kiru.StatefulPromise<T> & {
   refresh: () => void
-  pending: Signal<boolean>
+  isPending: Signal<boolean>
 }
 
 function usePromise<T>(
-  callback: (ctx: UsePromiseCallbackContext) => Promise<T>,
+  callback: (signal: AbortSignal) => Promise<T>,
   deps: unknown[]
-): UsePromiseState<T> {
+): UsePromiseResult<T> {
   const id = useId()
-  const pending = useSignal(true)
+  const isPending = useSignal(true)
 
   return useHook(
     "usePromise",
     {} as {
-      promise: Kiru.StatefulPromise<T>
+      promise: UsePromiseResult<T>
       abortController?: AbortController
       deps?: unknown[]
     },
-    ({ hook, isInit, vNode }) => {
+    ({ hook, isInit, vNode, update }) => {
       if (isInit || depsRequireChange(deps, hook.deps)) {
-        pending.value = true
+        isPending.value = true
         hook.deps = deps
         cleanupHook(hook)
 
@@ -59,77 +52,75 @@ function usePromise<T>(
         ) {
           // if we're hydrating and the hydration mode is not static,
           // we need to resolve the promise from cache/event
-          promise = resolvePrefetchedPromise<T>(promiseId, controller.signal)
+          promise = resolveDeferredPromise<T>(promiseId, controller.signal)
         } else {
           // dom / stream / (hydrate + static)
-          promise = callback({ signal: controller.signal })
+          promise = callback(controller.signal)
         }
 
         const state: Kiru.PromiseState<T> = { id: promiseId, state: "pending" }
-        const statefulPromise = (hook.promise = Object.assign(promise, state))
+        const statefulPromise: Kiru.StatefulPromise<T> = (hook.promise =
+          Object.assign(promise, state, {
+            isPending,
+            refresh: () => {
+              hook.deps = undefined
+              update()
+            },
+          }))
 
         statefulPromise
           .then((value) => {
             statefulPromise.state = "fulfilled"
             statefulPromise.value = value
+            isPending.value = false
           })
           .catch((error) => {
             statefulPromise.state = "rejected"
             statefulPromise.error =
               error instanceof Error ? error : new Error(error)
           })
-          .finally(() => {
-            pending.value = false
-          })
-      }
-      return {
-        data: hook.promise,
-        refresh: () => {
-          hook.deps = undefined
-          requestUpdate(vNode)
-        },
-        pending,
       }
+      return hook.promise
     }
   )
 }
 
-interface PrefetchedPromiseEventDetail<T> {
+interface DeferredPromiseEventDetail<T> {
   id: string
   data?: T
   error?: string
 }
 
-function resolvePrefetchedPromise<T>(
+function resolveDeferredPromise<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 deferralCache: Map<string, { data?: T; error?: string }> = // @ts-ignore
+      (window[STREAMED_DATA_EVENT] ??= new Map())
 
-    const existing = prefetchCache.get(id)
+    const existing = deferralCache.get(id)
     if (existing) {
       const { data, error } = existing
-      prefetchCache.delete(id)
+      deferralCache.delete(id)
       if (error) return reject(error)
       return resolve(data!)
     }
 
     const onDataEvent = (event: Event) => {
-      const { detail } = event as CustomEvent<PrefetchedPromiseEventDetail<T>>
+      const { detail } = event as CustomEvent<DeferredPromiseEventDetail<T>>
       if (detail.id === id) {
-        prefetchCache.delete(id)
-        window.removeEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+        deferralCache.delete(id)
+        window.removeEventListener(STREAMED_DATA_EVENT, onDataEvent)
         const { data, error } = detail
         if (error) return reject(error)
         resolve(data!)
       }
     }
 
-    window.addEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+    window.addEventListener(STREAMED_DATA_EVENT, onDataEvent)
     signal.addEventListener("abort", () => {
-      window.removeEventListener(PREFETCHED_DATA_EVENT, onDataEvent)
+      window.removeEventListener(STREAMED_DATA_EVENT, onDataEvent)
       reject()
     })
   })

package/src/hooks/useRef.ts

@@ -8,9 +8,9 @@ import { useHook } from "./utils.js"
  *
  * @see https://kirujs.dev/docs/hooks/useRef
  */
-export function useRef<T>(initialValue: T): Kiru.MutableRefObject<T>
+export function useRef<T>(initialValue: T): Kiru.RefObject<T>
 export function useRef<T>(initialValue: T | null): Kiru.RefObject<T>
-export function useRef<T = undefined>(): Kiru.MutableRefObject<T | undefined>
+export function useRef<T = undefined>(): Kiru.RefObject<T | undefined>
 export function useRef<T>(initialValue?: T | null) {
   if (!sideEffectsEnabled()) return { current: initialValue }
   return useHook(