@wular/pnext 0.0.3 → 0.0.6

package/src/compat/next/root-params.ts

@@ -1,49 +1,49 @@
-import { currentParams, currentRequest, getWorkUnit } from '../../request/context';
+import { currentParams, currentRequest, getWorkUnit } from '../../request/context'
 import {
   cacheComponents,
   hangingPromise,
   isPrerendering,
   isRuntimePrefetchPrerender,
-} from '../../ppr';
-import { currentRenderCacheMeta, insideUnstableCacheProducer } from '../cache/revalidate';
-import { insideUseCacheProducer, recordUseCacheRootParamRead } from '../cache/use-cache';
-import { generateStaticParamsScope } from '../static-params';
-import { accumulateRootVaryParam } from '../segment/vary-params';
+} from '../../render/ppr'
+import { currentRenderCacheMeta, insideUnstableCacheProducer } from '../cache/revalidate'
+import { insideUseCacheProducer, recordUseCacheRootParamRead } from '../cache/use-cache'
+import { generateStaticParamsScope } from '../static-params'
+import { accumulateRootVaryParam } from '../segment/vary-params'
 
 function currentRoutePattern(): string {
-  let pathname: string;
+  let pathname: string
   try {
-    pathname = new URL(currentRequest()?.url ?? '').pathname;
+    pathname = new URL(currentRequest()?.url ?? '').pathname
   } catch {
-    return '';
+    return ''
   }
-  const paramNamesByValue = new Map<string, string>();
+  const paramNamesByValue = new Map<string, string>()
   for (const [name, value] of Object.entries(currentParams())) {
-    if (typeof value === 'string') paramNamesByValue.set(value, name);
+    if (typeof value === 'string') paramNamesByValue.set(value, name)
   }
   return pathname
     .split('/')
     .map(segment => {
       try {
-        const name = paramNamesByValue.get(decodeURIComponent(segment));
-        return name ? `[${name}]` : segment;
+        const name = paramNamesByValue.get(decodeURIComponent(segment))
+        return name ? `[${name}]` : segment
       } catch {
-        return segment;
+        return segment
       }
     })
-    .join('/');
+    .join('/')
 }
 
 function rootParamContextError(name: string): Error | undefined {
-  const unit = getWorkUnit();
+  const unit = getWorkUnit()
   // Keep the module specifier out of a literal source string: the static
   // compat-import rewrite must not rewrite this user-facing diagnostic.
-  const specifier = ['next', 'root-params'].join('/');
-  const call = `\`import('${specifier}').${name}()\``;
-  const route = currentRoutePattern();
+  const specifier = ['next', 'root-params'].join('/')
+  const call = `\`import('${specifier}').${name}()\``
+  const route = currentRoutePattern()
 
-  const inUseCache = insideUseCacheProducer();
-  const inUnstableCache = insideUnstableCacheProducer();
+  const inUseCache = insideUseCacheProducer()
+  const inUnstableCache = insideUnstableCacheProducer()
 
   if (inUseCache && inUnstableCache) {
     return Object.assign(
@@ -51,12 +51,12 @@ function rootParamContextError(name: string): Error | undefined {
         `Route ${route} used ${call} inside \`"use cache"\` nested within \`unstable_cache\`. Root params are not available in this context.`,
       ),
       { digest: 'E1140' },
-    );
+    )
   }
 
   if (inUseCache) {
-    recordUseCacheRootParamRead(name);
-    return undefined;
+    recordUseCacheRootParamRead(name)
+    return undefined
   }
 
   if (inUnstableCache) {
@@ -65,52 +65,52 @@ function rootParamContextError(name: string): Error | undefined {
         `Route ${route} used ${call} inside \`unstable_cache\`. This is not supported. Use \`"use cache"\` instead.`,
       ),
       { digest: 'E1141' },
-    );
+    )
   }
 
