@scelar/nodepod 1.0.0

package/src/polyfills/util.ts

@@ -0,0 +1,559 @@
+// Utility helpers: format, inspect, inherits, promisify, deprecate, type checks, etc.
+
+
+export function format(template: unknown, ...values: unknown[]): string {
+  if (typeof template !== "string") {
+    // non-string first arg: inspect all args
+    return [template, ...values].map((v) => typeof v === "string" ? v : inspect(v)).join(" ");
+  }
+
+  let idx = 0;
+  let result = template.replace(/%[sdjifoO%]/g, (token) => {
+    if (token === "%%") return "%";
+    if (idx >= values.length) return token;
+
+    const val = values[idx++];
+    switch (token) {
+      case "%s":
+        return String(val);
+      case "%d":
+      case "%i":
+        return String(parseInt(String(val), 10));
+      case "%f":
+        return String(parseFloat(String(val)));
+      case "%j":
+        try {
+          return JSON.stringify(val);
+        } catch {
+          return "[Circular]";
+        }
+      case "%o":
+      case "%O":
+        return inspect(val);
+      default:
+        return token;
+    }
+  });
+
+  // append extra args beyond what format specifiers consumed (matches Node.js)
+  while (idx < values.length) {
+    const v = values[idx++];
+    result += " " + (typeof v === "string" ? v : inspect(v));
+  }
+
+  return result;
+}
+
+export function inspect(
+  target: unknown,
+  opts?: { depth?: number; colors?: boolean },
+): string {
+  const visited = new WeakSet();
+  const maxDepth = opts?.depth ?? 2;
+
+  function render(val: unknown, level: number): string {
+    if (val === null) return "null";
+    if (val === undefined) return "undefined";
+
+    const kind = typeof val;
+    if (kind === "string") return `'${val}'`;
+    if (kind === "number" || kind === "boolean" || kind === "bigint")
+      return String(val);
+    if (kind === "symbol") return (val as symbol).toString();
+    if (kind === "function") {
+      const fname = (val as Function).name || "anonymous";
+      return `[Function: ${fname}]`;
+    }
+    if (kind !== "object") return String(val);
+
+    if (visited.has(val as object)) return "[Circular]";
+    visited.add(val as object);
+
+    if (level > maxDepth) {
+      return Array.isArray(val) ? "[Array]" : "[Object]";
+    }
+
+    if (Array.isArray(val)) {
+      if (val.length === 0) return "[]";
+      const items = val.map((item) => render(item, level + 1));
+      return `[ ${items.join(", ")} ]`;
+    }
+
+    if (val instanceof Date) return val.toISOString();
+    if (val instanceof RegExp) return val.toString();
+    if (val instanceof Error) return `${val.name}: ${val.message}`;
+
+    if (val instanceof Map) {
+      const pairs = [...val.entries()].map(
+        ([k, v]) => `${render(k, level + 1)} => ${render(v, level + 1)}`,
+      );
+      return `Map(${val.size}) { ${pairs.join(", ")} }`;
+    }
+
+    if (val instanceof Set) {
+      const items = [...val].map((v) => render(v, level + 1));
+      return `Set(${val.size}) { ${items.join(", ")} }`;
+    }
+
+    const keys = Object.keys(val as object);
+    if (keys.length === 0) return "{}";
+    const fields = keys.map((k) => {
+      const v = (val as Record<string, unknown>)[k];
+      return `${k}: ${render(v, level + 1)}`;
+    });
+    return `{ ${fields.join(", ")} }`;
+  }
+
+  return render(target, 0);
+}
+
+export function inherits(child: Function, parent: Function): void {
+  if (child === undefined || child === null) {
+    throw new TypeError("inherits: child constructor must be provided");
+  }
+  if (parent === undefined || parent === null) return;
+  if (parent.prototype === undefined) return;
+  (child as any).super_ = parent;
+  Object.setPrototypeOf(child.prototype, parent.prototype);
+}
+
+// deprecated, equivalent to Object.assign
+export function _extend(target: any, source: any): any {
+  if (source == null) return target;
+  const keys = Object.keys(source);
+  for (let i = 0; i < keys.length; i++) {
+    target[keys[i]] = source[keys[i]];
+  }
+  return target;
+}
+
+export function deprecate<T extends Function>(
+  fn: T,
+  message: string,
+  code?: string,
+): T {
+  let alerted = false;
+  const wrapper = function (this: unknown, ...args: unknown[]) {
+    if (!alerted) {
+      console.warn(`DeprecationWarning: ${message}${code ? ` (${code})` : ""}`);
+      alerted = true;
+    }
+    return fn.apply(this, args);
+  };
+  return wrapper as unknown as T;
+}
+
+export function promisify<T>(
+  fn: (...args: any[]) => void,
+): (...args: any[]) => Promise<T> {
+  return (...args: any[]) =>
+    new Promise((ok, fail) => {
+      fn(...args, (err: Error | null, result: T) => {
+        if (err) fail(err);
+        else ok(result);
+      });
+    });
+}
+
+export function callbackify<T>(
+  fn: (...args: any[]) => Promise<T>,
+): (...args: any[]) => void {
+  return (...args: any[]) => {
+    const cb = args.pop() as (err: Error | null, result: T) => void;
+    fn(...args)
+      .then((result) => cb(null, result))
+      .catch((err) => cb(err, undefined as unknown as T));
+  };
+}
+
+export function isDeepStrictEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+
+  if (typeof a === "object") {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      return a.every((item, i) => isDeepStrictEqual(item, b[i]));
+    }
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+    const keysA = Object.keys(a as object);
+    const keysB = Object.keys(b as object);
+    if (keysA.length !== keysB.length) return false;
+
+    return keysA.every((k) =>
+      isDeepStrictEqual(
+        (a as Record<string, unknown>)[k],
+        (b as Record<string, unknown>)[k],
+      ),
+    );
+  }
+
+  return false;
+}
+
+export function isArray(val: unknown): val is unknown[] {
+  return Array.isArray(val);
+}
+export function isBoolean(val: unknown): val is boolean {
+  return typeof val === "boolean";
+}
+export function isNull(val: unknown): val is null {
+  return val === null;
+}
+export function isNullOrUndefined(val: unknown): val is null | undefined {
+  return val == null;
+}
+export function isNumber(val: unknown): val is number {
+  return typeof val === "number";
+}
+export function isString(val: unknown): val is string {
+  return typeof val === "string";
+}
+export function isUndefined(val: unknown): val is undefined {
+  return val === undefined;
+}
+export function isRegExp(val: unknown): val is RegExp {
+  return val instanceof RegExp;
+}
+export function isObject(val: unknown): val is object {
+  return typeof val === "object" && val !== null;
+}
+export function isDate(val: unknown): val is Date {
+  return val instanceof Date;
+}
+export function isError(val: unknown): val is Error {
+  return val instanceof Error;
+}
+export function isFunction(val: unknown): val is Function {
+  return typeof val === "function";
+}
+export function isPrimitive(val: unknown): boolean {
+  return val === null || (typeof val !== "object" && typeof val !== "function");
+}
+export function isBuffer(val: unknown): boolean {
+  return val instanceof Uint8Array;
+}
+export function isPromise(val: unknown): val is Promise<unknown> {
+  return val instanceof Promise;
+}
+
+// returns a logger when NODE_DEBUG includes the given section
+export function debuglog(section: string): (...args: unknown[]) => void {
+  const envDebug =
+    (typeof process !== "undefined" && process.env?.NODE_DEBUG) || "";
+  const active = envDebug.toLowerCase().includes(section.toLowerCase());
+
+  if (active) {
+    return (...args: unknown[]) => {
+      console.error(`${section.toUpperCase()} ${process?.pid || 0}:`, ...args);
+    };
+  }
+  return () => {};
+}
+
+export const debug = debuglog;
+
+export function stripVTControlCharacters(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(
+    /\x1B\[[0-9;]*[a-zA-Z]|\x1B\].*?(\x07|\x1B\\)|\x1B[()][A-Z0-9]|\x1B[#=]|\x1B./g,
+    "",
+  );
+}
+
+export const types = {
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isUndefined,
+  isRegExp,
+  isObject,
+  isDate,
+  isError,
+  isFunction,
+  isPrimitive,
+  isBuffer,
+  isPromise,
+};
+
+// styleText (Node.js 21.7+)
+
+const ANSI_STYLES: Record<string, [number, number]> = {
+  // Modifiers
+  reset: [0, 0],
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  // Foreground colors
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  grey: [90, 39],
+  blackBright: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  // Background colors
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49],
+};
+
+export function styleText(format: string | string[], text: string): string {
+  const formats = Array.isArray(format) ? format : [format];
+  let result = text;
+  for (const f of formats) {
+    const style = ANSI_STYLES[f];
+    if (style) {
+      result = `\x1b[${style[0]}m${result}\x1b[${style[1]}m`;
+    }
+  }
+  return result;
+}
+
+// parseArgs (Node.js 18.3+)
+
+interface ParseArgsOptionConfig {
+  type: "string" | "boolean";
+  short?: string;
+  multiple?: boolean;
+  default?: string | boolean | string[] | boolean[];
+}
+
+interface ParseArgsConfig {
+  args?: string[];
+  options?: Record<string, ParseArgsOptionConfig>;
+  strict?: boolean;
+  allowPositionals?: boolean;
+  tokens?: boolean;
+}
+
+interface ParseArgsResult {
+  values: Record<string, string | boolean | (string | boolean)[] | undefined>;
+  positionals: string[];
+  tokens?: Array<{
+    kind: string;
+    name?: string;
+    value?: string | boolean;
+    index: number;
+  }>;
+}
+
+export function parseArgs(config?: ParseArgsConfig): ParseArgsResult {
+  const args =
+    config?.args ??
+    (typeof process !== "undefined" ? process.argv.slice(2) : []);
+  const optDefs = config?.options ?? {};
+  const allowPositionals = config?.allowPositionals ?? !config?.options;
+  const strict = config?.strict ?? true;
+  const wantTokens = config?.tokens ?? false;
+
+  // Build short → long name map
+  const shortMap: Record<string, string> = {};
+  for (const [name, def] of Object.entries(optDefs)) {
+    if (def.short) shortMap[def.short] = name;
+  }
+
+  const values: Record<
+    string,
+    string | boolean | (string | boolean)[] | undefined
+  > = {};
+  const positionals: string[] = [];
+  const tokens: Array<{
+    kind: string;
+    name?: string;
+    value?: string | boolean;
+    index: number;
+  }> = [];
+
+  // Initialize defaults
+  for (const [name, def] of Object.entries(optDefs)) {
+    if (def.default !== undefined) {
+      values[name] = def.default;
+    }
+  }
+
+  let i = 0;
+  let afterDash = false;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (afterDash || !arg.startsWith("-") || arg === "-") {
+      if (!allowPositionals && strict && !afterDash) {
+        throw new Error(`Unexpected argument '${arg}'`);
+      }
+      positionals.push(arg);
+      if (wantTokens) tokens.push({ kind: "positional", value: arg, index: i });
+      i++;
+      continue;
+    }
+
+    if (arg === "--") {
+      afterDash = true;
+      if (wantTokens) tokens.push({ kind: "option-terminator", index: i });
+      i++;
+      continue;
+    }
+
+    // --long or --long=value
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      const rawName = eqIdx !== -1 ? arg.slice(2, eqIdx) : arg.slice(2);
+      const def = optDefs[rawName];
+
+      if (!def && strict) {
+        throw new Error(`Unknown option '--${rawName}'`);
+      }
+
+      const type = def?.type ?? "boolean";
+      let val: string | boolean;
+
+      if (type === "boolean") {
+        val = eqIdx !== -1 ? arg.slice(eqIdx + 1) !== "false" : true;
+      } else {
+        if (eqIdx !== -1) {
+          val = arg.slice(eqIdx + 1);
+        } else if (i + 1 < args.length) {
+          val = args[++i];
+        } else {
+          throw new Error(`Option '--${rawName}' requires a value`);
+        }
+      }
+
+      if (def?.multiple) {
+        const arr = (values[rawName] as (string | boolean)[] | undefined) ?? [];
+        arr.push(val);
+        values[rawName] = arr;
+      } else {
+        values[rawName] = val;
+      }
+
+      if (wantTokens)
+        tokens.push({ kind: "option", name: rawName, value: val, index: i });
+      i++;
+      continue;
+    }
+
+    // -s (short options)
+    if (arg.startsWith("-") && arg.length > 1) {
+      // Handle combined short flags: -abc → -a -b -c
+      const chars = arg.slice(1);
+      for (let c = 0; c < chars.length; c++) {
+        const ch = chars[c];
+        const longName = shortMap[ch];
+
+        if (!longName && strict) {
+          throw new Error(`Unknown option '-${ch}'`);
+        }
+
+        const name = longName ?? ch;
+        const def = longName ? optDefs[longName] : undefined;
+        const type = def?.type ?? "boolean";
+
+        let val: string | boolean;
+        if (type === "boolean") {
+          val = true;
+        } else {
+          // Rest of chars is the value, or next arg
+          const rest = chars.slice(c + 1);
+          if (rest.length > 0) {
+            val = rest;
+            c = chars.length; // break inner loop
+          } else if (i + 1 < args.length) {
+            val = args[++i];
+          } else {
+            throw new Error(`Option '-${ch}' requires a value`);
+          }
+        }
+
+        if (def?.multiple) {
+          const arr = (values[name] as (string | boolean)[] | undefined) ?? [];
+          arr.push(val);
+          values[name] = arr;
+        } else {
+          values[name] = val;
+        }
+
+        if (wantTokens)
+          tokens.push({ kind: "option", name, value: val, index: i });
+      }
+      i++;
+      continue;
+    }
+
+    i++;
+  }
+
+  const result: ParseArgsResult = { values, positionals };
+  if (wantTokens) result.tokens = tokens;
+  return result;
+}
+
+export const TextEncoder = globalThis.TextEncoder;
+export const TextDecoder = globalThis.TextDecoder;
+
+export default {
+  format,
+  inspect,
+  inherits,
+  _extend,
+  deprecate,
+  promisify,
+  callbackify,
+  isDeepStrictEqual,
+  debuglog,
+  debug,
+  stripVTControlCharacters,
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isUndefined,
+  isRegExp,
+  isObject,
+  isDate,
+  isError,
+  isFunction,
+  isPrimitive,
+  isBuffer,
+  isPromise,
+  styleText,
+  parseArgs,
+  types,
+  TextEncoder,
+  TextDecoder,
+};

