@wular/pnext 0.0.3 → 0.0.6

package/src/compat/actions/unrecognized-error.ts

@@ -9,8 +9,8 @@
  */
 export class UnrecognizedActionError extends Error {
   constructor(...args: ConstructorParameters<typeof Error>) {
-    super(...args);
-    this.name = 'UnrecognizedActionError';
+    super(...args)
+    this.name = 'UnrecognizedActionError'
   }
 }
 
@@ -21,10 +21,10 @@ export class UnrecognizedActionError extends Error {
  * prototype) by the name/message the endpoint sends.
  */
 export function isUnrecognizedActionError(error: unknown): boolean {
-  if (error instanceof UnrecognizedActionError) return true;
+  if (error instanceof UnrecognizedActionError) return true
   return (
     error instanceof Error &&
     (error.name === 'UnrecognizedActionError' ||
       / was not found on the server\.?$/.test(error.message))
-  );
+  )
 }

package/src/compat/{index.ts → aliases.ts}

@@ -1,25 +1,25 @@
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import type { Plugin } from 'esbuild';
-import { frameworkRuntimeAliasEntries, pnextAliases, type CompatAliasTarget } from '../config';
-import type { PNextConfig } from '../types';
-import { escapeRegex, isIdentifier, uniqueIdentifier } from '../utils/source';
-import { actionClientStubPlugin, hasClientActionModules } from './actions/client-plugin';
-import { rewriteRootParamsSource } from './ppr/root-params-transform';
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import type { Plugin } from 'esbuild'
+import { frameworkRuntimeAliasEntries, pnextAliases, type CompatAliasTarget } from '../config'
+import type { PNextConfig } from '../types'
+import { escapeRegex, isIdentifier, uniqueIdentifier } from '../utils/code'
+import { actionClientStubPlugin, hasClientActionModules } from './actions/client-plugin'
+import { rewriteRootParamsSource } from './ppr/root-params-transform'
 
-export type CompatConfig = Pick<PNextConfig, 'compat'>;
+export type CompatConfig = Pick<PNextConfig, 'compat'>
 
 export function reactCompatEnabled(config: CompatConfig) {
-  return Boolean(config.compat?.next || config.compat?.react || reactCompilerOptions(config));
+  return Boolean(config.compat?.next || config.compat?.react || reactCompilerOptions(config))
 }
 
 export function reactCompilerOptions(config: CompatConfig) {
-  if (!config.compat?.reactCompiler) return undefined;
-  return { target: '18' };
+  if (!config.compat?.reactCompiler) return undefined
+  return { target: '18' }
 }
 
 export function nextCompatEnabled(config: CompatConfig) {
-  return Boolean(config.compat?.next);
+  return Boolean(config.compat?.next)
 }
 
 /** The only `next/dist/*` deep imports pnext shims (see reference/compat.md "Smaller surfaces"). */
