@wular/pnext 0.0.3 → 0.0.6

package/src/compat/bundler/symlink-imports.ts

@@ -1,29 +1,29 @@
-import { readdirSync, realpathSync } from 'node:fs';
-import { realpath } from 'node:fs/promises';
-import path from 'node:path';
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import { resolveImport } from '../../resolve/imports';
+import { readdirSync, realpathSync } from 'node:fs'
+import { realpath } from 'node:fs/promises'
+import path from 'node:path'
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { resolveImport } from '../../resolve/imports'
 
-const resolvedMarker = Symbol('pnext-symlink-import');
+const resolvedMarker = Symbol('pnext-symlink-import')
 
 /**
  * Whether a file IS its own real path - asked once per relative import, so the same importers are
  * re-resolved component-by-component across every build. Keyed on the path alone: a path's symlink
  * identity changes only on an install, which already invalidates every resolved artifact key.
  */
-const realPaths = new Map<string, Promise<boolean>>();
+const realPaths = new Map<string, Promise<boolean>>()
 
 function isRealPath(file: string) {
-  let real = realPaths.get(file);
+  let real = realPaths.get(file)
   if (!real) {
     real = realpath(file).then(
       resolved => resolved === file,
       () => true,
-    );
-    realPaths.set(file, real);
+    )
+    realPaths.set(file, real)
   }
-  return real;
+  return real
 }
 
 /**
@@ -33,9 +33,9 @@ function isRealPath(file: string) {
  *                   these during node_modules resolution, so importers come out as realpaths
  *   'other'         pnpm trees, symlinked roots, stray source symlinks, or a failed scan
  */
-type SymlinkLayout = 'none' | 'package-links' | 'other';
+type SymlinkLayout = 'none' | 'package-links' | 'other'
 
-const symlinkLayouts = new Map<string, SymlinkLayout>();
+const symlinkLayouts = new Map<string, SymlinkLayout>()
 
 /**
  * Whether this build can see a SYMLINKED importer, so the plugin's onResolve is registered only where it
@@ -47,50 +47,47 @@ export function symlinkedImportsPossible(
   config: ResolvedConfig,
   realPathEntries?: boolean,
 ): boolean {
-  const key = `${config.root}\0${config.workspaceRoot}`;
-  let layout = symlinkLayouts.get(key);
+  const key = `${config.root}\0${config.workspaceRoot}`
+  let layout = symlinkLayouts.get(key)
   if (layout === undefined) {
-    layout = detectSymlinkLayout(config);
-    symlinkLayouts.set(key, layout);
+    layout = detectSymlinkLayout(config)
+    symlinkLayouts.set(key, layout)
   }
-  if (layout === 'none') return false;
-  if (layout === 'package-links') return !realPathEntries;
-  return true;
+  if (layout === 'none') return false
+  if (layout === 'package-links') return !realPathEntries
+  return true
 }
 
 function detectSymlinkLayout(config: ResolvedConfig): SymlinkLayout {
   try {
-    const roots = [...new Set([config.root, config.workspaceRoot])].map(root =>
-      path.resolve(root),
-    );
-    let packageLinks = false;
+    const roots = [...new Set([config.root, config.workspaceRoot])].map(root => path.resolve(root))
+    let packageLinks = false
     for (const root of roots) {
-      if (realpathSync(root) !== root) return 'other';
-      if (readDirEntries(root).some(entry => entry.isSymbolicLink())) return 'other';
-      const nodeModules = path.join(root, 'node_modules');
+      if (realpathSync(root) !== root) return 'other'
+      if (readDirEntries(root).some(entry => entry.isSymbolicLink())) return 'other'
+      const nodeModules = path.join(root, 'node_modules')
       for (const entry of readDirEntries(nodeModules)) {
-        if (entry.name === '.pnpm') return 'other';
-        if (entry.isSymbolicLink()) packageLinks = true;
+        if (entry.name === '.pnpm') return 'other'
+        if (entry.isSymbolicLink()) packageLinks = true
         else if (entry.isDirectory() && entry.name.startsWith('@')) {
-          const scopeDir = path.join(nodeModules, entry.name);
-          if (readDirEntries(scopeDir).some(scoped => scoped.isSymbolicLink()))
-            packageLinks = true;
+          const scopeDir = path.join(nodeModules, entry.name)
+          if (readDirEntries(scopeDir).some(scoped => scoped.isSymbolicLink())) packageLinks = true
         }
       }
     }
-    return packageLinks ? 'package-links' : 'none';
+    return packageLinks ? 'package-links' : 'none'
   } catch {
-    return 'other';
+    return 'other'
   }
 }
 
 /** Missing dir = no symlinks there; any other failure propagates as "uncertain". */
 function readDirEntries(dir: string) {
   try {
-    return readdirSync(dir, { withFileTypes: true });
+    return readdirSync(dir, { withFileTypes: true })
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
-    throw error;
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
+    throw error
   }
 }
 
