@rudderstack/integrations-lib 0.2.33 → 0.2.34

package/build/utils/batch-processing.bench.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch-processing.bench.d.ts.map

package/build/utils/batch-processing.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processing.bench.d.ts","sourceRoot":"","sources":["../../src/utils/batch-processing.bench.ts"],"names":[],"mappings":""}

package/build/utils/batch-processing.bench.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const node_perf_hooks_1 = require("node:perf_hooks");
+const lodash_1 = __importDefault(require("lodash"));
+const batch_processing_1 = require("./batch-processing");
+async function bench(fn, label, iterations = 5) {
+    let total = 0;
+    for (let i = 0; i < iterations; i += 1) {
+        const start = node_perf_hooks_1.performance.now();
+        // eslint-disable-next-line no-await-in-loop
+        await fn();
+        total += node_perf_hooks_1.performance.now() - start;
+    }
+    const avg = total / iterations;
+    console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);
+    return avg;
+}
+async function section(title, fn) {
+    console.log(`\n=== ${title} ===`);
+    await fn();
+}
+async function runBenchmarks() {
+    const arr = Array.from({ length: 10_000 }, (_, i) => i);
+    console.log(`Running benchmarks on array of length ${arr.length}`);
+    await section('map', async () => {
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }), 'mapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.map(arr, (x) => x + 1)), 'lodash.map');
+        await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');
+    });
+    await section('filter', async () => {
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }), 'filterInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');
+        await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');
+    });
+    await section('groupBy', async () => {
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))), 'lodash.groupBy');
+    });
+    await section('reduce', async () => {
+        await bench(() => (0, batch_processing_1.reduceInBatches)(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }), 'reduceInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => Promise.resolve(lodash_1.default.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');
+        await bench(() => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)), 'Array.prototype.reduce');
+    });
+    await section('flatMap', async () => {
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');
+        await bench(() => Promise.resolve(arr.flatMap
+            ? arr.flatMap((x) => [x, x])
+            : [].concat(...arr.map((x) => [x, x]))), 'Array.prototype.flatMap');
+    });
+    await section('forEach', async () => {
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, { batchSize: 20, yieldThreshold: 10 }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(arr.forEach(() => { })), 'Array.prototype.forEach');
+        await bench(() => Promise.resolve(lodash_1.default.forEach(arr, () => { })), 'lodash.forEach');
+    });
+}
+// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts
+if (require.main === module) {
+    runBenchmarks().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.bench.js","sourceRoot":"","sources":["../../src/utils/batch-processing.bench.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport { performance } from 'node:perf_hooks';\nimport lodash from 'lodash';\nimport {\n  mapInBatches,\n  filterInBatches,\n  groupByInBatches,\n  reduceInBatches,\n  flatMapInBatches,\n  forEachInBatches,\n} from './batch-processing';\n\nasync function bench(\n  fn: () => Promise<unknown> | unknown,\n  label: string,\n  iterations = 5,\n): Promise<number> {\n  let total = 0;\n  for (let i = 0; i < iterations; i += 1) {\n    const start = performance.now();\n    // eslint-disable-next-line no-await-in-loop\n    await fn();\n    total += performance.now() - start;\n  }\n  const avg = total / iterations;\n  console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);\n  return avg;\n}\n\nasync function section(title: string, fn: () => Promise<void>) {\n  console.log(`\\n=== ${title} ===`);\n  await fn();\n}\n\nasync function runBenchmarks() {\n  const arr = Array.from({ length: 10_000 }, (_, i) => i);\n\n  console.log(`Running benchmarks on array of length ${arr.length}`);\n\n  await section('map', async () => {\n    await bench(\n      () => mapInBatches(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        mapInBatches(arr, (x) => x + 1, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.map(arr, (x) => x + 1)), 'lodash.map');\n    await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');\n  });\n\n  await section('filter', async () => {\n    await bench(\n      () => filterInBatches(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        filterInBatches(arr, (x) => x % 2 === 0, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');\n    await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');\n  });\n\n  await section('groupBy', async () => {\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(\n      () => Promise.resolve(lodash.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))),\n      'lodash.groupBy',\n    );\n  });\n\n  await section('reduce', async () => {\n    await bench(\n      () => reduceInBatches(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }),\n      'reduceInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(() => Promise.resolve(lodash.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');\n    await bench(\n      () => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)),\n      'Array.prototype.reduce',\n    );\n  });\n\n  await section('flatMap', async () => {\n    await bench(\n      () => flatMapInBatches(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        flatMapInBatches(arr, (x) => [x, x], {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');\n    await bench(\n      () =>\n        Promise.resolve(\n          arr.flatMap\n            ? arr.flatMap((x) => [x, x])\n            : ([] as number[]).concat(...arr.map((x) => [x, x])),\n        ),\n      'Array.prototype.flatMap',\n    );\n  });\n\n  await section('forEach', async () => {\n    await bench(\n      () => forEachInBatches(arr, () => {}, { batchSize: 20, yieldThreshold: 10 }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        forEachInBatches(arr, () => {}, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(arr.forEach(() => {})), 'Array.prototype.forEach');\n    await bench(() => Promise.resolve(lodash.forEach(arr, () => {})), 'lodash.forEach');\n  });\n}\n\n// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts\nif (require.main === module) {\n  runBenchmarks().catch((err) => {\n    console.error(err);\n    process.exit(1);\n  });\n}\n"]}

package/build/utils/batch-processing.d.ts

@@ -1,15 +1,23 @@
 /**
- * Configuration options for batch processing operations
+ * Options for batch processing operations
  */
-export interface BatchProcessingDefaults {
+export interface BatchProcessingOptions {
     /**
-     * Default number of items to process in each batch
+     * Number of items to process in each batch (default: 10)
+     * Must be a positive integer.
      */
     batchSize?: number;
     /**
-     * Default time threshold in milliseconds before yielding control back to the event loop
+     * Time threshold in milliseconds (default: 10) before yielding control back to the event loop.
+     * Set to 0 to yield after every batch. Must be a non-negative integer.
      */
     yieldThreshold?: number;
+    /**
+     * Whether to process items sequentially within each batch. When true (default), each item in a batch
+     * will be processed one at a time. When false, all items in a batch will be processed concurrently.
+     * Consider the implications of concurrency on your processing logic before setting this to false, e.g. race conditions, rate limits, memory pressure, etc.
+     */
+    sequentialProcessing?: boolean;
 }
 /**
  * Configure global defaults for batch processing operations
@@ -25,11 +33,14 @@ export interface BatchProcessingDefaults {
  * // Set only batch size
  * configureBatchProcessingDefaults({ batchSize: 50 });
  *
+ * // Enable concurrent processing within batches
+ * configureBatchProcessingDefaults({ sequentialProcessing: false });
+ *
  * // Get current configuration
  * const currentConfig = configureBatchProcessingDefaults();
  * ```
  */
-export declare function configureBatchProcessingDefaults(config?: BatchProcessingDefaults): BatchProcessingDefaults;
+export declare function configureBatchProcessingDefaults(config?: BatchProcessingOptions): BatchProcessingOptions;
 /**
  * Maps over an array in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
@@ -39,26 +50,20 @@ export declare function configureBatchProcessingDefaults(config?: BatchProcessin
  * @template R - The type of items in the result array
  * @param items - The array to map over
  * @param mapFn - The mapping function to apply to each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the mapped array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Synchronous mapping
- * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);
- * // Result: [2, 4, 6, 8]
- *
- * // Asynchronous mapping
- * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);
+ * // Synchronous mapping with default options (sequential processing)
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);
  *
- * // With index
- * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);
- * // Result: ['a-0', 'b-1']
+ * // With concurrent processing within batches
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });
  * ```
  */
-export declare function mapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R | Promise<R>, batchSize?: number, yieldThreshold?: number): Promise<R[]>;
+export declare function mapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R | Promise<R>, options?: BatchProcessingOptions): Promise<R[]>;
 /**
  * Filters an array in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
@@ -67,29 +72,21 @@ export declare function mapInBatches<T, R>(items: T[], mapFn: (item: T, index: n
  * @template T - The type of items in the array
  * @param items - The array to filter
  * @param predicate - The predicate function to test each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the filtered array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Synchronous filtering
- * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);
+ * // Synchronous filtering with default options
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);
  * // Result: [2, 4]
  *
- * // Asynchronous filtering
- * const valid = await filterInBatches(urls, async (url) => {
- *   const response = await fetch(url);
- *   return response.ok;
- * }, 3);
- *
- * // With index
- * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);
- * // Result: ['a', 'c']
+ * // With custom batch size
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });
  * ```
  */
-export declare function filterInBatches<T>(items: T[], predicate: (item: T, index: number) => boolean | Promise<boolean>, batchSize?: number, yieldThreshold?: number): Promise<T[]>;
+export declare function filterInBatches<T>(items: T[], predicate: (item: T, index: number) => boolean | Promise<boolean>, options?: BatchProcessingOptions): Promise<T[]>;
 /**
  * Groups an array by a key function in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
@@ -99,73 +96,54 @@ export declare function filterInBatches<T>(items: T[], predicate: (item: T, inde
  * @template K - The type of the grouping key (must extend PropertyKey)
  * @param items - The array to group
  * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to an object with grouped items
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Group by property
+ * // Group by property with default options
  * const byType = await groupByInBatches(
  *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
- *   (item) => item.type,
- *   2
+ *   (item) => item.type
  * );
  * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
  *
- * // Group by computed value
- * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');
- * // Result: {odd: [1, 3], even: [2, 4]}
- *
- * // Asynchronous key function
- * const byCategory = await groupByInBatches(items, async (item) => {
- *   return await getCategoryForItem(item);
- * });
+ * // With custom batch size
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   { batchSize: 2 }
+ * );
  * ```
  */
-export declare function groupByInBatches<T, K extends PropertyKey>(items: T[], keyFn: (item: T, index: number) => K | Promise<K>, batchSize?: number, yieldThreshold?: number): Promise<Record<K, T[]>>;
+export declare function groupByInBatches<T, K extends PropertyKey>(items: T[], keyFn: (item: T, index: number) => K | Promise<K>, options?: BatchProcessingOptions): Promise<Record<K, T[]>>;
 /**
  * Reduces an array in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
- * when the processing time exceeds the threshold.
+ * when the processing time exceeds the threshold. Sequential processing is always used for the reducer function,
+ * irrespective of the `sequentialProcessing` option.
  *
  * @template T - The type of items in the array
  * @template R - The type of the accumulator/result
  * @param items - The array to reduce
  * @param reducer - The reducer function. Receives the accumulator, current item, and index.
  * @param initialValue - The initial value for the accumulator
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the reduced value
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Sum numbers
- * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);
+ * // Sum numbers with default options
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);
  * // Result: 10
  *
- * // Concatenate strings
- * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');
- * // Result: 'abc'
- *
- * // Build object with index
- * const indexed = await reduceInBatches(
- *   ['x', 'y'],
- *   (acc, item, index) => ({ ...acc, [index]: item }),
- *   {}
- * );
- * // Result: {0: 'x', 1: 'y'}
- *
- * // Asynchronous reducer
- * const processed = await reduceInBatches(urls, async (acc, url) => {
- *   const data = await fetch(url).then(r => r.json());
- *   return [...acc, data];
- * }, []);
+ * // With custom batch size
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });
  * ```
  */
-export declare function reduceInBatches<T, R>(items: T[], reducer: (acc: R, item: T, index: number) => R | Promise<R>, initialValue: R, batchSize?: number, yieldThreshold?: number): Promise<R>;
+export declare function reduceInBatches<T, R>(items: T[], reducer: (acc: R, item: T, index: number) => R | Promise<R>, initialValue: R, options?: BatchProcessingOptions): Promise<R>;
 /**
  * FlatMaps an array in batches to avoid blocking the event loop.
  * Processes items in chunks, flattens the results, and yields control back to the event loop between batches
@@ -175,31 +153,45 @@ export declare function reduceInBatches<T, R>(items: T[], reducer: (acc: R, item
  * @template R - The type of items in the flattened result array
  * @param items - The array to flatMap over
  * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the flattened mapped array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Duplicate each item
- * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);
+ * // Duplicate each item with default options
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);
  * // Result: [1, 1, 2, 2, 3, 3]
  *
- * // Variable length results
- * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));
- * // Result: [1, 2, 2, 3, 3, 3]
+ * // With custom batch size
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });
+ * ```
+ */
+export declare function flatMapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R[] | Promise<R[]>, options?: BatchProcessingOptions): Promise<R[]>;
+/**
+ * forEach over an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
  *
- * // Split strings into characters
- * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));
- * // Result: ['a', 'b', 'c', 'd']
+ * @template T - The type of items in the input array
+ * @param items - The array to iterate over
+ * @param fn - The function to apply to each item. Receives the item and its index. Can be async.
+ * @param options - Batch processing options
+ * @returns A promise that resolves when all items have been processed
+ * @throws {Error} When batchSize is not a positive integer
  *
- * // Asynchronous mapping
- * const expanded = await flatMapInBatches(categories, async (category) => {
- *   const items = await fetchItemsForCategory(category);
- *   return items;
+ * @example
+ * ```typescript
+ * // Process items in batches with default options
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
  * });
+ *
+ * // With custom batch size
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * }, { batchSize: 2 });
  * ```
  */
-export declare function flatMapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R[] | Promise<R[]>, batchSize?: number, yieldThreshold?: number): Promise<R[]>;
+export declare function forEachInBatches<T>(items: T[], fn: (item: T, index: number) => void | Promise<void>, options?: BatchProcessingOptions): Promise<void>;
 //# sourceMappingURL=batch-processing.d.ts.map

