almostnode 0.1.0

package/src/shims/dgram.ts

@@ -0,0 +1,47 @@
+/**
+ * dgram shim - UDP sockets are not available in browser
+ */
+
+import { EventEmitter } from './events';
+
+export class Socket extends EventEmitter {
+  bind(_port?: number, _address?: string, _callback?: () => void): this {
+    if (_callback) setTimeout(_callback, 0);
+    return this;
+  }
+
+  close(_callback?: () => void): void {
+    if (_callback) setTimeout(_callback, 0);
+  }
+
+  send(_msg: Buffer | string, _offset?: number, _length?: number, _port?: number, _address?: string, _callback?: (error: Error | null, bytes: number) => void): void {
+    if (_callback) setTimeout(() => _callback(null, 0), 0);
+  }
+
+  address(): { address: string; family: string; port: number } {
+    return { address: '0.0.0.0', family: 'IPv4', port: 0 };
+  }
+
+  setBroadcast(_flag: boolean): void {}
+  setTTL(_ttl: number): number { return _ttl; }
+  setMulticastTTL(_ttl: number): number { return _ttl; }
+  setMulticastLoopback(_flag: boolean): boolean { return _flag; }
+  setMulticastInterface(_multicastInterface: string): void {}
+  addMembership(_multicastAddress: string, _multicastInterface?: string): void {}
+  dropMembership(_multicastAddress: string, _multicastInterface?: string): void {}
+  ref(): this { return this; }
+  unref(): this { return this; }
+  setRecvBufferSize(_size: number): void {}
+  setSendBufferSize(_size: number): void {}
+  getRecvBufferSize(): number { return 0; }
+  getSendBufferSize(): number { return 0; }
+}
+
+export function createSocket(_type: string | object, _callback?: (msg: Buffer, rinfo: object) => void): Socket {
+  return new Socket();
+}
+
+export default {
+  Socket,
+  createSocket,
+};

package/src/shims/diagnostics_channel.ts

