@wular/pnext 0.0.4 → 0.0.6

package/src/request/context.ts

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks'
 import {
   cacheComponents,
   hangingPromise,
@@ -6,8 +6,8 @@ import {
   isRuntimePrefetchPrerender,
   markRuntimeApiOnAwait,
   PostponeError,
-} from '../ppr';
-import type { NextRequest, RouteParamValue } from '../types';
+} from '../render/ppr'
+import type { NextRequest, RouteParamValue } from '../types'
 
 // Request work-unit store (CORE seam for compat after()/onRequestError).
 //
@@ -21,56 +21,56 @@ import type { NextRequest, RouteParamValue } from '../types';
 // proxying on top of these accessors. Core only owns the store and the flush.
 
 /** The lifecycle phase the request is currently executing in. */
-export type WorkUnitPhase = 'render' | 'action' | 'handler' | 'middleware' | 'after';
+export type WorkUnitPhase = 'render' | 'action' | 'handler' | 'middleware' | 'after'
 
 /** How the matched route is being served — set by the responding call site. */
-export type WorkUnitRouteKind = 'html' | 'data' | 'static-asset' | 'route-handler';
+export type WorkUnitRouteKind = 'html' | 'data' | 'static-asset' | 'route-handler'
 
 /** Per-request work unit carrying phase + the after-task queue. */
 export interface WorkUnit {
-  phase: WorkUnitPhase;
+  phase: WorkUnitPhase
   /** Tasks queued via queueAfterTask, drained once on response close. */
-  afterTasks: (() => unknown)[];
+  afterTasks: (() => unknown)[]
   /** Guard so the after-queue flushes exactly once across all close paths. */
-  flushed: boolean;
+  flushed: boolean
   /** How the response is being produced (set by the responding call site). */
-  routeKind?: WorkUnitRouteKind;
+  routeKind?: WorkUnitRouteKind
   /** Caching disposition of the matched route, when known. */
-  routeMode?: 'static' | 'isr' | 'dynamic';
+  routeMode?: 'static' | 'isr' | 'dynamic'
   /** Opaque hints for response finalizers. */
-  responseHints?: Record<string, unknown>;
+  responseHints?: Record<string, unknown>
   /**
    * Opaque compat scratch space keyed by well-known symbols (testmode proxy
    * info, onRequestError dedupe flag). Core never reads these; it only carries
    * the store across the request lifecycle. Kept off the typed surface so core
    * grows no dependency on compat.
    */
-  compat?: Record<symbol, unknown>;
+  compat?: Record<symbol, unknown>
 }
 
 // Anchored on globalThis (like requestStorage below) so compiled compat
 // bundles that inline their own copy of this module still observe the same
 // per-request work unit — canonical-URL recording happens in core while its
 // readers (pages-router SSR state, navigation hooks) run from built bundles.
-const WORK_UNIT_STORAGE = Symbol.for('pnext.workUnitStorage');
+const WORK_UNIT_STORAGE = Symbol.for('pnext.workUnitStorage')
 const workUnitStorage = ((globalThis as Record<PropertyKey, unknown>)[WORK_UNIT_STORAGE] ??=
-  new AsyncLocalStorage<WorkUnit>()) as AsyncLocalStorage<WorkUnit>;
+  new AsyncLocalStorage<WorkUnit>()) as AsyncLocalStorage<WorkUnit>
 
 /** Run `callback` inside a fresh request work unit (start/dev per-request scope). */
 export function runWithWorkUnit<T>(phase: WorkUnitPhase, callback: () => T): T {
-  const unit: WorkUnit = { phase, afterTasks: [], flushed: false };
-  return workUnitStorage.run(unit, callback);
+  const unit: WorkUnit = { phase, afterTasks: [], flushed: false }
+  return workUnitStorage.run(unit, callback)
 }
 
 /** The active request work unit, or undefined outside a request scope. */
 export function getWorkUnit(): WorkUnit | undefined {
-  return workUnitStorage.getStore();
+  return workUnitStorage.getStore()
 }
 
 /** Set the current work-unit phase (compat toggles render/action/handler/...). */
 export function setPhase(phase: WorkUnitPhase): void {
-  const unit = workUnitStorage.getStore();
-  if (unit) unit.phase = phase;
+  const unit = workUnitStorage.getStore()
+  if (unit) unit.phase = phase
 }
 
 /** Record how the current request is being served (drives finalizers + funnel). */
