@daiso-tech/core 0.33.0 → 0.35.0

package/dist/async/middlewares/bulkhead/bulkhead.middleware.js

@@ -0,0 +1,46 @@
+/**
+ * @module Async
+ */
+import { callInvokable, TimeSpan, } from "../../../utilities/_module-exports.js";
+import { PromiseQueue } from "../../../async/utilities/_module.js";
+/**
+ * The `bulkhead` middlewares ensures that a given amount of {@link Promiselike | `PromiseLike`} objects run at the same time concurrently and the rest will be queued up.
+ * You can provide {@link BulkheadSettings | `settings.maxCapacity`}
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {CapacityFullAsyncError} {@link CapacityFullAsyncError}
+ * ```ts
+ * import { bulkhead } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * const fetchData = new AsyncHooks(async (url: string): Promise<unknown> => {
+ *   const response = await fetch(url);
+ *   const json = await response.json();
+ *   return json;
+ * }, [
+ *   bulkhead()
+ * ]);
+ *
+ * // Will run only 25 promises concurrently by default.
+ * await Promise.all(Array(50).fill("").map(() => fetchData.invoke("URL")));
+ * ```
+ */
+export function bulkhead(settings = {}) {
+    const { maxConcurrency = 25, maxCapacity = null, interval = TimeSpan.fromMilliseconds(0), onProcessing = () => { }, } = settings;
+    const promiseQueue = new PromiseQueue({
+        maxCapacity,
+        maxConcurrency,
+        interval,
+    });
+    return async (args, next, { context, signal }) => {
+        return await promiseQueue.add(() => {
+            callInvokable(onProcessing, {
+                args,
+                context,
+            });
+            return next(...args);
+        }, signal);
+    };
+}
+//# sourceMappingURL=bulkhead.middleware.js.map

package/dist/async/middlewares/bulkhead/bulkhead.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/bulkhead/bulkhead.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,aAAa,EACb,QAAQ,GAIX,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAwE5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,QAAQ,CAKpB,WAAoD,EAAE;IAEtD,MAAM,EACF,cAAc,GAAG,EAAE,EACnB,WAAW,GAAG,IAAI,EAClB,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,EACvC,YAAY,GAAG,GAAG,EAAE,GAAE,CAAC,GAC1B,GAAG,QAAQ,CAAC;IACb,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC;QAClC,WAAW;QACX,cAAc;QACd,QAAQ;KACX,CAAC,CAAC;IACH,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;QAC7C,OAAO,MAAM,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE;YAC/B,aAAa,CAAC,YAAY,EAAE;gBACxB,IAAI;gBACJ,OAAO;aACV,CAAC,CAAC;YACH,OAAO,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACzB,CAAC,EAAE,MAAM,CAAC,CAAC;IACf,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/dynamic/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/middlewares/dynamic/dynamic.middleware.js";

package/dist/async/middlewares/dynamic/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/dynamic/dynamic.middleware.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/dynamic/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/dynamic/_module.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}

