@vielzeug/toolkit 1.1.3 → 2.1.0

package/dist/array/select.js.map

@@ -1 +1 @@
-{"version":3,"file":"select.js","sources":["../../src/array/select.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { isPromise } from '../typed/isPromise';\nimport type { CallbackDynamic, Predicate, ResultArray } from '../types';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * await select(arr, async x => x * x, x => x > 2) // [9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R, C extends CallbackDynamic<T, R>>(\n  array: T[],\n  callback: C,\n  predicate?: Predicate<T>,\n): ResultArray<C> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = [];\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return (isPromise(callback) ? Promise.all(result) : result) as ResultArray<C>;\n}\n\nselect.fp = true;\n"],"names":["select","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","result","isValid","value","isNil","index","isPromise"],"mappings":";;;;AAwBO,SAASA,EACdC,GACAC,GACAC,GACgB;AAChB,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAS,CAAA,GAETC,IAAUL,MAAc,CAACM,MAAa,CAACC,EAAMD,CAAK;AAExD,WAASE,IAAQ,GAAGA,IAAQV,EAAM,QAAQU;AACxC,IAAIH,EAAQP,EAAMU,CAAK,GAAGA,GAAOV,CAAK,KACpCM,EAAO,KAAKL,EAASD,EAAMU,CAAK,GAAGA,GAAOV,CAAK,CAAC;AAIpD,SAAQW,EAAUV,CAAQ,IAAI,QAAQ,IAAIK,CAAM,IAAIA;AACtD;AAEAP,EAAO,KAAK;"}
+{"version":3,"file":"select.js","names":[],"sources":["../../src/array/select.ts"],"sourcesContent":["import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * select(arr, x => x * x) // [1, 4, 9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: Predicate<T>,\n): R[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n  const result: R[] = [];\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;AAwBA,SAAgB,EACd,GACA,GACA,GACK;AACL,GAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC;CAEhF,IAAM,IAAU,OAAe,MAAa,CAAC,EAAM,EAAM,GACnD,IAAc,EAAE;AAEtB,MAAK,IAAI,IAAQ,GAAG,IAAQ,EAAM,QAAQ,IACxC,CAAI,EAAQ,EAAM,IAAQ,GAAO,EAAM,IACrC,EAAO,KAAK,EAAS,EAAM,IAAQ,GAAO,EAAM,CAAC;AAIrD,QAAO"}

package/dist/array/sort.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs"),p=require("../function/compare.cjs"),t=require("../typed/isArray.cjs"),s=(r,e,o=!1)=>{n.assert(t.isArray(r),t.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError});const i=o?-1:1;return[...r].sort((u,c)=>p.compare(e(u),e(c))*i)};s.fp=!0;exports.sort=s;
-//# sourceMappingURL=sort.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../function/compare.cjs`),r=require(`../function/compareBy.cjs`);function i(i,a,o=`asc`){if(e.assert(t.isArray(i),t.IS_ARRAY_ERROR_MSG,{args:{array:i},type:TypeError}),typeof a==`function`){let e=o===`desc`?-1:1;return[...i].sort((t,r)=>n.compare(a(t),a(r))*e)}return[...i].sort(r.compareBy(a))}exports.sort=i;
+//# sourceMappingURL=sort.cjs.map

package/dist/array/sort.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sort.cjs","sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Sorts an array of objects by a specific key in ascending order.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 3 }, { a: 1 }];\n * sort(data, (item) => item.a); // [{ a: 1 }, { a: 2 }, { a: 3 }]\n * ```\n *\n * @param array - The array of objects to sort.\n * @param selector - A function that extracts the key to sort by.\n * @param desc - A boolean indicating whether to sort in descending order (default: false).\n *\n * @returns A new array sorted by the specified key.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const sort = <T>(array: T[], selector: (item: T) => any, desc = false) => {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const multiplier = desc ? -1 : 1;\n\n  return [...array].sort((a, b) => compare(selector(a), selector(b)) * multiplier);\n};\n\nsort.fp = true;\n"],"names":["sort","array","selector","desc","assert","isArray","IS_ARRAY_ERROR_MSG","multiplier","a","b","compare"],"mappings":"iMAsBaA,EAAO,CAAIC,EAAYC,EAA4BC,EAAO,KAAU,CAC/EC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAK,EAAGK,qBAAoB,CAAE,KAAM,CAAE,MAAAL,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMM,EAAaJ,EAAO,GAAK,EAE/B,MAAO,CAAC,GAAGF,CAAK,EAAE,KAAK,CAACO,EAAGC,IAAMC,EAAAA,QAAQR,EAASM,CAAC,EAAGN,EAASO,CAAC,CAAC,EAAIF,CAAU,CACjF,EAEAP,EAAK,GAAK"}
+{"version":3,"file":"sort.cjs","names":[],"sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { compareBy } from '../function/compareBy';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\nexport type SortDirection = 'asc' | 'desc';\nexport type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;\n\n/**\n * Sorts an array by a selector function (single-field) or by a multi-field\n * object of `{ key: 'asc' | 'desc' }` entries.\n *\n * @example\n * ```ts\n * // Single field\n * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]\n * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]\n *\n * // Multi-field\n * sort(users, { name: 'asc', age: 'desc' });\n * ```\n *\n * @param array - The array to sort.\n * @param selector - A function extracting the sort key, or a multi-field object.\n * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.\n * @returns A new sorted array.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];\nexport function sort<T>(array: T[], selectors: SortSelectors<T>): T[];\nexport function sort<T>(\n  array: T[],\n  selectorOrSelectors: ((item: T) => unknown) | SortSelectors<T>,\n  direction: SortDirection = 'asc',\n): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (typeof selectorOrSelectors === 'function') {\n    const multiplier = direction === 'desc' ? -1 : 1;\n\n    return [...array].sort((a, b) => compare(selectorOrSelectors(a), selectorOrSelectors(b)) * multiplier);\n  }\n\n  return [...array].sort(compareBy(selectorOrSelectors));\n}\n"],"mappings":"wJA+BA,SAAgB,EACd,EACA,EACA,EAA2B,MACtB,CAGL,GAFA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAE5E,OAAO,GAAwB,WAAY,CAC7C,IAAM,EAAa,IAAc,OAAS,GAAK,EAE/C,MAAO,CAAC,GAAG,EAAM,CAAC,MAAM,EAAG,IAAM,EAAA,QAAQ,EAAoB,EAAE,CAAE,EAAoB,EAAE,CAAC,CAAG,EAAW,CAGxG,MAAO,CAAC,GAAG,EAAM,CAAC,KAAK,EAAA,UAAU,EAAoB,CAAC"}