@@ -79,11 +79,11 @@ export function setWorkUnitRoute(
   routeMode?: WorkUnit['routeMode'],
   responseHints?: Record<string, unknown>,
 ): void {
-  const unit = workUnitStorage.getStore();
-  if (!unit) return;
-  unit.routeKind = routeKind;
-  if (routeMode) unit.routeMode = routeMode;
-  if (responseHints) unit.responseHints = responseHints;
+  const unit = workUnitStorage.getStore()
+  if (!unit) return
+  unit.routeKind = routeKind
+  if (routeMode) unit.routeMode = routeMode
+  if (responseHints) unit.responseHints = responseHints
 }
 
 /**
@@ -91,10 +91,10 @@ export function setWorkUnitRoute(
  * work unit is active. Compat's after() delegates here; core never enqueues.
  */
 export function queueAfterTask(task: () => unknown): boolean {
-  const unit = workUnitStorage.getStore();
-  if (!unit) return false;
-  unit.afterTasks.push(task);
-  return true;
+  const unit = workUnitStorage.getStore()
+  if (!unit) return false
+  unit.afterTasks.push(task)
+  return true
 }
 
 /**
@@ -104,9 +104,9 @@ export function queueAfterTask(task: () => unknown): boolean {
  * multiple close paths (stream end / redirect / abort / error).
  */
 export function flushWorkUnit(unit: WorkUnit | undefined = workUnitStorage.getStore()): void {
-  if (!unit || unit.flushed) return;
-  unit.flushed = true;
-  if (unit.afterTasks.length === 0) return;
+  if (!unit || unit.flushed) return
+  unit.flushed = true
+  if (unit.afterTasks.length === 0) return
   // Drain under a SHALLOW COPY carrying `phase: 'after'` rather than mutating
   // the shared unit. The flush is detached and async, so setting `phase` on the
   // unit itself leaked: every later render seen under that unit (the build/PPR
@@ -115,36 +115,36 @@ export function flushWorkUnit(unit: WorkUnit | undefined = workUnitStorage.getSt
   // after()". Every other field stays shared by reference; only the phase and
   // the queue diverge, and nested after() enqueues onto the copy's queue via
   // the store, which is exactly what this loop drains.
-  const afterUnit: WorkUnit = { ...unit, phase: 'after' };
+  const afterUnit: WorkUnit = { ...unit, phase: 'after' }
   const flushing = workUnitStorage.run(afterUnit, async () => {
     while (afterUnit.afterTasks.length) {
-      const tasks = afterUnit.afterTasks;
-      afterUnit.afterTasks = [];
+      const tasks = afterUnit.afterTasks
+      afterUnit.afterTasks = []
       for (const task of tasks) {
         try {
-          await task();
+          await task()
         } catch (error) {
-          console.error('after() task failed:', error);
+          console.error('after() task failed:', error)
         }
       }
     }
-  });
-  pendingFlushes.add(flushing);
-  void flushing.finally(() => pendingFlushes.delete(flushing));
+  })
+  pendingFlushes.add(flushing)
+  void flushing.finally(() => pendingFlushes.delete(flushing))
 }
 
-const pendingFlushes = new Set<Promise<void>>();
+const pendingFlushes = new Set<Promise<void>>()
 
 /**
  * Await all in-flight after-queue flushes (graceful shutdown). Bounded by
  * timeoutMs so a hung after() task can't block process exit.
  */
 export async function drainWorkUnits(timeoutMs = 10_000): Promise<void> {
-  if (pendingFlushes.size === 0) return;
+  if (pendingFlushes.size === 0) return
   await Promise.race([
     Promise.allSettled([...pendingFlushes]),
     new Promise(resolve => setTimeout(resolve, timeoutMs)),
-  ]);
+  ])
 }
 
 /**
@@ -158,52 +158,52 @@ export function flushWorkUnitOnClose(
   unit: WorkUnit | undefined,
   signal?: AbortSignal,
 ): Response {
-  if (!unit) return response;
-  if (signal) signal.addEventListener('abort', () => flushWorkUnit(unit), { once: true });
+  if (!unit) return response
+  if (signal) signal.addEventListener('abort', () => flushWorkUnit(unit), { once: true })
   if (!response.body) {
-    flushWorkUnit(unit);
-    return response;
+    flushWorkUnit(unit)
+    return response
   }
   // An explicit Content-Length means the body is fully buffered upstream (image
   // optimizer, static files) — nothing can enqueue after-tasks while it drains.
   // Re-wrapping it in a close-observing stream would switch the transfer to
   // chunked and drop the Content-Length header; flush immediately instead.
   if (response.headers.has('content-length')) {
-    flushWorkUnit(unit);
-    return response;
+    flushWorkUnit(unit)
+    return response
   }
   const observed = response.body.pipeThrough(
     new TransformStream({
       transform(chunk, controller) {
-        controller.enqueue(chunk);
+        controller.enqueue(chunk)
       },
       flush() {
-        flushWorkUnit(unit);
+        flushWorkUnit(unit)
       },
     }),
-  );
+  )
   return new Response(observed, {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers,
-  });
+  })
 }
 
 interface RequestScope {
-  request: NextRequest;
-  params: Record<string, RouteParamValue>;
+  request: NextRequest
+  params: Record<string, RouteParamValue>
   /** Work registered via after() from 'next/server', flushed once the request callback settles. */
