@zelgadis87/utils-core 5.4.0 → 5.4.1

package/.rollup/index.cjs

@@ -778,9 +778,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;
     }, [[], []]);
 }
 /**
@@ -1103,130 +1103,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) {
@@ -1399,6 +1275,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).
@@ -3685,6 +3752,7 @@ exports.Logger = Logger;
 exports.NEVER = NEVER;
 exports.NonExhaustiveSwitchError = NonExhaustiveSwitchError;
 exports.Operation = Operation;
+exports.OperationAggregateError = OperationAggregateError;
 exports.Optional = Optional;
 exports.PredicateBuilder = PredicateBuilder;
 exports.RandomTimeDuration = RandomTimeDuration;