@wular/pnext 0.0.4 → 0.0.6

package/src/compat/client/prefetch-cache.ts

@@ -13,48 +13,47 @@
 //
 // Injected into the client at build time as `window.__PNEXT_STALE_TIMES__`; undefined means Next defaults.
 
-
 /** Next's built-in prefetch staleTimes (milliseconds). */
 // Since Next 15 the DYNAMIC default is 0: dynamic data is never reused across
 // navigations unless `experimental.staleTimes.dynamic` opts in. (The loading
 // shell of a dynamic route still reuses for the STATIC window.)
-export const DEFAULT_DYNAMIC_STALE_TIME_MS = 0;
-export const DEFAULT_STATIC_STALE_TIME_MS = 300_000;
+export const DEFAULT_DYNAMIC_STALE_TIME_MS = 0
+export const DEFAULT_STATIC_STALE_TIME_MS = 300_000
 /** Next's runtime-prefetch stale threshold (RUNTIME_PREFETCH_DYNAMIC_STALE). */
-const RUNTIME_DOCUMENT_STALE_TIME_MS = 30_000;
+const RUNTIME_DOCUMENT_STALE_TIME_MS = 30_000
 
 /** Shape injected by the server (seconds, mirroring next.config). */
 interface StaleTimesConfig {
   /** experimental.staleTimes.dynamic (seconds). */
-  dynamic?: number;
+  dynamic?: number
   /** experimental.staleTimes.static (seconds). */
-  static?: number;
+  static?: number
 }
 
 declare global {
   interface Window {
-    __PNEXT_STALE_TIMES__?: StaleTimesConfig;
+    __PNEXT_STALE_TIMES__?: StaleTimesConfig
   }
 }
 
 function configuredStaleTimes(): StaleTimesConfig {
-  if (!process.browser && typeof window === 'undefined') return {};
-  return window.__PNEXT_STALE_TIMES__ ?? {};
+  if (!process.browser && typeof window === 'undefined') return {}
+  return window.__PNEXT_STALE_TIMES__ ?? {}
 }
 
 function windowFromSeconds(value: number | undefined, fallbackMs: number): number {
   // A configured 0 means "always fresh" (never reuse) — honour it exactly.
-  return typeof value === 'number' && Number.isFinite(value) ? value * 1000 : fallbackMs;
+  return typeof value === 'number' && Number.isFinite(value) ? value * 1000 : fallbackMs
 }
 
 /** The dynamic prefetch window in ms (config override or 30s default). */
 export function dynamicStaleTimeMs(): number {
-  return windowFromSeconds(configuredStaleTimes().dynamic, DEFAULT_DYNAMIC_STALE_TIME_MS);
+  return windowFromSeconds(configuredStaleTimes().dynamic, DEFAULT_DYNAMIC_STALE_TIME_MS)
 }
 
 /** The static prefetch window in ms (config override or 300s default). */
 export function staticStaleTimeMs(): number {
-  return windowFromSeconds(configuredStaleTimes().static, DEFAULT_STATIC_STALE_TIME_MS);
+  return windowFromSeconds(configuredStaleTimes().static, DEFAULT_STATIC_STALE_TIME_MS)
 }
 
 /**
@@ -74,11 +73,11 @@ export function staticStaleTimeMs(): number {
  * applies only to the per-segment cache.
  */
 export function staleTimeForEntryMs(options: {
-  headerStaleTimeSeconds?: number;
-  prefetchFull?: boolean;
-  static?: boolean;
-  runtime?: boolean;
-  runtimeDocument?: boolean;
+  headerStaleTimeSeconds?: number
+  prefetchFull?: boolean
+  static?: boolean
+  runtime?: boolean
+  runtimeDocument?: boolean
 }): number {
   // A NAVIGATION document of an `allow-runtime` route: its header reports the route's PUBLIC cache
   // window (the private/runtime caches resolve after the headers flushed), but the content is
@@ -89,23 +88,23 @@ export function staleTimeForEntryMs(options: {
     const headerMs =
       typeof options.headerStaleTimeSeconds === 'number'
         ? options.headerStaleTimeSeconds * 1000
-        : Number.POSITIVE_INFINITY;
-    return Math.min(headerMs, RUNTIME_DOCUMENT_STALE_TIME_MS);
+        : Number.POSITIVE_INFINITY
+    return Math.min(headerMs, RUNTIME_DOCUMENT_STALE_TIME_MS)
   }
   if ((options.static || options.runtime) && typeof options.headerStaleTimeSeconds === 'number') {
-    return options.headerStaleTimeSeconds * 1000;
+    return options.headerStaleTimeSeconds * 1000
   }
-  if (options.runtime) return dynamicStaleTimeMs();
+  if (options.runtime) return dynamicStaleTimeMs()
   if (options.prefetchFull) {
     return Math.max(
       staticStaleTimeMs(),
       typeof options.headerStaleTimeSeconds === 'number'
         ? options.headerStaleTimeSeconds * 1000
         : 0,
-    );
+    )
   }
   if (typeof options.headerStaleTimeSeconds === 'number') {
-    return options.headerStaleTimeSeconds * 1000;
+    return options.headerStaleTimeSeconds * 1000
   }
-  return dynamicStaleTimeMs();
+  return dynamicStaleTimeMs()
 }

