@wular/pnext 0.0.3 → 0.0.6

package/src/resolve/source-text.ts

@@ -8,19 +8,19 @@
 // released when it ends and nothing outside a build is cached at all. That is what keeps the dev
 // watcher out of it - dev reads go straight to the filesystem, so a save is never served a stale
 // string, and content-keyed invalidation downstream is untouched.
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
 
 // eslint-disable-next-line turbo/no-undeclared-env-vars
-const disabled = process.env.PNEXT_SRC_CACHE === '0';
+const disabled = process.env.PNEXT_SRC_CACHE === '0'
 
-const contents = new Map<string, string>();
+const contents = new Map<string, string>()
 // Reads still in flight: two async consumers asking at once share one read
 // rather than racing two. Resolved entries move to `contents`.
-const inflight = new Map<string, Promise<string>>();
-let scoped = false;
-let reads = 0;
-let hits = 0;
+const inflight = new Map<string, Promise<string>>()
+let scoped = false
+let reads = 0
+let hits = 0
 
 /**
  * Start caching source reads. Two builds in one process (the test runner) share the map - keyed by absolute
@@ -28,59 +28,59 @@ let hits = 0;
  * uncached.
  */
 export function beginSourceScope() {
-  if (disabled) return;
-  scoped = true;
+  if (disabled) return
+  scoped = true
 }
 
 /** End the scope and drop everything it held. */
 export function endSourceScope() {
-  scoped = false;
-  contents.clear();
-  inflight.clear();
+  scoped = false
+  contents.clear()
+  inflight.clear()
 }
 
 export function readSourceSync(file: string): string {
-  if (!scoped) return readFileSync(file, 'utf8');
-  const cached = contents.get(file);
+  if (!scoped) return readFileSync(file, 'utf8')
+  const cached = contents.get(file)
   if (cached !== undefined) {
-    hits += 1;
-    return cached;
+    hits += 1
+    return cached
   }
-  reads += 1;
-  const source = readFileSync(file, 'utf8');
-  contents.set(file, source);
-  return source;
+  reads += 1
+  const source = readFileSync(file, 'utf8')
+  contents.set(file, source)
+  return source
 }
 
 export async function readSourceText(file: string): Promise<string> {
-  if (!scoped) return readFile(file, 'utf8');
-  const cached = contents.get(file);
+  if (!scoped) return readFile(file, 'utf8')
+  const cached = contents.get(file)
   if (cached !== undefined) {
-    hits += 1;
-    return cached;
+    hits += 1
+    return cached
   }
-  const pending = inflight.get(file);
+  const pending = inflight.get(file)
   if (pending) {
-    hits += 1;
-    return pending;
+    hits += 1
+    return pending
   }
-  reads += 1;
+  reads += 1
   // A read that fails is dropped from `inflight` too: the next asker retries and
   // sees the error at its own call site, as it would without the cache.
   const read = (async () => {
     try {
-      const source = await readFile(file, 'utf8');
-      contents.set(file, source);
-      return source;
+      const source = await readFile(file, 'utf8')
+      contents.set(file, source)
+      return source
     } finally {
-      inflight.delete(file);
+      inflight.delete(file)
     }
-  })();
-  inflight.set(file, read);
-  return read;
+  })()
+  inflight.set(file, read)
+  return read
 }
 
 /** Read effectiveness, for the build benches. */
 export function sourceCacheStats() {
-  return { reads, hits, files: contents.size };
+  return { reads, hits, files: contents.size }
 }

package/src/{dynamic → resolve}/tree-shake.ts

@@ -18,245 +18,249 @@
 
 export interface ShakeableDynamicImport {
   /** Absolute index (inclusive) of the specifier string literal, quote included. */
-  literalStart: number;
+  literalStart: number
   /** Absolute index (exclusive) just past the closing quote. */
-  literalEnd: number;
+  literalEnd: number
   /** The import specifier (without quotes). */
-  specifier: string;
+  specifier: string
   /**
    * Export names the destructuring keeps. An empty array means the module is
    * imported purely for side effects (`const {} = ...`): drop every export.
    */
-  usedExports: string[];
+  usedExports: string[]
 }
 
