@wular/pnext 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {

package/src/cli/adapters/vercel.ts

@@ -116,8 +116,29 @@ function packRules(config: ResolvedConfig): PackRules {
   }
 }
 
-function shipsDir(pack: PackRules, name: string, source: string) {
-  return !pack.prunedDirs.has(name) || pack.keepPaths.has(path.resolve(source))
+/**
+ * A keep path and everything under it. Prefix, not equality: the compiled module cache mirrors the
+ * source layout, so a dependency's artifacts land in `<outDir>/cache/server/<profile>/node_modules/
+ * ...`. That segment names a source tree, not a package store, and pruning it by name ships the
+ * importer without the module it imports — the function then 500s on the first request that reaches
+ * it. Only the app's own build output is exempt; a real `node_modules` beside it still prunes.
+ */
+function withinKeepPath(pack: PackRules, source: string) {
+  const resolved = path.resolve(source)
+  for (const keep of pack.keepPaths) {
+    if (resolved === keep || resolved.startsWith(`${keep}${path.sep}`)) return true
+  }
+  return false
+}
+
+/**
+ * `isLink` is load-bearing, not a detail: the exemption covers real directories the build output
+ * owns, never a link out of it. The proxy shim links `node_modules` into `.pnext`, and following
+ * that would pull the whole store into the function.
+ */
+function shipsDir(pack: PackRules, name: string, source: string, isLink = false) {
+  if (!pack.prunedDirs.has(name)) return true
+  return !isLink && withinKeepPath(pack, source)
 }
 
 function shipsFile(pack: PackRules, name: string) {
@@ -466,7 +487,7 @@ async function copyTree(
   // Nothing to skip at this level: the whole tree clones in one syscall.
   if (exclude.size === 0 && !existsSync(to)) {
     await mkdir(path.dirname(to), { recursive: true })
-    if (clone?.(from, to)) return normalizeClone(to, pack, visited)
+    if (clone?.(from, to)) return normalizeClone(to, from, pack, visited)
   }
   // The build output is still live while the walk runs — typegen rewrites
   // `.pnext/types` under it — so a directory can vanish between the parent's
@@ -480,7 +501,8 @@ async function copyTree(
       const target = path.join(to, entry.name)
       // Matched by name before type: a symlinked `node_modules` must be pruned
       // as the directory it points at, not followed.
-      if (exclude.has(entry.name) || !shipsDir(pack, entry.name, source)) return
+      if (exclude.has(entry.name) || !shipsDir(pack, entry.name, source, entry.isSymbolicLink()))
+        return
       if (entry.isSymbolicLink()) {
         const link = resolveLinkTarget(source)
         if (!link) return
@@ -494,7 +516,7 @@ async function copyTree(
       // One syscall for the whole subtree beats one per file — the excluded
       // names are stripped from the copy afterwards.
       if (entry.isDirectory() && clone?.(source, target)) {
-        return normalizeClone(target, pack, visited)
+        return normalizeClone(target, source, pack, visited)
       }
       if (entry.isDirectory()) return copyTree(source, target, pack, [], visited)
       if (entry.isFile() && shipsFile(pack, entry.name)) return linkOrCopyFile(source, target)
@@ -555,18 +577,25 @@ async function directoryCloner() {
  * both paths emit the same tree. Reading directory entries costs nothing next
  * to the per-file copies this replaces.
  */
-async function normalizeClone(dir: string, pack: PackRules, visited: Set<string>) {
-  const stack = [dir]
+async function normalizeClone(
+  dir: string,
+  // Where `dir` was cloned from. Carried so the keep-path exemption reads the same here as in the
+  // walk: the clone's own paths are inside the function and would never match a source keep path.
+  from: string,
+  pack: PackRules,
+  visited: Set<string>,
+) {
+  const stack: [string, string][] = [[dir, from]]
   const pending: Promise<unknown>[] = []
   while (stack.length > 0) {
-    const current = stack.pop()!
+    const [current, currentFrom] = stack.pop()!
     for (const entry of readdirSync(current, { withFileTypes: true })) {
       const full = path.join(current, entry.name)
+      const source = path.join(currentFrom, entry.name)
       // Matched by name before type, as the walk does: the pages-compat shim
       // links `node_modules` at the app root, and following it would pull the
-      // whole store into the function. The clone is already inside the
-      // function, so the walk's keep-path exemption cannot apply here.
-      if (pack.prunedDirs.has(entry.name)) {
+      // whole store into the function.
+      if (!shipsDir(pack, entry.name, source, entry.isSymbolicLink())) {
         rmSync(full, { recursive: true, force: true })
       } else if (entry.isSymbolicLink()) {
         const link = resolveLinkTarget(full)
@@ -580,7 +609,7 @@ async function normalizeClone(dir: string, pack: PackRules, visited: Set<string>
           pending.push(linkOrCopyFile(link.path, full))
         }
       } else if (entry.isDirectory()) {
-        stack.push(full)
+        stack.push([full, source])
       } else if (!shipsFile(pack, entry.name)) {
         rmSync(full, { force: true })
       }

package/src/cli/migrate/package-json.ts

@@ -3,7 +3,7 @@
 
 import { readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { pnextVersionRange } from '../../utils/fs'
+import { pnextOptionalDependencyRange, pnextVersionRange } from '../../utils/fs'
 import type { MigrationResult } from './report'
 
 const SEPARATORS = new Set(['&&', '||', ';', '|', '&'])
@@ -132,6 +132,26 @@ export async function migratePackageJson(
       details: [`devDependencies: @wular/pnext ${versionRange}`],
     })
   }
+  // next/font/google resolves its metadata from `next-font`, one of pnext's optional dependencies.
+  // A hoisted store makes it resolve locally whether or not the app declares it, so an undeclared
+  // one only shows up as a 500 from a deployed function, where the closure ships what the app asks
+  // for. Declare it here, where the migration already knows the app uses the loader.
+  const fontRange = pnextOptionalDependencyRange('next-font')
+  if (
+    result.googleFontImports.length > 0 &&
+    fontRange &&
+    !('next-font' in dependencies) &&
+    !('next-font' in devDependencies)
+  ) {
+    dependencies['next-font'] = fontRange
+    result.edits.push({
+      file: 'package.json',
+      description: 'next-font added',
+      details: [
+        `dependencies: next-font ${fontRange} (next/font/google metadata, used by ${result.googleFontImports.length} file${result.googleFontImports.length === 1 ? '' : 's'})`,
+      ],
+    })
+  }
   if (!('preact' in dependencies) && !('preact' in devDependencies)) {
     dependencies.preact = '^10'
     result.edits.push({

package/src/cli/migrate/report.ts

@@ -27,10 +27,12 @@ export interface MigrationResult {
   reports: ReportItem[]
   /** Files reading cookies()/headers()/draftMode() synchronously (Next 14 style). */
   syncRequestApis: string[]
+  /** Files importing next/font/google, which needs the `next-font` metadata package. */
+  googleFontImports: string[]
 }
 
 export function emptyResult(): MigrationResult {
-  return { edits: [], reports: [], syncRequestApis: [] }
+  return { edits: [], reports: [], syncRequestApis: [], googleFontImports: [] }
 }
 
 export function printHeader(root: string, dryRun: boolean) {

package/src/cli/migrate/run.ts

@@ -36,9 +36,10 @@ export async function migrateApp(directory: string | undefined, options: { dryRu
 
   printHeader(root, options.dryRun)
   const result = emptyResult()
-  if (pkg) await migratePackageJson(root, pkg, result, options.dryRun)
-  // The scan runs first: what it finds (sync request APIs) decides what the config enables.
+  // The scan runs first: what it finds decides what the config enables (sync request APIs) and
+  // which dependencies the app needs (next/font/google → next-font).
   await withSpinner('Scanning sources ...', () => scanSources(root, result))
+  if (pkg) await migratePackageJson(root, pkg, result, options.dryRun)
   await createPnextConfig(root, result, options.dryRun)
   await migrateTsconfig(root, result, options.dryRun)
   await removeNextEnv(root, result, options.dryRun)

package/src/cli/migrate/scan.ts

@@ -53,6 +53,9 @@ export async function scanSources(root: string, result: MigrationResult) {
         streaming.push(relative)
       }
       if (specifier === 'next/head') headImports.push(relative)
+      // next/font/local reads the app's own files; only the Google loader needs the metadata
+      // package, so only it earns the dependency.
+      if (specifier === 'next/font/google') result.googleFontImports.push(relative)
     }
     if (readsRequestApiSynchronously(text)) result.syncRequestApis.push(relative)
   }

package/src/utils/fs.ts

@@ -137,3 +137,16 @@ export function pnextVersionRange() {
   const { version } = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version: string }
   return `^${version}`
 }
+
+/**
+ * The range pnext declares for one of its optional dependencies. An app that uses the feature has to
+ * declare the package itself — the vercel adapter ships pnext's optional deps only where the app
+ * depends on them too — so the range has to come from here rather than being written down twice.
+ */
+export function pnextOptionalDependencyRange(name: string) {
+  const pkgPath = fileURLToPath(new URL('../../package.json', import.meta.url))
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as {
+    optionalDependencies?: Record<string, string>
+  }
+  return pkg.optionalDependencies?.[name]
+}