@ix-xs/node-comfort 1.0.57 → 1.1.1

package/src/utils.js

@@ -1,225 +0,0 @@
-const logger = require("./logger");
-
-module.exports = {
-  /**
-	 * @param {number} ms
-	 */
-  async wait(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  },
-  /**
-   * Polls a predicate at a given interval and emits events when it matches or times out.
-   *
-   * The predicate is evaluated every `options.interval` milliseconds (default: 50 ms).
-   * Be careful with the default interval: 50 ms is very frequent polling and can be
-   * unnecessarily CPU‑intensive if your predicate or trigger handlers are heavy.
-   * When `options.max` is `null`, the predicate can match indefinitely (infinite triggers),
-   * so you should choose an interval that makes sense for your use‑case.
-   *
-   * @param {boolean|Promise<boolean>|(() => boolean|Promise<boolean>)} predicate
-   *        Condition to evaluate at each tick, or a function returning it.
-   * @param {*} payload
-   *        Value passed to listeners when events are emitted (e.g. an object or message).
-   * @param {object} [options]
-   * @param {number} [options.interval=50]
-   *        Polling interval in milliseconds. Increase this value if your predicate is
-   *        expensive or you expect many triggers without a `max` limit.
-   * @param {number|null} [options.timeout=null]
-   *        Maximum time in milliseconds before emitting a "timeout" event and stopping.
-   *        If `null`, no timeout is applied.
-   * @param {number|null} [options.max=null]
-   *        Maximum number of successful predicate evaluations ("trigger" events) before
-   *        automatically stopping. If `null`, triggers are infinite until `stop()` is called.
-   *
-   * @example
-   * // Basic usage: infinite triggers every 50 ms (default interval) – use with caution.
-   * const task = when(() => true, { message: "Ok" });
-   *
-   * task.on("trigger", (payload) => {
-   *   console.log(payload.message);
-   *   // task.stop(); // stop when you’re done
-   * });
-   *
-   * task.start();
-   *
-   * @example
-   * // Safer usage: limit triggers and/or lower polling frequency.
-   * when(() => true, { message: "Ok" }, { max: 1, interval: 500 }) // one trigger max, every 500 ms
-   *   .on("trigger", (payload) => {
-   *     console.log(payload.message);
-   *   })
-   *   .start();
-   */
-  when(predicate, payload = {}, options) {
-    const interval = options?.interval ?? 50;
-    const timeout = options?.timeout ?? null;
-    const max = options?.max ?? null;
-
-    const listeners = {
-      trigger: new Set(),
-      error: new Set(),
-      timeout: new Set(),
-    };
-
-    let _timer = null;
-    let _timeoutTimer = null;
-    let _stopped = false;
-    let _count = 0;
-
-    function emit(event, p) {
-      for (const fn of listeners[event]) {
-        try {
-          fn(p);
-        } catch (error) {
-          throw error;
-        }
-      }
-    }
-
-    async function evalPredicate() {
-      if (typeof predicate === "function") {
-        return await predicate();
-      }
-      return Boolean(predicate);
-    }
-
-    async function tick() {
-      if (_stopped) return;
-
-      try {
-        const ok = await evalPredicate();
-
-        if (ok) {
-          _count++;
-          emit("trigger", payload);
-
-          if (max != null && _count >= max) {
-            _stopInternal();
-            return;
-          }
-        }
-
-        if (!_stopped) {
-          _timer = setTimeout(tick, interval);
-        }
-      } catch (error) {
-        emit("error", error);
-        if (!_stopped) {
-          _timer = setTimeout(tick, interval);
-        }
-      }
-    }
-
-    function _stopInternal() {
-      _stopped = true;
-      if (_timer) {
-        clearTimeout(_timer);
-        _timer = null;
-      }
-      if (_timeoutTimer) {
-        clearTimeout(_timeoutTimer);
-        _timeoutTimer = null;
-      }
-    }
-
-    const _ = {
-      start() {
-        if (_stopped) return _;
-
-        if (!_timer) {
-          _timer = setTimeout(tick, 0);
-        }
-
-        if (timeout != null && !_timeoutTimer) {
-          _timeoutTimer = setTimeout(() => {
-            if (_stopped) return;
-            emit("timeout", payload);
-            _stopInternal();
-          }, timeout);
-        }
-
-        return _;
-      },
-      stop() {
-        _stopInternal();
-        return _;
-      },
-      /**
-       * @typedef { "error" | "trigger" | "timeout" } EventNames
-       * @typedef {{
-       * error: (error) => void|Promise<void>,
-       * trigger: (payload) => void|Promise<void>,
-       * timeout: (payload) => void|Promise<void>,
-       * }} EventHandlers
-       */
-      /**
-       * @template {EventNames} E
-			 * @param {E} event
-			 * @param {EventHandlers[E]} handler
-			 */
-      on(event, handler) {
-        listeners[event]?.add(handler);
-        return _;
-      },
-    };
-
-    return _;
-  },
-  dontCrash() {
-    const defaults = {
-      error: (error) => {
-        logger.log(`<% red [@ix-xs/node-comfort] Process Error %>\n<% gray ${error.stack ?? error} %>`);
-      },
-      exit: (code) => {
-        logger.log(`<% yellow [@ix-xs/node-comfort] Process Exit %>\n→ Code: <% gray ${code} %>`);
-      },
-      sig: (signal) => {
-        logger.log(`<% yellow [@ix-xs/node-comfort] Process SIG* %>\n→ Signal: <% gray ${signal} %>`);
-        process.exit(0);
-      },
-      beforeExit: (code) => {},
-    };
-
-    const _ = {
-      /**
-			 * @template { "error" | "exit" | "sig" | "beforeExit" } E
-			 * @param { E } event
-			 * @param { { error: (error: Error | unknown) => void | Promise<void>, exit: (code: number) => void | Promise<void>, sig: (signal: "SIGINT" | "SIGTERM" | "SIGQUIT") => void | Promise<void>, beforeExit: (code: number) => void|Promise<void> }[E] } handler
-			 */
-      on(event, handler) {
-        if (event === "error") {
-          process.removeAllListeners("uncaughtException");
-          process.removeAllListeners("unhandledRejection");
-          process.on("uncaughtException", handler ?? defaults.error);
-          process.on("unhandledRejection", handler ?? defaults.error);
-        } else if (event === "exit") {
-          process.removeAllListeners("exit");
-          process.on("exit", handler ?? defaults.exit);
-        } else if (event === "sig") {
-          for (const signal of ["SIGINT", "SIGTERM", "SIGQUIT"]) {
-            process.removeAllListeners(signal);
-            process.on(signal, handler ?? defaults.sig);
-          }
-        } else if (event === "beforeExit") {
-          process.removeAllListeners("beforeExit");
-          process.on("beforeExit", handler ?? defaults.beforeExit);
-        }
-
-        return _;
-      },
-    };
-
-    _.on("error").on("exit").on("sig");
-
-    return _;
-  },
-  /**
-   * @param {*} value
-   */
-  JSONString(value) {
-    return JSON.stringify(value, null, 4);
-  },
-  JSONParse(value) {
-    return JSON.parse(value);
-  },
-};