@@ -29,7 +29,7 @@ export const SHIMMED_NEXT_DIST_PATHS = [
   'next/dist/server/web/spec-extension/unstable-no-store',
   'next/dist/server/web/spec-extension/revalidate',
   'next/dist/server/app-render/work-unit-async-storage.external',
-];
+]
 
 /**
  * Clear failure for compat-only imports in apps that never enabled the
@@ -41,25 +41,25 @@ export function missingCompatImportError(
 ): string | undefined {
   if (/^next(\/|$)/.test(specifier)) {
     if (!nextCompatEnabled(config)) {
-      return `'${specifier}' requires Next compatibility. Enable compat.next in pnext.config.ts.`;
+      return `'${specifier}' requires Next compatibility. Enable compat.next in pnext.config.ts.`
     }
     if (specifier.startsWith('next/dist/')) {
-      const bare = specifier.replace(/\.js$/, '');
+      const bare = specifier.replace(/\.js$/, '')
       if (!SHIMMED_NEXT_DIST_PATHS.includes(bare)) {
         return (
           `'${specifier}' is not a supported import: next/dist internals are not part of the ` +
           `public surface pnext shims. Only these next/dist/* paths are shimmed:\n` +
           SHIMMED_NEXT_DIST_PATHS.map(path => `  - ${path}`).join('\n') +
           `\nSee reference/compat.md ("Smaller surfaces") and report the library that needs a new shim.`
-        );
+        )
       }
     }
-    return undefined;
+    return undefined
   }
   if (/^react(-dom)?(\/|$)/.test(specifier) && !reactCompatEnabled(config)) {
-    return `'${specifier}' requires React compatibility. Enable compat.react (or compat.next) in pnext.config.ts.`;
+    return `'${specifier}' requires React compatibility. Enable compat.react (or compat.next) in pnext.config.ts.`
   }
-  return undefined;
+  return undefined
 }
 
 export function compatAliases(
@@ -71,7 +71,7 @@ export function compatAliases(
     ...pnextAliases(target),
     ...reactCompatAliases(config, target),
     ...nextCompatAliases(config, target),
-  };
+  }
 }
 
 /**
@@ -80,21 +80,21 @@ export function compatAliases(
  * instrumentation compatibility.
  */
 export function reactServerLayerAliases(config: CompatConfig): Record<string, string> {
-  if (!reactCompatEnabled(config)) return {};
-  const reactRoot = path.resolve(import.meta.dirname, 'react');
+  if (!reactCompatEnabled(config)) return {}
+  const reactRoot = path.resolve(import.meta.dirname, 'react')
   return {
     react: path.join(reactRoot, 'react-server.ts'),
     'react-dom': path.join(reactRoot, 'dom-react-server.ts'),
-  };
+  }
 }
 
 export function reactCompatAliases(
   config: CompatConfig,
   target: CompatAliasTarget,
 ): Record<string, string> {
-  if (!reactCompatEnabled(config)) return {};
-  const reactRoot = path.resolve(import.meta.dirname, 'react');
-  const runtime = frameworkRuntimeAliasEntries();
+  if (!reactCompatEnabled(config)) return {}
+  const reactRoot = path.resolve(import.meta.dirname, 'react')
+  const runtime = frameworkRuntimeAliasEntries()
   return {
     react: path.join(reactRoot, target === 'client' ? 'client.ts' : 'server.ts'),
     // dom.ts wraps preact/compat with the form-action hooks react-dom ships
@@ -115,19 +115,19 @@ export function reactCompatAliases(
     // package's own `require('react').useMemo` throws under preact SSR.
     'react/compiler-runtime': path.join(reactRoot, 'compiler-runtime.ts'),
     'react-compiler-runtime': path.join(reactRoot, 'compiler-runtime.ts'),
-  };
+  }
 }
 
 export function nextCompatAliases(
   config: CompatConfig,
   target: CompatAliasTarget,
 ): Record<string, string> {
-  if (!nextCompatEnabled(config)) return {};
-  return nextCompatAliasEntries(target);
+  if (!nextCompatEnabled(config)) return {}
+  return nextCompatAliasEntries(target)
 }
 
 export function nextCompatAliasEntries(target: CompatAliasTarget): Record<string, string> {
-  const nextRoot = path.resolve(import.meta.dirname, 'next');
+  const nextRoot = path.resolve(import.meta.dirname, 'next')
   return withJsExtensionAliases({
     next: path.join(nextRoot, 'index.ts'),
     // Client variant avoids node:async_hooks (render cache-meta collector) in
@@ -225,15 +225,15 @@ export function nextCompatAliasEntries(target: CompatAliasTarget): Record<string
           ),
         }
       : {}),
