@ls-stack/utils 3.31.0 → 3.33.0

package/docs/concurrentCalls/README.md

@@ -14,7 +14,7 @@
 
 ### ConcurrentCallsAggregateError
 
-Defined in: [packages/utils/src/concurrentCalls.ts:32](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L32)
+Defined in: [packages/utils/src/concurrentCalls.ts:38](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L38)
 
 #### Extends
 
@@ -31,13 +31,13 @@ new ConcurrentCallsAggregateError(
    failed): ConcurrentCallsAggregateError;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:37](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L37)
+Defined in: [packages/utils/src/concurrentCalls.ts:43](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L43)
 
 ###### Parameters
 
 ###### errors
 
-`Error`[]
+`ResultValidErrors`[]
 
 ###### total
 
@@ -62,10 +62,10 @@ AggregateError.constructor
 ##### errors
 
 ```ts
-errors: Error[] = [];
+errors: ResultValidErrors[] = [];
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:33](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L33)
+Defined in: [packages/utils/src/concurrentCalls.ts:39](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L39)
 
 ###### Overrides
 
@@ -79,7 +79,7 @@ AggregateError.errors
 failed: number = 0;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L35)
+Defined in: [packages/utils/src/concurrentCalls.ts:41](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L41)
 
 ##### total
 
@@ -87,13 +87,13 @@ Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucaso
 total: number = 0;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:34](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L34)
+Defined in: [packages/utils/src/concurrentCalls.ts:40](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L40)
 
 ***
 
 ### ConcurrentCallsWithMetadataAggregateError\<M\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:50](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L50)
+Defined in: [packages/utils/src/concurrentCalls.ts:62](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L62)
 
 #### Extends
 
@@ -116,7 +116,7 @@ new ConcurrentCallsWithMetadataAggregateError<M>(
 failed): ConcurrentCallsWithMetadataAggregateError<M>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:58](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L58)
+Defined in: [packages/utils/src/concurrentCalls.ts:70](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L70)
 
 ###### Parameters
 
@@ -147,10 +147,10 @@ AggregateError.constructor
 ##### errors
 
 ```ts
-errors: Error[] = [];
+errors: ResultValidErrors[] = [];
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:53](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L53)
+Defined in: [packages/utils/src/concurrentCalls.ts:65](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L65)
 
 ###### Overrides
 
@@ -164,12 +164,12 @@ AggregateError.errors
 errorsWithMetadata: object[] = [];
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:54](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L54)
+Defined in: [packages/utils/src/concurrentCalls.ts:66](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L66)
 
 ###### error
 
 ```ts
-error: Error;
+error: ResultValidErrors;
 ```
 
 ###### metadata
@@ -184,7 +184,7 @@ metadata: M;
 failed: number = 0;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:56](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L56)
+Defined in: [packages/utils/src/concurrentCalls.ts:68](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L68)
 
 ##### total
 
@@ -192,7 +192,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:56](https://github.com/lucaso
 total: number = 0;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:55](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L55)
+Defined in: [packages/utils/src/concurrentCalls.ts:67](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L67)
 
 ## Functions
 
@@ -202,7 +202,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:55](https://github.com/lucaso
 function concurrentCalls<R>(): ConcurrentCalls<R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L246)
+Defined in: [packages/utils/src/concurrentCalls.ts:273](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L273)
 
 Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
 
@@ -226,9 +226,9 @@ The type of the result value.
 function concurrentCallsWithMetadata<M, R>(): ConcurrentCallsWithMetadata<M, R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:435](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L435)
+Defined in: [packages/utils/src/concurrentCalls.ts:472](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L472)
 
-Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
 
 #### Type Parameters
 