@@ -0,0 +1,196 @@
+/**
+ * Node.js diagnostics_channel module shim
+ * Provides basic diagnostics channel functionality for packages like undici
+ */
+
+import { EventEmitter } from './events';
+
+/**
+ * A Channel is used to publish messages to subscribers
+ */
+export class Channel {
+  private name: string;
+  private _subscribers: Set<(message: unknown, name: string) => void> = new Set();
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  get hasSubscribers(): boolean {
+    return this._subscribers.size > 0;
+  }
+
+  publish(message: unknown): void {
+    for (const subscriber of this._subscribers) {
+      try {
+        subscriber(message, this.name);
+      } catch (err) {
+        console.error('Error in diagnostics channel subscriber:', err);
+      }
+    }
+  }
+
+  subscribe(onMessage: (message: unknown, name: string) => void): void {
+    this._subscribers.add(onMessage);
+  }
+
+  unsubscribe(onMessage: (message: unknown, name: string) => void): boolean {
+    return this._subscribers.delete(onMessage);
+  }
+
+  bindStore(store: unknown, transform?: (message: unknown) => unknown): void {
+    // Stub - AsyncLocalStorage integration not implemented
+  }
+
+  unbindStore(store: unknown): boolean {
+    return false;
+  }
+}
+
+// Channel registry
+const channels = new Map<string, Channel>();
+
+/**
+ * Get or create a channel by name
+ */
+export function channel(name: string): Channel {
+  let ch = channels.get(name);
+  if (!ch) {
+    ch = new Channel(name);
+    channels.set(name, ch);
+  }
+  return ch;
+}
+
+/**
+ * Check if a channel has subscribers
+ */
+export function hasSubscribers(name: string): boolean {
+  const ch = channels.get(name);
+  return ch ? ch.hasSubscribers : false;
+}
+
+/**
+ * Subscribe to a channel
+ */
+export function subscribe(name: string, onMessage: (message: unknown, name: string) => void): void {
+  channel(name).subscribe(onMessage);
+}
+
+/**
+ * Unsubscribe from a channel
+ */
+export function unsubscribe(name: string, onMessage: (message: unknown, name: string) => void): boolean {
+  const ch = channels.get(name);
+  return ch ? ch.unsubscribe(onMessage) : false;
+}
+
+/**
+ * TracingChannel for distributed tracing
+ */
+export class TracingChannel {
+  private channels: {
+    start: Channel;
+    end: Channel;
+    asyncStart: Channel;
+    asyncEnd: Channel;
+    error: Channel;
+  };
+
+  constructor(nameOrChannels: string | { start: Channel; end: Channel; asyncStart: Channel; asyncEnd: Channel; error: Channel }) {
+    if (typeof nameOrChannels === 'string') {
+      this.channels = {
+        start: channel(`tracing:${nameOrChannels}:start`),
+        end: channel(`tracing:${nameOrChannels}:end`),
+        asyncStart: channel(`tracing:${nameOrChannels}:asyncStart`),
+        asyncEnd: channel(`tracing:${nameOrChannels}:asyncEnd`),
+        error: channel(`tracing:${nameOrChannels}:error`),
+      };
+    } else {
+      this.channels = nameOrChannels;
+    }
+  }
+
+  get hasSubscribers(): boolean {
+    return Object.values(this.channels).some(ch => ch.hasSubscribers);
+  }
+
+  subscribe(handlers: {
+    start?: (message: unknown) => void;
+    end?: (message: unknown) => void;
+    asyncStart?: (message: unknown) => void;
+    asyncEnd?: (message: unknown) => void;
+    error?: (message: unknown) => void;
+  }): void {
+    if (handlers.start) this.channels.start.subscribe(handlers.start);
+    if (handlers.end) this.channels.end.subscribe(handlers.end);
+    if (handlers.asyncStart) this.channels.asyncStart.subscribe(handlers.asyncStart);
+    if (handlers.asyncEnd) this.channels.asyncEnd.subscribe(handlers.asyncEnd);
+    if (handlers.error) this.channels.error.subscribe(handlers.error);
+  }
+
+  unsubscribe(handlers: {
+    start?: (message: unknown) => void;
+    end?: (message: unknown) => void;
+    asyncStart?: (message: unknown) => void;
+    asyncEnd?: (message: unknown) => void;
+    error?: (message: unknown) => void;
+  }): void {
+    if (handlers.start) this.channels.start.unsubscribe(handlers.start);
+    if (handlers.end) this.channels.end.unsubscribe(handlers.end);
+    if (handlers.asyncStart) this.channels.asyncStart.unsubscribe(handlers.asyncStart);
+    if (handlers.asyncEnd) this.channels.asyncEnd.unsubscribe(handlers.asyncEnd);
+    if (handlers.error) this.channels.error.unsubscribe(handlers.error);
+  }
+
+  traceSync<T>(fn: () => T, context?: unknown, thisArg?: unknown): T {
+    this.channels.start.publish(context);
+    try {
+      const result = fn.call(thisArg);
+      this.channels.end.publish(context);
+      return result;
+    } catch (error) {
+      this.channels.error.publish({ error, ...context as object });
+      throw error;
+    }
+  }
+
+  async tracePromise<T>(fn: () => Promise<T>, context?: unknown, thisArg?: unknown): Promise<T> {
+    this.channels.start.publish(context);
+    try {
+      const result = await fn.call(thisArg);
+      this.channels.asyncEnd.publish(context);
+      return result;
+    } catch (error) {
+      this.channels.error.publish({ error, ...context as object });
+      throw error;
+    }
+  }
+
+  traceCallback<T extends (...args: unknown[]) => unknown>(
+    fn: T,
+    position?: number,
+    context?: unknown,
+    thisArg?: unknown
+  ): T {
+    // Simplified callback tracing
+    return fn;
+  }
+}
+
+/**
+ * Create a TracingChannel
+ */
+export function tracingChannel(name: string): TracingChannel {
+  return new TracingChannel(name);
+}
+
+export default {
+  channel,
+  hasSubscribers,
+  subscribe,
+  unsubscribe,
+  tracingChannel,
+  Channel,
+  TracingChannel,
+};

package/src/shims/dns.ts