package/build/utils/batch-processing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-processing.d.ts","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,CAAC,EAAE,uBAAuB,GAC/B,uBAAuB,CAqBzB;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAmBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACjE,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAqBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACvD,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAiCzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC3D,YAAY,EAAE,CAAC,EACf,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EACrD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAoBd"}
+{"version":3,"file":"batch-processing.d.ts","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,CAAC,EAAE,sBAAsB,GAC9B,sBAAsB,CA0BxB;AAoFD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAqBd;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACjE,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAuBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACvD,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0BzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC3D,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EACrD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAuBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAef"}

package/build/utils/batch-processing.js

@@ -6,9 +6,11 @@ exports.filterInBatches = filterInBatches;
 exports.groupByInBatches = groupByInBatches;
 exports.reduceInBatches = reduceInBatches;
 exports.flatMapInBatches = flatMapInBatches;
+exports.forEachInBatches = forEachInBatches;
 // Default configuration values (internal)
 let defaultBatchSize = 10;
 let defaultYieldThreshold = 10;
+let defaultSequentialProcessing = true;
 /**
  * Configure global defaults for batch processing operations
  *
@@ -23,6 +25,9 @@ let defaultYieldThreshold = 10;
  * // Set only batch size
  * configureBatchProcessingDefaults({ batchSize: 50 });
  *
+ * // Enable concurrent processing within batches
+ * configureBatchProcessingDefaults({ sequentialProcessing: false });
+ *
  * // Get current configuration
  * const currentConfig = configureBatchProcessingDefaults();
  * ```
@@ -41,10 +46,14 @@ function configureBatchProcessingDefaults(config) {
             }
             defaultYieldThreshold = config.yieldThreshold;
         }
+        if (config.sequentialProcessing !== undefined) {
+            defaultSequentialProcessing = Boolean(config.sequentialProcessing);
+        }
     }
     return {
         batchSize: defaultBatchSize,
         yieldThreshold: defaultYieldThreshold,
+        sequentialProcessing: defaultSequentialProcessing,
     };
 }
 /**
@@ -68,6 +77,57 @@ function defer(startTime, yieldThreshold) {
     // Otherwise continue immediately
     return Promise.resolve(false);
 }
+/**
+ * Helper to get batch processing options with defaults applied
+ * @param options - User provided options
+ * @returns Options with defaults applied
+ * @internal
+ */
+function getOptions(options) {
+    const batchSize = options?.batchSize ?? defaultBatchSize;
+    const yieldThreshold = options?.yieldThreshold ?? defaultYieldThreshold;
+    const sequentialProcessing = options?.sequentialProcessing ?? defaultSequentialProcessing;
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    return {
+        batchSize,
+        yieldThreshold,
+        sequentialProcessing,
+    };
+}
+/**
+ * Helper to process an array in batches, yielding as needed.
+ * @param items - The array to process
+ * @param options - Batch processing options
+ * @param batchHandler - Function to handle each batch: (batch, batchStartIndex) => Promise<any>
+ * @returns Promise<void>
+ */
+async function processInBatches(items, options, batchHandler) {
+    let i = 0;
+    let startTime = Date.now();
+    const { batchSize } = options;
+    const n = items.length;
+    // Allocate a single batch array and reuses it for all batches
+    const batch = Array(batchSize);
+    while (i < n) {
+        const len = Math.min(batchSize, n - i);
+        for (let j = 0; j < len; j += 1) {
+            batch[j] = items[i + j];
+        }
+        batch.length = len;
+        // eslint-disable-next-line no-await-in-loop
+        await batchHandler(batch, i);
+        i += batchSize;
+        // eslint-disable-next-line no-await-in-loop
+        const didYield = await defer(startTime, options.yieldThreshold);
+        if (didYield)
+            startTime = Date.now();
+    }
+}
 /**
  * Maps over an array in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
@@ -77,40 +137,40 @@ function defer(startTime, yieldThreshold) {
  * @template R - The type of items in the result array
  * @param items - The array to map over
  * @param mapFn - The mapping function to apply to each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the mapped array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Synchronous mapping
- * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);
- * // Result: [2, 4, 6, 8]
- *
- * // Asynchronous mapping
- * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);
+ * // Synchronous mapping with default options (sequential processing)
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);
  *
- * // With index
- * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);
- * // Result: ['a-0', 'b-1']
+ * // With concurrent processing within batches
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });
  * ```
  */
