@ls-stack/utils 3.65.0 → 3.66.0

package/dist/timers.cjs

@@ -1,194 +0,0 @@
-"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);
-
-// src/timers.ts
-var timers_exports = {};
-__export(timers_exports, {
-  createDebouncedTimeout: () => createDebouncedTimeout,
-  createInterval: () => createInterval,
-  createTimeout: () => createTimeout,
-  createWaitUntil: () => createWaitUntil,
-  waitFor: () => waitFor
-});
-module.exports = __toCommonJS(timers_exports);
-var import_t_result = require("t-result");
-
-// src/promiseUtils.ts
-function defer() {
-  let resolve;
-  let reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { resolve, reject, promise };
-}
-
-// src/timers.ts
-function createTimeout(ms, callback) {
-  const timeoutId = setTimeout(callback, ms);
-  let isCleaned = false;
-  return () => {
-    if (isCleaned) return;
-    clearTimeout(timeoutId);
-    isCleaned = true;
-  };
-}
-function createInterval(ms, callback) {
-  const intervalId = setInterval(callback, ms);
-  let isCleaned = false;
-  return () => {
-    if (isCleaned) return;
-    clearInterval(intervalId);
-    isCleaned = true;
-  };
-}
-function createDebouncedTimeout(ms, callback) {
-  let cleanupTimer = null;
-  return {
-    clean: () => {
-      cleanupTimer?.();
-    },
-    call: () => {
-      cleanupTimer?.();
-      cleanupTimer = createTimeout(ms, () => {
-        callback();
-      });
-    }
-  };
-}
-function createWaitUntil({
-  condition,
-  maxWaitMs,
-  callback,
-  checkIntervalMs = 20
-}) {
-  let cleanCheckTimeout = null;
-  let cleanMaxWaitTimeout = null;
-  cleanMaxWaitTimeout = createTimeout(maxWaitMs, () => {
-    cleanCheckTimeout?.();
-  });
-  function check() {
-    const result = condition();
-    if (result) {
-      cleanMaxWaitTimeout?.();
-      callback(result);
-    } else {
-      cleanCheckTimeout = createTimeout(checkIntervalMs, check);
-    }
-  }
-  check();
-  return () => {
-    cleanMaxWaitTimeout();
-    cleanCheckTimeout?.();
-  };
-}
-async function waitFor(condition, { polling, timeout }) {
-  const { promise, resolve } = defer();
-  let timeoutId = null;
-  let intervalId = null;
-  let rafId = null;
-  let isResolved = false;
-  function cleanup() {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-    if (intervalId) {
-      clearInterval(intervalId);
-      intervalId = null;
-    }
-    if (rafId && typeof cancelAnimationFrame !== "undefined") {
-      cancelAnimationFrame(rafId);
-      rafId = null;
-    }
-  }
-  function resolveWith(result) {
-    if (isResolved) return;
-    isResolved = true;
-    cleanup();
-    resolve(result);
-  }
-  async function checkCondition() {
-    try {
-      const result = condition();
-      const conditionMet = result instanceof Promise ? await result : result;
-      if (conditionMet) {
-        resolveWith(import_t_result.Result.ok(void 0));
-        return true;
-      }
-      return false;
-    } catch (error) {
-      resolveWith(import_t_result.Result.err(new Error(`Condition check failed: ${error}`)));
-      return true;
-    }
-  }
-  checkCondition().then((resolved) => {
-    if (resolved) {
-      return;
-    }
-    timeoutId = setTimeout(() => {
-      resolveWith(
-        import_t_result.Result.err(
-          new Error(
-            `Timeout of ${timeout}ms exceeded while waiting for condition`
-          )
-        )
-      );
-    }, timeout);
-    if (polling === "raf") {
-      let rafCheck2 = function() {
-        if (isResolved) return;
-        checkCondition().then((conditionResolved) => {
-          if (!conditionResolved && !isResolved) {
-            rafId = requestAnimationFrame(rafCheck2);
-          }
-        }).catch(() => {
-        });
-      };
-      var rafCheck = rafCheck2;
-      if (typeof requestAnimationFrame === "undefined") {
-        resolveWith(
-          import_t_result.Result.err(
-            new Error(
-              "requestAnimationFrame is not available in this environment"
-            )
-          )
-        );
-        return;
-      }
-      rafId = requestAnimationFrame(rafCheck2);
-    } else {
-      intervalId = setInterval(() => {
-        checkCondition().catch(() => {
-        });
-      }, polling);
-    }
-  }).catch(() => {
-  });
-  return promise;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createDebouncedTimeout,
-  createInterval,
-  createTimeout,
-  createWaitUntil,
-  waitFor
-});

