@ls-stack/utils 3.56.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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.56.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"