package/dist/array/sort.d.ts

@@ -0,0 +1,26 @@
+export type SortDirection = 'asc' | 'desc';
+export type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;
+/**
+ * Sorts an array by a selector function (single-field) or by a multi-field
+ * object of `{ key: 'asc' | 'desc' }` entries.
+ *
+ * @example
+ * ```ts
+ * // Single field
+ * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]
+ * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]
+ *
+ * // Multi-field
+ * sort(users, { name: 'asc', age: 'desc' });
+ * ```
+ *
+ * @param array - The array to sort.
+ * @param selector - A function extracting the sort key, or a multi-field object.
+ * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.
+ * @returns A new sorted array.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];
+export declare function sort<T>(array: T[], selectors: SortSelectors<T>): T[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/array/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/array/sort.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAC3C,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,CAAC,EAAE,CAAC;AACpG,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC"}

package/dist/array/sort.js

@@ -1,13 +1,19 @@
 import { assert as e } from "../function/assert.js";
-import { compare as i } from "../function/compare.js";
-import { IS_ARRAY_ERROR_MSG as f, isArray as R } from "../typed/isArray.js";
-const n = (r, o, t = !1) => {
-  e(R(r), f, { args: { array: r }, type: TypeError });
-  const p = t ? -1 : 1;
-  return [...r].sort((m, s) => i(o(m), o(s)) * p);
-};
-n.fp = !0;
-export {
-  n as sort
-};
-//# sourceMappingURL=sort.js.map
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+import { compare as r } from "../function/compare.js";
+import { compareBy as i } from "../function/compareBy.js";
+//#region src/array/sort.ts
+function a(a, o, s = "asc") {
+	if (e(n(a), t, {
+		args: { array: a },
+		type: TypeError
+	}), typeof o == "function") {
+		let e = s === "desc" ? -1 : 1;
+		return [...a].sort((t, n) => r(o(t), o(n)) * e);
+	}
+	return [...a].sort(i(o));
+}
+//#endregion
+export { a as sort };
+
+//# sourceMappingURL=sort.js.map

package/dist/array/sort.js.map

@@ -1 +1 @@
-{"version":3,"file":"sort.js","sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Sorts an array of objects by a specific key in ascending order.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 3 }, { a: 1 }];\n * sort(data, (item) => item.a); // [{ a: 1 }, { a: 2 }, { a: 3 }]\n * ```\n *\n * @param array - The array of objects to sort.\n * @param selector - A function that extracts the key to sort by.\n * @param desc - A boolean indicating whether to sort in descending order (default: false).\n *\n * @returns A new array sorted by the specified key.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const sort = <T>(array: T[], selector: (item: T) => any, desc = false) => {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const multiplier = desc ? -1 : 1;\n\n  return [...array].sort((a, b) => compare(selector(a), selector(b)) * multiplier);\n};\n\nsort.fp = true;\n"],"names":["sort","array","selector","desc","assert","isArray","IS_ARRAY_ERROR_MSG","multiplier","a","b","compare"],"mappings":";;;AAsBO,MAAMA,IAAO,CAAIC,GAAYC,GAA4BC,IAAO,OAAU;AAC/E,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAaJ,IAAO,KAAK;AAE/B,SAAO,CAAC,GAAGF,CAAK,EAAE,KAAK,CAACO,GAAGC,MAAMC,EAAQR,EAASM,CAAC,GAAGN,EAASO,CAAC,CAAC,IAAIF,CAAU;AACjF;AAEAP,EAAK,KAAK;"}
+{"version":3,"file":"sort.js","names":[],"sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { compareBy } from '../function/compareBy';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\nexport type SortDirection = 'asc' | 'desc';\nexport type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;\n\n/**\n * Sorts an array by a selector function (single-field) or by a multi-field\n * object of `{ key: 'asc' | 'desc' }` entries.\n *\n * @example\n * ```ts\n * // Single field\n * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]\n * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]\n *\n * // Multi-field\n * sort(users, { name: 'asc', age: 'desc' });\n * ```\n *\n * @param array - The array to sort.\n * @param selector - A function extracting the sort key, or a multi-field object.\n * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.\n * @returns A new sorted array.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];\nexport function sort<T>(array: T[], selectors: SortSelectors<T>): T[];\nexport function sort<T>(\n  array: T[],\n  selectorOrSelectors: ((item: T) => unknown) | SortSelectors<T>,\n  direction: SortDirection = 'asc',\n): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (typeof selectorOrSelectors === 'function') {\n    const multiplier = direction === 'desc' ? -1 : 1;\n\n    return [...array].sort((a, b) => compare(selectorOrSelectors(a), selectorOrSelectors(b)) * multiplier);\n  }\n\n  return [...array].sort(compareBy(selectorOrSelectors));\n}\n"],"mappings":";;;;;AA+BA,SAAgB,EACd,GACA,GACA,IAA2B,OACtB;AAGL,KAFA,EAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC,EAE5E,OAAO,KAAwB,YAAY;EAC7C,IAAM,IAAa,MAAc,SAAS,KAAK;AAE/C,SAAO,CAAC,GAAG,EAAM,CAAC,MAAM,GAAG,MAAM,EAAQ,EAAoB,EAAE,EAAE,EAAoB,EAAE,CAAC,GAAG,EAAW;;AAGxG,QAAO,CAAC,GAAG,EAAM,CAAC,KAAK,EAAU,EAAoB,CAAC"}

package/dist/array/toggle.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n,r={}){let{strategy:i=`append`}=r,a=n?e=>n(e)===n(t):e=>e===t,o=e.findIndex(a);return o===-1?i===`prepend`?[t,...e]:[...e,t]:[...e.slice(0,o),...e.slice(o+1)]}exports.toggle=e;
+//# sourceMappingURL=toggle.cjs.map

package/dist/array/toggle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.cjs","names":[],"sources":["../../src/array/toggle.ts"],"sourcesContent":["import type { Primitive } from '../types';\n\n/**\n * Either adds or removes an item from an array, based on whether it already\n * exists in the array (toggle behaviour).\n *\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // [1, 3]\n *\n * toggle(\n *   [{ id: 1 }, { id: 2 }],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n *\n * @param array - The array to modify.\n * @param item - The item to add or remove.\n * @param selector - A function to determine item identity.\n * @param [options] - Options for the toggle operation.\n * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).\n * @returns A new array with the item toggled.\n */\nexport function toggle<T>(\n  array: T[],\n  item: T,\n  selector?: (item: T) => Primitive,\n  options: { strategy?: 'prepend' | 'append' } = {},\n): T[] {\n  const { strategy = 'append' } = options;\n  const compareFn = selector ? (el: T) => selector(el) === selector(item) : (el: T) => el === item;\n\n  const index = array.findIndex(compareFn);\n\n  if (index !== -1) {\n    return [...array.slice(0, index), ...array.slice(index + 1)];\n  }\n\n  return strategy === 'prepend' ? [item, ...array] : [...array, item];\n}\n"],"mappings":"AA0BA,SAAgB,EACd,EACA,EACA,EACA,EAA+C,EAAE,CAC5C,CACL,GAAM,CAAE,WAAW,UAAa,EAC1B,EAAY,EAAY,GAAU,EAAS,EAAG,GAAK,EAAS,EAAK,CAAI,GAAU,IAAO,EAEtF,EAAQ,EAAM,UAAU,EAAU,CAMxC,OAJI,IAAU,GAIP,IAAa,UAAY,CAAC,EAAM,GAAG,EAAM,CAAG,CAAC,GAAG,EAAO,EAAK,CAH1D,CAAC,GAAG,EAAM,MAAM,EAAG,EAAM,CAAE,GAAG,EAAM,MAAM,EAAQ,EAAE,CAAC"}