package/dist/timers.d.ts

@@ -1,121 +0,0 @@
-import { Result } from 't-result';
-
-type CleanupTimer = () => void;
-/**
- * Creates a timeout with automatic cleanup capability.
- *
- * Returns a cleanup function that can be called to cancel the timeout. The
- * cleanup function is idempotent - calling it multiple times is safe.
- *
- * @example
- *   ```typescript
- *   const cleanup = createTimeout(1000, () => {
- *     console.log('Timeout completed');
- *   });
- *
- *   // Cancel the timeout before it completes
- *   cleanup();
- *   ```;
- *
- * @param ms - The timeout duration in milliseconds
- * @param callback - The function to execute when the timeout completes
- * @returns A cleanup function that cancels the timeout when called
- */
-declare function createTimeout(ms: number, callback: () => void): CleanupTimer;
-/**
- * Creates an interval with automatic cleanup capability.
- *
- * Returns a cleanup function that can be called to cancel the interval. The
- * cleanup function is idempotent - calling it multiple times is safe.
- *
- * @example
- *   ```typescript
- *   const cleanup = createInterval(1000, () => {
- *     console.log('Interval tick');
- *   });
- *
- *   // Stop the interval
- *   cleanup();
- *   ```;
- *
- * @param ms - The interval duration in milliseconds
- * @param callback - The function to execute on each interval tick
- * @returns A cleanup function that cancels the interval when called
- */
-declare function createInterval(ms: number, callback: () => void): CleanupTimer;
-/**
- * Creates a timeout that prevents concurrent executions.
- *
- * Each call to the `call` function will cancel any previous pending timeout and
- * start a new one. This is useful for debouncing or ensuring only the last call
- * executes after a delay.
- *
- * @example
- *   ```typescript
- *   const { call, clean } = createDebouncedTimeout(1000, () => {
- *     console.log('Only the last call executes');
- *   });
- *
- *   call(); // This will be cancelled
- *   call(); // This will be cancelled
- *   call(); // Only this one will execute after 1000ms
- *
- *   // Or cancel all pending timeouts
- *   clean();
- *   ```;
- *
- * @param ms - The timeout duration in milliseconds
- * @param callback - The function to execute when the timeout completes
- * @returns An object with `call` to trigger the timeout and `clean` to cancel
- *   it
- */
-declare function createDebouncedTimeout(ms: number, callback: () => void): {
-    call: () => void;
-    clean: CleanupTimer;
-};
-/**
- * Creates a timeout that waits for a condition to become true.
- *
- * Polls the condition function at regular intervals until it returns a truthy
- * value, then calls the callback with that value. If the condition doesn't
- * become true within the maximum wait time, the timeout expires without calling
- * the callback.
- *
- * @example
- *   ```typescript
- *   const cleanup = createWaitUntil({
- *     condition: () => document.getElementById('myElement'),
- *     maxWaitMs: 5000,
- *     callback: (element) => {
- *       console.log('Element found:', element);
- *     },
- *     checkIntervalMs: 50
- *   });
- *
- *   // Cancel the condition check
- *   cleanup();
- *   ```;
- *
- * @template T - The type of value returned by the condition function when true
- * @param options - Configuration options
- * @param options.condition - Function that returns false or a truthy value when
- *   the condition is met
- * @param options.maxWaitMs - Maximum time to wait for the condition in
- *   milliseconds
- * @param options.callback - Function to call when the condition becomes true
- * @param options.checkIntervalMs - How often to check the condition in
- *   milliseconds (default: 20)
- * @returns A cleanup function that cancels the condition timeout
- */
-declare function createWaitUntil<T extends NonNullable<unknown>>({ condition, maxWaitMs, callback, checkIntervalMs, }: {
-    condition: () => false | T;
-    maxWaitMs: number;
-    callback: (value: T) => void;
-    checkIntervalMs?: number;
-}): CleanupTimer;
-declare function waitFor(condition: () => boolean | Promise<boolean>, { polling, timeout }: {
-    polling: number | 'raf';
-    timeout: number;
-}): Promise<Result<void, Error>>;
-
-export { type CleanupTimer, createDebouncedTimeout, createInterval, createTimeout, createWaitUntil, waitFor };

