@wular/pnext 0.0.1

package/src/api/server.ts

@@ -0,0 +1,323 @@
+import { safeDecode } from '../utils/decode';
+import { getProxyExtensions, getProxyResponseProtocol } from '../extensions';
+import { getBasePathPrefix } from '../routing/href';
+import type {
+  NextRequest as NextRequestLike,
+  NextRequestCookie,
+  NextRequestCookies,
+  NextURL,
+  NextResponseCookies,
+} from '../types';
+
+const nextResponseMetaSymbol = Symbol.for('pnext.nextResponse');
+
+export type { NextFetchEvent } from '../types';
+
+export interface NextRequestGeo {
+  city?: string;
+  country?: string;
+  region?: string;
+  latitude?: string;
+  longitude?: string;
+}
+
+/**
+ * Runtime NextRequest for user code that constructs requests, mirroring
+ * Next's `new NextRequest(input, init?)`. Internal paths keep augmenting
+ * plain Requests via toNextRequest().
+ */
+export class NextRequest extends Request implements NextRequestLike {
+  readonly cookies: NextRequestCookies;
+  readonly nextUrl: NextURL;
+  readonly geo?: NextRequestGeo;
+  readonly ip?: string;
+
+  constructor(input: RequestInfo | URL, init?: RequestInit) {
+    super(input, init);
+    this.cookies = requestCookies(this.headers);
+    this.nextUrl = createNextUrl(this.url);
+  }
+}
+
+export type NextResponseKind = 'next' | 'rewrite';
+
+export interface NextResponseMeta {
+  kind: NextResponseKind;
+  url?: string;
+  requestHeaders?: Headers;
+}
+
+type NextResponseInit = ResponseInit & {
+  request?: {
+    headers?: HeadersInit;
+  };
+};
+
+export class NextResponse extends Response {
+  readonly cookies: NextResponseCookies;
+  readonly [nextResponseMetaSymbol]?: NextResponseMeta;
+
+  constructor(body?: BodyInit | null, init?: ResponseInit) {
+    super(body, init);
+    this.cookies = responseCookies(this.headers);
+  }
+
+  static json<JsonBody>(body: JsonBody, init?: ResponseInit) {
+    const headers = new Headers(init?.headers);
+    if (!headers.has('content-type')) headers.set('content-type', 'application/json');
+    return new NextResponse(JSON.stringify(body), {
+      ...init,
+      headers,
+    });
+  }
+
+  static next(init?: NextResponseInit) {
+    const response = new NextResponse(null, init);
+    response.headers.set(getProxyResponseProtocol().nextHeader, '1');
+    defineMeta(response, { kind: 'next', ...requestMeta(init) });
+    return response;
+  }
+
+  static rewrite(url: string | URL, init?: NextResponseInit) {
+    const response = new NextResponse(null, init);
+    response.headers.set(getProxyResponseProtocol().rewriteHeader, String(url));
+    defineMeta(response, { kind: 'rewrite', url: String(url), ...requestMeta(init) });
+    return response;
+  }
+
+  static redirect(url: string | URL, init: number | ResponseInit = 307) {
+    const responseInit = typeof init === 'number' ? { status: init } : init;
+    const headers = new Headers(responseInit.headers);
+    headers.set('location', String(url));
+    return new NextResponse(null, {
+      ...responseInit,
+      status: responseInit.status ?? 307,
+      headers,
+    });
+  }
+}
+
+export function toNextRequest(request: Request): NextRequestLike {
+  const nextRequest = request as Partial<NextRequestLike>;
+  if (nextRequest.cookies && nextRequest.nextUrl) return request as NextRequestLike;
+
+  Object.defineProperties(request, {
+    cookies: {
+      configurable: true,
+      enumerable: true,
+      value: requestCookies(request.headers),
+    },
+    nextUrl: {
+      configurable: true,
+      enumerable: true,
+      value: createNextUrl(request.url),
+    },
+  });
+  return request as NextRequestLike;
+}
+
+export function nextResponseMeta(response: Response): NextResponseMeta | undefined {
+  const meta = (response as Response & { [nextResponseMetaSymbol]?: NextResponseMeta })[nextResponseMetaSymbol];
+  if (meta) return meta;
+
+  const protocol = getProxyResponseProtocol();
+  const rewrite = response.headers.get(protocol.rewriteHeader);
+  if (rewrite) return { kind: 'rewrite', url: rewrite };
+  if (response.headers.get(protocol.nextHeader)) return { kind: 'next' };
+  return undefined;
+}
+
+export function copyMiddlewareHeaders(from: Response, to: Response) {
+  const internalHeaders = proxyInternalHeaders();
+  from.headers.forEach((value, key) => {
+    if (internalHeaders.has(key) || key === 'content-length' || key === 'set-cookie') return;
+    // Vary is merged, never overwritten: the middleware's vary tokens join the
+    // handler/page's own (both survive for CDN correctness). Every other header
+    // is the middleware's to set.
+    if (key === 'vary') mergeVaryInto(to.headers, value);
+    else to.headers.set(key, value);
+  });
+  const middlewareCookies = getSetCookie(from.headers);
+  if (middlewareCookies.length === 0) return;
+  const responseCookies = getSetCookie(to.headers);
+  to.headers.delete('set-cookie');
+  for (const cookie of middlewareCookies) to.headers.append('set-cookie', cookie);
+  for (const cookie of responseCookies) to.headers.append('set-cookie', cookie);
+}
+
+// Forward a middleware response's non-internal headers onto the DOWNSTREAM REQUEST (in addition to
+// the response). Next applies every non-internal middleware response header to both req.headers and
+// the final response, so NextResponse.next({ headers }) values are visible to route handlers and
+// pages as request headers. set-cookie is handled separately and never forwarded here.
+export function forwardMiddlewareRequestHeaders(from: Response, request: Request): Request {
+  const additions: [string, string][] = [];
+  const internalHeaders = proxyInternalHeaders();
+  from.headers.forEach((value, key) => {
+    if (internalHeaders.has(key) || key === 'content-length' || key === 'set-cookie') return;
+    additions.push([key, value]);
+  });
+  if (additions.length === 0) return request;
+  const headers = new Headers(request.headers);
+  for (const [key, value] of additions) headers.set(key, value);
+  return new Request(request, { headers });
+}
+
+function proxyInternalHeaders() {
+  const protocol = getProxyResponseProtocol();
+  return new Set([protocol.nextHeader, protocol.rewriteHeader]);
+}
+
+// Append `value`'s comma-separated tokens to the response's Vary, preserving
+// existing tokens and never duplicating (case-insensitive).
+function mergeVaryInto(headers: Headers, value: string) {
+  const existing = headers.get('vary');
+  const seen = new Set(
+    (existing ?? '')
+      .split(',')
+      .map(token => token.trim().toLowerCase())
+      .filter(Boolean),
+  );
+  const merged = existing
+    ? existing.split(',').map(token => token.trim()).filter(Boolean)
+    : [];
+  for (const token of value.split(',').map(part => part.trim()).filter(Boolean)) {
+    if (seen.has(token.toLowerCase())) continue;
+    seen.add(token.toLowerCase());
+    merged.push(token);
+  }
+  if (merged.length > 0) headers.set('vary', merged.join(', '));
+}
+
+function defineMeta(response: NextResponse, meta: NextResponseMeta) {
+  Object.defineProperty(response, nextResponseMetaSymbol, {
+    configurable: false,
+    enumerable: false,
+    value: meta,
+  });
+}
+
+function requestMeta(init: NextResponseInit | undefined): Pick<NextResponseMeta, 'requestHeaders'> {
+  return init?.request?.headers ? { requestHeaders: new Headers(init.request.headers) } : {};
+}
+
+function createNextUrl(url: string | URL): NextURL {
+  const nextUrl = new URL(url) as NextURL;
+  Object.defineProperty(nextUrl, 'clone', {
+    configurable: true,
+    enumerable: false,
+    value: () => createNextUrl(nextUrl.href),
+  });
+  // Next's NextURL exposes basePath (the configured prefix, '' when unset) and
+  // locale ('' without i18n). The request URL reaching middleware already has
+  // any basePath stripped, so pathname stays app-relative while basePath holds
+  // the prefix. Defaulting these to strings (never undefined) matches Next, so
+  // `req.nextUrl.basePath` reads as a falsy '' rather than the string
+  // "undefined" when forwarded through a header.
+  nextUrl.basePath = getBasePathPrefix();
+  nextUrl.locale = getProxyExtensions().locale(nextUrl);
+  return nextUrl;
+}
+
+function requestCookies(headers: Headers): NextRequestCookies {
+  let cookies = parseCookies(headers.get('cookie') ?? '');
+  const sync = () => {
+    const header = requestCookieHeader(cookies);
+    if (header) headers.set('cookie', header);
+    else headers.delete('cookie');
+  };
+  return {
+    get(name) {
+      return cookies.find(cookie => cookie.name === name);
+    },
+    getAll(name) {
+      return name ? cookies.filter(cookie => cookie.name === name) : [...cookies];
+    },
+    has(name) {
+      return cookies.some(cookie => cookie.name === name);
+    },
+    set(name, value) {
+      cookies = [...cookies.filter(cookie => cookie.name !== name), { name, value }];
+      sync();
+      return this;
+    },
+    delete(name) {
+      const existed = cookies.some(cookie => cookie.name === name);
+      cookies = cookies.filter(cookie => cookie.name !== name);
+      sync();
+      return existed;
+    },
+    clear() {
+      cookies = [];
+      sync();
+    },
+  };
+}
+
+function responseCookies(headers: Headers): NextResponseCookies {
+  return {
+    set(nameOrOptions: string | ResponseCookie, value?: string, options: ResponseCookieOptions = {}) {
+      const cookie: ResponseCookie =
+        typeof nameOrOptions === 'string'
+          ? { ...options, name: nameOrOptions, value: value ?? '' }
+          : nameOrOptions;
+      headers.append('set-cookie', serializeCookie(cookie.name, cookie.value, cookie));
+      return this;
+    },
+    delete(name) {
+      headers.append('set-cookie', serializeCookie(name, '', { maxAge: 0, path: '/' }));
+      return this;
+    },
+  };
+}
+
+interface ResponseCookieOptions {
+  path?: string;
+  maxAge?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'strict' | 'lax' | 'none';
+}
+
+interface ResponseCookie extends ResponseCookieOptions {
+  name: string;
+  value: string;
+}
+
+function serializeCookie(
+  name: string,
+  value: string,
+  options: ResponseCookieOptions,
+) {
+  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+  // Next's ResponseCookies default the cookie path to '/' when unspecified,
+  // so a route handler's Set-Cookie is visible to sibling routes/middleware
+  // (not scoped to the request path). Match that default.
+  parts.push(`Path=${options.path ?? '/'}`);
+  if (options.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);
+  if (options.httpOnly) parts.push('HttpOnly');
+  if (options.secure) parts.push('Secure');
+  if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
+  return parts.join('; ');
+}
+
+export function parseCookies(header: string): NextRequestCookie[] {
+  return header
+    .split(';')
+    .map(part => part.trim())
+    .filter(Boolean)
+    .map(part => {
+      const [key = '', ...rest] = part.split('=');
+      return { name: safeDecode(key), value: safeDecode(rest.join('=')) };
+    });
+}
+
+export function requestCookieHeader(cookies: NextRequestCookie[]) {
+  return cookies
+    .map(cookie => `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`)
+    .join('; ');
+}
+
+export function getSetCookie(headers: Headers) {
+  const withSetCookie = headers as Headers & { getSetCookie?: () => string[] };
+  return withSetCookie.getSetCookie?.() ?? [];
+}

