@scelar/nodepod 1.0.0

package/src/polyfills/dgram.ts

@@ -0,0 +1,87 @@
+// stub - not available in browser
+
+import { EventEmitter } from "./events";
+
+export interface Socket extends EventEmitter {
+  bind(_port?: number, _addr?: string, _cb?: () => void): this;
+  close(_cb?: () => void): void;
+  send(
+    _msg: Uint8Array | string,
+    _offset?: number,
+    _length?: number,
+    _port?: number,
+    _addr?: string,
+    _cb?: (err: Error | null, bytes: number) => void,
+  ): void;
+  address(): { address: string; family: string; port: number };
+  setBroadcast(_flag: boolean): void;
+  setTTL(_ttl: number): number;
+  setMulticastTTL(_ttl: number): number;
+  setMulticastLoopback(_flag: boolean): boolean;
+  setMulticastInterface(_iface: string): void;
+  addMembership(_group: string, _iface?: string): void;
+  dropMembership(_group: string, _iface?: string): void;
+  ref(): this;
+  unref(): this;
+  setRecvBufferSize(_sz: number): void;
+  setSendBufferSize(_sz: number): void;
+  getRecvBufferSize(): number;
+  getSendBufferSize(): number;
+}
+
+export const Socket = function Socket(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Socket; prototype: any };
+
+Object.setPrototypeOf(Socket.prototype, EventEmitter.prototype);
+
+Socket.prototype.bind = function bind(_port?: number, _addr?: string, _cb?: () => void) {
+  if (_cb) setTimeout(_cb, 0);
+  return this;
+};
+
+Socket.prototype.close = function close(_cb?: () => void): void {
+  if (_cb) setTimeout(_cb, 0);
+};
+
+Socket.prototype.send = function send(
+  _msg: Uint8Array | string,
+  _offset?: number,
+  _length?: number,
+  _port?: number,
+  _addr?: string,
+  _cb?: (err: Error | null, bytes: number) => void,
+): void {
+  if (_cb) setTimeout(() => _cb(null, 0), 0);
+};
+
+Socket.prototype.address = function address(): { address: string; family: string; port: number } {
+  return { address: "0.0.0.0", family: "IPv4", port: 0 };
+};
+
+Socket.prototype.setBroadcast = function setBroadcast(_flag: boolean): void {};
+Socket.prototype.setTTL = function setTTL(_ttl: number): number { return _ttl; };
+Socket.prototype.setMulticastTTL = function setMulticastTTL(_ttl: number): number { return _ttl; };
+Socket.prototype.setMulticastLoopback = function setMulticastLoopback(_flag: boolean): boolean { return _flag; };
+Socket.prototype.setMulticastInterface = function setMulticastInterface(_iface: string): void {};
+Socket.prototype.addMembership = function addMembership(_group: string, _iface?: string): void {};
+Socket.prototype.dropMembership = function dropMembership(_group: string, _iface?: string): void {};
+Socket.prototype.ref = function ref() { return this; };
+Socket.prototype.unref = function unref() { return this; };
+Socket.prototype.setRecvBufferSize = function setRecvBufferSize(_sz: number): void {};
+Socket.prototype.setSendBufferSize = function setSendBufferSize(_sz: number): void {};
+Socket.prototype.getRecvBufferSize = function getRecvBufferSize(): number { return 0; };
+Socket.prototype.getSendBufferSize = function getSendBufferSize(): number { return 0; };
+
+export function createSocket(
+  _type: string | object,
+  _cb?: (msg: Uint8Array, rinfo: object) => void,
+): Socket {
+  return new Socket();
+}
+
+export default {
+  Socket,
+  createSocket,
+};

package/src/polyfills/diagnostics_channel.ts

