almostnode 0.1.0

package/src/shims/process.ts

@@ -0,0 +1,346 @@
+/**
+ * Node.js process shim
+ * Provides minimal process object for browser environment
+ * Process is an EventEmitter in Node.js
+ */
+
+import { EventEmitter, EventListener } from './events';
+
+export interface ProcessEnv {
+  [key: string]: string | undefined;
+}
+
+// Stream-like interface with EventEmitter methods
+interface ProcessStream {
+  isTTY: boolean;
+  on: (event: string, listener: EventListener) => ProcessStream;
+  once: (event: string, listener: EventListener) => ProcessStream;
+  off: (event: string, listener: EventListener) => ProcessStream;
+  emit: (event: string, ...args: unknown[]) => boolean;
+  addListener: (event: string, listener: EventListener) => ProcessStream;
+  removeListener: (event: string, listener: EventListener) => ProcessStream;
+  removeAllListeners: (event?: string) => ProcessStream;
+  setMaxListeners: (n: number) => ProcessStream;
+  pause?: () => ProcessStream;
+  resume?: () => ProcessStream;
+  setEncoding?: (encoding: string) => ProcessStream;
+}
+
+interface ProcessWritableStream extends ProcessStream {
+  write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
+  end?: (data?: string, callback?: () => void) => void;
+}
+
+interface ProcessReadableStream extends ProcessStream {
+  read?: (size?: number) => string | Buffer | null;
+  setRawMode?: (mode: boolean) => ProcessReadableStream;
+}
+
+export interface Process {
+  env: ProcessEnv;
+  cwd: () => string;
+  chdir: (directory: string) => void;
+  platform: string;
+  version: string;
+  versions: { node: string; v8: string; uv: string };
+  argv: string[];
+  argv0: string;
+  execPath: string;
+  execArgv: string[];
+  pid: number;
+  ppid: number;
+  exit: (code?: number) => never;
+  nextTick: (callback: (...args: unknown[]) => void, ...args: unknown[]) => void;
+  stdout: ProcessWritableStream;
+  stderr: ProcessWritableStream;
+  stdin: ProcessReadableStream;
+  hrtime: {
+    (time?: [number, number]): [number, number];
+    bigint: () => bigint;
+  };
+  memoryUsage: () => { rss: number; heapTotal: number; heapUsed: number; external: number; arrayBuffers: number };
+  uptime: () => number;
+  cpuUsage: () => { user: number; system: number };
+  // EventEmitter methods
+  on: (event: string, listener: EventListener) => Process;
+  once: (event: string, listener: EventListener) => Process;
+  off: (event: string, listener: EventListener) => Process;
+  emit: (event: string, ...args: unknown[]) => boolean;
+  addListener: (event: string, listener: EventListener) => Process;
+  removeListener: (event: string, listener: EventListener) => Process;
+  removeAllListeners: (event?: string) => Process;
+  listeners: (event: string) => EventListener[];
+  listenerCount: (event: string) => number;
+  prependListener: (event: string, listener: EventListener) => Process;
+  prependOnceListener: (event: string, listener: EventListener) => Process;
+  eventNames: () => string[];
+  setMaxListeners: (n: number) => Process;
+  getMaxListeners: () => number;
+  // Internal debug counter
+  _cwdCallCount?: number;
+}
+
+// Helper to create a stream-like object with EventEmitter methods
+function createProcessStream(
+  isWritable: boolean,
+  writeImpl?: (data: string) => boolean
+): ProcessWritableStream | ProcessReadableStream {
+  const emitter = new EventEmitter();
+
+  const stream: ProcessWritableStream & ProcessReadableStream = {
+    isTTY: false,
+
+    on(event: string, listener: EventListener) {
+      emitter.on(event, listener);
+      return stream;
+    },
+    once(event: string, listener: EventListener) {
+      emitter.once(event, listener);
+      return stream;
+    },
+    off(event: string, listener: EventListener) {
+      emitter.off(event, listener);
+      return stream;
+    },
+    emit(event: string, ...args: unknown[]) {
+      return emitter.emit(event, ...args);
+    },
+    addListener(event: string, listener: EventListener) {
+      emitter.addListener(event, listener);
+      return stream;
+    },
+    removeListener(event: string, listener: EventListener) {
+      emitter.removeListener(event, listener);
+      return stream;
+    },
+    removeAllListeners(event?: string) {
+      emitter.removeAllListeners(event);
+      return stream;
+    },
+    setMaxListeners(n: number) {
+      emitter.setMaxListeners(n);
+      return stream;
+    },
+    pause() {
+      return stream;
+    },
+    resume() {
+      return stream;
+    },
+    setEncoding(_encoding: string) {
+      return stream;
+    },
+    // Default write implementation (no-op for readable streams)
+    write(_data: string | Buffer, _encoding?: string, callback?: () => void) {
+      if (callback) queueMicrotask(callback);
+      return true;
+    },
+    end(_data?: string, callback?: () => void) {
+      if (callback) queueMicrotask(callback);
+    },
+    // Default read implementation (for stdin)
+    read() {
+      return null;
+    },
+    setRawMode(_mode: boolean) {
+      return stream;
+    },
+  };
+
+  // Override write for actual writable streams
+  if (isWritable && writeImpl) {
+    stream.write = (data: string | Buffer, _encoding?: string, callback?: () => void) => {
+      const result = writeImpl(typeof data === 'string' ? data : data.toString());
+      if (callback) queueMicrotask(callback);
+      return result;
+    };
+  }
+
+  return stream;
+}
+
+export function createProcess(options?: {
+  cwd?: string;
+  env?: ProcessEnv;
+  onExit?: (code: number) => void;
+}): Process {
+  let currentDir = options?.cwd || '/';
+  const env: ProcessEnv = {
+    NODE_ENV: 'development',
+    PATH: '/usr/local/bin:/usr/bin:/bin',
+    HOME: '/',
+    ...options?.env,
+  };
+
+  // Create an EventEmitter for process events
+  const emitter = new EventEmitter();
+  const startTime = Date.now();
+
+  const proc: Process = {
+    env,
+
+    cwd() {
+      // Debug: Log cwd calls (limited to first 5)
+      if (!proc._cwdCallCount) proc._cwdCallCount = 0;
+      proc._cwdCallCount++;
+      if (proc._cwdCallCount <= 5 || proc._cwdCallCount % 100 === 0) {
+        console.log(`[process] cwd() called (${proc._cwdCallCount}x), returning:`, currentDir);
+      }
+      return currentDir;
+    },
+
+    chdir(directory: string) {
+      console.log('[process] chdir called:', directory, 'from:', currentDir);
+      if (!directory.startsWith('/')) {
+        directory = currentDir + '/' + directory;
+      }
+      currentDir = directory;
+      console.log('[process] chdir result:', currentDir);
+    },
+
+    platform: 'linux', // Pretend to be linux for better compatibility
+    version: 'v20.0.0',
+    versions: { node: '20.0.0', v8: '11.3.244.8', uv: '1.44.2' },
+
+    argv: ['node', '/index.js'],
+    argv0: 'node',
+    execPath: '/usr/local/bin/node',
+    execArgv: [],
+
+    pid: 1,
+    ppid: 0,
+
+    exit(code = 0) {
+      emitter.emit('exit', code);
+      if (options?.onExit) {
+        options.onExit(code);
+      }
+      throw new Error(`Process exited with code ${code}`);
+    },
+
+    nextTick(callback, ...args) {
+      queueMicrotask(() => callback(...args));
+    },
+
+    stdout: createProcessStream(true, (data: string) => {
+      console.log(data);
+      return true;
+    }) as ProcessWritableStream,
+
+    stderr: createProcessStream(true, (data: string) => {
+      console.error(data);
+      return true;
+    }) as ProcessWritableStream,
+
+    stdin: createProcessStream(false) as ProcessReadableStream,
+
+    hrtime: Object.assign(
+      function hrtime(time?: [number, number]): [number, number] {
+        const now = performance.now();
+        const seconds = Math.floor(now / 1000);
+        const nanoseconds = Math.floor((now % 1000) * 1e6);
+        if (time) {
+          const diffSeconds = seconds - time[0];
+          const diffNanos = nanoseconds - time[1];
+          return [diffSeconds, diffNanos];
+        }
+        return [seconds, nanoseconds];
+      },
+      {
+        bigint: (): bigint => BigInt(Math.floor(performance.now() * 1e6)),
+      }
+    ),
+
+    memoryUsage() {
+      // Return mock values since we can't access real memory in browser
+      return {
+        rss: 50 * 1024 * 1024,
+        heapTotal: 30 * 1024 * 1024,
+        heapUsed: 20 * 1024 * 1024,
+        external: 1 * 1024 * 1024,
+        arrayBuffers: 0,
+      };
+    },
+
+    uptime() {
+      return (Date.now() - startTime) / 1000;
+    },
+
+    cpuUsage() {
+      return { user: 0, system: 0 };
+    },
+
+    // EventEmitter methods - delegate to emitter but return proc for chaining
+    on(event: string, listener: EventListener): Process {
+      emitter.on(event, listener);
+      return proc;
+    },
+
+    once(event: string, listener: EventListener): Process {
+      emitter.once(event, listener);
+      return proc;
+    },
+
+    off(event: string, listener: EventListener): Process {
+      emitter.off(event, listener);
+      return proc;
+    },
+
+    emit(event: string, ...args: unknown[]): boolean {
+      return emitter.emit(event, ...args);
+    },
+
+    addListener(event: string, listener: EventListener): Process {
+      emitter.addListener(event, listener);
+      return proc;
+    },
+
+    removeListener(event: string, listener: EventListener): Process {
+      emitter.removeListener(event, listener);
+      return proc;
+    },
+
+    removeAllListeners(event?: string): Process {
+      emitter.removeAllListeners(event);
+      return proc;
+    },
+
+    listeners(event: string): EventListener[] {
+      return emitter.listeners(event);
+    },
+
+    listenerCount(event: string): number {
+      return emitter.listenerCount(event);
+    },
+
+    prependListener(event: string, listener: EventListener): Process {
+      emitter.prependListener(event, listener);
+      return proc;
+    },
+
+    prependOnceListener(event: string, listener: EventListener): Process {
+      emitter.prependOnceListener(event, listener);
+      return proc;
+    },
+
+    eventNames(): string[] {
+      return emitter.eventNames();
+    },
+
+    setMaxListeners(n: number): Process {
+      emitter.setMaxListeners(n);
+      return proc;
+    },
+
+    getMaxListeners(): number {
+      return emitter.getMaxListeners();
+    },
+  };
+
+  return proc;
+}
+
+// Default process instance
+export const process = createProcess();
+
+export default process;

