@wular/pnext 0.0.3 → 0.0.6

package/src/compat/next/og.ts

@@ -10,56 +10,53 @@
 // satori/resvg pipeline is driven through a ReadableStream that resolves the bytes lazily; the fallback
 // path also flows through the stream.
 
-import { createRequire } from 'node:module';
-import path from 'node:path';
+import { createRequire } from 'node:module'
+import path from 'node:path'
 
 export interface ImageResponseFont {
-  name: string;
-  data: ArrayBuffer | Uint8Array;
-  weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
-  style?: 'normal' | 'italic';
+  name: string
+  data: ArrayBuffer | Uint8Array
+  weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+  style?: 'normal' | 'italic'
 }
 
 export type ImageResponseOptions = ResponseInit & {
-  width?: number;
-  height?: number;
-  debug?: boolean;
-  fonts?: ImageResponseFont[];
-  emoji?: string;
-};
+  width?: number
+  height?: number
+  debug?: boolean
+  fonts?: ImageResponseFont[]
+  emoji?: string
+}
 
-const DEFAULT_WIDTH = 1200;
-const DEFAULT_HEIGHT = 630;
-const MAX_DIMENSION = 4096;
-const MAX_RAW_IMAGE_BYTES = 3 * 1024 * 1024;
-const PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+const DEFAULT_WIDTH = 1200
+const DEFAULT_HEIGHT = 630
+const MAX_DIMENSION = 4096
+const MAX_RAW_IMAGE_BYTES = 3 * 1024 * 1024
+const PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
 
-let crcTable: Uint32Array | undefined;
+let crcTable: Uint32Array | undefined
 
 export class ImageResponse extends Response {
-  static displayName = 'ImageResponse';
+  static displayName = 'ImageResponse'
 
   constructor(element: unknown, options: ImageResponseOptions = {}) {
     // Validate dimensions eagerly so an invalid width/height throws from the
     // constructor (matching Next), not later inside the async PNG stream — a
     // stream-time RangeError would otherwise surface as a degraded fallback PNG
     // instead of the synchronous error callers assert on.
-    dimension(options.width, DEFAULT_WIDTH, 'width');
-    dimension(options.height, DEFAULT_HEIGHT, 'height');
-    const headers = new Headers(options.headers);
-    headers.set('content-type', 'image/png');
+    dimension(options.width, DEFAULT_WIDTH, 'width')
+    dimension(options.height, DEFAULT_HEIGHT, 'height')
+    const headers = new Headers(options.headers)
+    headers.set('content-type', 'image/png')
     // Match Next's default caching behavior for on-the-fly OG images.
     if (!headers.has('cache-control')) {
-      headers.set(
-        'cache-control',
-        'public, immutable, no-transform, max-age=31536000',
-      );
+      headers.set('cache-control', 'public, immutable, no-transform, max-age=31536000')
     }
     super(pngStream(element, options), {
       status: options.status,
       statusText: options.statusText,
       headers,
-    });
+    })
   }
 }
 
