@wular/pnext 0.0.3 → 0.0.6

package/src/compat/lifecycle/instrumentation-client.ts

@@ -17,12 +17,12 @@
 //
 // Zero-cost: apps without an instrumentation-client file get no bundle, no build work, no head tag.
 
-import { existsSync, mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { build } from '../../utils/esbuild';
-import type { ResolvedConfig } from '../../config';
-import { getNextConfig } from '../next/config-loader';
-import { instrumentationLookupRoots } from './instrumentation';
+import { existsSync, mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { build } from '../../utils/esbuild'
+import type { ResolvedConfig } from '../../config'
+import { getNextConfig } from '../next/config-loader'
+import { instrumentationLookupRoots } from './instrumentation'
 
 const CLIENT_BASENAMES = [
   'instrumentation-client.ts',
@@ -30,28 +30,28 @@ const CLIENT_BASENAMES = [
   'instrumentation-client.js',
   'instrumentation-client.mjs',
   'instrumentation-client.mts',
-];
+]
 
 /** The served pathname of the bundled instrumentation-client asset. */
-export const INSTRUMENTATION_CLIENT_ASSET = 'assets/instrumentation-client.js';
+export const INSTRUMENTATION_CLIENT_ASSET = 'assets/instrumentation-client.js'
 
 function findInstrumentationClient(config: ResolvedConfig): string | undefined {
   for (const root of instrumentationLookupRoots(config)) {
     for (const name of CLIENT_BASENAMES) {
-      const candidate = path.join(root, name);
-      if (existsSync(candidate)) return candidate;
+      const candidate = path.join(root, name)
+      if (existsSync(candidate)) return candidate
     }
   }
-  return undefined;
+  return undefined
 }
 
 /** `instrumentationClientInject` module paths from next.config, root-resolved. */
 function injectEntries(config: ResolvedConfig): string[] {
-  const value = getNextConfig().instrumentationClientInject;
-  if (!Array.isArray(value)) return [];
+  const value = getNextConfig().instrumentationClientInject
+  if (!Array.isArray(value)) return []
   return value
     .filter((entry): entry is string => typeof entry === 'string')
-    .map(entry => path.resolve(config.root, entry));
+    .map(entry => path.resolve(config.root, entry))
 }
 
 /**
@@ -61,8 +61,8 @@ function injectEntries(config: ResolvedConfig): string[] {
 function entrySource(modules: string[]): string {
   const imports = modules
     .map((file, index) => `import * as mod${index} from ${JSON.stringify(file)};`)
-    .join('\n');
-  const names = modules.map((_file, index) => `mod${index}`).join(', ');
+    .join('\n')
+  const names = modules.map((_file, index) => `mod${index}`).join(', ')
   return `${imports}
 const hooks = [${names}]
   .map(mod => (mod && typeof mod.onRouterTransitionStart === 'function' ? mod.onRouterTransitionStart : null))
@@ -78,7 +78,7 @@ if (hooks.length > 0) {
     }
   };
 }
-`;
+`
 }
 
 /**
@@ -87,16 +87,16 @@ if (hooks.length > 0) {
  * step (before prerendering, so prerendered documents include the head tag).
  */
 export async function buildInstrumentationClient(config: ResolvedConfig): Promise<void> {
-  const userFile = findInstrumentationClient(config);
-  if (!userFile) return;
-  const modules = [...injectEntries(config), userFile];
-  const workDir = path.join(config.outPath, 'cache', 'instrumentation-client');
-  mkdirSync(workDir, { recursive: true });
-  const entryFile = path.join(workDir, 'entry.ts');
-  const outfile = path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET);
-  mkdirSync(path.dirname(outfile), { recursive: true });
-  await Bun.write(entryFile, entrySource(modules));
-  const tsconfig = path.join(config.root, 'tsconfig.json');
+  const userFile = findInstrumentationClient(config)
+  if (!userFile) return
+  const modules = [...injectEntries(config), userFile]
+  const workDir = path.join(config.outPath, 'cache', 'instrumentation-client')
+  mkdirSync(workDir, { recursive: true })
+  const entryFile = path.join(workDir, 'entry.ts')
+  const outfile = path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET)
+  mkdirSync(path.dirname(outfile), { recursive: true })
+  await Bun.write(entryFile, entrySource(modules))
+  const tsconfig = path.join(config.root, 'tsconfig.json')
   await build({
     entryPoints: [entryFile],
     outfile,
@@ -108,23 +108,21 @@ export async function buildInstrumentationClient(config: ResolvedConfig): Promis
     ...(existsSync(tsconfig) ? { tsconfig } : {}),
     logLevel: 'silent',
     sourcemap: false,
-  });
-  bundlePresence = true;
+  })
+  bundlePresence = true
 }
 