@@ -247,3 +247,53 @@ The type of the result value.
 #### Returns
 
 [`ConcurrentCallsWithMetadata`](-internal-.md#concurrentcallswithmetadata)\<`M`, `R`, `Error`\>
+
+***
+
+### concurrentResultCalls()
+
+```ts
+function concurrentResultCalls<ResultFn>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:487](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L487)
+
+Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+
+#### Type Parameters
+
+##### ResultFn
+
+`ResultFn` *extends* (...`args`) => `Promise`\<`Result`\<`unknown`, `ResultValidErrors`\>\>
+
+#### Returns
+
+[`ConcurrentCalls`](-internal-.md#concurrentcalls)\<[`ValueFromResult`](-internal-.md#valuefromresult)\<`Awaited`\<`ReturnType`\<`ResultFn`\>\>\>, [`ErrorFromResult`](-internal-.md#errorfromresult)\<`Awaited`\<`ReturnType`\<`ResultFn`\>\>\>\>
+
+***
+
+### concurrentResultsWithMetadata()
+
+```ts
+function concurrentResultsWithMetadata<M, ResultFn>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:504](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L504)
+
+Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+
+#### Type Parameters
+
+##### M
+
+`M` *extends* [`ValidMetadata`](-internal-.md#validmetadata)
+
+##### ResultFn
+
+`ResultFn` *extends* (...`args`) => `Promise`\<`Result`\<`unknown`, `ResultValidErrors`\>\>
+
+The type of the result function that will be called.
+
+#### Returns
+
+[`ConcurrentCallsWithMetadata`](-internal-.md#concurrentcallswithmetadata)\<`M`, [`ValueFromResult`](-internal-.md#valuefromresult)\<`Awaited`\<`ReturnType`\<`ResultFn`\>\>\>, [`ErrorFromResult`](-internal-.md#errorfromresult)\<`Awaited`\<`ReturnType`\<`ResultFn`\>\>\>\>

package/lib/arrayUtils.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/arrayUtils.ts
 var arrayUtils_exports = {};
 __export(arrayUtils_exports, {
+  arrayOps: () => arrayOps,
   arrayWithPrev: () => arrayWithPrev,
   arrayWithPrevAndIndex: () => arrayWithPrevAndIndex,
   filterAndMap: () => filterAndMap,
@@ -155,8 +156,16 @@ function truncateArray(array, maxLength, appendIfTruncated) {
   }
   return result;
 }
+function arrayOps(array) {
+  return {
+    filterAndMap: (mapFilter) => filterAndMap(array, mapFilter),
+    sortBy: (sortByValue, props) => sortBy(array, sortByValue, props),
+    rejectDuplicates: (getKey) => rejectDuplicates(array, getKey)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  arrayOps,
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,

package/lib/arrayUtils.d.cts

@@ -21,6 +21,10 @@
 declare function filterAndMap<T, R>(array: IterableIterator<T> | readonly T[], mapFilter: (item: T, index: number) => false | R): R[];
 type FilterAndMapReturn<T> = false | T;
 type SortOrder = 'desc' | 'asc';
+type SortByValue<T> = (item: T) => (number | string)[] | number | string;
+type SortByProps = {
+    order?: SortOrder | SortOrder[];
+} | SortOrder | SortOrder[];
 /**
  * Sort an array based on a value
  *
@@ -42,9 +46,7 @@ type SortOrder = 'desc' | 'asc';
  * // return a array to sort by multiple values
  * const sortedItems = sortBy(items, (item) => [item.a, item.b]);
  */
-declare function sortBy<T>(arr: T[], sortByValue: (item: T) => (number | string)[] | number | string, props?: {
-    order?: SortOrder | SortOrder[];
-} | SortOrder | SortOrder[]): T[];
+declare function sortBy<T>(arr: T[], sortByValue: SortByValue<T>, props?: SortByProps): T[];
 declare function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][];
 declare function arrayWithPrevAndIndex<T>(array: T[]): {
     item: T;
@@ -58,5 +60,35 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @param mapFilter - A function that takes an item and returns a value or `false`
+     * to reject the item.
+     * @example
+     * const items = [1, 2, 3];
+     *
+     * const enhancedItems = arrayOps(items);
+     *
+     * enhancedItems.filterAndMap((item) => item === 2 ? false : item);
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValue<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+};
+/**
+ * Enhance an array with extra methods
+ *
+ * @param array
+ * @example
+ *
+ * const enhancedItems = arrayOps(array);
+ *
+ * enhancedItems.filterAndMap((item) => item === 2 ? false : item);
+ * enhancedItems.sortBy((item) => item);
+ * enhancedItems.rejectDuplicates((item) => item);
+ */
+declare function arrayOps<T>(array: T[]): ArrayOps<T>;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };

package/lib/arrayUtils.d.ts

@@ -21,6 +21,10 @@
 declare function filterAndMap<T, R>(array: IterableIterator<T> | readonly T[], mapFilter: (item: T, index: number) => false | R): R[];
 type FilterAndMapReturn<T> = false | T;
 type SortOrder = 'desc' | 'asc';
+type SortByValue<T> = (item: T) => (number | string)[] | number | string;
+type SortByProps = {
+    order?: SortOrder | SortOrder[];
+} | SortOrder | SortOrder[];
 /**
  * Sort an array based on a value
  *
@@ -42,9 +46,7 @@ type SortOrder = 'desc' | 'asc';
  * // return a array to sort by multiple values
  * const sortedItems = sortBy(items, (item) => [item.a, item.b]);
  */
-declare function sortBy<T>(arr: T[], sortByValue: (item: T) => (number | string)[] | number | string, props?: {
-    order?: SortOrder | SortOrder[];
-} | SortOrder | SortOrder[]): T[];
+declare function sortBy<T>(arr: T[], sortByValue: SortByValue<T>, props?: SortByProps): T[];
 declare function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][];
 declare function arrayWithPrevAndIndex<T>(array: T[]): {
     item: T;
@@ -58,5 +60,35 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @param mapFilter - A function that takes an item and returns a value or `false`
+     * to reject the item.
+     * @example
+     * const items = [1, 2, 3];
+     *
+     * const enhancedItems = arrayOps(items);
+     *
+     * enhancedItems.filterAndMap((item) => item === 2 ? false : item);
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValue<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+};
+/**
+ * Enhance an array with extra methods
+ *
+ * @param array
+ * @example
+ *
+ * const enhancedItems = arrayOps(array);
+ *
+ * enhancedItems.filterAndMap((item) => item === 2 ? false : item);
+ * enhancedItems.sortBy((item) => item);
+ * enhancedItems.rejectDuplicates((item) => item);
+ */
+declare function arrayOps<T>(array: T[]): ArrayOps<T>;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };

package/lib/arrayUtils.js

@@ -1,4 +1,5 @@
 import {
+  arrayOps,
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
@@ -10,10 +11,11 @@ import {
   rejectDuplicates,
   sortBy,
   truncateArray
-} from "./chunk-SRVMMYSW.js";
+} from "./chunk-RYBJST64.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
+  arrayOps,
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,

package/lib/{chunk-SRVMMYSW.js → chunk-RYBJST64.js}

@@ -115,6 +115,13 @@ function truncateArray(array, maxLength, appendIfTruncated) {
   }
   return result;
 }