@@ -0,0 +1,76 @@
+// stub - minimal diagnostics_channel for compatibility
+
+
+export interface DiagChannel {
+  name: string;
+  readonly hasSubscribers: boolean;
+  subscribe(handler: (message: unknown, name: string) => void): void;
+  unsubscribe(handler: (message: unknown, name: string) => void): boolean;
+  publish(message: unknown): void;
+}
+
+export const DiagChannel = function DiagChannel(this: any, name: string) {
+  if (!this) return;
+  this.name = name;
+  this._listeners = [];
+} as unknown as { new(name: string): DiagChannel; prototype: any };
+
+Object.defineProperty(DiagChannel.prototype, 'hasSubscribers', {
+  get(this: any) { return this._listeners.length > 0; },
+  configurable: true,
+});
+
+DiagChannel.prototype.subscribe = function subscribe(handler: (message: unknown, name: string) => void): void {
+  this._listeners.push(handler);
+};
+
+DiagChannel.prototype.unsubscribe = function unsubscribe(handler: (message: unknown, name: string) => void): boolean {
+  const idx = this._listeners.indexOf(handler);
+  if (idx === -1) return false;
+  this._listeners.splice(idx, 1);
+  return true;
+};
+
+DiagChannel.prototype.publish = function publish(this: any, message: unknown): void {
+  for (const handler of this._listeners) {
+    try {
+      handler(message, this.name);
+    } catch {
+      /* swallow */
+    }
+  }
+};
+
+const channels = new Map<string, DiagChannel>();
+
+export function channel(name: string): DiagChannel {
+  if (!channels.has(name)) channels.set(name, new DiagChannel(name));
+  return channels.get(name)!;
+}
+
+export function hasSubscribers(name: string): boolean {
+  return channels.get(name)?.hasSubscribers ?? false;
+}
+
+export function subscribe(
+  name: string,
+  handler: (message: unknown, name: string) => void,
+): void {
+  channel(name).subscribe(handler);
+}
+
+export function unsubscribe(
+  name: string,
+  handler: (message: unknown, name: string) => void,
+): boolean {
+  return channels.get(name)?.unsubscribe(handler) ?? false;
+}
+
+export { DiagChannel as Channel };
+export default {
+  channel,
+  hasSubscribers,
+  subscribe,
+  unsubscribe,
+  Channel: DiagChannel,
+};

package/src/polyfills/dns.ts

