@wular/pnext 0.0.4 → 0.0.7

package/src/compat/css/styled-jsx.ts

@@ -1,49 +1,49 @@
-import { createHash } from 'node:crypto';
+import { createHash } from 'node:crypto'
 
-import { isIdentifier, uniqueIdentifier } from '../../utils/source';
+import { isIdentifier, uniqueIdentifier } from '../../utils/code'
 
 export function rewriteStyledJsxSource(source: string, file: string): string {
-  if (!source.includes('<style') || !/\bjsx\b/.test(source)) return source;
+  if (!source.includes('<style') || !/\bjsx\b/.test(source)) return source
 
-  let next = source;
+  let next = source
   for (const match of source.matchAll(
     /import\s+([A-Za-z_$][\w$]*)\s+from\s+['"]styled-jsx\/css['"]\s*;?/g,
   )) {
-    const [statement, binding] = match;
-    if (!statement || !binding || !isIdentifier(binding)) continue;
-    next = next.replace(statement, '');
+    const [statement, binding] = match
+    if (!statement || !binding || !isIdentifier(binding)) continue
+    next = next.replace(statement, '')
     next = next.replace(
       new RegExp(`\\b${binding}\`((?:\\\\.|[^\`])*)\``, 'g'),
       (_statement, css: string) => `\`${minifyStaticCss(css)}\``,
-    );
+    )
   }
 
-  const component = uniqueIdentifier(next, '__PNextStyledJsx');
-  let index = 0;
+  const component = uniqueIdentifier(next, '__PNextStyledJsx')
+  let index = 0
   next = next.replace(
     /<style\s+(?:global\s+)?jsx\s*>\s*\{([\s\S]*?)\}\s*<\/style>/g,
     (_statement, css: string) => {
-      const id = createHash('sha256').update(`${file}:${index++}`).digest('hex').slice(0, 12);
-      return `<${component} id=${JSON.stringify(id)}>{${minifyTemplate(css)}}</${component}>`;
+      const id = createHash('sha256').update(`${file}:${index++}`).digest('hex').slice(0, 12)
+      return `<${component} id=${JSON.stringify(id)}>{${minifyTemplate(css)}}</${component}>`
     },
-  );
-  if (index === 0) return source;
+  )
+  if (index === 0) return source
 
