@wular/pnext 0.0.3 → 0.0.6

package/src/cli/{serve-ui.ts → serve/ui.ts}

@@ -1,14 +1,14 @@
-import { networkInterfaces } from 'node:os';
-import { bold, cyan, dim, green } from '../utils/ansi';
+import { networkInterfaces } from 'node:os'
+import { bold, cyan, dim, green } from '../../utils/ansi'
 
 interface ReadyBanner {
   /** Short mode label shown after the mark, e.g. "dev" or "production". */
-  mode: string;
+  mode: string
   /** The bind hostname, used to derive Local/Network URLs. */
-  hostname: string;
-  port: number;
+  hostname: string
+  port: number
   /** Milliseconds to boot, when known (dev server startup). */
-  elapsedMs?: number;
+  elapsedMs?: number
 }
 
 /**
@@ -18,39 +18,39 @@ interface ReadyBanner {
  */
 export function browserHost(hostname: string) {
   // IPv6 binds present their bracketed loopback (Next prints http://[::1]:port).
-  if (hostname === '::' || hostname === '::1') return '[::1]';
-  if (['0.0.0.0', '127.0.0.1'].includes(hostname)) return 'localhost';
-  return hostname;
+  if (hostname === '::' || hostname === '::1') return '[::1]'
+  if (['0.0.0.0', '127.0.0.1'].includes(hostname)) return 'localhost'
+  return hostname
 }
 
 /** Print a Next.js-style "server ready" banner with local and network URLs. */
 export function printServerReady({ mode, hostname, port, elapsedMs }: ReadyBanner) {
-  const rows: [string, string][] = [['Local:', cyan(`http://${browserHost(hostname)}:${port}`)]];
+  const rows: [string, string][] = [['Local:', cyan(`http://${browserHost(hostname)}:${port}`)]]
 
   // When bound to all interfaces, surface the LAN address so it's reachable
   // from other devices (phones, other machines) without hunting for the IP.
   // Next prints the bracketed wildcard itself for IPv6 (`http://[::]:port`).
-  const lan = hostname === '::' ? '[::]' : wildcard(hostname) ? lanAddress() : undefined;
-  if (lan) rows.push(['Network:', cyan(`http://${lan}:${port}`)]);
+  const lan = hostname === '::' ? '[::]' : wildcard(hostname) ? lanAddress() : undefined
+  if (lan) rows.push(['Network:', cyan(`http://${lan}:${port}`)])
 
   const ready =
     elapsedMs === undefined
       ? `${green('✓')} ${bold('Ready')}`
-      : `${green('✓')} ${bold('Ready')} ${dim(`in ${Math.round(elapsedMs)}ms`)}`;
+      : `${green('✓')} ${bold('Ready')} ${dim(`in ${Math.round(elapsedMs)}ms`)}`
 
-  const pad = Math.max(...rows.map(([label]) => label.length));
-  console.log('');
-  console.log(`${cyan('▲')} ${bold('pnext')} ${dim(mode)}`);
+  const pad = Math.max(...rows.map(([label]) => label.length))
+  console.log('')
+  console.log(`${cyan('▲')} ${bold('pnext')} ${dim(mode)}`)
   for (const [label, value] of rows) {
-    console.log(`  ${dim('-')} ${dim(label.padEnd(pad))}  ${value}`);
+    console.log(`  ${dim('-')} ${dim(label.padEnd(pad))}  ${value}`)
   }
-  console.log('');
-  console.log(ready);
-  console.log('');
+  console.log('')
+  console.log(ready)
+  console.log('')
 }
 
 function wildcard(hostname: string) {
-  return hostname === '0.0.0.0' || hostname === '::';
+  return hostname === '0.0.0.0' || hostname === '::'
 }
 
 /**
@@ -63,67 +63,67 @@ export async function ensurePortFree(
   hostname: string,
   options: { attempts?: number; delayMs?: number } = {},
 ) {
-  const attempts = options.attempts ?? 1;
-  const delayMs = options.delayMs ?? 300;
+  const attempts = options.attempts ?? 1
+  const delayMs = options.delayMs ?? 300
   const candidates =
-    wildcard(hostname) || hostname === 'localhost' ? ['127.0.0.1', '::1'] : [hostname];
+    wildcard(hostname) || hostname === 'localhost' ? ['127.0.0.1', '::1'] : [hostname]
 
   for (const candidate of candidates) {
-    let inUse = await portInUse(candidate, port);
+    let inUse = await portInUse(candidate, port)
     // A respawning server may race its predecessor's shutdown; give it a beat.
     for (let attempt = 1; inUse && attempt < attempts; attempt += 1) {
-      await new Promise(resolve => setTimeout(resolve, delayMs));
-      inUse = await portInUse(candidate, port);
+      await new Promise(resolve => setTimeout(resolve, delayMs))
+      inUse = await portInUse(candidate, port)
     }
     if (inUse) {
       throw new Error(
         `Port ${port} is already in use on ${candidate} (another pnext dev/start or process). ` +
           `Stop it or pass --port. To find it:` +
           `  lsof -nP -iTCP:${port} -sTCP:LISTEN`,
-      );
+      )
     }
   }
 }
 
 function portInUse(hostname: string, port: number) {
   return new Promise<boolean>(resolve => {
-    const timer = setTimeout(() => resolve(false), 300);
+    const timer = setTimeout(() => resolve(false), 300)
     Bun.connect({
       hostname,
       port,
       socket: {
         open(socket) {
-          clearTimeout(timer);
-          socket.end();
-          resolve(true);
+          clearTimeout(timer)
+          socket.end()
+          resolve(true)
         },
         data() {
           // Only connectability matters; any payload is ignored.
         },
         connectError() {
-          clearTimeout(timer);
-          resolve(false);
+          clearTimeout(timer)
+          resolve(false)
         },
         error() {
-          clearTimeout(timer);
-          resolve(false);
+          clearTimeout(timer)
+          resolve(false)
         },
       },
     }).catch(() => {
-      clearTimeout(timer);
-      resolve(false);
-    });
-  });
+      clearTimeout(timer)
+      resolve(false)
+    })
+  })
 }
 
 /** First non-internal IPv4 address, or undefined when offline. */
 function lanAddress() {
   for (const addresses of Object.values(networkInterfaces())) {
     for (const address of addresses ?? []) {
-      if (address.family === 'IPv4' && !address.internal) return address.address;
+      if (address.family === 'IPv4' && !address.internal) return address.address
     }
   }
-  return undefined;
+  return undefined
 }
 
 /**
@@ -136,12 +136,12 @@ function lanAddress() {
  */
 export function openBrowser(url: string) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const browser = process.env.BROWSER;
