@wular/pnext 0.0.1

package/src/index.ts

@@ -0,0 +1,34 @@
+export type {
+  LayoutProps,
+  Metadata,
+  MetadataLink,
+  NextRequest,
+  PageProps,
+  PageSearchParams,
+  PNextConfig,
+  PNextRoutes,
+  PrefetchMode,
+  RouteContext,
+  RouteHandler,
+  RouteMode,
+  RouteParams,
+  RoutePath,
+  ServerComponent,
+  StaticParams,
+  Viewport,
+} from './types';
+export type { PNextMetadataExport, PNextViewportExport } from './internal';
+
+export { Link } from './api/link';
+export { dynamic } from './api/dynamic';
+export { Suspense, type SuspenseProps } from './api/suspense';
+export {
+  href,
+  notFound,
+  permanentRedirect,
+  PNextNotFoundError,
+  PNextRedirectError,
+  redirect,
+} from './api/navigation';
+export type { HrefOptions, RedirectOptions, RedirectStatus } from './api/navigation';
+export { NextResponse } from './api/server';

package/src/internal.ts

@@ -0,0 +1,43 @@
+import type {
+  LayoutProps,
+  Metadata,
+  PageProps,
+  RoutePath,
+  ServerComponent,
+  StaticParams,
+  Viewport,
+} from './types';
+
+export type PNextMetadataExport = Metadata | (() => Metadata | Promise<Metadata>);
+export type PNextViewportExport = Viewport | (() => Viewport | Promise<Viewport>);
+
+export interface PNextPageModule<Route extends RoutePath> {
+  default: ServerComponent<PageProps<Route>>;
+  params?: () => StaticParams<Route>;
+  metadata?: PNextMetadataExport;
+  viewport?: PNextViewportExport;
+}
+
+export interface PNextLayoutModule {
+  default?: ServerComponent<LayoutProps>;
+  metadata?: PNextMetadataExport;
+  viewport?: PNextViewportExport;
+}
+
+type NextHandler = {
+  bivarianceHack(
+    request: never,
+    context: never,
+  ): Response | Promise<Response>;
+}['bivarianceHack'];
+
+export interface PNextRouteHandlerModule<Route extends RoutePath> {
+  GET?: NextHandler;
+  POST?: NextHandler;
+  PUT?: NextHandler;
+  PATCH?: NextHandler;
+  DELETE?: NextHandler;
+  OPTIONS?: NextHandler;
+  HEAD?: NextHandler;
+  params?: () => StaticParams<Route>;
+}

package/src/islands/boundary-error.ts

@@ -0,0 +1,8 @@
+/**
+ * Marker element carrying a server-subtree error across a client island's
+ * boundary: the client entry turns it back into a throw at hydration, so the
+ * island's own error boundary catches it.
+ */
+export const ISLAND_BOUNDARY_ERROR_ELEMENT = 'pnext-boundary-error';
+export const ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE = 'data-pnext-error-message';
+export const ISLAND_BOUNDARY_ERROR_DIGEST_ATTRIBUTE = 'data-pnext-error-digest';

package/src/islands/static-children.ts

@@ -0,0 +1,37 @@
+import { h, type ComponentChildren } from 'preact';
+
+export const ISLAND_STATIC_CHILDREN_ATTRIBUTE = 'data-pnext-static-children';
+
+export function islandStaticChildren(
+  id: string,
+  children: ComponentChildren,
+) {
+  if (!hasIslandStaticChildren(children)) return undefined;
+  return h(
+    'pnext-static-children',
+    { [ISLAND_STATIC_CHILDREN_ATTRIBUTE]: id, style: { display: 'contents' } },
+    children,
+  );
+}
+
+function hasIslandStaticChildren(children: ComponentChildren) {
+  return Array.isArray(children) ? children.length > 0 : children != null && children !== false;
+}
+
+/**
+ * Children that can cross the server-to-client island boundary INSIDE the serialized props (strings and
+ * numbers, or arrays of them). Element children return undefined and travel via DOM adoption instead.
+ */
+export function plainIslandChildren(
+  children: ComponentChildren,
+): string | number | (string | number)[] | undefined {
+  if (typeof children === 'string' || typeof children === 'number') return children;
+  if (
+    Array.isArray(children) &&
+    children.length > 0 &&
+    children.every(child => typeof child === 'string' || typeof child === 'number')
+  ) {
+    return children as (string | number)[];
+  }
+  return undefined;
+}

package/src/islands/static-slots.ts