-  const directives = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? '';
-  return `${directives}import { style as ${component} } from 'styled-jsx';\n${next.slice(directives.length)}`;
+  const directives = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? ''
+  return `${directives}import { style as ${component} } from 'styled-jsx';\n${next.slice(directives.length)}`
 }
 
 function minifyTemplate(expression: string): string {
-  const match = /^\s*`([\s\S]*)`\s*$/.exec(expression);
-  if (!match?.[1] || match[1].includes('${')) return expression;
-  return `\`${minifyStaticCss(match[1])}\``;
+  const match = /^\s*`([\s\S]*)`\s*$/.exec(expression)
+  if (!match?.[1] || match[1].includes('${')) return expression
+  return `\`${minifyStaticCss(match[1])}\``
 }
 
 function minifyStaticCss(css: string): string {
-  if (css.includes('${')) return css;
+  if (css.includes('${')) return css
   return css
     .replace(/\/\*[\s\S]*?\*\//g, '')
     .replace(/\s+/g, ' ')
     .replace(/\s*([{}:;,])\s*/g, '$1')
-    .trim();
+    .trim()
 }

package/src/compat/edge-runtime.ts

@@ -1,71 +1,71 @@
-import { reinstallCustomCacheHandlerForEdge } from './cache/custom-handler';
+import { reinstallCustomCacheHandlerForEdge } from './cache/custom-handler'
 
-type GlobalDescriptor = PropertyDescriptor | undefined;
+type GlobalDescriptor = PropertyDescriptor | undefined
 
 export function withEdgeRuntime<T>(callback: () => T): T {
   const globalObject = globalThis as typeof globalThis & {
-    EdgeRuntime?: string;
-    process?: NodeJS.Process;
-  };
-  const previousEdgeRuntime = Object.getOwnPropertyDescriptor(globalObject, 'EdgeRuntime');
-  const previousProcess = Object.getOwnPropertyDescriptor(globalObject, 'process');
-  const currentProcess = globalObject.process as NodeJS.Process | undefined;
+    EdgeRuntime?: string
+    process?: NodeJS.Process
+  }
+  const previousEdgeRuntime = Object.getOwnPropertyDescriptor(globalObject, 'EdgeRuntime')
+  const previousProcess = Object.getOwnPropertyDescriptor(globalObject, 'process')
+  const currentProcess = globalObject.process as NodeJS.Process | undefined
   const edgeProcess = currentProcess
     ? new Proxy(currentProcess, {
         get(target, property, receiver) {
-          if (property === 'emit') return undefined;
+          if (property === 'emit') return undefined
           // Next's Edge runtime exposes only a minimal `process` polyfill —
           // notably no Node `version`/`versions`. Code that branches on
           // `process.version` (to detect Node vs Edge) must see it absent.
-          if (property === 'version' || property === 'versions') return undefined;
-          const value: unknown = Reflect.get(target, property, receiver);
-          return typeof value === 'function' ? (value as () => unknown).bind(target) : value;
+          if (property === 'version' || property === 'versions') return undefined
+          const value: unknown = Reflect.get(target, property, receiver)
+          return typeof value === 'function' ? (value as () => unknown).bind(target) : value
         },
       })
-    : undefined;
+    : undefined
 
   Object.defineProperty(globalObject, 'EdgeRuntime', {
     configurable: true,
     enumerable: false,
     writable: true,
     value: 'edge-runtime',
-  });
+  })
   Object.defineProperty(globalObject, 'process', {
     configurable: true,
     enumerable: false,
     writable: true,
     value: edgeProcess ?? { env: {} },
-  });
+  })
 
   try {
-    reinstallCustomCacheHandlerForEdge();
-    const result = callback();
+    reinstallCustomCacheHandlerForEdge()
+    const result = callback()
     if (isThenable(result)) {
       return Promise.resolve(result).finally(() =>
         restore(previousEdgeRuntime, previousProcess),
-      ) as T;
+      ) as T
     }
-    restore(previousEdgeRuntime, previousProcess);
-    return result;
+    restore(previousEdgeRuntime, previousProcess)
+    return result
   } catch (error) {
-    restore(previousEdgeRuntime, previousProcess);
-    throw error;
+    restore(previousEdgeRuntime, previousProcess)
+    throw error
   }
 }
 
 function restore(edgeRuntime: GlobalDescriptor, process: GlobalDescriptor): void {
-  restoreProperty('EdgeRuntime', edgeRuntime);
-  restoreProperty('process', process);
+  restoreProperty('EdgeRuntime', edgeRuntime)
+  restoreProperty('process', process)
 }
 
 function restoreProperty(name: 'EdgeRuntime' | 'process', descriptor: GlobalDescriptor): void {
   if (descriptor) {
-    Object.defineProperty(globalThis, name, descriptor);
+    Object.defineProperty(globalThis, name, descriptor)
   } else {
-    delete (globalThis as Record<string, unknown>)[name];
+    delete (globalThis as Record<string, unknown>)[name]
   }
 }
 
 function isThenable<T>(value: T): value is T & PromiseLike<unknown> {
-  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function';
+  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function'
 }

package/src/compat/{adapter → export}/build-complete.ts