package/dist/array/toggle.d.ts

@@ -0,0 +1,29 @@
+import type { Primitive } from '../types';
+/**
+ * Either adds or removes an item from an array, based on whether it already
+ * exists in the array (toggle behaviour).
+ *
+ * @example
+ * ```ts
+ * toggle([1, 2, 3], 4) // [1, 2, 3, 4]
+ * toggle([1, 2, 3], 2) // [1, 3]
+ *
+ * toggle(
+ *   [{ id: 1 }, { id: 2 }],
+ *   { id: 3 },
+ *   (obj) => obj.id,
+ *   { strategy: 'prepend' }
+ * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]
+ * ```
+ *
+ * @param array - The array to modify.
+ * @param item - The item to add or remove.
+ * @param selector - A function to determine item identity.
+ * @param [options] - Options for the toggle operation.
+ * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).
+ * @returns A new array with the item toggled.
+ */
+export declare function toggle<T>(array: T[], item: T, selector?: (item: T) => Primitive, options?: {
+    strategy?: 'prepend' | 'append';
+}): T[];
+//# sourceMappingURL=toggle.d.ts.map

package/dist/array/toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../src/array/toggle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,CAAC,EACP,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,EACjC,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAO,GAChD,CAAC,EAAE,CAWL"}

package/dist/array/toggle.js

@@ -0,0 +1,9 @@
+//#region src/array/toggle.ts
+function e(e, t, n, r = {}) {
+	let { strategy: i = "append" } = r, a = n ? (e) => n(e) === n(t) : (e) => e === t, o = e.findIndex(a);
+	return o === -1 ? i === "prepend" ? [t, ...e] : [...e, t] : [...e.slice(0, o), ...e.slice(o + 1)];
+}
+//#endregion
+export { e as toggle };
+
+//# sourceMappingURL=toggle.js.map

package/dist/array/toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.js","names":[],"sources":["../../src/array/toggle.ts"],"sourcesContent":["import type { Primitive } from '../types';\n\n/**\n * Either adds or removes an item from an array, based on whether it already\n * exists in the array (toggle behaviour).\n *\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // [1, 3]\n *\n * toggle(\n *   [{ id: 1 }, { id: 2 }],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n *\n * @param array - The array to modify.\n * @param item - The item to add or remove.\n * @param selector - A function to determine item identity.\n * @param [options] - Options for the toggle operation.\n * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).\n * @returns A new array with the item toggled.\n */\nexport function toggle<T>(\n  array: T[],\n  item: T,\n  selector?: (item: T) => Primitive,\n  options: { strategy?: 'prepend' | 'append' } = {},\n): T[] {\n  const { strategy = 'append' } = options;\n  const compareFn = selector ? (el: T) => selector(el) === selector(item) : (el: T) => el === item;\n\n  const index = array.findIndex(compareFn);\n\n  if (index !== -1) {\n    return [...array.slice(0, index), ...array.slice(index + 1)];\n  }\n\n  return strategy === 'prepend' ? [item, ...array] : [...array, item];\n}\n"],"mappings":";AA0BA,SAAgB,EACd,GACA,GACA,GACA,IAA+C,EAAE,EAC5C;CACL,IAAM,EAAE,cAAW,aAAa,GAC1B,IAAY,KAAY,MAAU,EAAS,EAAG,KAAK,EAAS,EAAK,IAAI,MAAU,MAAO,GAEtF,IAAQ,EAAM,UAAU,EAAU;AAMxC,QAJI,MAAU,KAIP,MAAa,YAAY,CAAC,GAAM,GAAG,EAAM,GAAG,CAAC,GAAG,GAAO,EAAK,GAH1D,CAAC,GAAG,EAAM,MAAM,GAAG,EAAM,EAAE,GAAG,EAAM,MAAM,IAAQ,EAAE,CAAC"}

