@zelgadis87/utils-core 5.4.3 → 5.4.4

package/.rollup/index.d.ts

@@ -1069,6 +1069,7 @@ type TValidation<T, E = Error> = {
  */
 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.
  *
@@ -1082,6 +1083,32 @@ declare class OperationAggregateError<E = Error> extends Error {
      */
     get count(): number;
 }
+/**
+ * Recursively extracts the innermost error type from potentially nested OperationAggregateError.
+ * This enables `Operation.combine` to return accurate error types after flattening.
+ *
+ * @template E - The error type to flatten
+ * @example
+ *   TOperationAggregateFlattenedError<string>                            // string
+ *   TOperationAggregateFlattenedError<OperationAggregateError<string>>   // string
+ *   TOperationAggregateFlattenedError<Error | OperationAggregateError<string>>  // Error | string
+ */
+type TOperationAggregateFlattenedError<E> = E extends OperationAggregateError<infer Inner> ? TOperationAggregateFlattenedError<Inner> : 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.
+ *
+ * When combining operations whose error type is already `OperationAggregateError<E>`,
+ * the errors are automatically flattened to avoid nesting (e.g., combining results from
+ * previous `combine` calls).
+ *
+ * @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 (flattened)
+ */
+declare function combine<T, E = Error>(results: TReadableArray<TOperation<T, E>>): TOperation<T[], OperationAggregateError<TOperationAggregateFlattenedError<E>>>;
 declare const Operation: {
     ok: <const T>(data: T) => {
         readonly success: true;
@@ -1118,17 +1145,7 @@ declare const Operation: {
      * @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>>;
+    combine: typeof combine;
 };
 
 declare function withTryCatch<R>(fn: TFunction<void, R>, errMapFn?: TTransformer<Error, Error>): TOperationTuple<R, Error>;

package/.rollup/index.mjs

@@ -1274,6 +1274,7 @@ function wrapWithString(str, start, end = start) {
 }
 
 /**
+
  * An error class that aggregates multiple errors from a combined operation.
  * Used by `Operation.combine` to represent failures from multiple operations.
  *
@@ -1293,6 +1294,31 @@ class OperationAggregateError extends Error {
         return this.errors.length;
     }
 }
+/**
+ * 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.
+ *
+ * When combining operations whose error type is already `OperationAggregateError<E>`,
+ * the errors are automatically flattened to avoid nesting (e.g., combining results from
+ * previous `combine` calls).
+ *
+ * @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 (flattened)
+ */
+function combine$1(results) {
+    const [successes, failures] = partition(results, r => r.success);
+    if (failures.length === 0) {
+        return { success: true, data: successes.map(r => r.data) };
+    }
+    const allErrors = failures.flatMap(r => {
+        const error = r.error;
+        return error instanceof OperationAggregateError ? error.errors : [error];
+    });
+    return { success: false, error: new OperationAggregateError(allErrors) };
+}
 const Operation = {
     ok: (data) => {
         return { success: true, data };
@@ -1333,20 +1359,7 @@ const Operation = {
     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)));
-    },
+    combine: combine$1,
 };
 
 function asPromise(promisable) {