@@ -1,10 +1,10 @@
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileHref } from '../../config';
-import type { ResolvedConfig } from '../../config';
-import type { BuildManifest, RouteManifestEntry } from '../../types';
-import { getNextConfig } from '../next/config-loader';
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileHref } from '../../config'
+import type { ResolvedConfig } from '../../config'
+import type { BuildManifest, RouteManifestEntry } from '../../types'
+import { getNextConfig } from '../next/config-loader'
 
 /**
  * `adapterPath` support (Next's `onBuildComplete` hook).
@@ -15,49 +15,49 @@ import { getNextConfig } from '../next/config-loader';
  * artifacts. pnext reports the same classification off its build manifest.
  */
 interface SharedRouteFields {
-  id: string;
-  filePath: string;
-  pathname: string;
-  sourcePage: string;
-  runtime: 'nodejs' | 'edge';
-  assets: Record<string, string>;
-  assetsHashes: Record<string, string>;
-  config: { maxDuration?: number };
-  type: string;
+  id: string
+  filePath: string
+  pathname: string
+  sourcePage: string
+  runtime: 'nodejs' | 'edge'
+  assets: Record<string, string>
+  assetsHashes: Record<string, string>
+  config: { maxDuration?: number }
+  type: string
 }
 
 interface AdapterOutputs {
-  pages: SharedRouteFields[];
-  appPages: SharedRouteFields[];
-  pagesApi: SharedRouteFields[];
-  appRoutes: SharedRouteFields[];
-  prerenders: { id: string; pathname: string; type: string; parentOutputId: string }[];
-  staticFiles: { id: string; filePath: string; pathname: string; type: string }[];
+  pages: SharedRouteFields[]
+  appPages: SharedRouteFields[]
+  pagesApi: SharedRouteFields[]
+  appRoutes: SharedRouteFields[]
+  prerenders: { id: string; pathname: string; type: string; parentOutputId: string }[]
+  staticFiles: { id: string; filePath: string; pathname: string; type: string }[]
 }
 
 /** One entry of `routing.*` — Next's routes-manifest rewrite shape. */
 interface AdapterRoute {
-  source?: string;
-  sourceRegex: string;
-  destination?: string;
+  source?: string
+  sourceRegex: string
+  destination?: string
 }
 
 /** Adapter module shape — only the hook pnext can honour is typed. */
 interface NextAdapter {
-  name?: string;
-  onBuildComplete?: (ctx: unknown) => unknown;
+  name?: string
+  onBuildComplete?: (ctx: unknown) => unknown
 }
 
 /** The URL pathname a built `public/` file is served at. */
 function staticPathname(relative: string): string {
-  const url = `/${relative.replace(/\\/g, '/')}`;
-  if (url.endsWith('/index.html')) return url.slice(0, -'index.html'.length) || '/';
-  return url.endsWith('.html') ? url.slice(0, -'.html'.length) : url;
+  const url = `/${relative.replace(/\\/g, '/')}`
+  if (url.endsWith('/index.html')) return url.slice(0, -'index.html'.length) || '/'
+  return url.endsWith('.html') ? url.slice(0, -'.html'.length) : url
 }
 
 /** Where the per-route server entry for `route` is written. */
 function serverEntryPath(config: ResolvedConfig, route: RouteManifestEntry): string {
-  return path.join(config.outPath, 'server', `${route.id}.js`);
+  return path.join(config.outPath, 'server', `${route.id}.js`)
 }
 
 /**
@@ -66,13 +66,10 @@ function serverEntryPath(config: ResolvedConfig, route: RouteManifestEntry): str
  * there is no per-route bundle to point at - so the entry is a descriptor module naming the route and
  * the source module the server renders for it. Only written when an adapter is configured.
  */