package/dist/array/uniq.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../function/assert.cjs"),i=require("../typed/isArray.cjs");function s(e,t){if(o.assert(i.isArray(e),i.IS_ARRAY_ERROR_MSG,{type:TypeError}),e.length<=1)return[...e];if(!t)return[...new Set(e)];const r=new Map,f=typeof t=="function"?t:n=>n[t];return e.filter(n=>{const u=f(n);return r.has(u)?!1:(r.set(u,n),!0)})}s.fp=!0;exports.uniq=s;
-//# sourceMappingURL=uniq.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`);function n(n,r){if(e.assert(t.isArray(n),t.IS_ARRAY_ERROR_MSG,{type:TypeError}),n.length<=1)return[...n];if(!r)return[...new Set(n)];let i=new Set,a=typeof r==`function`?r:e=>e[r];return n.filter(e=>{let t=a(e);return i.has(t)?!1:(i.add(t),!0)})}exports.uniq=n;
+//# sourceMappingURL=uniq.cjs.map

package/dist/array/uniq.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"uniq.cjs","sources":["../../src/array/uniq.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Primitive, Selector } from '../types';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Map<Primitive, T>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.set(key, item);\n    return true;\n  });\n}\n\nuniq.fp = true;\n"],"names":["uniq","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","seen","getKey","item","key"],"mappings":"4JAsBO,SAASA,EAAQC,EAAYC,EAA6B,CAG/D,GAFAC,EAAAA,OAAOC,EAAAA,QAAQH,CAAK,EAAGI,EAAAA,mBAAoB,CAAE,KAAM,UAAW,EAE1DJ,EAAM,QAAU,EAClB,MAAO,CAAC,GAAGA,CAAK,EAGlB,GAAI,CAACC,EACH,MAAO,CAAC,GAAG,IAAI,IAAID,CAAK,CAAC,EAG3B,MAAMK,MAAW,IACXC,EAAS,OAAOL,GAAa,WAAaA,EAAYM,GAAYA,EAAKN,CAAQ,EAErF,OAAOD,EAAM,OAAQO,GAAS,CAC5B,MAAMC,EAAMF,EAAOC,CAAI,EACvB,OAAIF,EAAK,IAAIG,CAAG,EACP,IAETH,EAAK,IAAIG,EAAKD,CAAI,EACX,GACT,CAAC,CACH,CAEAR,EAAK,GAAK"}
+{"version":3,"file":"uniq.cjs","names":[],"sources":["../../src/array/uniq.ts"],"sourcesContent":["import type { Primitive, Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Set<Primitive>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n\n    return true;\n  });\n}\n"],"mappings":"4EAuBA,SAAgB,EAAQ,EAAY,EAA6B,CAG/D,GAFA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,UAAW,CAAC,CAE3D,EAAM,QAAU,EAClB,MAAO,CAAC,GAAG,EAAM,CAGnB,GAAI,CAAC,EACH,MAAO,CAAC,GAAG,IAAI,IAAI,EAAM,CAAC,CAG5B,IAAM,EAAO,IAAI,IACX,EAAS,OAAO,GAAa,WAAa,EAAY,GAAY,EAAK,GAE7E,OAAO,EAAM,OAAQ,GAAS,CAC5B,IAAM,EAAM,EAAO,EAAK,CAQxB,OANI,EAAK,IAAI,EAAI,CACR,IAGT,EAAK,IAAI,EAAI,CAEN,KACP"}

package/dist/array/uniq.d.ts

@@ -0,0 +1,21 @@
+import type { Selector } from '../types';
+/**
+ * Creates a new array with duplicate values removed.
+ *
+ * @example
+ * ```ts
+ * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]
+ * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];
+ * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * ```
+ *
+ * @param array - The array to process.
+ * @param [selector] - The key(s) to compare objects or a function to generate comparison values.
+
+ * @returns A new duplicate-free array.
+
+ * @throws {TypeError} - If the input is not an array or if the key is invalid.
+ */
+export declare function uniq<T>(array: T[], selector?: Selector<T>): T[];
+//# sourceMappingURL=uniq.d.ts.map

package/dist/array/uniq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../src/array/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,UAAU,CAAC;AAKpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAyB/D"}

package/dist/array/uniq.js

