@wular/pnext 0.0.4 → 0.0.6

package/src/index.ts

@@ -16,12 +16,12 @@ export type {
   ServerComponent,
   StaticParams,
   Viewport,
-} from './types';
-export type { PNextMetadataExport, PNextViewportExport } from './internal';
+} 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 { Link } from './api/link'
+export { dynamic } from './api/dynamic'
+export { Suspense, type SuspenseProps } from './api/suspense'
 export {
   href,
   notFound,
@@ -29,6 +29,6 @@ export {
   PNextNotFoundError,
   PNextRedirectError,
   redirect,
-} from './api/navigation';
-export type { HrefOptions, RedirectOptions, RedirectStatus } from './api/navigation';
-export { NextResponse } from './api/server';
+} from './api/navigation'
+export type { HrefOptions, RedirectOptions, RedirectStatus } from './api/navigation'
+export { NextResponse } from './api/server'

package/src/internal.ts

@@ -6,38 +6,35 @@ import type {
   ServerComponent,
   StaticParams,
   Viewport,
-} from './types';
+} from './types'
 
-export type PNextMetadataExport = Metadata | (() => Metadata | Promise<Metadata>);
-export type PNextViewportExport = Viewport | (() => Viewport | Promise<Viewport>);
+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;
+  default: ServerComponent<PageProps<Route>>
+  params?: () => StaticParams<Route>
+  metadata?: PNextMetadataExport
+  viewport?: PNextViewportExport
 }
 
 export interface PNextLayoutModule {
-  default?: ServerComponent<LayoutProps>;
-  metadata?: PNextMetadataExport;
-  viewport?: PNextViewportExport;
+  default?: ServerComponent<LayoutProps>
+  metadata?: PNextMetadataExport
+  viewport?: PNextViewportExport
 }
 
 type NextHandler = {
-  bivarianceHack(
-    request: never,
-    context: never,
-  ): Response | Promise<Response>;
-}['bivarianceHack'];
+  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>;
+  GET?: NextHandler
+  POST?: NextHandler
+  PUT?: NextHandler
+  PATCH?: NextHandler
+  DELETE?: NextHandler
+  OPTIONS?: NextHandler
+  HEAD?: NextHandler
+  params?: () => StaticParams<Route>
 }

package/src/{islands → render}/boundary-error.ts

@@ -3,6 +3,6 @@
  * 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';
+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/render/hooks.ts

@@ -10,25 +10,25 @@
 // inverted - core never imports compat. Types stay structural so core carries no type dependency on any
 // compat module.
 
-import type { ResolvedConfig } from '../config';
-import type { Metadata, MetadataLink, PageProps, Viewport } from '../types';
-import { restoreWithExtensionHost } from '../extensions';
+import type { ResolvedConfig } from '../config'
+import type { Metadata, MetadataLink, PageProps, Viewport } from '../types'
+import { restoreWithExtensionHost } from '../extensions'
 
 // ---------------------------------------------------------------------------
 // Compat enablement gates (pure config reads; kept in core so render never
-// imports compat/index just to branch on the mode). MUST stay in sync with
-// compat/index.ts reactCompatEnabled / nextCompatEnabled and the inlined gate
+// imports compat/aliases just to branch on the mode). MUST stay in sync with
+// compat/aliases.ts reactCompatEnabled / nextCompatEnabled and the inlined gate
 // in compat-bootstrap.ts.
 // ---------------------------------------------------------------------------
 
 /** Next compat is on (server actions, next/* modules, authInterrupts). */
 export function nextCompatEnabled(config: ResolvedConfig): boolean {
-  return Boolean(config.compat?.next);
+  return Boolean(config.compat?.next)
 }
 
 /** React compat is on (next implies react; react/react-dom aliasing, use() replay). */
 export function reactCompatEnabled(config: ResolvedConfig): boolean {
-  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler)
 }
 
 // ---------------------------------------------------------------------------
