@ls-stack/utils 3.21.0 → 3.23.0

package/docs/concurrentCalls/-internal-.md

@@ -10,7 +10,7 @@
 
 ### ConcurrentCalls\<R, E\>
 
-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:31](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L31)
 
 #### Type Parameters
 
@@ -42,7 +42,7 @@ new ConcurrentCalls<R, E>(): ConcurrentCalls<R, E>;
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:36](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L36)
+Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L35)
 
 ###### Parameters
 
@@ -60,13 +60,13 @@ Defined in: [packages/utils/src/concurrentCalls.ts:36](https://github.com/lucaso
 resultifyAdd(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:42](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L42)
+Defined in: [packages/utils/src/concurrentCalls.ts:41](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L41)
 
 ###### Parameters
 
 ###### calls
 
-...(`Promise`\<`R`\> \| () => `R` \| () => `Promise`\<`R`\>)[]
+...(() => `R` \| () => `Promise`\<`R`\>)[]
 
 ###### Returns
 
@@ -78,7 +78,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:42](https://github.com/lucaso
 runAll(__namedParameters): Promise<Result<R[], E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:74](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L74)
+Defined in: [packages/utils/src/concurrentCalls.ts:58](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L58)
 
 ###### Parameters
 
@@ -102,7 +102,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-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:90](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L90)
 
 ###### Parameters
 
@@ -124,7 +124,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:112](https://github.com/lucas
 
 ### ConcurrentCallsWithMetadata\<M, R, E\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:184](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L184)
+Defined in: [packages/utils/src/concurrentCalls.ts:157](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L157)
 
 #### Type Parameters
 
@@ -160,7 +160,7 @@ new ConcurrentCallsWithMetadata<M, R, E>(): ConcurrentCallsWithMetadata<M, R, E>
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:192](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L192)
+Defined in: [packages/utils/src/concurrentCalls.ts:165](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L165)
 
 ###### Parameters
 
@@ -178,7 +178,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:192](https://github.com/lucas
 resultifyAdd(...items): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:206](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L206)
+Defined in: [packages/utils/src/concurrentCalls.ts:179](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L179)
 
 ###### Parameters
 
@@ -196,7 +196,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:206](https://github.com/lucas
 runAll(__namedParameters): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:227](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L227)
+Defined in: [packages/utils/src/concurrentCalls.ts:199](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L199)
 
 ###### Parameters
 
@@ -222,7 +222,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:274](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L274)
+Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L246)
 
 ###### Parameters
 
@@ -244,15 +244,13 @@ Defined in: [packages/utils/src/concurrentCalls.ts:274](https://github.com/lucas
 
 ## Type Aliases
 
-### Action\<R, E\>
+### Action()\<R, E\>
 
 ```ts
-type Action<R, E> = 
-  | () => Promise<Result<R, E>>
-| Promise<Result<R, E>>;
+type Action<R, E> = () => Promise<Result<R, E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:23](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L23)
+Defined in: [packages/utils/src/concurrentCalls.ts:24](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L24)
 
 #### Type Parameters
 
@@ -264,6 +262,10 @@ Defined in: [packages/utils/src/concurrentCalls.ts:23](https://github.com/lucaso
 
 `E` *extends* `Error`
 
+#### Returns
+
+`Promise`\<`Result`\<`R`, `E`\>\>
+
 ***
 
 ### FailedCall\<M, E\>
@@ -272,7 +274,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:23](https://github.com/lucaso
 type FailedCall<M, E> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:18](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L18)
+Defined in: [packages/utils/src/concurrentCalls.ts:19](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L19)
 
 #### Type Parameters
 
@@ -292,7 +294,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:18](https://github.com/lucaso
 error: E;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:20](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L20)
+Defined in: [packages/utils/src/concurrentCalls.ts:21](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L21)
 
 ##### metadata
 
@@ -300,7 +302,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:20](https://github.com/lucaso
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:19](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L19)
+Defined in: [packages/utils/src/concurrentCalls.ts:20](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L20)
 
 ***
 
@@ -310,7 +312,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:19](https://github.com/lucaso
 type RunProps = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:9](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L9)
+Defined in: [packages/utils/src/concurrentCalls.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L10)
 
 #### Properties
 
@@ -320,7 +322,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:9](https://github.com/lucasol
 optional delayStart: (index) => number;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L10)
+Defined in: [packages/utils/src/concurrentCalls.ts:11](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L11)
 
 ###### Parameters
 
@@ -351,7 +353,7 @@ type SettledResultWithMetadata<R, M, E> =
 };
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:28](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L28)
+Defined in: [packages/utils/src/concurrentCalls.ts:27](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L27)
 
 #### Type Parameters
 
@@ -375,7 +377,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:28](https://github.com/lucaso
 type SucceededCall<R, M> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:14](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L14)
+Defined in: [packages/utils/src/concurrentCalls.ts:15](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L15)
 
 #### Type Parameters
 
@@ -395,7 +397,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:14](https://github.com/lucaso
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:16](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L16)
+Defined in: [packages/utils/src/concurrentCalls.ts:17](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L17)
 
 ##### value
 
@@ -403,7 +405,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:16](https://github.com/lucaso
 value: R;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:15](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L15)
+Defined in: [packages/utils/src/concurrentCalls.ts:16](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L16)
 
 ***
 
@@ -413,4 +415,4 @@ Defined in: [packages/utils/src/concurrentCalls.ts:15](https://github.com/lucaso
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L7)
+Defined in: [packages/utils/src/concurrentCalls.ts:8](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L8)

package/docs/concurrentCalls/README.md

@@ -15,10 +15,10 @@
 ### concurrentCalls()
 
 ```ts
-function concurrentCalls<R, E>(): ConcurrentCalls<R, E>;
+function concurrentCalls<R>(): ConcurrentCalls<R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:180](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L180)
+Defined in: [packages/utils/src/concurrentCalls.ts:153](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L153)
 
 Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
 