@@ -0,0 +1,172 @@
+/**
+ * dns shim - DNS operations are not available in browser
+ * Provides stubs that work for basic use cases
+ */
+
+// DNS lookup callback type
+type LookupCallback = (err: Error | null, address?: string, family?: number) => void;
+type LookupAllCallback = (err: Error | null, addresses?: Array<{ address: string; family: number }>) => void;
+
+/**
+ * Lookup a hostname - returns localhost in browser
+ */
+export function lookup(
+  hostname: string,
+  callback: LookupCallback
+): void;
+export function lookup(
+  hostname: string,
+  options: { family?: number; all?: boolean },
+  callback: LookupCallback | LookupAllCallback
+): void;
+export function lookup(
+  hostname: string,
+  optionsOrCallback: { family?: number; all?: boolean } | LookupCallback,
+  callback?: LookupCallback | LookupAllCallback
+): void {
+  const cb = typeof optionsOrCallback === 'function' ? optionsOrCallback : callback;
+  const options = typeof optionsOrCallback === 'object' ? optionsOrCallback : {};
+
+  // In browser, we can't do real DNS lookups
+  // Return localhost for localhost, or a fake IP for other hostnames
+  setImmediate(() => {
+    if (hostname === 'localhost' || hostname === '127.0.0.1') {
+      if (options.all) {
+        (cb as LookupAllCallback)(null, [{ address: '127.0.0.1', family: 4 }]);
+      } else {
+        (cb as LookupCallback)(null, '127.0.0.1', 4);
+      }
+    } else {
+      // For other hostnames, we can't resolve them in browser
+      // Return an error or a placeholder
+      if (options.all) {
+        (cb as LookupAllCallback)(null, [{ address: '0.0.0.0', family: 4 }]);
+      } else {
+        (cb as LookupCallback)(null, '0.0.0.0', 4);
+      }
+    }
+  });
+}
+
+/**
+ * Resolve hostname - stub
+ */
+export function resolve(
+  hostname: string,
+  callback: (err: Error | null, addresses?: string[]) => void
+): void {
+  setImmediate(() => {
+    callback(null, ['0.0.0.0']);
+  });
+}
+
+export function resolve4(
+  hostname: string,
+  callback: (err: Error | null, addresses?: string[]) => void
+): void {
+  resolve(hostname, callback);
+}
+
+export function resolve6(
+  hostname: string,
+  callback: (err: Error | null, addresses?: string[]) => void
+): void {
+  setImmediate(() => {
+    callback(null, ['::1']);
+  });
+}
+
+/**
+ * Reverse lookup - stub
+ */
+export function reverse(
+  ip: string,
+  callback: (err: Error | null, hostnames?: string[]) => void
+): void {
+  setImmediate(() => {
+    callback(null, ['localhost']);
+  });
+}
+
+/**
+ * Set servers - no-op in browser
+ */
+export function setServers(_servers: string[]): void {
+  // No-op
+}
+
+/**
+ * Get servers - return empty in browser
+ */
+export function getServers(): string[] {
+  return [];
+}
+
+/**
+ * Set default result order - no-op in browser
+ * Order can be 'ipv4first', 'ipv6first', or 'verbatim'
+ */
+export function setDefaultResultOrder(_order: string): void {
+  // No-op in browser
+}
+
+/**
+ * Get default result order
+ */
+export function getDefaultResultOrder(): string {
+  return 'verbatim';
+}
+
+// Promises API
+export const promises = {
+  lookup: (hostname: string, options?: { family?: number; all?: boolean }) => {
+    return new Promise((resolve, reject) => {
+      lookup(hostname, options || {}, (err, address, family) => {
+        if (err) reject(err);
+        else resolve({ address, family });
+      });
+    });
+  },
+  resolve: (hostname: string) => {
+    return new Promise<string[]>((promiseResolve, promiseReject) => {
+      resolve(hostname, (err, addresses) => {
+        if (err) promiseReject(err);
+        else promiseResolve(addresses || []);
+      });
+    });
+  },
+  resolve4: (hostname: string) => promises.resolve(hostname),
+  resolve6: (hostname: string) => {
+    return new Promise<string[]>((resolve) => {
+      resolve(['::1']);
+    });
+  },
+  reverse: (ip: string) => {
+    return new Promise<string[]>((resolve) => {
+      resolve(['localhost']);
+    });
+  },
+  setServers: (_servers: string[]) => {},
+  getServers: () => [] as string[],
+};
+
+// Constants
+export const ADDRCONFIG = 0;
+export const V4MAPPED = 0;
+export const ALL = 0;
+
+export default {
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  reverse,
+  setServers,
+  getServers,
+  setDefaultResultOrder,
+  getDefaultResultOrder,
+  promises,
+  ADDRCONFIG,
+  V4MAPPED,
+  ALL,
+};

package/src/shims/domain.ts

@@ -0,0 +1,58 @@
+/**
+ * Node.js domain module shim
+ * The domain module is deprecated but some packages still use it
+ */
+
+import { EventEmitter } from './events';
+
+export class Domain extends EventEmitter {
+  members: unknown[] = [];
+
+  add(emitter: EventEmitter): void {
+    this.members.push(emitter);
+  }
+
+  remove(emitter: EventEmitter): void {
+    const index = this.members.indexOf(emitter);
+    if (index !== -1) {
+      this.members.splice(index, 1);
+    }
+  }
+
+  bind<T extends (...args: unknown[]) => unknown>(callback: T): T {
+    return callback;
+  }
+
+  intercept<T extends (...args: unknown[]) => unknown>(callback: T): T {
+    return callback;
+  }
+
+  run<T>(fn: () => T): T {
+    return fn();
+  }
+
+  dispose(): void {
+    this.members = [];
+  }
+
+  enter(): void {
+    // Stub
+  }
+
+  exit(): void {
+    // Stub
+  }
+}
+
+export function create(): Domain {
+  return new Domain();
+}
+
+// Active domain (deprecated but some packages check for it)
+export let active: Domain | null = null;
+
+export default {
+  Domain,
+  create,
+  active,
+};