-let bundlePresence: boolean | undefined;
+let bundlePresence: boolean | undefined
 
 /** Whether the built instrumentation-client bundle exists (cached). */
 function hasInstrumentationClientBundle(config: ResolvedConfig): boolean {
-  bundlePresence ??= existsSync(
-    path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET),
-  );
-  return bundlePresence;
+  bundlePresence ??= existsSync(path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET))
+  return bundlePresence
 }
 
 /** Test-only reset for the bundle-presence cache. */
 export function resetInstrumentationClientForTest(): void {
-  bundlePresence = undefined;
+  bundlePresence = undefined
 }
 
 /**
@@ -132,7 +130,7 @@ export function resetInstrumentationClientForTest(): void {
  * app has none. basePath-prefixed like every other asset href.
  */
 export function instrumentationClientHeadTag(config: ResolvedConfig): string {
-  if (!hasInstrumentationClientBundle(config)) return '';
-  const prefix = config.basePath ?? '';
-  return `<script type="module" src="${prefix}/${INSTRUMENTATION_CLIENT_ASSET}"></script>`;
+  if (!hasInstrumentationClientBundle(config)) return ''
+  const prefix = config.basePath ?? ''
+  return `<script type="module" src="${prefix}/${INSTRUMENTATION_CLIENT_ASSET}"></script>`
 }

package/src/compat/lifecycle/instrumentation.ts

@@ -12,15 +12,15 @@
 // separate module state) and calling its register() with NEXT_RUNTIME='edge' set for the duration.
 // Apps without edge entities never get the pass.
 
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { createRequire } from 'node:module';
-import type { Plugin } from 'esbuild';
-import { build } from '../../utils/esbuild';
-import type { ResolvedConfig } from '../../config';
-import { resolveExternalLoadTarget } from '../../resolve/imports';
-import { compatAliases, reactServerLayerAliases } from '../index';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import type { Plugin } from 'esbuild'
+import { build } from '../../utils/esbuild'
+import type { ResolvedConfig } from '../../config'
+import { resolveExternalLoadTarget } from '../../resolve/imports'
+import { compatAliases, reactServerLayerAliases } from '../aliases'
 
 const INSTRUMENTATION_BASENAMES = [
   'instrumentation.ts',
@@ -28,7 +28,7 @@ const INSTRUMENTATION_BASENAMES = [
   'instrumentation.js',
   'instrumentation.mjs',
   'instrumentation.tsx',
-];
+]
 
 /**
  * The instrumentation bundle keeps node_modules external, so every bare specifier it emits is resolved
@@ -40,84 +40,84 @@ const INSTRUMENTATION_BASENAMES = [
  * server layer, so register() must observe the hook-free React.
  */
 function instrumentationAliases(config: ResolvedConfig): Record<string, string> {
-  return { ...compatAliases(config, 'server'), ...reactServerLayerAliases(config) };
+  return { ...compatAliases(config, 'server'), ...reactServerLayerAliases(config) }
 }
 
 function instrumentationPlugin(root: string, config?: ResolvedConfig): Plugin {
-  const appRequire = createRequire(path.join(root, 'package.json'));
-  const aliases = config ? instrumentationAliases(config) : {};
+  const appRequire = createRequire(path.join(root, 'package.json'))
+  const aliases = config ? instrumentationAliases(config) : {}
   return {
     name: 'pnext-instrumentation',
     setup(builder) {
       builder.onResolve({ filter: /^[^./]/ }, args => {
-        const alias = aliases[args.path];
-        if (!alias) return undefined;
+        const alias = aliases[args.path]
+        if (!alias) return undefined
         return {
           path: path.isAbsolute(alias) ? pathToFileURL(alias).href : alias,
           external: true,
-        };
-      });
+        }
+      })
       builder.onResolve({ filter: /^server-only$/ }, () => ({
         path: 'server-only',
         namespace: 'pnext',
-      }));
-      builder.onLoad({ filter: /^server-only$/, namespace: 'pnext' }, () => ({ contents: '' }));
+      }))
+      builder.onLoad({ filter: /^server-only$/, namespace: 'pnext' }, () => ({ contents: '' }))
       builder.onResolve({ filter: /^@vercel\/otel$/ }, () => {
         try {
-          appRequire.resolve('@vercel/otel');
-          return undefined;
+          appRequire.resolve('@vercel/otel')
+          return undefined
         } catch {
-          return { path: '@vercel/otel', namespace: 'pnext' };
+          return { path: '@vercel/otel', namespace: 'pnext' }
         }
-      });
+      })
       builder.onLoad({ filter: /^@vercel\/otel$/, namespace: 'pnext' }, () => ({
         contents: 'export function registerOTel() {}',
-      }));
+      }))
       builder.onResolve({ filter: /^[^./]/ }, args => {
         const target = resolveExternalLoadTarget({
           root,
           fromFile: args.importer || path.join(root, 'instrumentation.ts'),
           specifier: args.path,
           target: 'server',
-        });
-        return target ? { path: target } : undefined;
-      });
+        })
+        return target ? { path: target } : undefined
+      })
     },