package/src/compat/client/route-announcer.ts

@@ -3,70 +3,70 @@
 // readers announce client-side route changes that would otherwise be silent
 // (no full document load). The DOM name is Next-specific, so it lives in compat;
 // core exposes an `onNavigationCommit` hook that this module subscribes to.
-import { onNavigationCommit } from '../../api/router/events';
+import { onNavigationCommit } from '../../client/router/events'
 
-const ANNOUNCER_TAG = 'next-route-announcer';
+const ANNOUNCER_TAG = 'next-route-announcer'
 
-let announcerNode: HTMLElement | undefined;
+let announcerNode: HTMLElement | undefined
 
 // Next skips the very first render (no initial announcement): the announcer
 // starts empty and only updates on subsequent navigations. `onNavigationCommit`
 // only fires inside softNavigate, so it never runs for the hard load — but we
 // also guard against announcing an unchanged value.
-let lastAnnouncement = '';
+let lastAnnouncement = ''
 
 function ensureAnnouncer(): HTMLElement | undefined {
-  if (typeof document === 'undefined') return undefined;
-  if (announcerNode?.isConnected) return announcerNode;
+  if (typeof document === 'undefined') return undefined
+  if (announcerNode?.isConnected) return announcerNode
 
-  const existing = document.getElementsByTagName(ANNOUNCER_TAG)[0];
+  const existing = document.getElementsByTagName(ANNOUNCER_TAG)[0]
   if (existing instanceof HTMLElement && existing.shadowRoot) {
-    announcerNode = existing.shadowRoot.childNodes[0] as HTMLElement;
-    return announcerNode;
+    announcerNode = existing.shadowRoot.childNodes[0] as HTMLElement
+    return announcerNode
   }
 
-  const host = document.createElement(ANNOUNCER_TAG);
-  host.style.cssText = 'position:absolute';
-  const shadow = host.attachShadow({ mode: 'open' });
+  const host = document.createElement(ANNOUNCER_TAG)
+  host.style.cssText = 'position:absolute'
+  const shadow = host.attachShadow({ mode: 'open' })
   // A <div>, matching Next's app-router announcer exactly — a <p> here leaks
   // into shadow-piercing selectors (e.g. a test's `p` lookup racing an action
   // result) that Next's DOM never matches.
-  const live = document.createElement('div');
-  live.setAttribute('aria-live', 'assertive');
-  live.setAttribute('id', '__next-route-announcer__');
-  live.setAttribute('role', 'alert');
+  const live = document.createElement('div')
+  live.setAttribute('aria-live', 'assertive')
+  live.setAttribute('id', '__next-route-announcer__')
+  live.setAttribute('role', 'alert')
   // Visually hidden but available to assistive tech (Next's own styles).
   live.style.cssText =
-    'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal';
-  shadow.appendChild(live);
-  document.body.appendChild(host);
-  announcerNode = live;
-  return live;
+    'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal'
+  shadow.appendChild(live)
+  document.body.appendChild(host)
+  announcerNode = live
+  return live
 }
 
 // Priority order matches Next: document.title, then the first <h1>, then the
 // pathname. Read after the body swap + head sync so the new title/heading are
 // already in the DOM.
 function routeAnnouncement(): string {
-  if (document.title) return document.title;
-  const h1 = document.querySelector('h1');
-  const text = h1?.textContent?.trim();
-  if (text) return text;
-  return location.pathname;
+  if (document.title) return document.title
+  const h1 = document.querySelector('h1')
+  const text = h1?.textContent?.trim()
+  if (text) return text
+  return location.pathname
 }
 
 function announce() {
-  const node = ensureAnnouncer();
-  if (!node) return;
-  const next = routeAnnouncement();
-  if (next === lastAnnouncement) return;
-  lastAnnouncement = next;
-  node.textContent = next;
+  const node = ensureAnnouncer()
+  if (!node) return
+  const next = routeAnnouncement()
+  if (next === lastAnnouncement) return
+  lastAnnouncement = next
+  node.textContent = next
 }
 
 export function installRouteAnnouncer() {
-  if (!process.browser && typeof window === 'undefined') return;
+  if (!process.browser && typeof window === 'undefined') return
   // Create the empty announcer up front so it exists on first load with `''`.
-  ensureAnnouncer();
-  onNavigationCommit(announce);
+  ensureAnnouncer()
+  onNavigationCommit(announce)
 }

package/src/compat/client/segment-cache-policy.ts

@@ -3,7 +3,7 @@
 // stays importable - and unit-testable - without pulling the router, and the whole DOM runtime, into
 // the module graph.
 