-function mapInBatches(items, mapFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-        throw new Error('batchSize must be a positive integer');
-    }
-    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
-        throw new Error('yieldThreshold must be a non-negative integer');
-    }
-    const process = async (i = 0, acc = [], startTime = Date.now()) => {
-        if (i >= items.length)
-            return acc;
-        const batch = items.slice(i, i + batchSize);
-        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));
-        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(mapped), didYield ? Date.now() : startTime));
-    };
-    return process();
+function mapInBatches(items, mapFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const mapped = await mapFn(batch[j], batchStart + j);
+                    result.push(mapped);
+                }
+            }
+            else {
+                // Process items concurrently
+                const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));
+                result.push(...mapped);
+            }
+        });
+        return result;
+    })();
 }
 /**
  * Filters an array in batches to avoid blocking the event loop.
@@ -120,44 +180,45 @@ function mapInBatches(items, mapFn, batchSize = defaultBatchSize, yieldThreshold
  * @template T - The type of items in the array
  * @param items - The array to filter
  * @param predicate - The predicate function to test each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the filtered array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Synchronous filtering
- * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);
+ * // Synchronous filtering with default options
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);
  * // Result: [2, 4]
  *
- * // Asynchronous filtering
- * const valid = await filterInBatches(urls, async (url) => {
- *   const response = await fetch(url);
- *   return response.ok;
- * }, 3);
- *
- * // With index
- * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);
- * // Result: ['a', 'c']
+ * // With custom batch size
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });
  * ```
  */