-  };
+  }
 }
 
 export type OnRequestErrorHook = (
   error: unknown,
   request: { path: string; method: string; headers: Record<string, string> },
   context: Record<string, unknown>,
-) => void | Promise<void>;
+) => void | Promise<void>
 
 interface InstrumentationModule {
-  register?: () => void | Promise<void>;
-  onRequestError?: OnRequestErrorHook;
+  register?: () => void | Promise<void>
+  onRequestError?: OnRequestErrorHook
 }
 
-let loaded: InstrumentationModule | undefined;
-let readyGate: Promise<void> | undefined;
+let loaded: InstrumentationModule | undefined
+let readyGate: Promise<void> | undefined
 
 /** The user onRequestError export, once instrumentation has loaded. */
 export function getUserOnRequestError(): OnRequestErrorHook | undefined {
-  return loaded?.onRequestError;
+  return loaded?.onRequestError
 }
 
 /** Resolve once instrumentation register() has completed (or there is none). */
 export function instrumentationReady(): Promise<void> {
-  return readyGate ?? Promise.resolve();
+  return readyGate ?? Promise.resolve()
 }
 
 function findInstrumentation(config: ResolvedConfig): string | undefined {
   for (const root of instrumentationLookupRoots(config)) {
     for (const name of INSTRUMENTATION_BASENAMES) {
-      const candidate = path.join(root, name);
-      if (existsSync(candidate)) return candidate;
+      const candidate = path.join(root, name)
+      if (existsSync(candidate)) return candidate
     }
   }
-  return undefined;
+  return undefined
 }
 
 /**
@@ -126,9 +126,9 @@ function findInstrumentation(config: ResolvedConfig): string | undefined {
  * ignored). Apps without a `src/` source tree read from the project root.
  */
 export function instrumentationLookupRoots(config: ResolvedConfig): string[] {
-  const src = path.join(config.root, 'src');
-  const usesSrc = existsSync(path.join(src, 'app')) || existsSync(path.join(src, 'pages'));
-  return usesSrc ? [src] : [config.root];
+  const src = path.join(config.root, 'src')
+  const usesSrc = existsSync(path.join(src, 'app')) || existsSync(path.join(src, 'pages'))
+  return usesSrc ? [src] : [config.root]
 }
 
 async function importInstrumentation(
@@ -136,13 +136,13 @@ async function importInstrumentation(
   config: ResolvedConfig,
   suffix = '',
 ): Promise<InstrumentationModule> {
-  const root = config.root;
+  const root = config.root
   // Under config.outPath, so a dev server's scratch bundle lives in its own
   // subtree and a concurrent build never removes it mid-import.
-  const outDir = path.join(config.outPath, 'instrumentation');
-  mkdirSync(outDir, { recursive: true });
-  const outfile = path.join(outDir, `instrumentation.${Date.now()}${suffix}.mjs`);
-  const tsconfig = path.join(root, 'tsconfig.json');
+  const outDir = path.join(config.outPath, 'instrumentation')
+  mkdirSync(outDir, { recursive: true })
+  const outfile = path.join(outDir, `instrumentation.${Date.now()}${suffix}.mjs`)
+  const tsconfig = path.join(root, 'tsconfig.json')
   try {
     await build({
       entryPoints: [file],
@@ -161,10 +161,10 @@ async function importInstrumentation(
       },
       logLevel: 'silent',
       sourcemap: false,
-    });
-    return (await import(pathToFileURL(outfile).href)) as InstrumentationModule;
+    })
+    return (await import(pathToFileURL(outfile).href)) as InstrumentationModule
   } finally {
-    rmSync(outfile, { force: true });
+    rmSync(outfile, { force: true })
   }
 }
 
