@ls-stack/utils 3.55.0 → 3.57.0

package/dist/arrayUtils.cjs

@@ -29,9 +29,11 @@ __export(arrayUtils_exports, {
   findBeforeIndex: () => findBeforeIndex,
   getAscIndexOrder: () => getAscIndexOrder,
   hasDuplicates: () => hasDuplicates,
+  intersperse: () => intersperse,
   isInArray: () => isInArray,
   rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
   rejectDuplicates: () => rejectDuplicates,
+  repeat: () => repeat,
   sortBy: () => sortBy,
   truncateArray: () => truncateArray
 });
@@ -176,6 +178,26 @@ function arrayOps(array) {
     findAndMap: (predicate) => findAndMap(array, predicate)
   };
 }
+function intersperse(array, separator) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
+function repeat(value, count, separator) {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(value);
+    if (separator !== void 0 && i < count - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   arrayOps,
@@ -187,9 +209,11 @@ function arrayOps(array) {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
 });

package/dist/arrayUtils.d.cts

@@ -82,25 +82,6 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
-type ArrayOps<T> = {
-    /**
-     * Filter and map an array
-     *
-     * @example
-     *   const items = [1, 2, 3];
-     *
-     *   const enhancedItems = arrayOps(items);
-     *
-     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
-     *
-     * @param mapFilter - A function that takes an item and returns a value or
-     *   `false` to reject the item.
-     */
-    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
-    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
-    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
-    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
-};
 /**
  * Finds the first item in an array where the predicate returns a non-false
  * value and returns that mapped value.
@@ -127,6 +108,25 @@ type ArrayOps<T> = {
  *   item matches
  */
 declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false): R | undefined;
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @example
+     *   const items = [1, 2, 3];
+     *
+     *   const enhancedItems = arrayOps(items);
+     *
+     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
+     *
+     * @param mapFilter - A function that takes an item and returns a value or
+     *   `false` to reject the item.
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
+};
 /**
  * Enhance an array with extra methods
  *
@@ -140,5 +140,30 @@ declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false
  * @param array
  */
 declare function arrayOps<T>(array: T[]): ArrayOps<T>;
+/**
+ * Inserts a separator value between each element in an array.
+ *
+ * @example
+ *   intersperse([1, 2, 3], 0); // [1, 0, 2, 0, 3]
+ *
+ * @param array - The array to intersperse
+ * @param separator - The value to insert between elements
+ * @returns A new array with separator values inserted between elements
+ */
+declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
+/**
+ * Creates an array by repeating a value a specified number of times,
+ * optionally with a separator between each repetition.
+ *
+ * @example
+ *   repeat('x', 3); // ['x', 'x', 'x']
+ *   repeat('x', 3, '-'); // ['x', '-', 'x', '-', 'x']
+ *
+ * @param value - The value to repeat
+ * @param count - Number of times to repeat the value
+ * @param separator - Optional separator to insert between repetitions
+ * @returns A new array with the repeated values
+ */
+declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.d.ts

@@ -82,25 +82,6 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
-type ArrayOps<T> = {
-    /**
-     * Filter and map an array
-     *
-     * @example
-     *   const items = [1, 2, 3];
-     *
-     *   const enhancedItems = arrayOps(items);
-     *
-     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
-     *
-     * @param mapFilter - A function that takes an item and returns a value or
-     *   `false` to reject the item.
-     */
-    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
-    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
-    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
-    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
-};
 /**
  * Finds the first item in an array where the predicate returns a non-false
  * value and returns that mapped value.
@@ -127,6 +108,25 @@ type ArrayOps<T> = {
  *   item matches
  */
 declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false): R | undefined;
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @example
+     *   const items = [1, 2, 3];
+     *
+     *   const enhancedItems = arrayOps(items);
+     *
+     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
+     *
+     * @param mapFilter - A function that takes an item and returns a value or
+     *   `false` to reject the item.
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
+};
 /**
  * Enhance an array with extra methods
  *
@@ -140,5 +140,30 @@ declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false
  * @param array
  */
 declare function arrayOps<T>(array: T[]): ArrayOps<T>;