-  afterCallbacks?: (() => unknown)[];
+  afterCallbacks?: (() => unknown)[]
   /** Optional response-headers channel render/handler paths may provide (e.g. draftMode set-cookie). */
-  responseHeaders?: Headers;
+  responseHeaders?: Headers
 }
 
-const REQUEST_STORAGE = Symbol.for('pnext.requestStorage');
+const REQUEST_STORAGE = Symbol.for('pnext.requestStorage')
 const requestStorage = ((globalThis as Record<PropertyKey, unknown>)[REQUEST_STORAGE] ??=
-  new AsyncLocalStorage<RequestScope>()) as AsyncLocalStorage<RequestScope>;
+  new AsyncLocalStorage<RequestScope>()) as AsyncLocalStorage<RequestScope>
 
 export function currentRequest() {
-  return requestStorage.getStore()?.request;
+  return requestStorage.getStore()?.request
 }
 
 // Work-unit store bridge for the deep-internal shim
@@ -217,29 +217,29 @@ export function currentRequest() {
 // The store is NEVER undefined: callers do `getStore().type` during build prerenders as well as live
 // requests. `prerender-runtime` mirrors Next's runtime-prefetch work unit; `prerender` covers any other
 // prerender scope, including the fallback when no request scope exists.
-const WORK_UNIT_EXTERNAL = Symbol.for('pnext.workUnitExternal');
+const WORK_UNIT_EXTERNAL = Symbol.for('pnext.workUnitExternal')
 
 interface WorkUnitExternalStore {
-  type: 'request' | 'prerender' | 'prerender-runtime';
-  cookies: unknown;
-  headers: Headers;
+  type: 'request' | 'prerender' | 'prerender-runtime'
+  cookies: unknown
+  headers: Headers
 }
 
 function workUnitExternalStore(): WorkUnitExternalStore {
-  const request = currentRequest();
+  const request = currentRequest()
   const type = isRuntimePrefetchPrerender()
     ? 'prerender-runtime'
     : isPrerendering() || !request
       ? 'prerender'
-      : 'request';
+      : 'request'
   return {
     type,
     cookies: request?.cookies,
     headers: request?.headers ?? new Headers(),
-  };
+  }
 }
 
-(globalThis as Record<PropertyKey, unknown>)[WORK_UNIT_EXTERNAL] = workUnitExternalStore;
+;(globalThis as Record<PropertyKey, unknown>)[WORK_UNIT_EXTERNAL] = workUnitExternalStore
 
 /**
  * Capture the current request scope (if any) and return a wrapper that re-runs a function inside it.
@@ -249,13 +249,13 @@ function workUnitExternalStore(): WorkUnitExternalStore {
  * throws - matching Next's phase semantics.
  */
 export function captureRequestScope(): <T>(fn: () => T) => T {
-  const scope = requestStorage.getStore();
-  if (!scope) return fn => fn();
-  return fn => requestStorage.run(scope, fn);
+  const scope = requestStorage.getStore()
+  if (!scope) return fn => fn()
+  return fn => requestStorage.run(scope, fn)
 }
 
 export function currentParams() {
-  return requestStorage.getStore()?.params ?? {};
+  return requestStorage.getStore()?.params ?? {}
 }
 
 export function runWithRequest<T>(
@@ -264,28 +264,28 @@ export function runWithRequest<T>(
   params: Record<string, RouteParamValue> = {},
   extras: { responseHeaders?: Headers } = {},
 ): T {
-  if (!request) return callback();
+  if (!request) return callback()
   const scope: RequestScope = {
     request,
     params,
     afterCallbacks: [],
     responseHeaders: extras.responseHeaders,
-  };
-  const result = requestStorage.run(scope, callback);
+  }
+  const result = requestStorage.run(scope, callback)
   if (isThenable(result)) {
     return (result as PromiseLike<unknown>).then(
       value => {
-        void flushAfterCallbacks(scope);
-        return value;
+        void flushAfterCallbacks(scope)
+        return value
       },
       error => {
-        void flushAfterCallbacks(scope);
-        throw error;
+        void flushAfterCallbacks(scope)
+        throw error
       },
-    ) as T;
+    ) as T
   }