-  });
+  })
 }
 
 function withJsExtensionAliases(aliases: Record<string, string>) {
-  const entries = { ...aliases };
+  const entries = { ...aliases }
   for (const [specifier, target] of Object.entries(aliases)) {
-    if (specifier !== 'next') entries[`${specifier}.js`] = target;
+    if (specifier !== 'next') entries[`${specifier}.js`] = target
   }
-  return entries;
+  return entries
 }
 
 /**
@@ -242,8 +242,8 @@ function withJsExtensionAliases(aliases: Record<string, string>) {
  * happens to be installed.
  */
 export function compatAliasPlugin(config: CompatConfig): Plugin {
-  const aliases = compatAliases(config, 'client');
-  const specifiers = Object.keys(aliases);
+  const aliases = compatAliases(config, 'client')
+  const specifiers = Object.keys(aliases)
   return {
     name: 'pnext-compat-alias',
     setup(build) {
@@ -252,46 +252,46 @@ export function compatAliasPlugin(config: CompatConfig): Plugin {
       // stub participates in every client build without editing the client
       // build pipeline. No-op when no action modules were discovered.
       if (nextCompatEnabled(config) && hasClientActionModules()) {
-        void actionClientStubPlugin().setup(build);
+        void actionClientStubPlugin().setup(build)
       }
 
       build.onResolve({ filter: /^(?:react(?:-dom)?|next)(?:\/|$)/ }, args => {
-        if (aliases[args.path]) return undefined;
-        const message = missingCompatImportError(config, args.path);
-        return message ? { errors: [{ text: message }] } : undefined;
-      });
-      if (specifiers.length === 0) return;
+        if (aliases[args.path]) return undefined
+        const message = missingCompatImportError(config, args.path)
+        return message ? { errors: [{ text: message }] } : undefined
+      })
+      if (specifiers.length === 0) return
       build.onResolve(
         { filter: new RegExp(`^(${specifiers.map(escapeRegex).join('|')})$`) },
         async args => {
-          const target = aliases[args.path];
-          if (!target) return undefined;
-          if (path.isAbsolute(target)) return { path: target };
+          const target = aliases[args.path]
+          if (!target) return undefined
+          if (path.isAbsolute(target)) return { path: target }
           return build.resolve(target, {
             kind: args.kind,
             importer: args.importer,
             namespace: args.namespace,
             resolveDir: args.resolveDir,
-          });
+          })
         },
-      );
+      )
     },
-  };
+  }
 }
 
 // Compat apps render React's Suspense (the preact/compat class, via the react
 // aliases or a direct import). That identity is loaded lazily and only when
 // compat is enabled, so core apps never pull preact/compat into the server
 // process — core streaming uses PNext's own Suspense marker instead.