@@ -30,25 +30,19 @@ Executes multiple asynchronous calls concurrently and collects the results in a
 
 The type of the result value.
 
-##### E
-
-`E` *extends* `Error` = `Error`
-
-The type of the error.
-
 #### Returns
 
-[`ConcurrentCalls`](-internal-.md#concurrentcalls)\<`R`, `E`\>
+[`ConcurrentCalls`](-internal-.md#concurrentcalls)\<`R`, `Error`\>
 
 ***
 
 ### concurrentCallsWithMetadata()
 
 ```ts
-function concurrentCallsWithMetadata<M, R, E>(): ConcurrentCallsWithMetadata<M, R, E>;
+function concurrentCallsWithMetadata<M, R>(): ConcurrentCallsWithMetadata<M, R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:373](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L373)
+Defined in: [packages/utils/src/concurrentCalls.ts:345](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L345)
 
 Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
 
@@ -66,12 +60,6 @@ The type of the call metadata.
 
 The type of the result value.
 
-##### E
-
-`E` *extends* `Error` = `Error`
-
-The type of the error from individual Result objects.
-
 #### Returns
 
-[`ConcurrentCallsWithMetadata`](-internal-.md#concurrentcallswithmetadata)\<`M`, `R`, `E`\>
+[`ConcurrentCallsWithMetadata`](-internal-.md#concurrentcallswithmetadata)\<`M`, `R`, `Error`\>

package/docs/retryOnError/README.md

@@ -23,7 +23,7 @@ function retryOnError<T>(
 originalMaxRetries): Promise<T>;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:38](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L38)
+Defined in: [packages/utils/src/retryOnError.ts:36](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L36)
 
 Retries a function on error with configurable retry logic.
 
@@ -57,14 +57,10 @@ Configuration options
 
 `number` = `0`
 
-Internal parameter tracking current retry count
-
 ##### originalMaxRetries
 
 `number` = `maxRetries`
 
-Internal parameter tracking original max retries for logging
-
 #### Returns
 
 `Promise`\<`T`\>

package/lib/concurrentCalls.cjs

@@ -44,7 +44,6 @@ function invariant(condition, error = "Invariant violation") {
   }
 }
 var isFunction2 = isFunction;
-var isPromise2 = isPromise;
 
 // src/arrayUtils.ts
 function truncateArray(array, maxLength, appendIfTruncated) {
@@ -80,23 +79,17 @@ var ConcurrentCalls = class {
   }
   resultifyAdd(...calls) {
     const processedCalls = calls.map((call) => {
-      if (isPromise2(call)) {
-        return call.then((value) => import_t_result.Result.ok(value)).catch((err) => import_t_result.Result.err((0, import_t_result.unknownToError)(err)));
-      } else {
-        const originalFn = call;
-        return async () => {
-          try {
-            const valueOrPromise = originalFn();
-            const value = isPromise2(valueOrPromise) ? await valueOrPromise : valueOrPromise;
-            return import_t_result.Result.ok(value);
-          } catch (err) {
-            return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
-          }
-        };
-      }
+      return async () => {
+        try {
+          const valueOrPromise = call();
+          const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+          return import_t_result.Result.ok(value);
+        } catch (err) {
+          return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
+        }
+      };
     });
-    const correctlyTypedProcessedCalls = processedCalls;
-    return this.add(...correctlyTypedProcessedCalls);
+    return this.add(...processedCalls);
   }
   async runAll({ delayStart } = {}) {
     invariant(!this.#alreadyRun, "Already run");
@@ -105,15 +98,10 @@ var ConcurrentCalls = class {
       const asyncResults = await Promise.all(
         this.#pendingCalls.map(async (fn, i) => {
           try {
-            const isP = isPromise2(fn);
             if (delayStart) {
-              invariant(
-                !isP,
-                "Delay start is not supported direct promise calls"
-              );
               await sleep(delayStart(i));
             }
-            const result = await (isP ? fn : fn());
+            const result = await fn();
             if (!result.ok) throw result.error;
             return result.value;
           } catch (exception) {
@@ -135,15 +123,10 @@ var ConcurrentCalls = class {
     const settledResults = await Promise.allSettled(
       this.#pendingCalls.map(async (callOrPromise, i) => {
         try {
-          const isP = isPromise2(callOrPromise);
           if (delayStart) {
-            invariant(
-              !isP,
-              "Delay start is not supported for direct promise calls"
-            );
             await sleep(delayStart(i));
           }
-          const result = await (isP ? callOrPromise : callOrPromise());
+          const result = await callOrPromise();
           if (!result.ok) {
             throw result.error;
           }
@@ -190,9 +173,10 @@ var ConcurrentCallsWithMetadata = class {
   }
   resultifyAdd(...items) {
     const processedItems = items.map(({ fn, metadata }) => {
-      const cb = isPromise2(fn) ? (0, import_t_result.resultify)(fn) : () => (0, import_t_result.resultify)(async () => {
-        const result = await fn();
-        return result;
+      const cb = () => (0, import_t_result.resultify)(async () => {
+        const valueOrPromise = fn();
+        const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+        return value;
       });
       return {
         fn: cb,
@@ -214,7 +198,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw { metadata: call.metadata, error: result.error };
           }
@@ -261,7 +245,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw result.error;
           }

package/lib/concurrentCalls.d.cts

@@ -12,7 +12,7 @@ type FailedCall<M, E extends Error = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type Action<R, E extends Error> = () => Promise<Result<R, E>>;
 type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     ok: true;
     value: R;
@@ -26,7 +26,7 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
 declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
     #private;
     add(...calls: Action<R, E>[]): this;
-    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
@@ -42,7 +42,7 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
  * @template R - The type of the result value.
  * @template E - The type of the error.
  */
-declare function concurrentCalls<R = unknown, E extends Error = Error>(): ConcurrentCalls<R, E>;
+declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
 declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
     #private;
     add(...calls: {
@@ -50,7 +50,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         metadata: M;
     }[]): this;
     resultifyAdd(...items: {
-        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        fn: (() => R) | (() => Promise<R>);
         metadata: M;
     }[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
@@ -72,6 +72,6 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
  * @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, E extends Error = Error>(): ConcurrentCallsWithMetadata<M, R, E>;
+declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
 
 export { concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.d.ts

@@ -12,7 +12,7 @@ type FailedCall<M, E extends Error = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type Action<R, E extends Error> = () => Promise<Result<R, E>>;
 type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     ok: true;
     value: R;
@@ -26,7 +26,7 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
 declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
     #private;
     add(...calls: Action<R, E>[]): this;
-    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
@@ -42,7 +42,7 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
  * @template R - The type of the result value.
  * @template E - The type of the error.
  */
-declare function concurrentCalls<R = unknown, E extends Error = Error>(): ConcurrentCalls<R, E>;
+declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
 declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
     #private;
     add(...calls: {
@@ -50,7 +50,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         metadata: M;
     }[]): this;
     resultifyAdd(...items: {
-        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        fn: (() => R) | (() => Promise<R>);
         metadata: M;
     }[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
@@ -72,6 +72,6 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
  * @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, E extends Error = Error>(): ConcurrentCallsWithMetadata<M, R, E>;
+declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
 
 export { concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.js

@@ -8,10 +8,11 @@ import {
   truncateArray
 } from "./chunk-SRVMMYSW.js";
 import {
-  invariant,
-  isPromise
+  invariant
 } from "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
+import {
+  isPromise
+} from "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
 import { Result, resultify, unknownToError } from "t-result";
@@ -24,23 +25,17 @@ var ConcurrentCalls = class {
   }
   resultifyAdd(...calls) {
     const processedCalls = calls.map((call) => {
-      if (isPromise(call)) {
-        return call.then((value) => Result.ok(value)).catch((err) => Result.err(unknownToError(err)));
-      } else {
-        const originalFn = call;
-        return async () => {
-          try {
-            const valueOrPromise = originalFn();
-            const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
-            return Result.ok(value);
-          } catch (err) {
-            return Result.err(unknownToError(err));
-          }
-        };
-      }
+      return async () => {
+        try {
+          const valueOrPromise = call();
+          const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+          return Result.ok(value);
+        } catch (err) {
+          return Result.err(unknownToError(err));
+        }
+      };
     });
-    const correctlyTypedProcessedCalls = processedCalls;
-    return this.add(...correctlyTypedProcessedCalls);
+    return this.add(...processedCalls);
   }
   async runAll({ delayStart } = {}) {
     invariant(!this.#alreadyRun, "Already run");
@@ -49,15 +44,10 @@ var ConcurrentCalls = class {
       const asyncResults = await Promise.all(
         this.#pendingCalls.map(async (fn, i) => {
           try {
-            const isP = isPromise(fn);
             if (delayStart) {
-              invariant(
-                !isP,
-                "Delay start is not supported direct promise calls"
-              );
               await sleep(delayStart(i));
             }
-            const result = await (isP ? fn : fn());
+            const result = await fn();
             if (!result.ok) throw result.error;
             return result.value;
           } catch (exception) {
@@ -79,15 +69,10 @@ var ConcurrentCalls = class {
     const settledResults = await Promise.allSettled(
       this.#pendingCalls.map(async (callOrPromise, i) => {
         try {
-          const isP = isPromise(callOrPromise);
           if (delayStart) {
-            invariant(
-              !isP,
-              "Delay start is not supported for direct promise calls"
-            );
             await sleep(delayStart(i));
           }
-          const result = await (isP ? callOrPromise : callOrPromise());
+          const result = await callOrPromise();
           if (!result.ok) {
             throw result.error;
           }
@@ -134,9 +119,10 @@ var ConcurrentCallsWithMetadata = class {
   }
   resultifyAdd(...items) {
     const processedItems = items.map(({ fn, metadata }) => {
-      const cb = isPromise(fn) ? resultify(fn) : () => resultify(async () => {
-        const result = await fn();
-        return result;
+      const cb = () => resultify(async () => {
+        const valueOrPromise = fn();
+        const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+        return value;
       });
       return {
         fn: cb,
@@ -158,7 +144,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw { metadata: call.metadata, error: result.error };
           }
@@ -205,7 +191,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw result.error;
           }

package/lib/retryOnError.cjs

@@ -54,7 +54,13 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
           typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(retry) : delayBetweenRetriesMs
         );
       }
-      return retryOnError(fn, maxRetries - 1, options, retry + 1, originalMaxRetries);
+      return retryOnError(
+        fn,
+        maxRetries - 1,
+        options,
+        retry + 1,
+        originalMaxRetries
+      );
     } else {
       throw error;
     }

package/lib/retryOnError.d.cts

@@ -18,8 +18,6 @@ type RetryOptions = {
  * @param fn - Function to retry that receives context with retry count
  * @param maxRetries - Maximum number of retries
  * @param options - Configuration options
- * @param retry - Internal parameter tracking current retry count
- * @param originalMaxRetries - Internal parameter tracking original max retries for logging
  * @returns Promise resolving to the function result or rejecting with the final error
  *
  * @example
@@ -33,6 +31,7 @@ type RetryOptions = {
  * );
  */
 declare function retryOnError<T>(fn: (ctx: {
+    /** Current retry count, (0 for first attempt) */
     retry: number;
 }) => Promise<T>, maxRetries: number, options?: RetryOptions, retry?: number, originalMaxRetries?: number): Promise<T>;
 

package/lib/retryOnError.d.ts

@@ -18,8 +18,6 @@ type RetryOptions = {
  * @param fn - Function to retry that receives context with retry count
  * @param maxRetries - Maximum number of retries
  * @param options - Configuration options
- * @param retry - Internal parameter tracking current retry count
- * @param originalMaxRetries - Internal parameter tracking original max retries for logging
  * @returns Promise resolving to the function result or rejecting with the final error
  *
  * @example
@@ -33,6 +31,7 @@ type RetryOptions = {
  * );
  */
 declare function retryOnError<T>(fn: (ctx: {
+    /** Current retry count, (0 for first attempt) */
     retry: number;
 }) => Promise<T>, maxRetries: number, options?: RetryOptions, retry?: number, originalMaxRetries?: number): Promise<T>;
 

package/lib/retryOnError.js

@@ -27,7 +27,13 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
           typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(retry) : delayBetweenRetriesMs
         );
       }
-      return retryOnError(fn, maxRetries - 1, options, retry + 1, originalMaxRetries);
+      return retryOnError(
+        fn,
+        maxRetries - 1,
+        options,
+        retry + 1,
+        originalMaxRetries
+      );
     } else {
       throw error;
     }

package/package.json

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