@wular/pnext 0.0.3 → 0.0.6

package/src/utils/ansi.ts

@@ -1,9 +1,9 @@
 function color(open: string, close: string) {
-  return (value: string) => (process.stdout.isTTY ? `${open}${value}${close}` : value);
+  return (value: string) => (process.stdout.isTTY ? `${open}${value}${close}` : value)
 }
 
 /** Mid-gray for subordinate text. Readable on both light and dark terminals. */
-export const dim = color('\x1b[38;5;244m', '\x1b[39m');
-export const bold = color('\x1b[1m', '\x1b[22m');
-export const cyan = color('\x1b[36m', '\x1b[39m');
-export const green = color('\x1b[32m', '\x1b[39m');
+export const dim = color('\x1b[38;5;244m', '\x1b[39m')
+export const bold = color('\x1b[1m', '\x1b[22m')
+export const cyan = color('\x1b[36m', '\x1b[39m')
+export const green = color('\x1b[32m', '\x1b[39m')

package/src/utils/{source.ts → code.ts}

@@ -1,5 +1,5 @@
 export function escapeRegex(value: string) {
-  return value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
 }
 
 /**
@@ -11,25 +11,28 @@ export function specifierSniffTokens(keys: Iterable<string>): string[] {
   const heads = [
     ...new Set(
       [...keys].map(key => {
-        const head = key.split('/').slice(0, key.startsWith('@') ? 2 : 1).join('/');
-        return head.replace(/\*.*$/, '');
+        const head = key
+          .split('/')
+          .slice(0, key.startsWith('@') ? 2 : 1)
+          .join('/')
+        return head.replace(/\*.*$/, '')
       }),
     ),
-  ];
-  return heads.filter(head => !heads.some(other => other !== head && head.startsWith(other)));
+  ]
+  return heads.filter(head => !heads.some(other => other !== head && head.startsWith(other)))
 }
 
 export function uniqueIdentifier(source: string, base: string, ...used: string[]) {
-  const usedNames = new Set(used);
-  let name = base;
-  let index = 0;
+  const usedNames = new Set(used)
+  let name = base
+  let index = 0
   while (source.includes(name) || usedNames.has(name)) {
-    index += 1;
-    name = `${base}${index}`;
+    index += 1
+    name = `${base}${index}`
   }
-  return name;
+  return name
 }
 
 export function isIdentifier(value: string) {
-  return /^[A-Za-z_$][\w$]*$/.test(value);
+  return /^[A-Za-z_$][\w$]*$/.test(value)
 }

package/src/utils/content-type.ts

@@ -1,4 +1,4 @@
-import path from 'node:path';
+import path from 'node:path'
 
 const contentTypes: Record<string, string> = {
   '.avif': 'image/avif',
@@ -24,8 +24,8 @@ const contentTypes: Record<string, string> = {
   '.webp': 'image/webp',
   '.woff': 'font/woff',
   '.woff2': 'font/woff2',
-};
+}
 
 export function contentType(file: string): string {
-  return contentTypes[path.extname(file).toLowerCase()] ?? 'application/octet-stream';
+  return contentTypes[path.extname(file).toLowerCase()] ?? 'application/octet-stream'
 }

package/src/utils/decode.ts

@@ -1,7 +1,7 @@
 export function safeDecode(value: string) {
   try {
-    return decodeURIComponent(value);
+    return decodeURIComponent(value)
   } catch {
-    return value;
+    return value
   }
 }

package/src/utils/dev-profile.ts

@@ -3,29 +3,29 @@
  * straight to stdout inflated every enclosing span it sat inside - the measurement changed what it
  * measured. Lines accumulate here and the request handler flushes them in one write.
  */