@@ -100,20 +97,23 @@ export function serverSymlinkImportPlugin(config: ResolvedConfig): Plugin {
     name: 'pnext-symlink-imports',
     setup(build) {
       build.onResolve({ filter: /^\.\.?\// }, async args => {
-        if (!args.importer || (args.pluginData as Record<PropertyKey, unknown> | undefined)?.[resolvedMarker]) {
-          return undefined;
+        if (
+          !args.importer ||
+          (args.pluginData as Record<PropertyKey, unknown> | undefined)?.[resolvedMarker]
+        ) {
+          return undefined
         }
-        if (await isRealPath(args.importer)) return undefined;
-        const target = resolveImport(config.root, args.importer, args.path);
-        if (!target) return undefined;
+        if (await isRealPath(args.importer)) return undefined
+        const target = resolveImport(config.root, args.importer, args.path)
+        if (!target) return undefined
         return build.resolve(target, {
           kind: args.kind,
           importer: args.importer,
           namespace: args.namespace,
           resolveDir: args.resolveDir,
           pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
-        });
-      });
+        })
+      })
     },
-  };
+  }
 }

package/src/compat/bundler/tsconfig-paths.ts

@@ -19,21 +19,19 @@
 // anywhere -> no plugin.
 // ---------------------------------------------------------------------------
 
-import path from 'node:path';
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import { configuredTsPathPatterns, resolveConfiguredTsPath } from '../../resolve/imports';
-import { escapeRegex } from '../../utils/source';
+import path from 'node:path'
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { configuredTsPathPatterns, resolveConfiguredTsPath } from '../../resolve/imports'
+import { escapeRegex } from '../../utils/code'
 
 export function tsconfigPathsPlugin(config: ResolvedConfig): Plugin | undefined {
-  const patterns = configuredTsPathPatterns(config.root, config.workspaceRoot);
-  if (patterns.length === 0) return undefined;
+  const patterns = configuredTsPathPatterns(config.root, config.workspaceRoot)
+  if (patterns.length === 0) return undefined
   // A TS `paths` key holds at most one `*`; everything else is literal.
   const filter = new RegExp(
-    `^(?:${patterns
-      .map(pattern => pattern.split('*').map(escapeRegex).join('[^:]*'))
-      .join('|')})$`,
-  );
+    `^(?:${patterns.map(pattern => pattern.split('*').map(escapeRegex).join('[^:]*')).join('|')})$`,
+  )
   return {
     name: 'pnext-tsconfig-paths',
     setup(build) {
@@ -42,9 +40,9 @@ export function tsconfigPathsPlugin(config: ResolvedConfig): Plugin | undefined
           config.root,
           path.join(args.resolveDir || config.root, 'pnext-resolve.ts'),
           args.path,
-        );
-        return resolved ? { path: resolved } : undefined;
-      });
+        )
+        return resolved ? { path: resolved } : undefined
+      })
     },
-  };
+  }
 }

package/src/compat/bundler/wasm.ts

@@ -1,51 +1,49 @@
-import { createHash } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
 
 interface WasmManifestBinding {
-  name: string;
-  filePath: string;
+  name: string
+  filePath: string
 }
 
