@wular/pnext 0.0.3 → 0.0.6

package/src/compat/ppr/missing-root-params.ts

@@ -9,11 +9,11 @@
 // `.message`, and the Next e2e suite substring-matches it verbatim off cliOutput. Runs as a build step
 // gated on cacheComponents, ordered before the prerender pass so the build aborts before any shell work.
 
-import type { ResolvedConfig } from '../../config';
-import type { RouteManifestEntry } from '../../types';
-import { staticParamsFor } from '../../render';
-import { PnextBuildValidationError } from '../validation';
-import { scanRootParams } from './root-params-scan';
+import type { ResolvedConfig } from '../../config'
+import type { RouteManifestEntry } from '../../types'
+import { staticParamsFor } from '../../render/renderer'
+import { PnextBuildValidationError } from '../validation/validate'
+import { scanRootParams } from './root-params-scan'
 
 /**
  * Convert a colon route pattern (`/:lang/blog/:slug`) to the bracket form Next
@@ -25,35 +25,33 @@ function toBracketPattern(pattern: string): string {
   return pattern
     .split('/')
     .map(segment => {
-      if (!segment.startsWith(':')) return segment;
-      let name = segment.slice(1);
-      let optional = false;
-      let catchAll = false;
+      if (!segment.startsWith(':')) return segment
+      let name = segment.slice(1)
+      let optional = false
+      let catchAll = false
       if (name.endsWith('?')) {
-        optional = true;
-        name = name.slice(0, -1);
+        optional = true
+        name = name.slice(0, -1)
       }
       if (name.endsWith('*') || name.endsWith('+')) {
-        catchAll = true;
-        name = name.slice(0, -1);
+        catchAll = true
+        name = name.slice(0, -1)
       }
-      if (catchAll) return optional ? `[[...${name}]]` : `[...${name}]`;
-      return `[${name}]`;
+      if (catchAll) return optional ? `[[...${name}]]` : `[...${name}]`
+      return `[${name}]`
     })
-    .join('/');
+    .join('/')
 }
 
 /** The keys generateStaticParams actually enumerated for this route. */