@@ -174,11 +174,11 @@ async function importInstrumentation(
  * the register() completion is tracked by instrumentationReady().
  */
 export function loadInstrumentation(config: ResolvedConfig): void {
-  if (readyGate) return;
-  const file = findInstrumentation(config);
+  if (readyGate) return
+  const file = findInstrumentation(config)
   if (!file) {
-    readyGate = Promise.resolve();
-    return;
+    readyGate = Promise.resolve()
+    return
   }
   readyGate = (async () => {
     try {
@@ -187,14 +187,14 @@ export function loadInstrumentation(config: ResolvedConfig): void {
       // baseline runtime is 'nodejs' (edge-only fixtures still run here).
 
       // eslint-disable-next-line turbo/no-undeclared-env-vars
-      if (!process.env.NEXT_RUNTIME) process.env.NEXT_RUNTIME = 'nodejs';
-      loaded = await importInstrumentation(file, config);
-      await loaded.register?.();
-      if (appHasEdgeEntities(config)) await runEdgeRegisterPass(file, config);
+      if (!process.env.NEXT_RUNTIME) process.env.NEXT_RUNTIME = 'nodejs'
+      loaded = await importInstrumentation(file, config)
+      await loaded.register?.()
+      if (appHasEdgeEntities(config)) await runEdgeRegisterPass(file, config)
     } catch (error) {
-      console.error('instrumentation register() failed:', error);
+      console.error('instrumentation register() failed:', error)
     }
-  })();
+  })()
 }
 
 /**
@@ -204,29 +204,29 @@ export function loadInstrumentation(config: ResolvedConfig): void {
  */
 async function runEdgeRegisterPass(file: string, config: ResolvedConfig): Promise<void> {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const previous = process.env.NEXT_RUNTIME;
+  const previous = process.env.NEXT_RUNTIME
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  process.env.NEXT_RUNTIME = 'edge';
+  process.env.NEXT_RUNTIME = 'edge'
   try {
-    const edgeInstance = await importInstrumentation(file, config, '.edge');
-    await edgeInstance.register?.();
+    const edgeInstance = await importInstrumentation(file, config, '.edge')
+    await edgeInstance.register?.()
   } catch (error) {
-    console.error('instrumentation register() (edge pass) failed:', error);
+    console.error('instrumentation register() (edge pass) failed:', error)
   } finally {
     if (previous === undefined) {
       // eslint-disable-next-line turbo/no-undeclared-env-vars
-      delete process.env.NEXT_RUNTIME;
+      delete process.env.NEXT_RUNTIME
     } else {
       // eslint-disable-next-line turbo/no-undeclared-env-vars
-      process.env.NEXT_RUNTIME = previous;
+      process.env.NEXT_RUNTIME = previous
     }
   }
 }
 
-const SOURCE_FILE_RE = /\.(?:ts|tsx|js|jsx|mjs|mts|cjs|cts)$/;
+const SOURCE_FILE_RE = /\.(?:ts|tsx|js|jsx|mjs|mts|cjs|cts)$/
 // `export const runtime = 'edge'` (app router) or `config = { runtime:
 // 'edge' | 'experimental-edge' }` (pages router / API routes).