@@ -0,0 +1,106 @@
+import { h, type VNode } from 'preact';
+import { isElementLike } from '../utils/serialize';
+
+export const ISLAND_STATIC_SLOT_ATTRIBUTE = 'data-pnext-static-slot';
+export const ISLAND_STATIC_SLOT_MARKER = '$$pnext_slot';
+
+type Props = Record<string, unknown>;
+
+/**
+ * Element-valued island props travel exactly like element children: the SSR pass wraps each one in a
+ * `pnext-static-slot` host ('ssr') and the serialized props carry a `$$pnext_slot` id in its place
+ * ('wire'). Both walks see the same prop shape, so the ids line up. Elements nested in arrays and
+ * plain objects are covered; anything else (Map/Set values, class instances) is left alone.
+ */
+export function islandStaticSlotProps(id: string, props: Props, mode: 'ssr' | 'wire'): Props {
+  return mapSlots(props, id, mode, [], new Set()) as Props;
+}
+
+function mapSlots(
+  value: unknown,
+  id: string,
+  mode: 'ssr' | 'wire',
+  path: string[],
+  seen: Set<object>,
+): unknown {
+  if (isElementLike(value)) {
+    const slot = `${id}:${path.join('.')}`;
+    if (mode === 'wire') return { [ISLAND_STATIC_SLOT_MARKER]: slot };
+    return h(
+      'pnext-static-slot',
+      { [ISLAND_STATIC_SLOT_ATTRIBUTE]: slot, style: { display: 'contents' } },
+      value as VNode,
+    );
+  }
+  if (value === null || typeof value !== 'object') return value;
+  // Cyclic props are supported by the serializer; never walk a container twice.
+  if (seen.has(value)) return value;
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) return value;
+  seen.add(value);
+  let changed = false;
+  const entries = Array.isArray(value)
+    ? value.map((item, index) => [String(index), item] as const)
+    : Object.entries(value);
+  const mapped = entries.map(([key, item]) => {
+    const next = mapSlots(item, id, mode, [...path, key], seen);
+    if (next !== item) changed = true;
+    return [key, next] as const;
+  });
+  seen.delete(value);
+  // Untouched branches keep their identity (the taint check compares by identity).
+  if (!changed) return value;
+  if (Array.isArray(value)) return mapped.map(([, item]) => item);
+  return Object.fromEntries(mapped);
+}
+
+/** Cheap gate on the raw props attribute so islands with no element props skip the revive walk. */
+export function hasIslandStaticSlots(raw: string) {
+  return raw.includes(ISLAND_STATIC_SLOT_MARKER);
+}
+
+/**
+ * Client mount: swap each `$$pnext_slot` marker for a `pnext-static-slot` host holding the matching
+ * server-rendered DOM, converted to vnodes by the entry's DOM walker (so nested islands inside the
+ * adopted subtree become real island vnodes and hydrate on their own). The content is static server
+ * markup - it never re-renders, same as element children.
+ */
+export async function reviveIslandStaticSlots(
+  props: Props,
+  root: ParentNode,
+  toChildren: (node: ParentNode) => unknown,
+): Promise<Props> {
+  return (await reviveSlots(props, root, toChildren, new Set())) as Props;
+}
+
+async function reviveSlots(
+  value: unknown,
+  root: ParentNode,
+  toChildren: (node: ParentNode) => unknown,
+  seen: Set<object>,
+): Promise<unknown> {
+  if (value === null || typeof value !== 'object' || seen.has(value)) return value;
+  const marker = (value as Props)[ISLAND_STATIC_SLOT_MARKER];
+  if (typeof marker === 'string') {
+    const node = root.querySelector(`[${ISLAND_STATIC_SLOT_ATTRIBUTE}="${cssEscape(marker)}"]`);
+    // No server markup for this slot (the island never rendered the prop, or it was skipped for
+    // SSR): nothing to adopt, so the prop arrives null rather than as an empty host.
+    if (!node) return null;
+    return h(
+      'pnext-static-slot',
+      { [ISLAND_STATIC_SLOT_ATTRIBUTE]: marker, style: { display: 'contents' } },
+      (await toChildren(node)) as VNode,
+    );
+  }
+  const proto = Object.getPrototypeOf(value) as object | null;
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) return value;
+  seen.add(value);
+  const target = value as Props;
+  for (const key of Object.keys(target)) {
+    target[key] = await reviveSlots(target[key], root, toChildren, seen);
+  }
+  return value;
+}
+
+function cssEscape(value: string) {
+  return value.replace(/["\\]/g, '\\$&');
+}

package/src/ppr-postpone.ts

@@ -0,0 +1,24 @@
+// Client-safe postpone primitives (CORE).
+//
+// PostponeError + isPostpone are pure, browser-safe values: a client control-
+// flow module (compat/client/errors/control-flow.ts) needs isPostpone to skip
+// postpone errors during hydration. They used to live in ppr.ts, but ppr.ts
+// imports `node:async_hooks` at module scope (AsyncLocalStorage prerender
+// storage), so importing isPostpone from there dragged node:async_hooks into
+// the browser client bundle and broke `Could not resolve "node:async_hooks"`.
+// Splitting them out keeps ppr.ts as the single source (it re-exports these) so
+// server callers are unaffected, while client callers import only this file.
+
+const postponeSymbol = Symbol.for('pnext.postpone');
+
+export class PostponeError extends Error {
+  readonly [postponeSymbol] = true;
+  constructor(readonly api: string) {
+    super(`${api} postponed for partial prerendering`);
+    this.name = 'PostponeError';
+  }
+}
+
+export function isPostpone(error: unknown): error is PostponeError {
+  return typeof error === 'object' && error !== null && postponeSymbol in error;
+}