-const declStart = /\b(?:const|let|var)\s+\{/g;
+const declStart = /\b(?:const|let|var)\s+\{/g
 
 export function findShakeableDynamicImports(source: string): ShakeableDynamicImport[] {
-  const results: ShakeableDynamicImport[] = [];
-  let match: RegExpExecArray | null;
+  const results: ShakeableDynamicImport[] = []
+  let match: RegExpExecArray | null
 
   while ((match = declStart.exec(source))) {
-    const braceOpen = match.index + match[0].length - 1;
-    const braceClose = matchDelimiter(source, braceOpen, '{', '}');
-    if (braceClose < 0) continue;
+    const braceOpen = match.index + match[0].length - 1
+    const braceClose = matchDelimiter(source, braceOpen, '{', '}')
+    if (braceClose < 0) continue
 
-    let index = skipTrivia(source, braceClose + 1);
-    if (source[index] !== '=') continue;
-    index = skipTrivia(source, index + 1);
-    if (!matchesWord(source, index, 'await')) continue;
-    index = skipTrivia(source, index + 'await'.length);
-    if (!matchesWord(source, index, 'import')) continue;
-    index = skipTrivia(source, index + 'import'.length);
-    if (source[index] !== '(') continue;
+    let index = skipTrivia(source, braceClose + 1)
+    if (source[index] !== '=') continue
+    index = skipTrivia(source, index + 1)
+    if (!matchesWord(source, index, 'await')) continue
+    index = skipTrivia(source, index + 'await'.length)
+    if (!matchesWord(source, index, 'import')) continue
+    index = skipTrivia(source, index + 'import'.length)
+    if (source[index] !== '(') continue
 
-    const parenClose = matchDelimiter(source, index, '(', ')');
-    if (parenClose < 0) continue;
-    const argStart = index + 1;
-    const argText = source.slice(argStart, parenClose);
+    const parenClose = matchDelimiter(source, index, '(', ')')
+    if (parenClose < 0) continue
+    const argStart = index + 1
+    const argText = source.slice(argStart, parenClose)
 
-    const literal = firstStringLiteral(argText);
-    if (!literal || hasTrailingArgument(argText, literal.end)) continue;
+    const literal = firstStringLiteral(argText)
+    if (!literal || hasTrailingArgument(argText, literal.end)) continue
 
-    const patternExports = usedExportsFromPattern(source.slice(braceOpen, braceClose + 1));
-    if (patternExports === null) continue; // rest element — not shakeable
+    const patternExports = usedExportsFromPattern(source.slice(braceOpen, braceClose + 1))
+    if (patternExports === null) continue // rest element — not shakeable
 
-    const webpackExports = webpackExportsFromArg(argText);
+    const webpackExports = webpackExportsFromArg(argText)
     results.push({
       literalStart: argStart + literal.start,
       literalEnd: argStart + literal.end,
       specifier: literal.value,
       usedExports: webpackExports ?? patternExports,
-    });
-    declStart.lastIndex = parenClose + 1;
+    })
+    declStart.lastIndex = parenClose + 1
   }
 
-  return results;
+  return results
 }
 
 // Parse an object destructuring pattern (braces included) into the top-level
 // export names it binds. Returns null when a rest element is present (webpack
 // gives up on tree-shaking then).
 function usedExportsFromPattern(pattern: string): string[] | null {
-  const inner = pattern.slice(1, -1);
-  const names: string[] = [];
+  const inner = pattern.slice(1, -1)
+  const names: string[] = []
 
   for (const rawPart of splitTopLevel(inner)) {
-    const part = rawPart.trim();
-    if (!part) continue;
-    if (part.startsWith('...')) return null;
+    const part = rawPart.trim()
+    if (!part) continue
+    if (part.startsWith('...')) return null
 
-    const colon = topLevelColonIndex(part);
-    const keyRegion = colon >= 0 ? part.slice(0, colon) : part;
+    const colon = topLevelColonIndex(part)
+    const keyRegion = colon >= 0 ? part.slice(0, colon) : part
     // `{ a = fallback }` shorthand with a default — the key is before `=`.
-    const eq = colon >= 0 ? -1 : keyRegion.indexOf('=');
-    const name = (eq >= 0 ? keyRegion.slice(0, eq) : keyRegion).trim();
-    if (!/^[A-Za-z_$][\w$]*$/.test(name)) return null; // computed/string key — bail
-    names.push(name);
+    const eq = colon >= 0 ? -1 : keyRegion.indexOf('=')
+    const name = (eq >= 0 ? keyRegion.slice(0, eq) : keyRegion).trim()
+    if (!/^[A-Za-z_$][\w$]*$/.test(name)) return null // computed/string key — bail
+    names.push(name)
   }
 
-  return names;
+  return names
 }
 
 function webpackExportsFromArg(argText: string): string[] | undefined {
-  const match = /webpackExports\s*:\s*\[([^\]]*)\]/.exec(argText);
-  if (!match) return undefined;
-  const names: string[] = [];
-  const namePattern = /['"]([^'"]+)['"]/g;
-  let entry: RegExpExecArray | null;
+  const match = /webpackExports\s*:\s*\[([^\]]*)\]/.exec(argText)
+  if (!match) return undefined
+  const names: string[] = []
+  const namePattern = /['"]([^'"]+)['"]/g
+  let entry: RegExpExecArray | null
   while ((entry = namePattern.exec(match[1] ?? ''))) {
-    if (entry[1]) names.push(entry[1]);
+    if (entry[1]) names.push(entry[1])
   }
