almostnode 0.1.0

package/src/shims/tls.ts

@@ -0,0 +1,95 @@
+/**
+ * tls shim - TLS/SSL is not available in browser
+ * Provides stubs that allow code to load without crashing
+ */
+
+import { EventEmitter } from './events';
+import * as net from './net';
+
+export class TLSSocket extends EventEmitter {
+  authorized = false;
+  encrypted = true;
+
+  constructor(_socket?: unknown, _options?: unknown) {
+    super();
+  }
+
+  getPeerCertificate(_detailed?: boolean): object {
+    return {};
+  }
+
+  getCipher(): { name: string; version: string } | null {
+    return null;
+  }
+
+  getProtocol(): string | null {
+    return null;
+  }
+
+  setServername(_name: string): void {}
+
+  renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean {
+    return false;
+  }
+}
+
+export class Server extends EventEmitter {
+  constructor(_options?: unknown, _connectionListener?: (socket: TLSSocket) => void) {
+    super();
+  }
+
+  listen(..._args: unknown[]): this {
+    return this;
+  }
+
+  close(_callback?: (err?: Error) => void): this {
+    return this;
+  }
+
+  address(): { port: number; family: string; address: string } | string | null {
+    return null;
+  }
+
+  getTicketKeys(): Buffer {
+    return Buffer.from('');
+  }
+
+  setTicketKeys(_keys: Buffer): void {}
+
+  setSecureContext(_options: unknown): void {}
+}
+
+export function createServer(_options?: unknown, _connectionListener?: (socket: TLSSocket) => void): Server {
+  return new Server(_options, _connectionListener);
+}
+
+export function connect(_options: unknown, _callback?: () => void): TLSSocket {
+  const socket = new TLSSocket();
+  if (_callback) {
+    setTimeout(_callback, 0);
+  }
+  return socket;
+}
+
+export const createSecureContext = (_options?: unknown) => ({});
+
+export const getCiphers = () => ['TLS_AES_256_GCM_SHA384', 'TLS_AES_128_GCM_SHA256'];
+
+export const DEFAULT_ECDH_CURVE = 'auto';
+export const DEFAULT_MAX_VERSION = 'TLSv1.3';
+export const DEFAULT_MIN_VERSION = 'TLSv1.2';
+
+export const rootCertificates: string[] = [];
+
+export default {
+  TLSSocket,
+  Server,
+  createServer,
+  connect,
+  createSecureContext,
+  getCiphers,
+  DEFAULT_ECDH_CURVE,
+  DEFAULT_MAX_VERSION,
+  DEFAULT_MIN_VERSION,
+  rootCertificates,
+};

package/src/shims/tty.ts

@@ -0,0 +1,64 @@
+/**
+ * Node.js tty module shim
+ * Provides terminal detection utilities
+ */
+
+import { Readable, Writable } from './stream';
+
+export class ReadStream extends Readable {
+  isTTY: boolean = false;
+  isRaw: boolean = false;
+
+  setRawMode(mode: boolean): this {
+    this.isRaw = mode;
+    return this;
+  }
+}
+
+export class WriteStream extends Writable {
+  isTTY: boolean = false;
+  columns: number = 80;
+  rows: number = 24;
+
+  clearLine(dir: number, callback?: () => void): boolean {
+    if (callback) callback();
+    return true;
+  }
+
+  clearScreenDown(callback?: () => void): boolean {
+    if (callback) callback();
+    return true;
+  }
+
+  cursorTo(x: number, y?: number, callback?: () => void): boolean {
+    if (callback) callback();
+    return true;
+  }
+
+  moveCursor(dx: number, dy: number, callback?: () => void): boolean {
+    if (callback) callback();
+    return true;
+  }
+
+  getColorDepth(env?: object): number {
+    return 1; // No color support in browser
+  }
+
+  hasColors(count?: number | object, env?: object): boolean {
+    return false;
+  }
+
+  getWindowSize(): [number, number] {
+    return [this.columns, this.rows];
+  }
+}
+
+export function isatty(fd: number): boolean {
+  return false; // Browser is never a TTY
+}
+
+export default {
+  ReadStream,
+  WriteStream,
+  isatty,
+};

