@ls-stack/utils 3.31.0 → 3.32.0

package/docs/concurrentCalls/-internal-.md

@@ -10,7 +10,7 @@
 
 ### ConcurrentCalls\<R, E\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:124](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L124)
+Defined in: [packages/utils/src/concurrentCalls.ts:141](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L141)
 
 #### Type Parameters
 
@@ -20,20 +20,38 @@ Defined in: [packages/utils/src/concurrentCalls.ts:124](https://github.com/lucas
 
 ##### E
 
-`E` *extends* `Error` = `Error`
+`E` *extends* `ResultValidErrors` = `Error`
 
 #### Constructors
 
 ##### Constructor
 
 ```ts
-new ConcurrentCalls<R, E>(): ConcurrentCalls<R, E>;
+new ConcurrentCalls<R, E>(allowResultify): ConcurrentCalls<R, E>;
 ```
 
+Defined in: [packages/utils/src/concurrentCalls.ts:146](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L146)
+
+###### Parameters
+
+###### allowResultify
+
+`boolean`
+
 ###### Returns
 
 [`ConcurrentCalls`](#concurrentcalls)\<`R`, `E`\>
 
+#### Properties
+
+##### allowResultify
+
+```ts
+allowResultify: boolean = true;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:144](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L144)
+
 #### Methods
 
 ##### add()
@@ -42,7 +60,7 @@ new ConcurrentCalls<R, E>(): ConcurrentCalls<R, E>;
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:128](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L128)
+Defined in: [packages/utils/src/concurrentCalls.ts:150](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L150)
 
 ###### Parameters
 
@@ -60,7 +78,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:128](https://github.com/lucas
 resultifyAdd(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:134](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L134)
+Defined in: [packages/utils/src/concurrentCalls.ts:156](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L156)
 
 ###### Parameters
 
@@ -78,7 +96,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:134](https://github.com/lucas
 runAll(__namedParameters): Promise<Result<R[], E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:151](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L151)
+Defined in: [packages/utils/src/concurrentCalls.ts:179](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L179)
 
 ###### Parameters
 
@@ -103,7 +121,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:183](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L183)
+Defined in: [packages/utils/src/concurrentCalls.ts:211](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L211)
 
 ###### Parameters
 
@@ -126,7 +144,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:183](https://github.com/lucas
 
 ### ConcurrentCallsWithMetadata\<M, R, E\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:250](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L250)
+Defined in: [packages/utils/src/concurrentCalls.ts:277](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L277)
 
 #### Type Parameters
 
@@ -140,20 +158,38 @@ Defined in: [packages/utils/src/concurrentCalls.ts:250](https://github.com/lucas
 
 ##### E
 
-`E` *extends* `Error` = `Error`
+`E` *extends* `ResultValidErrors` = `Error`
 
 #### Constructors
 
 ##### Constructor
 
 ```ts
-new ConcurrentCallsWithMetadata<M, R, E>(): ConcurrentCallsWithMetadata<M, R, E>;
+new ConcurrentCallsWithMetadata<M, R, E>(allowResultify): ConcurrentCallsWithMetadata<M, R, E>;
 ```
 
+Defined in: [packages/utils/src/concurrentCalls.ts:286](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L286)
+
+###### Parameters
+
+###### allowResultify
+
+`boolean`
+
 ###### Returns
 
 [`ConcurrentCallsWithMetadata`](#concurrentcallswithmetadata)\<`M`, `R`, `E`\>
 
+#### Properties
+
+##### allowResultify
+
+```ts
+allowResultify: boolean = true;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:284](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L284)
+
 #### Methods
 
 ##### add()
@@ -162,7 +198,7 @@ new ConcurrentCallsWithMetadata<M, R, E>(): ConcurrentCallsWithMetadata<M, R, E>
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:258](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L258)
+Defined in: [packages/utils/src/concurrentCalls.ts:290](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L290)
 
 ###### Parameters
 
@@ -180,7 +216,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:258](https://github.com/lucas
 resultifyAdd(...items): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:272](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L272)
+Defined in: [packages/utils/src/concurrentCalls.ts:304](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L304)
 
 ###### Parameters
 
@@ -198,7 +234,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:272](https://github.com/lucas
 runAll(__namedParameters): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:292](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L292)
+Defined in: [packages/utils/src/concurrentCalls.ts:330](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L330)
 
 ###### Parameters
 
@@ -225,7 +261,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:339](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L339)
+Defined in: [packages/utils/src/concurrentCalls.ts:377](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L377)
 
 ###### Parameters
 
@@ -254,7 +290,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:339](https://github.com/lucas
 type Action<R, E> = () => Promise<Result<R, E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:117](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L117)
+Defined in: [packages/utils/src/concurrentCalls.ts:134](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L134)
 
 #### Type Parameters
 