package/src/shims/querystring.ts

@@ -0,0 +1,97 @@
+/**
+ * Node.js querystring module shim
+ * Uses browser's URLSearchParams
+ */
+
+export type ParsedUrlQuery = Record<string, string | string[]>;
+
+export function parse(
+  str: string,
+  sep: string = '&',
+  eq: string = '=',
+  options?: { maxKeys?: number }
+): ParsedUrlQuery {
+  const result: ParsedUrlQuery = {};
+
+  if (!str || typeof str !== 'string') {
+    return result;
+  }
+
+  const maxKeys = options?.maxKeys || 1000;
+  const pairs = str.split(sep).slice(0, maxKeys > 0 ? maxKeys : undefined);
+
+  for (const pair of pairs) {
+    const idx = pair.indexOf(eq);
+    let key: string;
+    let value: string;
+
+    if (idx >= 0) {
+      key = decodeURIComponent(pair.slice(0, idx).replace(/\+/g, ' '));
+      value = decodeURIComponent(pair.slice(idx + 1).replace(/\+/g, ' '));
+    } else {
+      key = decodeURIComponent(pair.replace(/\+/g, ' '));
+      value = '';
+    }
+
+    if (key in result) {
+      const existing = result[key];
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+export function stringify(
+  obj: Record<string, string | string[] | number | boolean | undefined>,
+  sep: string = '&',
+  eq: string = '='
+): string {
+  if (!obj || typeof obj !== 'object') {
+    return '';
+  }
+
+  const pairs: string[] = [];
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined) continue;
+
+    const encodedKey = encodeURIComponent(key);
+
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        pairs.push(`${encodedKey}${eq}${encodeURIComponent(String(v))}`);
+      }
+    } else {
+      pairs.push(`${encodedKey}${eq}${encodeURIComponent(String(value))}`);
+    }
+  }
+
+  return pairs.join(sep);
+}
+
+export function escape(str: string): string {
+  return encodeURIComponent(str);
+}
+
+export function unescape(str: string): string {
+  return decodeURIComponent(str.replace(/\+/g, ' '));
+}
+
+export const encode = stringify;
+export const decode = parse;
+
+export default {
+  parse,
+  stringify,
+  escape,
+  unescape,
+  encode,
+  decode,
+};