@@ -71,23 +68,23 @@ export class ImageResponse extends Response {
 function pngStream(element: unknown, options: ImageResponseOptions): ReadableStream<Uint8Array> {
   return new ReadableStream<Uint8Array>({
     async start(controller) {
-      let bytes: Uint8Array;
+      let bytes: Uint8Array
       try {
         bytes =
           (await renderWithVercelOg(element, options)) ??
           (await renderWithSatori(element, options)) ??
-          createFallbackPng(options);
+          createFallbackPng(options)
       } catch {
-        bytes = createFallbackPng(options);
+        bytes = createFallbackPng(options)
       }
-      controller.enqueue(bytes);
-      controller.close();
+      controller.enqueue(bytes)
+      controller.close()
     },
-  });
+  })
 }
 
 interface VercelOgModule {
-  ImageResponse: new (element: unknown, options?: Record<string, unknown>) => Response;
+  ImageResponse: new (element: unknown, options?: Record<string, unknown>) => Response
 }
 
 /**
@@ -103,30 +100,30 @@ async function renderWithVercelOg(
   element: unknown,
   options: ImageResponseOptions,
 ): Promise<Uint8Array | undefined> {
-  const og = await loadFromAppRoot<VercelOgModule>('@vercel/og');
-  if (!og?.ImageResponse) return undefined;
+  const og = await loadFromAppRoot<VercelOgModule>('@vercel/og')
+  if (!og?.ImageResponse) return undefined
 
-  const width = dimension(options.width, DEFAULT_WIDTH, 'width');
-  const height = dimension(options.height, DEFAULT_HEIGHT, 'height');
+  const width = dimension(options.width, DEFAULT_WIDTH, 'width')
+  const height = dimension(options.height, DEFAULT_HEIGHT, 'height')
   const response = new og.ImageResponse(element, {
     width,
     height,
     ...(options.fonts === undefined ? {} : { fonts: options.fonts }),
     ...(options.debug === undefined ? {} : { debug: options.debug }),
     ...(options.emoji === undefined ? {} : { emoji: options.emoji }),
-  });
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  return bytes.length > 0 ? bytes : undefined;
+  })
+  const bytes = new Uint8Array(await response.arrayBuffer())
+  return bytes.length > 0 ? bytes : undefined
 }
 
 interface SatoriModule {
-  default: (element: unknown, opts: Record<string, unknown>) => Promise<string>;
+  default: (element: unknown, opts: Record<string, unknown>) => Promise<string>
 }
 interface ResvgModule {
   Resvg: new (
     svg: string | Uint8Array,
     opts?: Record<string, unknown>,
-  ) => { render: () => { asPng: () => Uint8Array } };
+  ) => { render: () => { asPng: () => Uint8Array } }
 }
 
 /**
@@ -137,15 +134,15 @@ async function renderWithSatori(
   element: unknown,
   options: ImageResponseOptions,
 ): Promise<Uint8Array | undefined> {
-  const satori = await loadOptional<SatoriModule>('satori');
-  const resvg = await loadOptional<ResvgModule>('@resvg/resvg-js');
-  if (!satori || !resvg) return undefined;
+  const satori = await loadOptional<SatoriModule>('satori')
+  const resvg = await loadOptional<ResvgModule>('@resvg/resvg-js')
+  if (!satori || !resvg) return undefined
 
-  const fonts = normalizeFonts(options.fonts);
-  if (fonts.length === 0) return undefined;
+  const fonts = normalizeFonts(options.fonts)
+  if (fonts.length === 0) return undefined
 
-  const width = dimension(options.width, DEFAULT_WIDTH, 'width');
-  const height = dimension(options.height, DEFAULT_HEIGHT, 'height');
+  const width = dimension(options.width, DEFAULT_WIDTH, 'width')
+  const height = dimension(options.height, DEFAULT_HEIGHT, 'height')
 
   const svg = await satori.default(element, {
     width,
@@ -153,29 +150,29 @@ async function renderWithSatori(
     fonts,
     ...(options.debug === undefined ? {} : { debug: options.debug }),
     ...(options.emoji === undefined ? {} : { emoji: options.emoji }),
-  });
+  })
 
   const renderer = new resvg.Resvg(svg, {
     fitTo: { mode: 'width', value: width },
-  });
-  return renderer.render().asPng();
+  })
+  return renderer.render().asPng()
 }
 
 interface SatoriFont {
-  name: string;
-  data: ArrayBuffer | Uint8Array;
-  weight?: number;
-  style?: 'normal' | 'italic';
+  name: string
+  data: ArrayBuffer | Uint8Array
+  weight?: number
+  style?: 'normal' | 'italic'
 }
 
 function normalizeFonts(fonts: ImageResponseFont[] | undefined): SatoriFont[] {
-  if (!fonts) return [];
+  if (!fonts) return []
   return fonts.map(font => ({
     name: font.name,
     data: font.data,
     ...(font.weight === undefined ? {} : { weight: font.weight }),
     ...(font.style === undefined ? {} : { style: font.style }),
-  }));
+  }))
 }
 
 /**
@@ -185,10 +182,10 @@ function normalizeFonts(fonts: ImageResponseFont[] | undefined): SatoriFont[] {
  */
 async function loadOptional<T>(name: string): Promise<T | undefined> {
   try {
-    const specifier = name;
-    return (await import(/* @vite-ignore */ specifier)) as T;
+    const specifier = name
+    return (await import(/* @vite-ignore */ specifier)) as T
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -202,11 +199,11 @@ async function loadOptional<T>(name: string): Promise<T | undefined> {
  */
 async function loadFromAppRoot<T>(name: string): Promise<T | undefined> {
   try {
-    const resolveFrom = createRequire(path.join(process.cwd(), 'pnext-og-resolve.cjs'));
-    const resolved = resolveFrom.resolve(name);
-    return (await import(/* @vite-ignore */ resolved)) as T;
+    const resolveFrom = createRequire(path.join(process.cwd(), 'pnext-og-resolve.cjs'))
+    const resolved = resolveFrom.resolve(name)
+    return (await import(/* @vite-ignore */ resolved)) as T
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -217,108 +214,108 @@ async function loadFromAppRoot<T>(name: string): Promise<T | undefined> {
 // ---------------------------------------------------------------------------
 
 function createFallbackPng(options: ImageResponseOptions) {
-  const width = dimension(options.width, DEFAULT_WIDTH, 'width');
-  const height = dimension(options.height, DEFAULT_HEIGHT, 'height');
-  const rowBytes = Math.ceil(width / 8) + 1;
-  const rawBytes = rowBytes * height;
+  const width = dimension(options.width, DEFAULT_WIDTH, 'width')
+  const height = dimension(options.height, DEFAULT_HEIGHT, 'height')
+  const rowBytes = Math.ceil(width / 8) + 1
+  const rawBytes = rowBytes * height
   if (rawBytes > MAX_RAW_IMAGE_BYTES) {
     throw new RangeError(
       `ImageResponse dimensions ${width}x${height} exceed the lightweight PNG limit.`,
-    );
+    )
   }
 
-  const ihdr = new Uint8Array(13);
-  const ihdrView = new DataView(ihdr.buffer);
-  ihdrView.setUint32(0, width);
-  ihdrView.setUint32(4, height);
-  ihdr[8] = 1;
+  const ihdr = new Uint8Array(13)
+  const ihdrView = new DataView(ihdr.buffer)
+  ihdrView.setUint32(0, width)
+  ihdrView.setUint32(4, height)
+  ihdr[8] = 1
 
   return concat(
     PNG_SIGNATURE,
     chunk('IHDR', ihdr),
     chunk('IDAT', zlibStoreZeros(rawBytes)),
     chunk('IEND', new Uint8Array()),
-  );
+  )
 }
 
 function dimension(value: number | undefined, fallback: number, name: string) {
-  if (value === undefined) return fallback;
+  if (value === undefined) return fallback
   if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`ImageResponse ${name} must be a positive finite number.`);
+    throw new RangeError(`ImageResponse ${name} must be a positive finite number.`)
   }
-  const rounded = Math.floor(value);
+  const rounded = Math.floor(value)
   if (rounded > MAX_DIMENSION) {
-    throw new RangeError(`ImageResponse ${name} must be ${MAX_DIMENSION} pixels or less.`);
+    throw new RangeError(`ImageResponse ${name} must be ${MAX_DIMENSION} pixels or less.`)
   }
-  return rounded;
+  return rounded
 }
 
 function zlibStoreZeros(length: number) {
-  const blockCount = Math.max(1, Math.ceil(length / 0xffff));
-  const output = new Uint8Array(2 + blockCount * 5 + length + 4);
-  output[0] = 0x78;
-  output[1] = 0x01;
+  const blockCount = Math.max(1, Math.ceil(length / 0xffff))
+  const output = new Uint8Array(2 + blockCount * 5 + length + 4)
+  output[0] = 0x78
+  output[1] = 0x01
 
-  let offset = 2;
-  let remaining = length;
+  let offset = 2
+  let remaining = length
   while (remaining > 0 || offset === 2) {
-    const blockLength = Math.min(remaining, 0xffff);
-    remaining -= blockLength;
-    output[offset++] = remaining === 0 ? 0x01 : 0x00;
-    output[offset++] = blockLength & 0xff;
-    output[offset++] = (blockLength >> 8) & 0xff;
-    const inverse = 0xffff - blockLength;
-    output[offset++] = inverse & 0xff;
-    output[offset++] = (inverse >> 8) & 0xff;
-    offset += blockLength;
+    const blockLength = Math.min(remaining, 0xffff)
+    remaining -= blockLength
+    output[offset++] = remaining === 0 ? 0x01 : 0x00
+    output[offset++] = blockLength & 0xff
+    output[offset++] = (blockLength >> 8) & 0xff
+    const inverse = 0xffff - blockLength
+    output[offset++] = inverse & 0xff
+    output[offset++] = (inverse >> 8) & 0xff
+    offset += blockLength
   }
 
-  const adler = ((length % 65521) << 16) | 1;
-  new DataView(output.buffer).setUint32(output.length - 4, adler);
-  return output;
+  const adler = ((length % 65521) << 16) | 1
+  new DataView(output.buffer).setUint32(output.length - 4, adler)
+  return output
 }
 
 function chunk(type: string, data: Uint8Array) {
-  const output = new Uint8Array(12 + data.length);
-  const view = new DataView(output.buffer);
-  view.setUint32(0, data.length);
+  const output = new Uint8Array(12 + data.length)
+  const view = new DataView(output.buffer)
+  view.setUint32(0, data.length)
   for (let index = 0; index < 4; index += 1) {
-    output[4 + index] = type.charCodeAt(index);
+    output[4 + index] = type.charCodeAt(index)
   }
-  output.set(data, 8);
-  view.setUint32(output.length - 4, crc32(output.subarray(4, output.length - 4)));
-  return output;
+  output.set(data, 8)
+  view.setUint32(output.length - 4, crc32(output.subarray(4, output.length - 4)))
+  return output
 }
 
 function crc32(bytes: Uint8Array) {
-  const table = crcTable ?? createCrcTable();
-  crcTable = table;
-  let crc = 0xffffffff;
+  const table = crcTable ?? createCrcTable()
+  crcTable = table
+  let crc = 0xffffffff
   for (const byte of bytes) {
-    crc = table[(crc ^ byte) & 0xff]! ^ (crc >>> 8);
+    crc = table[(crc ^ byte) & 0xff]! ^ (crc >>> 8)
   }
-  return (crc ^ 0xffffffff) >>> 0;
+  return (crc ^ 0xffffffff) >>> 0
 }
 
 function createCrcTable() {
-  const table = new Uint32Array(256);
+  const table = new Uint32Array(256)
   for (let index = 0; index < table.length; index += 1) {
-    let value = index;
+    let value = index
     for (let bit = 0; bit < 8; bit += 1) {
-      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1
     }
-    table[index] = value >>> 0;
+    table[index] = value >>> 0
   }
-  return table;
+  return table
 }
 
 function concat(...parts: Uint8Array[]) {
-  const length = parts.reduce((total, part) => total + part.length, 0);
-  const output = new Uint8Array(length);
-  let offset = 0;
+  const length = parts.reduce((total, part) => total + part.length, 0)
+  const output = new Uint8Array(length)
+  let offset = 0
   for (const part of parts) {
-    output.set(part, offset);
-    offset += part.length;
+    output.set(part, offset)
+    offset += part.length
   }
-  return output;
+  return output
 }

package/src/compat/next/preferred-region.ts

@@ -2,11 +2,10 @@
 // its build manifests as a normalized string[]. It is read straight off the route's source files via
 // regex - the value is a static export, so a scan matches how `maxDuration` is already collected in core.
 
-import { readFileSync } from 'node:fs';
-import type { RouteManifestEntry } from '../../types';
+import { readFileSync } from 'node:fs'
+import type { RouteManifestEntry } from '../../types'
 
-const PREFERRED_REGION_RE =
-  /\bexport\s+const\s+preferredRegion\s*=\s*(\[[^\]]*\]|['"][^'"]*['"])/;
+const PREFERRED_REGION_RE = /\bexport\s+const\s+preferredRegion\s*=\s*(\[[^\]]*\]|['"][^'"]*['"])/
 
 /**
  * Resolve the route's `preferredRegion`, normalized to a string[] (Next accepts
@@ -14,26 +13,26 @@ const PREFERRED_REGION_RE =
  */
 export function preferredRegionForRoute(route: RouteManifestEntry): string[] | undefined {
   for (const file of routeSources(route)) {
-    let source: string;
+    let source: string
     try {
-      source = readFileSync(file, 'utf8');
+      source = readFileSync(file, 'utf8')
     } catch {
-      continue;
+      continue
     }
-    const match = PREFERRED_REGION_RE.exec(source);
-    if (!match?.[1]) continue;
-    return parsePreferredRegion(match[1]);
+    const match = PREFERRED_REGION_RE.exec(source)
+    if (!match?.[1]) continue
+    return parsePreferredRegion(match[1])
   }
-  return undefined;
+  return undefined
 }
 
 function routeSources(route: RouteManifestEntry): string[] {
-  return [...new Set([route.file, ...route.sourceFiles])].filter(Boolean);
+  return [...new Set([route.file, ...route.sourceFiles])].filter(Boolean)
 }
 
 function parsePreferredRegion(literal: string): string[] {
   if (literal.startsWith('[')) {
-    return Array.from(literal.matchAll(/['"]([^'"]*)['"]/g), m => m[1] ?? '');
+    return Array.from(literal.matchAll(/['"]([^'"]*)['"]/g), m => m[1] ?? '')
   }
-  return [literal.slice(1, -1)];
+  return [literal.slice(1, -1)]
 }