package/dist/timers.js

@@ -1,156 +0,0 @@
-import {
-  defer
-} from "./chunk-DFXNVEH6.js";
-
-// src/timers.ts
-import { Result } from "t-result";
-function createTimeout(ms, callback) {
-  const timeoutId = setTimeout(callback, ms);
-  let isCleaned = false;
-  return () => {
-    if (isCleaned) return;
-    clearTimeout(timeoutId);
-    isCleaned = true;
-  };
-}
-function createInterval(ms, callback) {
-  const intervalId = setInterval(callback, ms);
-  let isCleaned = false;
-  return () => {
-    if (isCleaned) return;
-    clearInterval(intervalId);
-    isCleaned = true;
-  };
-}
-function createDebouncedTimeout(ms, callback) {
-  let cleanupTimer = null;
-  return {
-    clean: () => {
-      cleanupTimer?.();
-    },
-    call: () => {
-      cleanupTimer?.();
-      cleanupTimer = createTimeout(ms, () => {
-        callback();
-      });
-    }
-  };
-}
-function createWaitUntil({
-  condition,
-  maxWaitMs,
-  callback,
-  checkIntervalMs = 20
-}) {
-  let cleanCheckTimeout = null;
-  let cleanMaxWaitTimeout = null;
-  cleanMaxWaitTimeout = createTimeout(maxWaitMs, () => {
-    cleanCheckTimeout?.();
-  });
-  function check() {
-    const result = condition();
-    if (result) {
-      cleanMaxWaitTimeout?.();
-      callback(result);
-    } else {
-      cleanCheckTimeout = createTimeout(checkIntervalMs, check);
-    }
-  }
-  check();
-  return () => {
-    cleanMaxWaitTimeout();
-    cleanCheckTimeout?.();
-  };
-}
-async function waitFor(condition, { polling, timeout }) {
-  const { promise, resolve } = defer();
-  let timeoutId = null;
-  let intervalId = null;
-  let rafId = null;
-  let isResolved = false;
-  function cleanup() {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-    if (intervalId) {
-      clearInterval(intervalId);
-      intervalId = null;
-    }
-    if (rafId && typeof cancelAnimationFrame !== "undefined") {
-      cancelAnimationFrame(rafId);
-      rafId = null;
-    }
-  }
-  function resolveWith(result) {
-    if (isResolved) return;
-    isResolved = true;
-    cleanup();
-    resolve(result);
-  }
-  async function checkCondition() {
-    try {
-      const result = condition();
-      const conditionMet = result instanceof Promise ? await result : result;
-      if (conditionMet) {
-        resolveWith(Result.ok(void 0));
-        return true;
-      }
-      return false;
-    } catch (error) {
-      resolveWith(Result.err(new Error(`Condition check failed: ${error}`)));
-      return true;
-    }
-  }
-  checkCondition().then((resolved) => {
-    if (resolved) {
-      return;
-    }
-    timeoutId = setTimeout(() => {
-      resolveWith(
-        Result.err(
-          new Error(
-            `Timeout of ${timeout}ms exceeded while waiting for condition`
-          )
-        )
-      );
-    }, timeout);
-    if (polling === "raf") {
-      let rafCheck2 = function() {
-        if (isResolved) return;
-        checkCondition().then((conditionResolved) => {
-          if (!conditionResolved && !isResolved) {
-            rafId = requestAnimationFrame(rafCheck2);
-          }
-        }).catch(() => {
-        });
-      };
-      var rafCheck = rafCheck2;
-      if (typeof requestAnimationFrame === "undefined") {
-        resolveWith(
-          Result.err(
-            new Error(
-              "requestAnimationFrame is not available in this environment"
-            )
-          )
-        );
-        return;
-      }
-      rafId = requestAnimationFrame(rafCheck2);
-    } else {
-      intervalId = setInterval(() => {
-        checkCondition().catch(() => {
-        });
-      }, polling);
-    }
-  }).catch(() => {
-  });
-  return promise;
-}
-export {
-  createDebouncedTimeout,
-  createInterval,
-  createTimeout,
-  createWaitUntil,
-  waitFor
-};

