@ls-stack/utils 3.63.0 → 3.66.0

package/dist/levenshtein.mjs

@@ -0,0 +1,121 @@
+//#region src/levenshtein.ts
+const peq = new Uint32Array(65536);
+const myers_32 = (a, b) => {
+	const n = a.length;
+	const m = b.length;
+	const lst = 1 << n - 1;
+	let pv = -1;
+	let mv = 0;
+	let sc = n;
+	let i = n;
+	while (i--) peq[a.charCodeAt(i)] |= 1 << i;
+	for (i = 0; i < m; i++) {
+		let eq = peq[b.charCodeAt(i)];
+		const xv = eq | mv;
+		eq |= (eq & pv) + pv ^ pv;
+		mv |= ~(eq | pv);
+		pv &= eq;
+		if (mv & lst) sc++;
+		if (pv & lst) sc--;
+		mv = mv << 1 | 1;
+		pv = pv << 1 | ~(xv | mv);
+		mv &= xv;
+	}
+	i = n;
+	while (i--) peq[a.charCodeAt(i)] = 0;
+	return sc;
+};
+const myers_x = (b, a) => {
+	const n = a.length;
+	const m = b.length;
+	const mhc = [];
+	const phc = [];
+	const hsize = Math.ceil(n / 32);
+	const vsize = Math.ceil(m / 32);
+	for (let i = 0; i < hsize; i++) {
+		phc[i] = -1;
+		mhc[i] = 0;
+	}
+	let j = 0;
+	for (; j < vsize - 1; j++) {
+		let mv$1 = 0;
+		let pv$1 = -1;
+		const start$1 = j * 32;
+		const vlen$1 = Math.min(32, m) + start$1;
+		for (let k = start$1; k < vlen$1; k++) peq[b.charCodeAt(k)] |= 1 << k;
+		for (let i = 0; i < n; i++) {
+			const eq = peq[a.charCodeAt(i)];
+			const pb = phc[i / 32 | 0] >>> i & 1;
+			const mb = mhc[i / 32 | 0] >>> i & 1;
+			const xv = eq | mv$1;
+			const xh = ((eq | mb) & pv$1) + pv$1 ^ pv$1 | eq | mb;
+			let ph = mv$1 | ~(xh | pv$1);
+			let mh = pv$1 & xh;
+			if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+			if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+			ph = ph << 1 | pb;
+			mh = mh << 1 | mb;
+			pv$1 = mh | ~(xv | ph);
+			mv$1 = ph & xv;
+		}
+		for (let k = start$1; k < vlen$1; k++) peq[b.charCodeAt(k)] = 0;
+	}
+	let mv = 0;
+	let pv = -1;
+	const start = j * 32;
+	const vlen = Math.min(32, m - start) + start;
+	for (let k = start; k < vlen; k++) peq[b.charCodeAt(k)] |= 1 << k;
+	let score = m;
+	for (let i = 0; i < n; i++) {
+		const eq = peq[a.charCodeAt(i)];
+		const pb = phc[i / 32 | 0] >>> i & 1;
+		const mb = mhc[i / 32 | 0] >>> i & 1;
+		const xv = eq | mv;
+		const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+		let ph = mv | ~(xh | pv);
+		let mh = pv & xh;
+		score += ph >>> m - 1 & 1;
+		score -= mh >>> m - 1 & 1;
+		if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+		if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+		ph = ph << 1 | pb;
+		mh = mh << 1 | mb;
+		pv = mh | ~(xv | ph);
+		mv = ph & xv;
+	}
+	for (let k = start; k < vlen; k++) peq[b.charCodeAt(k)] = 0;
+	return score;
+};
+function levenshteinDistance(a, b) {
+	if (a.length < b.length) {
+		const tmp = b;
+		b = a;
+		a = tmp;
+	}
+	if (b.length === 0) return a.length;
+	if (a.length <= 32) return myers_32(a, b);
+	return myers_x(a, b);
+}
+function getClosestString(str, arr, maxDistance = 2) {
+	let min_distance = Infinity;
+	let closestString;
+	for (let i = 0; i < arr.length; i++) {
+		const dist = levenshteinDistance(str, arr[i]);
+		if (dist < min_distance && dist <= maxDistance) {
+			min_distance = dist;
+			closestString = arr[i];
+		}
+	}
+	return closestString;
+}
+function getClosestStringsUpToDist(str, arr, maxDistance = 2) {
+	const distanceMap = /* @__PURE__ */ new Map();
+	for (const item of arr) {
+		const distance = levenshteinDistance(str, item);
+		if (distance <= maxDistance) distanceMap.set(item, distance);
+	}
+	return Array.from(distanceMap.entries()).sort((a, b) => a[1] - b[1]).map(([item]) => item);
+}
+
+//#endregion
+export { getClosestString, getClosestStringsUpToDist, levenshteinDistance };