+  const browser = process.env.BROWSER
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (browser === 'none' || process.env.CI) return;
+  if (browser === 'none' || process.env.CI) return
 
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const browserArgs = process.env.BROWSER_ARGS?.split(/\s+/).filter(Boolean) ?? [];
+  const browserArgs = process.env.BROWSER_ARGS?.split(/\s+/).filter(Boolean) ?? []
   const command = browser
     ? process.platform === 'darwin'
       ? ['open', '-a', browser, ...browserArgs, url]
@@ -150,10 +150,10 @@ export function openBrowser(url: string) {
       ? ['open', url]
       : process.platform === 'win32'
         ? ['cmd', '/c', 'start', '', url]
-        : ['xdg-open', url];
+        : ['xdg-open', url]
 
   try {
-    Bun.spawn(command, { stdout: 'ignore', stderr: 'ignore', stdin: 'ignore' }).unref();
+    Bun.spawn(command, { stdout: 'ignore', stderr: 'ignore', stdin: 'ignore' }).unref()
   } catch {
     // ignore: opening a browser is a convenience, not a requirement
   }

package/src/cli/start.ts

@@ -1,28 +1,28 @@
 /**
  * `pnext start`: the listen path only. Everything a request needs — renderer,
- * routing, server runtime — lives in `./request-pipeline` and is imported
+ * routing, server runtime — lives in `./serve/pipeline` and is imported
  * dynamically once the port is bound, so neither the listen syscall nor the
  * ready banner waits on parsing it (it is ~700 KB of the prebundled entry).
  */
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { loadConfig } from '../config';
-import type { ResolvedConfig } from '../config';
-import { bootstrapCompat } from '../compat-bootstrap';
-import { getBuildExtensions } from '../extensions';
-import { drainWorkUnits } from '../request/context';
-import { markErrorLogged } from '../utils/error-log';
-import { isPostpone } from '../ppr-postpone';
-import { browserHost, ensurePortFree, openBrowser, printServerReady } from './serve-ui';
-import type { BuildManifest } from '../types';
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import { loadConfig } from '../config'
+import type { ResolvedConfig } from '../config'
+import { bootstrapCompat } from '../compat-bootstrap'
+import { getBuildExtensions } from '../extensions'
+import { drainWorkUnits } from '../request/context'
+import { markErrorLogged } from '../utils/error-log'
+import { isPostpone } from '../render/postpone'
+import { browserHost, ensurePortFree, openBrowser, printServerReady } from './serve/ui'
+import type { BuildManifest } from '../types'
 
 interface StartOptions {
-  root?: string;
-  port?: number;
-  hostname?: string;
+  root?: string
+  port?: number
+  hostname?: string
 }
 
-type RequestHandler = (request: Request) => Promise<Response>;
+type RequestHandler = (request: Request) => Promise<Response>
 
 /**
  * The production request handler `pnext start` serves with. Exposed on its own
@@ -32,59 +32,58 @@ type RequestHandler = (request: Request) => Promise<Response>;
 export async function createRequestHandler(
   options: { root?: string; config?: ResolvedConfig; manifest?: BuildManifest } = {},
 ): Promise<RequestHandler> {
-  const { createRequestHandler: create } = await import('./request-pipeline');
-  return create(options);
+  const { createRequestHandler: create } = await import('./serve/pipeline')
+  return create(options)
 }
 
 export async function maybeBuiltFile(
-  ...args: Parameters<typeof import('./request-pipeline').maybeBuiltFile>
+  ...args: Parameters<typeof import('./serve/pipeline').maybeBuiltFile>
 ) {
-  const { maybeBuiltFile: impl } = await import('./request-pipeline');
-  return impl(...args);
+  const { maybeBuiltFile: impl } = await import('./serve/pipeline')
+  return impl(...args)
 }
 
 export async function start(options: StartOptions = {}) {
-  const startedAt = Date.now();
-  const port = options.port ?? 3000;
-  const hostname = options.hostname ?? 'localhost';
+  const startedAt = Date.now()
+  const port = options.port ?? 3000
+  const hostname = options.hostname ?? 'localhost'
   // Export builds are not served by a production start (Next throws). Standalone builds still serve -
   // Next only WARNS, pointing at the standalone launcher, and the launcher re-execs this path with
   // `__NEXT_PRIVATE_STANDALONE_CONFIG` set to suppress that warning. Handle both before binding a
   // port, matching Next's messages.
-  const config = await guardUnservableOutputMode(options.root);
+  const config = await guardUnservableOutputMode(options.root)
   const manifest = JSON.parse(
     await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
-  ) as BuildManifest;
-  await ensurePortFree(port, hostname);
+  ) as BuildManifest
+  await ensurePortFree(port, hostname)
 
   // The pipeline import starts right after listen; a request that beats it
   // simply awaits the same promise instead of racing a second import.
-  let handler: RequestHandler | undefined;
-  let pending: Promise<RequestHandler> | undefined;
+  let handler: RequestHandler | undefined
+  let pending: Promise<RequestHandler> | undefined
   const ensureHandler = () =>
     (pending ??= createRequestHandler({ root: options.root, config, manifest }).then(ready => {
-      handler = ready;
-      return ready;
-    }));
+      handler = ready
+      return ready
+    }))
 
   const server = Bun.serve({
     hostname,
     port,
-    fetch: request =>
-      handler ? handler(request) : ensureHandler().then(ready => ready(request)),
-  });
+    fetch: request => (handler ? handler(request) : ensureHandler().then(ready => ready(request))),
+  })
 
   printServerReady({
     mode: 'production',
     hostname,
     port: server.port ?? port,
     elapsedMs: Date.now() - startedAt,
-  });
-  void ensureHandler().catch(() => undefined); // a real failure resurfaces on the request
-  openBrowser(`http://${browserHost(hostname)}:${server.port ?? port}`);
-  installShutdownHandlers(server);
-  installProcessErrorHandlers();
-  return server;
+  })
+  void ensureHandler().catch(() => undefined) // a real failure resurfaces on the request
+  openBrowser(`http://${browserHost(hostname)}:${server.port ?? port}`)
+  installShutdownHandlers(server)
+  installProcessErrorHandlers()
+  return server
 }
 
 // Next deliberately overrides the runtime's fatal-by-default handling of unhandled rejections and
@@ -97,16 +96,16 @@ export async function start(options: StartOptions = {}) {
 // render site from being printed twice.
 function installProcessErrorHandlers(): void {
   const globalWithFlag = globalThis as typeof globalThis & {
-    __pnextProcessErrorHandlers?: boolean;
-  };
-  if (globalWithFlag.__pnextProcessErrorHandlers) return;
-  globalWithFlag.__pnextProcessErrorHandlers = true;
+    __pnextProcessErrorHandlers?: boolean
+  }
+  if (globalWithFlag.__pnextProcessErrorHandlers) return
+  globalWithFlag.__pnextProcessErrorHandlers = true
   const report = (reason: unknown) => {
-    if (isPostpone(reason)) return;
-    if (markErrorLogged(reason)) console.error(reason);
-  };
-  process.on('unhandledRejection', report);
-  process.on('uncaughtException', report);
+    if (isPostpone(reason)) return
+    if (markErrorLogged(reason)) console.error(reason)
+  }
+  process.on('unhandledRejection', report)
+  process.on('uncaughtException', report)
 }
 
 // Next's output-mode handling on start: an export build throws (fatal - it is unservable), while a
@@ -114,24 +113,24 @@ function installProcessErrorHandlers(): void {
 // `__NEXT_PRIVATE_STANDALONE_CONFIG` set. pnext mirrors that: load the compat config, read the output
 // mode from the build-compat registry, and reproduce Next's exact messages.
 async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig> {
-  const config = await loadConfig(root);
-  await bootstrapCompat(config);
-  const mode = getBuildExtensions().compat.nextOutputMode();
+  const config = await loadConfig(root)
+  await bootstrapCompat(config)
+  const mode = getBuildExtensions().compat.nextOutputMode()
   if (mode === 'export') {
     console.error(
       '"next start" does not work with "output: export" configuration. ' +
         'Use "npx serve@latest out" instead.',
-    );
-    process.exit(1);
+    )
+    process.exit(1)
   }
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (mode === 'standalone' && !process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
     console.warn(
       '"next start" does not work with "output: standalone" configuration. ' +
         'Use "node .next/standalone/server.js" instead.',
-    );
+    )
   }
-  return config;
+  return config
 }
 
 // Graceful stop: quit accepting connections, wait for in-flight after() flushes (bounded), then exit
@@ -140,14 +139,14 @@ async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig>
 // server receives it twice - with `once` the second delivery hit the default disposition and killed
 // the process mid-drain.
 function installShutdownHandlers(server: { stop(closeActiveConnections?: boolean): void }) {
-  let shuttingDown = false;
+  let shuttingDown = false
   const shutdown = async () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    server.stop();
-    await drainWorkUnits();
-    process.exit(0);
-  };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+    if (shuttingDown) return
+    shuttingDown = true
+    server.stop()
+    await drainWorkUnits()
+    process.exit(0)
+  }
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
 }

package/src/{typegen.ts → cli/typegen.ts}

@@ -1,40 +1,40 @@
-import { existsSync } from 'node:fs';
-import { readFile, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { ResolvedConfig } from './config';
-import { loadConfig } from './config';
-import { ensureDir, toPosixPath } from './utils/fs';
-import { scanRoutes } from './routing/routes';
-import type { RouteManifestEntry } from './types';
+import { existsSync } from 'node:fs'
+import { readFile, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../config'
+import { loadConfig } from '../config'
+import { ensureDir, toPosixPath } from '../utils/fs'
+import { scanRoutes } from '../routing/routes'
+import type { RouteManifestEntry } from '../types'
 
 export interface TypegenResult {
-  file: string;
-  routes: number;
-  checks: number;
-  aliases: number;
+  file: string
+  routes: number
+  checks: number
+  aliases: number
 }
 
 export async function typegenProject(root?: string): Promise<TypegenResult> {
-  const config = await loadConfig(root);
-  const routes = await scanRoutes(config.appPath);
-  return writeTypegen(config, routes);
+  const config = await loadConfig(root)
+  const routes = await scanRoutes(config.appPath)
+  return writeTypegen(config, routes)
 }
 
 export async function writeTypegen(
   config: ResolvedConfig,
   allRoutes: RouteManifestEntry[],
 ): Promise<TypegenResult> {
-  const routes = allRoutes.filter(route => !route.interception && !route.synthetic);
-  const file = path.join(config.typesPath, 'pnext.gen.d.ts');
-  const source = typegenSource(routes);
-  await writeIfChanged(file, source);
-  const aliases = await writeRouteAliases(config, routes);
-  const checks = await writeChecks(config, routes);
-  return { file, routes: routes.length, checks, aliases };
+  const routes = allRoutes.filter(route => !route.interception && !route.synthetic)
+  const file = path.join(config.typesPath, 'pnext.gen.d.ts')
+  const source = typegenSource(routes)
+  await writeIfChanged(file, source)
+  const aliases = await writeRouteAliases(config, routes)
+  const checks = await writeChecks(config, routes)
+  return { file, routes: routes.length, checks, aliases }
 }
 
 function typegenSource(routes: RouteManifestEntry[]) {
-  const entries = routes.map(route => routeEntry(route)).join('\n');
+  const entries = routes.map(route => routeEntry(route)).join('\n')
 
   return `// This file is generated by PNext. Do not edit.
 import '@wular/pnext';
@@ -44,7 +44,7 @@ declare module '@wular/pnext' {
 ${entries}
   }
 }
-`;
+`
 }
 
 function routeEntry(route: RouteManifestEntry) {
@@ -53,41 +53,41 @@ function routeEntry(route: RouteManifestEntry) {
       params: ${paramsType(route)};
       mode: '${route.mode}';
       hydrated: ${route.client ? 'true' : 'false'};
-    };`;
+    };`
 }
 
 async function writeChecks(config: ResolvedConfig, routes: RouteManifestEntry[]) {
-  const checksDir = path.join(config.typesPath, 'checks');
-  await rm(checksDir, { recursive: true, force: true });
-  await ensureDir(checksDir);
+  const checksDir = path.join(config.typesPath, 'checks')
+  await rm(checksDir, { recursive: true, force: true })
+  await ensureDir(checksDir)
 
   await Promise.all(
     routes.map(route => {
-      const file = path.join(checksDir, `${route.id}.check.ts`);
-      return writeIfChanged(file, checkSource(checksDir, route));
+      const file = path.join(checksDir, `${route.id}.check.ts`)
+      return writeIfChanged(file, checkSource(checksDir, route))
     }),
-  );
+  )
 
-  return routes.length;
+  return routes.length
 }
 
 async function writeRouteAliases(config: ResolvedConfig, routes: RouteManifestEntry[]) {
-  const aliasesDir = path.join(config.typesPath, 'app');
-  await rm(aliasesDir, { recursive: true, force: true });
-  await ensureDir(aliasesDir);
+  const aliasesDir = path.join(config.typesPath, 'app')
+  await rm(aliasesDir, { recursive: true, force: true })
+  await ensureDir(aliasesDir)
 
   await Promise.all(
     routes.map(route => {
-      const file = path.join(aliasesDir, `${routeAliasPath(config, route)}.d.ts`);
-      return writeIfChanged(file, routeAliasSource(route));
+      const file = path.join(aliasesDir, `${routeAliasPath(config, route)}.d.ts`)
+      return writeIfChanged(file, routeAliasSource(route))
     }),
-  );
+  )
 
-  return routes.length;
+  return routes.length
 }
 
 function routeAliasSource(route: RouteManifestEntry) {
-  const routeType = routeKey(route.route);
+  const routeType = routeKey(route.route)
 
   return `// This file is generated by PNext. Do not edit.
 import type {
@@ -101,22 +101,22 @@ export type Params = PNextRouteParams<'${routeType}'>;
 export type PageProps = PNextPageProps<'${routeType}'>;
 export type RouteContext = PNextRouteContext<'${routeType}'>;
 export type StaticParams = PNextStaticParams<'${routeType}'>;
-`;
+`
 }
 
 function routeAliasPath(config: ResolvedConfig, route: RouteManifestEntry) {
-  const relative = toPosixPath(path.relative(config.appPath, route.file));
-  const extension = path.extname(relative);
-  return relative.slice(0, -extension.length);
+  const relative = toPosixPath(path.relative(config.appPath, route.file))
+  const extension = path.extname(relative)
+  return relative.slice(0, -extension.length)
 }
 
 function checkSource(checksDir: string, route: RouteManifestEntry) {
-  const routeImport = routeImportPath(checksDir, route.file);
-  const routeType = routeKey(route.route);
+  const routeImport = routeImportPath(checksDir, route.file)
+  const routeType = routeKey(route.route)
   const moduleType =
     route.kind === 'page'
       ? `PNextPageModule<'${routeType}'>`
-      : `PNextRouteHandlerModule<'${routeType}'>`;
+      : `PNextRouteHandlerModule<'${routeType}'>`
 
   return `// This file is generated by PNext. Do not edit.
 import type { PNextPageModule, PNextRouteHandlerModule } from '@wular/pnext/internal';
@@ -124,28 +124,28 @@ import * as routeModule from '${routeImport}';
 
 const check: ${moduleType} = routeModule;
 void check;
-`;
+`
 }
 
 function routeImportPath(fromDir: string, file: string) {
-  const extension = path.extname(file);
-  const withoutExtension = file.slice(0, -extension.length);
-  const relative = toPosixPath(path.relative(fromDir, withoutExtension));
-  return relative.startsWith('.') ? relative : `./${relative}`;
+  const extension = path.extname(file)
+  const withoutExtension = file.slice(0, -extension.length)
+  const relative = toPosixPath(path.relative(fromDir, withoutExtension))
+  return relative.startsWith('.') ? relative : `./${relative}`
 }
 
 function routeKey(route: string) {
-  return route.replace(/:([a-zA-Z0-9_]+)\*/g, '[...$1]').replace(/:([a-zA-Z0-9_]+)/g, '[$1]');
+  return route.replace(/:([a-zA-Z0-9_]+)\*/g, '[...$1]').replace(/:([a-zA-Z0-9_]+)/g, '[$1]')
 }
 
 function paramsType(route: RouteManifestEntry) {
-  const entries = route.params.map(param => `${JSON.stringify(param)}: string`);
-  if (route.catchAll) entries.push(`${JSON.stringify(route.catchAll)}: string[]`);
-  return entries.length > 0 ? `{ ${entries.join('; ')} }` : 'Record<string, never>';
+  const entries = route.params.map(param => `${JSON.stringify(param)}: string`)
+  if (route.catchAll) entries.push(`${JSON.stringify(route.catchAll)}: string[]`)
+  return entries.length > 0 ? `{ ${entries.join('; ')} }` : 'Record<string, never>'
 }
 
 async function writeIfChanged(file: string, source: string) {
-  if (existsSync(file) && (await readFile(file, 'utf8')) === source) return;
-  await ensureDir(path.dirname(file));
-  await writeFile(file, source);
+  if (existsSync(file) && (await readFile(file, 'utf8')) === source) return
+  await ensureDir(path.dirname(file))
+  await writeFile(file, source)
 }