@@ -1,18 +1,16 @@
-import { assert as i } from "../function/assert.js";
-import { IS_ARRAY_ERROR_MSG as o, isArray as p } from "../typed/isArray.js";
-function s(t, e) {
-  if (i(p(t), o, { type: TypeError }), t.length <= 1)
-    return [...t];
-  if (!e)
-    return [...new Set(t)];
-  const r = /* @__PURE__ */ new Map(), u = typeof e == "function" ? e : (n) => n[e];
-  return t.filter((n) => {
-    const f = u(n);
-    return r.has(f) ? !1 : (r.set(f, n), !0);
-  });
+import { assert as e } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+//#region src/array/uniq.ts
+function r(r, i) {
+	if (e(n(r), t, { type: TypeError }), r.length <= 1) return [...r];
+	if (!i) return [...new Set(r)];
+	let a = /* @__PURE__ */ new Set(), o = typeof i == "function" ? i : (e) => e[i];
+	return r.filter((e) => {
+		let t = o(e);
+		return a.has(t) ? !1 : (a.add(t), !0);
+	});
 }
-s.fp = !0;
-export {
-  s as uniq
-};
-//# sourceMappingURL=uniq.js.map
+//#endregion
+export { r as uniq };
+
+//# sourceMappingURL=uniq.js.map

package/dist/array/uniq.js.map

@@ -1 +1 @@
-{"version":3,"file":"uniq.js","sources":["../../src/array/uniq.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Primitive, Selector } from '../types';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Map<Primitive, T>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.set(key, item);\n    return true;\n  });\n}\n\nuniq.fp = true;\n"],"names":["uniq","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","seen","getKey","item","key"],"mappings":";;AAsBO,SAASA,EAAQC,GAAYC,GAA6B;AAG/D,MAFAC,EAAOC,EAAQH,CAAK,GAAGI,GAAoB,EAAE,MAAM,WAAW,GAE1DJ,EAAM,UAAU;AAClB,WAAO,CAAC,GAAGA,CAAK;AAGlB,MAAI,CAACC;AACH,WAAO,CAAC,GAAG,IAAI,IAAID,CAAK,CAAC;AAG3B,QAAMK,wBAAW,IAAA,GACXC,IAAS,OAAOL,KAAa,aAAaA,IAAW,CAACM,MAAYA,EAAKN,CAAQ;AAErF,SAAOD,EAAM,OAAO,CAACO,MAAS;AAC5B,UAAMC,IAAMF,EAAOC,CAAI;AACvB,WAAIF,EAAK,IAAIG,CAAG,IACP,MAETH,EAAK,IAAIG,GAAKD,CAAI,GACX;AAAA,EACT,CAAC;AACH;AAEAR,EAAK,KAAK;"}
+{"version":3,"file":"uniq.js","names":[],"sources":["../../src/array/uniq.ts"],"sourcesContent":["import type { Primitive, Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Set<Primitive>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n\n    return true;\n  });\n}\n"],"mappings":";;;AAuBA,SAAgB,EAAQ,GAAY,GAA6B;AAG/D,KAFA,EAAO,EAAQ,EAAM,EAAE,GAAoB,EAAE,MAAM,WAAW,CAAC,EAE3D,EAAM,UAAU,EAClB,QAAO,CAAC,GAAG,EAAM;AAGnB,KAAI,CAAC,EACH,QAAO,CAAC,GAAG,IAAI,IAAI,EAAM,CAAC;CAG5B,IAAM,oBAAO,IAAI,KAAgB,EAC3B,IAAS,OAAO,KAAa,aAAa,KAAY,MAAY,EAAK;AAE7E,QAAO,EAAM,QAAQ,MAAS;EAC5B,IAAM,IAAM,EAAO,EAAK;AAQxB,SANI,EAAK,IAAI,EAAI,GACR,MAGT,EAAK,IAAI,EAAI,EAEN;GACP"}

package/dist/async/attempt.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../logit/dist/logit.cjs"),c=require("./predict.cjs"),u=require("./retry.cjs");async function s(t,{silent:e=!1,retries:r=0,timeout:i=7e3,identifier:a=t.name||"anonymous function"}={}){try{return await u.retry(()=>c.predict(()=>t(),{timeout:i}),{times:r+1})}catch(o){e||n.Logit.error(`attempt(${a}) -> all attempts failed`,{cause:o});return}}exports.attempt=s;
-//# sourceMappingURL=attempt.cjs.map
+const e=require(`./predict.cjs`),t=require(`./retry.cjs`);async function n(n,{onError:r,timeout:i=7e3,times:a=3}={}){try{return{ok:!0,value:await t.retry(()=>e.predict(()=>n(),{timeout:i}),{times:a})}}catch(e){return r?.(e),{error:e,ok:!1}}}exports.attempt=n;
+//# sourceMappingURL=attempt.cjs.map

package/dist/async/attempt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.cjs","sources":["../../src/async/attempt.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport type { Fn } from '../types';\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  identifier?: string;\n  retries?: number;\n  silent?: boolean;\n  timeout?: number;\n};\n\n/**\n * Attempts to execute a function with advanced error handling and retry logic.\n *\n * @example\n * ```ts\n * const unreliableFunction = async () => {\n *   if (Math.random() < 0.7) throw new Error ('Random failure');\n *   return 'Success!';\n * };\n *\n * await attempt(\n *   unreliableFunction,\n *   { retries: 3, silent: false, timeout: 5000 }); // Success! (or undefined if all attempts failed)\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options for the attempt.\n * @param [options.identifier] - Custom identifier for logging purposes.\n * @param [options.retries=0] - Number of retry attempts if the function fails.\n * @param [options.silent=false] - If true, suppresses error logging.\n * @param [options.timeout=7000] - Timeout in milliseconds for function execution.\n *\n * @returns The result of the function or undefined if it failed.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { silent = false, retries = 0, timeout = 7000, identifier = fn.name || 'anonymous function' }: AttemptOptions = {},\n): Promise<R | undefined> {\n  try {\n    return await retry(() => predict<R>(() => fn(), { timeout }), { times: retries + 1 });\n  } catch (err) {\n    if (!silent) {\n      Logit.error(`attempt(${identifier}) -> all attempts failed`, { cause: err });\n    }\n    return undefined;\n  }\n}\n"],"names":["attempt","fn","silent","retries","timeout","identifier","retry","predict","err","Logit"],"mappings":"+KAoCA,eAAsBA,EACpBC,EACA,CAAE,OAAAC,EAAS,GAAO,QAAAC,EAAU,EAAG,QAAAC,EAAU,IAAM,WAAAC,EAAaJ,EAAG,MAAQ,oBAAA,EAAyC,CAAA,EACxF,CACxB,GAAI,CACF,OAAO,MAAMK,EAAAA,MAAM,IAAMC,EAAAA,QAAW,IAAMN,EAAA,EAAM,CAAE,QAAAG,CAAA,CAAS,EAAG,CAAE,MAAOD,EAAU,EAAG,CACtF,OAASK,EAAK,CACPN,GACHO,QAAM,MAAM,WAAWJ,CAAU,2BAA4B,CAAE,MAAOG,EAAK,EAE7E,MACF,CACF"}
+{"version":3,"file":"attempt.cjs","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  onError?: (err: unknown) => void;\n  timeout?: number;\n  times?: number;\n};\n\nexport type AttemptResult<R> = { ok: true; value: R } | { error: unknown; ok: false };\n\n/**\n * Attempts to execute a function with retry logic and an optional timeout.\n * Returns a discriminated union so callers can handle success and failure\n * explicitly without relying on `undefined`.\n *\n * @example\n * ```ts\n * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });\n *\n * if (result.ok) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.onError] - Called with the error when all attempts fail.\n * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.\n *\n * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { onError, timeout = 7000, times = 3 }: AttemptOptions = {},\n): Promise<AttemptResult<R>> {\n  try {\n    const value = await retry(() => predict<R>(() => fn(), { timeout }), { times });\n\n    return { ok: true, value };\n  } catch (err) {\n    onError?.(err);\n\n    return { error: err, ok: false };\n  }\n}\n"],"mappings":"0DAqCA,eAAsB,EACpB,EACA,CAAE,UAAS,UAAU,IAAM,QAAQ,GAAsB,EAAE,CAChC,CAC3B,GAAI,CAGF,MAAO,CAAE,GAAI,GAAM,MAFL,MAAM,EAAA,UAAY,EAAA,YAAiB,GAAI,CAAE,CAAE,UAAS,CAAC,CAAE,CAAE,QAAO,CAAC,CAErD,OACnB,EAAK,CAGZ,OAFA,IAAU,EAAI,CAEP,CAAE,MAAO,EAAK,GAAI,GAAO"}

package/dist/async/attempt.d.ts

@@ -0,0 +1,40 @@
+import type { Fn } from '../types';
+type AttemptOptions = {
+    onError?: (err: unknown) => void;
+    timeout?: number;
+    times?: number;
+};
+export type AttemptResult<R> = {
+    ok: true;
+    value: R;
+} | {
+    error: unknown;
+    ok: false;
+};
+/**
+ * Attempts to execute a function with retry logic and an optional timeout.
+ * Returns a discriminated union so callers can handle success and failure
+ * explicitly without relying on `undefined`.
+ *
+ * @example
+ * ```ts
+ * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });
+ *
+ * if (result.ok) {
+ *   console.log(result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * @param fn - The function to be executed.
+ * @param [options] - Configuration options.
+ * @param [options.times=3] - Total number of attempts (including the first).
+ * @param [options.onError] - Called with the error when all attempts fail.
+ * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.
+ *
+ * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.
+ */
+export declare function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(fn: T, { onError, timeout, times }?: AttemptOptions): Promise<AttemptResult<R>>;
+export {};
+//# sourceMappingURL=attempt.d.ts.map