-async function writeServerEntries(
-  config: ResolvedConfig,
-  manifest: BuildManifest,
-): Promise<void> {
-  await mkdir(path.join(config.outPath, 'server'), { recursive: true });
+async function writeServerEntries(config: ResolvedConfig, manifest: BuildManifest): Promise<void> {
+  await mkdir(path.join(config.outPath, 'server'), { recursive: true })
   await Promise.all(
-    manifest.routes.map((route) =>
+    manifest.routes.map(route =>
       writeFile(
         serverEntryPath(config, route),
         [
@@ -89,11 +86,11 @@ async function writeServerEntries(
         ].join('\n'),
       ),
     ),
-  );
+  )
 }
 
 function sourcePage(config: ResolvedConfig, route: RouteManifestEntry): string {
-  return `/${path.relative(config.root, route.file).replace(/\\/g, '/')}`;
+  return `/${path.relative(config.root, route.file).replace(/\\/g, '/')}`
 }
 
 function sharedFields(
@@ -112,7 +109,7 @@ function sharedFields(
     config: {
       ...(route.maxDuration !== undefined ? { maxDuration: route.maxDuration } : {}),
     },
-  };
+  }
 }
 
 /**
@@ -129,36 +126,36 @@ function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): Adapte
     appRoutes: [],
     prerenders: [],
     staticFiles: [],
-  };
-  const prerenderedRoutes = new Set<string>();
+  }
+  const prerenderedRoutes = new Set<string>()
 
   for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
-    const filePath = path.join(config.outPath, 'public', relative);
+    const filePath = path.join(config.outPath, 'public', relative)
     // The manifest also records prerenders that produced no body on disk
     // (an empty response, `_not-found` / `_global-error`). Those are not
     // deployable artifacts: leave them out, and leave the owning route as a
     // server entrypoint rather than treating it as prerendered.
-    if (!existsSync(filePath)) continue;
-    if (metadata.routeId) prerenderedRoutes.add(metadata.routeId);
-    const entry = { id: relative, filePath, pathname: staticPathname(relative) };
+    if (!existsSync(filePath)) continue
+    if (metadata.routeId) prerenderedRoutes.add(metadata.routeId)
+    const entry = { id: relative, filePath, pathname: staticPathname(relative) }
     if (metadata.revalidateSeconds !== undefined) {
       outputs.prerenders.push({
         ...entry,
         type: 'PRERENDER',
         parentOutputId: metadata.routeId ?? relative,
-      });
+      })
     } else {
-      outputs.staticFiles.push({ ...entry, type: 'STATIC_FILE' });
+      outputs.staticFiles.push({ ...entry, type: 'STATIC_FILE' })
     }
   }
 
   for (const route of manifest.routes) {
-    if (prerenderedRoutes.has(route.id) && route.mode === 'static' && !route.ppr) continue;
-    const fields = sharedFields(config, route);
+    if (prerenderedRoutes.has(route.id) && route.mode === 'static' && !route.ppr) continue
+    const fields = sharedFields(config, route)
     if (route.kind === 'handler') {
-      outputs.appRoutes.push({ ...fields, type: 'APP_ROUTE' });
+      outputs.appRoutes.push({ ...fields, type: 'APP_ROUTE' })
     } else {
-      outputs.appPages.push({ ...fields, type: 'APP_PAGE' });
+      outputs.appPages.push({ ...fields, type: 'APP_PAGE' })
       // Every app page is reachable both as HTML and as its RSC payload; Next
       // reports the pair as two outputs sharing one entrypoint.
       outputs.appPages.push({
@@ -166,11 +163,11 @@ function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): Adapte
         type: 'APP_PAGE',
         id: `${route.id}.rsc`,
         pathname: `${fields.pathname}.rsc`,
-      });
+      })
     }
   }
 
-  return outputs;
+  return outputs
 }
 
 /**
@@ -178,12 +175,12 @@ function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): Adapte
  * the `namedRegex` form Next's routes-manifest uses (`$name` in destinations).
  */
 function namedSourceRegex(route: RouteManifestEntry): string {
-  let index = 0;
+  let index = 0
   const named = route.pattern.replace(/\((\[\^\/\]\+|\.\*)\)/g, (whole, body: string) => {
-    const param = route.params[index++];
-    return param ? `(?<${param.replace(/\W/g, '')}>${body})` : whole;
-  });
-  return `^${named}(?:/)?$`;
+    const param = route.params[index++]
+    return param ? `(?<${param.replace(/\W/g, '')}>${body})` : whole
+  })
+  return `^${named}(?:/)?$`
 }
 
 /**
@@ -192,10 +189,10 @@ function namedSourceRegex(route: RouteManifestEntry): string {
  * emits them.
  */
 function collectDynamicRoutes(manifest: BuildManifest): AdapterRoute[] {
-  const routes: AdapterRoute[] = [];
+  const routes: AdapterRoute[] = []
   for (const route of manifest.routes) {
-    if (route.params.length === 0) continue;
-    const sourceRegex = namedSourceRegex(route);
+    if (route.params.length === 0) continue
+    const sourceRegex = namedSourceRegex(route)
     if (route.kind === 'page') {
       routes.push({
         source: `${route.route}.rsc`,
@@ -204,11 +201,11 @@ function collectDynamicRoutes(manifest: BuildManifest): AdapterRoute[] {
           String.raw`(?<rscSuffix>\.rsc|\.segments/.+\.segment\.rsc)(?:/)?$`,
         ),
         destination: `${route.route}$rscSuffix`,
-      });
+      })
     }