@@ -264,7 +300,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:117](https://github.com/lucas
 
 ##### E
 
-`E` *extends* `Error`
+`E` *extends* `ResultValidErrors`
 
 #### Returns
 
@@ -272,13 +308,29 @@ Defined in: [packages/utils/src/concurrentCalls.ts:117](https://github.com/lucas
 
 ***
 
+### ErrorFromResult\<R\>
+
+```ts
+type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:480](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L480)
+
+#### Type Parameters
+
+##### R
+
+`R`
+
+***
+
 ### FailedCall\<M, E\>
 
 ```ts
 type FailedCall<M, E> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:112](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L112)
+Defined in: [packages/utils/src/concurrentCalls.ts:129](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L129)
 
 #### Type Parameters
 
@@ -288,7 +340,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:112](https://github.com/lucas
 
 ##### E
 
-`E` *extends* `Error` = `Error`
+`E` *extends* `ResultValidErrors` = `Error`
 
 #### Properties
 
@@ -298,7 +350,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:112](https://github.com/lucas
 error: E;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:114](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L114)
+Defined in: [packages/utils/src/concurrentCalls.ts:131](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L131)
 
 ##### metadata
 
@@ -306,7 +358,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:114](https://github.com/lucas
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:113](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L113)
+Defined in: [packages/utils/src/concurrentCalls.ts:130](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L130)
 
 ***
 
@@ -316,7 +368,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:113](https://github.com/lucas
 type RunProps = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:103](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L103)
+Defined in: [packages/utils/src/concurrentCalls.ts:120](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L120)
 
 #### Properties
 
@@ -326,7 +378,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:103](https://github.com/lucas
 optional delayStart: (index) => number;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:104](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L104)
+Defined in: [packages/utils/src/concurrentCalls.ts:121](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L121)
 
 ###### Parameters
 
@@ -357,7 +409,7 @@ type SettledResultWithMetadata<R, M, E> =
 };
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:120](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L120)
+Defined in: [packages/utils/src/concurrentCalls.ts:137](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L137)
 
 #### Type Parameters
 
@@ -371,7 +423,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:120](https://github.com/lucas
 
 ##### E
 
-`E` *extends* `Error` = `Error`
+`E` *extends* `ResultValidErrors` = `Error`
 
 ***
 
@@ -381,7 +433,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:120](https://github.com/lucas
 type SucceededCall<R, M> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:108](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L108)
+Defined in: [packages/utils/src/concurrentCalls.ts:125](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L125)
 
 #### Type Parameters
 
@@ -401,7 +453,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:108](https://github.com/lucas
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:110](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L110)
+Defined in: [packages/utils/src/concurrentCalls.ts:127](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L127)
 
 ##### value
 
@@ -409,7 +461,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:110](https://github.com/lucas
 value: R;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:109](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L109)
+Defined in: [packages/utils/src/concurrentCalls.ts:126](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L126)
 
 ***
 
@@ -419,4 +471,20 @@ Defined in: [packages/utils/src/concurrentCalls.ts:109](https://github.com/lucas
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:101](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L101)
+Defined in: [packages/utils/src/concurrentCalls.ts:118](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L118)
+
+***
+
+### ValueFromResult\<R\>
+
+```ts
+type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:479](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L479)
+
+#### Type Parameters
+
+##### R
+
+`R`

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/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 };

package/lib/concurrentCalls.d.ts

@@ -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 };

package/lib/concurrentCalls.js

@@ -4,6 +4,9 @@ import {
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   truncateArray
 } from "./chunk-SRVMMYSW.js";
@@ -16,7 +19,11 @@ import {
 } from "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
-import { Result, resultify, unknownToError } from "t-result";
+import {
+  Result,
+  resultify,
+  unknownToError
+} from "t-result";
 function formatErrorMessagesWithCounts(messages, failed, total) {
   const errorMessageCounts = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -38,7 +45,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);
@@ -67,7 +77,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);
@@ -81,11 +94,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 {
@@ -166,11 +188,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,
@@ -180,6 +206,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 = () => resultify(async () => {
         const valueOrPromise = fn();
@@ -297,11 +328,19 @@ var ConcurrentCallsWithMetadata = class {
   }
 };
 function concurrentCallsWithMetadata() {
-  return new ConcurrentCallsWithMetadata();
+  return new ConcurrentCallsWithMetadata(true);
+}
+function concurrentResultCalls() {
+  return new ConcurrentCalls(false);
+}
+function concurrentResultsWithMetadata() {
+  return new ConcurrentCallsWithMetadata(false);
 }
 export {
   ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
-  concurrentCallsWithMetadata
+  concurrentCallsWithMetadata,
+  concurrentResultCalls,
+  concurrentResultsWithMetadata
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.31.0",
+  "version": "3.32.0",
   "license": "MIT",
   "files": [
     "lib",