@wular/pnext 0.0.4 → 0.0.7

package/src/compat-bootstrap.ts

@@ -16,38 +16,38 @@
 //
 // The enablement gate is inlined here (a pure read of config.compat) rather than imported from
 // compat, so this file carries no static edge into compat. It must stay in sync with
-// compat/index.ts reactCompatEnabled/nextCompatEnabled.
+// compat/aliases.ts reactCompatEnabled/nextCompatEnabled.
 
-import type { ResolvedConfig } from './config';
-import { onExtensionHostReset } from './extensions';
+import type { ResolvedConfig } from './config'
+import { onExtensionHostReset } from './extensions'
 
 /** True when either Next or React compatibility (or the React compiler) is on. */
 function compatEnabled(config: ResolvedConfig): boolean {
-  const compat = config.compat;
-  return Boolean(compat?.next || compat?.react || compat?.reactCompiler);
+  const compat = config.compat
+  return Boolean(compat?.next || compat?.react || compat?.reactCompiler)
 }
 
-let bootRegistration: Promise<void> | undefined;
-let registration: Promise<void> | undefined;
+let bootRegistration: Promise<void> | undefined
+let registration: Promise<void> | undefined
 
 // A fresh host has none of compat's registrations, so the "already registered"
 // memo has to go with it — otherwise the next bootstrap call is a no-op and the
 // host stays empty for the rest of the process.
 onExtensionHostReset(() => {
-  bootRegistration = undefined;
-  registration = undefined;
-});
+  bootRegistration = undefined
+  registration = undefined
+})
 
 /**
  * Register the boot tier: the compat facts core consults before the first
  * compile. No-op (and no compat code loaded) for a pure-core app.
  */
 export function bootstrapCompatBoot(config: ResolvedConfig): Promise<void> {
-  if (!compatEnabled(config)) return Promise.resolve();
+  if (!compatEnabled(config)) return Promise.resolve()
   bootRegistration ??= import('./compat/register/boot').then(module =>
     module.registerCompatBootExtensions(config),
-  );
-  return bootRegistration;
+  )
+  return bootRegistration
 }
 
 /**
@@ -59,9 +59,9 @@ export function bootstrapCompat(
   config: ResolvedConfig,
   options: { serve?: boolean } = {},
 ): Promise<void> {
-  if (!compatEnabled(config)) return Promise.resolve();
+  if (!compatEnabled(config)) return Promise.resolve()
   registration ??= bootstrapCompatBoot(config)
     .then(() => import('./compat/register/index'))
-    .then(module => module.registerCompatExtensions(config, options));
-  return registration;
+    .then(module => module.registerCompatExtensions(config, options))
+  return registration
 }

package/src/config.ts

@@ -1,31 +1,31 @@
-import { existsSync, realpathSync } from 'node:fs';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import path from 'node:path';
-import { loadEnv } from './env';
-import { findWorkspaceRoot } from './resolve/imports';
-import type { PNextConfig } from './types';
-import { setCacheComponents } from './ppr';
+import { existsSync, realpathSync } from 'node:fs'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import path from 'node:path'
+import { loadEnv } from './env'
+import { findWorkspaceRoot } from './resolve/imports'
+import { PREFETCH_MODES, type PNextConfig } from './types'
+import { setCacheComponents } from './render/ppr'
 
 export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>> &
   Omit<PNextConfig, 'outDir' | 'basePath'> & {
-    root: string;
-    workspaceRoot: string;
-    appDir: string;
-    publicDir: 'public';
-    appPath: string;
-    publicPath: string;
+    root: string
+    workspaceRoot: string
+    appDir: string
+    publicDir: 'public'
+    appPath: string
+    publicPath: string
     /** Where this process writes and serves from: the out root, or `<outRoot>/dev` in dev. */
-    outPath: string;
+    outPath: string
     /** The out root itself (`.pnext`), identical in dev and build. */
-    outRootPath: string;
+    outRootPath: string
     /** Generated types — always under the out root, because tsconfig points at it. */
-    typesPath: string;
-  };
+    typesPath: string
+  }
 
 const defaultConfig = {
   outDir: '.pnext',
   basePath: '',
-} satisfies Required<Pick<PNextConfig, 'outDir' | 'basePath'>>;
+} satisfies Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
 
 // configSources seam. Core owns the shape; compat populates it.
 //