-    routes.push({ source: route.route, sourceRegex, destination: route.route });
+    routes.push({ source: route.route, sourceRegex, destination: route.route })
   }
-  return routes;
+  return routes
 }
 
 /**
@@ -221,21 +218,21 @@ export async function runBuildCompleteAdapter(
   config: ResolvedConfig,
   manifest: BuildManifest,
 ): Promise<void> {
-  const configured = getNextConfig().adapterPath;
+  const configured = getNextConfig().adapterPath
   const adapterPath =
     // eslint-disable-next-line turbo/no-undeclared-env-vars -- Next's own env override
-    process.env.NEXT_ADAPTER_PATH || (typeof configured === 'string' ? configured : undefined);
-  if (!adapterPath) return;
+    process.env.NEXT_ADAPTER_PATH || (typeof configured === 'string' ? configured : undefined)
+  if (!adapterPath) return
   const resolved = path.isAbsolute(adapterPath)
     ? adapterPath
-    : path.resolve(config.root, adapterPath);
+    : path.resolve(config.root, adapterPath)
   const module = (await import(pathToFileHref(resolved))) as {
-    default?: NextAdapter;
-  } & NextAdapter;
-  const adapter = module.default ?? module;
-  if (typeof adapter?.onBuildComplete !== 'function') return;
+    default?: NextAdapter
+  } & NextAdapter
+  const adapter = module.default ?? module
+  if (typeof adapter?.onBuildComplete !== 'function') return
 
-  await writeServerEntries(config, manifest);
+  await writeServerEntries(config, manifest)
 
   await adapter.onBuildComplete({
     routing: {
@@ -253,5 +250,5 @@ export async function runBuildCompleteAdapter(
     projectDir: config.root,
     repoRoot: config.root,
     distDir: config.outPath,
-  });
+  })
 }

package/src/compat/export/client.ts

@@ -15,15 +15,15 @@
 // rewrite of the page also cover the data request. A host-level REDIRECT typically does not, so - like
 // Next - a HEAD probe resolves the page's final URL first.
 
-import { setExportDocumentFetcher } from '../../api/router/policies';
+import { setExportDocumentFetcher } from '../../client/router/policies'
 
 /** The exported segment file carrying a route's complete document. */
-const SEGMENT_FILE = '__next._full.txt';
+const SEGMENT_FILE = '__next._full.txt'
 
 /** A document read out of the export tree, with the route URL it belongs to. */
 interface ExportedDocument {
-  html: string;
-  finalUrl: string;
+  html: string
+  finalUrl: string
 }
 
 // Registered at MODULE scope rather than from installNavCompat(): the router