+/**
+ * Inserts a separator value between each element in an array.
+ *
+ * @example
+ *   intersperse([1, 2, 3], 0); // [1, 0, 2, 0, 3]
+ *
+ * @param array - The array to intersperse
+ * @param separator - The value to insert between elements
+ * @returns A new array with separator values inserted between elements
+ */
+declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
+/**
+ * Creates an array by repeating a value a specified number of times,
+ * optionally with a separator between each repetition.
+ *
+ * @example
+ *   repeat('x', 3); // ['x', 'x', 'x']
+ *   repeat('x', 3, '-'); // ['x', '-', 'x', '-', 'x']
+ *
+ * @param value - The value to repeat
+ * @param count - Number of times to repeat the value
+ * @param separator - Optional separator to insert between repetitions
+ * @returns A new array with the repeated values
+ */
+declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.js

@@ -8,12 +8,14 @@ import {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
@@ -26,9 +28,11 @@ export {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
 };

package/dist/{chunk-27AL66CH.js → chunk-BT3UMATU.js}

@@ -133,6 +133,26 @@ function arrayOps(array) {
     findAndMap: (predicate) => findAndMap(array, predicate)
   };
 }
+function intersperse(array, separator) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
+function repeat(value, count, separator) {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(value);
+    if (separator !== void 0 && i < count - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
 
 export {
   filterAndMap,
@@ -148,5 +168,7 @@ export {
   rejectDuplicates,
   truncateArray,
   findAndMap,
-  arrayOps
+  arrayOps,
+  intersperse,
+  repeat
 };

package/dist/{chunk-6CG6JZKB.js → chunk-LBBC55GE.js}

@@ -1,6 +1,6 @@
 import {
   sortBy
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import {
   isPlainObject
 } from "./chunk-JF2MDHOJ.js";

package/dist/{chunk-Y76LZUOB.js → chunk-WNFRB7P6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GMJTLFM6.js";
 import {
   sortBy
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 
 // src/objUtils.ts
 import { Result } from "t-result";

package/dist/concurrentCalls.js

@@ -1,15 +1,15 @@
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
 import {
   truncateString
 } from "./chunk-BM4PYVOX.js";
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
 import {
   truncateArray
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import {
   invariant
 } from "./chunk-C2SVCIWE.js";

package/dist/filterObjectOrArrayKeys.js

@@ -1,7 +1,7 @@
 import {
   filterObjectOrArrayKeys
-} from "./chunk-6CG6JZKB.js";
-import "./chunk-27AL66CH.js";
+} from "./chunk-LBBC55GE.js";
+import "./chunk-BT3UMATU.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {

package/dist/iteratorUtils.cjs

@@ -0,0 +1,73 @@
+"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/iteratorUtils.ts
+var iteratorUtils_exports = {};
+__export(iteratorUtils_exports, {
+  enumerate: () => enumerate,
+  range: () => range,
+  rangeArray: () => rangeArray,
+  withIsLast: () => withIsLast,
+  withPrevious: () => withPrevious
+});
+module.exports = __toCommonJS(iteratorUtils_exports);
+function* enumerate(iter, start = 0) {
+  let index = start;
+  for (const item of iter) {
+    yield [index, item];
+    index++;
+  }
+}
+function* withIsLast(array) {
+  let index = 0;
+  for (const item of array) {
+    const isLast = index === array.length - 1;
+    yield [isLast, item, index];
+    index++;
+  }
+}
+function* withPrevious(iter) {
+  let prev = void 0;
+  for (const current of iter) {
+    yield { prev, current };
+    prev = current;
+  }
+}
+function* range(start, end, step = 1) {
+  if (start > end) {
+    for (let i = start; i >= end; i -= step) {
+      yield i;
+    }
+  } else {
+    for (let i = start; i <= end; i += step) {
+      yield i;
+    }
+  }
+}
+function rangeArray(start, end, step = 1) {
+  return [...range(start, end, step)];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enumerate,
+  range,
+  rangeArray,
+  withIsLast,
+  withPrevious
+});

package/dist/iteratorUtils.d.cts

@@ -0,0 +1,10 @@
+declare function enumerate<T>(iter: Iterable<T>, start?: number): Generator<[number, T]>;
+declare function withIsLast<T>(array: T[]): Generator<[isLast: boolean, item: T, index: number]>;
+declare function withPrevious<T>(iter: Iterable<T>): Generator<{
+    prev: T | undefined;
+    current: T;
+}>;
+declare function range(start: number, end: number, step?: number): Generator<number>;
+declare function rangeArray(start: number, end: number, step?: number): number[];
+
+export { enumerate, range, rangeArray, withIsLast, withPrevious };

package/dist/iteratorUtils.d.ts

@@ -0,0 +1,10 @@
+declare function enumerate<T>(iter: Iterable<T>, start?: number): Generator<[number, T]>;
+declare function withIsLast<T>(array: T[]): Generator<[isLast: boolean, item: T, index: number]>;
+declare function withPrevious<T>(iter: Iterable<T>): Generator<{
+    prev: T | undefined;
+    current: T;
+}>;
+declare function range(start: number, end: number, step?: number): Generator<number>;
+declare function rangeArray(start: number, end: number, step?: number): number[];
+
+export { enumerate, range, rangeArray, withIsLast, withPrevious };

package/dist/iteratorUtils.js

@@ -0,0 +1,44 @@
+// src/iteratorUtils.ts
+function* enumerate(iter, start = 0) {
+  let index = start;
+  for (const item of iter) {
+    yield [index, item];
+    index++;
+  }
+}
+function* withIsLast(array) {
+  let index = 0;
+  for (const item of array) {
+    const isLast = index === array.length - 1;
+    yield [isLast, item, index];
+    index++;
+  }
+}
+function* withPrevious(iter) {
+  let prev = void 0;
+  for (const current of iter) {
+    yield { prev, current };
+    prev = current;
+  }
+}
+function* range(start, end, step = 1) {
+  if (start > end) {
+    for (let i = start; i >= end; i -= step) {
+      yield i;
+    }
+  } else {
+    for (let i = start; i <= end; i += step) {
+      yield i;
+    }
+  }
+}
+function rangeArray(start, end, step = 1) {
+  return [...range(start, end, step)];
+}
+export {
+  enumerate,
+  range,
+  rangeArray,
+  withIsLast,
+  withPrevious
+};

package/dist/objUtils.js

@@ -9,9 +9,9 @@ import {
   pick,
   rejectObjUndefinedValues,
   sortObjectKeys
-} from "./chunk-Y76LZUOB.js";
+} from "./chunk-WNFRB7P6.js";
 import "./chunk-GMJTLFM6.js";
-import "./chunk-27AL66CH.js";
+import "./chunk-BT3UMATU.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {

package/dist/serializeXML.js

@@ -1,6 +1,6 @@
 import {
   filterAndMap
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import "./chunk-C2SVCIWE.js";
 import {
   isTruthy

package/dist/stringUtils.d.cts

@@ -13,23 +13,41 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
 /** @deprecated Use {@link concatStrings} instead */
 declare const joinStrings: typeof concatStrings;
 declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
+/** Check if a string is `snake_case` */
 declare function isSnakeCase(str: string): boolean;
+/** Check if a string is `kebab-case` */
 declare function isKebabCase(str: string): boolean;
+/** Check if a string is `PascalCase` */
 declare function isPascalCase(str: string): boolean;
+/** Check if a string is `camelCase` */
 declare function isCamelCase(str: string): boolean;
+/** Check if a string is `Title Case` */
 declare function isTitleCase(str: string): boolean;
+/** Check if a string is `Sentence Case` */
 declare function isSentenceCase(str: string): boolean;
+/** Check if a string is `CONSTANT_CASE` */
 declare function isConstantCase(str: string): boolean;
+/** Check if a string is `dot.case` */
 declare function isDotCase(str: string): boolean;
+/** Check if a string is `path/case` */
 declare function isPathCase(str: string): boolean;
+/** Convert a string to `kebab-case` */
 declare function convertToKebabCase(str: string): string;
+/** Convert a string to `snake_case` */
 declare function convertToSnakeCase(str: string): string;
+/** Convert a string to `PascalCase` */
 declare function convertToPascalCase(str: string): string;
+/** Convert a string to `camelCase` */
 declare function convertToCamelCase(str: string): string;
+/** Convert a string to `Sentence Case` */
 declare function convertToSentenceCase(str: string): string;
+/** Convert a string to `Title Case` */
 declare function convertToTitleCase(str: string): string;
+/** Convert a string to `CONSTANT_CASE` */
 declare function convertToConstantCase(str: string): string;
+/** Convert a string to `dot.case` */
 declare function convertToDotCase(str: string): string;
+/** Convert a string to `path/case` */
 declare function convertToPathCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 declare function removeANSIColors(str: string): string;

package/dist/stringUtils.d.ts

@@ -13,23 +13,41 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
 /** @deprecated Use {@link concatStrings} instead */
 declare const joinStrings: typeof concatStrings;
 declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
+/** Check if a string is `snake_case` */
 declare function isSnakeCase(str: string): boolean;
+/** Check if a string is `kebab-case` */
 declare function isKebabCase(str: string): boolean;
+/** Check if a string is `PascalCase` */
 declare function isPascalCase(str: string): boolean;
+/** Check if a string is `camelCase` */
 declare function isCamelCase(str: string): boolean;
+/** Check if a string is `Title Case` */
 declare function isTitleCase(str: string): boolean;
+/** Check if a string is `Sentence Case` */
 declare function isSentenceCase(str: string): boolean;
+/** Check if a string is `CONSTANT_CASE` */
 declare function isConstantCase(str: string): boolean;
+/** Check if a string is `dot.case` */
 declare function isDotCase(str: string): boolean;
+/** Check if a string is `path/case` */
 declare function isPathCase(str: string): boolean;
+/** Convert a string to `kebab-case` */
 declare function convertToKebabCase(str: string): string;
+/** Convert a string to `snake_case` */
 declare function convertToSnakeCase(str: string): string;
+/** Convert a string to `PascalCase` */
 declare function convertToPascalCase(str: string): string;
+/** Convert a string to `camelCase` */
 declare function convertToCamelCase(str: string): string;
+/** Convert a string to `Sentence Case` */
 declare function convertToSentenceCase(str: string): string;
+/** Convert a string to `Title Case` */
 declare function convertToTitleCase(str: string): string;
+/** Convert a string to `CONSTANT_CASE` */
 declare function convertToConstantCase(str: string): string;
+/** Convert a string to `dot.case` */
 declare function convertToDotCase(str: string): string;
+/** Convert a string to `path/case` */
 declare function convertToPathCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 declare function removeANSIColors(str: string): string;

package/dist/testUtils.js

@@ -4,11 +4,11 @@ import {
 import {
   omit,
   pick
-} from "./chunk-Y76LZUOB.js";
+} from "./chunk-WNFRB7P6.js";
 import "./chunk-GMJTLFM6.js";
 import {
   filterObjectOrArrayKeys
-} from "./chunk-6CG6JZKB.js";
+} from "./chunk-LBBC55GE.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual
@@ -26,7 +26,7 @@ import "./chunk-BM4PYVOX.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import {
   isObject
 } from "./chunk-C2SVCIWE.js";

package/dist/timers.cjs

@@ -125,9 +125,11 @@ async function waitFor(condition, { polling, timeout }) {
     cleanup();
     resolve(result);
   }
-  function checkCondition() {
+  async function checkCondition() {
     try {
-      if (condition()) {
+      const result = condition();
+      const conditionMet = result instanceof Promise ? await result : result;
+      if (conditionMet) {
         resolveWith(import_t_result.Result.ok(void 0));
         return true;
       }
@@ -137,30 +139,49 @@ async function waitFor(condition, { polling, timeout }) {
       return true;
     }
   }
-  if (checkCondition()) {
-    return promise;
-  }
-  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;
-      if (!checkCondition()) {
-        rafId = requestAnimationFrame(rafCheck2);
+  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;
       }
-    };
-    var rafCheck = rafCheck2;
-    if (typeof requestAnimationFrame === "undefined") {
-      resolveWith(import_t_result.Result.err(new Error("requestAnimationFrame is not available in this environment")));
-      return promise;
+      rafId = requestAnimationFrame(rafCheck2);
+    } else {
+      intervalId = setInterval(() => {
+        checkCondition().catch(() => {
+        });
+      }, polling);
     }
-    rafId = requestAnimationFrame(rafCheck2);
-  } else {
-    intervalId = setInterval(() => {
-      checkCondition();
-    }, polling);
-  }
+  }).catch(() => {
+  });
   return promise;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/timers.d.cts

@@ -113,7 +113,7 @@ declare function createWaitUntil<T extends NonNullable<unknown>>({ condition, ma
     callback: (value: T) => void;
     checkIntervalMs?: number;
 }): CleanupTimer;
-declare function waitFor(condition: () => boolean, { polling, timeout }: {
+declare function waitFor(condition: () => boolean | Promise<boolean>, { polling, timeout }: {
     polling: number | 'raf';
     timeout: number;
 }): Promise<Result<void, Error>>;

package/dist/timers.d.ts

@@ -113,7 +113,7 @@ declare function createWaitUntil<T extends NonNullable<unknown>>({ condition, ma
     callback: (value: T) => void;
     checkIntervalMs?: number;
 }): CleanupTimer;
-declare function waitFor(condition: () => boolean, { polling, timeout }: {
+declare function waitFor(condition: () => boolean | Promise<boolean>, { polling, timeout }: {
     polling: number | 'raf';
     timeout: number;
 }): Promise<Result<void, Error>>;

package/dist/timers.js

@@ -88,9 +88,11 @@ async function waitFor(condition, { polling, timeout }) {
     cleanup();
     resolve(result);
   }
-  function checkCondition() {
+  async function checkCondition() {
     try {
-      if (condition()) {
+      const result = condition();
+      const conditionMet = result instanceof Promise ? await result : result;
+      if (conditionMet) {
         resolveWith(Result.ok(void 0));
         return true;
       }
@@ -100,30 +102,49 @@ async function waitFor(condition, { polling, timeout }) {
       return true;
     }
   }
-  if (checkCondition()) {
-    return promise;
-  }
-  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;
-      if (!checkCondition()) {
-        rafId = requestAnimationFrame(rafCheck2);
+  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;
       }
-    };
-    var rafCheck = rafCheck2;
-    if (typeof requestAnimationFrame === "undefined") {
-      resolveWith(Result.err(new Error("requestAnimationFrame is not available in this environment")));
-      return promise;
+      rafId = requestAnimationFrame(rafCheck2);
+    } else {
+      intervalId = setInterval(() => {
+        checkCondition().catch(() => {
+        });
+      }, polling);
     }
-    rafId = requestAnimationFrame(rafCheck2);
-  } else {
-    intervalId = setInterval(() => {
-      checkCondition();
-    }, polling);
-  }
+  }).catch(() => {
+  });
   return promise;
 }
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.55.0",
+  "version": "3.57.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -112,6 +112,10 @@
       "import": "./dist/interpolate.js",
       "require": "./dist/interpolate.cjs"
     },
+    "./iteratorUtils": {
+      "import": "./dist/iteratorUtils.js",
+      "require": "./dist/iteratorUtils.cjs"
+    },
     "./keepPrevIfUnchanged": {
       "import": "./dist/keepPrevIfUnchanged.js",
       "require": "./dist/keepPrevIfUnchanged.cjs"