@ls-stack/utils 1.13.1 → 2.0.0

package/dist/shallowEqual.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/shallowEqual.ts
+var shallowEqual_exports = {};
+__export(shallowEqual_exports, {
+  shallowEqual: () => shallowEqual
+});
+module.exports = __toCommonJS(shallowEqual_exports);
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys()) {
+    if (key === tar) return key;
+  }
+}
+function shallowEqual(foo, bar) {
+  var ctor, len, tmp;
+  if (foo === bar) return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return shallowEqual(foo.getTime(), bar.getTime());
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && 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 (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) || !(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 = {
+  shallowEqual
+});

package/dist/shallowEqual.d.cts

@@ -0,0 +1,4 @@
+/** shallow equal version of https://github.com/lukeed/dequal */
+declare function shallowEqual(foo: any, bar: any): boolean;
+
+export { shallowEqual };

package/dist/shallowEqual.js

@@ -61,4 +61,3 @@ function shallowEqual(foo, bar) {
 export {
   shallowEqual
 };
-//# sourceMappingURL=shallowEqual.js.map

package/dist/sleep.cjs

@@ -0,0 +1,32 @@
+"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/sleep.ts
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sleep
+});

package/dist/sleep.d.cts

@@ -0,0 +1,3 @@
+declare function sleep(ms: number): Promise<unknown>;
+
+export { sleep };

package/dist/sleep.js

@@ -1,7 +1,6 @@
 import {
   sleep
-} from "./chunk-HLFWWIDK.js";
+} from "./chunk-5DZT3Z5Z.js";
 export {
   sleep
 };
-//# sourceMappingURL=sleep.js.map

package/dist/stringUtils.cjs

@@ -0,0 +1,66 @@
+"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/stringUtils.ts
+var stringUtils_exports = {};
+__export(stringUtils_exports, {
+  convertToSnakeCase: () => convertToSnakeCase,
+  formatNum: () => formatNum,
+  isSnakeCase: () => isSnakeCase,
+  joinStrings: () => joinStrings,
+  truncateString: () => truncateString
+});
+module.exports = __toCommonJS(stringUtils_exports);
+function joinStrings(...args) {
+  const strings = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (Array.isArray(arg)) {
+      strings.push(joinStrings(...arg));
+      continue;
+    }
+    strings.push(arg);
+  }
+  return strings.join("");
+}
+function formatNum(num) {
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+}
+function isSnakeCase(str) {
+  return /^[a-z0-9_]+$/.test(str);
+}
+function convertToSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").replace(/[^a-z0-9_]/g, "").toLowerCase();
+}
+function truncateString(str, length, ellipsis = "\u2026") {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 1) + ellipsis;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToSnakeCase,
+  formatNum,
+  isSnakeCase,
+  joinStrings,
+  truncateString
+});

package/dist/stringUtils.d.cts

@@ -0,0 +1,16 @@
+type Arg = string | false | undefined | null;
+/**
+ * A util to create more legible conditional concatenated strings
+ *
+ * @example
+ * joinStrings('a', 'b', 'c') // 'abc'
+ * joinStrings('a', false, 'c') // 'ac'
+ * joinStrings('a', addBString ? 'b' : null, 'c') // 'ac' if addBString is false, 'abc' if addBString is true
+ */
+declare function joinStrings(...args: (Arg | Arg[])[]): string;
+declare function formatNum(num: number): string;
+declare function isSnakeCase(str: string): boolean;
+declare function convertToSnakeCase(str: string): string;
+declare function truncateString(str: string, length: number, ellipsis?: string): string;
+
+export { convertToSnakeCase, formatNum, isSnakeCase, joinStrings, truncateString };

package/dist/stringUtils.d.ts

@@ -8,11 +8,9 @@ type Arg = string | false | undefined | null;
  * joinStrings('a', addBString ? 'b' : null, 'c') // 'ac' if addBString is false, 'abc' if addBString is true
  */
 declare function joinStrings(...args: (Arg | Arg[])[]): string;