-  if (!unit) return undefined;
+  if (!unit) return undefined
 
   if (unit.phase === 'action') {
     return new Error(
       `${call} was used inside a Server Action. This is not supported. ` +
         `Functions from '${specifier}' can only be called in the context of a route.`,
-    );
+    )
   }
 
   if (unit.phase !== 'after' && unit.routeKind === 'route-handler') {
     return new Error(
       `Route ${route} used ${call} inside a Route Handler. ` +
         `Support for this API in Route Handlers is planned for a future version of Next.js.`,
-    );
+    )
   }
 
-  return undefined;
+  return undefined
 }
 
 export function rootParam<T = string | string[] | undefined>(name: string): Promise<T> {
   // Inside generateStaticParams, a root param resolves only when a PARENT
   // generateStaticParams already provided it; reading the param in the very
   // call that defines it is a build error (Next E394).
-  const gsp = generateStaticParamsScope();
+  const gsp = generateStaticParamsScope()
   if (gsp) {
-    if (name in gsp.provided) return Promise.resolve(gsp.provided[name] as T);
+    if (name in gsp.provided) return Promise.resolve(gsp.provided[name] as T)
     const route = (currentRenderCacheMeta()?.route ?? '')
       .replace(/:\.\.\.([^/*]+)\*?/g, '[...$1]')
       .replace(/:([^/*]+)\*/g, '[...$1]')
-      .replace(/:([^/*]+)/g, '[$1]');
+      .replace(/:([^/*]+)/g, '[$1]')
     return Promise.reject(
       new Error(
         `Route ${route} used \`import('${['next', 'root-params'].join('/')}').${name}()\` inside \`generateStaticParams\`, ` +
           `but the \`${name}\` parameter was not provided by a parent \`generateStaticParams\`. ` +
           `In \`generateStaticParams\`, root params are only available for segments nested below the segment that provides them.`,
       ),
-    );
+    )
   }
   // Segment-M2: a root param read varies EVERY segment of the response (Next
   // merges the rootParams set into each segment accumulator).
-  accumulateRootVaryParam(name);
-  const error = rootParamContextError(name);
-  if (error) return Promise.reject(error);
+  accumulateRootVaryParam(name)
+  const error = rootParamContextError(name)
+  if (error) return Promise.reject(error)
   // A runtime-prefetch prerender renders against the REAL sampled request, so root params are concrete
   // there (root params are always available in a static prerender, so a runtime prefetch has them too).
   // Hanging them would postpone the ROOT LAYOUT itself - the whole document, not a boundary - so the
@@ -121,22 +121,22 @@ export function rootParam<T = string | string[] | undefined>(name: string): Prom
     isPrerendering() &&
     !isRuntimePrefetchPrerender()
   ) {
-    return hangingPromise<T>(`rootParam(${name})`);
+    return hangingPromise<T>(`rootParam(${name})`)
   }
-  const value = currentParams()[name];
-  return Promise.resolve((Array.isArray(value) && value.length === 0 ? undefined : value) as T);
+  const value = currentParams()[name]
+  return Promise.resolve((Array.isArray(value) && value.length === 0 ? undefined : value) as T)
 }
 
 const rootParamsModule = new Proxy(
   {},
   {
     get(_target, prop: string | symbol): unknown {
-      if (typeof prop !== 'string') return undefined;
-      if (prop === '__esModule') return true;
-      if (prop === 'default') return undefined;
-      return () => rootParam(prop);
+      if (typeof prop !== 'string') return undefined
+      if (prop === '__esModule') return true
+      if (prop === 'default') return undefined
+      return () => rootParam(prop)
     },
   },
-) as Record<string, () => Promise<unknown>>;
+) as Record<string, () => Promise<unknown>>
 
-export default rootParamsModule;
+export default rootParamsModule

package/src/compat/next/{optimistic-route-state.ts → route-state.ts}

@@ -10,30 +10,30 @@
 // URLs, and page-less intermediate directories still surface as static children without leaking their
 // nested names.
 
-import type { RouteManifestEntry, RouteParamValue } from '../../types';
-import { getRequestRuntime } from '../../routing/request-runtime';
-import { getNextConfig } from './config-loader';
+import type { RouteManifestEntry, RouteParamValue } from '../../types'
+import { getRequestRuntime } from '../../routing/request-environment'
+import { getNextConfig } from './config-loader'
 
 interface RouteState {
-  route: string;
-  params: Record<string, RouteParamValue>;
-  catchAllOptional?: boolean;
-  staticChildren?: string[];
-  staticChildrenBySegment?: Record<string, string[]>;
-  prefetchKind?: 'shell' | 'eager';
+  route: string
+  params: Record<string, RouteParamValue>
+  catchAllOptional?: boolean
+  staticChildren?: string[]
+  staticChildrenBySegment?: Record<string, string[]>
+  prefetchKind?: 'shell' | 'eager'
   /**
    * `prefetch = 'allow-runtime'`: the route's shell is RUNTIME-prefetched (request-sampled,
    * param-derived), so unlike a static `partial` shell it is NOT shared across params - every URL of the
    * route needs its own prefetch.
    */
-  runtimePrefetch?: boolean;
+  runtimePrefetch?: boolean
   /**
    * The vary set of the BAKED SHELL these bytes came from (renderer's
    * `bakedShellPageVary`). Passed straight through by the spread below: the
    * client segment cache reads it off a hard-loaded document to key that
    * document's static stage across the route's params.
    */
-  pageVary?: string[];
+  pageVary?: string[]
 }
 
 /**
@@ -42,12 +42,12 @@ interface RouteState {
  * align with the pattern the client trie matches against - and no `[x]` placeholder ever reaches a body.
  */
 function publicSegments(route: string): string[] {
-  if (route === 'index' || route === '/') return [];
-  return route.split('/').filter(Boolean);
+  if (route === 'index' || route === '/') return []
+  return route.split('/').filter(Boolean)
 }
 
 function isDynamicSegment(segment: string): boolean {
-  return segment.startsWith(':');
+  return segment.startsWith(':')
 }
 
 /**
@@ -62,9 +62,9 @@ export function staticSiblingNames(
   pattern: readonly string[],
 ): string[] {
   for (let index = pattern.length - 1; index >= 0; index--) {
-    if (isDynamicSegment(pattern[index]!)) return staticSiblingNamesAt(routes, pattern, index);
+    if (isDynamicSegment(pattern[index]!)) return staticSiblingNamesAt(routes, pattern, index)
   }
-  return [];
+  return []
 }
 
 /** Literal static siblings for every dynamic level in a route prediction. */
@@ -72,15 +72,15 @@ export function staticSiblingNamesBySegment(
   routes: readonly Pick<RouteManifestEntry, 'route' | 'kind' | 'interception'>[],
   pattern: readonly string[],
 ): Record<string, string[]> {
-  const result: Record<string, string[]> = {};
+  const result: Record<string, string[]> = {}
   for (let index = 0; index < pattern.length; index++) {
-    if (!isDynamicSegment(pattern[index]!)) continue;
-    const siblings = staticSiblingNamesAt(routes, pattern, index);
+    if (!isDynamicSegment(pattern[index]!)) continue
+    const siblings = staticSiblingNamesAt(routes, pattern, index)
     // An empty array is meaningful: unlike an absent entry, it says this
     // production route table knows there are no literal siblings here.
-    result[String(index)] = siblings;
+    result[String(index)] = siblings
   }
-  return result;
+  return result
 }
 
 function staticSiblingNamesAt(
@@ -88,27 +88,27 @@ function staticSiblingNamesAt(
   pattern: readonly string[],
   level: number,
 ): string[] {
-  if (!isDynamicSegment(pattern[level]!)) return [];
-  const names = new Set<string>();
+  if (!isDynamicSegment(pattern[level]!)) return []
+  const names = new Set<string>()
   for (const route of routes) {
-    if (route.kind !== 'page' || route.interception) continue;
-    const segments = publicSegments(route.route);
-    if (segments.length <= level) continue;
-    let compatible = true;
+    if (route.kind !== 'page' || route.interception) continue
+    const segments = publicSegments(route.route)
+    if (segments.length <= level) continue
+    let compatible = true
     for (let index = 0; index < level; index++) {
-      const own = pattern[index]!;
-      const other = segments[index]!;
-      if (isDynamicSegment(own) || isDynamicSegment(other)) continue;
+      const own = pattern[index]!
+      const other = segments[index]!
+      if (isDynamicSegment(own) || isDynamicSegment(other)) continue
       if (own !== other) {
-        compatible = false;
-        break;
+        compatible = false
+        break
       }
     }
-    if (!compatible) continue;
-    const name = segments[level]!;
-    if (!isDynamicSegment(name)) names.add(name);
+    if (!compatible) continue
+    const name = segments[level]!
+    if (!isDynamicSegment(name)) names.add(name)
   }
-  return [...names].sort();
+  return [...names].sort()
 }
 
 /** True when the build enumerated exactly this param set for the route. */
@@ -116,18 +116,18 @@ function paramsPrerendered(
   route: Pick<RouteManifestEntry, 'prerenderedParams' | 'params'>,
   params: Record<string, RouteParamValue>,
 ): boolean {
-  const sets = route.prerenderedParams;
-  if (!sets?.length) return false;
+  const sets = route.prerenderedParams
+  if (!sets?.length) return false
   // A PPR SUB-shell carries only the params the build made concrete (the rest
   // are still holes), so its state is not the full URL's — never "prerendered".
-  if (Object.keys(params).length !== (route.params ?? []).length) return false;
+  if (Object.keys(params).length !== (route.params ?? []).length) return false
   return sets.some(set => {
-    const names = Object.keys(set);
+    const names = Object.keys(set)
     return (
       names.length === Object.keys(params).length &&
       names.every(name => String(set[name]) === String(params[name]))
-    );
-  });
+    )
+  })
 }
 
 /**
@@ -151,23 +151,23 @@ export function nextClientRouteState(
   >,
   state: RouteState,
 ): RouteState {
-  const pattern = state.route.split('/').filter(Boolean);
-  const routes = getRequestRuntime()?.routes;
-  if (!routes) return state;
-  const staticChildrenBySegment = staticSiblingNamesBySegment(routes, pattern);
-  const staticChildren = staticSiblingNames(routes, pattern);
+  const pattern = state.route.split('/').filter(Boolean)
+  const routes = getRequestRuntime()?.routes
+  if (!routes) return state
+  const staticChildrenBySegment = staticSiblingNamesBySegment(routes, pattern)
+  const staticChildren = staticSiblingNames(routes, pattern)
   // Global `partialPrefetching: 'unstable_eager'` makes every route without a
   // per-segment `prefetch` export eager (the App Shells Speculative-skip does
   // not apply anywhere); a per-segment export still wins.
   const globalEager =
-    (getNextConfig() as { partialPrefetching?: unknown }).partialPrefetching === 'unstable_eager';
-  const declared = route.segmentConfig?.prefetch;
+    (getNextConfig() as { partialPrefetching?: unknown }).partialPrefetching === 'unstable_eager'
+  const declared = route.segmentConfig?.prefetch
   // `generateStaticParams` only makes a route eager for the param sets it actually enumerated. When
   // THIS URL's params were not among them and the route has a `loading` boundary, its page is dynamic
   // here - the server answers the default prefetch with the loading shell, and calling it eager would
   // escalate the reveal to a FULL prefetch that fetches the dynamic body and erases the loading state.
   const partiallyEnumerated =
-    route.stream?.hasLoadingBoundary === true && !paramsPrerendered(route, state.params);
+    route.stream?.hasLoadingBoundary === true && !paramsPrerendered(route, state.params)
   const prefetchKind =
     declared === 'unstable_eager' ||
     (declared === undefined &&
@@ -175,7 +175,7 @@ export function nextClientRouteState(
       ? 'eager'
       : declared === 'allow-runtime' || declared === 'partial'
         ? 'shell'
-        : undefined;
+        : undefined
   return {
     ...state,
     ...(staticChildren.length > 0 ? { staticChildren } : {}),
@@ -184,5 +184,5 @@ export function nextClientRouteState(
     // Only `allow-runtime` shells are request-sampled per URL; a `partial` shell
     // is a static prerender the whole route shares.
     ...(declared === 'allow-runtime' ? { runtimePrefetch: true } : {}),
-  };
+  }
 }

package/src/compat/next/router.cjs

@@ -44,6 +44,8 @@ exports.Router = { events }
 exports.default = exports.Router
 exports.useRouter = () => currentRouter()
 /** @param {(props: object) => unknown} Component */
-exports.withRouter = Component =>
+exports.withRouter =
+  Component =>
   /** @param {object} props */
-  props => Component({ ...props, router: currentRouter() })
+  props =>
+    Component({ ...props, router: currentRouter() })

package/src/compat/next/router.ts

@@ -1,5 +1,5 @@
-import { useEffect, useState } from 'preact/hooks';
-import { blockJavascriptUrl } from '../../api/router';
+import { useEffect, useState } from 'preact/hooks'
+import { blockJavascriptUrl } from '../../client/router'
 
 /**
  * Pages-router surface, present so shared components importing next/router
@@ -7,38 +7,38 @@ import { blockJavascriptUrl } from '../../api/router';
  * where it can and no-ops where pages-router concepts don't exist.
  */
 
-type RouterEventHandler = (...args: unknown[]) => void;
+type RouterEventHandler = (...args: unknown[]) => void
 
-const noop = () => undefined;
+const noop = () => undefined
 
 const routerEvents = {
   on: noop as (event: string, handler: RouterEventHandler) => void,
   off: noop as (event: string, handler: RouterEventHandler) => void,
   emit: noop as (event: string, ...args: unknown[]) => void,
-};
+}
 
 export interface PagesRouter {
-  pathname: string;
-  route: string;
-  query: Record<string, string | string[]>;
-  asPath: string;
-  basePath: string;
-  isReady: boolean;
-  isFallback: boolean;
-  isPreview: boolean;
-  events: typeof routerEvents;
-  push(url: string): Promise<boolean>;
-  replace(url: string): Promise<boolean>;
-  prefetch(url: string): Promise<void>;
-  back(): void;
-  forward(): void;
-  reload(): void;
+  pathname: string
+  route: string
+  query: Record<string, string | string[]>
+  asPath: string
+  basePath: string
+  isReady: boolean
+  isFallback: boolean
+  isPreview: boolean
+  events: typeof routerEvents
+  push(url: string): Promise<boolean>
+  replace(url: string): Promise<boolean>
+  prefetch(url: string): Promise<void>
+  back(): void
+  forward(): void
+  reload(): void
 }
 
 interface PagesRouterState {
-  pathname?: string;
-  asPath?: string;
-  query?: Record<string, string | string[]>;
+  pathname?: string
+  asPath?: string
+  query?: Record<string, string | string[]>
 }
 
 // The pages-router state the materialized page wrapper emits: SSR reads the
@@ -49,33 +49,32 @@ function pagesRouterState(browser: boolean): PagesRouterState | undefined {
   if (!browser) {
     const storage = (globalThis as Record<PropertyKey, unknown>)[
       Symbol.for('pnext.requestStorage')
-    ] as { getStore(): Record<PropertyKey, unknown> | undefined } | undefined;
+    ] as { getStore(): Record<PropertyKey, unknown> | undefined } | undefined
     return storage?.getStore?.()?.[Symbol.for('pnext.pagesRouterState')] as
-      | PagesRouterState
-      | undefined;
+      PagesRouterState | undefined
   }
-  const node = document.getElementById('__PNEXT_PAGES_DATA__');
-  if (!node?.textContent) return undefined;
+  const node = document.getElementById('__PNEXT_PAGES_DATA__')
+  if (!node?.textContent) return undefined
   try {
-    return JSON.parse(node.textContent) as PagesRouterState;
+    return JSON.parse(node.textContent) as PagesRouterState
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 function browserQuery(url: URL): Record<string, string> {
-  const query: Record<string, string> = {};
+  const query: Record<string, string> = {}
   for (const [key, value] of url.searchParams) {
-    if (key !== '_rsc') query[key] = value;
+    if (key !== '_rsc') query[key] = value
   }
-  return query;
+  return query
 }
 
 function currentRouter(ready: boolean): PagesRouter {
-  const browser = process.browser || typeof window !== 'undefined';
-  const url = browser ? new URL(window.location.href) : undefined;
-  const state = pagesRouterState(browser);
-  const pathname = state?.pathname ?? url?.pathname ?? '/';
+  const browser = process.browser || typeof window !== 'undefined'
+  const url = browser ? new URL(window.location.href) : undefined
+  const state = pagesRouterState(browser)
+  const pathname = state?.pathname ?? url?.pathname ?? '/'
   return {
     pathname,
     route: pathname,
@@ -83,9 +82,7 @@ function currentRouter(ready: boolean): PagesRouter {
     // server-computed query (they are the live values after shallow/query-only
     // history updates); on the server the state already merged them. The
     // router-fetch cache key (`_rsc`) is never part of the page's query.
-    query: url
-      ? { ...(state?.query ?? {}), ...browserQuery(url) }
-      : (state?.query ?? {}),
+    query: url ? { ...(state?.query ?? {}), ...browserQuery(url) } : (state?.query ?? {}),
     asPath: url ? `${url.pathname}${url.search}` : (state?.asPath ?? '/'),
     basePath: '',
     isReady: browser && ready,
@@ -93,51 +90,51 @@ function currentRouter(ready: boolean): PagesRouter {
     isPreview: false,
     events: routerEvents,
     push(target: string) {
-      if (blockJavascriptUrl(target)) return Promise.resolve(false);
-      if (browser) window.location.href = target;
-      return Promise.resolve(true);
+      if (blockJavascriptUrl(target)) return Promise.resolve(false)
+      if (browser) window.location.href = target
+      return Promise.resolve(true)
     },
     replace(target: string) {
-      if (blockJavascriptUrl(target)) return Promise.resolve(false);
-      if (browser) window.location.replace(target);
-      return Promise.resolve(true);
+      if (blockJavascriptUrl(target)) return Promise.resolve(false)
+      if (browser) window.location.replace(target)
+      return Promise.resolve(true)
     },
     prefetch(target: string) {
-      blockJavascriptUrl(target);
-      return Promise.resolve();
+      blockJavascriptUrl(target)
+      return Promise.resolve()
     },
     back() {
-      if (browser) window.history.back();
+      if (browser) window.history.back()
     },
     forward() {
-      if (browser) window.history.forward();
+      if (browser) window.history.forward()
     },
     reload() {
-      if (browser) window.location.reload();
+      if (browser) window.location.reload()
     },
-  };
+  }
 }
 
 // Next semantics: isReady is FALSE during the hydration render (matching the SSR markup - preact
 // hydrate adopts DOM without patching mismatches, so a true-at-hydration value would never reach
 // attributes) and flips via a post-hydration re-render. Once flipped, later mounts see true immediately.
-let pagesRouterReady = false;
+let pagesRouterReady = false
 
 export function useRouter(): PagesRouter {
-  const [ready, setReady] = useState(pagesRouterReady);
+  const [ready, setReady] = useState(pagesRouterReady)
   useEffect(() => {
-    pagesRouterReady = true;
-    setReady(true);
-  }, []);
-  return currentRouter(ready);
+    pagesRouterReady = true
+    setReady(true)
+  }, [])
+  return currentRouter(ready)
 }
 
-export const Router = { events: routerEvents };
-export default Router;
+export const Router = { events: routerEvents }
+export default Router
 
 export function withRouter<Props extends { router?: PagesRouter }>(
   Component: (props: Props) => unknown,
 ) {
   return (props: Omit<Props, 'router'>) =>
-    Component({ ...props, router: currentRouter(pagesRouterReady) } as Props);
+    Component({ ...props, router: currentRouter(pagesRouterReady) } as Props)
 }