almostnode 0.1.0

package/src/shims/ws.ts

@@ -0,0 +1,382 @@
+/**
+ * ws (WebSocket) shim for browser environment
+ * Used by Vite for HMR (Hot Module Replacement)
+ */
+
+import { EventEmitter } from './events';
+
+// Polyfill for CloseEvent (not available in Node.js)
+const CloseEventPolyfill = typeof CloseEvent !== 'undefined' ? CloseEvent : class CloseEvent extends Event {
+  code: number;
+  reason: string;
+  wasClean: boolean;
+  constructor(type: string, init?: { code?: number; reason?: string; wasClean?: boolean }) {
+    super(type);
+    this.code = init?.code ?? 1000;
+    this.reason = init?.reason ?? '';
+    this.wasClean = init?.wasClean ?? true;
+  }
+};
+
+// Polyfill for MessageEvent (not available in Node.js)
+const MessageEventPolyfill = typeof MessageEvent !== 'undefined' ? MessageEvent : class MessageEvent extends Event {
+  data: unknown;
+  constructor(type: string, init?: { data?: unknown }) {
+    super(type);
+    this.data = init?.data;
+  }
+};
+
+// Message channel for communication between WebSocket server and clients
+let messageChannel: BroadcastChannel | null = null;
+try {
+  messageChannel = new BroadcastChannel('vite-ws-channel');
+} catch {
+  // BroadcastChannel not available in some environments
+}
+
+// Track all server instances
+const servers = new Map<string, WebSocketServer>();
+let clientIdCounter = 0;
+
+export class WebSocket extends EventEmitter {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+
+  readonly CONNECTING = WebSocket.CONNECTING;
+  readonly OPEN = WebSocket.OPEN;
+  readonly CLOSING = WebSocket.CLOSING;
+  readonly CLOSED = WebSocket.CLOSED;
+
+  readyState: number = WebSocket.CONNECTING;
+  url: string;
+  protocol: string = '';
+  extensions: string = '';
+  bufferedAmount: number = 0;
+  binaryType: 'blob' | 'arraybuffer' = 'blob';
+
+  private _id: string;
+  private _server: WebSocketServer | null = null;
+
+  // Event handler properties
+  onopen: ((event: Event) => void) | null = null;
+  onclose: ((event: CloseEvent) => void) | null = null;
+  onerror: ((event: Event) => void) | null = null;
+  onmessage: ((event: MessageEvent) => void) | null = null;
+
+  constructor(url: string, protocols?: string | string[]) {
+    super();
+    this.url = url;
+    this._id = `client-${++clientIdCounter}`;
+
+    if (protocols) {
+      this.protocol = Array.isArray(protocols) ? protocols[0] : protocols;
+    }
+
+    // Connect asynchronously
+    setTimeout(() => this._connect(), 0);
+  }
+
+  private _connect(): void {
+    // For internal WebSocket connections (from server to client), connect immediately
+    if (this.url.startsWith('internal://')) {
+      this.readyState = WebSocket.OPEN;
+      this.emit('open');
+      if (this.onopen) this.onopen(new Event('open'));
+      return;
+    }
+
+    // If no BroadcastChannel, act as if connected
+    if (!messageChannel) {
+      setTimeout(() => {
+        this.readyState = WebSocket.OPEN;
+        this.emit('open');
+        if (this.onopen) this.onopen(new Event('open'));
+      }, 0);
+      return;
+    }
+
+    // Try to connect to a server via BroadcastChannel
+    messageChannel.postMessage({
+      type: 'connect',
+      clientId: this._id,
+      url: this.url,
+    });
+
+    // Listen for responses
+    const channel = messageChannel;
+    const handler = (event: MessageEvent) => {
+      const data = event.data;
+
+      if (data.targetClient !== this._id) return;
+
+      switch (data.type) {
+        case 'connected':
+          this.readyState = WebSocket.OPEN;
+          this.emit('open');
+          if (this.onopen) this.onopen(new Event('open'));
+          break;
+
+        case 'message':
+          const msgEvent = new MessageEventPolyfill('message', { data: data.payload });
+          this.emit('message', msgEvent);
+          if (this.onmessage) this.onmessage(msgEvent as unknown as MessageEvent);
+          break;
+
+        case 'close':
+          this.readyState = WebSocket.CLOSED;
+          const closeEvent = new CloseEventPolyfill('close', {
+            code: data.code || 1000,
+            reason: data.reason || '',
+            wasClean: true,
+          });
+          this.emit('close', closeEvent);
+          if (this.onclose) this.onclose(closeEvent as unknown as CloseEvent);
+          channel.removeEventListener('message', handler);
+          break;
+
+        case 'error':
+          const errorEvent = new Event('error');
+          this.emit('error', errorEvent);
+          if (this.onerror) this.onerror(errorEvent);
+          break;
+      }
+    };
+
+    channel.addEventListener('message', handler);
+
+    // Connection timeout
+    setTimeout(() => {
+      if (this.readyState === WebSocket.CONNECTING) {
+        // No server responded, act as if connected (for standalone client use)
+        this.readyState = WebSocket.OPEN;
+        this.emit('open');
+        if (this.onopen) this.onopen(new Event('open'));
+      }
+    }, 100);
+  }
+
+  send(data: string | ArrayBuffer | Uint8Array): void {
+    if (this.readyState !== WebSocket.OPEN) {
+      throw new Error('WebSocket is not open');
+    }
+
+    // If connected to internal server
+    if (this._server) {
+      this._server._handleClientMessage(this, data);
+      return;
+    }
+
+    // Send via BroadcastChannel
+    if (messageChannel) {
+      messageChannel.postMessage({
+        type: 'message',
+        clientId: this._id,
+        url: this.url,
+        payload: data,
+      });
+    }
+  }
+
+  close(code?: number, reason?: string): void {
+    if (this.readyState === WebSocket.CLOSED || this.readyState === WebSocket.CLOSING) {
+      return;
+    }
+
+    this.readyState = WebSocket.CLOSING;
+
+    if (messageChannel) {
+      messageChannel.postMessage({
+        type: 'disconnect',
+        clientId: this._id,
+        url: this.url,
+        code,
+        reason,
+      });
+    }
+
+    setTimeout(() => {
+      this.readyState = WebSocket.CLOSED;
+      const closeEvent = new CloseEventPolyfill('close', {
+        code: code || 1000,
+        reason: reason || '',
+        wasClean: true,
+      });
+      this.emit('close', closeEvent);
+      if (this.onclose) this.onclose(closeEvent as unknown as CloseEvent);
+    }, 0);
+  }
+
+  ping(): void {
+    // No-op in browser
+  }
+
+  pong(): void {
+    // No-op in browser
+  }
+
+  terminate(): void {
+    this.close(1006, 'Connection terminated');
+  }
+
+  // For internal server use
+  _setServer(server: WebSocketServer): void {
+    this._server = server;
+  }
+
+  _receiveMessage(data: unknown): void {
+    const msgEvent = new MessageEventPolyfill('message', { data });
+    this.emit('message', msgEvent);
+    if (this.onmessage) this.onmessage(msgEvent as unknown as MessageEvent);
+  }
+}
+
+export interface ServerOptions {
+  host?: string;
+  port?: number;
+  server?: unknown; // HTTP server
+  noServer?: boolean;
+  path?: string;
+  clientTracking?: boolean;
+  perMessageDeflate?: boolean | object;
+  maxPayload?: number;
+}
+
+export class WebSocketServer extends EventEmitter {
+  clients: Set<WebSocket> = new Set();
+  options: ServerOptions;
+  private _path: string;
+  private _channelHandler: ((event: MessageEvent) => void) | null = null;
+
+  constructor(options: ServerOptions = {}) {
+    super();
+    this.options = options;
+    this._path = options.path || '/';
+
+    // If not noServer, set up listening
+    if (!options.noServer) {
+      this._setupListener();
+    }
+
+    // Register server
+    servers.set(this._path, this);
+  }
+
+  private _setupListener(): void {
+    if (!messageChannel) return;
+
+    const channel = messageChannel;
+    this._channelHandler = (event: MessageEvent) => {
+      const data = event.data;
+
+      if (data.type === 'connect') {
+        // Create a new WebSocket for this client
+        const ws = new WebSocket('internal://' + this._path);
+        ws._setServer(this);
+        (ws as unknown as { _clientId: string })._clientId = data.clientId;
+        this.clients.add(ws);
+
+        // Notify client of connection
+        channel.postMessage({
+          type: 'connected',
+          targetClient: data.clientId,
+        });
+
+        // Emit connection event
+        this.emit('connection', ws, { url: data.url });
+      }
+
+      if (data.type === 'message') {
+        // Find the client and deliver the message
+        for (const client of this.clients) {
+          if ((client as unknown as { _clientId: string })._clientId === data.clientId) {
+            client._receiveMessage(data.payload);
+            break;
+          }
+        }
+      }
+
+      if (data.type === 'disconnect') {
+        for (const client of this.clients) {
+          if ((client as unknown as { _clientId: string })._clientId === data.clientId) {
+            client.close(data.code, data.reason);
+            this.clients.delete(client);
+            break;
+          }
+        }
+      }
+    };
+
+    channel.addEventListener('message', this._channelHandler);
+  }
+
+  _handleClientMessage(client: WebSocket, data: unknown): void {
+    // Broadcast to server-side handlers
+    const msgEvent = new MessageEventPolyfill('message', { data });
+    client.emit('message', msgEvent);
+  }
+
+  handleUpgrade(
+    request: unknown,
+    socket: unknown,
+    head: unknown,
+    callback: (ws: WebSocket, request: unknown) => void
+  ): void {
+    // Create WebSocket for this upgrade
+    const ws = new WebSocket('internal://' + this._path);
+    ws._setServer(this);
+
+    if (this.options.clientTracking !== false) {
+      this.clients.add(ws);
+    }
+
+    // Async callback
+    setTimeout(() => {
+      callback(ws, request);
+      this.emit('connection', ws, request);
+    }, 0);
+  }
+
+  close(callback?: () => void): void {
+    // Close all clients
+    for (const client of this.clients) {
+      client.close(1001, 'Server shutting down');
+    }
+    this.clients.clear();
+
+    // Remove from registry
+    servers.delete(this._path);
+
+    // Remove channel listener
+    if (this._channelHandler && messageChannel) {
+      messageChannel.removeEventListener('message', this._channelHandler);
+      this._channelHandler = null;
+    }
+
+    this.emit('close');
+
+    if (callback) {
+      setTimeout(callback, 0);
+    }
+  }
+
+  address(): { port: number; family: string; address: string } | null {
+    return {
+      port: this.options.port || 0,
+      family: 'IPv4',
+      address: this.options.host || '0.0.0.0',
+    };
+  }
+
+}
+
+// Export WebSocket and Server
+export default WebSocket;
+export const Server = WebSocketServer;
+
+// Additional exports for compatibility
+export const createWebSocketStream = () => {
+  throw new Error('createWebSocketStream is not supported in browser');
+};