-const WASM_MODULE_FILTER = /\.wasm\?module(?:[?#].*)?$/;
+const WASM_MODULE_FILTER = /\.wasm\?module(?:[?#].*)?$/
 
 // Keep one normalized binding list per build output root, so middleware manifest
 // emission can include the same `wasm` entries Next’s real middleware manifest
 // emits.
-const manifestWasmBindings = new Map<string, Map<string, WasmManifestBinding>>();
+const manifestWasmBindings = new Map<string, Map<string, WasmManifestBinding>>()
 
 function outPathKey(outPath: string): string {
-  return path.resolve(outPath);
+  return path.resolve(outPath)
 }
 
 function sourcePathFromSpecifier(specifier: string, resolveDir: string): string | undefined {
-  const [sourcePath] = specifier.split(/[?#]/, 1);
-  if (!sourcePath) return undefined;
-  return path.isAbsolute(sourcePath) ? sourcePath : path.resolve(resolveDir, sourcePath);
+  const [sourcePath] = specifier.split(/[?#]/, 1)
+  if (!sourcePath) return undefined
+  return path.isAbsolute(sourcePath) ? sourcePath : path.resolve(resolveDir, sourcePath)
 }
 
 function assetFileName(bytes: Uint8Array) {
-  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16);
-  return `wasm_${hash}.wasm`;
+  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16)
+  return `wasm_${hash}.wasm`
 }
 
 function registerManifestBinding(outPath: string, sourcePath: string, name: string) {
-  const key = outPathKey(outPath);
-  const bySource = manifestWasmBindings.get(key) ?? new Map<string, WasmManifestBinding>();
-  bySource.set(sourcePath, { name, filePath: `server/edge-chunks/${name}` });
-  manifestWasmBindings.set(key, bySource);
+  const key = outPathKey(outPath)
+  const bySource = manifestWasmBindings.get(key) ?? new Map<string, WasmManifestBinding>()
+  bySource.set(sourcePath, { name, filePath: `server/edge-chunks/${name}` })
+  manifestWasmBindings.set(key, bySource)
 }
 
-export function readMiddlewareWasmBindingsForOutPath(
-  outPath: string,
-): WasmManifestBinding[] {
-  const key = outPathKey(outPath);
-  const bindings = manifestWasmBindings.get(key);
-  if (!bindings || bindings.size === 0) return [];
-  return [...bindings.values()].sort((a, b) => a.name.localeCompare(b.name));
+export function readMiddlewareWasmBindingsForOutPath(outPath: string): WasmManifestBinding[] {
+  const key = outPathKey(outPath)
+  const bindings = manifestWasmBindings.get(key)
+  if (!bindings || bindings.size === 0) return []
+  return [...bindings.values()].sort((a, b) => a.name.localeCompare(b.name))
 }
 
 /**
@@ -62,9 +60,9 @@ export function readMiddlewareWasmBindingsForOutPath(
  */
 // The bare form (`import { add } from './add.wasm'`) is turbopack's default
 // wasm semantics: the module's own exports become the module's named exports.
-const WASM_FILTER = /\.wasm(?:[?#].*)?$/;
-const WASM_INSTANCE_NAMESPACE = 'pnext-wasm-instance';
-const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const WASM_FILTER = /\.wasm(?:[?#].*)?$/
+const WASM_INSTANCE_NAMESPACE = 'pnext-wasm-instance'
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
 
 /**
  * ESM source instantiating `bytes` and re-exporting the wasm module's own exports by name (plus the
@@ -74,13 +72,13 @@ const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function wasmInstanceModuleSource(bytes: Uint8Array): string {
   const names = WebAssembly.Module.exports(new WebAssembly.Module(bytes.buffer as ArrayBuffer))
     .map(entry => entry.name)
-    .filter(name => IDENTIFIER.test(name));
+    .filter(name => IDENTIFIER.test(name))
   return [
     `const bytes = Uint8Array.from(atob(${JSON.stringify(Buffer.from(bytes).toString('base64'))}), c => c.charCodeAt(0));`,
     'const wasmExports = new WebAssembly.Instance(new WebAssembly.Module(bytes), {}).exports;',
     ...names.map(name => `export const ${name} = wasmExports[${JSON.stringify(name)}];`),
     'export default wasmExports;',
-  ].join('\n');
+  ].join('\n')
 }
 
 /**
@@ -90,44 +88,44 @@ function wasmInstanceModuleSource(bytes: Uint8Array): string {
  * per project root.
  */
 export function registerWasmModuleRuntime(config: ResolvedConfig): void {
-  const root = path.resolve(config.root);
-  if (wasmRuntimeRoots.has(root)) return;
-  wasmRuntimeRoots.add(root);
+  const root = path.resolve(config.root)
+  if (wasmRuntimeRoots.has(root)) return
+  wasmRuntimeRoots.add(root)
   Bun.plugin({
     name: `pnext-compat-wasm-runtime-${root}`,
     setup(plugin) {
       plugin.onLoad({ filter: /\.wasm$/ }, async ({ path: file }) => ({
         contents: wasmInstanceModuleSource(new Uint8Array(await readFile(file))),
         loader: 'js',
-      }));
+      }))
     },
-  });
+  })
 }
 
-const wasmRuntimeRoots = new Set<string>();
+const wasmRuntimeRoots = new Set<string>()
 
 export function wasmModulePlugin(config: ResolvedConfig): Plugin {
-  const edgeChunkDir = path.join(config.outPath, 'server', 'edge-chunks');
+  const edgeChunkDir = path.join(config.outPath, 'server', 'edge-chunks')
   return {
     name: 'pnext-compat-wasm-module',
-      setup(build) {
+    setup(build) {
       build.onResolve({ filter: WASM_MODULE_FILTER }, args => {
-        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir);
-        if (!sourcePath) return undefined;
-        return { path: sourcePath, namespace: 'pnext-wasm-module' };
-      });
+        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir)
+        if (!sourcePath) return undefined
+        return { path: sourcePath, namespace: 'pnext-wasm-module' }
+      })
 
       build.onLoad({ filter: /.*/, namespace: 'pnext-wasm-module' }, async args => {
-        const sourcePath = path.resolve(args.path);
-        const bytes = new Uint8Array(await readFile(sourcePath));
-        const name = assetFileName(bytes);
-        const outFile = path.join(edgeChunkDir, name);
+        const sourcePath = path.resolve(args.path)
+        const bytes = new Uint8Array(await readFile(sourcePath))
+        const name = assetFileName(bytes)
+        const outFile = path.join(edgeChunkDir, name)
         if (!existsSync(outFile)) {
-          await mkdir(path.dirname(outFile), { recursive: true });
-          await writeFile(outFile, bytes);
+          await mkdir(path.dirname(outFile), { recursive: true })
+          await writeFile(outFile, bytes)
         }
-        registerManifestBinding(config.outPath, sourcePath, name);
-        const moduleBytes = JSON.stringify([...bytes]);
+        registerManifestBinding(config.outPath, sourcePath, name)
+        const moduleBytes = JSON.stringify([...bytes])
         return {
           contents: [
             `const bytes = new Uint8Array(${moduleBytes});`,
@@ -135,19 +133,19 @@ export function wasmModulePlugin(config: ResolvedConfig): Plugin {
             'export default module;',
           ].join('\n'),
           loader: 'js',
-        };
-      });
+        }
+      })
 
       // Bare `.wasm` (no `?module`): the instance's exports ARE the module's.
       build.onResolve({ filter: WASM_FILTER }, args => {
-        if (WASM_MODULE_FILTER.test(args.path)) return undefined;
-        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir);
-        return sourcePath ? { path: sourcePath, namespace: WASM_INSTANCE_NAMESPACE } : undefined;
-      });
+        if (WASM_MODULE_FILTER.test(args.path)) return undefined
+        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir)
+        return sourcePath ? { path: sourcePath, namespace: WASM_INSTANCE_NAMESPACE } : undefined
+      })
       build.onLoad({ filter: /.*/, namespace: WASM_INSTANCE_NAMESPACE }, async args => ({
         contents: wasmInstanceModuleSource(new Uint8Array(await readFile(path.resolve(args.path)))),
         loader: 'js',
-      }));
+      }))
     },
-  };
+  }
 }