package/dist/async/attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/async/attempt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC,KAAK,cAAc,GAAG;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EACpE,EAAE,EAAE,CAAC,EACL,EAAE,OAAO,EAAE,OAAc,EAAE,KAAS,EAAE,GAAE,cAAmB,GAC1D,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAU3B"}

package/dist/async/attempt.js

@@ -1,15 +1,20 @@
-import { Logit as m } from "../logit/dist/logit.js";
-import { predict as n } from "./predict.js";
-import { retry as p } from "./retry.js";
-async function u(t, { silent: r = !1, retries: e = 0, timeout: a = 7e3, identifier: o = t.name || "anonymous function" } = {}) {
-  try {
-    return await p(() => n(() => t(), { timeout: a }), { times: e + 1 });
-  } catch (i) {
-    r || m.error(`attempt(${o}) -> all attempts failed`, { cause: i });
-    return;
-  }
+import { predict as e } from "./predict.js";
+import { retry as t } from "./retry.js";
+//#region src/async/attempt.ts
+async function n(n, { onError: r, timeout: i = 7e3, times: a = 3 } = {}) {
+	try {
+		return {
+			ok: !0,
+			value: await t(() => e(() => n(), { timeout: i }), { times: a })
+		};
+	} catch (e) {
+		return r?.(e), {
+			error: e,
+			ok: !1
+		};
+	}
 }
-export {
-  u as attempt
-};
-//# sourceMappingURL=attempt.js.map
+//#endregion
+export { n as attempt };
+
+//# sourceMappingURL=attempt.js.map

package/dist/async/attempt.js.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.js","sources":["../../src/async/attempt.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport type { Fn } from '../types';\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  identifier?: string;\n  retries?: number;\n  silent?: boolean;\n  timeout?: number;\n};\n\n/**\n * Attempts to execute a function with advanced error handling and retry logic.\n *\n * @example\n * ```ts\n * const unreliableFunction = async () => {\n *   if (Math.random() < 0.7) throw new Error ('Random failure');\n *   return 'Success!';\n * };\n *\n * await attempt(\n *   unreliableFunction,\n *   { retries: 3, silent: false, timeout: 5000 }); // Success! (or undefined if all attempts failed)\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options for the attempt.\n * @param [options.identifier] - Custom identifier for logging purposes.\n * @param [options.retries=0] - Number of retry attempts if the function fails.\n * @param [options.silent=false] - If true, suppresses error logging.\n * @param [options.timeout=7000] - Timeout in milliseconds for function execution.\n *\n * @returns The result of the function or undefined if it failed.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { silent = false, retries = 0, timeout = 7000, identifier = fn.name || 'anonymous function' }: AttemptOptions = {},\n): Promise<R | undefined> {\n  try {\n    return await retry(() => predict<R>(() => fn(), { timeout }), { times: retries + 1 });\n  } catch (err) {\n    if (!silent) {\n      Logit.error(`attempt(${identifier}) -> all attempts failed`, { cause: err });\n    }\n    return undefined;\n  }\n}\n"],"names":["attempt","fn","silent","retries","timeout","identifier","retry","predict","err","Logit"],"mappings":";;;AAoCA,eAAsBA,EACpBC,GACA,EAAE,QAAAC,IAAS,IAAO,SAAAC,IAAU,GAAG,SAAAC,IAAU,KAAM,YAAAC,IAAaJ,EAAG,QAAQ,qBAAA,IAAyC,CAAA,GACxF;AACxB,MAAI;AACF,WAAO,MAAMK,EAAM,MAAMC,EAAW,MAAMN,EAAA,GAAM,EAAE,SAAAG,EAAA,CAAS,GAAG,EAAE,OAAOD,IAAU,GAAG;AAAA,EACtF,SAASK,GAAK;AACZ,IAAKN,KACHO,EAAM,MAAM,WAAWJ,CAAU,4BAA4B,EAAE,OAAOG,GAAK;AAE7E;AAAA,EACF;AACF;"}
+{"version":3,"file":"attempt.js","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  onError?: (err: unknown) => void;\n  timeout?: number;\n  times?: number;\n};\n\nexport type AttemptResult<R> = { ok: true; value: R } | { error: unknown; ok: false };\n\n/**\n * Attempts to execute a function with retry logic and an optional timeout.\n * Returns a discriminated union so callers can handle success and failure\n * explicitly without relying on `undefined`.\n *\n * @example\n * ```ts\n * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });\n *\n * if (result.ok) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.onError] - Called with the error when all attempts fail.\n * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.\n *\n * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { onError, timeout = 7000, times = 3 }: AttemptOptions = {},\n): Promise<AttemptResult<R>> {\n  try {\n    const value = await retry(() => predict<R>(() => fn(), { timeout }), { times });\n\n    return { ok: true, value };\n  } catch (err) {\n    onError?.(err);\n\n    return { error: err, ok: false };\n  }\n}\n"],"mappings":";;;AAqCA,eAAsB,EACpB,GACA,EAAE,YAAS,aAAU,KAAM,WAAQ,MAAsB,EAAE,EAChC;AAC3B,KAAI;AAGF,SAAO;GAAE,IAAI;GAAM,OAFL,MAAM,QAAY,QAAiB,GAAI,EAAE,EAAE,YAAS,CAAC,EAAE,EAAE,UAAO,CAAC;GAErD;UACnB,GAAK;AAGZ,SAFA,IAAU,EAAI,EAEP;GAAE,OAAO;GAAK,IAAI;GAAO"}

package/dist/async/defer.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function i(){let e,r;return{promise:new Promise((t,o)=>{e=t,r=o}),reject:r,resolve:e}}exports.defer=i;
-//# sourceMappingURL=defer.cjs.map
+function e(){let{promise:e,reject:t,resolve:n}=Promise.withResolvers();return{promise:e,reject:t,resolve:n}}exports.defer=e;
+//# sourceMappingURL=defer.cjs.map

package/dist/async/defer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defer.cjs","sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: unknown) => void;\n} {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason?: unknown) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, reject, resolve };\n}\n"],"names":["defer","resolve","reject","res","rej"],"mappings":"gFAiBO,SAASA,GAId,CACA,IAAIC,EACAC,EAOJ,MAAO,CAAE,QALO,IAAI,QAAW,CAACC,EAAKC,IAAQ,CAC3CH,EAAUE,EACVD,EAASE,CACX,CAAC,EAEiB,OAAAF,EAAQ,QAAAD,CAAA,CAC5B"}
+{"version":3,"file":"defer.cjs","names":[],"sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  reject: (reason?: unknown) => void;\n  resolve: (value: T | PromiseLike<T>) => void;\n} {\n  const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n  return { promise, reject, resolve };\n}\n"],"mappings":"AAiBA,SAAgB,GAId,CACA,GAAM,CAAE,UAAS,SAAQ,WAAY,QAAQ,eAAkB,CAE/D,MAAO,CAAE,UAAS,SAAQ,UAAS"}

package/dist/async/defer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a deferred promise with resolve and reject methods exposed.
+ * Useful for creating promises that are resolved/rejected externally.
+ *
+ * @example
+ * ```ts
+ * const deferred = defer<string>();
+ *
+ * setTimeout(() => {
+ *   deferred.resolve('Done!');
+ * }, 1000);
+ *
+ * const result = await deferred.promise; // 'Done!'
+ * ```
+ *
+ * @returns Object with promise and resolve/reject methods
+ */
+export declare function defer<T = void>(): {
+    promise: Promise<T>;
+    reject: (reason?: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};
+//# sourceMappingURL=defer.d.ts.map

package/dist/async/defer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.d.ts","sourceRoot":"","sources":["../../src/async/defer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,IAAI,KAAK;IACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CAC9C,CAIA"}

package/dist/async/defer.js

@@ -1,10 +1,13 @@
-function s() {
-  let e, r;
-  return { promise: new Promise((o, t) => {
-    e = o, r = t;
-  }), reject: r, resolve: e };
+//#region src/async/defer.ts
+function e() {
+	let { promise: e, reject: t, resolve: n } = Promise.withResolvers();
+	return {
+		promise: e,
+		reject: t,
+		resolve: n
+	};
 }
-export {
-  s as defer
-};
-//# sourceMappingURL=defer.js.map
+//#endregion
+export { e as defer };
+
+//# sourceMappingURL=defer.js.map

package/dist/async/defer.js.map

@@ -1 +1 @@
-{"version":3,"file":"defer.js","sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: unknown) => void;\n} {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason?: unknown) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, reject, resolve };\n}\n"],"names":["defer","resolve","reject","res","rej"],"mappings":"AAiBO,SAASA,IAId;AACA,MAAIC,GACAC;AAOJ,SAAO,EAAE,SALO,IAAI,QAAW,CAACC,GAAKC,MAAQ;AAC3C,IAAAH,IAAUE,GACVD,IAASE;AAAA,EACX,CAAC,GAEiB,QAAAF,GAAQ,SAAAD,EAAA;AAC5B;"}
+{"version":3,"file":"defer.js","names":[],"sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  reject: (reason?: unknown) => void;\n  resolve: (value: T | PromiseLike<T>) => void;\n} {\n  const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n  return { promise, reject, resolve };\n}\n"],"mappings":";AAiBA,SAAgB,IAId;CACA,IAAM,EAAE,YAAS,WAAQ,eAAY,QAAQ,eAAkB;AAE/D,QAAO;EAAE;EAAS;EAAQ;EAAS"}

