@ls-stack/utils 1.13.2 → 2.0.1

package/dist/consoleFmt.d.cts

@@ -0,0 +1,48 @@
+declare const colorToCodeASCII: {
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    black: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+declare function consoleColors(color: keyof typeof colorToCodeASCII, text: string): string;
+declare function bold(text: string): string;
+declare function underline(text: string): string;
+declare const bgColorToCodeASCII: {
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    black: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+declare function bgColor(color: keyof typeof bgColorToCodeASCII, text: string): string;
+declare const consoleFmt: {
+    color: typeof consoleColors;
+    bold: typeof bold;
+    underline: typeof underline;
+    bgColor: typeof bgColor;
+};
+
+export { consoleFmt };

package/dist/consoleFmt.js

@@ -57,4 +57,3 @@ var consoleFmt = {
 export {
   consoleFmt
 };
-//# sourceMappingURL=consoleFmt.js.map

package/dist/conversions.cjs

@@ -0,0 +1,44 @@
+"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/conversions.ts
+var conversions_exports = {};
+__export(conversions_exports, {
+  bytesToHumanReadable: () => bytesToHumanReadable
+});
+module.exports = __toCommonJS(conversions_exports);
+function bytesToHumanReadable(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(2)} KB`;
+  }
+  const mb = kb / 1024;
+  if (mb < 1024) {
+    return `${mb.toFixed(2)} MB`;
+  }
+  const gb = mb / 1024;
+  return `${gb.toFixed(2)} GB`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bytesToHumanReadable
+});

package/dist/conversions.d.cts

@@ -0,0 +1,3 @@
+declare function bytesToHumanReadable(bytes: number): string;
+
+export { bytesToHumanReadable };

package/dist/conversions.js

@@ -1,7 +1,6 @@
 import {
   bytesToHumanReadable
-} from "./chunk-MMKMF4GG.js";
+} from "./chunk-IATIXMCE.js";
 export {
   bytesToHumanReadable
 };
-//# sourceMappingURL=conversions.js.map

package/dist/createThrottleController.cjs

@@ -0,0 +1,183 @@
+"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/createThrottleController.ts
+var createThrottleController_exports = {};
+__export(createThrottleController_exports, {
+  createThrottleController: () => createThrottleController
+});
+module.exports = __toCommonJS(createThrottleController_exports);
+
+// src/assertions.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/enhancedMap.ts
+var enhancedMapReject = Symbol();
+var EnhancedMap = class _EnhancedMap extends Map {
+  find(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key)) {
+        return { key, value };
+      }
+    }
+    return void 0;
+  }
+  setMultiple(...values) {
+    if (Array.isArray(values[0])) {
+      for (const [key, value] of values) {
+        this.set(key, value);
+      }
+    } else {
+      for (const [key, value] of Object.entries(values[0])) {
+        this.set(key, value);
+      }
+    }
+    return this;
+  }
+  getOrThrow(key) {
+    const value = this.get(key);
+    if (value === void 0) {
+      throw new Error(`Key ${key} not found in EnhancedMap`);
+    }
+    return value;
+  }
+  getOrInsert(key, fallback) {
+    if (!this.has(key)) {
+      this.set(key, fallback());
+    }
+    return this.getOrThrow(key);
+  }
+  toFilteredValues(predicate) {
+    const values = [];
+    for (const [key, value] of this) {
+      if (predicate(value, key)) {
+        values.push(value);
+      }
+    }
+    return values;
+  }
+  toMap(mapFunction) {
+    const values = [];
+    for (const [key, value] of this) {
+      const result = mapFunction(value, key, enhancedMapReject);
+      if (result !== enhancedMapReject) {
+        values.push(result);
+      }
+    }
+    return values;
+  }
+  toObjMap(mapFunction) {
+    const values = {};
+    for (const [key, value] of this) {
+      const result = mapFunction(value, key);
+      if (result) {
+        values[result[0]] = result[1];
+      }
+    }
+    return values;
+  }
+  toValues() {
+    return [...this.values()];
+  }
+  toKeys() {
+    return [...this.keys()];
+  }
+  static from(array, mapFunction) {
+    const map = new _EnhancedMap();
+    if (!array) return map;
+    const isFn = isFunction(mapFunction);
+    for (const item of array) {
+      if (isFn) {
+        const result = mapFunction(item);
+        if (result) {
+          map.set(result[0], result[1]);
+        }
+      } else {
+        const key = item[mapFunction];
+        if (key !== void 0) {
+          map.set(key, item);
+        }
+      }
+    }
+    return map;
+  }
+};
+
+// src/createThrottleController.ts
+function createThrottleController({
+  maxCalls,
+  per,
+  cleanupCheckSecsInterval = 60 * 30
+}) {
+  let msInterval = 0;
+  if (per.ms) {
+    msInterval = per.ms;
+  } else if (per.seconds) {
+    msInterval = per.seconds * 1e3;
+  } else if (per.minutes) {
+    msInterval = per.minutes * 1e3 * 60;
+  } else if (per.hours) {
+    msInterval = per.hours * 1e3 * 60 * 60;
+  }
+  if (msInterval === 0) {
+    throw new Error("Invalid interval");
+  }
+  let lastCleanupCheck = Date.now();
+  const windows = new EnhancedMap();
+  function cleanup(checkTime) {
+    const shouldCleanup = checkTime - lastCleanupCheck > cleanupCheckSecsInterval * 1e3;
+    if (!shouldCleanup) return;
+    setTimeout(() => {
+      const now = Date.now();
+      lastCleanupCheck = now;
+      for (const [key, value] of windows) {
+        if (now - value.windowStartTime > msInterval) {
+          windows.delete(key);
+        }
+      }
+    }, 2);
+  }
+  return {
+    shouldSkip(callId = "") {
+      const now = Date.now();
+      const serializedCallId = String(callId);
+      const window = windows.getOrInsert(serializedCallId, () => ({
+        windowStartTime: now,
+        calls: 0
+      }));
+      if (now - window.windowStartTime > msInterval) {
+        window.windowStartTime = now;
+        window.calls = 0;
+      }
+      window.calls++;
+      cleanup(now);
+      if (window.calls > maxCalls) {
+        return true;
+      }
+      return false;
+    },
+    _currentWindows: windows
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createThrottleController
+});

package/dist/createThrottleController.d.cts

@@ -0,0 +1,16 @@
+type Options = {
+    maxCalls: number;
+    per: {
+        ms?: number;
+        seconds?: number;
+        minutes?: number;
+        hours?: number;
+    };
+    cleanupCheckSecsInterval?: number;
+};
+type ThrottleController = {
+    shouldSkip: (callId?: string | number | (string | number)[]) => boolean;
+};
+declare function createThrottleController({ maxCalls, per, cleanupCheckSecsInterval, }: Options): ThrottleController;
+
+export { createThrottleController };

package/dist/createThrottleController.js

@@ -1,7 +1,7 @@
 import {
   EnhancedMap
-} from "./chunk-4QK76IRX.js";
-import "./chunk-FYMTZQ42.js";
+} from "./chunk-T5WDDPFI.js";
+import "./chunk-4UGSP3L3.js";
 
 // src/createThrottleController.ts
 function createThrottleController({
@@ -62,4 +62,3 @@ function createThrottleController({
 export {
   createThrottleController
 };
-//# sourceMappingURL=createThrottleController.js.map

package/dist/debounce.cjs

@@ -0,0 +1,125 @@
+"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/debounce.ts
+var debounce_exports = {};
+__export(debounce_exports, {
+  debounce: () => debounce,
+  isDebouncedFn: () => isDebouncedFn
+});
+module.exports = __toCommonJS(debounce_exports);
+function debounce(func, wait, options) {
+  let lastArgs;
+  let lastThis;
+  let maxWait;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  let leading = false;
+  let maxing = false;
+  let trailing = true;
+  if (options) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced() {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isDebouncedFn(fn) {
+  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounce,
+  isDebouncedFn
+});

package/dist/debounce.d.cts

@@ -0,0 +1,45 @@
+type DebounceOptions = {
+    /**
+     * @see _.leading
+     */
+    leading?: boolean;
+    /**
+     * @see _.maxWait
+     */
+    maxWait?: number;
+    /**
+     * @see _.trailing
+     */
+    trailing?: boolean;
+};
+interface DebouncedFunc<T extends (...args: any[]) => void> {
+    /**
+     * Call the original function, but applying the debounce rules.
+     *
+     * If the debounced function can be run immediately, this calls it and returns its return
+     * value.
+     *
+     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
+     * function was not invoked yet.
+     */
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Throw away any pending invocation of the debounced function.
+     */
+    cancel: () => void;
+    /**
+     * If there is a pending invocation of the debounced function, invoke it immediately and return
+     * its return value.
+     *
+     * Otherwise, return the value from the last invocation, or undefined if the debounced function
+     * was never invoked.
+     */
+    flush: () => ReturnType<T> | undefined;
+}
+declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number, options?: DebounceOptions): DebouncedFunc<T>;
+declare function isDebouncedFn<T extends (...args: any[]) => void>(fn: T): fn is T & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+
+export { type DebounceOptions, type DebouncedFunc, debounce, isDebouncedFn };

package/dist/debounce.js

@@ -97,4 +97,3 @@ export {
   debounce,
   isDebouncedFn
 };
-//# sourceMappingURL=debounce.js.map

package/dist/dedent.cjs

@@ -0,0 +1,57 @@
+"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/dedent.ts
+var dedent_exports = {};
+__export(dedent_exports, {
+  dedent: () => dedent
+});
+module.exports = __toCommonJS(dedent_exports);
+function dedent(strings, ...values) {
+  const raw = typeof strings === "string" ? [strings] : strings.raw;
+  let result = "";
+  for (let i = 0; i < raw.length; i++) {
+    result += raw[i].replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`");
+    if (i < values.length) {
+      result += values[i];
+    }
+  }
+  const lines = result.split("\n");
+  let mindent = null;
+  lines.forEach((l) => {
+    const m = l.match(/^(\s+)\S+/);
+    if (m) {
+      const indent = m[1].length;
+      if (!mindent) {
+        mindent = indent;
+      } else {
+        mindent = Math.min(mindent, indent);
+      }
+    }
+  });
+  if (mindent !== null) {
+    const m = mindent;
+    result = lines.map((l) => l.startsWith(" ") ? l.slice(m) : l).join("\n");
+  }
+  return result.trim().replace(/\\n/g, "\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dedent
+});

package/dist/dedent.d.cts

@@ -0,0 +1,4 @@
+declare function dedent(strings: TemplateStringsArray, ...values: string[]): string;
+declare function dedent(strings: string): string;
+
+export { dedent };

package/dist/dedent.js

@@ -30,4 +30,3 @@ function dedent(strings, ...values) {
 export {
   dedent
 };
-//# sourceMappingURL=dedent.js.map

package/dist/deepEqual.cjs

@@ -0,0 +1,88 @@
+"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/deepEqual.ts
+var deepEqual_exports = {};
+__export(deepEqual_exports, {
+  deepEqual: () => deepEqual
+});
+module.exports = __toCommonJS(deepEqual_exports);
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys()) {
+    if (deepEqual(key, tar)) return key;
+  }
+}
+function deepEqual(foo, bar) {
+  let ctor, len, tmp;
+  if (foo === bar) return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime());
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && deepEqual(foo[len], bar[len])) ;
+      }
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp) return false;
+        }
+        if (!bar.has(tmp)) return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp) return false;
+        }
+        if (!deepEqual(len[1], bar.get(tmp))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deepEqual
+});

package/dist/deepEqual.d.cts

@@ -0,0 +1,4 @@
+/** forked from https://github.com/lukeed/dequal to consider invalid dates as equal */
+declare function deepEqual(foo: any, bar: any): boolean;
+
+export { deepEqual };

package/dist/deepEqual.js

@@ -1,7 +1,6 @@
 import {
   deepEqual
-} from "./chunk-M74KKYE4.js";
+} from "./chunk-KCOXGSRA.js";
 export {
   deepEqual
 };
-//# sourceMappingURL=deepEqual.js.map