-  void flushAfterCallbacks(scope);
-  return result;
+  void flushAfterCallbacks(scope)
+  return result
 }
 
 /**
@@ -293,33 +293,33 @@ export function runWithRequest<T>(
  * settles. Returns false when no request scope is active.
  */
 export function registerAfterCallback(callback: () => unknown): boolean {
-  const scope = requestStorage.getStore();
-  if (!scope) return false;
-  (scope.afterCallbacks ??= []).push(callback);
-  return true;
+  const scope = requestStorage.getStore()
+  if (!scope) return false
+  ;(scope.afterCallbacks ??= []).push(callback)
+  return true
 }
 
 /** Response-headers channel for the active request scope, when a caller provided one. */
 export function currentResponseHeaders(): Headers | undefined {
-  return requestStorage.getStore()?.responseHeaders;
+  return requestStorage.getStore()?.responseHeaders
 }
 
 async function flushAfterCallbacks(scope: RequestScope) {
   while (scope.afterCallbacks?.length) {
-    const callbacks = scope.afterCallbacks;
-    scope.afterCallbacks = [];
+    const callbacks = scope.afterCallbacks
+    scope.afterCallbacks = []
     for (const callback of callbacks) {
       try {
-        await requestStorage.run(scope, callback);
+        await requestStorage.run(scope, callback)
       } catch (error) {
-        console.error('after() callback failed:', error);
+        console.error('after() callback failed:', error)
       }
     }
   }
 }
 
 function isThenable(value: unknown): value is PromiseLike<unknown> {
-  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function';
+  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function'
 }
 
 /**
@@ -331,39 +331,39 @@ function isThenable(value: unknown): value is PromiseLike<unknown> {
  * the same flag, and module-level rather than ALS-scoped because the calls it
  * looks for run outside the render's async context by definition.
  */
-const BAILOUT_PROBE = Symbol.for('pnext.dynamicBailoutProbe');
+const BAILOUT_PROBE = Symbol.for('pnext.dynamicBailoutProbe')
 
 export function beginDynamicBailoutProbe(route: string): void {
-  (globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE] = route;
+  ;(globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE] = route
 }
 
 export function endDynamicBailoutProbe(): void {
-  delete (globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE];
+  delete (globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE]
 }
 
 function dynamicBailoutRoute(): string | undefined {
-  const route = (globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE];
-  return typeof route === 'string' ? route : undefined;
+  const route = (globalThis as Record<PropertyKey, unknown>)[BAILOUT_PROBE]
+  return typeof route === 'string' ? route : undefined
 }
 
 export function requireRequest(api: string) {
-  const probeRoute = dynamicBailoutRoute();
+  const probeRoute = dynamicBailoutRoute()
   if (probeRoute !== undefined) {
     const error = new Error(
       `Route ${probeRoute} couldn't be rendered statically because it used \`${api.replace(/\(\)$/, '')}\`. ` +
         `See more info here: https://nextjs.org/docs/messages/dynamic-server-error`,
-    );
-    error.name = 'DynamicServerError';
-    throw error;
+    )
+    error.name = 'DynamicServerError'
+    throw error
   }
-  const request = currentRequest();
+  const request = currentRequest()
   if (!request) {
     // In a partial prerender, request access marks the surrounding Suspense
     // boundary as a dynamic hole rather than failing the build.
-    if (isPrerendering()) throw new PostponeError(api);
-    throw new Error(`${api} can only be used while rendering a dynamic PNext request.`);
+    if (isPrerendering()) throw new PostponeError(api)
+    throw new Error(`${api} can only be used while rendering a dynamic PNext request.`)
   }
-  return request;
+  return request
 }
 
 /**
@@ -386,11 +386,11 @@ export function requestApiPromise<T>(api: string, produce: () => T): Promise<T>
       // Awaiting the resolved value arms the sync-IO abort: anything the render
       // computes with Date.now() & co. AFTER a runtime API resolved belongs to
       // the navigation, not the prefetch (see runWithRuntimePrefetchSyncIoAbort).
-      return markRuntimeApiOnAwait(Promise.resolve(produce()));
+      return markRuntimeApiOnAwait(Promise.resolve(produce()))
     }
-    return hangingPromise<T>(api);
+    return hangingPromise<T>(api)
   }
   // Legacy PPR (experimental_ppr, cacheComponents off): keep the call-site
   // throw so the existing shell path postpones exactly as before.
-  return Promise.resolve(produce());
+  return Promise.resolve(produce())
 }