package/dist/async/index.d.ts

@@ -0,0 +1,12 @@
+export * from './attempt';
+export * from './defer';
+export * from './parallel';
+export * from './pool';
+export * from './predict';
+export * from './queue';
+export * from './race';
+export * from './retry';
+export * from './scheduler';
+export * from './sleep';
+export * from './waitFor';
+//# sourceMappingURL=index.d.ts.map

package/dist/async/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC"}

package/dist/async/parallel.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function f(n,r,a,l){if(n<1)throw new Error("Limit must be at least 1");if(l?.aborted)throw new DOMException("Aborted","AbortError");const s=new Array(r.length);let c=0,t=!1,o;const u=()=>l?.aborted?(t=!0,o=new DOMException("Aborted","AbortError"),!0):!1,w=async()=>{for(;c<r.length&&!t&&!u();){const e=c++;try{s[e]=await a(r[e],e,r)}catch(h){t=!0,o=h;break}}},i=[],b=Math.min(n,r.length);for(let e=0;e<b;e++)i.push(w());if(await Promise.all(i),t)throw o;return s}exports.parallel=f;
-//# sourceMappingURL=parallel.cjs.map
+async function e(e,t,n,r){if(e<1)throw Error(`Limit must be at least 1`);if(r?.aborted)throw new DOMException(`Aborted`,`AbortError`);let i=Array(t.length),a=0,o=!1,s,c=async()=>{for(;a<t.length&&!o;){if(r?.aborted){o=!0,s=new DOMException(`Aborted`,`AbortError`);break}let e=a++;try{i[e]=await n(t[e],e,t)}catch(e){o=!0,s=e;break}}},l=[],u=Math.min(e,t.length);for(let e=0;e<u;e++)l.push(c());if(await Promise.all(l),o)throw s;return i}exports.parallel=e;
+//# sourceMappingURL=parallel.cjs.map