@@ -0,0 +1,134 @@
+// stub - real DNS not available in browser, returns 127.0.0.1 for localhost, 0.0.0.0 otherwise
+
+type SingleResult = (err: Error | null, addr?: string, fam?: number) => void;
+type MultiResult = (
+  err: Error | null,
+  entries?: Array<{ address: string; family: number }>
+) => void;
+
+export function lookup(
+  host: string,
+  cb: SingleResult
+): void;
+export function lookup(
+  host: string,
+  opts: { family?: number; all?: true },
+  cb: MultiResult
+): void;
+export function lookup(
+  host: string,
+  opts: { family?: number; all?: boolean },
+  cb: SingleResult | MultiResult
+): void;
+export function lookup(
+  host: string,
+  optsOrCb: { family?: number; all?: boolean } | SingleResult,
+  cb?: SingleResult | MultiResult
+): void {
+  const handler = typeof optsOrCb === 'function' ? optsOrCb : cb;
+  const flags = typeof optsOrCb === 'object' ? optsOrCb : {};
+
+  const isLocal = host === 'localhost' || host === '127.0.0.1';
+  const ip = isLocal ? '127.0.0.1' : '0.0.0.0';
+
+  setTimeout(() => {
+    if (flags.all) {
+      (handler as MultiResult)(null, [{ address: ip, family: 4 }]);
+    } else {
+      (handler as SingleResult)(null, ip, 4);
+    }
+  }, 0);
+}
+
+export function resolve(
+  _host: string,
+  cb: (err: Error | null, addrs?: string[]) => void
+): void {
+  setTimeout(() => cb(null, ['0.0.0.0']), 0);
+}
+
+export function resolve4(
+  host: string,
+  cb: (err: Error | null, addrs?: string[]) => void
+): void {
+  resolve(host, cb);
+}
+
+export function resolve6(
+  _host: string,
+  cb: (err: Error | null, addrs?: string[]) => void
+): void {
+  setTimeout(() => cb(null, ['::1']), 0);
+}
+
+export function reverse(
+  _ip: string,
+  cb: (err: Error | null, names?: string[]) => void
+): void {
+  setTimeout(() => cb(null, ['localhost']), 0);
+}
+
+export function setServers(_list: string[]): void {}
+export function getServers(): string[] { return []; }
+export function setDefaultResultOrder(_order: string): void {}
+export function getDefaultResultOrder(): string { return 'verbatim'; }
+
+export const promises = {
+  lookup(
+    host: string,
+    opts?: { family?: number; all?: boolean }
+  ): Promise<{ address: string; family: number } | Array<{ address: string; family: number }>> {
+    return new Promise((ok, fail) => {
+      if (opts?.all) {
+        lookup(host, opts, ((e: Error | null, a?: Array<{ address: string; family: number }>) => {
+          if (e) fail(e); else ok(a ?? []);
+        }) as MultiResult);
+      } else {
+        lookup(host, opts ?? {}, (e, addr, fam) => {
+          if (e) fail(e); else ok({ address: addr!, family: fam! });
+        });
+      }
+    });
+  },
+
+  resolve(host: string): Promise<string[]> {
+    return new Promise((ok, fail) => {
+      resolve(host, (e, a) => (e ? fail(e) : ok(a ?? [])));
+    });
+  },
+
+  resolve4(host: string): Promise<string[]> {
+    return promises.resolve(host);
+  },
+
+  resolve6(_host: string): Promise<string[]> {
+    return Promise.resolve(['::1']);
+  },
+
+  reverse(_ip: string): Promise<string[]> {
+    return Promise.resolve(['localhost']);
+  },
+
+  setServers(_s: string[]): void {},
+  getServers(): string[] { return []; },
+};
+
+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/polyfills/domain.ts

@@ -0,0 +1,68 @@
+// stub - deprecated in Node.js, minimal pass-through implementation
+
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  Domain                                                             */
+/* ------------------------------------------------------------------ */
+
+export interface Domain extends EventEmitter {
+  members: unknown[];
+  add(emitter: EventEmitter): void;
+  remove(emitter: EventEmitter): void;
+  bind<F extends (...args: unknown[]) => unknown>(fn: F): F;
+  intercept<F extends (...args: unknown[]) => unknown>(fn: F): F;
+  run<T>(fn: () => T): T;
+  dispose(): void;
+  enter(): void;
+  exit(): void;
+}
+
+export const Domain = function Domain(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.members = [];
+} as unknown as { new(): Domain; prototype: any };
+
+Object.setPrototypeOf(Domain.prototype, EventEmitter.prototype);
+
+Domain.prototype.add = function add(emitter: EventEmitter): void {
+  this.members.push(emitter);
+};
+Domain.prototype.remove = function remove(emitter: EventEmitter): void {
+  const idx = this.members.indexOf(emitter);
+  if (idx >= 0) this.members.splice(idx, 1);
+};
+Domain.prototype.bind = function bind<F extends (...args: unknown[]) => unknown>(fn: F): F {
+  return fn;
+};
+Domain.prototype.intercept = function intercept<F extends (...args: unknown[]) => unknown>(fn: F): F {
+  return fn;
+};
+Domain.prototype.run = function run<T>(fn: () => T): T {
+  return fn();
+};
+Domain.prototype.dispose = function dispose(): void {
+  this.members.length = 0;
+};
+Domain.prototype.enter = function enter(): void {};
+Domain.prototype.exit = function exit(): void {};
+
+/* ------------------------------------------------------------------ */
+/*  Factory                                                            */
+/* ------------------------------------------------------------------ */
+
+export function create(): Domain {
+  return new Domain();
+}
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  Domain,
+  create,
+  active,
+};