@wular/pnext 0.0.4 → 0.0.6

package/src/compat/react/server.ts

@@ -1,7 +1,7 @@
-import ReactCompat from './preact';
-import { cache as serverCache } from '../../api/cache';
-import { currentPrerenderScope } from '../../ppr';
-import { currentCacheSignal } from '../../cache/context';
+import ReactCompat from './preact'
+import { cache as serverCache } from '../../api/cache'
+import { currentPrerenderScope } from '../../render/ppr'
+import { currentCacheSignal } from '../../request/cache'
 
 export {
   Children,
@@ -35,20 +35,20 @@ export {
   useActionState,
   useOptimistic,
   version,
-} from './preact';
-export { cache } from '../../api/cache';
-import { ViewTransition, addTransitionType } from './view-transition';
-export { ViewTransition, addTransitionType };
+} from './preact'
+export { cache } from '../../api/cache'
+import { ViewTransition, addTransitionType } from './view-transition'
+export { ViewTransition, addTransitionType }
 
-type EffectHook = typeof ReactCompat.useEffect;
-type StateSetter<State> = (value: State | ((previous: State) => State)) => void;
-type Reducer<Action> = (action: Action) => void;
+type EffectHook = typeof ReactCompat.useEffect
+type StateSetter<State> = (value: State | ((previous: State) => State)) => void
+type Reducer<Action> = (action: Action) => void
 