-function providedParamKeys(
-  allSets: Record<string, unknown>[],
-): Set<string> {
-  const provided = new Set<string>();
+function providedParamKeys(allSets: Record<string, unknown>[]): Set<string> {
+  const provided = new Set<string>()
   for (const set of allSets) {
     for (const [key, value] of Object.entries(set)) {
-      if (value !== undefined) provided.add(key);
+      if (value !== undefined) provided.add(key)
     }
   }
-  return provided;
+  return provided
 }
 
 /**
@@ -66,40 +64,38 @@ export async function validateRootParamsProvided(
   config: ResolvedConfig,
   routes: RouteManifestEntry[],
 ): Promise<void> {
-  const rootParams = scanRootParams(config.appPath);
-  if (rootParams.size === 0) return;
+  const rootParams = scanRootParams(config.appPath)
+  if (rootParams.size === 0) return
 
-  const pageRoutes = routes.filter(
-    route => route.kind === 'page' && !route.interception,
-  );
+  const pageRoutes = routes.filter(route => route.kind === 'page' && !route.interception)
 
   for (const route of pageRoutes) {
-    const routeRootParams = route.params.filter(name => rootParams.has(name));
-    if (routeRootParams.length === 0) continue;
+    const routeRootParams = route.params.filter(name => rootParams.has(name))
+    if (routeRootParams.length === 0) continue
 
-    let provided: Set<string>;
+    let provided: Set<string>
     try {
-      const staticParams = await staticParamsFor(config, route);
-      provided = providedParamKeys(staticParams.allSets);
+      const staticParams = await staticParamsFor(config, route)
+      provided = providedParamKeys(staticParams.allSets)
     } catch {
       // A generateStaticParams that throws provides nothing — treat every root
       // param as missing rather than masking the (more relevant) config error.
-      provided = new Set<string>();
+      provided = new Set<string>()
     }
 
-    const missing = routeRootParams.filter(name => !provided.has(name));
-    if (missing.length === 0) continue;
+    const missing = routeRootParams.filter(name => !provided.has(name))
+    if (missing.length === 0) continue
 
-    const routePattern = toBracketPattern(route.route || '/');
+    const routePattern = toBracketPattern(route.route || '/')
     if (missing.length === 1) {
       throw new PnextBuildValidationError(
         `Error: A required root parameter (${missing[0]}) was not provided in ` +
           `generateStaticParams for ${routePattern}, please provide at least one value.`,
-      );
+      )
     }
     throw new PnextBuildValidationError(
       `Error: Required root params (${missing.join(', ')}) were not provided in ` +
         `generateStaticParams for ${routePattern}, please provide at least one value for each.`,
-    );
+    )
   }
 }

package/src/compat/ppr/root-params-scan.ts

@@ -8,34 +8,34 @@
 // The scan drives which names `next/root-params` legitimately exports (import validation) and typegen.
 // Route-group and slot dirs never contribute params; catch-all segments contribute their param name.
 
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import path from 'node:path'
 
-const LAYOUT_BASENAMES = ['layout.tsx', 'layout.ts', 'layout.jsx', 'layout.js'];
+const LAYOUT_BASENAMES = ['layout.tsx', 'layout.ts', 'layout.jsx', 'layout.js']
 
 /** True when a layout source renders `<html>` (i.e. it is a root/document layout). */
 function isRootLayoutSource(source: string): boolean {
-  return /<html[\s>]/.test(source);
+  return /<html[\s>]/.test(source)
 }
 
 /** Extract the param name from a segment dir name, or undefined for a static one. */
 function paramNameOfSegment(segment: string): string | undefined {
   // [[...slug]] optional catch-all, [...slug] catch-all, [slug] dynamic.
-  const optional = /^\[\[\.\.\.(.+)\]\]$/.exec(segment);
-  if (optional) return optional[1];
-  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
-  if (catchAll) return catchAll[1];
-  const dynamic = /^\[(.+)\]$/.exec(segment);
-  if (dynamic) return dynamic[1];
-  return undefined;
+  const optional = /^\[\[\.\.\.(.+)\]\]$/.exec(segment)
+  if (optional) return optional[1]
+  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment)
+  if (catchAll) return catchAll[1]
+  const dynamic = /^\[(.+)\]$/.exec(segment)
+  if (dynamic) return dynamic[1]
+  return undefined
 }
 
 function findLayoutFile(dir: string): string | undefined {
   for (const base of LAYOUT_BASENAMES) {
-    const candidate = path.join(dir, base);
-    if (existsSync(candidate)) return candidate;
+    const candidate = path.join(dir, base)
+    if (existsSync(candidate)) return candidate
   }
-  return undefined;
+  return undefined
 }
 
 /**
@@ -44,52 +44,52 @@ function findLayoutFile(dir: string): string | undefined {
  * the app's root-param set.
  */
 export function scanRootParams(appPath: string): Set<string> {
-  const rootParams = new Set<string>();
-  if (!existsSync(appPath)) return rootParams;
+  const rootParams = new Set<string>()
+  if (!existsSync(appPath)) return rootParams
 
   const walk = (dir: string, paramsAbove: string[]): void => {
-    const layoutFile = findLayoutFile(dir);
+    const layoutFile = findLayoutFile(dir)
     if (layoutFile) {
-      let source = '';
+      let source = ''
       try {
-        source = readFileSync(layoutFile, 'utf8');
+        source = readFileSync(layoutFile, 'utf8')
       } catch {
-        source = '';
+        source = ''
       }
       if (isRootLayoutSource(source)) {
-        for (const name of paramsAbove) rootParams.add(name);
+        for (const name of paramsAbove) rootParams.add(name)
       }
     }
-    let children: string[] = [];
+    let children: string[] = []
     try {
-      children = readdirSync(dir);
+      children = readdirSync(dir)
     } catch {
-      return;
+      return
     }
     for (const child of children) {
-      const childPath = path.join(dir, child);
-      let isDir = false;
+      const childPath = path.join(dir, child)
+      let isDir = false
       try {
-        isDir = statSync(childPath).isDirectory();
+        isDir = statSync(childPath).isDirectory()
       } catch {
-        isDir = false;
+        isDir = false
       }
-      if (!isDir) continue;
-      if (child.startsWith('@')) continue; // parallel-route slot dir
-      const param = paramNameOfSegment(child);
-      walk(childPath, param ? [...paramsAbove, param] : paramsAbove);
+      if (!isDir) continue
+      if (child.startsWith('@')) continue // parallel-route slot dir
+      const param = paramNameOfSegment(child)
+      walk(childPath, param ? [...paramsAbove, param] : paramsAbove)
     }
-  };
+  }
 
-  walk(appPath, []);
-  return rootParams;
+  walk(appPath, [])
+  return rootParams
 }
 