+function arrayOps(array) {
+  return {
+    filterAndMap: (mapFilter) => filterAndMap(array, mapFilter),
+    sortBy: (sortByValue, props) => sortBy(array, sortByValue, props),
+    rejectDuplicates: (getKey) => rejectDuplicates(array, getKey)
+  };
+}
 
 export {
   filterAndMap,
@@ -127,5 +134,6 @@ export {
   rejectArrayUndefinedValues,
   hasDuplicates,
   rejectDuplicates,
-  truncateArray
+  truncateArray,
+  arrayOps
 };

package/lib/{chunk-J3ILVKZC.js → chunk-XUNY3QUT.js}

@@ -1,6 +1,6 @@
 import {
   sortBy
-} from "./chunk-SRVMMYSW.js";
+} from "./chunk-RYBJST64.js";
 import {
   isPlainObject
 } from "./chunk-JF2MDHOJ.js";

package/lib/concurrentCalls.cjs

@@ -23,7 +23,9 @@ __export(concurrentCalls_exports, {
   ConcurrentCallsAggregateError: () => ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError: () => ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls: () => concurrentCalls,
-  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata
+  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata,
+  concurrentResultCalls: () => concurrentResultCalls,
+  concurrentResultsWithMetadata: () => concurrentResultsWithMetadata
 });
 module.exports = __toCommonJS(concurrentCalls_exports);
 var import_t_result = require("t-result");
@@ -60,6 +62,15 @@ function truncateArray(array, maxLength, appendIfTruncated) {
   return result;
 }
 