package/dist/async/middlewares/dynamic/dynamic.middleware.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module Async
+ */
+import type { HookContext, AsyncMiddleware } from "../../../utilities/_module-exports.js";
+import { type AsyncMiddlewareFn, type Invokable } from "../../../utilities/_module-exports.js";
+/**
+ * The `dynamic` is wrapper middleware that allows configuration of other middlewares dynamically based on the function arguments and context.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { dynamic, fallback  } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * await new AsyncHooks(
+ *   (a: number, b: number) => a / b,
+ *   [
+ *     // You pass callback function where you get access to the function arguments and context.
+ *     // The callback function must return a middleware.
+ *     dynamic((_args, _context) =>
+ *       fallback({
+ *         fallbackValue: 1,
+ *       }),
+ *     ),
+ *   ],
+ * ).invoke(1, 0);
+ * ```
+ */
+export declare function dynamic<TParameters extends unknown[], TReturn, TContext extends HookContext>(dynamic: NoInfer<Invokable<[
+    arguments_: TParameters,
+    context: TContext
+], AsyncMiddleware<TParameters, TReturn, TContext>>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/dynamic/dynamic.middleware.js

@@ -0,0 +1,36 @@
+/**
+ * @module Async
+ */
+import { callInvokable, } from "../../../utilities/_module-exports.js";
+/**
+ * The `dynamic` is wrapper middleware that allows configuration of other middlewares dynamically based on the function arguments and context.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { dynamic, fallback  } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * await new AsyncHooks(
+ *   (a: number, b: number) => a / b,
+ *   [
+ *     // You pass callback function where you get access to the function arguments and context.
+ *     // The callback function must return a middleware.
+ *     dynamic((_args, _context) =>
+ *       fallback({
+ *         fallbackValue: 1,
+ *       }),
+ *     ),
+ *   ],
+ * ).invoke(1, 0);
+ * ```
+ */
+export function dynamic(dynamic) {
+    return (args, next, settings) => {
+        const middleware = callInvokable(dynamic, args, settings.context);
+        return callInvokable(middleware, args, next, settings);
+    };
+}
+//# sourceMappingURL=dynamic.middleware.js.map

package/dist/async/middlewares/dynamic/dynamic.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/dynamic/dynamic.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EACH,aAAa,GAGhB,MAAM,gCAAgC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,OAAO,CAKnB,OAKC;IAED,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QAC5B,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClE,OAAO,aAAa,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/fallback/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/middlewares/fallback/fallback.middleware.js";

package/dist/async/middlewares/fallback/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/fallback/fallback.middleware.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/fallback/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/fallback/_module.ts"],"names":[],"mappings":"AAAA,cAAc,qDAAqD,CAAC"}

package/dist/async/middlewares/fallback/fallback.middleware.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @module Async
+ */
+import type { HookContext, AsyncLazyable } from "../../../utilities/_module-exports.js";
+import { type AsyncMiddlewareFn, type Invokable } from "../../../utilities/_module-exports.js";
+import type { ErrorPolicy } from "../../../async/middlewares/_shared.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnFallbackData<TParameters extends unknown[] = unknown[], TFallbackValue = unknown, TContext extends HookContext = HookContext> = {
+    error: unknown;
+    fallbackValue: TFallbackValue;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnFallback<TParameters extends unknown[] = unknown[], TFallbackValue = unknown, TContext extends HookContext = HookContext> = Invokable<[data: OnFallbackData<TParameters, TFallbackValue, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type FallbackCallbacks<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
+    /**
+     * Callback function that will be called before fallback values is returned.
+     */
+    onFallback?: OnFallback<TParameters, TReturn, TContext>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type FallbackSettings<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = FallbackCallbacks<TParameters, TReturn, TContext> & {
+    fallbackValue: AsyncLazyable<TReturn>;
+    /**
+     * You can choose what errors you want to add fallback value. By default fallback value will be added to all errors.
+     *
+     * @default
+     * ```ts
+     * (_error: unknown) => true
+     * ```
+     */
+    fallbackPolicy?: ErrorPolicy;
+};
+/**
+ * The `fallback` middleware adds fallback value when an error occurs.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { fallback } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * const fetchData = new AsyncHooks(async (url: string): Promise<unknown> => {
+ *   const response = await fetch(url);
+ *   const json = await response.json();
+ *   if (!response.ok) {
+ *     throw json
+ *   }
+ *   return json;
+ * }, [
+ *   fallback({ fallbackValue: null })
+ * ]);
+ *
+ * // Will return null when the fetch method throws an error.
+ * console.log(await fetchData.invoke("URL_ENDPOINT"));
+ * ```
+ */
+export declare function fallback<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<FallbackSettings<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/fallback/fallback.middleware.js

@@ -0,0 +1,52 @@
+/**
+ * @module Async
+ */
+import { callInvokable, resolveAsyncLazyable, } from "../../../utilities/_module-exports.js";
+/**
+ * The `fallback` middleware adds fallback value when an error occurs.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { fallback } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * const fetchData = new AsyncHooks(async (url: string): Promise<unknown> => {
+ *   const response = await fetch(url);
+ *   const json = await response.json();
+ *   if (!response.ok) {
+ *     throw json
+ *   }
+ *   return json;
+ * }, [
+ *   fallback({ fallbackValue: null })
+ * ]);
+ *
+ * // Will return null when the fetch method throws an error.
+ * console.log(await fetchData.invoke("URL_ENDPOINT"));
+ * ```
+ */
+export function fallback(settings) {
+    const { fallbackValue, fallbackPolicy = () => true, onFallback = () => { }, } = settings;
+    return async (args, next, { context }) => {
+        try {
+            return await next(...args);
+        }
+        catch (error) {
+            if (callInvokable(fallbackPolicy, error)) {
+                const resolvedFallbackValue = await resolveAsyncLazyable(fallbackValue);
+                callInvokable(onFallback, {
+                    error,
+                    fallbackValue: resolvedFallbackValue,
+                    args,
+                    context,
+                });
+                return resolvedFallbackValue;
+            }
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=fallback.middleware.js.map

package/dist/async/middlewares/fallback/fallback.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/fallback/fallback.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EACH,aAAa,EACb,oBAAoB,GAGvB,MAAM,gCAAgC,CAAC;AAqExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,QAAQ,CAKpB,QAAmE;IAEnE,MAAM,EACF,aAAa,EACb,cAAc,GAAG,GAAG,EAAE,CAAC,IAAI,EAC3B,UAAU,GAAG,GAAG,EAAE,GAAE,CAAC,GACxB,GAAG,QAAQ,CAAC;IACb,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,EAAoB,EAAE;QACvD,IAAI,CAAC;YACD,OAAO,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACtB,IAAI,aAAa,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;gBACvC,MAAM,qBAAqB,GACvB,MAAM,oBAAoB,CAAC,aAAa,CAAC,CAAC;gBAC9C,aAAa,CAAC,UAAU,EAAE;oBACtB,KAAK;oBACL,aAAa,EAAE,qBAAqB;oBACpC,IAAI;oBACJ,OAAO;iBACV,CAAC,CAAC;gBACH,OAAO,qBAAqB,CAAC;YACjC,CAAC;YACD,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/hedging/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/hedging/concurrent-hedging/_module.js";
+export * from "../../../async/middlewares/hedging/sequential-hedging/_module.js";

package/dist/async/middlewares/hedging/_module.js

@@ -0,0 +1,3 @@
+export * from "../../../async/middlewares/hedging/concurrent-hedging/_module.js";
+export * from "../../../async/middlewares/hedging/sequential-hedging/_module.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/hedging/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/hedging/_module.ts"],"names":[],"mappings":"AAAA,cAAc,2DAA2D,CAAC;AAC1E,cAAc,2DAA2D,CAAC"}

package/dist/async/middlewares/hedging/_shared.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../../utilities/_module-exports.js";
+import { type HookContext, type Invokable, type OneOrMore, type Promisable } from "../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnHedgeAttemptData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    name: string;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnHedgeAttempt<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnHedgeAttemptData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnHedgeErrorData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    name: string;
+    error: unknown;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnHedgeError<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnHedgeErrorData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type HedgingCallbacks<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    /**
+     * Callback function that will be called before execution attempt.
+     */
+    onHedgeAttempt?: OnHedgeAttempt<TParameters, TContext>;
+    /**
+     * Callback function that will be called when the error occurs.
+     */
+    onHedgeError?: OnHedgeError<TParameters, TContext>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type Fallback<TParameters extends unknown[] = unknown[], TReturn = unknown> = Invokable<TParameters, Promisable<TReturn>>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type NamedFallback<TParameters extends unknown[] = unknown[], TReturn = unknown> = {
+    /**
+     * You can assign a custom name to the fallback function for easier identification in logs.
+     */
+    name: string;
+    func: Fallback<TParameters, TReturn>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type HedgingSettings<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = HedgingCallbacks<TParameters, TContext> & {
+    /**
+     * The maximum time to wait before automatically aborting the executing primary function or fallback functions.
+     *
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/utilities";
+     *
+     * TimeSpan.fromSeconds(2)
+     * ```
+     */
+    waitTime?: TimeSpan;
+    /**
+     * The fallback functions that run in case the primary function fails.
+     */
+    fallbacks: OneOrMore<Fallback<TParameters, TReturn> | NamedFallback<TParameters, TReturn>>;
+};

package/dist/async/middlewares/hedging/_shared.js

@@ -0,0 +1,5 @@
+/**
+ * @module Async
+ */
+import {} from "../../../utilities/_module-exports.js";
+//# sourceMappingURL=_shared.js.map

package/dist/async/middlewares/hedging/_shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shared.js","sourceRoot":"","sources":["../../../../src/async/middlewares/hedging/_shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAKN,MAAM,gCAAgC,CAAC"}

package/dist/async/middlewares/hedging/concurrent-hedging/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../async/middlewares/hedging/concurrent-hedging/_module.js";

package/dist/async/middlewares/hedging/concurrent-hedging/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../../async/middlewares/hedging/concurrent-hedging/_module.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/hedging/concurrent-hedging/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/async/middlewares/hedging/concurrent-hedging/_module.ts"],"names":[],"mappings":"AAAA,cAAc,2DAA2D,CAAC"}

package/dist/async/middlewares/hedging/concurrent-hedging/concurrent-hedging.middleware.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module Async
+ */
+import { type AsyncMiddlewareFn, type HookContext } from "../../../../utilities/_module-exports.js";
+import type { HedgingSettings } from "../../../../async/middlewares/hedging/_shared.js";
+/**
+ * The `concurrentHedging` middleware executes the primary function and all fallback functions concurrently.
+ * It returns the result of the first successful function and automatically aborts all remaining functions.
+ * If all function fail than error is thrown.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {HedgingAsyncError} {@link HedgingAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { concurrentHedging } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * async function fn1(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-1", { signal });
+ *   return await response.json();
+ * }
+ * async function fn2(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-2", { signal });
+ *   return await response.json();
+ * }
+ * async function fn3(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-3", { signal });
+ *   return await response.json();
+ * }
+ * const fetchData = new AsyncHooks(fn1, [
+ *   concurrentHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export declare function concurrentHedging<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<HedgingSettings<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/hedging/concurrent-hedging/concurrent-hedging.middleware.js

@@ -0,0 +1,138 @@
+/**
+ * @module Async
+ */
+import { callInvokable, isInvokable, resolveOneOrMore, TimeSpan, } from "../../../../utilities/_module-exports.js";
+import { HedgingAsyncError } from "../../../../async/async.errors.js";
+import { timeoutAndFail } from "../../../../async/utilities/_module.js";
+/**
+ * @internal
+ */
+class ResolvedError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = ResolvedError.name;
+    }
+}
+/**
+ * The `concurrentHedging` middleware executes the primary function and all fallback functions concurrently.
+ * It returns the result of the first successful function and automatically aborts all remaining functions.
+ * If all function fail than error is thrown.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {HedgingAsyncError} {@link HedgingAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { concurrentHedging } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * async function fn1(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-1", { signal });
+ *   return await response.json();
+ * }
+ * async function fn2(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-2", { signal });
+ *   return await response.json();
+ * }
+ * async function fn3(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-3", { signal });
+ *   return await response.json();
+ * }
+ * const fetchData = new AsyncHooks(fn1, [
+ *   concurrentHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export function concurrentHedging(settings) {
+    const { waitTime = TimeSpan.fromSeconds(2), fallbacks, onHedgeAttempt = () => { }, onHedgeError = () => { }, } = settings;
+    const resolvedFallbacks = resolveOneOrMore(fallbacks).map((fallback, index) => {
+        if (isInvokable(fallback)) {
+            return {
+                name: `fallback-${String(index + 1)}`,
+                func: fallback,
+            };
+        }
+        return fallback;
+    });
+    return async (args, next, { context, abort, signal }) => {
+        function step1({ name, func }) {
+            return {
+                name,
+                promise: timeoutAndFail((async () => callInvokable(func, ...args))(), waitTime, (error) => {
+                    abort(error);
+                }, signal),
+            };
+        }
+        async function step2({ name, promise }) {
+            try {
+                const value = await promise;
+                // We abort all other promises when on promise succeds.
+                abort(new ResolvedError("Already resolved"));
+                return {
+                    type: "success",
+                    value,
+                    name,
+                };
+            }
+            catch (error) {
+                return {
+                    type: "failure",
+                    error,
+                    name,
+                };
+            }
+        }
+        const funcs = [
+            {
+                name: "__initial",
+                func: next,
+            },
+            ...resolvedFallbacks,
+        ];
+        const promises = funcs.map(step1).map(step2);
+        const errors = [];
+        const promiseResults = await Promise.all(promises);
+        for (const promiseResult of promiseResults) {
+            callInvokable(onHedgeAttempt, {
+                args,
+                context,
+                name: promiseResult.name,
+            });
+            // We return the first fulfilled value
+            if (promiseResult.type === "success") {
+                return promiseResult.value;
+            }
+            else if (!(promiseResult.error instanceof ResolvedError)) {
+                callInvokable(onHedgeError, {
+                    args,
+                    context,
+                    error: promiseResult.error,
+                    name: promiseResult.name,
+                });
+                errors.push(promiseResult.error);
+            }
+        }
+        // If all promiseResults are rejected we will throw an error
+        const funcNames = funcs
+            .slice(1)
+            .map(({ name }) => `"${name}"`)
+            .join(", ");
+        throw new HedgingAsyncError(`The original function and fallback functions failed: ${funcNames}`, errors);
+    };
+}
+//# sourceMappingURL=concurrent-hedging.middleware.js.map

package/dist/async/middlewares/hedging/concurrent-hedging/concurrent-hedging.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrent-hedging.middleware.js","sourceRoot":"","sources":["../../../../../src/async/middlewares/hedging/concurrent-hedging/concurrent-hedging.middleware.ts"],"names":[],"mappings":"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"}

package/dist/async/middlewares/hedging/sequential-hedging/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../async/middlewares/hedging/sequential-hedging/_module.js";

package/dist/async/middlewares/hedging/sequential-hedging/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../../async/middlewares/hedging/sequential-hedging/_module.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/hedging/sequential-hedging/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/async/middlewares/hedging/sequential-hedging/_module.ts"],"names":[],"mappings":"AAAA,cAAc,2DAA2D,CAAC"}