@cognite/underscore 1.0.1 → 1.48411.0

package/dist/chunk-and-process-in-parallel.js

@@ -1,30 +1,139 @@
-import { chunkArray as e } from "./chunk-array.js";
-//#region libs/shared/underscore/src/chunk-and-process-in-parallel.ts
-var t = class extends Error {
-	constructor(e, t, n, r, i) {
-		super(`${e.message} (succeeded: ${t.length}, failed: ${r.length}, unprocessed: ${i.length})`), this.name = "PartialExecutionError", this.reason = e, this.succeeded = t, this.succeededResults = n, this.failed = r, this.unprocessed = i, this.message = `Processing failed for ${r.length} items: ${e.message}`;
-	}
-};
-async function n(n, r, i, a) {
-	let o = a?.numWorkers ?? 10;
-	if (o <= 0 || !Number.isInteger(o)) throw Error("numWorkers must be a positive integer");
-	let s = Array.from(e(n, r));
-	if (s.length === 0) return [];
-	let c = Array(s.length), l = 0, u = !1, d = /* @__PURE__ */ new Set(), f = async () => {
-		for (; !u && l < s.length;) {
-			let e = l++;
-			try {
-				let t = await i(s[e]);
-				c[e] = t, d.add(e);
-			} catch (n) {
-				u = !0;
-				let r = [], i = [], a = [];
-				for (let t = 0; t < s.length; t++) d.has(t) ? (r.push(...s[t]), i.push(...c[t])) : t !== e && a.push(...s[t]);
-				throw new t(n instanceof Error ? n : Error(String(n)), r, i, s[e], a);
-			}
-		}
-	}, p = Array.from({ length: Math.min(o, s.length) }, () => f());
-	return await Promise.all(p), c.flat();
+import { chunkArray } from "./chunk-array.js";
+/**
+ * Error thrown when {@link chunkAndProcessInParallel} fails partway through processing.
+ *
+ * This error provides detailed information about which items were successfully processed,
+ * which items failed, and which items were never attempted.
+ *
+ * @template T - The type of input elements.
+ */ export class PartialExecutionError extends Error {
+    constructor(reason, succeeded, succeededResults, failed, unprocessed){
+        super(`${reason.message} (succeeded: ${succeeded.length}, failed: ${failed.length}, unprocessed: ${unprocessed.length})`);
+        this.name = 'PartialExecutionError';
+        this.reason = reason;
+        this.succeeded = succeeded;
+        this.succeededResults = succeededResults;
+        this.failed = failed;
+        this.unprocessed = unprocessed;
+        this.message = `Processing failed for ${failed.length} items: ${reason.message}`;
+    }
 }
-//#endregion
-export { t as PartialExecutionError, n as chunkAndProcessInParallel };
+/**
+ * Splits an array into chunks and processes each chunk in parallel using a callback function.
+ *
+ * This function is useful for batch processing large datasets where you want to:
+ * - Limit the number of items processed at once (e.g., API limits)
+ * - Process multiple chunks simultaneously for better performance
+ * - Control the degree of parallelism to avoid overwhelming resources
+ *
+ * The function maintains a saturated queue up to `numWorkers` concurrent operations.
+ * When one chunk completes, the next chunk starts immediately, ensuring optimal throughput.
+ *
+ * All chunks are processed with controlled parallelism, and the results are flattened into
+ * a single array. If any chunk fails, the entire operation fails.
+ * The order of the result is maintained regardless of the completion order of the
+ * chunks, but not that there is no requirement that the callback must return one
+ * result per input element (i.e. the number of result elements might differ from the
+ * number of input elements).
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param workItems - The array of items to process.
+ * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+ * @param performWorkCallback - An async function that processes a chunk and returns results.
+ * @param options - Optional configuration for parallelism control.
+ * @returns A promise that resolves to a flattened array of all results.
+ * @throws {Error} If `chunkSize` is not a positive integer or `numWorkers` is not a positive integer.
+ * @throws {PartialExecutionError} If `performWorkCallback` throws an error for any chunk, providing details about succeeded, failed, and unprocessed items.
+ *
+ * @example
+ * ```ts
+ * // Batch retrieve assets from CDF with controlled parallelism
+ * const assetIds = [1, 2, 3, ..., 10000];
+ * const assets = await chunkAndProcessInParallel(
+ *   assetIds,
+ *   1000, // Retrieve 1000 assets per request
+ *   async (chunk) => {
+ *     const response = await client.assets.retrieve(
+ *       chunk.map(id => ({ id }))
+ *     );
+ *     return response;
+ *   },
+ *   { numWorkers: 5 } // Process at most 5 chunks concurrently
+ * );
+ * // Result: All assets from all chunks combined
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handle partial execution errors
+ * try {
+ *   const results = await chunkAndProcessInParallel(
+ *     largeDataset,
+ *     100,
+ *     async (chunk) => processChunk(chunk),
+ *     { numWorkers: 3 }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof PartialExecutionError) {
+ *     console.log(`Successfully processed ${error.succeeded.length} items`);
+ *     console.log(`Failed to process ${error.failed.length} items`);
+ *     console.log(`Did not attempt ${error.unprocessed.length} items`);
+ *     console.error('Failure reason:', error.reason);
+ *     // Optionally retry only the failed and unprocessed items
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */ export async function chunkAndProcessInParallel(workItems, chunkSize, performWorkCallback, options) {
+    var _ref;
+    const numWorkers = (_ref = options === null || options === void 0 ? void 0 : options.numWorkers) !== null && _ref !== void 0 ? _ref : 10;
+    if (numWorkers <= 0 || !Number.isInteger(numWorkers)) {
+        throw new Error('numWorkers must be a positive integer');
+    }
+    const chunks = Array.from(chunkArray(workItems, chunkSize));
+    if (chunks.length === 0) {
+        return [];
+    }
+    // Results array to maintain order
+    const results = new Array(chunks.length);
+    // Track processing state
+    let nextChunkIndex = 0;
+    let stopped = false;
+    const completedChunks = new Set();
+    // Worker function that keeps processing chunks until done or stopped
+    const worker = async ()=>{
+        while(!stopped && nextChunkIndex < chunks.length){
+            const currentIndex = nextChunkIndex++;
+            try {
+                const result = await performWorkCallback(chunks[currentIndex]);
+                results[currentIndex] = result;
+                completedChunks.add(currentIndex);
+            } catch (error) {
+                stopped = true;
+                // Calculate succeeded, failed, and unprocessed items
+                const succeeded = [];
+                const succeededResults = [];
+                const unprocessed = [];
+                for(let i = 0; i < chunks.length; i++){
+                    if (completedChunks.has(i)) {
+                        succeeded.push(...chunks[i]);
+                        succeededResults.push(...results[i]);
+                    } else if (i !== currentIndex) {
+                        unprocessed.push(...chunks[i]);
+                    }
+                }
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                throw new PartialExecutionError(errorObj, succeeded, succeededResults, chunks[currentIndex], unprocessed);
+            }
+        }
+    };
+    // Start up to numWorkers workers
+    const workers = Array.from({
+        length: Math.min(numWorkers, chunks.length)
+    }, ()=>worker());
+    await Promise.all(workers);
+    return results.flat();
+}
+
+//# sourceMappingURL=chunk-and-process-in-parallel.js.map

package/dist/chunk-and-process-in-parallel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chunk-and-process-in-parallel.ts"],"sourcesContent":["import { chunkArray } from './chunk-array';\n\n/**\n * Options for {@link chunkAndProcessInParallel}.\n */\nexport interface ChunkAndProcessOptions {\n  /**\n   * Maximum number of chunks to process in parallel.\n   * @default 10\n   */\n  numWorkers?: number;\n}\n\n/**\n * Error thrown when {@link chunkAndProcessInParallel} fails partway through processing.\n *\n * This error provides detailed information about which items were successfully processed,\n * which items failed, and which items were never attempted.\n *\n * @template T - The type of input elements.\n */\nexport class PartialExecutionError<T, U> extends Error {\n  /**\n   * The underlying error that caused the failure.\n   */\n  public readonly reason: Error;\n\n  /**\n   * Input items from chunks that were successfully processed before the error occurred.\n   */\n  public readonly succeeded: T[];\n\n  /**\n   * Results from the chunks that were successfully processed before the error occurred.\n   */\n  public readonly succeededResults: U[];\n\n  /**\n   * Input items from the chunk that failed and caused the error.\n   */\n  public readonly failed: T[];\n\n  /**\n   * Input items from chunks that were never processed due to the error.\n   * This includes both chunks that were never started and chunks that were\n   * in-progress when the error occurred.\n   */\n  public readonly unprocessed: T[];\n\n  constructor(\n    reason: Error,\n    succeeded: T[],\n    succeededResults: U[],\n    failed: T[],\n    unprocessed: T[]\n  ) {\n    super(\n      `${reason.message} (succeeded: ${succeeded.length}, failed: ${failed.length}, unprocessed: ${unprocessed.length})`\n    );\n    this.name = 'PartialExecutionError';\n    this.reason = reason;\n    this.succeeded = succeeded;\n    this.succeededResults = succeededResults;\n    this.failed = failed;\n    this.unprocessed = unprocessed;\n    this.message = `Processing failed for ${failed.length} items: ${reason.message}`;\n  }\n}\n\n/**\n * Splits an array into chunks and processes each chunk in parallel using a callback function.\n *\n * This function is useful for batch processing large datasets where you want to:\n * - Limit the number of items processed at once (e.g., API limits)\n * - Process multiple chunks simultaneously for better performance\n * - Control the degree of parallelism to avoid overwhelming resources\n *\n * The function maintains a saturated queue up to `numWorkers` concurrent operations.\n * When one chunk completes, the next chunk starts immediately, ensuring optimal throughput.\n *\n * All chunks are processed with controlled parallelism, and the results are flattened into\n * a single array. If any chunk fails, the entire operation fails.\n * The order of the result is maintained regardless of the completion order of the\n * chunks, but not that there is no requirement that the callback must return one\n * result per input element (i.e. the number of result elements might differ from the\n * number of input elements).\n *\n * @template T - The type of elements in the input array.\n * @template U - The type of elements in the output array.\n * @param workItems - The array of items to process.\n * @param chunkSize - The maximum size of each chunk. Must be a positive integer.\n * @param performWorkCallback - An async function that processes a chunk and returns results.\n * @param options - Optional configuration for parallelism control.\n * @returns A promise that resolves to a flattened array of all results.\n * @throws {Error} If `chunkSize` is not a positive integer or `numWorkers` is not a positive integer.\n * @throws {PartialExecutionError} If `performWorkCallback` throws an error for any chunk, providing details about succeeded, failed, and unprocessed items.\n *\n * @example\n * ```ts\n * // Batch retrieve assets from CDF with controlled parallelism\n * const assetIds = [1, 2, 3, ..., 10000];\n * const assets = await chunkAndProcessInParallel(\n *   assetIds,\n *   1000, // Retrieve 1000 assets per request\n *   async (chunk) => {\n *     const response = await client.assets.retrieve(\n *       chunk.map(id => ({ id }))\n *     );\n *     return response;\n *   },\n *   { numWorkers: 5 } // Process at most 5 chunks concurrently\n * );\n * // Result: All assets from all chunks combined\n * ```\n *\n * @example\n * ```ts\n * // Handle partial execution errors\n * try {\n *   const results = await chunkAndProcessInParallel(\n *     largeDataset,\n *     100,\n *     async (chunk) => processChunk(chunk),\n *     { numWorkers: 3 }\n *   );\n * } catch (error) {\n *   if (error instanceof PartialExecutionError) {\n *     console.log(`Successfully processed ${error.succeeded.length} items`);\n *     console.log(`Failed to process ${error.failed.length} items`);\n *     console.log(`Did not attempt ${error.unprocessed.length} items`);\n *     console.error('Failure reason:', error.reason);\n *     // Optionally retry only the failed and unprocessed items\n *   }\n *   throw error;\n * }\n * ```\n */\nexport async function chunkAndProcessInParallel<T, U>(\n  workItems: T[],\n  chunkSize: number,\n  performWorkCallback: (workItemsChunk: T[]) => Promise<U[]>,\n  options?: ChunkAndProcessOptions\n): Promise<U[]> {\n  const numWorkers = options?.numWorkers ?? 10;\n  if (numWorkers <= 0 || !Number.isInteger(numWorkers)) {\n    throw new Error('numWorkers must be a positive integer');\n  }\n\n  const chunks = Array.from(chunkArray(workItems, chunkSize));\n  if (chunks.length === 0) {\n    return [];\n  }\n\n  // Results array to maintain order\n  const results: U[][] = new Array(chunks.length);\n\n  // Track processing state\n  let nextChunkIndex = 0;\n  let stopped = false;\n  const completedChunks = new Set<number>();\n\n  // Worker function that keeps processing chunks until done or stopped\n  const worker = async (): Promise<void> => {\n    while (!stopped && nextChunkIndex < chunks.length) {\n      const currentIndex = nextChunkIndex++;\n      try {\n        const result = await performWorkCallback(chunks[currentIndex]);\n        results[currentIndex] = result;\n        completedChunks.add(currentIndex);\n      } catch (error) {\n        stopped = true;\n\n        // Calculate succeeded, failed, and unprocessed items\n        const succeeded: T[] = [];\n        const succeededResults: U[] = [];\n        const unprocessed: T[] = [];\n\n        for (let i = 0; i < chunks.length; i++) {\n          if (completedChunks.has(i)) {\n            succeeded.push(...chunks[i]);\n            succeededResults.push(...results[i]);\n          } else if (i !== currentIndex) {\n            unprocessed.push(...chunks[i]);\n          }\n        }\n\n        const errorObj =\n          error instanceof Error ? error : new Error(String(error));\n        throw new PartialExecutionError<T, U>(\n          errorObj,\n          succeeded,\n          succeededResults,\n          chunks[currentIndex],\n          unprocessed\n        );\n      }\n    }\n  };\n\n  // Start up to numWorkers workers\n  const workers = Array.from(\n    { length: Math.min(numWorkers, chunks.length) },\n    () => worker()\n  );\n\n  await Promise.all(workers);\n  return results.flat();\n}\n"],"names":["chunkArray","PartialExecutionError","Error","reason","succeeded","succeededResults","failed","unprocessed","message","length","name","chunkAndProcessInParallel","workItems","chunkSize","performWorkCallback","options","numWorkers","Number","isInteger","chunks","Array","from","results","nextChunkIndex","stopped","completedChunks","Set","worker","currentIndex","result","add","error","i","has","push","errorObj","String","workers","Math","min","Promise","all","flat"],"mappings":"AAAA,SAASA,UAAU,QAAQ,mBAAgB;AAa3C;;;;;;;CAOC,GACD,OAAO,MAAMC,8BAAoCC;IA4B/C,YACEC,MAAa,EACbC,SAAc,EACdC,gBAAqB,EACrBC,MAAW,EACXC,WAAgB,CAChB;QACA,KAAK,CACH,GAAGJ,OAAOK,OAAO,CAAC,aAAa,EAAEJ,UAAUK,MAAM,CAAC,UAAU,EAAEH,OAAOG,MAAM,CAAC,eAAe,EAAEF,YAAYE,MAAM,CAAC,CAAC,CAAC;QAEpH,IAAI,CAACC,IAAI,GAAG;QACZ,IAAI,CAACP,MAAM,GAAGA;QACd,IAAI,CAACC,SAAS,GAAGA;QACjB,IAAI,CAACC,gBAAgB,GAAGA;QACxB,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACC,WAAW,GAAGA;QACnB,IAAI,CAACC,OAAO,GAAG,CAAC,sBAAsB,EAAEF,OAAOG,MAAM,CAAC,QAAQ,EAAEN,OAAOK,OAAO,EAAE;IAClF;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEC,GACD,OAAO,eAAeG,0BACpBC,SAAc,EACdC,SAAiB,EACjBC,mBAA0D,EAC1DC,OAAgC;;IAEhC,MAAMC,qBAAaD,oBAAAA,8BAAAA,QAASC,UAAU,uCAAI;IAC1C,IAAIA,cAAc,KAAK,CAACC,OAAOC,SAAS,CAACF,aAAa;QACpD,MAAM,IAAId,MAAM;IAClB;IAEA,MAAMiB,SAASC,MAAMC,IAAI,CAACrB,WAAWY,WAAWC;IAChD,IAAIM,OAAOV,MAAM,KAAK,GAAG;QACvB,OAAO,EAAE;IACX;IAEA,kCAAkC;IAClC,MAAMa,UAAiB,IAAIF,MAAMD,OAAOV,MAAM;IAE9C,yBAAyB;IACzB,IAAIc,iBAAiB;IACrB,IAAIC,UAAU;IACd,MAAMC,kBAAkB,IAAIC;IAE5B,qEAAqE;IACrE,MAAMC,SAAS;QACb,MAAO,CAACH,WAAWD,iBAAiBJ,OAAOV,MAAM,CAAE;YACjD,MAAMmB,eAAeL;YACrB,IAAI;gBACF,MAAMM,SAAS,MAAMf,oBAAoBK,MAAM,CAACS,aAAa;gBAC7DN,OAAO,CAACM,aAAa,GAAGC;gBACxBJ,gBAAgBK,GAAG,CAACF;YACtB,EAAE,OAAOG,OAAO;gBACdP,UAAU;gBAEV,qDAAqD;gBACrD,MAAMpB,YAAiB,EAAE;gBACzB,MAAMC,mBAAwB,EAAE;gBAChC,MAAME,cAAmB,EAAE;gBAE3B,IAAK,IAAIyB,IAAI,GAAGA,IAAIb,OAAOV,MAAM,EAAEuB,IAAK;oBACtC,IAAIP,gBAAgBQ,GAAG,CAACD,IAAI;wBAC1B5B,UAAU8B,IAAI,IAAIf,MAAM,CAACa,EAAE;wBAC3B3B,iBAAiB6B,IAAI,IAAIZ,OAAO,CAACU,EAAE;oBACrC,OAAO,IAAIA,MAAMJ,cAAc;wBAC7BrB,YAAY2B,IAAI,IAAIf,MAAM,CAACa,EAAE;oBAC/B;gBACF;gBAEA,MAAMG,WACJJ,iBAAiB7B,QAAQ6B,QAAQ,IAAI7B,MAAMkC,OAAOL;gBACpD,MAAM,IAAI9B,sBACRkC,UACA/B,WACAC,kBACAc,MAAM,CAACS,aAAa,EACpBrB;YAEJ;QACF;IACF;IAEA,iCAAiC;IACjC,MAAM8B,UAAUjB,MAAMC,IAAI,CACxB;QAAEZ,QAAQ6B,KAAKC,GAAG,CAACvB,YAAYG,OAAOV,MAAM;IAAE,GAC9C,IAAMkB;IAGR,MAAMa,QAAQC,GAAG,CAACJ;IAClB,OAAOf,QAAQoB,IAAI;AACrB"}

package/dist/chunk-array.d.ts

@@ -1,27 +1,27 @@
 /**
- * Splits an array into smaller chunks of a specified size using a generator. If the
- * array length is not evenly divisible by `chunkSize`, the final chunk will contain
- * the remaining elements.
- *
- * @template T - The type of elements in the array.
- * @param array - The array to split into chunks.
- * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
- * @returns A generator that yields arrays of size `chunkSize` (or smaller for the last chunk).
- * @throws {Error} If `chunkSize` is not a positive integer.
- *
- * @example
- * ```ts
- * // Basic usage
- * const chunks = Array.from(chunkArray([1, 2, 3, 4, 5], 2));
- * // Result: [[1, 2], [3, 4], [5]]
- * ```
- *
- * @example
- * ```ts
- * // Process chunks lazily using for...of
- * for (const chunk of chunkArray([1, 2, 3, 4, 5, 6], 3)) {
- *   console.log(chunk); // Logs: [1, 2, 3], then [4, 5, 6]
- * }
- * ```
- */
+* Splits an array into smaller chunks of a specified size using a generator. If the
+* array length is not evenly divisible by `chunkSize`, the final chunk will contain
+* the remaining elements.
+*
+* @template T - The type of elements in the array.
+* @param array - The array to split into chunks.
+* @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+* @returns A generator that yields arrays of size `chunkSize` (or smaller for the last chunk).
+* @throws {Error} If `chunkSize` is not a positive integer.
+*
+* @example
+* ```ts
+* // Basic usage
+* const chunks = Array.from(chunkArray([1, 2, 3, 4, 5], 2));
+* // Result: [[1, 2], [3, 4], [5]]
+* ```
+*
+* @example
+* ```ts
+* // Process chunks lazily using for...of
+* for (const chunk of chunkArray([1, 2, 3, 4, 5, 6], 3)) {
+*   console.log(chunk); // Logs: [1, 2, 3], then [4, 5, 6]
+* }
+* ```
+*/
 export declare function chunkArray<T>(array: T[], chunkSize: number): Generator<T[], void, unknown>;

package/dist/chunk-array.js

@@ -1,7 +1,35 @@
-//#region libs/shared/underscore/src/chunk-array.ts
-function* e(e, t) {
-	if (t <= 0 || !Number.isInteger(t)) throw Error(`chunkSize must be an integer greater than 0, but got ${t}`);
-	for (let n = 0; n < e.length; n += t) yield e.slice(n, n + t);
+/**
+ * Splits an array into smaller chunks of a specified size using a generator. If the
+ * array length is not evenly divisible by `chunkSize`, the final chunk will contain
+ * the remaining elements.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to split into chunks.
+ * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+ * @returns A generator that yields arrays of size `chunkSize` (or smaller for the last chunk).
+ * @throws {Error} If `chunkSize` is not a positive integer.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const chunks = Array.from(chunkArray([1, 2, 3, 4, 5], 2));
+ * // Result: [[1, 2], [3, 4], [5]]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Process chunks lazily using for...of
+ * for (const chunk of chunkArray([1, 2, 3, 4, 5, 6], 3)) {
+ *   console.log(chunk); // Logs: [1, 2, 3], then [4, 5, 6]
+ * }
+ * ```
+ */ export function* chunkArray(array, chunkSize) {
+    if (chunkSize <= 0 || !Number.isInteger(chunkSize)) {
+        throw new Error(`chunkSize must be an integer greater than 0, but got ${chunkSize}`);
+    }
+    for(let i = 0; i < array.length; i += chunkSize){
+        yield array.slice(i, i + chunkSize);
+    }
 }
-//#endregion
-export { e as chunkArray };
+
+//# sourceMappingURL=chunk-array.js.map

package/dist/chunk-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chunk-array.ts"],"sourcesContent":["/**\n * Splits an array into smaller chunks of a specified size using a generator. If the\n * array length is not evenly divisible by `chunkSize`, the final chunk will contain\n * the remaining elements.\n *\n * @template T - The type of elements in the array.\n * @param array - The array to split into chunks.\n * @param chunkSize - The maximum size of each chunk. Must be a positive integer.\n * @returns A generator that yields arrays of size `chunkSize` (or smaller for the last chunk).\n * @throws {Error} If `chunkSize` is not a positive integer.\n *\n * @example\n * ```ts\n * // Basic usage\n * const chunks = Array.from(chunkArray([1, 2, 3, 4, 5], 2));\n * // Result: [[1, 2], [3, 4], [5]]\n * ```\n *\n * @example\n * ```ts\n * // Process chunks lazily using for...of\n * for (const chunk of chunkArray([1, 2, 3, 4, 5, 6], 3)) {\n *   console.log(chunk); // Logs: [1, 2, 3], then [4, 5, 6]\n * }\n * ```\n */\nexport function* chunkArray<T>(\n  array: T[],\n  chunkSize: number\n): Generator<T[], void, unknown> {\n  if (chunkSize <= 0 || !Number.isInteger(chunkSize)) {\n    throw new Error(\n      `chunkSize must be an integer greater than 0, but got ${chunkSize}`\n    );\n  }\n\n  for (let i = 0; i < array.length; i += chunkSize) {\n    yield array.slice(i, i + chunkSize);\n  }\n}\n"],"names":["chunkArray","array","chunkSize","Number","isInteger","Error","i","length","slice"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,UAAUA,WACfC,KAAU,EACVC,SAAiB;IAEjB,IAAIA,aAAa,KAAK,CAACC,OAAOC,SAAS,CAACF,YAAY;QAClD,MAAM,IAAIG,MACR,CAAC,qDAAqD,EAAEH,WAAW;IAEvE;IAEA,IAAK,IAAII,IAAI,GAAGA,IAAIL,MAAMM,MAAM,EAAED,KAAKJ,UAAW;QAChD,MAAMD,MAAMO,KAAK,CAACF,GAAGA,IAAIJ;IAC3B;AACF"}

package/dist/class.d.ts

@@ -1,12 +1,12 @@
 export type Class<T> = Function & {
-    prototype: T;
+	prototype: T;
 };
 /**
- * Returns true if the value is an instance of the given class type.
- *
- * @template T - The type of the class instance.
- * @param value - The value to check
- * @param classType - The class type to expect.
- * @returns True if the value is an instance of the given class type.
- */
+* Returns true if the value is an instance of the given class type.
+*
+* @template T - The type of the class instance.
+* @param value - The value to check
+* @param classType - The class type to expect.
+* @returns True if the value is an instance of the given class type.
+*/
 export declare function isInstanceOf<T>(value: unknown, classType: Class<T>): value is T;

package/dist/class.js

@@ -1,6 +1,12 @@
-//#region libs/shared/underscore/src/class.ts
-function e(e, t) {
-	return e instanceof t;
+/**
+ * Returns true if the value is an instance of the given class type.
+ *
+ * @template T - The type of the class instance.
+ * @param value - The value to check
+ * @param classType - The class type to expect.
+ * @returns True if the value is an instance of the given class type.
+ */ export function isInstanceOf(value, classType) {
+    return value instanceof classType;
 }
-//#endregion
-export { e as isInstanceOf };
+
+//# sourceMappingURL=class.js.map

package/dist/class.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/class.ts"],"sourcesContent":["export type Class<T> = Function & { prototype: T };\n\n/**\n * Returns true if the value is an instance of the given class type.\n *\n * @template T - The type of the class instance.\n * @param value - The value to check\n * @param classType - The class type to expect.\n * @returns True if the value is an instance of the given class type.\n */\nexport function isInstanceOf<T>(\n  value: unknown,\n  classType: Class<T>\n): value is T {\n  return value instanceof classType;\n}\n"],"names":["isInstanceOf","value","classType"],"mappings":"AAEA;;;;;;;CAOC,GACD,OAAO,SAASA,aACdC,KAAc,EACdC,SAAmB;IAEnB,OAAOD,iBAAiBC;AAC1B"}

package/dist/exhaustive-guard.d.ts

@@ -1,17 +1,17 @@
 /**
- * This will cause a type error if the switch statement is not exhaustive.
- *
- * @example
- * ```ts
- * type Value = 'a' | 'b';
- * const value: Value = 'a';
- * switch (value) {
- *  case 'a':
- *   return 'A';
- *  default:
- *    // This will cause a type error as we are missing the case for 'b'
- *    return exhaustiveGuard(value);
- * }
- * ```
- */
+* This will cause a type error if the switch statement is not exhaustive.
+*
+* @example
+* ```ts
+* type Value = 'a' | 'b';
+* const value: Value = 'a';
+* switch (value) {
+*  case 'a':
+*   return 'A';
+*  default:
+*    // This will cause a type error as we are missing the case for 'b'
+*    return exhaustiveGuard(value);
+* }
+* ```
+*/
 export declare function exhaustiveGuard(_value: never): never;

package/dist/exhaustive-guard.js

@@ -1,6 +1,20 @@
-//#region libs/shared/underscore/src/exhaustive-guard.ts
-function e(e) {
-	throw Error(`ERROR! Reached forbidden guard function with unexpected value: ${JSON.stringify(e)}`);
+/**
+ * This will cause a type error if the switch statement is not exhaustive.
+ *
+ * @example
+ * ```ts
+ * type Value = 'a' | 'b';
+ * const value: Value = 'a';
+ * switch (value) {
+ *  case 'a':
+ *   return 'A';
+ *  default:
+ *    // This will cause a type error as we are missing the case for 'b'
+ *    return exhaustiveGuard(value);
+ * }
+ * ```
+ */ export function exhaustiveGuard(_value) {
+    throw new Error(`ERROR! Reached forbidden guard function with unexpected value: ${JSON.stringify(_value)}`);
 }
-//#endregion
-export { e as exhaustiveGuard };
+
+//# sourceMappingURL=exhaustive-guard.js.map

package/dist/exhaustive-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/exhaustive-guard.ts"],"sourcesContent":["/**\n * This will cause a type error if the switch statement is not exhaustive.\n *\n * @example\n * ```ts\n * type Value = 'a' | 'b';\n * const value: Value = 'a';\n * switch (value) {\n *  case 'a':\n *   return 'A';\n *  default:\n *    // This will cause a type error as we are missing the case for 'b'\n *    return exhaustiveGuard(value);\n * }\n * ```\n */\nexport function exhaustiveGuard(_value: never): never {\n  throw new Error(\n    `ERROR! Reached forbidden guard function with unexpected value: ${JSON.stringify(\n      _value\n    )}`\n  );\n}\n"],"names":["exhaustiveGuard","_value","Error","JSON","stringify"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASA,gBAAgBC,MAAa;IAC3C,MAAM,IAAIC,MACR,CAAC,+DAA+D,EAAEC,KAAKC,SAAS,CAC9EH,SACC;AAEP"}

package/dist/exponential-backoff-with-jitter.d.ts

@@ -1,15 +1,15 @@
 /**
- * Calculates the delay in milliseconds for the next retry attempt. Uses "exponential backoff with
- * full jitter" algorithm.
- *
- * `floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))`
- *
- * @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
- *
- * @param attempt - The current attempt (1-based).
- * @param baseDelayInMs - The base delay in milliseconds. Default is 250ms.
- * @param maxDelayInMs - The maximum delay in milliseconds. Default is 15,000ms (15 seconds).
- * @param randomCallback - A callback function that returns a random number between 0 (inclusive) and 1 (exclusive). Default is Math.random. Provided for testing/mocking purposes.
- * @returns The delay in milliseconds for the next retry attempt.
- */
+* Calculates the delay in milliseconds for the next retry attempt. Uses "exponential backoff with
+* full jitter" algorithm.
+*
+* `floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))`
+*
+* @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+*
+* @param attempt - The current attempt (1-based).
+* @param baseDelayInMs - The base delay in milliseconds. Default is 250ms.
+* @param maxDelayInMs - The maximum delay in milliseconds. Default is 15,000ms (15 seconds).
+* @param randomCallback - A callback function that returns a random number between 0 (inclusive) and 1 (exclusive). Default is Math.random. Provided for testing/mocking purposes.
+* @returns The delay in milliseconds for the next retry attempt.
+*/
 export declare function exponentialBackoffWithJitter(attempt: number, baseDelayInMs?: number, maxDelayInMs?: number, randomCallback?: typeof Math.random): number;

package/dist/exponential-backoff-with-jitter.js

@@ -1,8 +1,24 @@
-//#region libs/shared/underscore/src/exponential-backoff-with-jitter.ts
-function e(e, t = 250, n = 15e3, r = Math.random) {
-	if (e < 1) throw Error("`attempt` must be 1 or greater");
-	let i = 2 ** e * t, a = Math.min(i, n);
-	return Math.floor(r() * a);
+/**
+ * Calculates the delay in milliseconds for the next retry attempt. Uses "exponential backoff with
+ * full jitter" algorithm.
+ *
+ * `floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))`
+ *
+ * @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+ *
+ * @param attempt - The current attempt (1-based).
+ * @param baseDelayInMs - The base delay in milliseconds. Default is 250ms.
+ * @param maxDelayInMs - The maximum delay in milliseconds. Default is 15,000ms (15 seconds).
+ * @param randomCallback - A callback function that returns a random number between 0 (inclusive) and 1 (exclusive). Default is Math.random. Provided for testing/mocking purposes.
+ * @returns The delay in milliseconds for the next retry attempt.
+ */ export function exponentialBackoffWithJitter(attempt, baseDelayInMs = 250, maxDelayInMs = 15000, randomCallback = Math.random) {
+    if (attempt < 1) {
+        throw new Error('`attempt` must be 1 or greater');
+    }
+    // = floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))
+    const exponentialDelay = 2 ** attempt * baseDelayInMs;
+    const cappedDelay = Math.min(exponentialDelay, maxDelayInMs);
+    return Math.floor(randomCallback() * cappedDelay);
 }
-//#endregion
-export { e as exponentialBackoffWithJitter };
+
+//# sourceMappingURL=exponential-backoff-with-jitter.js.map

package/dist/exponential-backoff-with-jitter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/exponential-backoff-with-jitter.ts"],"sourcesContent":["/**\n * Calculates the delay in milliseconds for the next retry attempt. Uses \"exponential backoff with\n * full jitter\" algorithm.\n *\n * `floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))`\n *\n * @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/\n *\n * @param attempt - The current attempt (1-based).\n * @param baseDelayInMs - The base delay in milliseconds. Default is 250ms.\n * @param maxDelayInMs - The maximum delay in milliseconds. Default is 15,000ms (15 seconds).\n * @param randomCallback - A callback function that returns a random number between 0 (inclusive) and 1 (exclusive). Default is Math.random. Provided for testing/mocking purposes.\n * @returns The delay in milliseconds for the next retry attempt.\n */\nexport function exponentialBackoffWithJitter(\n  attempt: number,\n  baseDelayInMs = 250,\n  maxDelayInMs = 15_000,\n  randomCallback: typeof Math.random = Math.random\n): number {\n  if (attempt < 1) {\n    throw new Error('`attempt` must be 1 or greater');\n  }\n\n  // = floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))\n  const exponentialDelay = 2 ** attempt * baseDelayInMs;\n  const cappedDelay = Math.min(exponentialDelay, maxDelayInMs);\n  return Math.floor(randomCallback() * cappedDelay);\n}\n"],"names":["exponentialBackoffWithJitter","attempt","baseDelayInMs","maxDelayInMs","randomCallback","Math","random","Error","exponentialDelay","cappedDelay","min","floor"],"mappings":"AAAA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASA,6BACdC,OAAe,EACfC,gBAAgB,GAAG,EACnBC,eAAe,KAAM,EACrBC,iBAAqCC,KAAKC,MAAM;IAEhD,IAAIL,UAAU,GAAG;QACf,MAAM,IAAIM,MAAM;IAClB;IAEA,sEAAsE;IACtE,MAAMC,mBAAmB,KAAKP,UAAUC;IACxC,MAAMO,cAAcJ,KAAKK,GAAG,CAACF,kBAAkBL;IAC/C,OAAOE,KAAKM,KAAK,CAACP,mBAAmBK;AACvC"}

package/dist/generate-unique-name.d.ts

@@ -1,19 +1,19 @@
 /**
- * Generates a unique name based on a prefix and existing names.
- * If no existing names match the prefix, returns the prefix as-is.
- * Otherwise, appends the next available number to the prefix.
- *
- * @param existingNames - Array of existing names to check against
- * @param prefix - The prefix to use for the unique name
- * @returns A unique name that doesn't conflict with existing names
- *
- * @example
- * ```typescript
- * generateUniqueName(['Untitled evaluation', 'Untitled evaluation 1'], 'Untitled evaluation')
- * // Returns: 'Untitled evaluation 2'
- *
- * generateUniqueName(['Other name'], 'Untitled evaluation')
- * // Returns: 'Untitled evaluation'
- * ```
- */
+* Generates a unique name based on a prefix and existing names.
+* If no existing names match the prefix, returns the prefix as-is.
+* Otherwise, appends the next available number to the prefix.
+*
+* @param existingNames - Array of existing names to check against
+* @param prefix - The prefix to use for the unique name
+* @returns A unique name that doesn't conflict with existing names
+*
+* @example
+* ```typescript
+* generateUniqueName(['Untitled evaluation', 'Untitled evaluation 1'], 'Untitled evaluation')
+* // Returns: 'Untitled evaluation 2'
+*
+* generateUniqueName(['Other name'], 'Untitled evaluation')
+* // Returns: 'Untitled evaluation'
+* ```
+*/
 export declare function generateUniqueName(existingNames: string[], prefix: string): string;

package/dist/generate-unique-name.js

@@ -1,11 +1,47 @@
-//#region libs/shared/underscore/src/generate-unique-name.ts
-function e(e, t) {
-	let n = e.filter((e) => e.startsWith(t));
-	return n.length === 0 ? t : `${t} ${n.reduce((e, n) => {
-		if (n === t) return Math.max(e, 0);
-		let r = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), i = n.match(RegExp(`^${r} (\\d+)(?:.*)?$`));
-		return i || (i = n.match(RegExp(`^${r}[^\\w]*(\\d+)(?:.*)?$`)), i) ? Math.max(e, parseInt(i[1], 10)) : Math.max(e, 0);
-	}, 0) + 1}`;
+/**
+ * Generates a unique name based on a prefix and existing names.
+ * If no existing names match the prefix, returns the prefix as-is.
+ * Otherwise, appends the next available number to the prefix.
+ *
+ * @param existingNames - Array of existing names to check against
+ * @param prefix - The prefix to use for the unique name
+ * @returns A unique name that doesn't conflict with existing names
+ *
+ * @example
+ * ```typescript
+ * generateUniqueName(['Untitled evaluation', 'Untitled evaluation 1'], 'Untitled evaluation')
+ * // Returns: 'Untitled evaluation 2'
+ *
+ * generateUniqueName(['Other name'], 'Untitled evaluation')
+ * // Returns: 'Untitled evaluation'
+ * ```
+ */ export function generateUniqueName(existingNames, prefix) {
+    const matchingNames = existingNames.filter((name)=>name.startsWith(prefix));
+    if (matchingNames.length === 0) {
+        return prefix;
+    }
+    const maxNumber = matchingNames.reduce((max, name)=>{
+        if (name === prefix) {
+            return Math.max(max, 0);
+        }
+        // Try to extract any number that appears after the prefix
+        // This handles cases like "Test (1)", "Test.1", "Test 1", etc.
+        const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Pattern 1: prefix + space + number + optional text
+        let match = name.match(new RegExp(`^${escapedPrefix} (\\d+)(?:.*)?$`));
+        if (match) {
+            return Math.max(max, parseInt(match[1], 10));
+        }
+        // Pattern 2: prefix + any non-word character + number + optional text
+        match = name.match(new RegExp(`^${escapedPrefix}[^\\w]*(\\d+)(?:.*)?$`));
+        if (match) {
+            return Math.max(max, parseInt(match[1], 10));
+        }
+        // If the name starts with prefix but doesn't follow any numbered pattern,
+        // treat it as if it's the base prefix (equivalent to having number 0)
+        return Math.max(max, 0);
+    }, 0);
+    return `${prefix} ${maxNumber + 1}`;
 }
-//#endregion
-export { e as generateUniqueName };
+
+//# sourceMappingURL=generate-unique-name.js.map

package/dist/generate-unique-name.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generate-unique-name.ts"],"sourcesContent":["/**\n * Generates a unique name based on a prefix and existing names.\n * If no existing names match the prefix, returns the prefix as-is.\n * Otherwise, appends the next available number to the prefix.\n *\n * @param existingNames - Array of existing names to check against\n * @param prefix - The prefix to use for the unique name\n * @returns A unique name that doesn't conflict with existing names\n *\n * @example\n * ```typescript\n * generateUniqueName(['Untitled evaluation', 'Untitled evaluation 1'], 'Untitled evaluation')\n * // Returns: 'Untitled evaluation 2'\n *\n * generateUniqueName(['Other name'], 'Untitled evaluation')\n * // Returns: 'Untitled evaluation'\n * ```\n */\nexport function generateUniqueName(\n  existingNames: string[],\n  prefix: string\n): string {\n  const matchingNames = existingNames.filter((name) => name.startsWith(prefix));\n\n  if (matchingNames.length === 0) {\n    return prefix;\n  }\n\n  const maxNumber = matchingNames.reduce((max, name) => {\n    if (name === prefix) {\n      return Math.max(max, 0);\n    }\n\n    // Try to extract any number that appears after the prefix\n    // This handles cases like \"Test (1)\", \"Test.1\", \"Test 1\", etc.\n    const escapedPrefix = prefix.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n    // Pattern 1: prefix + space + number + optional text\n    let match = name.match(new RegExp(`^${escapedPrefix} (\\\\d+)(?:.*)?$`));\n    if (match) {\n      return Math.max(max, parseInt(match[1], 10));\n    }\n\n    // Pattern 2: prefix + any non-word character + number + optional text\n    match = name.match(new RegExp(`^${escapedPrefix}[^\\\\w]*(\\\\d+)(?:.*)?$`));\n    if (match) {\n      return Math.max(max, parseInt(match[1], 10));\n    }\n\n    // If the name starts with prefix but doesn't follow any numbered pattern,\n    // treat it as if it's the base prefix (equivalent to having number 0)\n    return Math.max(max, 0);\n  }, 0);\n\n  return `${prefix} ${maxNumber + 1}`;\n}\n"],"names":["generateUniqueName","existingNames","prefix","matchingNames","filter","name","startsWith","length","maxNumber","reduce","max","Math","escapedPrefix","replace","match","RegExp","parseInt"],"mappings":"AAAA;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,SAASA,mBACdC,aAAuB,EACvBC,MAAc;IAEd,MAAMC,gBAAgBF,cAAcG,MAAM,CAAC,CAACC,OAASA,KAAKC,UAAU,CAACJ;IAErE,IAAIC,cAAcI,MAAM,KAAK,GAAG;QAC9B,OAAOL;IACT;IAEA,MAAMM,YAAYL,cAAcM,MAAM,CAAC,CAACC,KAAKL;QAC3C,IAAIA,SAASH,QAAQ;YACnB,OAAOS,KAAKD,GAAG,CAACA,KAAK;QACvB;QAEA,0DAA0D;QAC1D,+DAA+D;QAC/D,MAAME,gBAAgBV,OAAOW,OAAO,CAAC,uBAAuB;QAE5D,qDAAqD;QACrD,IAAIC,QAAQT,KAAKS,KAAK,CAAC,IAAIC,OAAO,CAAC,CAAC,EAAEH,cAAc,eAAe,CAAC;QACpE,IAAIE,OAAO;YACT,OAAOH,KAAKD,GAAG,CAACA,KAAKM,SAASF,KAAK,CAAC,EAAE,EAAE;QAC1C;QAEA,sEAAsE;QACtEA,QAAQT,KAAKS,KAAK,CAAC,IAAIC,OAAO,CAAC,CAAC,EAAEH,cAAc,qBAAqB,CAAC;QACtE,IAAIE,OAAO;YACT,OAAOH,KAAKD,GAAG,CAACA,KAAKM,SAASF,KAAK,CAAC,EAAE,EAAE;QAC1C;QAEA,0EAA0E;QAC1E,sEAAsE;QACtE,OAAOH,KAAKD,GAAG,CAACA,KAAK;IACvB,GAAG;IAEH,OAAO,GAAGR,OAAO,CAAC,EAAEM,YAAY,GAAG;AACrC"}

package/dist/get-numbers-between.d.ts

@@ -1,17 +1,17 @@
 /**
- * Generates a sequence of numbers between the specified range.
- *
- * @param minInclusive - The starting number of the sequence (inclusive).
- * @param maxExclusive - The ending number of the sequence (exclusive).
- * @param step - The step value to increment by (default is 1).
- * @returns A generator that yields numbers between the specified range.
- *
- * @example
- * ```ts
- * const numbers = getNumbersBetween(1, 5);
- * for (const num of numbers) {
- *   console.log(num); // 1, 2, 3, 4
- * }
- * ```
- */
+* Generates a sequence of numbers between the specified range.
+*
+* @param minInclusive - The starting number of the sequence (inclusive).
+* @param maxExclusive - The ending number of the sequence (exclusive).
+* @param step - The step value to increment by (default is 1).
+* @returns A generator that yields numbers between the specified range.
+*
+* @example
+* ```ts
+* const numbers = getNumbersBetween(1, 5);
+* for (const num of numbers) {
+*   console.log(num); // 1, 2, 3, 4
+* }
+* ```
+*/
 export declare function getNumbersBetween(minInclusive: number, maxExclusive: number, step?: number): Generator<number>;