-  return names;
+  return names
 }
 
 // Split a comma-separated list at top level, ignoring commas nested in braces,
 // brackets, parens, strings, or comments.
 function splitTopLevel(source: string): string[] {
-  const parts: string[] = [];
-  let depth = 0;
-  let start = 0;
-  let index = 0;
+  const parts: string[] = []
+  let depth = 0
+  let start = 0
+  let index = 0
 
   while (index < source.length) {
-    const skipped = skipStringOrComment(source, index);
+    const skipped = skipStringOrComment(source, index)
     if (skipped > index) {
-      index = skipped;
-      continue;
+      index = skipped
+      continue
     }
-    const char = source[index];
-    if (char === '{' || char === '[' || char === '(') depth += 1;
-    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    const char = source[index]
+    if (char === '{' || char === '[' || char === '(') depth += 1
+    else if (char === '}' || char === ']' || char === ')') depth -= 1
     else if (char === ',' && depth === 0) {
-      parts.push(source.slice(start, index));
-      start = index + 1;
+      parts.push(source.slice(start, index))
+      start = index + 1
     }
-    index += 1;
+    index += 1
   }
-  parts.push(source.slice(start));
-  return parts;
+  parts.push(source.slice(start))
+  return parts
 }
 
 function topLevelColonIndex(source: string): number {
-  let depth = 0;
-  let index = 0;
+  let depth = 0
+  let index = 0
   while (index < source.length) {
-    const skipped = skipStringOrComment(source, index);
+    const skipped = skipStringOrComment(source, index)
     if (skipped > index) {
-      index = skipped;
-      continue;
+      index = skipped
+      continue
     }
-    const char = source[index];
-    if (char === '{' || char === '[' || char === '(') depth += 1;
-    else if (char === '}' || char === ']' || char === ')') depth -= 1;
-    else if (char === ':' && depth === 0) return index;
-    index += 1;
+    const char = source[index]
+    if (char === '{' || char === '[' || char === '(') depth += 1
+    else if (char === '}' || char === ']' || char === ')') depth -= 1
+    else if (char === ':' && depth === 0) return index
+    index += 1
   }
-  return -1;
+  return -1
 }
 
 // Index of the matching close delimiter for the open delimiter at `open`,
 // respecting nested delimiters, strings, and comments. Returns -1 if unbalanced.
 function matchDelimiter(source: string, open: number, openChar: string, closeChar: string): number {
-  let depth = 0;
-  let index = open;
+  let depth = 0
+  let index = open
   while (index < source.length) {
-    const skipped = skipStringOrComment(source, index);
+    const skipped = skipStringOrComment(source, index)
     if (skipped > index) {
-      index = skipped;
-      continue;
+      index = skipped
+      continue
     }
-    const char = source[index];
-    if (char === openChar) depth += 1;
+    const char = source[index]
+    if (char === openChar) depth += 1
     else if (char === closeChar) {
-      depth -= 1;
-      if (depth === 0) return index;
+      depth -= 1
+      if (depth === 0) return index
     }
-    index += 1;
+    index += 1
   }
-  return -1;
+  return -1
 }
 
 // Locate the first string literal in `text`, skipping leading whitespace and
 // comments. Returns its bounds (quotes included, `end` exclusive) and value.