@@ -38,22 +38,22 @@ const defaultConfig = {
 // dynamic import when compat.next is enabled - mirroring the compat-bootstrap gate so core keeps no static
 // edge into compat.
 export interface ConfigSourceOverrides {
-  basePath?: string;
-  trailingSlash?: boolean;
-  skipTrailingSlashRedirect?: boolean;
-  outDir?: string;
-  assetPrefix?: string;
-  productionBrowserSourceMaps?: boolean;
+  basePath?: string
+  trailingSlash?: boolean
+  skipTrailingSlashRedirect?: boolean
+  outDir?: string
+  assetPrefix?: string
+  productionBrowserSourceMaps?: boolean
 }
 export type ConfigSource = (
   root: string,
   options: { dev?: boolean },
-) => Promise<ConfigSourceOverrides>;
+) => Promise<ConfigSourceOverrides>
 
-let configSource: ConfigSource | undefined;
+let configSource: ConfigSource | undefined
 
 export function registerConfigSource(source: ConfigSource): void {
-  configSource = source;
+  configSource = source
 }
 
 async function resolveConfigSource(
@@ -61,44 +61,45 @@ async function resolveConfigSource(
   root: string,
   options: { dev?: boolean },
 ): Promise<ConfigSourceOverrides> {
-  if (!config.compat?.next) return {};
+  if (!config.compat?.next) return {}
   if (!configSource) {
-    await import('./compat/register/config').then(module => module.registerConfigSource());
+    await import('./compat/register/config').then(module => module.registerConfigSource())
   }
-  if (!configSource) return {};
-  return configSource(root, options);
+  if (!configSource) return {}
+  return configSource(root, options)
 }
 
 export async function loadConfig(
   rootInput = process.cwd(),
   options: { dev?: boolean } = {},
 ): Promise<ResolvedConfig> {
-  const root = canonicalRoot(path.resolve(rootInput));
-  await loadEnv(root, options);
-  const configPath = path.join(root, 'pnext.config.ts');
+  const root = canonicalRoot(path.resolve(rootInput))
+  await loadEnv(root, options)
+  const configPath = path.join(root, 'pnext.config.ts')
   const loadedConfig = existsSync(configPath)
     ? ((await import(pathToFileHref(configPath))) as { default?: PNextConfig })
-    : {};
+    : {}
   const config: PNextConfig = {
     ...(loadedConfig.default ?? {}),
     // eslint-disable-next-line turbo/no-undeclared-env-vars
     ...(process.env.PNEXT_COMPAT === 'next'
       ? { compat: { ...(loadedConfig.default?.compat ?? {}), next: true } }
       : {}),
-  };
+  }
+  validateConfig(config)
   // cacheComponents is a per-app flag on a process-global cell: clear it before
   // the next.config source re-derives it, so a pure-core (or flag-off) app
   // loaded after a cacheComponents app never inherits the previous build's flag.
-  setCacheComponents(false);
-  const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options));
-  const merged = { ...defaultConfig, ...config, ...sourceOverrides };
-  const appPath = await resolveAppPath(root, config);
-  const outRootPath = path.resolve(root, merged.outDir);
+  setCacheComponents(false)
+  const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options))
+  const merged = { ...defaultConfig, ...config, ...sourceOverrides }
+  const appPath = await resolveAppPath(root, config)
+  const outRootPath = path.resolve(root, merged.outDir)
   const workspaceRoot = canonicalRoot(
     config.workspaceRoot
       ? path.resolve(root, config.workspaceRoot)
       : (findWorkspaceRoot(root) ?? root),
-  );
+  )
 
   return {
     ...config,
@@ -125,11 +126,27 @@ export async function loadConfig(
     outPath: options.dev ? path.join(outRootPath, devOutSegment) : outRootPath,
     outRootPath,
     typesPath: path.join(outRootPath, 'types'),
-  };
+  }
+}
+
+// One row per enum-valued config field; validateConfig checks them all.
+const enumFields: readonly [keyof PNextConfig, readonly unknown[]][] = [
+  ['prefetch', PREFETCH_MODES],
+]
+
+function validateConfig(config: PNextConfig) {
+  for (const [field, allowed] of enumFields) {
+    const value = config[field]
+    if (value === undefined || allowed.includes(value)) continue
+    const list = allowed.map(v => (typeof v === 'string' ? `'${v}'` : String(v))).join(', ')
+    throw new Error(
+      `Invalid pnext config: '${field}' must be one of ${list} (received ${JSON.stringify(value)}).`,
+    )
+  }
 }
 
 /** Dev's private subtree under the out root. Build never touches it. */
-export const devOutSegment = 'dev';
+export const devOutSegment = 'dev'
 
 // Relative-import resolution realpaths the importing file (so a materialized shim resolves `./sibling`
 // against real source), so every containment check against root/workspaceRoot compares realpaths.