@@ -38,8 +38,8 @@ export function reactCompatEnabled(config: ResolvedConfig): boolean {
 
 /** Resolved next/font CSS + preload links for a render (mirrors ResolvedFontAssets). */
 export interface RenderFontAssets {
-  css: string;
-  preloads: MetadataLink[];
+  css: string
+  preloads: MetadataLink[]
 }
 
 export interface FontExtensions {
@@ -48,7 +48,7 @@ export interface FontExtensions {
    * register their definitions. Compat installs the AsyncLocalStorage scope
    * (compat/next/font/runtime runWithFontScope). Default: run untouched.
    */
-  runWithFontScope: <T>(callback: () => T) => T;
+  runWithFontScope: <T>(callback: () => T) => T
 
   /**
    * Emit the CSS + preload links for the fonts registered during the current
@@ -57,7 +57,7 @@ export interface FontExtensions {
   collectFontAssets: (
     config: ResolvedConfig,
     options: { dev?: boolean },
-  ) => Promise<RenderFontAssets>;
+  ) => Promise<RenderFontAssets>
 
   /**
    * Resolve every font declared by modules loaded so far, without waiting for a render to register
@@ -65,21 +65,21 @@ export interface FontExtensions {
    * render, so it serializes behind everything. Called off the request's critical path, it lands in
    * the same memo the render reads. Default: none.
    */
-  prewarmFontAssets: (config: ResolvedConfig, options: { dev?: boolean }) => Promise<void>;
+  prewarmFontAssets: (config: ResolvedConfig, options: { dev?: boolean }) => Promise<void>
 }
 
 const fontExtensions: FontExtensions = {
   runWithFontScope: callback => callback(),
   collectFontAssets: () => Promise.resolve({ css: '', preloads: [] }),
   prewarmFontAssets: () => Promise.resolve(),
-};
+}
 
 export function getFontExtensions(): FontExtensions {
-  return fontExtensions;
+  return fontExtensions
 }
 
 export function setFontExtensions(overrides: Partial<FontExtensions>): void {
-  Object.assign(fontExtensions, overrides);
+  Object.assign(fontExtensions, overrides)
 }
 
 // Suspense identity - compat apps render React's Suspense (preact/compat), which streaming must recognize
@@ -91,29 +91,29 @@ export interface SuspenseExtensions {
    * Lazily resolve the compat Suspense component type (preact/compat) once, so the streaming tree walker can
    * treat it as a boundary. Default is a noop - core streaming uses its own Suspense marker only.
    */
-  ensureCompatSuspense: (config: ResolvedConfig) => Promise<void>;
+  ensureCompatSuspense: (config: ResolvedConfig) => Promise<void>
   /** The resolved compat Suspense type, or undefined for a pure-core render. */
-  compatSuspenseType: () => unknown;
+  compatSuspenseType: () => unknown
 }
 
 const suspenseExtensions: SuspenseExtensions = {
   ensureCompatSuspense: () => Promise.resolve(),
   compatSuspenseType: () => undefined,
-};
+}
 
 export function getSuspenseExtensions(): SuspenseExtensions {
-  return suspenseExtensions;
+  return suspenseExtensions
 }
 
 export function setSuspenseExtensions(overrides: Partial<SuspenseExtensions>): void {
-  Object.assign(suspenseExtensions, overrides);
+  Object.assign(suspenseExtensions, overrides)
 }
 
 export interface StreamRouteExtensions {
   canStreamRoute: (input: {
-    config: ResolvedConfig;
-    route: { client?: boolean; stream?: unknown };
-  }) => boolean;
+    config: ResolvedConfig
+    route: { client?: boolean; stream?: unknown }
+  }) => boolean
   /**
    * True when the route must stream through a SINGLE preact render (suspending
    * in place) rather than the out-of-order resolve walk, because an ancestor
@@ -121,88 +121,88 @@ export interface StreamRouteExtensions {
    * rendered replacement chunk would lose. See renderClientPageStreamShell.
    */
   inlineSuspenseStream: (input: {
-    config: ResolvedConfig;
-    route: { client?: boolean; stream?: unknown };
-  }) => boolean;
+    config: ResolvedConfig
+    route: { client?: boolean; stream?: unknown }
+  }) => boolean
 }
 
 const streamRouteExtensions: StreamRouteExtensions = {
   canStreamRoute: () => true,
   inlineSuspenseStream: () => false,
-};
+}
 
 export function getStreamRouteExtensions(): StreamRouteExtensions {
-  return streamRouteExtensions;
+  return streamRouteExtensions
 }
 
 export function setStreamRouteExtensions(overrides: Partial<StreamRouteExtensions>): void {
-  Object.assign(streamRouteExtensions, overrides);
+  Object.assign(streamRouteExtensions, overrides)
 }
 
 export interface StreamBoundaryExtensions {
-  onStreamBoundaryError: (error: unknown) => void | Promise<void>;
+  onStreamBoundaryError: (error: unknown) => void | Promise<void>
 }
 
 const streamBoundaryExtensions: StreamBoundaryExtensions = {
   onStreamBoundaryError: () => undefined,
-};
+}
 
 export function getStreamBoundaryExtensions(): StreamBoundaryExtensions {
-  return streamBoundaryExtensions;
+  return streamBoundaryExtensions
 }
 
 export function setStreamBoundaryExtensions(overrides: Partial<StreamBoundaryExtensions>): void {
-  Object.assign(streamBoundaryExtensions, overrides);
+  Object.assign(streamBoundaryExtensions, overrides)
 }
 
 export function reportStreamBoundaryError(error: unknown): void {
   try {
-    const result = streamBoundaryExtensions.onStreamBoundaryError(error);
+    const result = streamBoundaryExtensions.onStreamBoundaryError(error)
     if (isThenable(result)) {
       void Promise.resolve(result).catch(reportError => {
-        console.error('stream boundary error hook failed:', reportError);
-      });
+        console.error('stream boundary error hook failed:', reportError)
+      })
     }
   } catch (reportError) {
-    console.error('stream boundary error hook failed:', reportError);
+    console.error('stream boundary error hook failed:', reportError)
   }
 }
 
 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'
 }
 
 // Metadata resolver - core handles static/build-time metadata. Compat registers request-time/streaming-
 // compatible metadata resolvers here without adding a core-to-compat import edge.
 
 export interface MetadataExtensions {
-  enabled: (config: ResolvedConfig) => boolean;
-  hasRuntimeMetadata: (module: Record<string, unknown>) => boolean;
+  enabled: (config: ResolvedConfig) => boolean
+  hasRuntimeMetadata: (module: Record<string, unknown>) => boolean
   readModuleMetadata: (
     module: Record<string, unknown>,
     props: PageProps,
     parent: Metadata,
     modulePath?: string,
-  ) => Promise<Metadata | undefined>;
+  ) => Promise<Metadata | undefined>
   readModuleViewport: (
     module: Record<string, unknown>,
     props: PageProps,
-  ) => Promise<Viewport | undefined>;
-  shouldRenderMetadataInBody: (input: { config: ResolvedConfig; request?: Request }) => boolean;
+  ) => Promise<Viewport | undefined>
+  shouldRenderMetadataInBody: (input: { config: ResolvedConfig; request?: Request }) => boolean
 }
 