package/src/shims/url.ts

@@ -0,0 +1,171 @@
+/**
+ * Node.js url module shim
+ * Uses browser's built-in URL API
+ */
+
+export interface UrlObject {
+  protocol?: string | null;
+  slashes?: boolean | null;
+  auth?: string | null;
+  host?: string | null;
+  port?: string | null;
+  hostname?: string | null;
+  hash?: string | null;
+  search?: string | null;
+  query?: string | Record<string, string | string[]> | null;
+  pathname?: string | null;
+  path?: string | null;
+  href?: string;
+}
+
+export function parse(
+  urlString: string,
+  parseQueryString: boolean = false,
+  slashesDenoteHost: boolean = false
+): UrlObject {
+  try {
+    const url = new URL(urlString, 'http://localhost');
+    const result: UrlObject = {
+      protocol: url.protocol,
+      slashes: url.protocol.endsWith(':'),
+      auth: url.username ? `${url.username}:${url.password}` : null,
+      host: url.host,
+      port: url.port || null,
+      hostname: url.hostname,
+      hash: url.hash || null,
+      search: url.search || null,
+      query: parseQueryString ? Object.fromEntries(url.searchParams) : url.search?.slice(1) || null,
+      pathname: url.pathname,
+      path: url.pathname + url.search,
+      href: url.href,
+    };
+    return result;
+  } catch {
+    // Handle relative URLs
+    return {
+      protocol: null,
+      slashes: null,
+      auth: null,
+      host: null,
+      port: null,
+      hostname: null,
+      hash: null,
+      search: null,
+      query: null,
+      pathname: urlString,
+      path: urlString,
+      href: urlString,
+    };
+  }
+}
+
+export function format(urlObject: UrlObject): string {
+  if (urlObject.href) {
+    return urlObject.href;
+  }
+
+  let result = '';
+
+  if (urlObject.protocol) {
+    result += urlObject.protocol;
+    if (!urlObject.protocol.endsWith(':')) {
+      result += ':';
+    }
+  }
+
+  if (urlObject.slashes || urlObject.protocol === 'http:' || urlObject.protocol === 'https:') {
+    result += '//';
+  }
+
+  if (urlObject.auth) {
+    result += urlObject.auth + '@';
+  }
+
+  if (urlObject.hostname) {
+    result += urlObject.hostname;
+  } else if (urlObject.host) {
+    result += urlObject.host;
+  }
+
+  if (urlObject.port) {
+    result += ':' + urlObject.port;
+  }
+
+  if (urlObject.pathname) {
+    result += urlObject.pathname;
+  }
+
+  if (urlObject.search) {
+    result += urlObject.search;
+  } else if (urlObject.query) {
+    if (typeof urlObject.query === 'string') {
+      result += '?' + urlObject.query;
+    } else {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(urlObject.query)) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            params.append(key, v);
+          }
+        } else {
+          params.set(key, value);
+        }
+      }
+      const search = params.toString();
+      if (search) {
+        result += '?' + search;
+      }
+    }
+  }
+
+  if (urlObject.hash) {
+    result += urlObject.hash;
+  }
+
+  return result;
+}
+
+export function resolve(from: string, to: string): string {
+  try {
+    return new URL(to, from).href;
+  } catch {
+    return to;
+  }
+}
+
+// Re-export URL and URLSearchParams from globals
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;
+
+/**
+ * Convert a file:// URL to a file path
+ * Node.js: url.fileURLToPath('file:///home/user/file.txt') -> '/home/user/file.txt'
+ */
+export function fileURLToPath(url: string | URL): string {
+  const urlObj = typeof url === 'string' ? new globalThis.URL(url) : url;
+  if (urlObj.protocol !== 'file:') {
+    throw new TypeError('The URL must be of scheme file');
+  }
+  // Decode percent-encoded characters and return pathname
+  return decodeURIComponent(urlObj.pathname);
+}
+
+/**
+ * Convert a file path to a file:// URL
+ * Node.js: url.pathToFileURL('/home/user/file.txt') -> URL { href: 'file:///home/user/file.txt' }
+ */
+export function pathToFileURL(path: string): URL {
+  // Encode special characters in path
+  const encoded = encodeURIComponent(path).replace(/%2F/g, '/');
+  return new globalThis.URL('file://' + encoded);
+}
+
+export default {
+  parse,
+  format,
+  resolve,
+  URL,
+  URLSearchParams,
+  fileURLToPath,
+  pathToFileURL,
+};