-const useEffect: EffectHook = () => undefined;
-const useLayoutEffect: EffectHook = () => undefined;
-const useInsertionEffect: EffectHook = () => undefined;
-const useDebugValue: typeof ReactCompat.useDebugValue = () => undefined;
-const useImperativeHandle: typeof ReactCompat.useImperativeHandle = () => undefined;
+const useEffect: EffectHook = () => undefined
+const useLayoutEffect: EffectHook = () => undefined
+const useInsertionEffect: EffectHook = () => undefined
+const useDebugValue: typeof ReactCompat.useDebugValue = () => undefined
+const useImperativeHandle: typeof ReactCompat.useImperativeHandle = () => undefined
 
 function useState<State = undefined>(
   initialState?: State | (() => State),
@@ -56,7 +56,7 @@ function useState<State = undefined>(
   return [
     typeof initialState === 'function' ? (initialState as () => State)() : initialState,
     () => undefined,
-  ];
+  ]
 }
 
 function useReducer<State, Action>(
@@ -64,29 +64,29 @@ function useReducer<State, Action>(
   initialArg: State,
   init?: (value: State) => State,
 ): [State, Reducer<Action>] {
-  void reducer;
-  return [init ? init(initialArg) : initialArg, () => undefined];
+  void reducer
+  return [init ? init(initialArg) : initialArg, () => undefined]
 }
 
 function useRef<Value = undefined>(initialValue?: Value): { current: Value | undefined } {
-  return { current: initialValue };
+  return { current: initialValue }
 }
 
 function useMemo<Value>(factory: () => Value): Value {
-  return factory();
+  return factory()
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- must mirror preact's `<T extends Function>` useCallback signature
 function useCallback<Callback extends Function>(callback: Callback): Callback {
-  return callback;
+  return callback
 }
 
 function useDeferredValue<Value>(value: Value): Value {
-  return value;
+  return value
 }
 
 function useTransition(): [false, (callback: () => void) => void] {
-  return [false, callback => callback()];
+  return [false, callback => callback()]
 }
 
 function useSyncExternalStore<Snapshot>(
@@ -94,13 +94,11 @@ function useSyncExternalStore<Snapshot>(
   getSnapshot: () => Snapshot,
   getServerSnapshot?: () => Snapshot,
 ): Snapshot {
-  return getServerSnapshot ? getServerSnapshot() : getSnapshot();
+  return getServerSnapshot ? getServerSnapshot() : getSnapshot()
 }
 
-function useContext<Value>(
-  context: Parameters<typeof ReactCompat.useContext<Value>>[0],
-): Value {
-  return ReactCompat.useContext(context);
+function useContext<Value>(context: Parameters<typeof ReactCompat.useContext<Value>>[0]): Value {
+  return ReactCompat.useContext(context)
 }
 
 // Re-export the server stubs as named exports too. Client-component libraries
@@ -123,34 +121,34 @@ export {
   useTransition,
   useSyncExternalStore,
   useContext,
-};
+}
 
 export function cacheSignal(): AbortSignal | null {
-  const prerender = currentPrerenderScope();
-  if (prerender) return prerender.signal;
-  return currentCacheSignal();
+  const prerender = currentPrerenderScope()
+  if (prerender) return prerender.signal
+  return currentCacheSignal()
 }
 
 const ReactServer = { ...ReactCompat } as typeof ReactCompat & {
-  cache: typeof serverCache;
-  cacheSignal: typeof cacheSignal;
-};
-delete (ReactServer as { useState?: unknown }).useState;
-ReactServer.cache = serverCache;
-ReactServer.cacheSignal = cacheSignal;
-ReactServer.useEffect = useEffect;
-ReactServer.useLayoutEffect = useLayoutEffect;
-ReactServer.useInsertionEffect = useInsertionEffect;
-ReactServer.useDebugValue = useDebugValue;
-ReactServer.useImperativeHandle = useImperativeHandle;
-ReactServer.useReducer = useReducer;
-ReactServer.useRef = useRef;
-ReactServer.useMemo = useMemo;
-ReactServer.useCallback = useCallback;
-ReactServer.useDeferredValue = useDeferredValue;
-ReactServer.useTransition = useTransition;
-ReactServer.useSyncExternalStore = useSyncExternalStore;
-ReactServer.useContext = useContext as typeof ReactCompat.useContext;
-Object.assign(ReactServer, { ViewTransition, addTransitionType });
-
-export default ReactServer;
+  cache: typeof serverCache
+  cacheSignal: typeof cacheSignal
+}
+delete (ReactServer as { useState?: unknown }).useState
+ReactServer.cache = serverCache
+ReactServer.cacheSignal = cacheSignal
+ReactServer.useEffect = useEffect
+ReactServer.useLayoutEffect = useLayoutEffect
+ReactServer.useInsertionEffect = useInsertionEffect
+ReactServer.useDebugValue = useDebugValue
+ReactServer.useImperativeHandle = useImperativeHandle
+ReactServer.useReducer = useReducer
+ReactServer.useRef = useRef
+ReactServer.useMemo = useMemo
+ReactServer.useCallback = useCallback
+ReactServer.useDeferredValue = useDeferredValue
+ReactServer.useTransition = useTransition
+ReactServer.useSyncExternalStore = useSyncExternalStore
+ReactServer.useContext = useContext as typeof ReactCompat.useContext
+Object.assign(ReactServer, { ViewTransition, addTransitionType })
+
+export default ReactServer

package/src/compat/react/use.ts

@@ -1,72 +1,72 @@
-import { useContext } from 'preact/hooks';
-import type { Context } from 'preact';
+import { useContext } from 'preact/hooks'
+import type { Context } from 'preact'
 
 interface TrackedThenable<T> extends PromiseLike<T> {
-  status?: 'pending' | 'fulfilled' | 'rejected';
-  value?: T;
-  reason?: unknown;
+  status?: 'pending' | 'fulfilled' | 'rejected'
+  value?: T
+  reason?: unknown
 }
 
 // Replay state for use() in server components: the renderer replays a component
 // after a thrown thenable settles, and use() call N must resolve to the thenable
 // recorded on the previous attempt (the rerun creates a fresh promise).
 export interface UseThenableState {
-  thenables: TrackedThenable<unknown>[];
+  thenables: TrackedThenable<unknown>[]
 }
 
 // globalThis-anchored: the prebundled server entry inlines its own copy of this module;
 // a replay in one copy must be visible to use() in the other or retries loop forever.
 interface UseReplayState {
-  active: UseThenableState | null;
-  index: number;
+  active: UseThenableState | null
+  index: number
 }
-const REPLAY_STATE_KEY = Symbol.for('pnext.useReplayState');
+const REPLAY_STATE_KEY = Symbol.for('pnext.useReplayState')
 const replayState = ((globalThis as Record<PropertyKey, unknown>)[REPLAY_STATE_KEY] ??= {
   active: null,
   index: 0,
-}) as UseReplayState;
+}) as UseReplayState
 
 export function withUseThenableState<T>(state: UseThenableState, run: () => T): T {
-  const previousState = replayState.active;
-  const previousIndex = replayState.index;
-  replayState.active = state;
-  replayState.index = 0;
+  const previousState = replayState.active
+  const previousIndex = replayState.index
+  replayState.active = state
+  replayState.index = 0
   try {
-    return run();
+    return run()
   } finally {
-    replayState.active = previousState;
-    replayState.index = previousIndex;
+    replayState.active = previousState
+    replayState.index = previousIndex
   }
 }
 
 // React 19's use(): unwrap a thenable via suspense, or read a context.
 export function use<T>(usable: PromiseLike<T> | Context<T>): T {
   if (usable && typeof (usable as PromiseLike<T>).then === 'function') {
-    let thenable = usable as TrackedThenable<T>;
+    let thenable = usable as TrackedThenable<T>
     if (replayState.active) {
-      const index = replayState.index++;
-      const existing = replayState.active.thenables[index];
-      if (existing) thenable = existing as TrackedThenable<T>;
-      else replayState.active.thenables[index] = thenable;
+      const index = replayState.index++
+      const existing = replayState.active.thenables[index]
+      if (existing) thenable = existing as TrackedThenable<T>
+      else replayState.active.thenables[index] = thenable
     }
-    if (thenable.status === 'fulfilled') return thenable.value as T;
-    if (thenable.status === 'rejected') throw thenable.reason;
+    if (thenable.status === 'fulfilled') return thenable.value as T
+    if (thenable.status === 'rejected') throw thenable.reason
     if (thenable.status !== 'pending') {
-      thenable.status = 'pending';
+      thenable.status = 'pending'
       thenable.then(
         value => {
-          thenable.status = 'fulfilled';
-          thenable.value = value;
+          thenable.status = 'fulfilled'
+          thenable.value = value
         },
         reason => {
-          thenable.status = 'rejected';
-          thenable.reason = reason;
+          thenable.status = 'rejected'
+          thenable.reason = reason
         },
-      );
+      )
     }
     // React use() protocol: suspend by throwing the thenable itself.
     // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw thenable;
+    throw thenable
   }