@@ -31,31 +31,29 @@ interface ExportedDocument {
 // install sequence, and those would otherwise fall through to a server that
 // isn't there. Module initialization runs before any of it, and the marker is
 // an inline script in <head>, so it is already set by the time this evaluates.
-if (outputExportMode()) setExportDocumentFetcher(fetchExportedDocument);
+if (outputExportMode()) setExportDocumentFetcher(fetchExportedDocument)
 
 /** Whether the running document was served out of an export tree. */
 function outputExportMode(): boolean {
   return (
     (process.browser || typeof window !== 'undefined') &&
     (window as { __PNEXT_OUTPUT_EXPORT__?: boolean }).__PNEXT_OUTPUT_EXPORT__ === true
-  );
+  )
 }
 
 /** `/another` -> `/another.txt`; `/another/` -> `/another/index.txt`. */
 function documentUrl(url: URL): URL {
-  const target = new URL(url.href);
-  target.pathname += target.pathname.endsWith('/') ? 'index.txt' : '.txt';
-  return target;
+  const target = new URL(url.href)
+  target.pathname += target.pathname.endsWith('/') ? 'index.txt' : '.txt'
+  return target
 }
 
 /** `/another` (or `/another/`) -> `/another/__next._full.txt`. */
 function segmentUrl(url: URL): URL {
-  const target = new URL(url.href);
-  const directory = target.pathname.endsWith('/')
-    ? target.pathname.slice(0, -1)
-    : target.pathname;
-  target.pathname = `${directory}/${SEGMENT_FILE}`;
-  return target;
+  const target = new URL(url.href)
+  const directory = target.pathname.endsWith('/') ? target.pathname.slice(0, -1) : target.pathname
+  target.pathname = `${directory}/${SEGMENT_FILE}`
+  return target
 }
 
 /**
@@ -68,30 +66,30 @@ async function fetchExportedDocument(
   init: RequestInit,
   prefetch: boolean,
 ): Promise<ExportedDocument | null> {
-  const url = new URL(href, location.href);
-  let pageUrl = url;
+  const url = new URL(href, location.href)
+  let pageUrl = url
   if (prefetch) {
     // Resolve host-level redirects on the PAGE path before asking for a file
     // beside it: a host that redirects `/old` to `/new` has no reason to also
     // redirect `/old/__next._full.txt`, which the exporter never wrote.
     const probe = await fetch(url.href, { method: 'HEAD', credentials: 'same-origin' }).catch(
       () => null,
-    );
+    )
     // `Response#ok` is false for a followed 3xx chain, so test the range.
-    if (!probe || probe.status < 200 || probe.status >= 400) return null;
-    if (probe.redirected) pageUrl = new URL(probe.url);
+    if (!probe || probe.status < 200 || probe.status >= 400) return null
+    if (probe.redirected) pageUrl = new URL(probe.url)
   }
-  const target = prefetch ? segmentUrl(pageUrl) : documentUrl(pageUrl);
-  const response = await fetch(target.href, init);
-  if (!response.ok) return null;
-  const html = await response.text();
+  const target = prefetch ? segmentUrl(pageUrl) : documentUrl(pageUrl)
+  const response = await fetch(target.href, init)
+  if (!response.ok) return null
+  const html = await response.text()
   // Static hosts answer an unknown path with a catch-all document or a
   // directory listing rather than a 404; neither is a pnext document.
-  if (!html.includes('<html')) return null;
+  if (!html.includes('<html')) return null
   return {
     html,
     finalUrl: prefetch ? pageUrl.href : navigatedUrl(response, url),
-  };
+  }
 }
 
 /**
@@ -99,14 +97,14 @@ async function fetchExportedDocument(
  * suffix peeled back off when the host redirected, otherwise the requested URL.
  */
 function navigatedUrl(response: Response, requested: URL): string {
-  if (!response.redirected) return requested.href;
+  if (!response.redirected) return requested.href
   try {
-    const url = new URL(response.url);
+    const url = new URL(response.url)
     url.pathname = url.pathname.endsWith('/index.txt')
       ? url.pathname.slice(0, -'index.txt'.length)
-      : url.pathname.replace(/\.txt$/, '');
-    return url.href;
+      : url.pathname.replace(/\.txt$/, '')
+    return url.href
   } catch {
-    return requested.href;
+    return requested.href
   }
 }