@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/signal-exit.d.ts

@@ -1,50 +0,0 @@
-/**
- * @fileoverview Process signal handling utilities.
- * Provides cross-platform signal exit detection and cleanup handlers.
- */
-export interface OnExitOptions {
-    alwaysLast?: boolean;
-}
-/**
- * Load signal handlers and hook into process exit events.
- *
- * @example
- * ```typescript
- * load()
- * // Signal handlers are now active
- * ```
- */
-export declare function load(): void;
-/**
- * Register a callback to run on process exit or signal.
- *
- * @example
- * ```typescript
- * const remove = onExit((code, signal) => {
- *   console.log(`Exiting with code ${code}, signal ${signal}`)
- * })
- * // Later, to unregister:
- * remove()
- * ```
- */
-export declare function onExit(cb: (code: number | null, signal: string | null) => void, options?: OnExitOptions | undefined): () => void;
-/**
- * Get the list of signals that are currently being monitored.
- *
- * @example
- * ```typescript
- * const sigs = signals()
- * console.log(sigs) // ['SIGABRT', 'SIGALRM', 'SIGHUP', ...]
- * ```
- */
-export declare function signals(): string[];
-/**
- * Unload signal handlers and restore original process behavior.
- *
- * @example
- * ```typescript
- * unload()
- * // Signal handlers are now removed
- * ```
- */
-export declare function unload(): void;

package/dist/signal-exit.js