package/dist/async/parallel.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.cjs","sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  // Check for abort\n  const checkAbort = () => {\n    if (signal?.aborted) {\n      hasError = true;\n      error = new DOMException('Aborted', 'AbortError');\n      return true;\n    }\n    return false;\n  };\n\n  // Worker function that processes items from the queue\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (checkAbort()) {\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"names":["parallel","limit","array","callback","signal","results","currentIndex","hasError","error","checkAbort","worker","index","err","workers","workerCount","i"],"mappings":"gFA6BA,eAAsBA,EACpBC,EACAC,EACAC,EACAC,EACc,CACd,GAAIH,EAAQ,EACV,MAAM,IAAI,MAAM,0BAA0B,EAG5C,GAAIG,GAAQ,QACV,MAAM,IAAI,aAAa,UAAW,YAAY,EAGhD,MAAMC,EAAe,IAAI,MAAMH,EAAM,MAAM,EAC3C,IAAII,EAAe,EACfC,EAAW,GACXC,EAGJ,MAAMC,EAAa,IACbL,GAAQ,SACVG,EAAW,GACXC,EAAQ,IAAI,aAAa,UAAW,YAAY,EACzC,IAEF,GAIHE,EAAS,SAA2B,CACxC,KAAOJ,EAAeJ,EAAM,QAAU,CAACK,GACjC,CAAAE,KAD2C,CAK/C,MAAME,EAAQL,IAEd,GAAI,CACFD,EAAQM,CAAK,EAAI,MAAMR,EAASD,EAAMS,CAAK,EAAGA,EAAOT,CAAK,CAC5D,OAASU,EAAK,CACZL,EAAW,GACXC,EAAQI,EACR,KACF,CACF,CACF,EAGMC,EAA2B,CAAA,EAC3BC,EAAc,KAAK,IAAIb,EAAOC,EAAM,MAAM,EAEhD,QAASa,EAAI,EAAGA,EAAID,EAAaC,IAC/BF,EAAQ,KAAKH,GAAQ,EAOvB,GAHA,MAAM,QAAQ,IAAIG,CAAO,EAGrBN,EACF,MAAMC,EAGR,OAAOH,CACT"}
+{"version":3,"file":"parallel.cjs","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (signal?.aborted) {\n        hasError = true;\n        error = new DOMException('Aborted', 'AbortError');\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"mappings":"AA6BA,eAAsB,EACpB,EACA,EACA,EACA,EACc,CACd,GAAI,EAAQ,EACV,MAAU,MAAM,2BAA2B,CAG7C,GAAI,GAAQ,QACV,MAAM,IAAI,aAAa,UAAW,aAAa,CAGjD,IAAM,EAAmB,MAAM,EAAM,OAAO,CACxC,EAAe,EACf,EAAW,GACX,EAEE,EAAS,SAA2B,CACxC,KAAO,EAAe,EAAM,QAAU,CAAC,GAAU,CAC/C,GAAI,GAAQ,QAAS,CACnB,EAAW,GACX,EAAQ,IAAI,aAAa,UAAW,aAAa,CACjD,MAGF,IAAM,EAAQ,IAEd,GAAI,CACF,EAAQ,GAAS,MAAM,EAAS,EAAM,GAAQ,EAAO,EAAM,OACpD,EAAK,CACZ,EAAW,GACX,EAAQ,EACR,SAMA,EAA2B,EAAE,CAC7B,EAAc,KAAK,IAAI,EAAO,EAAM,OAAO,CAEjD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAa,IAC/B,EAAQ,KAAK,GAAQ,CAAC,CAOxB,GAHA,MAAM,QAAQ,IAAI,EAAQ,CAGtB,EACF,MAAM,EAGR,OAAO"}

package/dist/async/parallel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Processes an array with an async callback with controlled parallelism.
+ * Similar to Promise.all, but limits how many items are processed concurrently.
+ * Returns an ordered array of results.
+ *
+ * @example
+ * ```ts
+ * // Process 3 items at a time
+ * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {
+ *   await delay(100);
+ *   return n * 2;
+ * });
+ * // [2, 4, 6, 8, 10]
+ *
+ * // With abort signal
+ * const controller = new AbortController();
+ * const results = await parallel(2, items, async (item) => {
+ *   return processItem(item);
+ * }, controller.signal);
+ * ```
+ *
+ * @param limit - Maximum number of concurrent operations (must be >= 1)
+ * @param array - Array of items to process
+ * @param callback - Async function to process each item
+ * @param signal - Optional AbortSignal to cancel processing
+ * @returns Promise resolving to an ordered array of results
+ * @throws {Error} If limit is less than 1
+ * @throws {DOMException} If aborted via signal
+ */
+export declare function parallel<T, R>(limit: number, array: T[], callback: (item: T, index: number, array: T[]) => Promise<R>, signal?: AbortSignal): Promise<R[]>;
+//# sourceMappingURL=parallel.d.ts.map

package/dist/async/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/async/parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5D,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,EAAE,CAAC,CAmDd"}