package/dist/tsResult.cjs

@@ -1,226 +0,0 @@
-"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);
-
-// src/tsResult.ts
-var tsResult_exports = {};
-__export(tsResult_exports, {
-  Result: () => Result,
-  err: () => err,
-  ok: () => ok,
-  resultify: () => resultify,
-  unknownToError: () => unknownToError
-});
-module.exports = __toCommonJS(tsResult_exports);
-
-// src/typeGuards.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPromise(value) {
-  return isObject(value) && "then" in value && isFunction(value.then);
-}
-
-// src/assertions.ts
-var isFunction2 = isFunction;
-var isObject2 = isObject;
-var isPromise2 = isPromise;
-
-// src/safeJson.ts
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return void 0;
-  }
-}
-
-// src/tsResult.ts
-function okUnwrapOr() {
-  return this.value;
-}
-function okMap(mapFn) {
-  return this.ok ? ok(mapFn(this.value)) : this;
-}
-function errMap(mapFn) {
-  return this.ok ? this : err(mapFn(this.error));
-}
-function mapOkAndErr({
-  ok: mapFn,
-  err: mapErrFn
-}) {
-  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
-}
-function returnResult() {
-  return this;
-}
-function okOnOk(fn) {
-  if (this.ok) {
-    fn(this.value);
-  }
-  return this;
-}
-function errOnErr(fn) {
-  if (!this.ok) {
-    fn(this.error);
-  }
-  return this;
-}
-function ok(value = void 0) {
-  const methods = {
-    unwrapOrNull: okUnwrapOr,
-    unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr,
-    mapOk: okMap,
-    mapErr: returnResult,
-    mapOkAndErr,
-    ifOk: okOnOk,
-    ifErr: returnResult
-  };
-  return {
-    ok: true,
-    error: false,
-    value,
-    ...methods
-  };
-}
-function err(error) {
-  const methods = {
-    unwrapOrNull: () => null,
-    unwrapOr: (defaultValue) => defaultValue,
-    unwrap: () => {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw unknownToError(error);
-    },
-    mapOk: returnResult,
-    mapErr: errMap,
-    mapOkAndErr,
-    ifOk: returnResult,
-    ifErr: errOnErr
-  };
-  return {
-    ok: false,
-    error,
-    errorResult() {
-      return err(error);
-    },
-    ...methods
-  };
-}
-function unknownToResultError(error) {
-  return err(unknownToError(error));
-}
-async function asyncUnwrap(result) {
-  const unwrapped = await result;
-  if (unwrapped.ok) {
-    return unwrapped.value;
-  }
-  if (unwrapped.error instanceof Error) {
-    throw unwrapped.error;
-  }
-  throw unknownToError(unwrapped.error);
-}
-function asyncMap(resultPromise) {
-  return {
-    err: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: async ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
-var Result = {
-  ok,
-  err,
-  unknownToError: unknownToResultError,
-  asyncUnwrap,
-  asyncMap,
-  getOkErr
-};
-function resultify(fn, errorNormalizer) {
-  if (!isFunction2(fn)) {
-    return fn.then((value) => ok(value)).catch(
-      (error) => err(
-        errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-      )
-    );
-  }
-  try {
-    const result = fn();
-    if (isPromise2(result)) {
-      return result.then((value) => ok(value)).catch(
-        (error) => err(
-          errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-        )
-      );
-    }
-    return ok(result);
-  } catch (error) {
-    return err(
-      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-    );
-  }
-}
-function unknownToError(error) {
-  if (error instanceof Error) return error;
-  if (typeof error === "string") {
-    return new Error(error);
-  }
-  if (isObject2(error)) {
-    return new Error(
-      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
-      { cause: error }
-    );
-  }
-  return new Error(safeJsonStringify(error) ?? "unknown", {
-    cause: error
-  });
-}
-var typedResult = {
-  ok,
-  err,
-  get _type() {
-    throw new Error("usage as value is not allowed");
-  }
-};
-function getOkErr() {
-  return typedResult;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Result,
-  err,
-  ok,
-  resultify,
-  unknownToError
-});