-export type RootParamValueType = 'string' | 'string[]' | 'undefined';
+export type RootParamValueType = 'string' | 'string[]' | 'undefined'
 
 interface ScannedParam {
-  name: string;
-  segment: string;
+  name: string
+  segment: string
 }
 
 /**
@@ -99,20 +99,20 @@ interface ScannedParam {
  * layouts, a param absent from some root also gains `undefined`.
  */
 export function scanRootParamTypes(appPath: string): Map<string, Set<RootParamValueType>> {
-  const roots: Map<string, RootParamValueType[]>[] = [];
-  if (!existsSync(appPath)) return new Map();
+  const roots: Map<string, RootParamValueType[]>[] = []
+  if (!existsSync(appPath)) return new Map()
 
   const walk = (dir: string, paramsAbove: ScannedParam[]): void => {
-    const layoutFile = findLayoutFile(dir);
+    const layoutFile = findLayoutFile(dir)
     if (layoutFile) {
-      let source = '';
+      let source = ''
       try {
-        source = readFileSync(layoutFile, 'utf8');
+        source = readFileSync(layoutFile, 'utf8')
       } catch {
-        source = '';
+        source = ''
       }
       if (isRootLayoutSource(source)) {
-        const params = new Map<string, RootParamValueType[]>();
+        const params = new Map<string, RootParamValueType[]>()
         for (const { name, segment } of paramsAbove) {
           params.set(
             name,
@@ -121,44 +121,44 @@ export function scanRootParamTypes(appPath: string): Map<string, Set<RootParamVa
               : segment.startsWith('[...')
                 ? ['string[]']
                 : ['string'],
-          );
+          )
         }
-        roots.push(params);
+        roots.push(params)
       }
     }
-    let children: string[] = [];
+    let children: string[] = []
     try {
-      children = readdirSync(dir);
+      children = readdirSync(dir)
     } catch {
-      return;
+      return
     }
     for (const child of children) {
-      const childPath = path.join(dir, child);
-      let isDir = false;
+      const childPath = path.join(dir, child)
+      let isDir = false
       try {
-        isDir = statSync(childPath).isDirectory();
+        isDir = statSync(childPath).isDirectory()
       } catch {
-        isDir = false;
+        isDir = false
       }
-      if (!isDir) continue;
-      if (child.startsWith('@')) continue; // parallel-route slot dir
-      const param = paramNameOfSegment(child);
-      walk(childPath, param ? [...paramsAbove, { name: param, segment: child }] : paramsAbove);
+      if (!isDir) continue
+      if (child.startsWith('@')) continue // parallel-route slot dir
+      const param = paramNameOfSegment(child)
+      walk(childPath, param ? [...paramsAbove, { name: param, segment: child }] : paramsAbove)
     }
-  };
+  }
 
-  walk(appPath, []);
+  walk(appPath, [])
 
-  const combined = new Map<string, Set<RootParamValueType>>();
+  const combined = new Map<string, Set<RootParamValueType>>()
   for (const params of roots) {
     for (const [name, types] of params) {
-      const set = combined.get(name) ?? new Set<RootParamValueType>();
-      for (const type of types) set.add(type);
-      combined.set(name, set);
+      const set = combined.get(name) ?? new Set<RootParamValueType>()
+      for (const type of types) set.add(type)
+      combined.set(name, set)
     }
   }
   for (const [name, set] of combined) {
-    if (roots.some(params => !params.has(name))) set.add('undefined');
+    if (roots.some(params => !params.has(name))) set.add('undefined')
   }
-  return combined;
+  return combined
 }

package/src/compat/ppr/root-params-transform.ts

@@ -14,18 +14,18 @@
 // the Proxy. Build-time validation that a name is actually a root param lives in root-params-scan.ts;
 // this transform stays permissive.
 
-import { isIdentifier, uniqueIdentifier } from '../../utils/source';
+import { isIdentifier, uniqueIdentifier } from '../../utils/code'
 