@@ -138,21 +155,21 @@ export const devOutSegment = 'dev';
 // resolving. A no-op when the path holds no symlinks.
 function canonicalRoot(dir: string) {
   try {
-    return realpathSync(dir);
+    return realpathSync(dir)
   } catch {
-    return dir;
+    return dir
   }
 }
 
 function stripUndefined<T extends object>(value: T): T {
-  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined)) as T;
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined)) as T
 }
 
 export function pathToFileHref(filePath: string) {
   // pathToFileURL percent-encodes literal special characters (notably `%`, so a
   // directory physically named `%5Ffoo` on disk stays `%255Ffoo` in the href and
   // import() decodes it back to the literal `%5Ffoo` rather than to `_foo`).
-  return pathToFileURL(path.resolve(filePath)).href;
+  return pathToFileURL(path.resolve(filePath)).href
 }
 
 export function publicEnvDefines() {
@@ -167,7 +184,7 @@ export function publicEnvDefines() {
       `process.env.${key}`,
       value === undefined ? 'undefined' : JSON.stringify(value),
     ]),
-  );
+  )
 }
 
 type FrameworkRuntimeAlias =
@@ -177,15 +194,15 @@ type FrameworkRuntimeAlias =
   | 'preact/compat/client'
   | 'preact/jsx-runtime'
   | 'preact/jsx-dev-runtime'
-  | 'react-compiler-runtime';
+  | 'react-compiler-runtime'
 
-export type CompatAliasTarget = 'server' | 'client';
+export type CompatAliasTarget = 'server' | 'client'
 
 /**
  * Seven `import.meta.resolve` calls against the framework's OWN install - the answer cannot change for the
  * life of the process, and every esbuild build builds an alias map (a vendor pass runs hundreds of those).
  */
-let frameworkRuntimeAliases: Record<FrameworkRuntimeAlias, string> | undefined;
+let frameworkRuntimeAliases: Record<FrameworkRuntimeAlias, string> | undefined
 
 export function frameworkRuntimeAliasEntries(): Record<FrameworkRuntimeAlias, string> {
   frameworkRuntimeAliases ??= {
@@ -196,37 +213,37 @@ export function frameworkRuntimeAliasEntries(): Record<FrameworkRuntimeAlias, st
     'preact/jsx-runtime': resolveRuntimeModule('preact/jsx-runtime'),
     'preact/jsx-dev-runtime': resolveRuntimeModule('preact/jsx-dev-runtime'),
     'react-compiler-runtime': resolveRuntimeModule('react-compiler-runtime'),
-  };
-  return frameworkRuntimeAliases;
+  }
+  return frameworkRuntimeAliases
 }
 
 function resolveRuntimeModule(specifier: string) {
-  return fileURLToPath(import.meta.resolve(specifier));
+  return fileURLToPath(import.meta.resolve(specifier))
 }
 
 export function pnextAliases(target: CompatAliasTarget): Record<string, string> {
-  if (target !== 'client') return {};
+  if (target !== 'client') return {}
   return {
     '@wular/pnext/cache': path.resolve(import.meta.dirname, 'api/client-cache.ts'),
-  };
+  }
 }
 
 async function resolveAppPath(root: string, config: PNextConfig) {
-  const rootApp = path.join(root, 'app');
+  const rootApp = path.join(root, 'app')
   if (config.compat?.next) {
-    const pagesPath = path.join(root, 'pages');
-    const hasPages = existsSync(pagesPath);
+    const pagesPath = path.join(root, 'pages')
+    const hasPages = existsSync(pagesPath)
     if (existsSync(rootApp)) {
       if (hasPages) {
-        const { materializePagesApp } = await import('./compat/pages');
-        const hybrid = await materializePagesApp(root);
-        if (hybrid) return hybrid;
+        const { materializePagesApp } = await import('./compat/pages/router')
+        const hybrid = await materializePagesApp(root)
+        if (hybrid) return hybrid
       }
-      return rootApp;
+      return rootApp
     }
-    const { materializePagesApp } = await import('./compat/pages');
-    const pagesApp = await materializePagesApp(root);
-    if (pagesApp) return pagesApp;
-  } else if (existsSync(rootApp)) return rootApp;
-  return path.join(root, 'src', 'app');
+    const { materializePagesApp } = await import('./compat/pages/router')
+    const pagesApp = await materializePagesApp(root)
+    if (pagesApp) return pagesApp
+  } else if (existsSync(rootApp)) return rootApp
+  return path.join(root, 'src', 'app')
 }