-const SINK = Symbol.for('pnext.devProfileSink');
+const SINK = Symbol.for('pnext.devProfileSink')
 
 function sink(): string[] {
-  const store = globalThis as Record<PropertyKey, unknown>;
-  return (store[SINK] ??= []) as string[];
+  const store = globalThis as Record<PropertyKey, unknown>
+  return (store[SINK] ??= []) as string[]
 }
 
 export function recordDevProfileLine(line: string) {
-  sink().push(line);
+  sink().push(line)
 }
 
 /** Emit and clear everything buffered so far (one write per request). */
 export function flushDevProfileLines() {
-  const lines = sink();
-  if (lines.length === 0) return;
-  const out = lines.join('\n');
-  lines.length = 0;
-  console.log(out);
+  const lines = sink()
+  if (lines.length === 0) return
+  const out = lines.join('\n')
+  lines.length = 0
+  console.log(out)
 }
 
 export function formatProfileDuration(durationMs: number) {
-  const ms = Math.max(0, durationMs);
-  if (ms < 10) return `${ms.toFixed(2)}ms`;
-  if (ms < 1000) return `${ms.toFixed(1)}ms`;
-  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`;
+  const ms = Math.max(0, durationMs)
+  if (ms < 10) return `${ms.toFixed(2)}ms`
+  if (ms < 1000) return `${ms.toFixed(1)}ms`
+  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`
 }

package/src/utils/error-log.ts

@@ -6,7 +6,7 @@
 // without a WeakSet keyed to a work unit - an error thrown outside any work-unit scope is still deduped. A
 // non-Error throw cannot carry the tag; those are always logged.
 
-const ERROR_LOGGED = Symbol.for('pnext.errorLogged');
+const ERROR_LOGGED = Symbol.for('pnext.errorLogged')
 
 /**
  * Mark `error` as logged. Returns true when this call was the FIRST to mark it (the caller should log), false
@@ -15,15 +15,15 @@ const ERROR_LOGGED = Symbol.for('pnext.errorLogged');
  */
 export function markErrorLogged(error: unknown): boolean {
   if (error === null || (typeof error !== 'object' && typeof error !== 'function')) {
-    return true;
+    return true
   }
-  const holder = error as Record<symbol, unknown>;
-  if (holder[ERROR_LOGGED]) return false;
+  const holder = error as Record<symbol, unknown>
+  if (holder[ERROR_LOGGED]) return false
   Object.defineProperty(error, ERROR_LOGGED, {
     value: true,
     enumerable: false,
     configurable: true,
     writable: true,
-  });
-  return true;
+  })
+  return true
 }

package/src/utils/esbuild.ts

@@ -1,36 +1,36 @@
 // Lazy esbuild facade: importing 'esbuild' eagerly costs ~2.7 MB RSS and its
 // first build()/transform() call spawns a resident ~10-45 MB service child, so
 // the library must not load until something actually compiles.
-import type * as Esbuild from 'esbuild';
-import { loadNative } from './native-require';
+import type * as Esbuild from 'esbuild'
+import { loadNative } from './native-require'
 
-let esbuild: typeof Esbuild | undefined;
+let esbuild: typeof Esbuild | undefined
 
 function load(): typeof Esbuild {
   // eslint-disable-next-line @typescript-eslint/no-require-imports
-  return (esbuild ??= loadNative(() => require('esbuild') as typeof Esbuild));
+  return (esbuild ??= loadNative(() => require('esbuild') as typeof Esbuild))
 }
 
 // In-flight compiles, so a stop() never kills the service child out from under
 // one: esbuild drops the pending call's promise and it never settles.
-let inFlight = 0;
-let stopWhenIdle = false;
+let inFlight = 0
+let stopWhenIdle = false
 
 function track<T>(promise: Promise<T>): Promise<T> {
-  inFlight += 1;
+  inFlight += 1
   return promise.finally(() => {
-    inFlight -= 1;
+    inFlight -= 1
     if (inFlight === 0 && stopWhenIdle) {
-      stopWhenIdle = false;
-      void esbuild?.stop();
+      stopWhenIdle = false
+      void esbuild?.stop()
     }
-  });
+  })
 }
 
-export const build: typeof Esbuild.build = options => track(load().build(options));
+export const build: typeof Esbuild.build = options => track(load().build(options))
 
 export const transform: typeof Esbuild.transform = (input, options) =>