-declare function dedent(strings: string): string;
-declare function dedent(strings: TemplateStringsArray, ...values: string[]): string;
 declare function formatNum(num: number): string;
 declare function isSnakeCase(str: string): boolean;
 declare function convertToSnakeCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 
-export { convertToSnakeCase, dedent, formatNum, isSnakeCase, joinStrings, truncateString };
+export { convertToSnakeCase, formatNum, isSnakeCase, joinStrings, truncateString };

package/dist/stringUtils.js

@@ -1,17 +1,14 @@
 import {
   convertToSnakeCase,
-  dedent,
   formatNum,
   isSnakeCase,
   joinStrings,
   truncateString
-} from "./chunk-GLZ5MZC5.js";
+} from "./chunk-V2L472LS.js";
 export {
   convertToSnakeCase,
-  dedent,
   formatNum,
   isSnakeCase,
   joinStrings,
   truncateString
 };
-//# sourceMappingURL=stringUtils.js.map

package/dist/testUtils.cjs

@@ -0,0 +1,357 @@
+"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/testUtils.ts
+var testUtils_exports = {};
+__export(testUtils_exports, {
+  createLoggerStore: () => createLoggerStore,
+  getResultFn: () => getResultFn
+});
+module.exports = __toCommonJS(testUtils_exports);
+
+// src/arrayUtils.ts
+function filterAndMap(array, mapFilter) {
+  const result = [];
+  let i = -1;
+  for (const item of array) {
+    i += 1;
+    const filterResult = mapFilter(item, i);
+    if (filterResult !== false) {
+      result.push(filterResult);
+    }
+  }
+  return result;
+}
+function arrayWithPrevAndIndex(array) {
+  return array.map((item, i) => ({
+    item,
+    prev: array[i - 1] ?? null,
+    index: i
+  }));
+}
+
+// src/assertions.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/deepEqual.ts
+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;
+}
+
+// src/mathUtils.ts
+function clampMin(value, min) {
+  return value < min ? min : value;
+}
+
+// src/objUtils.ts
+function pick(obj, keys, rename) {
+  const result = {};
+  if (!obj) {
+    return result;
+  }
+  for (const key of keys) {
+    result[rename?.[key] || key] = obj[key];
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// src/testUtils.ts
+function createLoggerStore({
+  filterKeys: defaultFilterKeys,
+  rejectKeys: defaultRejectKeys,
+  splitLongLines: defaultSplitLongLines = true,
+  maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit = 80,
+  fromLastSnapshot: defaultFromLastSnapshot = false,
+  arrays: defaultArrays = { firstNItems: 1 },
+  changesOnly: defaultChangesOnly = false,
+  useEmojiForBooleans: defaultUseEmojiForBooleans = true
+} = {}) {
+  let logs = [];
+  let logsTime = [];
+  let startTime = Date.now();
+  let onNextLog = () => {
+  };
+  function reset(keepLastRender = false) {
+    logs = keepLastRender ? [logs.at(-1)] : [];
+    logsTime = [];
+    startTime = Date.now();
+  }
+  function add(render) {
+    if (!isObject(render)) {
+      for (const [i, r] of render.entries()) {
+        logs.push({
+          i: i + 1,
+          ...r
+        });
+        logsTime.push(Date.now() - startTime);
+      }
+    } else {
+      logs.push(render);
+      logsTime.push(Date.now() - startTime);
+    }
+    onNextLog();
+    if (logs.length > 100) {
+      throw new Error("Too many logs");
+    }
+  }
+  function logsCount() {
+    return logs.filter((item) => !item._lastSnapshotMark).length;
+  }
+  async function waitNextLog(timeout = 50) {
+    return new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        throw new Error("Timeout");
+      }, timeout);
+      onNextLog = () => {
+        clearTimeout(timeoutId);
+        resolve();
+      };
+    });
+  }
+  function getSnapshot({
+    arrays = defaultArrays,
+    changesOnly = defaultChangesOnly,
+    filterKeys = defaultFilterKeys,
+    rejectKeys = defaultRejectKeys,
+    includeLastSnapshotEndMark = true,
+    splitLongLines = defaultSplitLongLines,
+    maxLineLengthBeforeSplit = defaultMaxLineLengthBeforeSplit,
+    fromLastSnapshot = defaultFromLastSnapshot,
+    useEmojiForBooleans = defaultUseEmojiForBooleans
+  } = {}) {
+    let rendersToUse = logs;
+    if (changesOnly || filterKeys || rejectKeys) {
+      rendersToUse = [];
+      for (let { item, prev } of arrayWithPrevAndIndex(logs)) {
+        if (item._lastSnapshotMark || item._mark) {
+          rendersToUse.push(item);
+          continue;
+        }
+        if (filterKeys) {
+          prev = prev && pick(prev, filterKeys);
+          item = pick(item, filterKeys);
+        }
+        if (rejectKeys) {
+          prev = prev && omit(prev, rejectKeys);
+          item = omit(item, rejectKeys);
+        }
+        if (!deepEqual(prev, item)) {
+          rendersToUse.push(item);
+        }
+      }
+    }
+    if (fromLastSnapshot) {
+      const lastSnapshotMark = rendersToUse.findLastIndex(
+        (item) => item._lastSnapshotMark === true
+      );
+      rendersToUse = rendersToUse.slice(clampMin(lastSnapshotMark, 0));
+    }
+    logs.push({ _lastSnapshotMark: true });
+    const propDivider = "\u22C5";
+    const snapShot = `
+${filterAndMap(rendersToUse, (render, i) => {
+      if (render._lastSnapshotMark) {
+        if (includeLastSnapshotEndMark) {
+          if (rendersToUse.length === 1) {
+            return "\u22C5\u22C5\u22C5";
+          }
+          if (i !== rendersToUse.length - 1) {
+            return "\u22C5\u22C5\u22C5";
+          }
+          return false;
+        } else {
+          return false;
+        }
+      }
+      if (render._mark) {
+        const prevIsLastSnapshotMark = rendersToUse[i - 1]?._lastSnapshotMark;
+        let mark = `${prevIsLastSnapshotMark ? "" : "\n"}>>> ${String(render._mark)}`;
+        const nextRender = rendersToUse[i + 1];
+        if (nextRender && !nextRender._mark && !nextRender._lastSnapshotMark) {
+          mark = `${mark}
+`;
+        }
+        return mark;
+      }
+      let line = "";
+      for (const [key, _value] of Object.entries(render)) {
+        let value = _value;
+        if (Array.isArray(value)) {
+          if (arrays === "length") {
+            value = `Array(${value.length})`;
+          } else if (arrays === "firstAndLast" && value.length > 2) {
+            const intermediateSize = clampMin(value.length - 2, 0);
+            value = [value[0], `\u2026(${intermediateSize} between)`, value.at(-1)];
+          } else if (typeof arrays === "object" && value.length > 2) {
+            value = [
+              ...value.slice(0, arrays.firstNItems),
+              `\u2026(${value.length - arrays.firstNItems} more)`
+            ];
+          }
+        }
+        if (typeof value === "boolean" && useEmojiForBooleans) {
+          value = value ? "\u2705" : "\u274C";
+        }
+        if (value === "") {
+          value = `''`;
+        }
+        if (typeof value === "object" && value !== null) {
+          value = JSON.stringify(value).replace(/:true/g, ":\u2705").replace(/:false/g, ":\u274C").replace(/:""/g, ":''").replace(/"/g, "").replace(/,/g, ", ");
+        }
+        line += `${key}: ${value} ${propDivider} `;
+      }
+      line = line.slice(0, (propDivider.length + 2) * -1);
+      if (splitLongLines && line.length > maxLineLengthBeforeSplit) {
+        const parts = line.split(` ${propDivider} `);
+        if (parts.length === 1) {
+          return line;
+        }
+        line = "";
+        const propDividerML = "\u22C5";
+        for (const { item, index } of arrayWithPrevAndIndex(parts)) {
+          if (index === 0) {
+            line += `\u250C\u2500
+${propDividerML} `;
+          } else if (index === parts.length - 1) {
+            line += `${propDividerML} `;
+          } else {
+            line += `${propDividerML} `;
+          }
+          line += `${item}
+`;
+          if (index === parts.length - 1) {
+            line += "\u2514\u2500";
+          }
+        }
+      } else {
+        line = `-> ${line}`;
+      }
+      return line;
+    }).join("\n")}
+`;
+    return snapShot === `
+\u22C5\u22C5\u22C5
+` ? "\u22C5\u22C5\u22C5empty\u22C5\u22C5\u22C5" : snapShot;
+  }
+  function addMark(label) {
+    add({ _mark: label });
+  }
+  return {
+    add,
+    reset,
+    getSnapshot,
+    waitNextLog,
+    get changesSnapshot() {
+      return getSnapshot({ changesOnly: true });
+    },
+    get snapshot() {
+      return getSnapshot();
+    },
+    get snapshotFromLast() {
+      return getSnapshot({ fromLastSnapshot: true });
+    },
+    logsCount,
+    get rendersTime() {
+      return logsTime;
+    },
+    addMark
+  };
+}
+function getResultFn(fnGetter, wrapper) {
+  return (...args) => {
+    const fn = fnGetter();
+    if (wrapper) {
+      return wrapper(fn(...args));
+    } else {
+      return fn(...args);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLoggerStore,
+  getResultFn
+});

package/dist/testUtils.d.cts

@@ -0,0 +1,38 @@
+declare function createLoggerStore({ filterKeys: defaultFilterKeys, rejectKeys: defaultRejectKeys, splitLongLines: defaultSplitLongLines, maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit, fromLastSnapshot: defaultFromLastSnapshot, arrays: defaultArrays, changesOnly: defaultChangesOnly, useEmojiForBooleans: defaultUseEmojiForBooleans, }?: {
+    filterKeys?: string[];
+    rejectKeys?: string[];
+    splitLongLines?: true;
+    maxLineLengthBeforeSplit?: number;
+    fromLastSnapshot?: boolean;
+    arrays?: 'all' | 'firstAndLast' | 'length' | {
+        firstNItems: number;
+    };
+    changesOnly?: boolean;
+    useEmojiForBooleans?: boolean;
+}): {
+    add: (render: Record<string, unknown> | readonly Record<string, unknown>[]) => void;
+    reset: (keepLastRender?: boolean) => void;
+    getSnapshot: ({ arrays, changesOnly, filterKeys, rejectKeys, includeLastSnapshotEndMark, splitLongLines, maxLineLengthBeforeSplit, fromLastSnapshot, useEmojiForBooleans, }?: {
+        arrays?: "all" | "firstAndLast" | "length" | {
+            firstNItems: number;
+        };
+        changesOnly?: boolean;
+        filterKeys?: string[];
+        rejectKeys?: string[];
+        includeLastSnapshotEndMark?: boolean;
+        splitLongLines?: boolean;
+        maxLineLengthBeforeSplit?: number;
+        fromLastSnapshot?: boolean;
+        useEmojiForBooleans?: boolean;
+    }) => string;
+    waitNextLog: (timeout?: number) => Promise<void>;
+    readonly changesSnapshot: string;
+    readonly snapshot: string;
+    readonly snapshotFromLast: string;
+    logsCount: () => number;
+    readonly rendersTime: number[];
+    addMark: (label: string) => void;
+};
+declare function getResultFn<T extends (...args: any[]) => any>(fnGetter: () => T, wrapper?: (...args: any[]) => any): T;
+
+export { createLoggerStore, getResultFn };