@wular/pnext 0.0.4 → 0.0.6

package/src/compat/cache-control.ts

@@ -1,83 +1,84 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { nextCompatEnabled } from '../compat';
-import type { ResolvedConfig } from '../config';
-import type { ResponseFinalizer, ResponseFinalizerContext } from '../extensions';
-import { getNextConfig } from './next/config-loader';
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { nextCompatEnabled } from '../compat/aliases'
+import type { ResolvedConfig } from '../config'
+import type { ResponseFinalizer, ResponseFinalizerContext } from '../extensions'
+import { getNextConfig } from './next/config-loader'
+import { escapeRegex } from '../utils/code'
 import {
   evaluateConditions,
   parseConditions,
   substitute,
   type RewriteCondition,
   type RewriteRequestContext,
-} from './next/rewrites';
+} from './next/rewrites'
 
-const DEFAULT_EXPIRE_TIME = 31536000;
+const DEFAULT_EXPIRE_TIME = 31536000
 
 interface HeaderRule {
-  regex: RegExp;
-  paramNames: string[];
-  headers: [string, string][];
-  has: RewriteCondition[];
-  missing: RewriteCondition[];
+  regex: RegExp
+  paramNames: string[]
+  headers: [string, string][]
+  has: RewriteCondition[]
+  missing: RewriteCondition[]
 }
 
 interface HeaderEntry {
-  source?: string;
-  headers?: unknown;
-  has?: unknown;
-  missing?: unknown;
+  source?: string
+  headers?: unknown
+  has?: unknown
+  missing?: unknown
 }
 
 interface RevalidateRule {
-  regex: RegExp;
-  revalidateSeconds: number;
+  regex: RegExp
+  revalidateSeconds: number
 }
 
 interface ConfigHeader {
-  key?: unknown;
-  value?: unknown;
+  key?: unknown
+  value?: unknown
 }
 
 export function cacheControlFinalizers(config: ResolvedConfig): ResponseFinalizer[] {
-  if (!nextCompatEnabled(config)) return [];
+  if (!nextCompatEnabled(config)) return []
 
-  let rules: Promise<HeaderRule[]> | undefined;
-  let pagesRevalidateRules: RevalidateRule[] | undefined;
+  let rules: Promise<HeaderRule[]> | undefined
+  let pagesRevalidateRules: RevalidateRule[] | undefined
   const finalizer: ResponseFinalizer = async ctx => {
-    rules ??= loadHeaderRules();
-    applyConfigHeaders(ctx, await rules);
-    pagesRevalidateRules ??= loadPagesRevalidateRules(config.root);
-    applyDefaultIsrHeader(ctx, pagesRevalidateRules);
-  };
-  return [finalizer];
+    rules ??= loadHeaderRules()
+    applyConfigHeaders(ctx, await rules)
+    pagesRevalidateRules ??= loadPagesRevalidateRules(config.root)
+    applyDefaultIsrHeader(ctx, pagesRevalidateRules)
+  }
+  return [finalizer]
 }
 
 async function loadHeaderRules(): Promise<HeaderRule[]> {
-  const producer = getNextConfig().headers;
-  if (typeof producer !== 'function') return [];
+  const producer = getNextConfig().headers
+  if (typeof producer !== 'function') return []
 
-  let entries: unknown;
+  let entries: unknown
   try {
-    entries = await (producer as () => unknown)();
+    entries = await (producer as () => unknown)()
   } catch {
-    return [];
+    return []
   }
-  if (!Array.isArray(entries)) return [];
+  if (!Array.isArray(entries)) return []
 
-  const rules: HeaderRule[] = [];
+  const rules: HeaderRule[] = []
   for (const entry of entries as HeaderEntry[]) {
-    if (!entry?.source || !Array.isArray(entry.headers)) continue;
-    const compiled = compileHeaderSource(entry.source);
-    if (!compiled) continue;
-    const has = parseConditions(entry.has);
-    const missing = parseConditions(entry.missing);
-    if (!has || !missing) continue;
-    const headers = headerPairs(entry.headers);
-    if (headers.length === 0) continue;
-    rules.push({ ...compiled, headers, has, missing });
+    if (!entry?.source || !Array.isArray(entry.headers)) continue
+    const compiled = compileHeaderSource(entry.source)
+    if (!compiled) continue
+    const has = parseConditions(entry.has)
+    const missing = parseConditions(entry.missing)
+    if (!has || !missing) continue
+    const headers = headerPairs(entry.headers)
+    if (headers.length === 0) continue
+    rules.push({ ...compiled, headers, has, missing })
   }
-  return rules;
+  return rules
 }
 
 /**
@@ -87,86 +88,86 @@ async function loadHeaderRules(): Promise<HeaderRule[]> {
  * path-to-regexp treats those as literals. Raw regex bodies still only appear inside `:param(...)`.
  */
 function compileHeaderSource(source: string): { regex: RegExp; paramNames: string[] } | null {
-  const paramNames: string[] = [];
-  const parts: string[] = [];
+  const paramNames: string[] = []
+  const parts: string[] = []
   for (const segment of source.split('/').filter(Boolean)) {
-    const custom = /^:([A-Za-z_$][\w$]*)\((.*)\)$/.exec(segment);
+    const custom = /^:([A-Za-z_$][\w$]*)\((.*)\)$/.exec(segment)
     if (custom?.[1] !== undefined && custom[2] !== undefined) {
-      paramNames.push(custom[1]);
-      parts.push(`(${custom[2]})`);
-      continue;
+      paramNames.push(custom[1])
+      parts.push(`(${custom[2]})`)
+      continue
     }
-    const catchAll = /^:([A-Za-z_$][\w$]*)[*+]$/.exec(segment);
+    const catchAll = /^:([A-Za-z_$][\w$]*)[*+]$/.exec(segment)
     if (catchAll?.[1]) {
-      paramNames.push(catchAll[1]);
-      parts.push('(.*)');
-      continue;
+      paramNames.push(catchAll[1])
+      parts.push('(.*)')
+      continue
     }
-    const optional = /^:([A-Za-z_$][\w$]*)\?$/.exec(segment);
+    const optional = /^:([A-Za-z_$][\w$]*)\?$/.exec(segment)
     if (optional?.[1]) {
-      paramNames.push(optional[1]);
-      parts.push('([^/]*)');
-      continue;
+      paramNames.push(optional[1])
+      parts.push('([^/]*)')
+      continue
     }
-    const param = /^:([A-Za-z_$][\w$]*)$/.exec(segment);
+    const param = /^:([A-Za-z_$][\w$]*)$/.exec(segment)
     if (param?.[1]) {
-      paramNames.push(param[1]);
-      parts.push('([^/]+)');
-      continue;
+      paramNames.push(param[1])
+      parts.push('([^/]+)')
+      continue
     }
     // Plain literal segment: escape regex-special characters so `.` etc. match
     // literally rather than acting as regex metacharacters.
-    parts.push(segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    parts.push(segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
   }
-  return { regex: new RegExp(`^/${parts.join('/')}/?$`), paramNames };
+  return { regex: new RegExp(`^/${parts.join('/')}/?$`), paramNames }
 }
 
 function headerPairs(headers: unknown[]): [string, string][] {
-  const pairs: [string, string][] = [];
+  const pairs: [string, string][] = []
   for (const header of headers as ConfigHeader[]) {
-    if (typeof header?.key !== 'string' || typeof header.value !== 'string') continue;
-    pairs.push([header.key, header.value]);
+    if (typeof header?.key !== 'string' || typeof header.value !== 'string') continue
+    pairs.push([header.key, header.value])
   }
-  return pairs;
+  return pairs
 }
 
 function applyConfigHeaders(ctx: ResponseFinalizerContext, rules: readonly HeaderRule[]): void {
-  if (rules.length === 0) return;
-  const url = ctx.request.url;
+  if (rules.length === 0) return
+  const url = ctx.request.url
   const requestCtx: RewriteRequestContext = {
     host: url.host,
     headers: ctx.request.headers,
     cookies: parseCookieHeader(ctx.request.headers.get('cookie')),
     query: url.searchParams,
-  };
+  }
 
   // Config `Set-Cookie` headers must be appended (each entry is its own header,
   // never overwriting) and must precede the response's own Set-Cookie headers —
   // Next applies config headers at the router layer before the route's own
   // cookies (set-cookies suite asserts [...nextConfigHeaders, ...cookies]).
-  const configSetCookies: string[] = [];
+  const configSetCookies: string[] = []
   for (const rule of rules) {
-    const match = rule.regex.exec(url.pathname);
-    if (!match) continue;
-    const params: Record<string, string> = {};
+    const match = rule.regex.exec(url.pathname)
+    if (!match) continue
+    const params: Record<string, string> = {}
     rule.paramNames.forEach((name, index) => {
-      params[name] = match[index + 1] ?? '';
-    });
-    const conditionParams = evaluateConditions(rule, requestCtx);
-    if (conditionParams === null) continue;
-    Object.assign(params, conditionParams);
+      params[name] = match[index + 1] ?? ''
+    })
+    const conditionParams = evaluateConditions(rule, requestCtx)
+    if (conditionParams === null) continue
+    Object.assign(params, conditionParams)
     for (const [key, value] of rule.headers) {
-      const resolved = substitute(value, params).pathname;
-      if (key.toLowerCase() === 'set-cookie') configSetCookies.push(resolved);
-      else ctx.headers.set(key, resolved);
+      const resolved = substitute(value, params).pathname
+      if (key.toLowerCase() === 'set-cookie') configSetCookies.push(resolved)
+      else ctx.headers.set(key, resolved)
     }
   }
   if (configSetCookies.length > 0) {
     const existing =
-      (ctx.headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? [];
-    ctx.headers.delete('set-cookie');
-    for (const cookie of configSetCookies) ctx.headers.append('set-cookie', cookie);
-    for (const cookie of existing) ctx.headers.append('set-cookie', cookie);
+      (ctx.headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? []
+    ctx.headers.delete('set-cookie')
+    for (const cookie of configSetCookies) ctx.headers.append('set-cookie', cookie)
+    for (const cookie of existing) ctx.headers.append('set-cookie', cookie)
   }
 }
 
@@ -176,94 +177,91 @@ function applyDefaultIsrHeader(
 ): void {
   const pagesRevalidateSeconds = pagesRevalidateRules.find(rule =>
     rule.regex.test(ctx.request.url.pathname),
-  )?.revalidateSeconds;
-  const existing = ctx.headers.get('cache-control');
+  )?.revalidateSeconds
+  const existing = ctx.headers.get('cache-control')
   // An RSC payload is never browser-cacheable: the flight response embeds the
   // render's data, so a cached copy replays stale content after a revalidation
   // (actions "should invalidate client cache when path is revalidated"). Match
   // the RSC document path in register-segment, which stamps `private, no-store`.
   if (isRscPayload(ctx)) {
     if (existing === null || isBrowserCacheable(existing)) {
-      ctx.headers.set('cache-control', 'private, no-store');
+      ctx.headers.set('cache-control', 'private, no-store')
     }
-    return;
+    return
   }
-  if (existing && (pagesRevalidateSeconds === undefined || existing !== 'no-store')) return;
+  if (existing && (pagesRevalidateSeconds === undefined || existing !== 'no-store')) return
   const revalidateSeconds =
-    pagesRevalidateSeconds ??
-    (ctx.routeMode === 'isr' ? ctx.hints?.revalidateSeconds : undefined);
-  if (typeof revalidateSeconds !== 'number' || revalidateSeconds <= 0) return;
-  const config = getNextConfig();
-  const expireTime =
-    typeof config.expireTime === 'number' ? config.expireTime : DEFAULT_EXPIRE_TIME;
-  const swr = Math.max(0, expireTime - revalidateSeconds);
-  ctx.headers.set('cache-control', `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`);
+    pagesRevalidateSeconds ?? (ctx.routeMode === 'isr' ? ctx.hints?.revalidateSeconds : undefined)
+  if (typeof revalidateSeconds !== 'number' || revalidateSeconds <= 0) return
+  const config = getNextConfig()
+  const expireTime = typeof config.expireTime === 'number' ? config.expireTime : DEFAULT_EXPIRE_TIME
+  const swr = Math.max(0, expireTime - revalidateSeconds)
+  ctx.headers.set('cache-control', `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`)
 }
 
 /** A flight response: core's `data` route kind, or an `_rsc` cache-busted URL. */
 function isRscPayload(ctx: ResponseFinalizerContext): boolean {
-  return ctx.routeKind === 'data' || ctx.request.url.searchParams.has('_rsc');
+  return ctx.routeKind === 'data' || ctx.request.url.searchParams.has('_rsc')
 }
 
 /** True for a cache-control a browser may reuse (no `no-store`/`no-cache`). */
 function isBrowserCacheable(value: string): boolean {
-  return !/\bno-store\b|\bno-cache\b/i.test(value);
+  return !/\bno-store\b|\bno-cache\b/i.test(value)
 }
 
 function loadPagesRevalidateRules(root: string): RevalidateRule[] {
-  const pagesDir = path.join(root, 'pages');
-  if (!existsSync(pagesDir)) return [];
-  const rules: RevalidateRule[] = [];
+  const pagesDir = path.join(root, 'pages')
+  if (!existsSync(pagesDir)) return []
+  const rules: RevalidateRule[] = []
   for (const file of walkFiles(pagesDir)) {
-    const source = readFileSync(file, 'utf8');
-    if (!/\bgetStaticProps\b/.test(source)) continue;
-    const match = /\brevalidate\s*:\s*(\d+)/.exec(source);
-    if (!match?.[1]) continue;
-    const regex = pagesRouteRegex(path.relative(pagesDir, file));
-    if (!regex) continue;
-    rules.push({ regex, revalidateSeconds: Number(match[1]) });
+    const source = readFileSync(file, 'utf8')
+    if (!/\bgetStaticProps\b/.test(source)) continue
+    const match = /\brevalidate\s*:\s*(\d+)/.exec(source)
+    if (!match?.[1]) continue
+    const regex = pagesRouteRegex(path.relative(pagesDir, file))
+    if (!regex) continue
+    rules.push({ regex, revalidateSeconds: Number(match[1]) })
   }
-  return rules;
+  return rules
 }
 
 function walkFiles(dir: string): string[] {
-  const files: string[] = [];
+  const files: string[] = []
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const file = path.join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...walkFiles(file));
-    else if (/\.(?:tsx|ts|jsx|js|mjs)$/.test(entry.name)) files.push(file);
+    const file = path.join(dir, entry.name)
+    if (entry.isDirectory()) files.push(...walkFiles(file))
+    else if (/\.(?:tsx|ts|jsx|js|mjs)$/.test(entry.name)) files.push(file)
   }
