@zelgadis87/utils-core 5.4.0 → 5.4.1

package/.rollup/index.d.ts

@@ -181,8 +181,8 @@ type TOptional<T> = {
     orElseReturnNullableAndApply: (newValue: T | null | undefined) => TOptional<T>;
     orElseProduceNullableAndApply: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
     orElseThrow: (errorProducer: TProducer<Error>) => TPresentOptional<T>;
-    mapTo<R>(mapper: TFunction<T, R>): TOptional<R>;
-    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
+    mapTo<R>(mapper: TFunction<T, R>): TPresentOptional<R> | TEmptyOptional<T>;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R> | TEmptyOptional<T>;
     filter(predicate: TPredicate<T>): TOptional<T>;
 };
 type TEmptyOptional<T> = TOptional<T> & {
@@ -190,12 +190,17 @@ type TEmptyOptional<T> = TOptional<T> & {
     isEmpty(): true;
     isPresent(): false;
     apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RE;
+    mapTo<R>(mapper: TFunction<T, R>): TEmptyOptional<T>;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TEmptyOptional<T>;
+    filter(predicate: TPredicate<T>): TEmptyOptional<T>;
 };
 type TPresentOptional<T> = TOptional<T> & {
     get(): T;
     isEmpty(): false;
     isPresent(): true;
     apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RP;
+    mapTo<R>(mapper: TFunction<T, R>): TPresentOptional<R>;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
 };
 declare class ErrorGetEmptyOptional extends Error {
     constructor();
@@ -893,7 +898,7 @@ declare function filterMapReduce<T, U, R>(array: T[], filterFn: TPredicate<T>, m
  * @param predicate the predicate to use to partition the array
  * @returns a tuple, where the first array contains items matching the predicate, and the second array contains items not matching the predicate.
  */
-declare function partition<T>(arr: T[], predicate: TPredicate<T>): [T[], T[]];
+declare function partition<T>(arr: TReadableArray<T>, predicate: TPredicate<T>): [T[], T[]];
 /**
  * Maps the first truthy value in the array using the provided mapping function.
  * @param arr - The array of items.
@@ -1021,16 +1026,21 @@ type TIsEmptyObject<T> = keyof T extends never ? true : false;
 type TConditionalOptionalType<T> = TIsEmptyObject<T> extends true ? [] : [T];
 type TEmptyObject = Record<string, never>;
 
-type TOperation<T, E = Error> = {
+type TOperationFailure<E = Error> = {
     success: false;
     error: E;
-} | {
+};
+type TOperationSuccess<T> = {
     success: true;
     data: T;
 };
+type TOperation<T, E = Error> = TOperationFailure<E> | TOperationSuccess<T>;
 type TAsyncOperation<T, E = Error> = Promise<TOperation<T, E>>;
 type TOperationTuple<T, E = Error> = [T, undefined] | [undefined, E];
 type TAsyncOperationTuple<T, E = Error> = Promise<TOperationTuple<T, E>>;
+/**
+ * @deprecated Use `TOperation<T, OperationAggregateError<E>>` with `Operation.combine` instead.
+ */
 type TValidation<T, E = Error> = {
     success: false;
     errors: E[];
@@ -1038,7 +1048,24 @@ type TValidation<T, E = Error> = {
     success: true;
     data: T;
 };
+/**
+ * @deprecated Use `TAsyncOperation<T, OperationAggregateError<E>>` with `Operation.combine` instead.
+ */
 type TAsyncValidation<T, E = Error> = Promise<TValidation<T, E>>;
+/**
+ * An error class that aggregates multiple errors from a combined operation.
+ * Used by `Operation.combine` to represent failures from multiple operations.
+ *
+ * @template E - The type of individual errors (defaults to Error, but can be any type)
+ */
+declare class OperationAggregateError<E = Error> extends Error {
+    readonly errors: E[];
+    constructor(errors: E[]);
+    /**
+     * Returns the number of aggregated errors.
+     */
+    get count(): number;
+}
 declare const Operation: {
     ok: <const T>(data: T) => {
         readonly success: true;
@@ -1048,6 +1075,44 @@ declare const Operation: {
         readonly success: false;
         readonly error: E;
     };
+    /**
+     * Type predicate that returns true if the operation is a success.
+     * Useful for type narrowing in conditional blocks.
+     *
+     * @template T - The success data type
+     * @param result - The operation result to check
+     * @returns true if the operation succeeded, false otherwise
+     */
+    isSuccess<T>(result: TOperation<T, unknown>): result is TOperationSuccess<T>;
+    /**
+     * Type predicate that returns true if the operation is a failure.
+     * Useful for type narrowing in conditional blocks.
+     *
+     * @template E - The error type
+     * @param result - The operation result to check
+     * @returns true if the operation failed, false otherwise
+     */
+    isFailure<E>(result: TOperation<unknown, E>): result is TOperationFailure<E>;
+    /**
+     * Partitions an array of operations into successes and failures.
+     *
+     * @template T - The success data type of individual operations
+     * @template E - The error type of individual operations (defaults to Error)
+     * @param results - Array of operation results to partition
+     * @returns A tuple of [successes, failures]
+     */
+    partition: <T, E = Error>(results: TReadableArray<TOperation<T, E>>) => [TOperationSuccess<T>[], TOperationFailure<E>[]];
+    /**
+     * Combines multiple operation results into a single result.
+     * - If all operations succeed, returns success with an array of all data values.
+     * - If any operation fails, returns failure with an `OperationAggregateError` containing all errors.
+     *
+     * @template T - The success data type of individual operations
+     * @template E - The error type of individual operations (defaults to Error)
+     * @param results - Array of operation results to combine
+     * @returns A single operation with either all data or all aggregated errors
+     */
+    combine: <T, E = Error>(results: TReadableArray<TOperation<T, E>>) => TOperation<T[], OperationAggregateError<E>>;
 };
 
 declare function withTryCatch<R>(fn: TFunction<void, R>, errMapFn?: TTransformer<Error, Error>): TOperationTuple<R, Error>;
@@ -1504,5 +1569,5 @@ declare class DataUpgrader<X extends TUpgradable, XLatest extends X> implements
 }
 declare function isUpgradable(obj: TJsonSerializable): obj is TUpgradable;
 
-export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, havingMaxBy, havingMinBy, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomDecimalInInterval, randomId, randomIntegerInInterval, randomNumberInInterval, randomPick, randomPicks, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
-export type { ICancelable, ICancelablePromise, IDataUpgrader, TAccumulator, TAllKeysOptional, TAnyFunction, TArrayable, TAsyncAnyFunction, TAsyncBiConsumer, TAsyncBiFunction, TAsyncBiPredicate, TAsyncConsumer, TAsyncFunction, TAsyncOperation, TAsyncOperationTuple, TAsyncPredicate, TAsyncProducer, TAsyncValidation, TAsyncVoidFunction, TBasicTimePattern, TBiConsumer, TBiFunction, TBiPredicate, TComparisonDirection, TComparisonFunction, TComparisonResult, TConditionalOptionalType, TConditionalParameter, TConditionalParameterOptions, TConsumer, TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, TDayOfMonth, TDayOfWeek, TDigit, TDigit1_9, TEmpty, TEmptyArray, TEmptyObject, TEmptyOptional, TFourDigits, TFourDigitsMillisecond, TFourDigitsYear, TFunction, THasNever, THourOfDay, THtmlString, TIdentityFunction, TIntervalHandle, TIsEmptyObject, TIso8601DateString, TIso8601DateUtcString, TJsonArray, TJsonObject, TJsonPrimitive, TJsonSerializable, TKeysOfType, TLoggerOpts, TMaybe, TMillisecondOfSecond, TMinuteOfHour, TMonth, TMonthName, TNegativeNumber, TNumber0_10, TNumber0_100, TNumber0_1000, TNumber0_15, TNumber0_20, TNumber0_5, TNumber1_10, TNumericFloatingPointString, TNumericString, TOneDigit, TOperation, TOperationTuple, TOptional, TOptionalKeysForType, TOptionsWithoutDefaults, TParseInt, TParseableInt, TPositiveNumber, TPredefinedTimeDuration, TPredicate, TPresentOptional, TPrettify, TPrimitive, TProducer, TPromisable, TReadableArray, TRelativeUrl, TReplaceType, TRequiredKeysForType, TSecondOfMinute, TSorter, TSorterBuilder, TStrictComparisonResult, TThreeDigits, TThreeDigitsMillisecond, TTimeInUnits, TTimeoutHandle, TTransformer, TTwoDigits, TTwoDigitsDate, TTwoDigitsHour, TTwoDigitsMinute, TTwoDigitsMonth, TTwoDigitsSecond, TTypePredicate, TUpToFourDigits, TUpToThreeDigits, TUpToTwoDigits, TUpgradable, TUrl, TValidTimeDuration, TValidation, TVoidFunction, TWeekNumber, TWithExtras, TWithRequiredProperties, TWithRequiredProperty, TYear, TZero };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, OperationAggregateError, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, havingMaxBy, havingMinBy, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomDecimalInInterval, randomId, randomIntegerInInterval, randomNumberInInterval, randomPick, randomPicks, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export type { ICancelable, ICancelablePromise, IDataUpgrader, TAccumulator, TAllKeysOptional, TAnyFunction, TArrayable, TAsyncAnyFunction, TAsyncBiConsumer, TAsyncBiFunction, TAsyncBiPredicate, TAsyncConsumer, TAsyncFunction, TAsyncOperation, TAsyncOperationTuple, TAsyncPredicate, TAsyncProducer, TAsyncValidation, TAsyncVoidFunction, TBasicTimePattern, TBiConsumer, TBiFunction, TBiPredicate, TComparisonDirection, TComparisonFunction, TComparisonResult, TConditionalOptionalType, TConditionalParameter, TConditionalParameterOptions, TConsumer, TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, TDayOfMonth, TDayOfWeek, TDigit, TDigit1_9, TEmpty, TEmptyArray, TEmptyObject, TEmptyOptional, TFourDigits, TFourDigitsMillisecond, TFourDigitsYear, TFunction, THasNever, THourOfDay, THtmlString, TIdentityFunction, TIntervalHandle, TIsEmptyObject, TIso8601DateString, TIso8601DateUtcString, TJsonArray, TJsonObject, TJsonPrimitive, TJsonSerializable, TKeysOfType, TLoggerOpts, TMaybe, TMillisecondOfSecond, TMinuteOfHour, TMonth, TMonthName, TNegativeNumber, TNumber0_10, TNumber0_100, TNumber0_1000, TNumber0_15, TNumber0_20, TNumber0_5, TNumber1_10, TNumericFloatingPointString, TNumericString, TOneDigit, TOperation, TOperationFailure, TOperationSuccess, TOperationTuple, TOptional, TOptionalKeysForType, TOptionsWithoutDefaults, TParseInt, TParseableInt, TPositiveNumber, TPredefinedTimeDuration, TPredicate, TPresentOptional, TPrettify, TPrimitive, TProducer, TPromisable, TReadableArray, TRelativeUrl, TReplaceType, TRequiredKeysForType, TSecondOfMinute, TSorter, TSorterBuilder, TStrictComparisonResult, TThreeDigits, TThreeDigitsMillisecond, TTimeInUnits, TTimeoutHandle, TTransformer, TTwoDigits, TTwoDigitsDate, TTwoDigitsHour, TTwoDigitsMinute, TTwoDigitsMonth, TTwoDigitsSecond, TTypePredicate, TUpToFourDigits, TUpToThreeDigits, TUpToTwoDigits, TUpgradable, TUrl, TValidTimeDuration, TValidation, TVoidFunction, TWeekNumber, TWithExtras, TWithRequiredProperties, TWithRequiredProperty, TYear, TZero };

package/.rollup/index.mjs

@@ -776,9 +776,9 @@ function filterMapReduce(array, filterFn, mapFn, reduceFn, initialValue) {
  * @returns a tuple, where the first array contains items matching the predicate, and the second array contains items not matching the predicate.
  */
 function partition(arr, predicate) {
-    return arr.reduce((partition, item) => {
-        partition[(predicate(item) ? 0 : 1)].push(item);
-        return partition;
+    return [...arr].reduce((acc, item) => {
+        acc[(predicate(item) ? 0 : 1)].push(item);
+        return acc;
     }, [[], []]);
 }
 /**
@@ -1101,130 +1101,6 @@ function tryToParseNumber(numberStr) {
     });
 }
 
-const Operation = {
-    ok: (data) => {
-        return { success: true, data };
-    },
-    ko: (error) => {
-        return { success: false, error };
-    },
-};
-
-function asPromise(promisable) {
-    return Promise.resolve(promisable);
-}
-function promiseSequence(...fns) {
-    const fn = async function () {
-        const results = [];
-        for (let i = 0; i < fns.length; i++) {
-            results[i] = await fns[i]();
-        }
-        return results;
-    };
-    return fn;
-}
-function delayPromise(duration) {
-    return (result) => duration.promise().then(() => result);
-}
-class TimeoutError extends Error {
-}
-async function awaitAtMost(promise, duration) {
-    return Promise.race([
-        promise.then(value => ({ status: 'ok', value })),
-        duration.promise().then(() => ({ status: 'timeout' }))
-    ]).then(({ status, value }) => {
-        if (status === 'ok')
-            return value;
-        throw new TimeoutError("Time out reached while waiting for a promise to resolve.");
-    });
-}
-const NEVER = new Promise(_resolve => { });
-
-/**
- * Returns a random integer in the range [min, max].
- * @deprecated Use randomIntegerInInterval or randomDecimalInInterval instead
- */
-function randomNumberInInterval(min, max) {
-    return Math.floor(Math.random() * (max - min + 1) + min);
-}
-/**
- * Returns a random integer in the range [min, max].
- * @param min - Minimum value (inclusive)
- * @param max - Maximum value (inclusive)
- * @returns A random integer between min and max
- */
-function randomIntegerInInterval(min, max) {
-    return Math.floor(Math.random() * (max - min + 1) + min);
-}
-/**
- * Returns a random decimal in the range [min, max).
- * @param min - Minimum value (inclusive)
- * @param max - Maximum value (exclusive)
- * @returns A random decimal between min and max
- */
-function randomDecimalInInterval(min, max) {
-    return Math.random() * (max - min) + min;
-}
-const randomId = (length) => {
-    const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += characters.charAt(randomIntegerInInterval(0, characters.length - 1));
-    }
-    return result;
-};
-function randomPick(arr) {
-    return first$1(randomPicks(arr, 1));
-}
-function randomPicks(arr, count) {
-    const available = [...arr];
-    const result = [];
-    while (available.length > 0 && count > 0) {
-        const randomIndex = randomIntegerInInterval(0, available.length - 1);
-        result.push(available[randomIndex]);
-        available.splice(randomIndex, 1);
-        count--;
-    }
-    return result;
-}
-
-function dictToEntries(obj) {
-    return Object.entries(obj);
-}
-function entriesToDict(entries) {
-    return Object.fromEntries(entries);
-}
-function entriesToEntries(dict, mapper) {
-    return entriesToDict(dictToEntries(dict).map((entry) => mapper(entry)));
-}
-/** @deprecated[2025.08.01]: Compatibility layer. */
-const mapEntries = entriesToEntries;
-function entriesToList(dict, mapper) {
-    return dictToEntries(dict).map((entry) => mapper(entry));
-}
-
-function dictToList(obj) {
-    return Object.keys(obj).map(key => obj[key]);
-}
-function pick(o, keys) {
-    return keys.reduce((obj, key) => {
-        obj[key] = o[key];
-        return obj;
-    }, {});
-}
-function shallowRecordEquals(a, b) {
-    if (a === b)
-        return true;
-    const aKeys = Object.keys(a), bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    for (const key of aKeys) {
-        if (a[key] !== b[key])
-            return false;
-    }
-    return true;
-}
-
 class StringParts {
     _parts;
     constructor(...parts) {
@@ -1397,6 +1273,197 @@ function wrapWithString(str, start, end = start) {
     return start + str + end;
 }
 
+/**
+ * An error class that aggregates multiple errors from a combined operation.
+ * Used by `Operation.combine` to represent failures from multiple operations.
+ *
+ * @template E - The type of individual errors (defaults to Error, but can be any type)
+ */
+class OperationAggregateError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Operation failed with ${pluralize(errors.length, 'error')}`);
+        this.errors = errors;
+        this.name = 'OperationAggregateError';
+    }
+    /**
+     * Returns the number of aggregated errors.
+     */
+    get count() {
+        return this.errors.length;
+    }
+}
+const Operation = {
+    ok: (data) => {
+        return { success: true, data };
+    },
+    ko: (error) => {
+        return { success: false, error };
+    },
+    /**
+     * Type predicate that returns true if the operation is a success.
+     * Useful for type narrowing in conditional blocks.
+     *
+     * @template T - The success data type
+     * @param result - The operation result to check
+     * @returns true if the operation succeeded, false otherwise
+     */
+    isSuccess(result) {
+        return result.success === true;
+    },
+    /**
+     * Type predicate that returns true if the operation is a failure.
+     * Useful for type narrowing in conditional blocks.
+     *
+     * @template E - The error type
+     * @param result - The operation result to check
+     * @returns true if the operation failed, false otherwise
+     */
+    isFailure(result) {
+        return result.success === false;
+    },
+    /**
+     * Partitions an array of operations into successes and failures.
+     *
+     * @template T - The success data type of individual operations
+     * @template E - The error type of individual operations (defaults to Error)
+     * @param results - Array of operation results to partition
+     * @returns A tuple of [successes, failures]
+     */
+    partition: (results) => {
+        return partition(results, r => r.success);
+    },
+    /**
+     * Combines multiple operation results into a single result.
+     * - If all operations succeed, returns success with an array of all data values.
+     * - If any operation fails, returns failure with an `OperationAggregateError` containing all errors.
+     *
+     * @template T - The success data type of individual operations
+     * @template E - The error type of individual operations (defaults to Error)
+     * @param results - Array of operation results to combine
+     * @returns A single operation with either all data or all aggregated errors
+     */
+    combine: (results) => {
+        const [successes, failures] = Operation.partition(results);
+        return failures.length === 0 ? Operation.ok(successes.map(r => r.data)) : Operation.ko(new OperationAggregateError(failures.map(r => r.error)));
+    },
+};
+
+function asPromise(promisable) {
+    return Promise.resolve(promisable);
+}
+function promiseSequence(...fns) {
+    const fn = async function () {
+        const results = [];
+        for (let i = 0; i < fns.length; i++) {
+            results[i] = await fns[i]();
+        }
+        return results;
+    };
+    return fn;
+}
+function delayPromise(duration) {
+    return (result) => duration.promise().then(() => result);
+}
+class TimeoutError extends Error {
+}
+async function awaitAtMost(promise, duration) {
+    return Promise.race([
+        promise.then(value => ({ status: 'ok', value })),
+        duration.promise().then(() => ({ status: 'timeout' }))
+    ]).then(({ status, value }) => {
+        if (status === 'ok')
+            return value;
+        throw new TimeoutError("Time out reached while waiting for a promise to resolve.");
+    });
+}
+const NEVER = new Promise(_resolve => { });
+
+/**
+ * Returns a random integer in the range [min, max].
+ * @deprecated Use randomIntegerInInterval or randomDecimalInInterval instead
+ */
+function randomNumberInInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+/**
+ * Returns a random integer in the range [min, max].
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns A random integer between min and max
+ */
+function randomIntegerInInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+/**
+ * Returns a random decimal in the range [min, max).
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (exclusive)
+ * @returns A random decimal between min and max
+ */
+function randomDecimalInInterval(min, max) {
+    return Math.random() * (max - min) + min;
+}
+const randomId = (length) => {
+    const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(randomIntegerInInterval(0, characters.length - 1));
+    }
+    return result;
+};
+function randomPick(arr) {
+    return first$1(randomPicks(arr, 1));
+}
+function randomPicks(arr, count) {
+    const available = [...arr];
+    const result = [];
+    while (available.length > 0 && count > 0) {
+        const randomIndex = randomIntegerInInterval(0, available.length - 1);
+        result.push(available[randomIndex]);
+        available.splice(randomIndex, 1);
+        count--;
+    }
+    return result;
+}
+
+function dictToEntries(obj) {
+    return Object.entries(obj);
+}
+function entriesToDict(entries) {
+    return Object.fromEntries(entries);
+}
+function entriesToEntries(dict, mapper) {
+    return entriesToDict(dictToEntries(dict).map((entry) => mapper(entry)));
+}
+/** @deprecated[2025.08.01]: Compatibility layer. */
+const mapEntries = entriesToEntries;
+function entriesToList(dict, mapper) {
+    return dictToEntries(dict).map((entry) => mapper(entry));
+}
+
+function dictToList(obj) {
+    return Object.keys(obj).map(key => obj[key]);
+}
+function pick(o, keys) {
+    return keys.reduce((obj, key) => {
+        obj[key] = o[key];
+        return obj;
+    }, {});
+}
+function shallowRecordEquals(a, b) {
+    if (a === b)
+        return true;
+    const aKeys = Object.keys(a), bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+
 /**
  * Class that stores a value that is computationally/memory intensive to initialize.
  * The initialization of the value is done once and only if required (lazy initialization).
@@ -3669,5 +3736,5 @@ function isUpgradable(obj) {
     return isDefined(obj) && typeof obj === "object" && VERSION_FIELD in obj && isNumber(obj.$version) && isPositiveNumber(obj.$version);
 }
 
-export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, havingMaxBy, havingMinBy, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomDecimalInInterval, randomId, randomIntegerInInterval, randomNumberInInterval, randomPick, randomPicks, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, OperationAggregateError, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, havingMaxBy, havingMinBy, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomDecimalInInterval, randomId, randomIntegerInInterval, randomNumberInInterval, randomPick, randomPicks, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
 //# sourceMappingURL=index.mjs.map