package/src/shims/readdirp.ts

@@ -0,0 +1,228 @@
+/**
+ * readdirp shim - Recursive directory reader
+ * Used by some build tools for file discovery
+ */
+
+import type { VirtualFS, Stats } from '../virtual-fs';
+
+// Global reference to VFS - set by runtime
+let globalVFS: VirtualFS | null = null;
+
+export function setVFS(vfs: VirtualFS): void {
+  globalVFS = vfs;
+}
+
+export interface ReaddirpOptions {
+  root?: string;
+  fileFilter?: string | string[] | ((entry: EntryInfo) => boolean);
+  directoryFilter?: string | string[] | ((entry: EntryInfo) => boolean);
+  depth?: number;
+  type?: 'files' | 'directories' | 'files_directories' | 'all';
+  lstat?: boolean;
+  alwaysStat?: boolean;
+}
+
+export interface EntryInfo {
+  path: string;
+  fullPath: string;
+  basename: string;
+  stats?: Stats;
+  dirent?: { isFile(): boolean; isDirectory(): boolean; name: string };
+}
+
+class ReaddirpStream {
+  private options: ReaddirpOptions;
+  private root: string;
+  private entries: EntryInfo[] = [];
+  private index = 0;
+  private collected = false;
+
+  constructor(root: string, options: ReaddirpOptions = {}) {
+    this.root = root;
+    this.options = options;
+  }
+
+  private matchFilter(
+    entry: EntryInfo,
+    filter?: string | string[] | ((entry: EntryInfo) => boolean)
+  ): boolean {
+    if (!filter) return true;
+
+    if (typeof filter === 'function') {
+      return filter(entry);
+    }
+
+    const patterns = Array.isArray(filter) ? filter : [filter];
+    for (const pattern of patterns) {
+      if (pattern.startsWith('!')) {
+        // Negation pattern
+        const posPattern = pattern.slice(1);
+        if (this.matchGlob(entry.basename, posPattern)) {
+          return false;
+        }
+      } else if (this.matchGlob(entry.basename, pattern)) {
+        return true;
+      }
+    }
+
+    return patterns.length === 0 || patterns.every((p) => p.startsWith('!'));
+  }
+
+  private matchGlob(name: string, pattern: string): boolean {
+    // Simple glob matching
+    if (pattern === '*') return true;
+    if (pattern.startsWith('*.')) {
+      const ext = pattern.slice(1);
+      return name.endsWith(ext);
+    }
+    if (pattern.endsWith('*')) {
+      const prefix = pattern.slice(0, -1);
+      return name.startsWith(prefix);
+    }
+    return name === pattern;
+  }
+
+  private collect(dir: string, depth: number, relativePath: string = ''): void {
+    if (!globalVFS) return;
+    if (this.options.depth !== undefined && depth > this.options.depth) return;
+
+    try {
+      const entries = globalVFS.readdirSync(dir);
+
+      for (const name of entries) {
+        const fullPath = dir === '/' ? '/' + name : dir + '/' + name;
+        const relPath = relativePath ? relativePath + '/' + name : name;
+
+        try {
+          const stats = globalVFS.statSync(fullPath);
+          const isDir = stats.isDirectory();
+
+          const entry: EntryInfo = {
+            path: relPath,
+            fullPath,
+            basename: name,
+            stats: this.options.alwaysStat ? stats : undefined,
+            dirent: {
+              isFile: () => !isDir,
+              isDirectory: () => isDir,
+              name,
+            },
+          };
+
+          const type = this.options.type || 'files';
+
+          if (isDir) {
+            // Check directory filter
+            if (!this.matchFilter(entry, this.options.directoryFilter)) {
+              continue; // Skip this directory entirely
+            }
+
+            if (type === 'directories' || type === 'files_directories' || type === 'all') {
+              this.entries.push(entry);
+            }
+
+            // Recurse into directory
+            this.collect(fullPath, depth + 1, relPath);
+          } else {
+            if (type === 'files' || type === 'files_directories' || type === 'all') {
+              // Check file filter
+              if (this.matchFilter(entry, this.options.fileFilter)) {
+                this.entries.push(entry);
+              }
+            }
+          }
+        } catch {
+          // Skip entries that can't be stat'd
+        }
+      }
+    } catch {
+      // Skip directories that can't be read
+    }
+  }
+
+  // Async iterator
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<EntryInfo> {
+    if (!this.collected) {
+      this.collect(this.root, 0);
+      this.collected = true;
+    }
+
+    for (const entry of this.entries) {
+      yield entry;
+    }
+  }
+
+  // Promise-based API
+  async toArray(): Promise<EntryInfo[]> {
+    if (!this.collected) {
+      this.collect(this.root, 0);
+      this.collected = true;
+    }
+    return [...this.entries];
+  }
+
+  // Stream-like API for compatibility
+  on(event: string, callback: (...args: unknown[]) => void): this {
+    if (event === 'data') {
+      // Emit entries asynchronously
+      setTimeout(async () => {
+        if (!this.collected) {
+          this.collect(this.root, 0);
+          this.collected = true;
+        }
+        for (const entry of this.entries) {
+          callback(entry);
+        }
+        // Emit 'end' after all data
+        this.emit('end');
+      }, 0);
+    }
+    return this;
+  }
+
+  private listeners: Map<string, ((...args: unknown[]) => void)[]> = new Map();
+
+  private emit(event: string, ...args: unknown[]): void {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+
+  once(event: string, callback: (...args: unknown[]) => void): this {
+    const wrapper = (...args: unknown[]) => {
+      callback(...args);
+      this.off(event, wrapper);
+    };
+    return this.on(event, wrapper);
+  }
+
+  off(event: string, callback: (...args: unknown[]) => void): this {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(callback);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+    }
+    return this;
+  }
+}
+
+/**
+ * Read directory recursively
+ */
+export function readdirp(root: string, options?: ReaddirpOptions): ReaddirpStream {
+  return new ReaddirpStream(root, options);
+}
+
+// Promise-based helper
+export async function readdirpPromise(root: string, options?: ReaddirpOptions): Promise<EntryInfo[]> {
+  const stream = new ReaddirpStream(root, options);
+  return stream.toArray();
+}
+
+export default readdirp;
+export { ReaddirpStream };