-function firstStringLiteral(text: string): { start: number; end: number; value: string } | undefined {
-  let index = skipTrivia(text, 0);
-  const quote = text[index];
-  if (quote !== '"' && quote !== "'" && quote !== '`') return undefined;
-  const start = index;
-  index += 1;
-  let value = '';
+function firstStringLiteral(
+  text: string,
+): { start: number; end: number; value: string } | undefined {
+  let index = skipTrivia(text, 0)
+  const quote = text[index]
+  if (quote !== '"' && quote !== "'" && quote !== '`') return undefined
+  const start = index
+  index += 1
+  let value = ''
   while (index < text.length) {
-    const char = text[index];
+    const char = text[index]
     if (char === '\\') {
-      value += text[index + 1] ?? '';
-      index += 2;
-      continue;
+      value += text[index + 1] ?? ''
+      index += 2
+      continue
     }
-    if (char === quote) return { start, end: index + 1, value };
-    value += char;
-    index += 1;
+    if (char === quote) return { start, end: index + 1, value }
+    value += char
+    index += 1
   }
-  return undefined;
+  return undefined
 }
 
 // True when a second top-level argument follows the specifier — `import('x', y)`
 // is not a bare specifier import and is left untouched.
 function hasTrailingArgument(argText: string, afterLiteral: number): boolean {
-  const index = skipTrivia(argText, afterLiteral);
-  return index < argText.length && argText[index] === ',' && Boolean(argText.slice(index + 1).trim());
+  const index = skipTrivia(argText, afterLiteral)
+  return (
+    index < argText.length && argText[index] === ',' && Boolean(argText.slice(index + 1).trim())
+  )
 }
 
 function matchesWord(source: string, index: number, word: string): boolean {
-  if (!source.startsWith(word, index)) return false;
-  const after = source[index + word.length];
-  return after === undefined || !/[\w$]/.test(after);
+  if (!source.startsWith(word, index)) return false
+  const after = source[index + word.length]
+  return after === undefined || !/[\w$]/.test(after)
 }
 
 // Skip whitespace and `//`/`/* */` comments starting at `index`.
 function skipTrivia(source: string, index: number): number {
-  let current = index;
+  let current = index
   for (;;) {
-    while (current < source.length && /\s/.test(source[current] ?? '')) current += 1;
-    const skipped = skipComment(source, current);
-    if (skipped === current) return current;
-    current = skipped;
+    while (current < source.length && /\s/.test(source[current] ?? '')) current += 1
+    const skipped = skipComment(source, current)
+    if (skipped === current) return current
+    current = skipped
   }
 }
 
 // If `index` starts a string or comment, return the index just past it;
 // otherwise return `index` unchanged.
 function skipStringOrComment(source: string, index: number): number {
-  const comment = skipComment(source, index);
-  if (comment > index) return comment;
-  const char = source[index];
+  const comment = skipComment(source, index)
+  if (comment > index) return comment
+  const char = source[index]
   if (char === '"' || char === "'" || char === '`') {
-    let current = index + 1;
+    let current = index + 1
     while (current < source.length) {
       if (source[current] === '\\') {
-        current += 2;
-        continue;
+        current += 2
+        continue
       }
-      if (source[current] === char) return current + 1;
-      current += 1;
+      if (source[current] === char) return current + 1
+      current += 1
     }
-    return source.length;
+    return source.length
   }
-  return index;
+  return index
 }
 
 function skipComment(source: string, index: number): number {
   if (source[index] === '/' && source[index + 1] === '/') {
-    let current = index + 2;
-    while (current < source.length && source[current] !== '\n') current += 1;
-    return current;
+    let current = index + 2
+    while (current < source.length && source[current] !== '\n') current += 1
+    return current
   }
   if (source[index] === '/' && source[index + 1] === '*') {
-    let current = index + 2;
+    let current = index + 2
     while (current < source.length && !(source[current] === '*' && source[current + 1] === '/')) {
-      current += 1;
+      current += 1
     }
-    return Math.min(source.length, current + 2);
+    return Math.min(source.length, current + 2)
   }
-  return index;
+  return index
 }

package/src/routing/forwarded.ts

@@ -6,9 +6,9 @@
 // x-forwarded-* values are never overridden (a trusted proxy already set them),
 // including multi-value forms like "https, https".
 
-const FORWARDED_HOST = 'x-forwarded-host';
-const FORWARDED_PORT = 'x-forwarded-port';
-const FORWARDED_PROTO = 'x-forwarded-proto';
+const FORWARDED_HOST = 'x-forwarded-host'
+const FORWARDED_PORT = 'x-forwarded-port'
+const FORWARDED_PROTO = 'x-forwarded-proto'
 
 /**
  * Return the request with x-forwarded-host/port/proto injected from the request
@@ -16,26 +16,26 @@ const FORWARDED_PROTO = 'x-forwarded-proto';
  * request when every value was already present (no allocation on the hot path).
  */
 export function withForwardedHeaders(request: Request): Request {
-  const headers = request.headers;
-  const hasHost = headers.has(FORWARDED_HOST);
-  const hasPort = headers.has(FORWARDED_PORT);
-  const hasProto = headers.has(FORWARDED_PROTO);
-  if (hasHost && hasPort && hasProto) return request;
+  const headers = request.headers
+  const hasHost = headers.has(FORWARDED_HOST)
+  const hasPort = headers.has(FORWARDED_PORT)
+  const hasProto = headers.has(FORWARDED_PROTO)
+  if (hasHost && hasPort && hasProto) return request
 
-  let url: URL;
+  let url: URL
   try {
-    url = new URL(request.url);
+    url = new URL(request.url)
   } catch {
-    return request;
+    return request
   }
-  const host = headers.get('host') ?? url.host;
-  const proto = url.protocol.replace(':', '');
+  const host = headers.get('host') ?? url.host
+  const proto = url.protocol.replace(':', '')
   // The server's own listen port (reflected in the request URL by the runtime).
-  const port = url.port;
+  const port = url.port
 
-  const next = new Headers(headers);
-  if (!hasHost) next.set(FORWARDED_HOST, host);
-  if (!hasPort) next.set(FORWARDED_PORT, port);
-  if (!hasProto) next.set(FORWARDED_PROTO, proto);
-  return new Request(request, { headers: next });
+  const next = new Headers(headers)
+  if (!hasHost) next.set(FORWARDED_HOST, host)
+  if (!hasPort) next.set(FORWARDED_PORT, port)
+  if (!hasProto) next.set(FORWARDED_PROTO, proto)
+  return new Request(request, { headers: next })
 }