-function filterInBatches(items, predicate, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-        throw new Error('batchSize must be a positive integer');
-    }
-    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
-        throw new Error('yieldThreshold must be a non-negative integer');
-    }
-    const process = async (i = 0, acc = [], startTime = Date.now()) => {
-        if (i >= items.length)
-            return acc;
-        const batch = items.slice(i, i + batchSize);
-        const flags = await Promise.all(batch.map((item, j) => predicate(item, i + j)));
-        const filtered = batch.filter((_, j) => flags[j]);
-        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(filtered), didYield ? Date.now() : startTime));
-    };
-    return process();
+function filterInBatches(items, predicate, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const passes = await predicate(batch[j], batchStart + j);
+                    if (passes)
+                        result.push(batch[j]);
+                }
+            }
+            else {
+                // Process items concurrently
+                const flags = await Promise.all(batch.map((item, j) => predicate(item, batchStart + j)));
+                for (let j = 0; j < batch.length; j += 1) {
+                    if (flags[j])
+                        result.push(batch[j]);
+                }
+            }
+        });
+        return result;
+    })();
 }
 /**
  * Groups an array by a key function in batches to avoid blocking the event loop.
@@ -168,112 +229,94 @@ function filterInBatches(items, predicate, batchSize = defaultBatchSize, yieldTh
  * @template K - The type of the grouping key (must extend PropertyKey)
  * @param items - The array to group
  * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to an object with grouped items
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Group by property
+ * // Group by property with default options
  * const byType = await groupByInBatches(
  *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
- *   (item) => item.type,
- *   2
+ *   (item) => item.type
  * );
  * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
  *
- * // Group by computed value
- * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');
- * // Result: {odd: [1, 3], even: [2, 4]}
- *
- * // Asynchronous key function
- * const byCategory = await groupByInBatches(items, async (item) => {
- *   return await getCategoryForItem(item);
- * });
+ * // With custom batch size
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   { batchSize: 2 }
+ * );
  * ```
  */
-function groupByInBatches(items, keyFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-        throw new Error('batchSize must be a positive integer');
-    }
-    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
-        throw new Error('yieldThreshold must be a non-negative integer');
-    }
-    const process = async (i = 0, acc = {}, startTime = Date.now()) => {
-        if (i >= items.length)
-            return acc;
-        const batch = items.slice(i, i + batchSize);
-        const keys = await Promise.all(batch.map((item, j) => keyFn(item, i + j)));
-        const updated = keys.reduce((res, key, j) => {
-            const item = batch[j];
-            if (!res[key])
-                res[key] = [];
-            res[key] = res[key].concat(item);
-            return res;
-        }, { ...acc });
-        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, updated, didYield ? Date.now() : startTime));
-    };
-    return process();
+function groupByInBatches(items, keyFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = {};
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const key = await keyFn(batch[j], batchStart + j);
+                    if (!result[key])
+                        result[key] = [];
+                    result[key].push(batch[j]);
+                }
+            }
+            else {
+                // Process items concurrently
+                const keys = await Promise.all(batch.map((item, j) => keyFn(item, batchStart + j)));
+                for (let j = 0; j < batch.length; j += 1) {
+                    const key = keys[j];
+                    if (!result[key])
+                        result[key] = [];
+                    result[key].push(batch[j]);
+                }
+            }
+        });
+        return result;
+    })();
 }
 /**
  * Reduces an array in batches to avoid blocking the event loop.
  * Processes items in chunks and yields control back to the event loop between batches
- * when the processing time exceeds the threshold.
+ * when the processing time exceeds the threshold. Sequential processing is always used for the reducer function,
+ * irrespective of the `sequentialProcessing` option.
  *
  * @template T - The type of items in the array
  * @template R - The type of the accumulator/result
  * @param items - The array to reduce
  * @param reducer - The reducer function. Receives the accumulator, current item, and index.
  * @param initialValue - The initial value for the accumulator
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the reduced value
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Sum numbers
- * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);
+ * // Sum numbers with default options
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);
  * // Result: 10
  *
- * // Concatenate strings
- * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');
- * // Result: 'abc'
- *
- * // Build object with index
- * const indexed = await reduceInBatches(
- *   ['x', 'y'],
- *   (acc, item, index) => ({ ...acc, [index]: item }),
- *   {}
- * );
- * // Result: {0: 'x', 1: 'y'}
- *
- * // Asynchronous reducer
- * const processed = await reduceInBatches(urls, async (acc, url) => {
- *   const data = await fetch(url).then(r => r.json());
- *   return [...acc, data];
- * }, []);
+ * // With custom batch size
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });
  * ```
  */