-const metadataExtensions: Partial<MetadataExtensions> = {};
+const metadataExtensions: Partial<MetadataExtensions> = {}
 
 export function getMetadataExtensions(): Partial<MetadataExtensions> {
-  return metadataExtensions;
+  return metadataExtensions
 }
 
 export function getActiveMetadataExtensions(config: ResolvedConfig): Partial<MetadataExtensions> {
-  return metadataExtensions.enabled?.(config) ? metadataExtensions : {};
+  return metadataExtensions.enabled?.(config) ? metadataExtensions : {}
 }
 
 export function setMetadataExtensions(overrides: Partial<MetadataExtensions>): void {
-  Object.assign(metadataExtensions, overrides);
+  Object.assign(metadataExtensions, overrides)
 }
 
 // ---------------------------------------------------------------------------
@@ -212,14 +212,14 @@ export function setMetadataExtensions(overrides: Partial<MetadataExtensions>): v
 
 export interface DocumentScriptExtensions {
   /** Optional precedence assigned to renderer-managed stylesheet links. */
-  stylesheetPrecedence: (config: ResolvedConfig) => string | undefined;
+  stylesheetPrecedence: (config: ResolvedConfig) => string | undefined
 
   /**
    * Inline scripts compat injects near the end of the document body, before the
    * props/route/client scripts. Compat (react) returns Next's window.next router
    * shim. Default: '' (core injects no compat scripts).
    */
-  documentBodyScripts: (config: ResolvedConfig) => string;
+  documentBodyScripts: (config: ResolvedConfig) => string
 
   /**
    * Inline tags compat injects into the document `<head>` once per document
@@ -229,23 +229,23 @@ export interface DocumentScriptExtensions {
    * (otel) composes clientTraceMetadata `<meta>` tags here. Default: '' (core
    * injects no compat head tags).
    */
-  documentHeadTags?: (config: ResolvedConfig, ctx: { dynamic: boolean; rsc: boolean }) => string;
+  documentHeadTags?: (config: ResolvedConfig, ctx: { dynamic: boolean; rsc: boolean }) => string
 
   /** Tags collected after the document shell has flushed. */
-  streamInsertedHTML?: () => string;
+  streamInsertedHTML?: () => string
 }
 
 const documentScriptExtensions: DocumentScriptExtensions = {
   stylesheetPrecedence: () => undefined,
   documentBodyScripts: () => '',
-};
+}
 
 export function getDocumentScriptExtensions(): DocumentScriptExtensions {
-  return documentScriptExtensions;
+  return documentScriptExtensions
 }
 
 export function setDocumentScriptExtensions(overrides: Partial<DocumentScriptExtensions>): void {
-  Object.assign(documentScriptExtensions, overrides);
+  Object.assign(documentScriptExtensions, overrides)
 }
 
 // ---------------------------------------------------------------------------
