@wular/pnext 0.0.4 → 0.0.6

package/src/compat/bundler/require-context.ts

@@ -10,26 +10,26 @@
 // Wired as a server source transform (covering both the Bun runtime's per-file SSR loading and the
 // esbuild server passes) and as a client source transform.
 
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import path from 'node:path'
 
 /** Extensions whose files also get an extension-less request key (webpack resolves both). */
-const RESOLVABLE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json'];
+const RESOLVABLE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json']
 
 // `require.context(` — also matches the TS-cast form the Next fixtures use,
 // `(require as any).context(`, since the transform runs on pre-compiled source.
-const CONTEXT_CALL = /(?:\(\s*require\s+as\s+[^)]*\)|\brequire)\s*\.\s*context\s*\(/g;
+const CONTEXT_CALL = /(?:\(\s*require\s+as\s+[^)]*\)|\brequire)\s*\.\s*context\s*\(/g
 
 /** Cheap gate: does this source contain any candidate `require.context(` call? */
 export function sourceHasRequireContext(source: string): boolean {
-  return source.includes('.context(') && source.includes('require');
+  return source.includes('.context(') && source.includes('require')
 }
 
 interface ContextEntry {
   /** Request key, e.g. `./parent/file1.js`. */
-  key: string;
+  key: string
   /** Absolute path of the file the key resolves to. */
-  file: string;
+  file: string
 }
 
 /**
@@ -37,98 +37,101 @@ interface ContextEntry {
  * commas, ignoring commas nested in parens/brackets/braces, strings, regex
  * literals and comments. Returns `undefined` when the parens never balance.
  */
-function splitCallArguments(source: string, openIndex: number): { args: string[]; end: number } | undefined {
-  const args: string[] = [];
-  let depth = 0;
-  let start = openIndex + 1;
-  let index = openIndex;
-  let quote: string | undefined;
-  let inRegex = false;
+function splitCallArguments(
+  source: string,
+  openIndex: number,
+): { args: string[]; end: number } | undefined {
+  const args: string[] = []
+  let depth = 0
+  let start = openIndex + 1
+  let index = openIndex
+  let quote: string | undefined
+  let inRegex = false
   while (index < source.length) {
-    const char = source[index]!;
-    const prev = source[index - 1];
+    const char = source[index]!
+    const prev = source[index - 1]
     if (quote) {
-      if (char === quote && prev !== '\\') quote = undefined;
+      if (char === quote && prev !== '\\') quote = undefined
     } else if (inRegex) {
-      if (char === '/' && prev !== '\\') inRegex = false;
+      if (char === '/' && prev !== '\\') inRegex = false
     } else if (char === '"' || char === "'" || char === '`') {
-      quote = char;
+      quote = char
     } else if (char === '/' && source[index + 1] === '/') {
-      index = source.indexOf('\n', index);
-      if (index === -1) return undefined;
+      index = source.indexOf('\n', index)
+      if (index === -1) return undefined
     } else if (char === '/' && source[index + 1] === '*') {
-      const close = source.indexOf('*/', index + 2);
-      if (close === -1) return undefined;
-      index = close + 1;
+      const close = source.indexOf('*/', index + 2)
+      if (close === -1) return undefined
+      index = close + 1
     } else if (char === '/' && depth > 0) {
       // Inside the argument list a `/` can only start a regex literal (the
       // division case would need a preceding operand, which no argument
       // position of `require.context` produces).
-      inRegex = true;
+      inRegex = true
     } else if (char === '(' || char === '[' || char === '{') {
-      depth++;
+      depth++
     } else if (char === ')' || char === ']' || char === '}') {
-      depth--;
+      depth--
       if (depth === 0) {
-        args.push(source.slice(start, index));
-        const trimmed = args.map(arg => arg.trim());
-        return { args: trimmed.length === 1 && trimmed[0] === '' ? [] : trimmed, end: index };
+        args.push(source.slice(start, index))
+        const trimmed = args.map(arg => arg.trim())
+        return { args: trimmed.length === 1 && trimmed[0] === '' ? [] : trimmed, end: index }
       }
     } else if (char === ',' && depth === 1) {
-      args.push(source.slice(start, index));
-      start = index + 1;
+      args.push(source.slice(start, index))
+      start = index + 1
     }
-    index++;
+    index++
   }
-  return undefined;
+  return undefined
 }
 
 /** Parse a `/pattern/flags` literal; returns `undefined` for anything else. */
 function parseRegExpLiteral(text: string): RegExp | undefined {
-  const match = /^\/((?:\\.|\[(?:\\.|[^\]])*\]|[^/])+)\/([a-z]*)$/.exec(text);
-  if (!match) return undefined;
+  const match = /^\/((?:\\.|\[(?:\\.|[^\]])*\]|[^/])+)\/([a-z]*)$/.exec(text)
+  if (!match) return undefined
   try {
-    return new RegExp(match[1]!, match[2]!.replace(/[gy]/g, ''));
+    return new RegExp(match[1]!, match[2]!.replace(/[gy]/g, ''))
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 /** Parse a plain string literal argument; returns `undefined` for anything else. */
 function parseStringLiteral(text: string): string | undefined {
-  const match = /^(['"`])((?:\\.|[^\\])*)\1$/.exec(text);
-  if (!match) return undefined;
+  const match = /^(['"`])((?:\\.|[^\\])*)\1$/.exec(text)
+  if (!match) return undefined
   try {
-    return JSON.parse(`"${match[2]!.replace(/"/g, '\\"').replace(/\\'/g, "'")}"`) as string;
+    return JSON.parse(`"${match[2]!.replace(/"/g, '\\"').replace(/\\'/g, "'")}"`) as string
   } catch {
-    return match[2];
+    return match[2]
   }
 }
 
 function walkFiles(dir: string, recursive: boolean, prefix = ''): string[] {
-  let names: string[];
+  let names: string[]
   try {
-    names = readdirSync(dir).sort();
+    names = readdirSync(dir).sort()
   } catch {
-    return [];
+    return []
   }
-  const files: string[] = [];
+  const files: string[] = []
   for (const name of names) {
-    if (name.startsWith('.') || name === 'node_modules') continue;
-    const full = path.join(dir, name);
-    let isDirectory = false;
+    if (name.startsWith('.') || name === 'node_modules') continue
+    const full = path.join(dir, name)
+    let isDirectory = false
     try {
-      isDirectory = statSync(full).isDirectory();
+      isDirectory = statSync(full).isDirectory()
     } catch {
-      continue;
+      continue
     }
     if (isDirectory) {
-      if (recursive) files.push(...walkFiles(full, recursive, `${prefix}${name}/`));
+      if (recursive) files.push(...walkFiles(full, recursive, `${prefix}${name}/`))
     } else {
-      files.push(`${prefix}${name}`);
+      files.push(`${prefix}${name}`)
     }
   }
-  return files;
+  return files
 }
 
 /**
@@ -138,23 +141,27 @@ function walkFiles(dir: string, recursive: boolean, prefix = ''): string[] {
  * accepts everything AND the extension-less form of each resolvable file also
  * becomes a key, since `require('./parent/file1')` resolves there too.
  */
-export function requireContextEntries(dir: string, recursive: boolean, regExp?: RegExp): ContextEntry[] {
-  const entries: ContextEntry[] = [];
-  const seen = new Set<string>();
+export function requireContextEntries(
+  dir: string,
+  recursive: boolean,
+  regExp?: RegExp,
+): ContextEntry[] {
+  const entries: ContextEntry[] = []
+  const seen = new Set<string>()
   for (const relative of walkFiles(dir, recursive)) {
-    const file = path.join(dir, ...relative.split('/'));
-    const keys = [`./${relative}`];
+    const file = path.join(dir, ...relative.split('/'))
+    const keys = [`./${relative}`]
     if (!regExp && RESOLVABLE_EXTENSIONS.includes(path.extname(relative))) {
-      keys.push(`./${relative.slice(0, -path.extname(relative).length)}`);
+      keys.push(`./${relative.slice(0, -path.extname(relative).length)}`)
     }
     for (const key of keys) {
-      if (regExp && !regExp.test(key)) continue;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      entries.push({ key, file });
+      if (regExp && !regExp.test(key)) continue
+      if (seen.has(key)) continue
+      seen.add(key)
+      entries.push({ key, file })
     }
   }
-  return entries.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+  return entries.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))
 }
 
 // Runtime helper injected alongside the expanded contexts. `ctx(key)` mirrors
@@ -186,7 +193,7 @@ const CONTEXT_RUNTIME = `function __pnext_require_context(entries, id) {
   };
   context.id = id;
   return context;
-}`;
+}`
 
 /**
  * Resolve the context directory argument against the importing file. Server
@@ -200,22 +207,22 @@ function resolveContextDir(
   file: string,
   paths: { outPath?: string; workspaceRoot?: string } | undefined,
 ): string {
-  const direct = path.resolve(path.dirname(file), specifier);
-  if (existsSync(direct)) return direct;
+  const direct = path.resolve(path.dirname(file), specifier)
+  if (existsSync(direct)) return direct
   if (paths?.outPath && paths.workspaceRoot) {
-    const cacheRoot = path.join(paths.outPath, 'cache', 'server');
-    const relative = path.relative(cacheRoot, file);
+    const cacheRoot = path.join(paths.outPath, 'cache', 'server')
+    const relative = path.relative(cacheRoot, file)
     if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
-      const segments = relative.split(path.sep);
-      segments.shift(); // drop <profileDir>
+      const segments = relative.split(path.sep)
+      segments.shift() // drop <profileDir>
       const original = path.resolve(
         path.dirname(path.join(paths.workspaceRoot, ...segments)),
         specifier,
-      );
-      if (existsSync(original)) return original;
+      )
+      if (existsSync(original)) return original
     }
   }
-  return direct;
+  return direct
 }
 
 /**
@@ -229,53 +236,52 @@ export function rewriteRequireContextSource(
   file: string,
   paths?: { outPath?: string; workspaceRoot?: string },
 ): string {
-  if (!sourceHasRequireContext(source)) return source;
-  const imports: string[] = [];
-  const contexts: string[] = [];
-  let output = '';
-  let cursor = 0;
-  CONTEXT_CALL.lastIndex = 0;
-  let match: RegExpExecArray | null;
+  if (!sourceHasRequireContext(source)) return source
+  const imports: string[] = []
+  const contexts: string[] = []
+  let output = ''
+  let cursor = 0
+  CONTEXT_CALL.lastIndex = 0
+  let match: RegExpExecArray | null
   while ((match = CONTEXT_CALL.exec(source))) {
-    const openIndex = match.index + match[0].length - 1;
-    const parsed = splitCallArguments(source, openIndex);
-    if (!parsed) continue;
-    const [dirArg, recursiveArg, regExpArg] = parsed.args;
-    const specifier = dirArg === undefined ? undefined : parseStringLiteral(dirArg);
-    if (specifier === undefined) continue;
-    const recursive = recursiveArg === undefined ? true : recursiveArg.trim() !== 'false';
-    const regExp = regExpArg === undefined ? undefined : parseRegExpLiteral(regExpArg.trim());
-    if (regExpArg !== undefined && !regExp) continue;
+    const openIndex = match.index + match[0].length - 1
+    const parsed = splitCallArguments(source, openIndex)
+    if (!parsed) continue
+    const [dirArg, recursiveArg, regExpArg] = parsed.args
+    const specifier = dirArg === undefined ? undefined : parseStringLiteral(dirArg)
+    if (specifier === undefined) continue
+    const recursive = recursiveArg === undefined ? true : recursiveArg.trim() !== 'false'
+    const regExp = regExpArg === undefined ? undefined : parseRegExpLiteral(regExpArg.trim())
+    if (regExpArg !== undefined && !regExp) continue
 
-    const dir = resolveContextDir(specifier, file, paths);
-    const entries = requireContextEntries(dir, recursive, regExp);
-    const id = contexts.length;
-    const binding = `__pnext_context_${id}`;
+    const dir = resolveContextDir(specifier, file, paths)
+    const entries = requireContextEntries(dir, recursive, regExp)
+    const id = contexts.length
+    const binding = `__pnext_context_${id}`
     const rows = entries.map((entry, index) => {
-      const namespace = `${binding}_${index}`;
-      imports.push(`import * as ${namespace} from ${JSON.stringify(entry.file)};`);
-      return `[${JSON.stringify(entry.key)}, ${JSON.stringify(entry.file)}, ${namespace}]`;
-    });
-    const contextId = `${specifier} ${recursive ? 'recursive ' : ''}${regExp ? regExp.source : '^\\.\\/.*$'}`;
+      const namespace = `${binding}_${index}`
+      imports.push(`import * as ${namespace} from ${JSON.stringify(entry.file)};`)
+      return `[${JSON.stringify(entry.key)}, ${JSON.stringify(entry.file)}, ${namespace}]`
+    })
+    const contextId = `${specifier} ${recursive ? 'recursive ' : ''}${regExp ? regExp.source : '^\\.\\/.*$'}`
     contexts.push(
       `const ${binding} = __pnext_require_context([${rows.join(', ')}], ${JSON.stringify(contextId)});`,
-    );
-    output += source.slice(cursor, match.index) + binding;
-    cursor = parsed.end + 1;
-    CONTEXT_CALL.lastIndex = cursor;
+    )
+    output += source.slice(cursor, match.index) + binding
+    cursor = parsed.end + 1
+    CONTEXT_CALL.lastIndex = cursor
   }
-  if (contexts.length === 0) return source;
-  output += source.slice(cursor);
-  const injection = [...imports, CONTEXT_RUNTIME, ...contexts].join('\n');
-  return injectAfterDirectives(output, injection);
+  if (contexts.length === 0) return source
+  output += source.slice(cursor)
+  const injection = [...imports, CONTEXT_RUNTIME, ...contexts].join('\n')
+  return injectAfterDirectives(output, injection)
 }
 
 // Injected declarations go after any leading directive prologue ('use client' /
 // 'use server') and optional shebang so the directive stays the first statement.
 function injectAfterDirectives(source: string, injection: string): string {
-  const prologue = /^(\uFEFF?(?:#![^\n]*\n)?(?:[ \t]*(['"])use [\w-]+\2[ \t]*;?[ \t]*(?:\r?\n|$))*)/.exec(
-    source,
-  );
-  const index = prologue ? prologue[0].length : 0;
-  return `${source.slice(0, index)}${injection}\n${source.slice(index)}`;
+  const prologue =
+    /^(\uFEFF?(?:#![^\n]*\n)?(?:[ \t]*(['"])use [\w-]+\2[ \t]*;?[ \t]*(?:\r?\n|$))*)/.exec(source)
+  const index = prologue ? prologue[0].length : 0
+  return `${source.slice(0, index)}${injection}\n${source.slice(index)}`
 }

package/src/compat/bundler/resolve-extensions.ts

@@ -9,17 +9,17 @@
 // downstream plugin sees the same path it would for an explicit extension. Only registered when the app
 // configures resolveExtensions.
 
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import type { Plugin } from 'esbuild';
+import { existsSync, statSync } from 'node:fs'
+import path from 'node:path'
+import type { Plugin } from 'esbuild'
 
-const resolvedMarker = Symbol('pnext-resolve-extensions');
+const resolvedMarker = Symbol('pnext-resolve-extensions')
 
 function isFile(file: string): boolean {
   try {
-    return statSync(file).isFile();
+    return statSync(file).isFile()
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -34,15 +34,15 @@ export function clientResolveExtensionsPlugin(extensions: readonly string[]): Pl
     setup(build) {
       build.onResolve({ filter: /^\.\.?\// }, async args => {
         if ((args.pluginData as Record<PropertyKey, unknown> | undefined)?.[resolvedMarker]) {
-          return undefined;
+          return undefined
         }
-        if (!args.resolveDir) return undefined;
-        const base = path.resolve(args.resolveDir, args.path);
+        if (!args.resolveDir) return undefined
+        const base = path.resolve(args.resolveDir, args.path)
         // An import that already names an existing file resolves as-is.
-        if (isFile(base)) return undefined;
+        if (isFile(base)) return undefined
         for (const extension of extensions) {
-          const candidate = `${base}${extension}`;
-          if (!isFile(candidate)) continue;
+          const candidate = `${base}${extension}`
+          if (!isFile(candidate)) continue
           // Re-dispatch with the extension made explicit so downstream
           // onResolve plugins (static assets, css) match on it.
           return build.resolve(`${args.path}${extension}`, {
@@ -51,25 +51,25 @@ export function clientResolveExtensionsPlugin(extensions: readonly string[]): Pl
             namespace: args.namespace,
             resolveDir: args.resolveDir,
             pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
-          });
+          })
         }
         // Directory (index probe) or genuinely missing: preserve the probe
         // order for index files too, then fall back to esbuild's resolution.
         if (existsSync(base)) {
           for (const extension of extensions) {
-            if (extension === '') continue;
-            if (!isFile(path.join(base, `index${extension}`))) continue;
+            if (extension === '') continue
+            if (!isFile(path.join(base, `index${extension}`))) continue
             return build.resolve(`${args.path.replace(/\/$/, '')}/index${extension}`, {
               kind: args.kind,
               importer: args.importer,
               namespace: args.namespace,
               resolveDir: args.resolveDir,
               pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
-            });
+            })
           }
         }
-        return undefined;
-      });
+        return undefined
+      })
     },
-  };
+  }
 }

package/src/compat/bundler/source-cache.ts

@@ -7,40 +7,40 @@
  * for the life of the process (the same assumption the vendor artifact cache makes), and anything
  * else is keyed on mtime + size so an edit is never served from the memo.
  */
-import { statSync } from 'node:fs';
-import path from 'node:path';
+import { statSync } from 'node:fs'
+import path from 'node:path'
 
-const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`
 
 interface Entry<T> {
-  stamp: string;
-  value: T;
+  stamp: string
+  value: T
 }
 
 /** mtime+size stamp, or '' for a file whose contents cannot change here. */
 function stamp(file: string) {
-  if (file.includes(NODE_MODULES)) return '';
+  if (file.includes(NODE_MODULES)) return ''
   try {
-    const info = statSync(file);
-    return `${info.mtimeMs}\0${info.size}`;
+    const info = statSync(file)
+    return `${info.mtimeMs}\0${info.size}`
   } catch {
     // A missing file is a real answer for the callers here (they all catch), so
     // it is cached like any other — under a stamp no live file can produce.
-    return 'missing';
+    return 'missing'
   }
 }
 
 /** A memo whose entries are recomputed when their file changes on disk. */
 export function fileMemo<T>(compute: (file: string) => T) {
-  const entries = new Map<string, Entry<T>>();
+  const entries = new Map<string, Entry<T>>()
   return (file: string): T => {
-    const current = stamp(file);
-    const cached = entries.get(file);
-    if (cached?.stamp === current) return cached.value;
-    const value = compute(file);
-    entries.set(file, { stamp: current, value });
-    return value;
-  };
+    const current = stamp(file)
+    const cached = entries.get(file)
+    if (cached?.stamp === current) return cached.value
+    const value = compute(file)
+    entries.set(file, { stamp: current, value })
+    return value
+  }
 }
 
 /**
@@ -49,13 +49,13 @@ export function fileMemo<T>(compute: (file: string) => T) {
  * use - awaiting one lets the other builds' callbacks interleave with it.
  */
 export function fileMemoAsync<T>(compute: (file: string) => Promise<T>) {
-  const entries = new Map<string, Entry<Promise<T>>>();
+  const entries = new Map<string, Entry<Promise<T>>>()
   return (file: string): Promise<T> => {
-    const current = stamp(file);
-    const cached = entries.get(file);
-    if (cached?.stamp === current) return cached.value;
-    const value = compute(file);
-    entries.set(file, { stamp: current, value });
-    return value;
-  };
+    const current = stamp(file)
+    const cached = entries.get(file)
+    if (cached?.stamp === current) return cached.value
+    const value = compute(file)
+    entries.set(file, { stamp: current, value })
+    return value
+  }
 }

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

@@ -1,5 +1,5 @@
-import { pathToFileHref } from '../../config';
-import { rewriteSpecifierLiterals } from '../../resolve/scan-facts';
+import { pathToFileHref } from '../../config'
+import { rewriteSpecifierLiterals } from '../../resolve/scan-facts'
 
 /**
  * Resolve registered compat aliases before Bun reaches installed package entries. Folded onto the
@@ -16,10 +16,10 @@ export function rewriteStaticCompatImports(
   return rewriteSpecifierLiterals(source, file, (specifier, kind) => {
     // A side-effect `import 'x'` keeps resolving through the host resolver, as
     // it did under the `from`-anchored regex this replaced.
-    const target = kind === 'side-effect' ? undefined : aliases[specifier];
-    if (!target) return undefined;
+    const target = kind === 'side-effect' ? undefined : aliases[specifier]
+    if (!target) return undefined
     const resolved =
-      kind === 'require' ? (requireAliases[specifier] ?? target) : pathToFileHref(target);
-    return JSON.stringify(resolved);
-  });
+      kind === 'require' ? (requireAliases[specifier] ?? target) : pathToFileHref(target)
+    return JSON.stringify(resolved)
+  })
 }