package/src/api/suspense.ts

@@ -0,0 +1,16 @@
+import type { ComponentChildren } from 'preact';
+
+export interface SuspenseProps {
+  fallback?: ComponentChildren;
+  children?: ComponentChildren;
+}
+
+/**
+ * Server streaming boundary for core PNext apps. The renderer resolves these
+ * boundaries itself (streaming, PPR, loading.tsx), so no preact/compat
+ * suspension machinery is involved. Rendered directly (client trees, tests),
+ * it passes children through.
+ */
+export function Suspense(props: SuspenseProps): ComponentChildren {
+  return props.children ?? null;
+}

package/src/cache/context.ts

@@ -0,0 +1,61 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export interface CacheNode {
+  children: Map<unknown, CacheNode>;
+  record?: CacheRecord;
+}
+
+export type CacheRecord =
+  | { status: 'pending'; value: Promise<unknown> }
+  | { status: 'resolved'; value: unknown; async: boolean }
+  | { status: 'rejected'; error: unknown; async: boolean };
+
+export interface CacheScope {
+  functions: WeakMap<object, CacheNode>;
+  fetches?: Map<string, Promise<unknown>>;
+  /**
+   * Lazily-created controller backing React.cacheSignal() in a request render. The signal stays live
+   * for the whole render - including deferred/streamed Suspense boundaries that resolve after the
+   * shell has flushed - so a slow cache component's bounded polling is never cut short. A build
+   * prerender uses the prerender scope's signal instead, which aborts at completePrerender().
+   */
+  controller?: AbortController;
+}
+
+const storage = new AsyncLocalStorage<CacheScope>();
+
+export function currentCacheScope() {
+  return storage.getStore();
+}
+
+/**
+ * The AbortSignal for the current cache/render scope (React.cacheSignal()), or null outside any
+ * render. A request render's shell can flush while deferred boundaries are still resolving, so this
+ * signal is intentionally NOT aborted at shell-flush time - doing so would abort a still-pending slow
+ * boundary's polling. Build prerenders get a deterministically-aborting signal from the prerender scope.
+ */
+export function currentCacheSignal(): AbortSignal | null {
+  const scope = storage.getStore();
+  if (!scope) return null;
+  if (!scope.controller) scope.controller = new AbortController();
+  return scope.controller.signal;
+}
+
+export function runWithCacheScope<T>(callback: () => T): T {
+  const existing = storage.getStore();
+  if (existing) return callback();
+  return storage.run({ functions: new WeakMap() }, callback);
+}
+
+/**
+ * Capture the current cache scope (if any) and return a wrapper that re-runs a
+ * function inside it. after() uses this so a callback registered during a page
+ * render still shares the render's React cache() memo cache when it runs later
+ * in the detached work-unit flush (which otherwise carries no cache scope).
+ * Returns an identity wrapper when no scope is active.
+ */
+export function captureCacheScope(): <T>(fn: () => T) => T {
+  const scope = storage.getStore();
+  if (!scope) return fn => fn();
+  return fn => storage.run(scope, fn);
+}