-function reduceInBatches(items, reducer, initialValue, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-        throw new Error('batchSize must be a positive integer');
-    }
-    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
-        throw new Error('yieldThreshold must be a non-negative integer');
-    }
-    const process = async (i = 0, acc = initialValue, startTime = Date.now()) => {
-        if (i >= items.length)
-            return acc;
-        const batch = items.slice(i, i + batchSize);
-        const reduced = await batch.reduce(async (prevAcc, item, j) => {
-            const resolvedAcc = await prevAcc;
-            return reducer(resolvedAcc, item, i + j);
-        }, Promise.resolve(acc));
-        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, reduced, didYield ? Date.now() : startTime));
-    };
-    return process();
+function reduceInBatches(items, reducer, initialValue, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        let acc = initialValue;
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            // Always sequential, regardless of sequentialProcessing option
+            for (let j = 0; j < batch.length; j += 1) {
+                // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                acc = await reducer(acc, batch[j], batchStart + j);
+            }
+        });
+        return acc;
+    })();
 }
 /**
  * FlatMaps an array in batches to avoid blocking the event loop.
@@ -284,47 +327,83 @@ function reduceInBatches(items, reducer, initialValue, batchSize = defaultBatchS
  * @template R - The type of items in the flattened result array
  * @param items - The array to flatMap over
  * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.
- * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
- * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @param options - Batch processing options
  * @returns A promise that resolves to the flattened mapped array
  * @throws {Error} When batchSize is not a positive integer
  *
  * @example
  * ```typescript
- * // Duplicate each item
- * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);
+ * // Duplicate each item with default options
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);
  * // Result: [1, 1, 2, 2, 3, 3]
  *
- * // Variable length results
- * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));
- * // Result: [1, 2, 2, 3, 3, 3]
+ * // With custom batch size
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });
+ * ```
+ */
+function flatMapInBatches(items, mapFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const mapped = await mapFn(batch[j], batchStart + j);
+                    result.push(...mapped);
+                }
+            }
+            else {
+                // Process items concurrently
+                const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));
+                mapped.forEach((arr) => {
+                    result.push(...arr);
+                });
+            }
+        });
+        return result;
+    })();
+}
+/**
+ * forEach over an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
  *
- * // Split strings into characters
- * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));
- * // Result: ['a', 'b', 'c', 'd']
+ * @template T - The type of items in the input array
+ * @param items - The array to iterate over
+ * @param fn - The function to apply to each item. Receives the item and its index. Can be async.
+ * @param options - Batch processing options
+ * @returns A promise that resolves when all items have been processed
+ * @throws {Error} When batchSize is not a positive integer
  *
- * // Asynchronous mapping
- * const expanded = await flatMapInBatches(categories, async (category) => {
- *   const items = await fetchItemsForCategory(category);
- *   return items;
+ * @example
+ * ```typescript
+ * // Process items in batches with default options
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
  * });
+ *
+ * // With custom batch size
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * }, { batchSize: 2 });
  * ```
  */