-let compatSuspense: unknown;
+let compatSuspense: unknown
 
 export async function ensureCompatSuspense(config: CompatConfig) {
-  if (compatSuspense !== undefined || !reactCompatEnabled(config)) return;
-  compatSuspense = ((await import('preact/compat')) as { Suspense: unknown }).Suspense;
+  if (compatSuspense !== undefined || !reactCompatEnabled(config)) return
+  compatSuspense = ((await import('preact/compat')) as { Suspense: unknown }).Suspense
 }
 
 export function compatSuspenseType() {
-  return compatSuspense;
+  return compatSuspense
 }
 
 /**
@@ -305,7 +305,7 @@ export function compatSuspenseType() {
 const fontRuntimePaths: Record<CompatAliasTarget, string> = {
   server: path.join(import.meta.dirname, 'next', 'font', 'runtime.ts'),
   client: path.join(import.meta.dirname, 'next', 'font', 'runtime-client.ts'),
-};
+}
 
 /**
  * Next-compat source rewrites for `next/font/google` and `next/font/local` imports. Only invoked when
@@ -321,15 +321,15 @@ export function rewriteNextFontSource(
   target: CompatAliasTarget = 'server',
   root?: string,
 ) {
-  if (!source.includes('next/font') && !source.includes('next/root-params')) return source;
+  if (!source.includes('next/font') && !source.includes('next/root-params')) return source
   // The single next/root-params rewrite in the tree; every other call site
   // reaches it through this pass rather than re-running its own copy.
-  source = rewriteRootParamsSource(source);
-  const runtimePath = fontRuntimePaths[target];
-  let next = rewriteNextGoogleFontImports(source, runtimePath);
-  const localFontNames = nextLocalFontImportNames(next);
-  if (localFontNames.size === 0) return next;
-  const callerFile = localFontCallerFile(file, root);
+  source = rewriteRootParamsSource(source)
+  const runtimePath = fontRuntimePaths[target]
+  let next = rewriteNextGoogleFontImports(source, runtimePath)
+  const localFontNames = nextLocalFontImportNames(next)
+  if (localFontNames.size === 0) return next
+  const callerFile = localFontCallerFile(file, root)
   // Rewrite each `NAME(...)` call to `NAME.withFile(<file>)(...)` so the runtime
   // gets the caller path (for `src` resolution + a stable per-caller hash). The
   // client runtime only uses `callerFile` for the hash (which must match the
@@ -338,16 +338,19 @@ export function rewriteNextFontSource(
     next = next.replace(
       new RegExp(`(?<![.$\\w])${escapeRegex(name)}\\s*\\(`, 'g'),
       `${name}.withFile(${JSON.stringify(callerFile)})(`,
-    );
+    )
   }
   // Next names local-font families after the binding (`const myFont = …`),
   // including when the loader lives in a package under node_modules.
   for (const name of localFontNames) {
     next = next.replace(
-      new RegExp(`((?:export\\s+)?(?:const|let|var)\\s+)([A-Za-z_$][\\w$]*)(\\s*=\\s*)${escapeRegex(name)}\\.withFile\\(([^)]*)\\)\\(`, 'g'),
+      new RegExp(
+        `((?:export\\s+)?(?:const|let|var)\\s+)([A-Za-z_$][\\w$]*)(\\s*=\\s*)${escapeRegex(name)}\\.withFile\\(([^)]*)\\)\\(`,
+        'g',
+      ),
       (_statement, declaration: string, binding: string, equals: string, caller: string) =>
         `${declaration}${binding}${equals}${name}.withFile(${caller}, ${JSON.stringify(binding)})(`,
-    );
+    )
   }
   // Replace the bare `import NAME from 'next/font/local'` with an import bound
   // directly to the runtime's absolute path. This avoids relying on server-side
@@ -356,65 +359,65 @@ export function rewriteNextFontSource(
   next = next.replace(
     /^[ \t]*import\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2\s*;?[ \t]*$/gm,
     (statement, name: string, _quote: string, specifier: string) => {
-      if (!isNextLocalFontSpecifier(specifier)) return statement;
-      return `import { localFont as ${name} } from ${JSON.stringify(runtimePath)};`;
+      if (!isNextLocalFontSpecifier(specifier)) return statement
+      return `import { localFont as ${name} } from ${JSON.stringify(runtimePath)};`
     },
-  );
-  return next;
+  )
+  return next
 }
 
 function rewriteNextGoogleFontImports(source: string, runtimePath: string) {
-  const statements: string[] = [];
-  const helperName = uniqueIdentifier(source, '__pnextGoogleFont');
-  const namespaceHelperName = uniqueIdentifier(source, '__pnextGoogleFonts', helperName);
+  const statements: string[] = []
+  const helperName = uniqueIdentifier(source, '__pnextGoogleFont')
+  const namespaceHelperName = uniqueIdentifier(source, '__pnextGoogleFonts', helperName)
   const rewritten = source.replace(
     /^[ \t]*import\s+(?!type\b)((?:[^\n;]|\n(?![ \t]*(?:import|export)\b))*?)\s+from\s+['"]next\/font\/google['"]\s*;?[ \t]*(?:\r?\n)?/gm,
     (_statement: string, clause: string) => {
-      const bindings = nextGoogleFontBindings(clause);
-      if (bindings.length === 0) return '';
+      const bindings = nextGoogleFontBindings(clause)
+      if (bindings.length === 0) return ''
       statements.push(
         ...bindings.map(binding =>
           googleFontBindingSource(binding, helperName, namespaceHelperName),
         ),
-      );
-      return '';
+      )
+      return ''
     },
-  );
+  )
 
-  if (statements.length === 0) return source;
+  if (statements.length === 0) return source
   return [
     `import { googleFont as ${helperName} } from ${JSON.stringify(runtimePath)};`,
     `const ${namespaceHelperName} = new Proxy({}, { get: (_target, key) => typeof key === 'string' ? ${helperName}(key.replace(/_/g, ' ')) : undefined });`,
     ...statements,
     rewritten,
-  ].join('\n');
+  ].join('\n')
 }
 
 interface GoogleFontBinding {
-  imported: string;
-  local: string;
-  namespace?: boolean;
+  imported: string
+  local: string
+  namespace?: boolean
 }
 
 function nextGoogleFontBindings(clause: string): GoogleFontBinding[] {
-  const trimmed = clause.trim();
-  const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(trimmed)?.[1];
-  if (namespace) return [{ imported: namespace, local: namespace, namespace: true }];
+  const trimmed = clause.trim()
+  const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(trimmed)?.[1]
+  if (namespace) return [{ imported: namespace, local: namespace, namespace: true }]
 
-  const named = /\{([\s\S]*)\}/.exec(trimmed)?.[1];
-  if (!named) return [];
+  const named = /\{([\s\S]*)\}/.exec(trimmed)?.[1]
+  if (!named) return []
   return named
     .split(',')
     .map(part => part.trim())
     .filter(Boolean)
     .flatMap(part => {
-      if (part.startsWith('type ')) return [];
-      const [importedRaw, localRaw] = part.split(/\s+as\s+/);
-      const imported = importedRaw?.trim();
-      const local = (localRaw ?? importedRaw)?.trim();
-      if (!imported || !local || !isIdentifier(imported) || !isIdentifier(local)) return [];
-      return [{ imported, local }];
-    });
+      if (part.startsWith('type ')) return []
+      const [importedRaw, localRaw] = part.split(/\s+as\s+/)
+      const imported = importedRaw?.trim()
+      const local = (localRaw ?? importedRaw)?.trim()
+      if (!imported || !local || !isIdentifier(imported) || !isIdentifier(local)) return []
+      return [{ imported, local }]
+    })
 }
 
 function googleFontBindingSource(
@@ -422,37 +425,37 @@ function googleFontBindingSource(
   helperName: string,
   namespaceHelperName: string,
 ) {
-  if (binding.namespace) return `const ${binding.local} = ${namespaceHelperName};`;
-  return `const ${binding.local} = ${helperName}(${JSON.stringify(googleFontFamily(binding.imported))});`;
+  if (binding.namespace) return `const ${binding.local} = ${namespaceHelperName};`
+  return `const ${binding.local} = ${helperName}(${JSON.stringify(googleFontFamily(binding.imported))});`
 }
 
 function googleFontFamily(exportName: string) {
-  return exportName.replace(/_/g, ' ');
+  return exportName.replace(/_/g, ' ')
 }
 
 function nextLocalFontImportNames(source: string) {
-  const names = new Set<string>();
-  const pattern = /\bimport\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2/g;
-  let match: RegExpExecArray | null;
+  const names = new Set<string>()
+  const pattern = /\bimport\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2/g
+  let match: RegExpExecArray | null
   while ((match = pattern.exec(source))) {
-    if (match[1] && match[3] && isNextLocalFontSpecifier(match[3])) names.add(match[1]);
+    if (match[1] && match[3] && isNextLocalFontSpecifier(match[3])) names.add(match[1])
   }
-  return names;
+  return names
 }
 
 function isNextLocalFontSpecifier(specifier: string) {
-  if (specifier === 'next/font/local' || specifier === 'next/font/local.js') return true;
-  const normalized = specifier.replace(/^file:\/\//, '').replace(/\\/g, '/');
-  return /\/compat\/next\/font\/local\.[jt]s$/.test(normalized);
+  if (specifier === 'next/font/local' || specifier === 'next/font/local.js') return true
+  const normalized = specifier.replace(/^file:\/\//, '').replace(/\\/g, '/')
+  return /\/compat\/next\/font\/local\.[jt]s$/.test(normalized)
 }
 
 function localFontCallerFile(file: string, root: string | undefined) {
-  if (path.isAbsolute(file)) return file;
-  if (file.startsWith('.')) return path.resolve(root ?? process.cwd(), file);
-  if (!root) return file;
+  if (path.isAbsolute(file)) return file
+  if (file.startsWith('.')) return path.resolve(root ?? process.cwd(), file)
+  if (!root) return file
   try {
-    return createRequire(path.join(root, 'pnext-resolve.cjs')).resolve(file);
+    return createRequire(path.join(root, 'pnext-resolve.cjs')).resolve(file)
   } catch {
-    return file;
+    return file
   }
 }

package/src/compat/bundler/bun-externals.ts

@@ -1,11 +1,11 @@
-import { uniqueIdentifier } from '../../utils/source';
+import { uniqueIdentifier } from '../../utils/code'
 
 // A quoted `'bun'`/`'bun:x'` specifier anywhere in the source. Deliberately not
 // the module record's edges: a route handler looping
 // `require(name)` over a table of module names has NO static edge, and Next
 // still externalizes those. Matching the quoted specifier keeps that reach while
 // staying far tighter than the old bare-word `bun` regex.
-const QUOTED_BUN_SPECIFIER = /(['"])bun(?::[^'"]+)?\1/;
+const QUOTED_BUN_SPECIFIER = /(['"])bun(?::[^'"]+)?\1/
 
 /**
  * Guard `bun`/`bun:*` builtins behind a runtime throw so a module importing one can still be compiled
@@ -13,27 +13,27 @@ const QUOTED_BUN_SPECIFIER = /(['"])bun(?::[^'"]+)?\1/;
  * require/import calls too, which no record can name.
  */
 export function rewriteBunBuiltinExternals(source: string, _file = 'module.tsx'): string {
-  if (!source.includes('bun')) return source;
-  if (!QUOTED_BUN_SPECIFIER.test(source)) return source;
+  if (!source.includes('bun')) return source
+  if (!QUOTED_BUN_SPECIFIER.test(source)) return source
 
-  const requireName = uniqueIdentifier(source, '__pnext_require_external');
-  const importName = uniqueIdentifier(source, '__pnext_import_external', requireName);
-  const literalRequires: string[] = [];
+  const requireName = uniqueIdentifier(source, '__pnext_require_external')
+  const importName = uniqueIdentifier(source, '__pnext_import_external', requireName)
+  const literalRequires: string[] = []
   let next = source.replace(
     /\brequire\s*\(\s*(['"])(bun(?::[^'"]+)?)\1\s*\)/g,
     (_match, _quote: string, specifier: string) => {
-      literalRequires.push(specifier);
-      return `__pnext_bun_external_${literalRequires.length - 1}__`;
+      literalRequires.push(specifier)
+      return `__pnext_bun_external_${literalRequires.length - 1}__`
     },
-  );
-  next = next.replace(/\brequire\s*\(/g, `${requireName}(`);
+  )
+  next = next.replace(/\brequire\s*\(/g, `${requireName}(`)
   next = next.replace(/__pnext_bun_external_(\d+)__/g, (_match, index: string) => {
-    const specifier = literalRequires[Number(index)];
-    return `${requireName}(${JSON.stringify(specifier)}, () => require(${JSON.stringify(specifier)}))`;
-  });
-  next = next.replace(/\bimport\s*\(/g, `${importName}(`);
+    const specifier = literalRequires[Number(index)]
+    return `${requireName}(${JSON.stringify(specifier)}, () => require(${JSON.stringify(specifier)}))`
+  })
+  next = next.replace(/\bimport\s*\(/g, `${importName}(`)
 
-  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? '';
+  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? ''
   const helpers = [
     `const ${requireName} = (specifier, load) => {`,
     `  if (specifier === 'bun' || specifier.startsWith('bun:')) {`,
@@ -48,6 +48,6 @@ export function rewriteBunBuiltinExternals(source: string, _file = 'module.tsx')
     '  return import(specifier);',
     '};',
     '',
-  ].join('\n');
-  return `${directive}${helpers}${next.slice(directive.length)}`;
+  ].join('\n')
+  return `${directive}${helpers}${next.slice(directive.length)}`
 }