-const EDGE_RUNTIME_RE = /\bruntime\b\s*[:=]\s*['"](?:experimental-)?edge['"]/;
+const EDGE_RUNTIME_RE = /\bruntime\b\s*[:=]\s*['"](?:experimental-)?edge['"]/
 
 /**
  * Whether the app contains anything Next would boot the edge runtime for:
@@ -235,46 +235,46 @@ const EDGE_RUNTIME_RE = /\bruntime\b\s*[:=]\s*['"](?:experimental-)?edge['"]/;
  * at boot; apps without instrumentation never pay).
  */
 function appHasEdgeEntities(config: ResolvedConfig): boolean {
-  const roots = [config.root, path.join(config.root, 'src')];
+  const roots = [config.root, path.join(config.root, 'src')]
   for (const root of roots) {
     for (const name of ['middleware', 'proxy']) {
       for (const ext of ['ts', 'js', 'mts', 'mjs']) {
-        if (existsSync(path.join(root, `${name}.${ext}`))) return true;
+        if (existsSync(path.join(root, `${name}.${ext}`))) return true
       }
     }
     for (const dir of ['app', 'pages']) {
-      if (sourceTreeDeclaresEdgeRuntime(path.join(root, dir))) return true;
+      if (sourceTreeDeclaresEdgeRuntime(path.join(root, dir))) return true
     }
   }
-  return false;
+  return false
 }
 
 function sourceTreeDeclaresEdgeRuntime(dir: string): boolean {
-  let entries: string[];
+  let entries: string[]
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync(dir)
   } catch {
-    return false;
+    return false
   }
   for (const entry of entries) {
-    if (entry === 'node_modules' || entry.startsWith('.')) continue;
-    const full = path.join(dir, entry);
-    let stats;
+    if (entry === 'node_modules' || entry.startsWith('.')) continue
+    const full = path.join(dir, entry)
+    let stats
     try {
-      stats = statSync(full);
+      stats = statSync(full)
     } catch {
-      continue;
+      continue
     }
     if (stats.isDirectory()) {
-      if (sourceTreeDeclaresEdgeRuntime(full)) return true;
-      continue;
+      if (sourceTreeDeclaresEdgeRuntime(full)) return true
+      continue
     }
-    if (!SOURCE_FILE_RE.test(entry)) continue;
+    if (!SOURCE_FILE_RE.test(entry)) continue
     try {
-      if (EDGE_RUNTIME_RE.test(readFileSync(full, 'utf8'))) return true;
+      if (EDGE_RUNTIME_RE.test(readFileSync(full, 'utf8'))) return true
     } catch {
       // unreadable file — skip
     }
   }
-  return false;
+  return false
 }

package/src/compat/lifecycle/node-console.ts

@@ -1,19 +1,19 @@
-import { format } from 'node:util';
+import { format } from 'node:util'
 
-const installed = Symbol.for('pnext.node-console-format-installed');
+const installed = Symbol.for('pnext.node-console-format-installed')
 
 export function installNodeConsoleFormat(): void {
-  const state = globalThis as typeof globalThis & Record<symbol, true | undefined>;
-  if (state[installed]) return;
-  state[installed] = true;
-  const log = console.log.bind(console);
-  console.log = (...args: unknown[]) => log(format(...args));
+  const state = globalThis as typeof globalThis & Record<symbol, true | undefined>
+  if (state[installed]) return
+  state[installed] = true
+  const log = console.log.bind(console)
+  console.log = (...args: unknown[]) => log(format(...args))
   // Errors too: bun prints a thrown/logged Error as `error: message` (and uses
   // `err.name` alone for a renamed one), while Node — and therefore every Next
   // e2e expectation — prints util.inspect's `ClassName: message` /
   // `ClassName [name]: message` header followed by the stack.
-  const error = console.error.bind(console);
-  console.error = (...args: unknown[]) => error(format(...args));
-  const warn = console.warn.bind(console);
-  console.warn = (...args: unknown[]) => warn(format(...args));
+  const error = console.error.bind(console)
+  console.error = (...args: unknown[]) => error(format(...args))
+  const warn = console.warn.bind(console)
+  console.warn = (...args: unknown[]) => warn(format(...args))
 }