package/src/compat/next/redirects.ts

@@ -8,7 +8,7 @@
  * Source params captured but not consumed by the destination are appended to the destination query,
  * the same rule rewrites follow.
  */
-import { loadNextConfig } from '../actions/config';
+import { loadNextConfig } from '../actions/config'
 import {
   compileSource,
   evaluateConditions,
@@ -17,51 +17,51 @@ import {
   substitute,
   type RewriteCondition,
   type RewriteRequestContext,
-} from './rewrites';
+} from './rewrites'
 
 export interface CompatRedirect {
-  regex: RegExp;
-  paramNames: string[];
-  destination: string;
-  has: RewriteCondition[];
-  missing: RewriteCondition[];
-  status: number;
+  regex: RegExp
+  paramNames: string[]
+  destination: string
+  has: RewriteCondition[]
+  missing: RewriteCondition[]
+  status: number
   /** `basePath: false`: the source matches the RAW path, outside the basePath. */
-  outsideBasePath: boolean;
+  outsideBasePath: boolean
 }
 
 interface RedirectEntry {
-  source?: string;
-  destination?: string;
-  permanent?: boolean;
-  statusCode?: number;
-  has?: unknown;
-  missing?: unknown;
-  basePath?: unknown;
+  source?: string
+  destination?: string
+  permanent?: boolean
+  statusCode?: number
+  has?: unknown
+  missing?: unknown
+  basePath?: unknown
 }
 
 export async function loadCompatRedirects(root: string): Promise<CompatRedirect[]> {
-  const config = await loadNextConfig(root);
-  const producer = config?.redirects;
-  if (typeof producer !== 'function') return [];
-  let value: unknown;
+  const config = await loadNextConfig(root)
+  const producer = config?.redirects
+  if (typeof producer !== 'function') return []
+  let value: unknown
   try {
-    value = await producer();
+    value = await producer()
   } catch {
-    return [];
+    return []
   }
-  if (!Array.isArray(value)) return [];
+  if (!Array.isArray(value)) return []
 
-  const redirects: CompatRedirect[] = [];
+  const redirects: CompatRedirect[] = []
   for (const entry of value as RedirectEntry[]) {
-    if (!entry?.source || !entry.destination) continue;
-    const has = parseConditions(entry.has);
-    const missing = parseConditions(entry.missing);
-    if (has === null || missing === null) continue; // unsupported condition shape
-    const compiled = compileSource(entry.source);
-    if (!compiled) continue;
+    if (!entry?.source || !entry.destination) continue
+    const has = parseConditions(entry.has)
+    const missing = parseConditions(entry.missing)
+    if (has === null || missing === null) continue // unsupported condition shape
+    const compiled = compileSource(entry.source)
+    if (!compiled) continue
     const status =
-      typeof entry.statusCode === 'number' ? entry.statusCode : entry.permanent ? 308 : 307;
+      typeof entry.statusCode === 'number' ? entry.statusCode : entry.permanent ? 308 : 307
     redirects.push({
       ...compiled,
       destination: entry.destination,
@@ -69,14 +69,14 @@ export async function loadCompatRedirects(root: string): Promise<CompatRedirect[
       missing,
       status,
       outsideBasePath: entry.basePath === false,
-    });
+    })
   }