-function flatMapInBatches(items, mapFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-        throw new Error('batchSize must be a positive integer');
-    }
-    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
-        throw new Error('yieldThreshold must be a non-negative integer');
-    }
-    const process = async (i = 0, acc = [], startTime = Date.now()) => {
-        if (i >= items.length)
-            return acc;
-        const batch = items.slice(i, i + batchSize);
-        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));
-        const flattened = mapped.reduce((all, arr) => all.concat(arr), []);
-        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(flattened), didYield ? Date.now() : startTime));
-    };
-    return process();
+function forEachInBatches(items, fn, options) {
+    const opts = getOptions(options);
+    return processInBatches(items, opts, async (batch, batchStart) => {
+        if (opts.sequentialProcessing) {
+            // Process items sequentially
+            for (let j = 0; j < batch.length; j += 1) {
+                // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                await fn(batch[j], batchStart + j);
+            }
+        }
+        else {
+            // Process items concurrently
+            await Promise.all(batch.map((item, j) => fn(item, batchStart + j)));
+        }
+    });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.js","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":";;AAqCA,4EAuBC;AAsDD,oCAwBC;AAgCD,0CA0BC;AAoCD,4CAsCC;AA0CD,0CA4BC;AAqCD,4CAyBC;AAnYD,0CAA0C;AAC1C,IAAI,gBAAgB,GAAG,EAAE,CAAC;AAC1B,IAAI,qBAAqB,GAAG,EAAE,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,gCAAgC,CAC9C,MAAgC;IAEhC,IAAI,MAAM,EAAE,CAAC;QACX,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC,EAAE,CAAC;gBACjE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YAC1D,CAAC;YACD,gBAAgB,GAAG,MAAM,CAAC,SAAS,CAAC;QACtC,CAAC;QAED,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC;gBAC1E,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;YACnE,CAAC;YACD,qBAAqB,GAAG,MAAM,CAAC,cAAc,CAAC;QAChD,CAAC;IACH,CAAC;IAED,OAAO;QACL,SAAS,EAAE,gBAAgB;QAC3B,cAAc,EAAE,qBAAqB;KACtC,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,KAAK,CAAC,SAAiB,EAAE,cAAsB;IACtD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;IAEvC,6CAA6C;IAC7C,IAAI,OAAO,IAAI,cAAc,EAAE,CAAC;QAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,YAAY,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAiC;IACjC,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,YAAY,CAC1B,KAAU,EACV,KAAiD,EACjD,SAAS,GAAG,gBAAgB,EAC5B,cAAc,GAAG,qBAAqB;IAEtC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAW,EAAE,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EAAgB,EAAE;QACnF,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QAElC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE7E,OAAO,KAAK,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAC9E,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,SAAgB,eAAe,CAC7B,KAAU,EACV,SAAiE,EACjE,SAAS,GAAG,gBAAgB,EAC5B,cAAc,GAAG,qBAAqB;IAEtC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAW,EAAE,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EAAgB,EAAE;QACnF,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QAElC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhF,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAElD,OAAO,KAAK,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAChF,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,gBAAgB,CAC9B,KAAU,EACV,KAAiD,EACjD,SAAS,GAAG,gBAAgB,EAC5B,cAAc,GAAG,qBAAqB;IAEtC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,EACnB,CAAC,GAAG,CAAC,EACL,MAAsB,EAAoB,EAC1C,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EACG,EAAE;QAC3B,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QAElC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3E,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CACzB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE;YACd,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YAC7B,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACjC,OAAO,GAAG,CAAC;QACb,CAAC,EACD,EAAE,GAAG,GAAG,EAAE,CACX,CAAC;QAEF,OAAO,KAAK,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CACnE,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,SAAgB,eAAe,CAC7B,KAAU,EACV,OAA2D,EAC3D,YAAe,EACf,SAAS,GAAG,gBAAgB,EAC5B,cAAc,GAAG,qBAAqB;IAEtC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAS,YAAY,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EAAc,EAAE;QACzF,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QAElC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,MAAM,CAAa,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE;YACxE,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC;YAClC,OAAO,OAAO,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QAEzB,OAAO,KAAK,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CACnE,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,SAAgB,gBAAgB,CAC9B,KAAU,EACV,KAAqD,EACrD,SAAS,GAAG,gBAAgB,EAC5B,cAAc,GAAG,qBAAqB;IAEtC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAW,EAAE,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EAAgB,EAAE;QACnF,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QAElC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7E,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAEnE,OAAO,KAAK,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CACjF,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC","sourcesContent":["/**\n * Configuration options for batch processing operations\n */\nexport interface BatchProcessingDefaults {\n  /**\n   * Default number of items to process in each batch\n   */\n  batchSize?: number;\n\n  /**\n   * Default time threshold in milliseconds before yielding control back to the event loop\n   */\n  yieldThreshold?: number;\n}\n\n// Default configuration values (internal)\nlet defaultBatchSize = 10;\nlet defaultYieldThreshold = 10;\n\n/**\n * Configure global defaults for batch processing operations\n *\n * @param config - Configuration options for batch processing\n * @returns The current configuration after applying changes\n *\n * @example\n * ```typescript\n * // Set both defaults\n * configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });\n *\n * // Set only batch size\n * configureBatchProcessingDefaults({ batchSize: 50 });\n *\n * // Get current configuration\n * const currentConfig = configureBatchProcessingDefaults();\n * ```\n */\nexport function configureBatchProcessingDefaults(\n  config?: BatchProcessingDefaults,\n): BatchProcessingDefaults {\n  if (config) {\n    if (config.batchSize !== undefined) {\n      if (!Number.isInteger(config.batchSize) || config.batchSize <= 0) {\n        throw new Error('batchSize must be a positive integer');\n      }\n      defaultBatchSize = config.batchSize;\n    }\n\n    if (config.yieldThreshold !== undefined) {\n      if (!Number.isInteger(config.yieldThreshold) || config.yieldThreshold < 0) {\n        throw new Error('yieldThreshold must be a non-negative integer');\n      }\n      defaultYieldThreshold = config.yieldThreshold;\n    }\n  }\n\n  return {\n    batchSize: defaultBatchSize,\n    yieldThreshold: defaultYieldThreshold,\n  };\n}\n\n/**\n * Utility function to defer execution to the next tick of the event loop.\n * This prevents blocking the event loop during heavy batch operations by\n * yielding control back to the event loop using setImmediate.\n *\n * @param startTime - The timestamp when the current batch processing started\n * @param yieldThreshold - Time threshold in milliseconds before yielding control\n * @returns A promise that resolves to a boolean indicating whether a yield occurred\n * @internal\n */\nfunction defer(startTime: number, yieldThreshold: number): Promise<boolean> {\n  const elapsed = Date.now() - startTime;\n\n  // Only yield if we've exceeded the threshold\n  if (elapsed >= yieldThreshold) {\n    return new Promise((resolve) => {\n      setImmediate(() => resolve(true));\n    });\n  }\n\n  // Otherwise continue immediately\n  return Promise.resolve(false);\n}\n\n/**\n * Maps over an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the result array\n * @param items - The array to map over\n * @param mapFn - The mapping function to apply to each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous mapping\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);\n * // Result: [2, 4, 6, 8]\n *\n * // Asynchronous mapping\n * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);\n *\n * // With index\n * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);\n * // Result: ['a-0', 'b-1']\n * ```\n */\nexport function mapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R | Promise<R>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R[] = [], startTime = Date.now()): Promise<R[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(mapped), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Filters an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @param items - The array to filter\n * @param predicate - The predicate function to test each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the filtered array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous filtering\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);\n * // Result: [2, 4]\n *\n * // Asynchronous filtering\n * const valid = await filterInBatches(urls, async (url) => {\n *   const response = await fetch(url);\n *   return response.ok;\n * }, 3);\n *\n * // With index\n * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);\n * // Result: ['a', 'c']\n * ```\n */\nexport function filterInBatches<T>(\n  items: T[],\n  predicate: (item: T, index: number) => boolean | Promise<boolean>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<T[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: T[] = [], startTime = Date.now()): Promise<T[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const flags = await Promise.all(batch.map((item, j) => predicate(item, i + j)));\n\n    const filtered = batch.filter((_, j) => flags[j]);\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(filtered), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Groups an array by a key function in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @template K - The type of the grouping key (must extend PropertyKey)\n * @param items - The array to group\n * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to an object with grouped items\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Group by property\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type,\n *   2\n * );\n * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}\n *\n * // Group by computed value\n * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');\n * // Result: {odd: [1, 3], even: [2, 4]}\n *\n * // Asynchronous key function\n * const byCategory = await groupByInBatches(items, async (item) => {\n *   return await getCategoryForItem(item);\n * });\n * ```\n */\nexport function groupByInBatches<T, K extends PropertyKey>(\n  items: T[],\n  keyFn: (item: T, index: number) => K | Promise<K>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<Record<K, T[]>> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (\n    i = 0,\n    acc: Record<K, T[]> = {} as Record<K, T[]>,\n    startTime = Date.now(),\n  ): Promise<Record<K, T[]>> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const keys = await Promise.all(batch.map((item, j) => keyFn(item, i + j)));\n\n    const updated = keys.reduce(\n      (res, key, j) => {\n        const item = batch[j];\n        if (!res[key]) res[key] = [];\n        res[key] = res[key].concat(item);\n        return res;\n      },\n      { ...acc },\n    );\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, updated, didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Reduces an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @template R - The type of the accumulator/result\n * @param items - The array to reduce\n * @param reducer - The reducer function. Receives the accumulator, current item, and index.\n * @param initialValue - The initial value for the accumulator\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the reduced value\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Sum numbers\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);\n * // Result: 10\n *\n * // Concatenate strings\n * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');\n * // Result: 'abc'\n *\n * // Build object with index\n * const indexed = await reduceInBatches(\n *   ['x', 'y'],\n *   (acc, item, index) => ({ ...acc, [index]: item }),\n *   {}\n * );\n * // Result: {0: 'x', 1: 'y'}\n *\n * // Asynchronous reducer\n * const processed = await reduceInBatches(urls, async (acc, url) => {\n *   const data = await fetch(url).then(r => r.json());\n *   return [...acc, data];\n * }, []);\n * ```\n */\nexport function reduceInBatches<T, R>(\n  items: T[],\n  reducer: (acc: R, item: T, index: number) => R | Promise<R>,\n  initialValue: R,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R = initialValue, startTime = Date.now()): Promise<R> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const reduced = await batch.reduce<Promise<R>>(async (prevAcc, item, j) => {\n      const resolvedAcc = await prevAcc;\n      return reducer(resolvedAcc, item, i + j);\n    }, Promise.resolve(acc));\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, reduced, didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * FlatMaps an array in batches to avoid blocking the event loop.\n * Processes items in chunks, flattens the results, and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the flattened result array\n * @param items - The array to flatMap over\n * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the flattened mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Duplicate each item\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);\n * // Result: [1, 1, 2, 2, 3, 3]\n *\n * // Variable length results\n * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));\n * // Result: [1, 2, 2, 3, 3, 3]\n *\n * // Split strings into characters\n * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));\n * // Result: ['a', 'b', 'c', 'd']\n *\n * // Asynchronous mapping\n * const expanded = await flatMapInBatches(categories, async (category) => {\n *   const items = await fetchItemsForCategory(category);\n *   return items;\n * });\n * ```\n */\nexport function flatMapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R[] | Promise<R[]>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R[] = [], startTime = Date.now()): Promise<R[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));\n    const flattened = mapped.reduce((all, arr) => all.concat(arr), []);\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(flattened), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.js","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Options for batch processing operations\n */\nexport interface BatchProcessingOptions {\n  /**\n   * Number of items to process in each batch (default: 10)\n   * Must be a positive integer.\n   */\n  batchSize?: number;\n\n  /**\n   * Time threshold in milliseconds (default: 10) before yielding control back to the event loop.\n   * Set to 0 to yield after every batch. Must be a non-negative integer.\n   */\n  yieldThreshold?: number;\n\n  /**\n   * Whether to process items sequentially within each batch. When true (default), each item in a batch\n   * will be processed one at a time. When false, all items in a batch will be processed concurrently.\n   * Consider the implications of concurrency on your processing logic before setting this to false, e.g. race conditions, rate limits, memory pressure, etc.\n   */\n  sequentialProcessing?: boolean;\n}\n\n// Default configuration values (internal)\nlet defaultBatchSize = 10;\nlet defaultYieldThreshold = 10;\nlet defaultSequentialProcessing = true;\n\n/**\n * Configure global defaults for batch processing operations\n *\n * @param config - Configuration options for batch processing\n * @returns The current configuration after applying changes\n *\n * @example\n * ```typescript\n * // Set both defaults\n * configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });\n *\n * // Set only batch size\n * configureBatchProcessingDefaults({ batchSize: 50 });\n *\n * // Enable concurrent processing within batches\n * configureBatchProcessingDefaults({ sequentialProcessing: false });\n *\n * // Get current configuration\n * const currentConfig = configureBatchProcessingDefaults();\n * ```\n */\nexport function configureBatchProcessingDefaults(\n  config?: BatchProcessingOptions,\n): BatchProcessingOptions {\n  if (config) {\n    if (config.batchSize !== undefined) {\n      if (!Number.isInteger(config.batchSize) || config.batchSize <= 0) {\n        throw new Error('batchSize must be a positive integer');\n      }\n      defaultBatchSize = config.batchSize;\n    }\n\n    if (config.yieldThreshold !== undefined) {\n      if (!Number.isInteger(config.yieldThreshold) || config.yieldThreshold < 0) {\n        throw new Error('yieldThreshold must be a non-negative integer');\n      }\n      defaultYieldThreshold = config.yieldThreshold;\n    }\n\n    if (config.sequentialProcessing !== undefined) {\n      defaultSequentialProcessing = Boolean(config.sequentialProcessing);\n    }\n  }\n\n  return {\n    batchSize: defaultBatchSize,\n    yieldThreshold: defaultYieldThreshold,\n    sequentialProcessing: defaultSequentialProcessing,\n  };\n}\n\n/**\n * Utility function to defer execution to the next tick of the event loop.\n * This prevents blocking the event loop during heavy batch operations by\n * yielding control back to the event loop using setImmediate.\n *\n * @param startTime - The timestamp when the current batch processing started\n * @param yieldThreshold - Time threshold in milliseconds before yielding control\n * @returns A promise that resolves to a boolean indicating whether a yield occurred\n * @internal\n */\nfunction defer(startTime: number, yieldThreshold: number): Promise<boolean> {\n  const elapsed = Date.now() - startTime;\n\n  // Only yield if we've exceeded the threshold\n  if (elapsed >= yieldThreshold) {\n    return new Promise((resolve) => {\n      setImmediate(() => resolve(true));\n    });\n  }\n\n  // Otherwise continue immediately\n  return Promise.resolve(false);\n}\n\n/**\n * Helper to get batch processing options with defaults applied\n * @param options - User provided options\n * @returns Options with defaults applied\n * @internal\n */\nfunction getOptions(options?: BatchProcessingOptions): Required<BatchProcessingOptions> {\n  const batchSize = options?.batchSize ?? defaultBatchSize;\n  const yieldThreshold = options?.yieldThreshold ?? defaultYieldThreshold;\n  const sequentialProcessing = options?.sequentialProcessing ?? defaultSequentialProcessing;\n\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n\n  return {\n    batchSize,\n    yieldThreshold,\n    sequentialProcessing,\n  };\n}\n\n/**\n * Helper to process an array in batches, yielding as needed.\n * @param items - The array to process\n * @param options - Batch processing options\n * @param batchHandler - Function to handle each batch: (batch, batchStartIndex) => Promise<any>\n * @returns Promise<void>\n */\nasync function processInBatches<T>(\n  items: T[],\n  options: Required<BatchProcessingOptions>,\n  batchHandler: (batch: T[], batchStart: number) => Promise<void>,\n): Promise<void> {\n  let i = 0;\n  let startTime = Date.now();\n  const { batchSize } = options;\n  const n = items.length;\n  // Allocate a single batch array and reuses it for all batches\n  const batch: T[] = Array(batchSize);\n  while (i < n) {\n    const len = Math.min(batchSize, n - i);\n    for (let j = 0; j < len; j += 1) {\n      batch[j] = items[i + j];\n    }\n    batch.length = len;\n    // eslint-disable-next-line no-await-in-loop\n    await batchHandler(batch, i);\n    i += batchSize;\n    // eslint-disable-next-line no-await-in-loop\n    const didYield = await defer(startTime, options.yieldThreshold);\n    if (didYield) startTime = Date.now();\n  }\n}\n\n/**\n * Maps over an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the result array\n * @param items - The array to map over\n * @param mapFn - The mapping function to apply to each item. Receives the item and its index.\n * @param options - Batch processing options\n * @returns A promise that resolves to the mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous mapping with default options (sequential processing)\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);\n *\n * // With concurrent processing within batches\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });\n * ```\n */\nexport function mapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R | Promise<R>,\n  options?: BatchProcessingOptions,\n): Promise<R[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: R[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const mapped = await mapFn(batch[j], batchStart + j);\n          result.push(mapped);\n        }\n      } else {\n        // Process items concurrently\n        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));\n        result.push(...mapped);\n      }\n    });\n    return result;\n  })();\n}\n\n/**\n * Filters an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @param items - The array to filter\n * @param predicate - The predicate function to test each item. Receives the item and its index.\n * @param options - Batch processing options\n * @returns A promise that resolves to the filtered array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous filtering with default options\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);\n * // Result: [2, 4]\n *\n * // With custom batch size\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });\n * ```\n */\nexport function filterInBatches<T>(\n  items: T[],\n  predicate: (item: T, index: number) => boolean | Promise<boolean>,\n  options?: BatchProcessingOptions,\n): Promise<T[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: T[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const passes = await predicate(batch[j], batchStart + j);\n          if (passes) result.push(batch[j]);\n        }\n      } else {\n        // Process items concurrently\n        const flags = await Promise.all(batch.map((item, j) => predicate(item, batchStart + j)));\n        for (let j = 0; j < batch.length; j += 1) {\n          if (flags[j]) result.push(batch[j]);\n        }\n      }\n    });\n    return result;\n  })();\n}\n\n/**\n * Groups an array by a key function in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @template K - The type of the grouping key (must extend PropertyKey)\n * @param items - The array to group\n * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.\n * @param options - Batch processing options\n * @returns A promise that resolves to an object with grouped items\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Group by property with default options\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type\n * );\n * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}\n *\n * // With custom batch size\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type,\n *   { batchSize: 2 }\n * );\n * ```\n */\nexport function groupByInBatches<T, K extends PropertyKey>(\n  items: T[],\n  keyFn: (item: T, index: number) => K | Promise<K>,\n  options?: BatchProcessingOptions,\n): Promise<Record<K, T[]>> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: Record<K, T[]> = {} as Record<K, T[]>;\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const key = await keyFn(batch[j], batchStart + j);\n          if (!result[key]) result[key] = [];\n          result[key].push(batch[j]);\n        }\n      } else {\n        // Process items concurrently\n        const keys = await Promise.all(batch.map((item, j) => keyFn(item, batchStart + j)));\n        for (let j = 0; j < batch.length; j += 1) {\n          const key = keys[j];\n          if (!result[key]) result[key] = [];\n          result[key].push(batch[j]);\n        }\n      }\n    });\n    return result;\n  })();\n}\n\n/**\n * Reduces an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold. Sequential processing is always used for the reducer function,\n * irrespective of the `sequentialProcessing` option.\n *\n * @template T - The type of items in the array\n * @template R - The type of the accumulator/result\n * @param items - The array to reduce\n * @param reducer - The reducer function. Receives the accumulator, current item, and index.\n * @param initialValue - The initial value for the accumulator\n * @param options - Batch processing options\n * @returns A promise that resolves to the reduced value\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Sum numbers with default options\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);\n * // Result: 10\n *\n * // With custom batch size\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });\n * ```\n */\nexport function reduceInBatches<T, R>(\n  items: T[],\n  reducer: (acc: R, item: T, index: number) => R | Promise<R>,\n  initialValue: R,\n  options?: BatchProcessingOptions,\n): Promise<R> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    let acc = initialValue;\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      // Always sequential, regardless of sequentialProcessing option\n      for (let j = 0; j < batch.length; j += 1) {\n        // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n        acc = await reducer(acc, batch[j], batchStart + j);\n      }\n    });\n    return acc;\n  })();\n}\n\n/**\n * FlatMaps an array in batches to avoid blocking the event loop.\n * Processes items in chunks, flattens the results, and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the flattened result array\n * @param items - The array to flatMap over\n * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.\n * @param options - Batch processing options\n * @returns A promise that resolves to the flattened mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Duplicate each item with default options\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);\n * // Result: [1, 1, 2, 2, 3, 3]\n *\n * // With custom batch size\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });\n * ```\n */\nexport function flatMapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R[] | Promise<R[]>,\n  options?: BatchProcessingOptions,\n): Promise<R[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: R[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const mapped = await mapFn(batch[j], batchStart + j);\n          result.push(...mapped);\n        }\n      } else {\n        // Process items concurrently\n        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));\n        mapped.forEach((arr) => {\n          result.push(...arr);\n        });\n      }\n    });\n    return result;\n  })();\n}\n\n/**\n * forEach over an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @param items - The array to iterate over\n * @param fn - The function to apply to each item. Receives the item and its index. Can be async.\n * @param options - Batch processing options\n * @returns A promise that resolves when all items have been processed\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Process items in batches with default options\n * await forEachInBatches([1, 2, 3, 4], async (x) => {\n *   await doSomething(x);\n * });\n *\n * // With custom batch size\n * await forEachInBatches([1, 2, 3, 4], async (x) => {\n *   await doSomething(x);\n * }, { batchSize: 2 });\n * ```\n */\nexport function forEachInBatches<T>(\n  items: T[],\n  fn: (item: T, index: number) => void | Promise<void>,\n  options?: BatchProcessingOptions,\n): Promise<void> {\n  const opts = getOptions(options);\n\n  return processInBatches(items, opts, async (batch, batchStart) => {\n    if (opts.sequentialProcessing) {\n      // Process items sequentially\n      for (let j = 0; j < batch.length; j += 1) {\n        // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n        await fn(batch[j], batchStart + j);\n      }\n    } else {\n      // Process items concurrently\n      await Promise.all(batch.map((item, j) => fn(item, batchStart + j)));\n    }\n  });\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.33",
+  "version": "0.2.34",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",