-const ROOT_PARAMS_SPECIFIER = /['"]next\/root-params['"]/;
+const ROOT_PARAMS_SPECIFIER = /['"]next\/root-params['"]/
 
 // `[^}]` for the clause, never a lazy `[\s\S]*?`: the latter backtracks across
 // an earlier `import { X } from 'react'` and swallows that line too.
 const IMPORT_RE =
-  /^[ \t]*import\s+\{([^}]*)\}\s+from\s+['"]next\/root-params['"]\s*;?[ \t]*(?:\r?\n)?/gm;
+  /^[ \t]*import\s+\{([^}]*)\}\s+from\s+['"]next\/root-params['"]\s*;?[ \t]*(?:\r?\n)?/gm
 
 interface Binding {
-  imported: string;
-  local: string;
+  imported: string
+  local: string
 }
 
 function parseBindings(clause: string): Binding[] {
@@ -34,13 +34,13 @@ function parseBindings(clause: string): Binding[] {
     .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 }]
+    })
 }
 
 /**
@@ -49,27 +49,25 @@ function parseBindings(clause: string): Binding[] {
  * source transform and applied in the client bundler plugin.
  */
 export function rewriteRootParamsSource(source: string): string {
-  if (!ROOT_PARAMS_SPECIFIER.test(source)) return source;
-  const proxyName = uniqueIdentifier(source, '__pnextRootParams');
-  const declarations: string[] = [];
-  let importedProxy = false;
+  if (!ROOT_PARAMS_SPECIFIER.test(source)) return source
+  const proxyName = uniqueIdentifier(source, '__pnextRootParams')
+  const declarations: string[] = []
+  let importedProxy = false
 
   const rewritten = source.replace(IMPORT_RE, (_statement, clause: string) => {
-    const bindings = parseBindings(clause);
-    if (bindings.length === 0) return '';
-    importedProxy = true;
+    const bindings = parseBindings(clause)
+    if (bindings.length === 0) return ''
+    importedProxy = true
     for (const { imported, local } of bindings) {
-      declarations.push(
-        `const ${local} = ${proxyName}[${JSON.stringify(imported)}];`,
-      );
+      declarations.push(`const ${local} = ${proxyName}[${JSON.stringify(imported)}];`)
     }
-    return '';
-  });
+    return ''
+  })
 
-  if (!importedProxy) return source;
+  if (!importedProxy) return source
   return [
     `import ${proxyName} from ${JSON.stringify('next/root-params')};`,
     ...declarations,
     rewritten,
-  ].join('\n');
+  ].join('\n')
 }

package/src/compat/ppr/root-params.ts

@@ -8,23 +8,23 @@
 // a build/dev error there - so this runtime is intentionally permissive and a valid getter always works.
 // Context errors (server action / route handler / unstable_cache) match Next's messages exactly.
 
-import { currentParams, currentRequest, getWorkUnit } from '../../request/context';
+import { currentParams, currentRequest, getWorkUnit } from '../../request/context'
 import {
   cacheComponents,
   hangingPromise,
   isPrerendering,
   isRuntimePrefetchPrerender,
-} from '../../ppr';
-import { insideUnstableCacheProducer } from '../cache/revalidate';
-import { insideUseCacheProducer, recordUseCacheRootParamRead } from '../cache/use-cache';
+} from '../../render/ppr'
+import { insideUnstableCacheProducer } from '../cache/revalidate'
+import { insideUseCacheProducer, recordUseCacheRootParamRead } from '../cache/use-cache'
 
 /** E-code errors Next throws for root-params used in an unsupported context. */
 function rootParamContextError(name: string): Error | undefined {
-  const unit = getWorkUnit();
-  const call = `\`import('next/root-params').${name}()\``;
+  const unit = getWorkUnit()
+  const call = `\`import('next/root-params').${name}()\``
 
-  const inUseCache = insideUseCacheProducer();
-  const inUnstableCache = insideUnstableCacheProducer();
+  const inUseCache = insideUseCacheProducer()
+  const inUnstableCache = insideUnstableCacheProducer()
 
   // Root params inside a `use cache` NESTED within `unstable_cache`: E1140.
   // (The `use cache` scope sits inside the unstable_cache producer, so both
@@ -35,15 +35,15 @@ function rootParamContextError(name: string): Error | undefined {
         `Root params (${call}) were used inside a cache scope nested within \`unstable_cache\`. Root params are not available in this context.`,
       ),
       { digest: 'E1140' },
-    );
+    )
   }
 
   // Inside a plain `use cache` (not under unstable_cache): legal. Record the
   // read so the entry's cache key participates in this root param (Stage B-3),
   // then let the getter resolve the value below (no error).
   if (inUseCache) {
-    recordUseCacheRootParamRead(name);
-    return undefined;
+    recordUseCacheRootParamRead(name)
+    return undefined
   }
 
   // Inside `unstable_cache` (a data-cache producer that is NOT a `use cache`
@@ -54,34 +54,34 @@ function rootParamContextError(name: string): Error | undefined {
         `Root params (${call}) were used inside \`unstable_cache\`. This is not supported. Use \`"use cache"\` instead.`,
       ),
       { digest: 'E1141' },