@@ -1,247 +0,0 @@
-"use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var signal_exit_exports = {};
-__export(signal_exit_exports, {
-  load: () => load,
-  onExit: () => onExit,
-  signals: () => signals,
-  unload: () => unload
-});
-module.exports = __toCommonJS(signal_exit_exports);
-var import_primordials = require("./primordials");
-const globalProcess = globalThis.process;
-const originalProcessEmit = globalProcess?.emit;
-const platform = globalProcess?.platform ?? "";
-const originalProcessReallyExit = globalProcess?.reallyExit;
-const WIN32 = platform === "win32";
-let _events;
-let _emitter;
-let _sigListeners;
-let loaded = false;
-let _signals;
-// @__NO_SIDE_EFFECTS__
-function emit(event, code, signal) {
-  const emitter = /* @__PURE__ */ getEmitter();
-  if (emitter.emitted?.[event]) {
-    return;
-  }
-  if (emitter.emitted) {
-    emitter.emitted[event] = true;
-  }
-  emitter.emit(event, code, signal);
-}
-// @__NO_SIDE_EFFECTS__
-function getEmitter() {
-  if (_emitter === void 0) {
-    if (globalProcess?.__signal_exit_emitter__) {
-      _emitter = globalProcess.__signal_exit_emitter__;
-    } else if (globalProcess) {
-      const EventEmitter = (/* @__PURE__ */ getEvents()).EventEmitter;
-      _emitter = globalProcess.__signal_exit_emitter__ = new EventEmitter();
-      _emitter.count = 0;
-      _emitter.emitted = { __proto__: null };
-    }
-    if (_emitter && !_emitter.infinite) {
-      _emitter.setMaxListeners(Number.POSITIVE_INFINITY);
-      _emitter.infinite = true;
-    }
-  }
-  return _emitter;
-}
-// @__NO_SIDE_EFFECTS__
-function getEvents() {
-  if (_events === void 0) {
-    _events = require("node:events");
-  }
-  return _events;
-}
-// @__NO_SIDE_EFFECTS__
-function getSignalListeners() {
-  if (_sigListeners === void 0) {
-    _sigListeners = { __proto__: null };
-    const emitter = /* @__PURE__ */ getEmitter();
-    const sigs = /* @__PURE__ */ signals();
-    for (const sig of sigs) {
-      _sigListeners[sig] = function listener() {
-        const listeners = globalProcess?.listeners(sig) || [];
-        if (listeners.length === emitter.count) {
-          /* @__PURE__ */ unload();
-          /* @__PURE__ */ emit("exit", null, sig);
-          /* @__PURE__ */ emit("afterexit", null, sig);
-          const killSig = WIN32 && sig === "SIGHUP" ? "SIGINT" : sig;
-          globalProcess?.kill(globalProcess?.pid, killSig);
-        }
-      };
-    }
-  }
-  return _sigListeners;
-}
-// @__NO_SIDE_EFFECTS__
-function processEmit(eventName, exitCode, ...args) {
-  if (eventName === "exit") {
-    let actualExitCode = exitCode;
-    if (actualExitCode === void 0) {
-      const processExitCode = globalProcess?.exitCode;
-      actualExitCode = typeof processExitCode === "number" ? processExitCode : void 0;
-    } else if (globalProcess) {
-      globalProcess.exitCode = actualExitCode;
-    }
-    const result = (0, import_primordials.ReflectApply)(
-      originalProcessEmit,
-      this,
-      [eventName, actualExitCode, ...args]
-    );
-    const numExitCode = typeof actualExitCode === "number" ? actualExitCode : null;
-    /* @__PURE__ */ emit("exit", numExitCode, null);
-    /* @__PURE__ */ emit("afterexit", numExitCode, null);
-    return result;
-  }
-  return (0, import_primordials.ReflectApply)(
-    originalProcessEmit,
-    this,
-    [eventName, exitCode, ...args]
-  );
-}
-// @__NO_SIDE_EFFECTS__
-function processReallyExit(code) {
-  const exitCode = code || 0;
-  if (globalProcess) {
-    globalProcess.exitCode = exitCode;
-  }
-  /* @__PURE__ */ emit("exit", exitCode, null);
-  /* @__PURE__ */ emit("afterexit", exitCode, null);
-  (0, import_primordials.ReflectApply)(
-    originalProcessReallyExit,
-    globalProcess,
-    [exitCode]
-  );
-  throw new import_primordials.ErrorCtor("processReallyExit should never return");
-}
-// @__NO_SIDE_EFFECTS__
-function load() {
-  if (loaded || !globalProcess) {
-    return;
-  }
-  loaded = true;
-  const emitter = /* @__PURE__ */ getEmitter();
-  if (emitter.count !== void 0) {
-    emitter.count += 1;
-  }
-  const sigs = /* @__PURE__ */ signals();
-  const sigListeners = /* @__PURE__ */ getSignalListeners();
-  _signals = sigs.filter((sig) => {
-    try {
-      globalProcess.on(
-        sig,
-        sigListeners[sig]
-      );
-      return true;
-    } catch {
-    }
-    return false;
-  });
-  globalProcess.emit = processEmit;
-  globalProcess.reallyExit = processReallyExit;
-}
-// @__NO_SIDE_EFFECTS__
-function onExit(cb, options) {
-  if (!globalProcess) {
-    return function remove() {
-    };
-  }
-  if (typeof cb !== "function") {
-    throw new import_primordials.TypeErrorCtor("a callback must be provided for exit handler");
-  }
-  if (loaded === false) {
-    /* @__PURE__ */ load();
-  }
-  const { alwaysLast } = { __proto__: null, ...options };
-  let eventName = "exit";
-  if (alwaysLast) {
-    eventName = "afterexit";
-  }
-  const emitter = /* @__PURE__ */ getEmitter();
-  emitter.on(eventName, cb);
-  return function remove() {
-    emitter.removeListener(eventName, cb);
-    if (!emitter.listeners("exit").length && !emitter.listeners("afterexit").length) {
-      /* @__PURE__ */ unload();
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function signals() {
-  if (_signals === void 0) {
-    _signals = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
-    if (!WIN32) {
-      _signals.push(
-        "SIGVTALRM",
-        "SIGXCPU",
-        "SIGXFSZ",
-        "SIGUSR2",
-        "SIGTRAP",
-        "SIGSYS",
-        "SIGQUIT",
-        "SIGIOT"
-        // should detect profiler and enable/disable accordingly.
-        // see #21
-        // 'SIGPROF'
-      );
-    }
-    if (platform === "linux") {
-      _signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
-    }
-  }
-  return _signals;
-}
-// @__NO_SIDE_EFFECTS__
-function unload() {
-  if (!loaded || !globalProcess) {
-    return;
-  }
-  loaded = false;
-  const sigs = /* @__PURE__ */ signals();
-  const sigListeners = /* @__PURE__ */ getSignalListeners();
-  for (const sig of sigs) {
-    try {
-      globalProcess.removeListener(
-        sig,
-        sigListeners[sig]
-      );
-    } catch {
-    }
-  }
-  globalProcess.emit = originalProcessEmit;
-  if (originalProcessReallyExit !== void 0) {
-    globalProcess.reallyExit = originalProcessReallyExit;
-  }
-  const emitter = /* @__PURE__ */ getEmitter();
-  if (emitter.count !== void 0) {
-    emitter.count -= 1;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  load,
-  onExit,
-  signals,
-  unload
-});

package/dist/smol/util.d.ts

@@ -1,87 +0,0 @@
-/**
- * @fileoverview Smol detection + lazy-loader for `node:smol-util`.
- *
- * Two responsibilities:
- *
- *   1. `isSmol()` — memoized boolean detector for socket-btm's smol
- *      Node binary. Mirrors `isSeaBinary()` from `src/sea.ts`. Probes
- *      via `node:module.isBuiltin('node:smol-util')` since only the
- *      smol binary registers any `node:smol-*` builtins.
- *
- *   2. `getSmolUtil()` — lazy-loader for the `node:smol-util` binding,
- *      which provides native `uncurryThis` and `applyBind` (single
- *      V8 dispatch via `args.Data()` + `v8::Function::Call`, skipping
- *      the BoundFunction adapter + `Function.prototype.call` trampoline
- *      that the JS form `bind.bind(call)(fn)` hits twice per invocation).
- *      ~2x faster on hot uncurried-call sites.
- *
- * `getSmolUtil()` returns `undefined` on stock Node + non-Node
- * runtimes. Result is cached across calls; the lazy-loader follows
- * the same shape as `src/node/fs.ts` etc.
- *
- * @see https://github.com/SocketDev/socket-btm — socket-btm builds
- *   the smol binary that exposes the `node:smol-util` binding.
- */
-/**
- * Detect if the current process is running on socket-btm's smol Node
- * binary. Memoized on first call.
- *
- * Defensive across runtimes: returns `false` on stock Node, browsers
- * (no `node:module`), Deno / Bun (different module resolution), and
- * worker threads (each has its own builtin table).
- *
- * @example
- * ```ts
- * import { isSmol } from '@socketsecurity/lib/smol/util'
- *
- * if (isSmol()) {
- *   // running on the smol binary; native fast paths available
- * }
- * ```
- */
-export declare function isSmol(): boolean;
-/**
- * Surface of `node:smol-util`. See socket-btm's
- * additions/source-patched/lib/smol-util.js for the canonical shape.
- */
-export interface SmolUtilBinding {
-    /**
-     * Native equivalent of `Function.prototype.bind.bind(apply)(fn)`.
-     */
-    applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
-    /**
-     * Native equivalent of:
-     *   `(self, args) => { try { return fn.apply(self, args) } catch {} }`.
-     * Returns a function that swallows synchronous throws and returns
-     * `undefined`. Avoids JS-level throw construction on the swallow
-     * path — useful for logger sinks, debug hooks, abort handlers, etc.
-     */
-    applySafe: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R | undefined;
-    /**
-     * Native equivalent of:
-     *   `(...newArgs) => fn.call(thisArg, ...presetArgs, ...newArgs)`.
-     * Same shape as `Function.prototype.bind` but with a single C++
-     * dispatch instead of going through V8's BoundFunction adapter.
-     * Useful where `bind` would be hot — captured callbacks fed to
-     * `setImmediate`/`setTimeout`/promise continuations.
-     */
-    bindCall: <T, P extends readonly unknown[], A extends readonly unknown[], R>(fn: (this: T, ...args: [...P, ...A]) => R, thisArg: T, ...presetArgs: P) => (...newArgs: A) => R;
-    /**
-     * Native equivalent of `Function.prototype.bind.bind(call)(fn)`.
-     * Single C++ dispatch via `args.Data()` + `v8::Function::Call`.
-     */
-    uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
-    /**
-     * Native equivalent of:
-     *   `try { return new WeakRef(target) } catch { return undefined }`.
-     * Returns `undefined` for non-Object, non-Symbol inputs that would
-     * make the constructor throw. The Safe suffix follows the project's
-     * non-throwing-wrapper convention.
-     */
-    weakRefSafe: <T extends object | symbol>(target: T) => WeakRef<T> | undefined;
-}
-/**
- * Returns `node:smol-util` when running on the smol Node binary,
- * otherwise `undefined`. Result is cached across calls.
- */
-export declare function getSmolUtil(): SmolUtilBinding | undefined;

package/dist/sorts.d.ts

@@ -1,59 +0,0 @@
-/**
- * @fileoverview Sorting comparison functions including locale-aware and natural sorting.
- * Provides various comparison utilities for arrays and collections.
- */
-type FastSortFunction = ReturnType<typeof import('fast-sort').createNewSortInstance>;
-/**
- * Compare semantic versions.
- *
- * @example
- * ```typescript
- * compareSemver('1.0.0', '2.0.0')  // -1
- * compareSemver('2.0.0', '1.0.0')  // 1
- * compareSemver('1.0.0', '1.0.0')  // 0
- * ```
- */
-export declare function compareSemver(a: string, b: string): number;
-/**
- * Simple string comparison.
- *
- * @example
- * ```typescript
- * compareStr('a', 'b')  // -1
- * compareStr('b', 'a')  // 1
- * compareStr('a', 'a')  // 0
- * ```
- */
-export declare function compareStr(a: string, b: string): number;
-/**
- * Compare two strings using locale-aware comparison.
- *
- * @example
- * ```typescript
- * localeCompare('a', 'b')  // -1
- * localeCompare('b', 'a')  // 1
- * localeCompare('a', 'a')  // 0
- * ```
- */
-export declare function localeCompare(x: string, y: string): number;
-/**
- * Compare two strings using natural sorting (numeric-aware, case-insensitive).
- *
- * @example
- * ```typescript
- * naturalCompare('file2', 'file10')  // negative (file2 before file10)
- * naturalCompare('img10', 'img2')    // positive (img10 after img2)
- * ```
- */
-export declare function naturalCompare(x: string, y: string): number;
-/**
- * Sort an array using natural comparison.
- *
- * @example
- * ```typescript
- * naturalSorter(['file10', 'file2', 'file1']).asc()
- * // ['file1', 'file2', 'file10']
- * ```
- */
-export declare function naturalSorter<T>(arrayToSort: T[]): ReturnType<FastSortFunction>;
-export {};