-  return files;
+  return files
 }
 
 function pagesRouteRegex(relative: string): RegExp | undefined {
-  const withoutExt = relative.replace(/\.(?:tsx|ts|jsx|js|mjs)$/, '').split(path.sep).join('/');
-  const route = withoutExt === 'index' ? '' : withoutExt.replace(/\/index$/, '');
-  const parts = route.split('/').filter(Boolean);
+  const withoutExt = relative
+    .replace(/\.(?:tsx|ts|jsx|js|mjs)$/, '')
+    .split(path.sep)
+    .join('/')
+  const route = withoutExt === 'index' ? '' : withoutExt.replace(/\/index$/, '')
+  const parts = route.split('/').filter(Boolean)
   const pattern = parts
     .map(part => {
-      if (/^\[\[\.\.\.[^\]]+\]\]$/.test(part)) return '(?:/.*)?';
-      if (/^\[\.\.\.[^\]]+\]$/.test(part)) return '/.+';
-      if (/^\[[^\]]+\]$/.test(part)) return '/[^/]+';
-      return `/${escapeRegex(part)}`;
+      if (/^\[\[\.\.\.[^\]]+\]\]$/.test(part)) return '(?:/.*)?'
+      if (/^\[\.\.\.[^\]]+\]$/.test(part)) return '/.+'
+      if (/^\[[^\]]+\]$/.test(part)) return '/[^/]+'
+      return `/${escapeRegex(part)}`
     })
