@rudderstack/integrations-lib
Version:
A comprehensive TypeScript library providing shared utilities, SDKs, and tools for RudderStack integrations and destinations.
409 lines • 50 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.configureBatchProcessingDefaults = configureBatchProcessingDefaults;
exports.mapInBatches = mapInBatches;
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
*
* @param config - Configuration options for batch processing
* @returns The current configuration after applying changes
*
* @example
* ```typescript
* // Set both defaults
* configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });
*
* // Set only batch size
* configureBatchProcessingDefaults({ batchSize: 50 });
*
* // Enable concurrent processing within batches
* configureBatchProcessingDefaults({ sequentialProcessing: false });
*
* // Get current configuration
* const currentConfig = configureBatchProcessingDefaults();
* ```
*/
function configureBatchProcessingDefaults(config) {
if (config) {
if (config.batchSize !== undefined) {
if (!Number.isInteger(config.batchSize) || config.batchSize <= 0) {
throw new Error('batchSize must be a positive integer');
}
defaultBatchSize = config.batchSize;
}
if (config.yieldThreshold !== undefined) {
if (!Number.isInteger(config.yieldThreshold) || config.yieldThreshold < 0) {
throw new Error('yieldThreshold must be a non-negative integer');
}
defaultYieldThreshold = config.yieldThreshold;
}
if (config.sequentialProcessing !== undefined) {
defaultSequentialProcessing = Boolean(config.sequentialProcessing);
}
}
return {
batchSize: defaultBatchSize,
yieldThreshold: defaultYieldThreshold,
sequentialProcessing: defaultSequentialProcessing,
};
}
/**
* Utility function to defer execution to the next tick of the event loop.
* This prevents blocking the event loop during heavy batch operations by
* yielding control back to the event loop using setImmediate.
*
* @param startTime - The timestamp when the current batch processing started
* @param yieldThreshold - Time threshold in milliseconds before yielding control
* @returns A promise that resolves to a boolean indicating whether a yield occurred
* @internal
*/
function defer(startTime, yieldThreshold) {
const elapsed = Date.now() - startTime;
// Only yield if we've exceeded the threshold
if (elapsed >= yieldThreshold) {
return new Promise((resolve) => {
setImmediate(() => resolve(true));
});
}
// 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
* when the processing time exceeds the threshold.
*
* @template T - The type of items in the input array
* @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 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 with default options (sequential processing)
* const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);
*
* // With concurrent processing within batches
* const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });
* ```
*/
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.
* Processes items in chunks and yields control back to the event loop between batches
* when the processing time exceeds the threshold.
*
* @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 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 with default options
* const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);
* // Result: [2, 4]
*
* // With custom batch size
* const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });
* ```
*/
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.
* Processes items in chunks and yields control back to the event loop between batches
* when the processing time exceeds the threshold.
*
* @template T - The type of items in the array
* @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 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 with default options
* const byType = await groupByInBatches(
* [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
* (item) => item.type
* );
* // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
*
* // 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, 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. 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 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 with default options
* const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);
* // Result: 10
*
* // With custom batch size
* const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });
* ```
*/
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.
* Processes items in chunks, flattens the results, and yields control back to the event loop between batches
* when the processing time exceeds the threshold.
*
* @template T - The type of items in the input array
* @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 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 with default options
* const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);
* // Result: [1, 1, 2, 2, 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.
*
* @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
*
* @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 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":"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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"]}