package/src/shims/util.ts

@@ -0,0 +1,312 @@
+/**
+ * Node.js util module shim
+ * Basic utility functions
+ */
+
+export function format(fmt: string, ...args: unknown[]): string {
+  if (typeof fmt !== 'string') {
+    return args.map((arg) => inspect(arg)).join(' ');
+  }
+
+  let i = 0;
+  return fmt.replace(/%[sdjifoO%]/g, (match) => {
+    if (match === '%%') return '%';
+    if (i >= args.length) return match;
+
+    const arg = args[i++];
+
+    switch (match) {
+      case '%s':
+        return String(arg);
+      case '%d':
+      case '%i':
+        return String(parseInt(String(arg), 10));
+      case '%f':
+        return String(parseFloat(String(arg)));
+      case '%j':
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return '[Circular]';
+        }
+      case '%o':
+      case '%O':
+        return inspect(arg);
+      default:
+        return match;
+    }
+  });
+}
+
+export function inspect(obj: unknown, options?: { depth?: number; colors?: boolean }): string {
+  const seen = new WeakSet();
+  const depth = options?.depth ?? 2;
+
+  function inspectValue(value: unknown, currentDepth: number): string {
+    if (value === null) return 'null';
+    if (value === undefined) return 'undefined';
+
+    const type = typeof value;
+
+    if (type === 'string') {
+      return `'${value}'`;
+    }
+
+    if (type === 'number' || type === 'boolean' || type === 'bigint') {
+      return String(value);
+    }
+
+    if (type === 'symbol') {
+      return value.toString();
+    }
+
+    if (type === 'function') {
+      const name = (value as Function).name || 'anonymous';
+      return `[Function: ${name}]`;
+    }
+
+    if (type !== 'object') {
+      return String(value);
+    }
+
+    // Handle circular references
+    if (seen.has(value as object)) {
+      return '[Circular]';
+    }
+    seen.add(value as object);
+
+    if (currentDepth > depth) {
+      return Array.isArray(value) ? '[Array]' : '[Object]';
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) return '[]';
+      const items = value.map((v) => inspectValue(v, currentDepth + 1));
+      return `[ ${items.join(', ')} ]`;
+    }
+
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+
+    if (value instanceof Error) {
+      return `${value.name}: ${value.message}`;
+    }
+
+    if (value instanceof Map) {
+      const entries = [...value.entries()].map(
+        ([k, v]) => `${inspectValue(k, currentDepth + 1)} => ${inspectValue(v, currentDepth + 1)}`
+      );
+      return `Map(${value.size}) { ${entries.join(', ')} }`;
+    }
+
+    if (value instanceof Set) {
+      const items = [...value].map((v) => inspectValue(v, currentDepth + 1));
+      return `Set(${value.size}) { ${items.join(', ')} }`;
+    }
+
+    // Plain object
+    const keys = Object.keys(value as object);
+    if (keys.length === 0) return '{}';
+
+    const entries = keys.map((key) => {
+      const val = (value as Record<string, unknown>)[key];
+      return `${key}: ${inspectValue(val, currentDepth + 1)}`;
+    });
+
+    return `{ ${entries.join(', ')} }`;
+  }
+
+  return inspectValue(obj, 0);
+}
+
+export function inherits(
+  ctor: Function,
+  superCtor: Function
+): void {
+  if (ctor === undefined || ctor === null) {
+    throw new TypeError('inherits: ctor must be a function');
+  }
+  if (superCtor === undefined || superCtor === null) {
+    // Some packages call inherits with undefined as a no-op, just return
+    return;
+  }
+  if (superCtor.prototype === undefined) {
+    // Skip if superCtor doesn't have a prototype
+    return;
+  }
+  (ctor as any).super_ = superCtor;
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+
+export function deprecate<T extends Function>(
+  fn: T,
+  msg: string,
+  code?: string
+): T {
+  let warned = false;
+  const deprecated = function (this: unknown, ...args: unknown[]) {
+    if (!warned) {
+      console.warn(`DeprecationWarning: ${msg}${code ? ` (${code})` : ''}`);
+      warned = true;
+    }
+    return fn.apply(this, args);
+  };
+  return deprecated as unknown as T;
+}
+
+export function promisify<T>(
+  fn: (...args: [...unknown[], (err: Error | null, result: T) => void]) => void
+): (...args: unknown[]) => Promise<T> {
+  return (...args: unknown[]) => {
+    return new Promise((resolve, reject) => {
+      fn(...args, (err: Error | null, result: T) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  };
+}
+
+export function callbackify<T>(
+  fn: (...args: unknown[]) => Promise<T>
+): (...args: [...unknown[], (err: Error | null, result: T) => void]) => void {
+  return (...args: unknown[]) => {
+    const callback = args.pop() as (err: Error | null, result: T) => void;
+    fn(...args)
+      .then((result) => callback(null, result))
+      .catch((err) => callback(err, undefined as unknown as T));
+  };
+}
+
+export function isArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+export function isNull(value: unknown): value is null {
+  return value === null;
+}
+
+export function isNullOrUndefined(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number';
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+export function isUndefined(value: unknown): value is undefined {
+  return value === undefined;
+}
+
+export function isRegExp(value: unknown): value is RegExp {
+  return value instanceof RegExp;
+}
+
+export function isObject(value: unknown): value is object {
+  return typeof value === 'object' && value !== null;
+}
+
+export function isDate(value: unknown): value is Date {
+  return value instanceof Date;
+}
+
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+export function isFunction(value: unknown): value is Function {
+  return typeof value === 'function';
+}
+
+export function isPrimitive(value: unknown): boolean {
+  return value === null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+export function isBuffer(value: unknown): boolean {
+  return value instanceof Uint8Array;
+}
+
+/**
+ * Returns a function that logs debug messages when NODE_DEBUG includes the section
+ */
+export function debuglog(section: string): (...args: unknown[]) => void {
+  const nodeDebug = (typeof process !== 'undefined' && process.env?.NODE_DEBUG) || '';
+  const enabled = nodeDebug.toLowerCase().includes(section.toLowerCase());
+
+  if (enabled) {
+    return (...args: unknown[]) => {
+      console.error(`${section.toUpperCase()} ${process?.pid || 0}:`, ...args);
+    };
+  }
+
+  // Return a no-op function
+  return () => {};
+}
+
+// Alias for debuglog
+export const debug = debuglog;
+
+export const types = {
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isUndefined,
+  isRegExp,
+  isObject,
+  isDate,
+  isError,
+  isFunction,
+  isPrimitive,
+  isBuffer,
+};
+
+// Re-export TextEncoder and TextDecoder from global
+export const TextEncoder = globalThis.TextEncoder;
+export const TextDecoder = globalThis.TextDecoder;
+
+export default {
+  format,
+  inspect,
+  inherits,
+  deprecate,
+  promisify,
+  callbackify,
+  debuglog,
+  debug,
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isUndefined,
+  isRegExp,
+  isObject,
+  isDate,
+  isError,
+  isFunction,
+  isPrimitive,
+  isBuffer,
+  types,
+  TextEncoder,
+  TextDecoder,
+};