@@ -254,7 +254,7 @@ export function setDocumentScriptExtensions(overrides: Partial<DocumentScriptExt
 // ---------------------------------------------------------------------------
 
 export interface StaticParamsExtensions {
-  normalizeModule: (module: Record<string, unknown>) => Record<string, unknown>;
+  normalizeModule: (module: Record<string, unknown>) => Record<string, unknown>
 }
 
 const staticParamsExtensions: StaticParamsExtensions = {
@@ -262,14 +262,14 @@ const staticParamsExtensions: StaticParamsExtensions = {
     typeof module.params === 'function' || typeof module.generateStaticParams !== 'function'
       ? module
       : { ...module, params: module.generateStaticParams },
-};
+}
 
 export function getStaticParamsExtensions(): StaticParamsExtensions {
-  return staticParamsExtensions;
+  return staticParamsExtensions
 }
 
 export function setStaticParamsExtensions(overrides: Partial<StaticParamsExtensions>): void {
-  Object.assign(staticParamsExtensions, overrides);
+  Object.assign(staticParamsExtensions, overrides)
 }
 
 // Server-action module tagging - when a server render imports a 'use server' module, compat tags each
@@ -287,7 +287,7 @@ export interface ActionModuleExtensions {
   tagActionModulesForRender: (
     config: ResolvedConfig,
     importModule: (file: string) => Promise<Record<string, unknown>>,
-  ) => Promise<void>;
+  ) => Promise<void>
 
   /**
    * Tag the exports of a freshly imported module when it is a discovered action
@@ -298,20 +298,20 @@ export interface ActionModuleExtensions {
     config: ResolvedConfig,
     file: string,
     module: Record<string, unknown>,
-  ) => void;
+  ) => void
 }
 
 const actionModuleExtensions: ActionModuleExtensions = {
   tagActionModulesForRender: () => Promise.resolve(),
   tagActionModuleExports: () => undefined,
-};
+}
 
 export function getActionModuleExtensions(): ActionModuleExtensions {
-  return actionModuleExtensions;
+  return actionModuleExtensions
 }
 
 export function setActionModuleExtensions(overrides: Partial<ActionModuleExtensions>): void {
-  Object.assign(actionModuleExtensions, overrides);
+  Object.assign(actionModuleExtensions, overrides)
 }
 
 // Render span seam - compat (otel) wraps the render-body and route-resolution phases in OpenTelemetry
@@ -325,14 +325,14 @@ export interface RenderSpanExtensions {
    * `render route (app) <route>` span (`AppRender.getBodyResult`). `route` is
    * the route PATTERN. Default: run `fn` untouched.
    */
-  withRenderBodySpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>;
+  withRenderBodySpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>
 
   /**
    * Wrap route-component resolution (page module import) so compat emits the
    * `resolve page components` span (`NextNodeServer.findPageComponents`,
    * sibling of the render-body span under the root). Default: run `fn`.
    */
-  withFindPageComponentsSpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>;
+  withFindPageComponentsSpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>
 
   /**
    * Emit a cheap leaf `resolve segment modules` span
@@ -341,14 +341,14 @@ export interface RenderSpanExtensions {
    * `__PAGE__` for the leaf page or the dynamic/literal dir label for a layout.
    * Default: noop.
    */
-  emitResolveSegmentSpan: (segment: string) => void;
+  emitResolveSegmentSpan: (segment: string) => void
 
   /**
    * Wrap a route-handler invocation so compat emits the
    * `executing api route (app) <route>` span (`AppRouteRouteHandlers.
    * runHandler`). `route` is the core route PATTERN. Default: run `fn`.
    */
-  withRouteHandlerSpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>;
+  withRouteHandlerSpan: <T>(route: string, fn: () => Promise<T>) => Promise<T>
 }
 
 const renderSpanExtensions: RenderSpanExtensions = {
@@ -356,14 +356,14 @@ const renderSpanExtensions: RenderSpanExtensions = {
   withFindPageComponentsSpan: (_route, fn) => fn(),
   emitResolveSegmentSpan: () => undefined,
   withRouteHandlerSpan: (_route, fn) => fn(),
-};
+}
 
 export function getRenderSpanExtensions(): RenderSpanExtensions {
-  return renderSpanExtensions;
+  return renderSpanExtensions
 }
 
 export function setRenderSpanExtensions(overrides: Partial<RenderSpanExtensions>): void {
-  Object.assign(renderSpanExtensions, overrides);
+  Object.assign(renderSpanExtensions, overrides)
 }
 
 // Compat populates every registry above at the bootstrap seam, exactly as it