-    .join('');
-  return new RegExp(`^${pattern || '/'}\\/?$`);
-}
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    .join('')
+  return new RegExp(`^${pattern || '/'}\\/?$`)
 }
 
 function parseCookieHeader(header: string | null): Record<string, string> {
-  const cookies: Record<string, string> = {};
-  if (!header) return cookies;
+  const cookies: Record<string, string> = {}
+  if (!header) return cookies
   for (const part of header.split(';')) {
-    const index = part.indexOf('=');
-    if (index === -1) continue;
-    const name = part.slice(0, index).trim();
-    if (!name) continue;
-    cookies[name] = decodeURIComponent(part.slice(index + 1).trim());
+    const index = part.indexOf('=')
+    if (index === -1) continue
+    const name = part.slice(0, index).trim()
+    if (!name) continue
+    cookies[name] = decodeURIComponent(part.slice(index + 1).trim())
   }
-  return cookies;
+  return cookies
 }

package/src/compat/client/base-path.ts

@@ -10,9 +10,9 @@
 
 declare global {
   interface Window {
-    __PNEXT_BASE_PATH__?: string;
+    __PNEXT_BASE_PATH__?: string
   }
-  var __PNEXT_BASE_PATH__: string | undefined;
+  var __PNEXT_BASE_PATH__: string | undefined
 }
 
 /**
@@ -23,8 +23,8 @@ declare global {
  * config loader, so this stays safe to ship to the browser.
  */
 export function basePath(): string {
-  if (process.browser || typeof window !== 'undefined') return window.__PNEXT_BASE_PATH__ ?? '';
-  return globalThis.__PNEXT_BASE_PATH__ ?? '';
+  if (process.browser || typeof window !== 'undefined') return window.__PNEXT_BASE_PATH__ ?? ''
+  return globalThis.__PNEXT_BASE_PATH__ ?? ''
 }
 
 /**
@@ -34,21 +34,21 @@ export function basePath(): string {
  * no-basePath app is always a no-op.
  */
 export function addBasePath(path: string): string {
-  const base = basePath();
-  if (!base) return path;
-  if (!path.startsWith('/') || path.startsWith('//')) return path;
-  if (path === '/') return base;
-  if (path === base || path.startsWith(`${base}/`)) return path;
-  return `${base}${path}`;
+  const base = basePath()
+  if (!base) return path
+  if (!path.startsWith('/') || path.startsWith('//')) return path
+  if (path === '/') return base
+  if (path === base || path.startsWith(`${base}/`)) return path
+  return `${base}${path}`
 }
 
 /** Strip the configured basePath prefix from an in-app path (inverse of addBasePath). */
 export function stripBasePath(path: string): string {
-  const base = basePath();
-  if (!base) return path;
-  if (path === base) return '/';
-  if (path.startsWith(`${base}/`)) return path.slice(base.length);
-  return path;
+  const base = basePath()
+  if (!base) return path
+  if (path === base) return '/'
+  if (path.startsWith(`${base}/`)) return path.slice(base.length)
+  return path
 }
 
 /**
@@ -56,9 +56,10 @@ export function stripBasePath(path: string): string {
  * hard-navigate to it (a `basePath:false` target). Always false when no basePath is configured.
  */
 export function isOutsideBasePath(url: URL): boolean {
-  const base = basePath();
-  if (!base) return false;
-  if ((process.browser || typeof window !== 'undefined') && url.origin !== window.location.origin) return false;
-  const path = url.pathname;
-  return path !== base && !path.startsWith(`${base}/`);
+  const base = basePath()
+  if (!base) return false
+  if ((process.browser || typeof window !== 'undefined') && url.origin !== window.location.origin)
+    return false
+  const path = url.pathname
+  return path !== base && !path.startsWith(`${base}/`)
 }