package/src/shims/zlib.ts

@@ -0,0 +1,289 @@
+/**
+ * Node.js zlib module shim
+ * Provides basic compression utilities
+ */
+
+import { Buffer } from './stream';
+import pako from 'pako';
+
+// Brotli WASM instance - loaded lazily
+type BrotliModule = { compress: (data: Uint8Array) => Uint8Array; decompress: (data: Uint8Array) => Uint8Array };
+let brotliModule: BrotliModule | null = null;
+let brotliLoadPromise: Promise<BrotliModule | null> | null = null;
+
+async function loadBrotli(): Promise<BrotliModule | null> {
+  if (brotliModule) return brotliModule;
+  if (!brotliLoadPromise) {
+    brotliLoadPromise = (async () => {
+      try {
+        // Dynamic import - brotli-wasm handles environment detection automatically
+        // In Node.js: returns sync module
+        // In browser: returns promise that resolves after WASM init
+        const brotliWasmModule = await import('brotli-wasm');
+        // The default export is a promise that resolves to the module
+        brotliModule = await brotliWasmModule.default;
+        console.log('[zlib] brotli-wasm loaded successfully');
+        return brotliModule;
+      } catch (error) {
+        console.error('[zlib] Failed to load brotli-wasm:', error);
+        return null;
+      }
+    })();
+  }
+  return brotliLoadPromise;
+}
+
+export function gzip(
+  buffer: Buffer | string,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+    const result = pako.gzip(input);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+export function gunzip(
+  buffer: Buffer,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const result = pako.ungzip(buffer);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+export function deflate(
+  buffer: Buffer | string,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+    const result = pako.deflate(input);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+export function inflate(
+  buffer: Buffer,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const result = pako.inflate(buffer);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+export function deflateRaw(
+  buffer: Buffer | string,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+    const result = pako.deflateRaw(input);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+export function inflateRaw(
+  buffer: Buffer,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  try {
+    const result = pako.inflateRaw(buffer);
+    callback(null, Buffer.from(result));
+  } catch (error) {
+    callback(error as Error, Buffer.alloc(0));
+  }
+}
+
+// Brotli compression using brotli-wasm
+export function brotliCompress(
+  buffer: Buffer | string,
+  options: unknown,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  // Handle overload where options is the callback
+  if (typeof options === 'function') {
+    callback = options as (error: Error | null, result: Buffer) => void;
+  }
+
+  loadBrotli().then(brotli => {
+    if (!brotli) {
+      callback(new Error('Brotli WASM failed to load'), Buffer.alloc(0));
+      return;
+    }
+    try {
+      const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+      const result = brotli.compress(new Uint8Array(input));
+      callback(null, Buffer.from(result));
+    } catch (error) {
+      callback(error as Error, Buffer.alloc(0));
+    }
+  }).catch(error => {
+    callback(error as Error, Buffer.alloc(0));
+  });
+}
+
+export function brotliDecompress(
+  buffer: Buffer,
+  options: unknown,
+  callback: (error: Error | null, result: Buffer) => void
+): void {
+  // Handle overload where options is the callback
+  if (typeof options === 'function') {
+    callback = options as (error: Error | null, result: Buffer) => void;
+  }
+
+  loadBrotli().then(brotli => {
+    if (!brotli) {
+      callback(new Error('Brotli WASM failed to load'), Buffer.alloc(0));
+      return;
+    }
+    try {
+      const result = brotli.decompress(new Uint8Array(buffer));
+      callback(null, Buffer.from(result));
+    } catch (error) {
+      callback(error as Error, Buffer.alloc(0));
+    }
+  }).catch(error => {
+    callback(error as Error, Buffer.alloc(0));
+  });
+}
+
+export function brotliCompressSync(buffer: Buffer | string, _options?: unknown): Buffer {
+  if (!brotliModule) {
+    throw new Error('Brotli WASM not loaded. Call brotliCompress first to initialize.');
+  }
+  const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+  return Buffer.from(brotliModule.compress(new Uint8Array(input)));
+}
+
+export function brotliDecompressSync(buffer: Buffer, _options?: unknown): Buffer {
+  if (!brotliModule) {
+    throw new Error('Brotli WASM not loaded. Call brotliDecompress first to initialize.');
+  }
+  return Buffer.from(brotliModule.decompress(new Uint8Array(buffer)));
+}
+
+// Sync versions
+export function gzipSync(buffer: Buffer | string): Buffer {
+  const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+  return Buffer.from(pako.gzip(input));
+}
+
+export function gunzipSync(buffer: Buffer): Buffer {
+  return Buffer.from(pako.ungzip(buffer));
+}
+
+export function deflateSync(buffer: Buffer | string): Buffer {
+  const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+  return Buffer.from(pako.deflate(input));
+}
+
+export function inflateSync(buffer: Buffer): Buffer {
+  return Buffer.from(pako.inflate(buffer));
+}
+
+export function deflateRawSync(buffer: Buffer | string): Buffer {
+  const input = typeof buffer === 'string' ? Buffer.from(buffer) : buffer;
+  return Buffer.from(pako.deflateRaw(input));
+}
+
+export function inflateRawSync(buffer: Buffer): Buffer {
+  return Buffer.from(pako.inflateRaw(buffer));
+}
+
+// Constants
+export const constants = {
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  Z_VERSION_ERROR: -6,
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  ZLIB_VERNUM: 4784,
+  Z_MIN_WINDOWBITS: 8,
+  Z_MAX_WINDOWBITS: 15,
+  Z_DEFAULT_WINDOWBITS: 15,
+  Z_MIN_CHUNK: 64,
+  Z_MAX_CHUNK: Infinity,
+  Z_DEFAULT_CHUNK: 16384,
+  Z_MIN_MEMLEVEL: 1,
+  Z_MAX_MEMLEVEL: 9,
+  Z_DEFAULT_MEMLEVEL: 8,
+  Z_MIN_LEVEL: -1,
+  Z_MAX_LEVEL: 9,
+  Z_DEFAULT_LEVEL: -1,
+  // Brotli constants
+  BROTLI_DECODE: 0,
+  BROTLI_ENCODE: 1,
+  BROTLI_OPERATION_PROCESS: 0,
+  BROTLI_OPERATION_FLUSH: 1,
+  BROTLI_OPERATION_FINISH: 2,
+  BROTLI_OPERATION_EMIT_METADATA: 3,
+  BROTLI_PARAM_MODE: 0,
+  BROTLI_MODE_GENERIC: 0,
+  BROTLI_MODE_TEXT: 1,
+  BROTLI_MODE_FONT: 2,
+  BROTLI_PARAM_QUALITY: 1,
+  BROTLI_MIN_QUALITY: 0,
+  BROTLI_MAX_QUALITY: 11,
+  BROTLI_DEFAULT_QUALITY: 11,
+  BROTLI_PARAM_LGWIN: 2,
+  BROTLI_MIN_WINDOW_BITS: 10,
+  BROTLI_MAX_WINDOW_BITS: 24,
+  BROTLI_DEFAULT_WINDOW: 22,
+  BROTLI_PARAM_LGBLOCK: 3,
+  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+};
+
+export default {
+  gzip,
+  gunzip,
+  deflate,
+  inflate,
+  deflateRaw,
+  inflateRaw,
+  gzipSync,
+  gunzipSync,
+  deflateSync,
+  inflateSync,
+  deflateRawSync,
+  inflateRawSync,
+  brotliCompress,
+  brotliDecompress,
+  brotliCompressSync,
+  brotliDecompressSync,
+  constants,
+};