-import type { SegmentCacheHit, SegmentCachePolicy, SegmentCacheRecord } from '../../api/router';
+import type { SegmentCacheHit, SegmentCachePolicy, SegmentCacheRecord } from '../../client/router'
 import {
   BODY_SEGMENT_PATHS,
   clearSegmentCache,
@@ -23,8 +23,8 @@ import {
   takeComposedSegment,
   takeSegment,
   type SegmentPayloadMeta,
-} from './segment-cache';
-import { resetSegmentPrefetchDedupe, scheduleAppShellPrefetch } from './segment-prefetch';
+} from './segment-cache'
+import { resetSegmentPrefetchDedupe, scheduleAppShellPrefetch } from './segment-prefetch'
 
 export function installSegmentCachePolicy(): SegmentCachePolicy {
   return {
@@ -41,7 +41,7 @@ export function installSegmentCachePolicy(): SegmentCachePolicy {
     // LAYOUT varied, the prefetch fetches `/_layout` alone instead of the whole
     // route. Inert until segment-split commit is enabled (the composition half
     // is what makes the half-fetched document paintable).
-    needsLayoutFrameOnly: (input) => needsLayoutFrameOnly(input),
+    needsLayoutFrameOnly: input => needsLayoutFrameOnly(input),
     runtimePageFrameSatisfied,
     // w9-segment-split (G2), the live half: when this URL's LAYOUT chain is
     // already cached (or already on screen, for a same-URL click), the
@@ -61,10 +61,10 @@ export function installSegmentCachePolicy(): SegmentCachePolicy {
     // set) must fall with the entries, or a revalidated route stays deduped - and stale - for its whole
     // window. evictPageSegments deliberately keeps it, since a same-URL refresh keeps layout/head dedupe.
     clear: () => {
-      clearSegmentCache();
-      resetSegmentPrefetchDedupe();
+      clearSegmentCache()
+      resetSegmentPrefetchDedupe()
     },
-  };
+  }
 }
 
 function record(input: SegmentCacheRecord): void {
@@ -73,11 +73,11 @@ function record(input: SegmentCacheRecord): void {
       ? // A navigation response / the hard-loaded document: no framed payload
         // and no vary set, so it keys on its exact URL (fix-forward 2).
         decodeDocumentSegmentMeta(input.body)
-      : decodeSegmentPayload(input.body, input.segmentPath);
+      : decodeSegmentPayload(input.body, input.segmentPath)
   // No decodable payload (a header-stripping proxy, a plain document): there is
   // no vary metadata to key on, so nothing worth caching here — the router's
   // own whole-URL caches already hold it.
-  if (!decoded) return;
+  if (!decoded) return
   // App Shells (fix-forward 5): a per-URL static prerender of a params-reading
   // route also primes the route's SHARED shell, so navigations to its other
   // params paint instantly. No-op unless experimental.appShells is on.
@@ -88,7 +88,7 @@ function record(input: SegmentCacheRecord): void {
     static: input.static,
     complete: input.complete,
     runtime: input.runtime,
-  });
+  })
   // App Shells: the per-URL prerender carried the route's shared shell. File it
   // at the route's fallback vary path (empty vary = every param value) as a
   // SHELL — it paints, but a navigation still fetches the per-URL remainder.
@@ -105,7 +105,7 @@ function record(input: SegmentCacheRecord): void {
       vary: [],
       route: decoded.shell.route,
       params: decoded.params,
-    });
+    })
   }
   recordSegment({
     segmentPath: input.segmentPath,
@@ -126,34 +126,34 @@ function record(input: SegmentCacheRecord): void {
     ...(decoded.staticSiblings ? { staticSiblings: decoded.staticSiblings } : {}),
     route: decoded.route,
     params: decoded.params,
-  });
+  })
 }
 
 function take(input: {
-  pathname: string;
-  search: string;
-  segmentPath: string;
+  pathname: string
+  search: string
+  segmentPath: string
 }): SegmentCacheHit | null {
-  const hit = takeSegment(input);
+  const hit = takeSegment(input)
   if (hit) {
     return {
       html: hit.html,
       networkFree: hit.networkFree,
       prefetchSatisfied: hit.prefetchSatisfied,
-    };
+    }
   }
   // w9-segment-split: the whole-document entry missed because ONE of the two
   // frames varied. Compose the cached layout + page frames instead of going to
   // the network for both. No-op until segment-split commit is enabled.
   if (!BODY_SEGMENT_PATHS.includes(input.segmentPath as (typeof BODY_SEGMENT_PATHS)[number])) {
-    return null;
+    return null
   }
-  const composed = takeComposedSegment({ pathname: input.pathname, search: input.search });
+  const composed = takeComposedSegment({ pathname: input.pathname, search: input.search })
   return composed
     ? {
         html: composed.html,
         networkFree: composed.networkFree,
         prefetchSatisfied: composed.prefetchSatisfied,
       }
-    : null;
+    : null
 }