package/dist/main.d.mts

@@ -0,0 +1,4 @@
+//#region src/main.d.ts
+declare const _doNotUseThis: () => never;
+//#endregion
+export { _doNotUseThis };

package/dist/main.mjs

@@ -0,0 +1,7 @@
+//#region src/main.ts
+const _doNotUseThis = () => {
+	throw new Error("do not use this file");
+};
+
+//#endregion
+export { _doNotUseThis };

package/dist/matchPath.d.mts

@@ -0,0 +1,50 @@
+//#region src/matchPath.d.ts
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?` ? Optional : Param : never;
+type PathParam<Path extends string> = Path extends '*' | '/*' ? '*' : Path extends `${infer Rest}/*` ? '*' | _PathParam<Rest> : _PathParam<Path>;
+type ParamParseKey<Segment extends string> = [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;
+/** A PathPattern is used to match on some portion of a URL pathname. */
+interface PathPattern<Path extends string = string> {
+  /**
+   * A string to match against a URL pathname. May contain `:id`-style segments
+   * to indicate placeholders for dynamic parameters. May also end with `/*` to
+   * indicate matching the rest of the URL pathname.
+   */
+  path: Path;
+  /**
+   * Should be `true` if the static portions of the `path` should be matched in
+   * the same case.
+   */
+  caseSensitive?: boolean;
+  /** Should be `true` if this pattern should match the entire URL pathname. */
+  end?: boolean;
+}
+/** The parameters that were parsed from the URL path. */
+type Params<Key extends string = string> = { readonly [key in Key]: string | undefined };
+type PathMatchGlob = {
+  matchPath: <K extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path) => PathMatch<K> | null;
+  path: string;
+};
+/** A PathMatch contains info about how a PathPattern matched on a URL pathname. */
+interface PathMatch<ParamKey extends string = string> {
+  /** The names and values of dynamic parameters in the URL. */
+  params: Params<ParamKey>;
+  /** The portion of the URL pathname that was matched. */
+  pathname: string;
+  /** The portion of the URL pathname that was matched before child routes. */
+  pathnameBase: string;
+  /** The pattern that was used to match. */
+  pattern: PathPattern;
+  glob: null | PathMatchGlob;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about the
+ * match.
+ *
+ * @see https://reactrouter.com/utils/match-path
+ */
+declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+declare function matchPathWith(path: string | undefined | null): {
+  patterns: <R$1>(patterns: Record<string, (match: PathMatch) => R$1>) => R$1 | null;
+};
+//#endregion
+export { ParamParseKey, Params, PathMatch, PathMatchGlob, PathParam, PathPattern, matchPath, matchPathWith };

package/dist/matchPath.mjs

@@ -0,0 +1,81 @@
+import { fastCache } from "./cache.mjs";
+
+//#region src/matchPath.ts
+/**
+* Performs pattern matching on a URL pathname and returns information about the
+* match.
+*
+* @see https://reactrouter.com/utils/match-path
+*/
+function matchPath(pattern, pathname) {
+	if (typeof pattern === "string") pattern = {
+		path: pattern,
+		caseSensitive: false,
+		end: true
+	};
+	const normalizedPathname = pathname === "" ? "" : pathname.replace(/^\/*/, "/");
+	const [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+	const match = normalizedPathname.match(matcher);
+	if (!match) return null;
+	const matchedPathname = match[0];
+	let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+	const captureGroups = match.slice(1);
+	const params = compiledParams.reduce((memo, { paramName, isOptional }, index) => {
+		if (paramName === "*") {
+			const splatValue = captureGroups[index] || "";
+			pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+		}
+		const value = captureGroups[index];
+		if (isOptional && !value) memo[paramName] = void 0;
+		else memo[paramName] = (value || "").replace(/%2F/g, "/");
+		return memo;
+	}, {});
+	const glob = params["*"];
+	const globPath = glob && `/${glob}`;
+	return {
+		params,
+		pathname: matchedPathname,
+		pathnameBase,
+		pattern,
+		glob: globPath ? {
+			matchPath: (subPattern) => matchPath(subPattern, globPath),
+			path: globPath
+		} : null
+	};
+}
+function warning(condition, message) {
+	if (process.env.NODE_ENV === "development" && !condition) console.warn(message);
+}
+const cache = fastCache({ maxCacheSize: 5e3 });
+function compilePath(path, caseSensitive = false, end = true) {
+	return cache.getOrInsert(`${path}-${caseSensitive ? "s" : "i"}${end ? "e" : ""}`, () => {
+		warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
+		const params = [];
+		let regexpSource = `^${path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+			params.push({
+				paramName,
+				isOptional: isOptional != null
+			});
+			return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+		})}`;
+		if (path.endsWith("*")) {
+			params.push({ paramName: "*" });
+			regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+		} else if (end) regexpSource += "\\/*$";
+		else if (path !== "" && path !== "/") regexpSource += "(?:(?=\\/|$))";
+		return [new RegExp(regexpSource, caseSensitive ? void 0 : "i"), params];
+	});
+}
+function matchPathWith(path) {
+	return { patterns: (patternsToMatch) => {
+		if (!path) return null;
+		for (const [key, pattern] of Object.entries(patternsToMatch)) {
+			const match = matchPath(key, path);
+			if (match) return pattern(match);
+		}
+		return null;
+	} };
+}
+
+//#endregion
+export { matchPath, matchPathWith };

package/dist/mathUtils-BDP1lM_z.mjs

@@ -0,0 +1,81 @@
+//#region src/mathUtils.ts
+function clampMax(value, max) {
+	return value > max ? max : value;
+}
+function clampMin(value, min) {
+	return value < min ? min : value;
+}
+function clampRange(num, v1, v2) {
+	if (v2 > v1) return clamp(num, v1, v2);
+	return clamp(num, v2, v1);
+}
+function clamp(num, min, max) {
+	return num > max ? max : num < min ? min : num;
+}
+function fixFloatingPointNumber(value) {
+	return Number(value.toPrecision(15));
+}
+/**
+* Rounds a number to the nearest multiple of the specified step value.
+*
+* @param value - The number to round
+* @param step - The step size to round to
+* @param offset - Optional offset to shift the rounding grid
+* @returns The rounded value
+*
+* @example
+* roundToStep(23, 5) // 25 (nearest multiple of 5)
+*/
+function roundToStep(value, step, offset = 0) {
+	const inv = 1 / step;
+	const snapped = Math.round((value - offset) * inv) / inv + offset;
+	return Number(snapped.toFixed(12));
+}
+/**
+* Floors a number down to the nearest multiple of the specified step value.
+*
+* @param value - The number to floor
+* @param step - The step size to floor to
+* @param offset - Optional offset to shift the flooring grid
+* @returns The floored value
+*
+* @example
+* floorToStep(23, 5) // 20 (largest multiple of 5 ≤ 23)
+*/
+function floorToStep(value, step, offset = 0) {
+	const inv = 1 / step;
+	const snapped = Math.floor((value - offset) * inv) / inv + offset;
+	return Number(snapped.toFixed(12));
+}
+/**
+* Ceils a number up to the nearest multiple of the specified step value.
+*
+* @param value - The number to ceil
+* @param step - The step size to ceil to
+* @param offset - Optional offset to shift the ceiling grid
+* @returns The ceiled value
+*
+* @example
+* ceilToStep(23, 5) // 25 (smallest multiple of 5 ≥ 23)
+*/
+function ceilToStep(value, step, offset = 0) {
+	const inv = 1 / step;
+	const snapped = Math.ceil((value - offset) * inv) / inv + offset;
+	return Number(snapped.toFixed(12));
+}
+/**
+* Rounds a number to the specified number of decimal places.
+*
+* @param num - The number to round
+* @param precision - Number of decimal places
+* @returns The rounded number
+*
+* @example
+* round(3.14159, 2) // 3.14
+*/
+function round(num, precision) {
+	return Math.round(num * 10 ** precision) / 10 ** precision;
+}
+
+//#endregion
+export { clampRange as a, round as c, clampMin as i, roundToStep as l, clamp as n, fixFloatingPointNumber as o, clampMax as r, floorToStep as s, ceilToStep as t };

package/dist/{mathUtils.d.cts → mathUtils.d.mts}

@@ -1,3 +1,4 @@
+//#region src/mathUtils.d.ts
 declare function clampMax(value: number, max: number): number;
 declare function clampMin(value: number, min: number): number;
 declare function clampRange(num: number, v1: number, v2: number): number;
@@ -50,5 +51,5 @@ declare function ceilToStep(value: number, step: number, offset?: number): numbe
  * round(3.14159, 2) // 3.14
  */
 declare function round(num: number, precision: number): number;
-
-export { ceilToStep, clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber, floorToStep, round, roundToStep };
+//#endregion
+export { ceilToStep, clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber, floorToStep, round, roundToStep };

package/dist/mathUtils.mjs

@@ -0,0 +1,3 @@
+import { a as clampRange, c as round, i as clampMin, l as roundToStep, n as clamp, o as fixFloatingPointNumber, r as clampMax, s as floorToStep, t as ceilToStep } from "./mathUtils-BDP1lM_z.mjs";
+
+export { ceilToStep, clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber, floorToStep, round, roundToStep };

package/dist/{mutationUtils.d.cts → mutationUtils.d.mts}

@@ -1,3 +1,4 @@
+//#region src/mutationUtils.d.ts
 /**
  * Updates an object with a new set of values. undefined values are ignored in
  * the updates object and deep equal values are not updated.
@@ -7,9 +8,9 @@
  */
 declare function updateObject<T extends Record<string, unknown>>(object: T | undefined | null, updates: Partial<T>): void;
 declare function getArrayMethodsFromProduce<T extends Record<string, unknown>>(produceFn: (cb: (newVal: T[]) => void | T[]) => T[] | void, getItemId: (item: T) => string): {
-    add: (item: T) => void | T[];
-    remove: (id: string) => void | T[];
-    update: (id: string, updateItem: ((draftItem: T) => T | void) | Partial<T>) => void | T[];
+  add: (item: T) => void | T[];
+  remove: (id: string) => void | T[];
+  update: (id: string, updateItem: ((draftItem: T) => T | void) | Partial<T>) => void | T[];
 };
-
-export { getArrayMethodsFromProduce, updateObject };
+//#endregion
+export { getArrayMethodsFromProduce, updateObject };

package/dist/mutationUtils.mjs

@@ -0,0 +1,44 @@
+import { n as isFunction } from "./typeGuards-B1mzA-Rz.mjs";
+import { keepPrevIfUnchanged } from "./keepPrevIfUnchanged.mjs";
+
+//#region src/mutationUtils.ts
+/**
+* Updates an object with a new set of values. undefined values are ignored in
+* the updates object and deep equal values are not updated.
+*
+* @param object - The object to update.
+* @param updates - The new values to update the object with.
+*/
+function updateObject(object, updates) {
+	if (!object || typeof object !== "object") return;
+	for (const key of Object.keys(updates)) {
+		const value = updates[key];
+		if (value !== void 0) object[key] = keepPrevIfUnchanged({
+			prev: object[key],
+			newValue: value
+		});
+	}
+}
+function getArrayMethodsFromProduce(produceFn, getItemId) {
+	return {
+		add: (item) => produceFn((draft) => {
+			draft.push(item);
+		}),
+		remove: (id) => produceFn((draft) => {
+			const index = draft.findIndex((item) => getItemId(item) === id);
+			if (index !== -1) draft.splice(index, 1);
+		}),
+		update: (id, updateItem) => produceFn((draft) => {
+			const index = draft.findIndex((item$1) => getItemId(item$1) === id);
+			const item = draft[index];
+			if (!item) throw new Error(`Item with id ${id} not found`);
+			if (isFunction(updateItem)) {
+				const updatedItem = updateItem(item);
+				if (updatedItem) draft[index] = updatedItem;
+			} else updateObject(item, updateItem);
+		})
+	};
+}
+
+//#endregion
+export { getArrayMethodsFromProduce, updateObject };

package/dist/{objUtils.d.ts → objUtils.d.mts}

@@ -1,7 +1,9 @@
-import { Result } from 't-result';
-import { SortByValueFn, SortByProps } from './arrayUtils.js';
-import { MakeUndefinedKeysOptional } from './typeUtils.js';
-import { AddPrefixToObjKeys, AddSuffixToObjKeys } from './typingUtils.js';
+import { SortByProps, SortByValueFn } from "./arrayUtils.mjs";
+import { MakeUndefinedKeysOptional } from "./typeUtils.mjs";
+import { AddPrefixToObjKeys, AddSuffixToObjKeys } from "./typingUtils.mjs";
+import { Result } from "t-result";
+
+//#region src/objUtils.d.ts
 
 /**
  * @deprecated Use typedObjectEntries from @ls-stack/utils/typingFnUtils instead
@@ -24,5 +26,5 @@ declare function getValueFromPath(obj: Record<string, unknown>, path: string): R
 declare function getObjPropertyOrInsert<T extends Record<string, any>, K extends keyof T>(obj: T, prop: K, insertValue: () => Exclude<T[K], undefined>): Exclude<T[K], undefined>;
 declare function addPrefixToObjKeys<T extends Record<string, unknown>, P extends string>(obj: T, prefix: P): AddPrefixToObjKeys<T, P>;
 declare function addSuffixToObjKeys<T extends Record<string, unknown>, S extends string>(obj: T, suffix: S): AddSuffixToObjKeys<T, S>;
-
-export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };
+//#endregion
+export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };

package/dist/objUtils.mjs

@@ -0,0 +1,115 @@
+import { sortBy } from "./arrayUtils.mjs";
+import { d as typedObjectEntries } from "./typingFnUtils-Bb8drgKF.mjs";
+import { Result } from "t-result";
+
+//#region src/objUtils.ts
+/**
+* @deprecated Use typedObjectEntries from @ls-stack/utils/typingFnUtils instead
+* @param obj
+*/
+function objectTypedEntries(obj) {
+	return Object.entries(obj);
+}
+function pick(obj, keys) {
+	const result = {};
+	for (const key of keys) result[key] = obj[key];
+	return result;
+}
+function mapArrToObj(array, mapper) {
+	return Object.fromEntries(array.map(mapper));
+}
+/** @deprecated Use mapArrToObj instead */
+const mapArrayToObject = mapArrToObj;
+function mapObjToObj(obj, mapper) {
+	return Object.fromEntries(objectTypedEntries(obj).map(([key, value]) => mapper(key, value)));
+}
+/** @deprecated Use mapObjToObj instead */
+const mapObjectToObject = mapObjToObj;
+function omit(obj, keys) {
+	const result = {};
+	for (const key of Object.keys(obj)) if (!keys.includes(key)) result[key] = obj[key];
+	return result;
+}
+function looseGetObjectProperty(obj, key) {
+	return obj[key];
+}
+function rejectObjUndefinedValues(obj) {
+	const result = {};
+	for (const key in obj) if (obj[key] !== void 0) result[key] = obj[key];
+	return result;
+}
+function filterObjectKeys(obj, predicate) {
+	return Object.fromEntries(Object.entries(obj).filter(([key, value]) => predicate(key, value)));
+}
+function sortObjectKeys(obj, sortByFn, options) {
+	return Object.fromEntries(sortBy(typedObjectEntries(obj), sortByFn, options));
+}
+function getValueFromPath(obj, path) {
+	if (!path.trim()) return Result.err(/* @__PURE__ */ new Error("Path cannot be empty"));
+	const segments = parsePath(path);
+	let current = obj;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (!segment) return Result.err(/* @__PURE__ */ new Error("Invalid empty segment in path"));
+		if (current == null) return Result.err(/* @__PURE__ */ new Error(`Cannot access property '${segment}' on null or undefined`));
+		if (isNumericString(segment)) {
+			if (!Array.isArray(current)) return Result.err(/* @__PURE__ */ new Error(`Cannot access array index '${segment}' on non-array value`));
+			const index = parseInt(segment, 10);
+			if (index < 0 || index >= current.length) return Result.err(/* @__PURE__ */ new Error(`Array index '${index}' out of bounds`));
+			current = current[index];
+		} else {
+			if (typeof current !== "object" || current === null) return Result.err(/* @__PURE__ */ new Error(`Cannot access property '${segment}' on non-object value`));
+			if (!(segment in current)) return Result.err(/* @__PURE__ */ new Error(`Property '${segment}' not found`));
+			current = current[segment];
+		}
+	}
+	return Result.ok(current);
+}
+function parsePath(path) {
+	const segments = [];
+	let current = "";
+	let inBrackets = false;
+	for (let i = 0; i < path.length; i++) {
+		const char = path[i];
+		if (char === "[") {
+			if (current) {
+				segments.push(current);
+				current = "";
+			}
+			inBrackets = true;
+		} else if (char === "]") {
+			if (inBrackets && current) {
+				segments.push(current);
+				current = "";
+			}
+			inBrackets = false;
+		} else if (char === "." && !inBrackets) {
+			if (current) {
+				segments.push(current);
+				current = "";
+			}
+		} else current += char;
+	}
+	if (current) segments.push(current);
+	return segments;
+}
+function isNumericString(str) {
+	return /^\d+$/.test(str);
+}
+function getObjPropertyOrInsert(obj, prop, insertValue) {
+	if (obj[prop] === void 0) obj[prop] = insertValue();
+	return obj[prop];
+}
+function addPrefixToObjKeys(obj, prefix) {
+	const newObj = {};
+	for (const [key, value] of Object.entries(obj)) newObj[`${prefix}${key}`] = value;
+	return newObj;
+}
+function addSuffixToObjKeys(obj, suffix) {
+	const newObj = {};
+	for (const [key, value] of Object.entries(obj)) newObj[`${key}${suffix}`] = value;
+	return newObj;
+}
+
+//#endregion
+export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };

package/dist/parallelAsyncCalls.d.mts

@@ -0,0 +1,83 @@
+import { Result } from "t-result";
+
+//#region src/parallelAsyncCalls.d.ts
+type ValidMetadata = string | number | boolean | Record<string, unknown>;
+type TupleRunAllSuccess<T> = T extends (() => Promise<Result<infer V>>) ? Succeeded<V, undefined> : T extends {
+  metadata: infer M;
+  fn: () => Promise<Result<infer V>>;
+} ? Succeeded<V, M> : never;
+type TupleRunAllFailed<T> = T extends (() => Promise<Result<any>>) ? {
+  metadata: undefined;
+  error: Error;
+} : T extends {
+  metadata: infer M extends ValidMetadata;
+} ? {
+  metadata: M;
+  error: Error;
+} : never;
+type TupleRunAllSettled<T> = T extends (() => Promise<Result<infer V>>) ? Succeeded<V, undefined> | Failed<undefined> : T extends {
+  metadata: infer M;
+  fn: () => Promise<Result<infer V>>;
+} ? Succeeded<V, M> | Failed<M> : never;
+type RunProps = {
+  delayStart?: (index: number) => number;
+};
+type Failed<M$1> = {
+  metadata: M$1;
+  error: Error;
+};
+type Succeeded<R, M$1> = {
+  value: R;
+  metadata: M$1;
+};
+declare class ParallelAsyncResultCalls<M$1 extends ValidMetadata | undefined = undefined, R = unknown> {
+  private pendingCalls;
+  alreadyRun: boolean;
+  constructor();
+  add(call: M$1 extends undefined ? () => Promise<Result<R>> : {
+    metadata: M$1;
+    fn: () => Promise<Result<R>>;
+  }): this;
+  /**
+   * Adds calls return tuples with inferred results
+   *
+   * @param calls
+   */
+  addTuple<T extends (M$1 extends undefined ? () => Promise<Result<R>> : {
+    metadata: M$1;
+    fn: () => Promise<Result<R>>;
+  })[]>(...calls: T): {
+    runAllSettled: (props?: RunProps) => Promise<{
+      results: { [I in keyof T]: TupleRunAllSettled<T[I]> };
+      allFailed: boolean;
+    }>;
+    runAll: (props?: RunProps) => Promise<Result<{ [I in keyof T]: TupleRunAllSuccess<T[I]> }, TupleRunAllFailed<T[number]>>>;
+  };
+  runAllSettled({
+    delayStart
+  }?: RunProps): Promise<{
+    failed: Failed<M$1>[];
+    succeeded: Succeeded<R, M$1>[];
+    allFailed: boolean;
+    results: (Failed<M$1> | Succeeded<R, M$1>)[];
+  }>;
+  runAll({
+    delayStart
+  }?: {
+    delayStart?: (index: number) => number;
+  }): Promise<Result<Succeeded<R, M$1>[], {
+    metadata: M$1;
+    error: Error;
+  }>>;
+}
+/**
+ * Executes multiple asynchronous calls in parallel and collects the results in
+ * a easier to use format.
+ *
+ * @deprecated Use concurrentAsyncCalls instead.
+ * @template R - The type of the result value.
+ * @template M - The type of the call metadata.
+ */
+declare function parallelAsyncCalls<M$1 extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M$1, R>;
+//#endregion
+export { parallelAsyncCalls };