-  return redirects;
+  return redirects
 }
 
 export interface RedirectResult {
-  location: string;
-  status: number;
+  location: string
+  status: number
 }
 
 /** First matching redirect for the request, or undefined. */
@@ -90,42 +90,44 @@ export function resolveCompatRedirect(
     headers: new Headers(),
     cookies: {},
     query: new URLSearchParams(),
-  };
+  }
   for (const redirect of redirects) {
-    const match = redirect.regex.exec(pathname);
-    if (!match) continue;
+    const match = redirect.regex.exec(pathname)
+    if (!match) continue
 
-    const params: Record<string, string> = {};
+    const params: Record<string, string> = {}
     redirect.paramNames.forEach((name, index) => {
-      params[name] = match[index + 1] ?? '';
-    });
+      params[name] = match[index + 1] ?? ''
+    })
 
-    const conditionParams = evaluateConditions(redirect, context);
-    if (conditionParams === null) continue; // has/missing gate failed
-    Object.assign(params, conditionParams);
+    const conditionParams = evaluateConditions(redirect, context)
+    if (conditionParams === null) continue // has/missing gate failed
+    Object.assign(params, conditionParams)
 
-    const [destPath, destQuery] = splitDestination(redirect.destination);
-    const { pathname: resolvedPath, used: usedInPath } = substitute(destPath, params);
+    const [destPath, destQuery] = splitDestination(redirect.destination)
+    const { pathname: resolvedPath, used: usedInPath } = substitute(destPath, params)
 
-    const query = new URLSearchParams();
-    let usedInQuery = false;
+    const query = new URLSearchParams()
+    let usedInQuery = false
     if (destQuery) {
       for (const [key, rawValue] of new URLSearchParams(destQuery).entries()) {
-        const { pathname: value, used } = substitute(rawValue, params);
-        if (used) usedInQuery = true;
-        query.set(key, value);
+        const { pathname: value, used } = substitute(rawValue, params)
+        if (used) usedInQuery = true
+        query.set(key, value)
       }
     }
     // Next appends source params not consumed by the destination to the query.
     if (usedInPath.size === 0 && !usedInQuery) {
       for (const [name, value] of Object.entries(params)) {
-        if (!query.has(name)) query.append(name, value);
+        if (!query.has(name)) query.append(name, value)
       }
     }
 
-    const search = query.toString();
-    const location = search ? `${resolvedPath}${resolvedPath.includes('?') ? '&' : '?'}${search}` : resolvedPath;
-    return { location, status: redirect.status };
+    const search = query.toString()
+    const location = search
+      ? `${resolvedPath}${resolvedPath.includes('?') ? '&' : '?'}${search}`
+      : resolvedPath
+    return { location, status: redirect.status }
   }
-  return undefined;
+  return undefined
 }