package/src/compat/client/css-order.ts

@@ -2,35 +2,35 @@
 // Shared links otherwise retain their old position while newly-needed links
 // append, which reverses ties in the CSS cascade after a route transition.
 export function reconcileNextStylesheets(incoming: Document) {
-  const order = new Map<string, number>();
+  const order = new Map<string, number>()
   for (const link of incoming.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"][href]')) {
-    const href = absoluteHref(link);
-    if (href && nextStylesheet(href) && !order.has(href)) order.set(href, order.size);
+    const href = absoluteHref(link)
+    if (href && nextStylesheet(href) && !order.has(href)) order.set(href, order.size)
   }
-  if (order.size < 2) return;
+  if (order.size < 2) return
 
-  const current = [...document.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"][href]')].filter(
-    link => order.has(link.href),
-  );
-  if (current.length < 2) return;
+  const current = [
+    ...document.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"][href]'),
+  ].filter(link => order.has(link.href))
+  if (current.length < 2) return
 
-  const rank = (link: HTMLLinkElement) => order.get(link.href) ?? 0;
-  if (current.every((link, index) => index === 0 || rank(current[index - 1]!) <= rank(link))) return;
+  const rank = (link: HTMLLinkElement) => order.get(link.href) ?? 0
+  if (current.every((link, index) => index === 0 || rank(current[index - 1]!) <= rank(link))) return
 
-  const sorted = [...current].sort((left, right) => rank(left) - rank(right));
-  let previous = sorted[0]!;
+  const sorted = [...current].sort((left, right) => rank(left) - rank(right))
+  let previous = sorted[0]!
   for (const link of sorted.slice(1)) {
-    if (previous.nextSibling !== link) previous.after(link);
-    previous = link;
+    if (previous.nextSibling !== link) previous.after(link)
+    previous = link
   }
 }
 
 function absoluteHref(link: HTMLLinkElement) {
-  const href = link.getAttribute('href');
-  return href ? new URL(href, location.href).href : undefined;
+  const href = link.getAttribute('href')
+  return href ? new URL(href, location.href).href : undefined
 }
 
 function nextStylesheet(href: string) {
-  const url = new URL(href, location.href);
-  return url.origin === location.origin && url.pathname.startsWith('/assets/');
+  const url = new URL(href, location.href)
+  return url.origin === location.origin && url.pathname.startsWith('/assets/')
 }