-    );
+    )
   }
 
-  if (!unit) return undefined;
+  if (!unit) return undefined
 
   if (unit.phase === 'action') {
     return new Error(
       `${call} was used inside a Server Action. This is not supported. ` +
         `Functions from 'next/root-params' can only be called in the context of a route.`,
-    );
+    )
   }
 
   // Route handlers are detected via routeKind (core sets no 'handler' phase).
   if (unit.phase !== 'after' && unit.routeKind === 'route-handler') {
     const route = (() => {
       try {
-        return new URL(currentRequest()?.url ?? '').pathname;
+        return new URL(currentRequest()?.url ?? '').pathname
       } catch {
-        return '';
+        return ''
       }
-    })();
+    })()
     return new Error(
       `Route ${route} used ${call} inside a Route Handler. ` +
         `Support for this API in Route Handlers is planned for a future version of Next.js.`,
-    );
+    )
   }
 
-  return undefined;
+  return undefined
 }
 
 /**
@@ -90,8 +90,8 @@ function rootParamContextError(name: string): Error | undefined {
  * resolves to undefined.
  */
 export function rootParam<T = string | string[] | undefined>(name: string): Promise<T> {
-  const error = rootParamContextError(name);
-  if (error) return Promise.reject(error);
+  const error = rootParamContextError(name)
+  if (error) return Promise.reject(error)
   // A runtime-prefetch prerender renders against the REAL sampled request, so root params are concrete
   // there (root params are always available in static prerenders, so a runtime prefetch has them too).
   // Hanging them would postpone the root layout itself - the whole document, not a boundary - and the
@@ -102,10 +102,10 @@ export function rootParam<T = string | string[] | undefined>(name: string): Prom
     isPrerendering() &&
     !isRuntimePrefetchPrerender()
   ) {
-    return hangingPromise<T>(`rootParam(${name})`);
+    return hangingPromise<T>(`rootParam(${name})`)
   }
-  const params = currentParams();
-  return Promise.resolve(params[name] as T);
+  const params = currentParams()
+  return Promise.resolve(params[name] as T)
 }
 
 /**
@@ -118,12 +118,12 @@ const rootParamsModule = new Proxy(
   {},
   {
     get(_target, prop: string | symbol): unknown {
-      if (typeof prop !== 'string') return undefined;
-      if (prop === '__esModule') return true;
-      if (prop === 'default') return undefined;
-      return () => rootParam(prop);
+      if (typeof prop !== 'string') return undefined
+      if (prop === '__esModule') return true
+      if (prop === 'default') return undefined
+      return () => rootParam(prop)
     },
   },
-) as Record<string, () => Promise<unknown>>;
+) as Record<string, () => Promise<unknown>>
 
-export default rootParamsModule;
+export default rootParamsModule

package/src/compat/ppr/segment-config-incompat.ts

@@ -9,17 +9,16 @@ export const INCOMPATIBLE_SEGMENT_KEYS = [
   'dynamicParams',
   'dynamic',
   'fetchCache',
-] as const;
+] as const
 
-export type IncompatibleSegmentKey = (typeof INCOMPATIBLE_SEGMENT_KEYS)[number];
+export type IncompatibleSegmentKey = (typeof INCOMPATIBLE_SEGMENT_KEYS)[number]
 
 /** Next's exact incompat message for an offending segment-config export. */
 export function segmentConfigIncompatMessage(key: IncompatibleSegmentKey, file: string): string {
-  return `"${key}" is not compatible with \`nextConfig.cacheComponents\`. Please remove it. Used in ${file}`;
+  return `"${key}" is not compatible with \`nextConfig.cacheComponents\`. Please remove it. Used in ${file}`
 }
 
-const EXPORT_RE = (key: string) =>
-  new RegExp(`\\bexport\\s+const\\s+${key}\\b`);
+const EXPORT_RE = (key: string) => new RegExp(`\\bexport\\s+const\\s+${key}\\b`)
 
 /**
  * Scan a page/layout source for an incompatible segment-config export, returning
@@ -28,7 +27,7 @@ const EXPORT_RE = (key: string) =>
  */
 export function findIncompatibleSegmentKey(source: string): IncompatibleSegmentKey | undefined {
   for (const key of INCOMPATIBLE_SEGMENT_KEYS) {
-    if (EXPORT_RE(key).test(source)) return key;
+    if (EXPORT_RE(key).test(source)) return key
   }
-  return undefined;
+  return undefined
 }