-  track(load().transform(input, options));
+  track(load().transform(input, options))
 
 /**
  * Spawn the resident service child ahead of the first real compile. Fire-and-forget: the spawn and
@@ -38,7 +38,7 @@ export const transform: typeof Esbuild.transform = (input, options) =>
  * which compiles nothing before it listens) can absorb a cost the first compile would otherwise pay.
  */
 export function warmEsbuildService(): void {
-  void transform('', { loader: 'js' }).catch(() => undefined);
+  void transform('', { loader: 'js' }).catch(() => undefined)
 }
 
 /**
@@ -49,10 +49,10 @@ export function warmEsbuildService(): void {
  * server boot, and killing the service mid-build hangs it forever.
  */
 export function stopEsbuildService(): void {
-  if (!esbuild) return;
+  if (!esbuild) return
   if (inFlight > 0) {
-    stopWhenIdle = true;
-    return;
+    stopWhenIdle = true
+    return
   }
-  void esbuild.stop();
+  void esbuild.stop()
 }

package/src/utils/fs-cache.ts

@@ -1,31 +1,31 @@
-import { existsSync, readdirSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readdirSync } 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}`
 
 // One cached dirent listing per directory replaces per-file stat probes.
 // node_modules only: installed layouts are process-immutable, app paths are not.
-const dirents = new Map<string, Set<string> | undefined>();
+const dirents = new Map<string, Set<string> | undefined>()
 
 function direntsFor(dir: string) {
-  if (dirents.has(dir)) return dirents.get(dir);
-  let names: Set<string> | undefined;
+  if (dirents.has(dir)) return dirents.get(dir)
+  let names: Set<string> | undefined
   try {
-    names = new Set(readdirSync(dir));
+    names = new Set(readdirSync(dir))
   } catch {
-    names = undefined;
+    names = undefined
   }
-  dirents.set(dir, names);
-  return names;
+  dirents.set(dir, names)
+  return names
 }
 
 /** `existsSync`, served from the dirent cache for node_modules paths. */
 export function cachedExistsSync(file: string): boolean {
-  if (!file.includes(NODE_MODULES)) return existsSync(file);
-  return direntsFor(path.dirname(file))?.has(path.basename(file)) ?? false;
+  if (!file.includes(NODE_MODULES)) return existsSync(file)
+  return direntsFor(path.dirname(file))?.has(path.basename(file)) ?? false
 }
 
 /** Structural-save invalidation: a file added or deleted changes the answers. */
 export function clearNodeModulesFsCache(): void {
-  dirents.clear();
+  dirents.clear()
 }

package/src/utils/fs.ts

@@ -1,45 +1,46 @@
-import { existsSync, readdirSync } from 'node:fs';
-import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 // Write-then-rename so a concurrent import never observes a truncated file; Bun caches a failed load for the
 // life of the process. The temp name must be unique per CALL, not per process: two writers of the same output
 // (two routes demanding one vendor bundle, a re-write after a cache eviction) otherwise share a name and the
 // second rename hits ENOENT once the first moved it away. Losing that race is harmless - both wrote the same
 // content-keyed bytes - so a rename whose temp is gone only fails if the destination is missing too.
-let atomicWriteSequence = 0;
+let atomicWriteSequence = 0
 export async function writeFileAtomic(file: string, contents: string) {
-  const temp = `${file}.${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`;
-  await writeFile(temp, contents);
+  const temp = `${file}.${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`
+  await writeFile(temp, contents)
   try {
-    await rename(temp, file);
+    await rename(temp, file)
   } catch (error) {
-    if (!existsSync(file)) throw error;
+    if (!existsSync(file)) throw error
   }
 }
 
 export async function listFiles(root: string): Promise<string[]> {
-  if (!existsSync(root)) return [];
-  const entries = await readdir(root, { withFileTypes: true });
+  if (!existsSync(root)) return []
+  const entries = await readdir(root, { withFileTypes: true })
   // Subdirectories are walked concurrently — a depth-first await chain spends
   // the whole walk waiting on one readdir at a time (0.6 s on a ~1k-file app).
   // Results stay in readdir order so callers keep a stable file order.
   const branches = await Promise.all(
     entries.map(entry => {
-      const entryPath = path.join(root, entry.name);
-      if (entry.isDirectory()) return listFiles(entryPath);
-      return Promise.resolve(entry.isFile() ? [entryPath] : []);
+      const entryPath = path.join(root, entry.name)
+      if (entry.isDirectory()) return listFiles(entryPath)
+      return Promise.resolve(entry.isFile() ? [entryPath] : [])
     }),
-  );
-  return branches.flat();
+  )
+  return branches.flat()
 }
 
 interface DirListing {
-  files: Set<string>;
-  dirs: string[];
+  files: Set<string>
+  dirs: string[]
 }
 
-let dirListings: Map<string, DirListing> | undefined;
+let dirListings: Map<string, DirListing> | undefined
 
 /**
  * Memoize directory listings for the duration of `run`. A route scan asks the
@@ -48,84 +49,91 @@ let dirListings: Map<string, DirListing> | undefined;
  * reads the directory fresh, so request-time callers never see a stale tree.
  */
 export function withDirCache<T>(run: () => T): T {
-  if (dirListings) return run();
-  dirListings = new Map();
+  if (dirListings) return run()
+  dirListings = new Map()
   try {
-    return run();
+    return run()
   } finally {
-    dirListings = undefined;
+    dirListings = undefined
   }
 }
 
 /** File and subdirectory names of `dir` (both empty when it does not exist). */
 export function readDirListing(dir: string): DirListing {
-  const cached = dirListings?.get(dir);
-  if (cached) return cached;
-  let listing: DirListing;
+  const cached = dirListings?.get(dir)
+  if (cached) return cached
+  let listing: DirListing
   try {
-    const entries = readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync(dir, { withFileTypes: true })
     listing = {
       files: new Set(entries.filter(entry => !entry.isDirectory()).map(entry => entry.name)),
       dirs: entries
         .filter(entry => entry.isDirectory())
         .map(entry => entry.name)
         .sort(),
-    };
+    }
   } catch {
-    listing = { files: new Set(), dirs: [] };
+    listing = { files: new Set(), dirs: [] }
   }
-  dirListings?.set(dir, listing);
-  return listing;
+  dirListings?.set(dir, listing)
+  return listing
 }
 
 /** listFiles for callers already running synchronously (route fact scans). */
 export function listFilesSync(root: string): string[] {
-  if (!existsSync(root)) return [];
-  const out: string[] = [];
+  if (!existsSync(root)) return []
+  const out: string[] = []
 
   for (const entry of readdirSync(root, { withFileTypes: true })) {
-    const entryPath = path.join(root, entry.name);
-    if (entry.isDirectory()) out.push(...listFilesSync(entryPath));
-    else if (entry.isFile()) out.push(entryPath);
+    const entryPath = path.join(root, entry.name)
+    if (entry.isDirectory()) out.push(...listFilesSync(entryPath))
+    else if (entry.isFile()) out.push(entryPath)
   }
 
-  return out;
+  return out
 }
 
 /** Empty `dir`, leaving the named top-level entries (and their contents) in place. */
 export async function ensureEmptyDir(dir: string, keep: readonly string[] = []) {
   if (keep.length === 0) {
-    await rm(dir, { recursive: true, force: true });
-    await mkdir(dir, { recursive: true });
-    return;
+    await rm(dir, { recursive: true, force: true })
+    await mkdir(dir, { recursive: true })
+    return
   }
-  await mkdir(dir, { recursive: true });
-  const preserved = new Set(keep);
-  const entries = await readdir(dir).catch(() => [] as string[]);
+  await mkdir(dir, { recursive: true })
+  const preserved = new Set(keep)
+  const entries = await readdir(dir).catch(() => [] as string[])
   await Promise.all(
     entries
       .filter(entry => !preserved.has(entry))
       .map(entry => rm(path.join(dir, entry), { recursive: true, force: true })),
-  );
+  )
 }
 
 export async function ensureDir(dir: string) {
-  await mkdir(dir, { recursive: true });
+  await mkdir(dir, { recursive: true })
 }
 
 export async function writeText(file: string, value: string) {
-  await ensureDir(path.dirname(file));
-  await writeFile(file, value);
+  await ensureDir(path.dirname(file))
+  await writeFile(file, value)
 }
 
 export async function readText(file: string) {
-  return readFile(file, 'utf8');
+  return readFile(file, 'utf8')
 }
 
 export async function fileMtime(file: string) {
-  return (await stat(file)).mtimeMs;
+  return (await stat(file)).mtimeMs
 }
 
 export function toPosixPath(value: string) {
-  return value.split(path.sep).join('/');
+  return value.split(path.sep).join('/')
+}
+
+/** '^' + pnext's own running version, read from its package.json (this module lives at src/utils/). */
+export function pnextVersionRange() {
+  const pkgPath = fileURLToPath(new URL('../../package.json', import.meta.url))
+  const { version } = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version: string }
+  return `^${version}`
 }

package/src/utils/html.ts

@@ -2,45 +2,41 @@ export function escapeHtml(value: unknown) {
   return stringifyHtmlValue(value).replace(/[&<>"']/g, char => {
     switch (char) {
       case '&':
-        return '&amp;';
+        return '&amp;'
       case '<':
-        return '&lt;';
+        return '&lt;'
       case '>':
-        return '&gt;';
+        return '&gt;'
       case '"':
-        return '&quot;';
+        return '&quot;'
       case "'":
-        return '&#39;';
+        return '&#39;'
       default:
-        return char;
+        return char
     }
-  });
+  })
 }
 
 export function stringifyHtmlValue(value: unknown) {
-  if (value === undefined || value === null) return '';
-  if (typeof value === 'string') return value;
-  if (
-    typeof value === 'number' ||
-    typeof value === 'boolean' ||
-    typeof value === 'bigint'
-  ) {
-    return String(value);
+  if (value === undefined || value === null) return ''
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    return String(value)
   }
-  if (value instanceof URL) return value.href;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value !== 'object') return '';
+  if (value instanceof URL) return value.href
+  if (value instanceof Date) return value.toISOString()
+  if (typeof value !== 'object') return ''
 
-  const stringifier = (value as { toString?: (this: object) => unknown }).toString;
-  if (!stringifier || stringifier === Object.prototype.toString) return '';
-  const stringified = stringifier.call(value);
-  if (typeof stringified === 'string') return stringified;
+  const stringifier = (value as { toString?: (this: object) => unknown }).toString
+  if (!stringifier || stringifier === Object.prototype.toString) return ''
+  const stringified = stringifier.call(value)
+  if (typeof stringified === 'string') return stringified
   if (
     typeof stringified === 'number' ||
     typeof stringified === 'boolean' ||
     typeof stringified === 'bigint'
   ) {
-    return String(stringified);
+    return String(stringified)
   }
-  return '';
+  return ''
 }

package/src/utils/native-require.ts

@@ -7,22 +7,22 @@
 // these loaders read `process.versions.node` / `process.versions.pnp` while initializing - so the
 // require throws. Load them against the real process instead; the module cache then holds a good copy
 // for every later call.
-import realProcess from 'node:process';
+import realProcess from 'node:process'
 
 export function loadNative<T>(load: () => T): T {
-  const globalObject = globalThis as typeof globalThis & { process?: NodeJS.Process };
-  if (globalObject.process === realProcess) return load();
-  const previous = Object.getOwnPropertyDescriptor(globalObject, 'process');
+  const globalObject = globalThis as typeof globalThis & { process?: NodeJS.Process }
+  if (globalObject.process === realProcess) return load()
+  const previous = Object.getOwnPropertyDescriptor(globalObject, 'process')
   Object.defineProperty(globalObject, 'process', {
     configurable: true,
     enumerable: false,
     writable: true,
     value: realProcess,
-  });
+  })
   try {
-    return load();
+    return load()
   } finally {
-    if (previous) Object.defineProperty(globalObject, 'process', previous);
-    else delete (globalObject as { process?: NodeJS.Process }).process;
+    if (previous) Object.defineProperty(globalObject, 'process', previous)
+    else delete (globalObject as { process?: NodeJS.Process }).process
   }
 }