-  return useContext(usable as Context<T>);
+  return useContext(usable as Context<T>)
 }

package/src/compat/react/view-transition.ts

@@ -9,52 +9,52 @@
 // `document.startViewTransition`, so this shim keeps the same DOM shape (pure passthrough) and records
 // the declared names/types; the router applies the actual transition when the browser supports it.
 
-import { Fragment, h, type ComponentChildren, type VNode } from 'preact';
+import { Fragment, h, type ComponentChildren, type VNode } from 'preact'
 
 /**
  * The class/name a ViewTransition applies for a given trigger. React accepts a
  * string (a single view-transition-class) or a record keyed by transition type.
  */
-export type ViewTransitionClass = string | Record<string, string>;
+export type ViewTransitionClass = string | Record<string, string>
 
 export interface ViewTransitionProps {
   /** view-transition-name for the child; 'auto' lets React derive one. */
-  name?: string;
+  name?: string
   /** Fallback class applied when no more specific trigger prop matches. */
-  default?: ViewTransitionClass;
-  enter?: ViewTransitionClass;
-  exit?: ViewTransitionClass;
-  update?: ViewTransitionClass;
-  share?: ViewTransitionClass;
-  onEnter?: (element: Element, types: string[]) => void;
-  onExit?: (element: Element, types: string[]) => void;
-  onUpdate?: (element: Element, types: string[]) => void;
-  onShare?: (element: Element, types: string[]) => void;
-  ref?: unknown;
-  children?: ComponentChildren;
+  default?: ViewTransitionClass
+  enter?: ViewTransitionClass
+  exit?: ViewTransitionClass
+  update?: ViewTransitionClass
+  share?: ViewTransitionClass
+  onEnter?: (element: Element, types: string[]) => void
+  onExit?: (element: Element, types: string[]) => void
+  onUpdate?: (element: Element, types: string[]) => void
+  onShare?: (element: Element, types: string[]) => void
+  ref?: unknown
+  children?: ComponentChildren
 }
 
 export function ViewTransition({ children }: ViewTransitionProps): VNode {
   // Pure passthrough: React's ViewTransition adds no element to the tree, and
   // any wrapper here would change every consuming app's DOM/CSS selectors.
-  return h(Fragment, null, children);
+  return h(Fragment, null, children)
 }
-ViewTransition.displayName = 'ViewTransition';
+ViewTransition.displayName = 'ViewTransition'
 
 // Transition types declared during the current update (React clears them once
 // the transition commits). `startViewTransition({ types })` consumes them.
-const pendingTransitionTypes: string[] = [];
+const pendingTransitionTypes: string[] = []
 
 /**
  * Declare a view-transition type for the in-flight transition, so
  * `:active-view-transition-type(...)` CSS rules match while it runs.
  */
 export function addTransitionType(type: string): void {
-  if (typeof type !== 'string' || pendingTransitionTypes.includes(type)) return;
-  pendingTransitionTypes.push(type);
+  if (typeof type !== 'string' || pendingTransitionTypes.includes(type)) return
+  pendingTransitionTypes.push(type)
 }
 
 /** Drain the declared types (the navigation that starts the transition owns them). */
 export function takeTransitionTypes(): string[] {
-  return pendingTransitionTypes.splice(0, pendingTransitionTypes.length);
+  return pendingTransitionTypes.splice(0, pendingTransitionTypes.length)
 }