package/src/polyfills/v8.ts

@@ -0,0 +1,126 @@
+// stub - not available in browser
+
+export function getHeapStatistics() {
+  return {
+    total_heap_size: 0,
+    total_heap_size_executable: 0,
+    total_physical_size: 0,
+    total_available_size: 0,
+    used_heap_size: 0,
+    heap_size_limit: 0,
+    malloced_memory: 0,
+    peak_malloced_memory: 0,
+    does_zap_garbage: 0,
+    number_of_native_contexts: 0,
+    number_of_detached_contexts: 0,
+  };
+}
+
+export function getHeapSpaceStatistics(): unknown[] {
+  return [];
+}
+
+export function getHeapCodeStatistics() {
+  return {
+    code_and_metadata_size: 0,
+    bytecode_and_metadata_size: 0,
+    external_script_source_size: 0,
+  };
+}
+
+export function getHeapSnapshot(): null { return null; }
+export function writeHeapSnapshot(): string { return ''; }
+
+
+export function setFlagsFromString(_flags: string): void {}
+export function takeCoverage(): void {}
+export function stopCoverage(): void {}
+
+export function cachedDataVersionTag(): number {
+  return 0;
+}
+
+// serialize/deserialize use JSON as a fallback
+
+export function serialize(value: unknown): Uint8Array {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+
+export function deserialize(bytes: Uint8Array): unknown {
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
+export interface Serializer {
+  writeHeader(): void;
+  writeValue(_v: unknown): void;
+  releaseBuffer(): Uint8Array;
+}
+
+export const Serializer = function Serializer(this: any) {
+  if (!this) return;
+} as unknown as { new(): Serializer; prototype: any };
+
+Serializer.prototype.writeHeader = function writeHeader(): void {};
+Serializer.prototype.writeValue = function writeValue(_v: unknown): void {};
+Serializer.prototype.releaseBuffer = function releaseBuffer(): Uint8Array { return new Uint8Array(0); };
+
+export interface Deserializer {
+  readHeader(): boolean;
+  readValue(): unknown;
+}
+
+export const Deserializer = function Deserializer(this: any, _buf: Uint8Array) {
+  if (!this) return;
+} as unknown as { new(_buf: Uint8Array): Deserializer; prototype: any };
+
+Deserializer.prototype.readHeader = function readHeader(): boolean { return true; };
+Deserializer.prototype.readValue = function readValue(): unknown { return null; };
+
+export interface DefaultSerializer extends Serializer {}
+
+export const DefaultSerializer = function DefaultSerializer(this: any) {
+  if (!this) return;
+  (Serializer as any).call(this);
+} as unknown as { new(): DefaultSerializer; prototype: any };
+
+Object.setPrototypeOf(DefaultSerializer.prototype, Serializer.prototype);
+
+export interface DefaultDeserializer extends Deserializer {}
+
+export const DefaultDeserializer = function DefaultDeserializer(this: any, _buf: Uint8Array) {
+  if (!this) return;
+  (Deserializer as any).call(this, _buf);
+} as unknown as { new(_buf: Uint8Array): DefaultDeserializer; prototype: any };
+
+Object.setPrototypeOf(DefaultDeserializer.prototype, Deserializer.prototype);
+
+
+export function promiseHooks() {
+  return {
+    onInit: () => {},
+    onSettled: () => {},
+    onBefore: () => {},
+    onAfter: () => {},
+    createHook: () => ({ enable: () => {}, disable: () => {} }),
+  };
+}
+
+
+export default {
+  getHeapStatistics,
+  getHeapSpaceStatistics,
+  getHeapCodeStatistics,
+  getHeapSnapshot,
+  writeHeapSnapshot,
+  setFlagsFromString,
+  takeCoverage,
+  stopCoverage,
+  cachedDataVersionTag,
+  serialize,
+  deserialize,
+  Serializer,
+  Deserializer,
+  DefaultSerializer,
+  DefaultDeserializer,
+  promiseHooks,
+};