@@ -380,5 +380,5 @@ for (const registry of [
   actionModuleExtensions,
   renderSpanExtensions,
 ]) {
-  restoreWithExtensionHost(registry);
+  restoreWithExtensionHost(registry)
 }

package/src/render/island-context.ts

@@ -1,15 +1,15 @@
-import { createContext, type Context } from 'preact';
+import { createContext, type Context } from 'preact'
 
 // Island SSR runs prebundled client chunks — a separate module graph with its own copy of this file, so
 // a plain createContext() would mint two identity-mismatched contexts. Resolve one shared instance.
 function sharedContext<T>(key: string, defaultValue: T): Context<T> {
-  const registry = globalThis as typeof globalThis & Record<symbol, Context<unknown>>;
-  const symbol = Symbol.for(key);
-  const existing = registry[symbol];
-  if (existing) return existing as Context<T>;
-  const context = createContext<T>(defaultValue);
-  registry[symbol] = context as Context<unknown>;
-  return context;
+  const registry = globalThis as typeof globalThis & Record<symbol, Context<unknown>>
+  const symbol = Symbol.for(key)
+  const existing = registry[symbol]
+  if (existing) return existing as Context<T>
+  const context = createContext<T>(defaultValue)
+  registry[symbol] = context as Context<unknown>
+  return context
 }
 
 // ---------------------------------------------------------------------------
@@ -33,17 +33,17 @@ function sharedContext<T>(key: string, defaultValue: T): Context<T> {
 
 export interface LayoutSegmentSnapshot {
   /** Segments consumed AT or ABOVE the owning layout's directory. */
-  depth: number;
+  depth: number
   /** Resolved URL segments below the owning layout (server-side truth). */
-  segments: string[];
+  segments: string[]
   /** Resolved segments per parallel-route slot key (server-side truth). */
-  slots: Record<string, string[]>;
+  slots: Record<string, string[]>
 }
 
 export const LayoutSegmentContext = sharedContext<LayoutSegmentSnapshot | null>(
   'pnext.layoutSegmentContext',
   null,
-);
+)
 
 // Per-island params snapshot (CORE seam for compat useParams).
 //
@@ -57,9 +57,9 @@ export const LayoutSegmentContext = sharedContext<LayoutSegmentSnapshot | null>(
 // Kept in core (imports only `preact`) so both the renderer's SSR wrap and the entry's client mount
 // reference the SAME context object, exactly like LayoutSegmentContext above.
 
-export type RouteParamsSnapshot = Record<string, string | string[]>;
+export type RouteParamsSnapshot = Record<string, string | string[]>
 
 export const RouteParamsContext = sharedContext<RouteParamsSnapshot | null>(
   'pnext.routeParamsContext',
   null,
-);
+)