package/src/compat/client/errors/bare-boundary.ts

@@ -1,32 +1,32 @@
 // Bare tier of the client error boundary (see ./error-boundary): a route with no error.*/not-found.*
 // still needs one so hydration throws reach the window last resort (not preact's diff) and primitive
 // throws keep their raw value en route to global-error. Exactly those two behaviors, ~0.5 KB raw.
-import { Component, type ComponentChildren } from 'preact';
-import { normalizeBoundaryError } from './primitive-throw';
+import { Component, type ComponentChildren } from 'preact'
+import { normalizeBoundaryError } from './primitive-throw'
 
 interface BareBoundaryState {
-  error: unknown;
-  hasError: boolean;
+  error: unknown
+  hasError: boolean
 }
 
 export class BareErrorBoundary extends Component<{ children?: unknown }, BareBoundaryState> {
-  state: BareBoundaryState = { error: null, hasError: false };
+  state: BareBoundaryState = { error: null, hasError: false }
 
   static getDerivedStateFromError(error: unknown): BareBoundaryState {
-    return { error: normalizeBoundaryError(error), hasError: true };
+    return { error: normalizeBoundaryError(error), hasError: true }
   }
 
   render(): ComponentChildren {
-    if (!this.state.hasError) return this.props.children;
-    const { error } = this.state;
+    if (!this.state.hasError) return this.props.children
+    const { error } = this.state
     // A primitive would arrive at the window handler as a synthesized Error, so
     // escalate it to global-error directly (deferred tier) with its raw value.
     // Everything else re-throws: unmarked, so the window last resort still sees
     // a genuinely uncaught error and drives it.
     if (error === null || typeof error !== 'object') {
-      void import('./global-error').then(module => module.escalateToGlobalError(error));
-      return null;
+      void import('./global-error').then(module => module.escalateToGlobalError(error))
+      return null
     }
-    throw error as Error;
+    throw error as Error
   }
 }