+// src/safeJson.ts
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+
 // src/sleep.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -93,7 +104,10 @@ var ConcurrentCallsAggregateError = class extends AggregateError {
   failed = 0;
   constructor(errors, total, failed) {
     const messages = errors.map(
-      (error) => `- ${truncateString(error.message, 100)}`
+      (error) => `- ${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`
     );
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     super(errors, message);
@@ -122,7 +136,10 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
         }
       } catch (_) {
       }
-      return `- ${metadataPrefix}${truncateString(error.message, 100)}`;
+      return `- ${metadataPrefix}${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`;
     });
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     const errorInstances = errors.map((e) => e.error);
@@ -136,11 +153,20 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
 var ConcurrentCalls = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     this.#pendingCalls.push(...calls);
     return this;
   }
   resultifyAdd(...calls) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResults"
+      );
+    }
     const processedCalls = calls.map((call) => {
       return async () => {
         try {
@@ -221,11 +247,15 @@ var ConcurrentCalls = class {
   }
 };
 function concurrentCalls() {
-  return new ConcurrentCalls();
+  return new ConcurrentCalls(true);
 }
 var ConcurrentCallsWithMetadata = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     invariant(
       !this.#alreadyRun,
@@ -235,6 +265,11 @@ var ConcurrentCallsWithMetadata = class {
     return this;
   }
   resultifyAdd(...items) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResultsWithMetadata"
+      );
+    }
     const processedItems = items.map(({ fn, metadata }) => {
       const cb = () => (0, import_t_result.resultify)(async () => {
         const valueOrPromise = fn();
@@ -352,12 +387,20 @@ var ConcurrentCallsWithMetadata = class {
   }
 };
 function concurrentCallsWithMetadata() {
-  return new ConcurrentCallsWithMetadata();
+  return new ConcurrentCallsWithMetadata(true);
+}
+function concurrentResultCalls() {
+  return new ConcurrentCalls(false);
+}
+function concurrentResultsWithMetadata() {
+  return new ConcurrentCallsWithMetadata(false);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
-  concurrentCallsWithMetadata
+  concurrentCallsWithMetadata,
+  concurrentResultCalls,
+  concurrentResultsWithMetadata
 });

package/lib/concurrentCalls.d.cts

@@ -1,21 +1,21 @@
-import { Result } from 't-result';
+import { ResultValidErrors, Result } from 't-result';
 
 declare class ConcurrentCallsAggregateError extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     total: number;
     failed: number;
-    constructor(errors: Error[], total: number, failed: number);
+    constructor(errors: ResultValidErrors[], total: number, failed: number);
 }
 declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     errorsWithMetadata: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[];
     total: number;
     failed: number;
     constructor(errors: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[], total: number, failed: number);
 }
@@ -27,12 +27,12 @@ type SucceededCall<R, M> = {
     value: R;
     metadata: M;
 };
-type FailedCall<M, E extends Error = Error> = {
+type FailedCall<M, E extends ResultValidErrors = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = () => Promise<Result<R, E>>;
-type SettledResultWithMetadata<R, M, E extends Error = Error> = {
+type Action<R, E extends ResultValidErrors> = () => Promise<Result<R, E>>;
+type SettledResultWithMetadata<R, M, E extends ResultValidErrors = Error> = {
     ok: true;
     value: R;
     metadata: M;
@@ -42,8 +42,10 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     error: E;
     metadata: M;
 };
-declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
+declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: Action<R, E>[]): this;
     resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
@@ -59,11 +61,12 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
  * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
  *
  * @template R - The type of the result value.
- * @template E - The type of the error.
  */
 declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
-declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
+declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: {
         fn: Action<R, E>;
         metadata: M;
@@ -85,12 +88,25 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
  *
  * @template M - The type of the call metadata.
  * @template R - The type of the result value.
- * @template E - The type of the error from individual Result objects.
  */
 declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
+type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
+type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+ *
+ * @template R - The type of the result function that will be called.
+ */
+declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
+/**
+ * Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+ *
+ * @template ResultFn - The type of the result function that will be called.
+ */
+declare function concurrentResultsWithMetadata<M extends ValidMetadata, ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 
-export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata };
+export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata, concurrentResultCalls, concurrentResultsWithMetadata };