@daiso-tech/core 0.42.0 → 0.43.2

package/README.md

@@ -8,7 +8,16 @@
 
 `@daiso-tech/core` is a TypeScript-first backend library for building web apps and API servers. It includes an ecosystem of official packages designed to work seamlessly together.
 
-[Get started now](https://daiso-core.vercel.app/docs/Installation)
+**@daiso-tech/core** is a libary of backend server components designed for maximum flexibility. While each component is fully functional on its own, they are written to work seamlessly together to build robust server-side logic.
+
+Key Features:
+- **Framework Agnostic:** Built without a dependency injection (DI) container, the library integrates effortlessly into any framework / library. Whether you use Express.js, backend frameworks like AdonisJS or NestJS, or full-stack frameworks like Next.js, Nuxt, or TanStack Start, these components "just work."
+
+- **Runtime Portability:** By leveraging the Adapter Pattern, the library remains decoupled from specific runtimes. Easily implement custom adapters, such as Cloudflare Durable Objects or Amazon DynamoDB, for better serverless integration with cloudflare workers or aws lambda.
+
+- **Test Friendly:** Testing is simple because every component comes with an "in-memory" adapter. This means you can run your tests instantly without needing to connect to a real database or server.
+
+- **Developer Friendly:** Save time with high-quality documentation and a readable, well-documented codebase. Clear comments and a logical structure make it easy to understand and extend system functionality.
 
 - **Type safe:**
   We pay a closer look at type-safety, seamless intellisense, and support for auto imports when designing library APIs.
@@ -16,12 +25,10 @@
 - **ESM ready:**
   @daiso-tech/core leverages modern JavaScript primitives, including ES modules
 
-- **Easily testable:**
-  @daiso-tech/core includes built-in [vitest](https://vitest.dev/) helpers for custom adapters and in-memory adapters for all components, enabling testing without Docker.
-
 - **Supports standard schema:**
   Integrated seamlessly with [standard schema](https://standardschema.dev/) allowing you to use libraries like zod to ensure both compile time and runtimte typesafety.
 
+[Get started now](https://daiso-core.vercel.app/docs/Installation)
 
 ## A growing collection of officially maintained components
 
@@ -31,14 +38,17 @@
 - **EventBus:**
   Easily send events accross different applications or in-memory.
 
-- **Distributed lock:**
+- **Circuit-breaker:**
+  A circuit-breaker is a resilience primitive preventing cascading failures from external services by stopping calls to a failing service.
+
+- **Lock:**
   Synchronize the access to a shared resource to prevents several processes, or concurrent code, from executing a section of code at the same time.
 
-- **Distributed semaphore:**
+- **Semaphore:**
   A semaphore is a concurrency control primitive used to limit the number of processes or systems that can access a shared resource of code concurrently.
 
-- **Distributed shared lock:**
-  A shared lock (a.k.a reader writer lock) is a concurrency primitive offering better concurrency than a lock by coordinating a reader semaphore for concurrent access and an writer lock for mutual exclusion, strictly preventing conflicting simultaneous access and maintaining data consistency.
+- **Shared-lock:**
+  A shared-lock (a.k.a reader writer lock) is a concurrency primitive offering better concurrency than a lock by coordinating a reader semaphore for concurrent access and an writer lock for mutual exclusion, strictly preventing conflicting simultaneous access and maintaining data consistency.
 
 - **Serde:**
   Add custom serialization and deserialization logic that seamlessly integrates with all other components.

package/dist/backoff-policies/_module-exports.d.ts

@@ -1,5 +1,6 @@
+export * from "../backoff-policies/constant-backoff/_module.js";
+export * from "../backoff-policies/exponential-backoff/_module.js";
+export * from "../backoff-policies/linear-backoff/_module.js";
+export * from "../backoff-policies/polynomial-backoff/_module.js";
 export * from "../backoff-policies/_shared.js";
-export * from "../backoff-policies/constant-backoff-policy/_module.js";
-export * from "../backoff-policies/exponential-backoff-policy/_module.js";
-export * from "../backoff-policies/linear-backoff-policy/_module.js";
-export * from "../backoff-policies/polynomial-backoff-policy/_module.js";
+export * from "../backoff-policies/types.js";

package/dist/backoff-policies/_module-exports.js

@@ -1,6 +1,7 @@
+export * from "../backoff-policies/constant-backoff/_module.js";
+export * from "../backoff-policies/exponential-backoff/_module.js";
+export * from "../backoff-policies/linear-backoff/_module.js";
+export * from "../backoff-policies/polynomial-backoff/_module.js";
 export * from "../backoff-policies/_shared.js";
-export * from "../backoff-policies/constant-backoff-policy/_module.js";
-export * from "../backoff-policies/exponential-backoff-policy/_module.js";
-export * from "../backoff-policies/linear-backoff-policy/_module.js";
-export * from "../backoff-policies/polynomial-backoff-policy/_module.js";
+export * from "../backoff-policies/types.js";
 //# sourceMappingURL=_module-exports.js.map

package/dist/backoff-policies/_module-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../src/backoff-policies/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uDAAuD,CAAC;AACtE,cAAc,0DAA0D,CAAC;AACzE,cAAc,qDAAqD,CAAC;AACpE,cAAc,yDAAyD,CAAC"}
+{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../src/backoff-policies/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC;AAClE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,kDAAkD,CAAC;AACjE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC"}

package/dist/backoff-policies/_module.d.ts

@@ -0,0 +1,7 @@
+export * from "../backoff-policies/constant-backoff/_module.js";
+export * from "../backoff-policies/exponential-backoff/_module.js";
+export * from "../backoff-policies/linear-backoff/_module.js";
+export * from "../backoff-policies/polynomial-backoff/_module.js";
+export * from "../backoff-policies/_shared.js";
+export * from "../backoff-policies/backoffs-lua.js";
+export * from "../backoff-policies/types.js";

package/dist/backoff-policies/_module.js

@@ -0,0 +1,8 @@
+export * from "../backoff-policies/constant-backoff/_module.js";
+export * from "../backoff-policies/exponential-backoff/_module.js";
+export * from "../backoff-policies/linear-backoff/_module.js";
+export * from "../backoff-policies/polynomial-backoff/_module.js";
+export * from "../backoff-policies/_shared.js";
+export * from "../backoff-policies/backoffs-lua.js";
+export * from "../backoff-policies/types.js";
+//# sourceMappingURL=_module.js.map

package/dist/backoff-policies/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../src/backoff-policies/_module.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC;AAClE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,kDAAkD,CAAC;AACjE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,6BAA6B,CAAC"}

package/dist/backoff-policies/_shared.d.ts

@@ -1,8 +1,9 @@
 /**
  * @module BackoffPolicy
  */
-import type { ITimeSpan } from "../time-span/contracts/_module-exports.js";
-import type { Invokable } from "../utilities/_module-exports.js";
+import { type BackoffSettingsEnum, type SerializedBackoffSettingsEnum } from "../backoff-policies/types.js";
+import { type ITimeSpan } from "../time-span/contracts/_module.js";
+import { type Invokable } from "../utilities/_module.js";
 /**
  * @returns Amount milliseconds to wait
  *
@@ -20,4 +21,8 @@ export type DynamicBackoffPolicy<TSettings> = TSettings | Invokable<[error: unkn
 /**
  * @internal
  */
-export declare function withJitter(jitter: number, value: number, mathRandom: () => number): number;
+export declare function resolveBackoffSettingsEnum(settings: BackoffSettingsEnum): Required<BackoffSettingsEnum>;
+/**
+ * @internal
+ */
+export declare function serializeBackoffSettingsEnum(settings: BackoffSettingsEnum): Required<SerializedBackoffSettingsEnum>;

package/dist/backoff-policies/_shared.js

@@ -1,10 +1,65 @@
 /**
  * @module BackoffPolicy
  */
+import { resolveConstantBackoffSettings, serializeConstantBackoffSettings, } from "../backoff-policies/constant-backoff/_module.js";
+import { resolveExponentialBackoffSettings, serializeExponentialBackoffSettings, } from "../backoff-policies/exponential-backoff/_module.js";
+import { resolveLinearBackoffSettings, serializeLinearBackoffSettings, } from "../backoff-policies/linear-backoff/_module.js";
+import { resolvePolynomialBackoffSettings, serializePolynomialBackoffSettings, } from "../backoff-policies/polynomial-backoff/_module.js";
+import { BACKOFFS, } from "../backoff-policies/types.js";
+import {} from "../time-span/contracts/_module.js";
+import {} from "../utilities/_module.js";
 /**
  * @internal
  */
-export function withJitter(jitter, value, mathRandom) {
-    return (1 - jitter * mathRandom()) * value;
+export function resolveBackoffSettingsEnum(settings) {
+    if (settings.type === BACKOFFS.CONSTANT) {
+        return {
+            type: BACKOFFS.CONSTANT,
+            ...resolveConstantBackoffSettings(settings),
+        };
+    }
+    if (settings.type === BACKOFFS.EXPONENTIAL) {
+        return {
+            type: BACKOFFS.EXPONENTIAL,
+            ...resolveExponentialBackoffSettings(settings),
+        };
+    }
+    if (settings.type === BACKOFFS.LINEAR) {
+        return {
+            type: BACKOFFS.LINEAR,
+            ...resolveLinearBackoffSettings(settings),
+        };
+    }
+    return {
+        type: BACKOFFS.POLYNOMIAL,
+        ...resolvePolynomialBackoffSettings(settings),
+    };
+}
+/**
+ * @internal
+ */
+export function serializeBackoffSettingsEnum(settings) {
+    if (settings.type === BACKOFFS.CONSTANT) {
+        return {
+            type: BACKOFFS.CONSTANT,
+            ...serializeConstantBackoffSettings(settings),
+        };
+    }
+    if (settings.type === BACKOFFS.EXPONENTIAL) {
+        return {
+            type: BACKOFFS.EXPONENTIAL,
+            ...serializeExponentialBackoffSettings(settings),
+        };
+    }
+    if (settings.type === BACKOFFS.LINEAR) {
+        return {
+            type: BACKOFFS.LINEAR,
+            ...serializeLinearBackoffSettings(settings),
+        };
+    }
+    return {
+        type: BACKOFFS.POLYNOMIAL,
+        ...serializePolynomialBackoffSettings(settings),
+    };
 }
 //# sourceMappingURL=_shared.js.map

package/dist/backoff-policies/_shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"_shared.js","sourceRoot":"","sources":["../../src/backoff-policies/_shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AAuBH;;GAEG;AACH,MAAM,UAAU,UAAU,CACtB,MAAc,EACd,KAAa,EACb,UAAwB;IAExB,OAAO,CAAC,CAAC,GAAG,MAAM,GAAG,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC;AAC/C,CAAC"}
+{"version":3,"file":"_shared.js","sourceRoot":"","sources":["../../src/backoff-policies/_shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,8BAA8B,EAC9B,gCAAgC,GACnC,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACH,iCAAiC,EACjC,mCAAmC,GACtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EACH,4BAA4B,EAC5B,8BAA8B,GACjC,MAAM,8CAA8C,CAAC;AACtD,OAAO,EACH,gCAAgC,EAChC,kCAAkC,GACrC,MAAM,kDAAkD,CAAC;AAC1D,OAAO,EACH,QAAQ,GAGX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAkB,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAkB,MAAM,wBAAwB,CAAC;AAoBxD;;GAEG;AACH,MAAM,UAAU,0BAA0B,CACtC,QAA6B;IAE7B,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACtC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,QAAQ;YACvB,GAAG,8BAA8B,CAAC,QAAQ,CAAC;SAC9C,CAAC;IACN,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,WAAW,EAAE,CAAC;QACzC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,WAAW;YAC1B,GAAG,iCAAiC,CAAC,QAAQ,CAAC;SACjD,CAAC;IACN,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,MAAM;YACrB,GAAG,4BAA4B,CAAC,QAAQ,CAAC;SAC5C,CAAC;IACN,CAAC;IACD,OAAO;QACH,IAAI,EAAE,QAAQ,CAAC,UAAU;QACzB,GAAG,gCAAgC,CAAC,QAAQ,CAAC;KAChD,CAAC;AACN,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CACxC,QAA6B;IAE7B,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACtC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,QAAQ;YACvB,GAAG,gCAAgC,CAAC,QAAQ,CAAC;SAChD,CAAC;IACN,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,WAAW,EAAE,CAAC;QACzC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,WAAW;YAC1B,GAAG,mCAAmC,CAAC,QAAQ,CAAC;SACnD,CAAC;IACN,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpC,OAAO;YACH,IAAI,EAAE,QAAQ,CAAC,MAAM;YACrB,GAAG,8BAA8B,CAAC,QAAQ,CAAC;SAC9C,CAAC;IACN,CAAC;IACD,OAAO;QACH,IAAI,EAAE,QAAQ,CAAC,UAAU;QACzB,GAAG,kCAAkC,CAAC,QAAQ,CAAC;KAClD,CAAC;AACN,CAAC"}

package/dist/backoff-policies/backoffs-lua.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module CircuitBreaker
+ */
+/**
+ * @internal
+ */
+export declare const backoffsLua = "\n-- @param args WithJitterArgs\n-- @return number\nlocal function withJitter(args)\n    if args.jitter ~= nil and args.jitter ~= cjson.null then\n        return (1 - args.jitter * args.mathRandom) * args.value\n    end\n\n    return args.value\nend\n\n-- @param settings Required<SerializedConstantBackoffSettings>\n-- @return BackoffPolicy\nlocal function constantBackoff(settings)\n    -- @param _attempt number\n    -- @return number\n    return function(_attempt)\n        return withJitter({\n            jitter = settings.jitter,\n            value = settings.delay,\n            mathRandom = settings._mathRandom,\n        })\n    end\nend\n\n-- @param settings Required<SerializedExponentialBackoffSettings>\n-- @return BackoffPolicy\nlocal function exponentialBackoff(settings)\n    -- @param attempt number\n    -- @return number\n    return function(attempt)\n        local exponential = math.min(settings.maxDelay, settings.minDelay, math.pow(settings.multiplier, attempt))\n        return withJitter({\n            jitter = settings.jitter,\n            value = exponential,\n            mathRandom = settings._mathRandom,\n        })\n    end\nend\n\n-- @param settings Required<SerializedLinearBackoffSettings>\n-- @return BackoffPolicy\nlocal function linearBackoff(settings)\n    -- @param attempt number\n    -- @return number\n    return function(attempt)\n        local linear = math.min(settings.maxDelay, settings.minDelay * attempt)\n        return withJitter({\n            jitter = settings.jitter,\n            value = linear,\n            mathRandom = settings._mathRandom,\n        })\n    end\nend\n\n\n-- @param settings Required<SerializedPolynomialBackoffSettings>\n-- @return BackoffPolicy\nlocal function polynomialBackoff(settings)\n    -- @param attempt number\n    -- @return number\n    return function(attempt)\n        local polynomial = math.min(settings.maxDelay, settings.minDelay * math.pow(attempt, settings.degree))\n        return withJitter({\n            jitter = settings.jitter,\n            value = polynomial,\n            mathRandom = settings._mathRandom,\n        })\n    end\nend\n";

package/dist/backoff-policies/backoffs-lua.js

@@ -0,0 +1,78 @@
+/**
+ * @module CircuitBreaker
+ */
+/**
+ * @internal
+ */
+export const backoffsLua = `
+-- @param args WithJitterArgs
+-- @return number
+local function withJitter(args)
+    if args.jitter ~= nil and args.jitter ~= cjson.null then
+        return (1 - args.jitter * args.mathRandom) * args.value
+    end
+
+    return args.value
+end
+
+-- @param settings Required<SerializedConstantBackoffSettings>
+-- @return BackoffPolicy
+local function constantBackoff(settings)
+    -- @param _attempt number
+    -- @return number
+    return function(_attempt)
+        return withJitter({
+            jitter = settings.jitter,
+            value = settings.delay,
+            mathRandom = settings._mathRandom,
+        })
+    end
+end
+
+-- @param settings Required<SerializedExponentialBackoffSettings>
+-- @return BackoffPolicy
+local function exponentialBackoff(settings)
+    -- @param attempt number
+    -- @return number
+    return function(attempt)
+        local exponential = math.min(settings.maxDelay, settings.minDelay, math.pow(settings.multiplier, attempt))
+        return withJitter({
+            jitter = settings.jitter,
+            value = exponential,
+            mathRandom = settings._mathRandom,
+        })
+    end
+end
+
+-- @param settings Required<SerializedLinearBackoffSettings>
+-- @return BackoffPolicy
+local function linearBackoff(settings)
+    -- @param attempt number
+    -- @return number
+    return function(attempt)
+        local linear = math.min(settings.maxDelay, settings.minDelay * attempt)
+        return withJitter({
+            jitter = settings.jitter,
+            value = linear,
+            mathRandom = settings._mathRandom,
+        })
+    end
+end
+
+
+-- @param settings Required<SerializedPolynomialBackoffSettings>
+-- @return BackoffPolicy
+local function polynomialBackoff(settings)
+    -- @param attempt number
+    -- @return number
+    return function(attempt)
+        local polynomial = math.min(settings.maxDelay, settings.minDelay * math.pow(attempt, settings.degree))
+        return withJitter({
+            jitter = settings.jitter,
+            value = polynomial,
+            mathRandom = settings._mathRandom,
+        })
+    end
+end
+`;
+//# sourceMappingURL=backoffs-lua.js.map

package/dist/backoff-policies/backoffs-lua.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoffs-lua.js","sourceRoot":"","sources":["../../src/backoff-policies/backoffs-lua.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsE1B,CAAC"}

package/dist/backoff-policies/constant-backoff/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../backoff-policies/constant-backoff/constant-backoff.js";

package/dist/backoff-policies/constant-backoff/_module.js

@@ -0,0 +1,2 @@
+export * from "../../backoff-policies/constant-backoff/constant-backoff.js";
+//# sourceMappingURL=_module.js.map

package/dist/backoff-policies/constant-backoff/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/backoff-policies/constant-backoff/_module.ts"],"names":[],"mappings":"AAAA,cAAc,yDAAyD,CAAC"}

package/dist/backoff-policies/constant-backoff/constant-backoff.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module BackoffPolicy
+ */
+import { type BackoffPolicy, type DynamicBackoffPolicy } from "../../backoff-policies/_shared.js";
+import { type ITimeSpan } from "../../time-span/contracts/_module.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export type ConstantBackoffSettings = {
+    /**
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/time-span";
+     *
+     * TimeSpan.fromSeconds(1)
+     * ```
+     */
+    delay?: ITimeSpan;
+    /**
+     * You can pass jitter value to ensure the backoff will not execute at the same time.
+     * If you pas null you can disable the jitrter.
+     * @default 0.5
+     */
+    jitter?: number | null;
+    /**
+     * @internal
+     * Should only be used for testing
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * @internal
+ */
+export declare function resolveConstantBackoffSettings(settings: ConstantBackoffSettings): Required<ConstantBackoffSettings>;
+/**
+ * Constant backoff policy with jitter
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export declare function constantBackoff(settings?: DynamicBackoffPolicy<ConstantBackoffSettings>): BackoffPolicy;
+/**
+ * @internal
+ */
+export type SerializedConstantBackoffSettings = {
+    delay?: number;
+    jitter?: number | null;
+    _mathRandom?: number;
+};
+/**
+ * @internal
+ */
+export declare function serializeConstantBackoffSettings(settings: ConstantBackoffSettings): Required<SerializedConstantBackoffSettings>;

package/dist/backoff-policies/constant-backoff/constant-backoff.js

@@ -0,0 +1,54 @@
+/**
+ * @module BackoffPolicy
+ */
+import {} from "../../backoff-policies/_shared.js";
+import { TO_MILLISECONDS, } from "../../time-span/contracts/_module.js";
+import { TimeSpan } from "../../time-span/implementations/_module.js";
+import { callInvokable, isInvokable, withJitter } from "../../utilities/_module.js";
+/**
+ * @internal
+ */
+export function resolveConstantBackoffSettings(settings) {
+    const { delay = TimeSpan.fromMilliseconds(100), jitter = 0.5, _mathRandom = Math.random, } = settings;
+    return {
+        delay,
+        jitter,
+        _mathRandom,
+    };
+}
+/**
+ * Constant backoff policy with jitter
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export function constantBackoff(settings = {}) {
+    return (_attempt, error) => {
+        if (isInvokable(settings)) {
+            const dynamicSettings = callInvokable(settings, error);
+            if (dynamicSettings === undefined) {
+                settings = {};
+            }
+            else {
+                settings = dynamicSettings;
+            }
+        }
+        const { delay, jitter, _mathRandom } = resolveConstantBackoffSettings(settings);
+        return TimeSpan.fromMilliseconds(withJitter({
+            jitter,
+            value: delay[TO_MILLISECONDS](),
+            randomValue: _mathRandom(),
+        }));
+    };
+}
+/**
+ * @internal
+ */
+export function serializeConstantBackoffSettings(settings) {
+    const { delay, jitter, _mathRandom } = resolveConstantBackoffSettings(settings);
+    return {
+        delay: delay[TO_MILLISECONDS](),
+        jitter,
+        _mathRandom: _mathRandom(),
+    };
+}
+//# sourceMappingURL=constant-backoff.js.map

package/dist/backoff-policies/constant-backoff/constant-backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-backoff.js","sourceRoot":"","sources":["../../../src/backoff-policies/constant-backoff/constant-backoff.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAGN,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACH,eAAe,GAElB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA+BhF;;GAEG;AACH,MAAM,UAAU,8BAA8B,CAC1C,QAAiC;IAEjC,MAAM,EACF,KAAK,GAAG,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,EACtC,MAAM,GAAG,GAAG,EACZ,WAAW,GAAG,IAAI,CAAC,MAAM,GAC5B,GAAG,QAAQ,CAAC;IAEb,OAAO;QACH,KAAK;QACL,MAAM;QACN,WAAW;KACd,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC3B,WAA0D,EAAE;IAE5D,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE;QACvB,IAAI,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxB,MAAM,eAAe,GAAG,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACvD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;gBAChC,QAAQ,GAAG,EAAE,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACJ,QAAQ,GAAG,eAAe,CAAC;YAC/B,CAAC;QACL,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,GAChC,8BAA8B,CAAC,QAAQ,CAAC,CAAC;QAC7C,OAAO,QAAQ,CAAC,gBAAgB,CAC5B,UAAU,CAAC;YACP,MAAM;YACN,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE;YAC/B,WAAW,EAAE,WAAW,EAAE;SAC7B,CAAC,CACL,CAAC;IACN,CAAC,CAAC;AACN,CAAC;AAaD;;GAEG;AACH,MAAM,UAAU,gCAAgC,CAC5C,QAAiC;IAEjC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,GAChC,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IAC7C,OAAO;QACH,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE;QAC/B,MAAM;QACN,WAAW,EAAE,WAAW,EAAE;KAC7B,CAAC;AACN,CAAC"}

package/dist/backoff-policies/exponential-backoff/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../backoff-policies/exponential-backoff/exponential-backoff.js";

package/dist/backoff-policies/exponential-backoff/_module.js

@@ -0,0 +1,2 @@
+export * from "../../backoff-policies/exponential-backoff/exponential-backoff.js";
+//# sourceMappingURL=_module.js.map

package/dist/backoff-policies/exponential-backoff/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/backoff-policies/exponential-backoff/_module.ts"],"names":[],"mappings":"AAAA,cAAc,+DAA+D,CAAC"}

package/dist/backoff-policies/exponential-backoff/exponential-backoff.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @module BackoffPolicy
+ */
+import { type BackoffPolicy, type DynamicBackoffPolicy } from "../../backoff-policies/_shared.js";
+import { type ITimeSpan } from "../../time-span/contracts/_module.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export type ExponentialBackoffSettings = {
+    /**
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/time-span";
+     *
+     * TimeSpan.fromSeconds(60)
+     * ```
+     */
+    maxDelay?: ITimeSpan;
+    /**
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/time-span";
+     *
+     * TimeSpan.fromSeconds(1)
+     * ```
+     */
+    minDelay?: ITimeSpan;
+    /**
+     * @default 2
+     */
+    multiplier?: number;
+    /**
+     * You can pass jitter value to ensure the backoff will not execute at the same time.
+     * If you pas null you can disable the jitrter.
+     * @default 0.5
+     */
+    jitter?: number | null;
+    /**
+     * @internal
+     * Should only be used for testing
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * @internal
+ */
+export declare function resolveExponentialBackoffSettings(settings: ExponentialBackoffSettings): Required<ExponentialBackoffSettings>;
+/**
+ * Exponential backoff policy with jitter
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export declare function exponentialBackoff(settings?: DynamicBackoffPolicy<ExponentialBackoffSettings>): BackoffPolicy;
+/**
+ * @internal
+ */
+export type SerializedExponentialBackoffSettings = {
+    maxDelay?: number;
+    minDelay?: number;
+    multiplier?: number;
+    jitter?: number | null;
+    _mathRandom?: number;
+};
+/**
+ * @internal
+ */
+export declare function serializeExponentialBackoffSettings(settings: ExponentialBackoffSettings): Required<SerializedExponentialBackoffSettings>;

package/dist/backoff-policies/exponential-backoff/exponential-backoff.js

@@ -0,0 +1,59 @@
+/**
+ * @module BackoffPolicy
+ */
+import {} from "../../backoff-policies/_shared.js";
+import { TO_MILLISECONDS, } from "../../time-span/contracts/_module.js";
+import { TimeSpan } from "../../time-span/implementations/_module.js";
+import { callInvokable, isInvokable, withJitter } from "../../utilities/_module.js";
+/**
+ * @internal
+ */
+export function resolveExponentialBackoffSettings(settings) {
+    const { maxDelay = TimeSpan.fromMilliseconds(60_000), minDelay = TimeSpan.fromMilliseconds(1_000), multiplier = 2, jitter = 0.5, _mathRandom = Math.random, } = settings;
+    return {
+        maxDelay,
+        minDelay,
+        multiplier,
+        jitter,
+        _mathRandom,
+    };
+}
+/**
+ * Exponential backoff policy with jitter
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export function exponentialBackoff(settings = {}) {
+    return (attempt, error) => {
+        if (isInvokable(settings)) {
+            const dynamicSettings = callInvokable(settings, error);
+            if (dynamicSettings === undefined) {
+                settings = {};
+            }
+            else {
+                settings = dynamicSettings;
+            }
+        }
+        const { jitter, _mathRandom, multiplier, maxDelay, minDelay } = resolveExponentialBackoffSettings(settings);
+        const exponential = Math.min(maxDelay[TO_MILLISECONDS](), minDelay[TO_MILLISECONDS]() * Math.pow(multiplier, attempt));
+        return TimeSpan.fromMilliseconds(withJitter({
+            jitter,
+            value: exponential,
+            randomValue: _mathRandom(),
+        }));
+    };
+}
+/**
+ * @internal
+ */
+export function serializeExponentialBackoffSettings(settings) {
+    const { maxDelay, minDelay, multiplier, jitter, _mathRandom } = resolveExponentialBackoffSettings(settings);
+    return {
+        maxDelay: maxDelay[TO_MILLISECONDS](),
+        minDelay: minDelay[TO_MILLISECONDS](),
+        multiplier,
+        jitter,
+        _mathRandom: _mathRandom(),
+    };
+}
+//# sourceMappingURL=exponential-backoff.js.map

package/dist/backoff-policies/exponential-backoff/exponential-backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponential-backoff.js","sourceRoot":"","sources":["../../../src/backoff-policies/exponential-backoff/exponential-backoff.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAGN,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACH,eAAe,GAElB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA8ChF;;GAEG;AACH,MAAM,UAAU,iCAAiC,CAC7C,QAAoC;IAEpC,MAAM,EACF,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAC5C,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAC3C,UAAU,GAAG,CAAC,EACd,MAAM,GAAG,GAAG,EACZ,WAAW,GAAG,IAAI,CAAC,MAAM,GAC5B,GAAG,QAAQ,CAAC;IAEb,OAAO;QACH,QAAQ;QACR,QAAQ;QACR,UAAU;QACV,MAAM;QACN,WAAW;KACd,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAC9B,WAA6D,EAAE;IAE/D,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;QACtB,IAAI,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxB,MAAM,eAAe,GAAG,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACvD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;gBAChC,QAAQ,GAAG,EAAE,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACJ,QAAQ,GAAG,eAAe,CAAC;YAC/B,CAAC;QACL,CAAC;QACD,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,GACzD,iCAAiC,CAAC,QAAQ,CAAC,CAAC;QAEhD,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,QAAQ,CAAC,eAAe,CAAC,EAAE,EAC3B,QAAQ,CAAC,eAAe,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAC9D,CAAC;QACF,OAAO,QAAQ,CAAC,gBAAgB,CAC5B,UAAU,CAAC;YACP,MAAM;YACN,KAAK,EAAE,WAAW;YAClB,WAAW,EAAE,WAAW,EAAE;SAC7B,CAAC,CACL,CAAC;IACN,CAAC,CAAC;AACN,CAAC;AAiBD;;GAEG;AACH,MAAM,UAAU,mCAAmC,CAC/C,QAAoC;IAEpC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,GACzD,iCAAiC,CAAC,QAAQ,CAAC,CAAC;IAChD,OAAO;QACH,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE;QACrC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE;QACrC,UAAU;QACV,MAAM;QACN,WAAW,EAAE,WAAW,EAAE;KAC7B,CAAC;AACN,CAAC"}

package/dist/backoff-policies/linear-backoff/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../backoff-policies/linear-backoff/linear-backoff.js";

package/dist/backoff-policies/linear-backoff/_module.js

@@ -0,0 +1,2 @@
+export * from "../../backoff-policies/linear-backoff/linear-backoff.js";
+//# sourceMappingURL=_module.js.map

package/dist/backoff-policies/linear-backoff/_module.js.map

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

package/dist/backoff-policies/linear-backoff/linear-backoff.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @module BackoffPolicy
+ */
+import { type BackoffPolicy, type DynamicBackoffPolicy } from "../../backoff-policies/_shared.js";
+import { type ITimeSpan } from "../../time-span/contracts/_module.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export type LinearBackoffSettings = {
+    /**
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/time-span";
+     *
+     * TimeSpan.fromSeconds(6)
+     * ```
+     */
+    maxDelay?: ITimeSpan;
+    /**
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/time-span";
+     *
+     * TimeSpan.fromSeconds(1)
+     * ```
+     */
+    minDelay?: ITimeSpan;
+    /**
+     * You can pass jitter value to ensure the backoff will not execute at the same time.
+     * If you pas null you can disable the jitrter.
+     * @default 0.5
+     */
+    jitter?: number | null;
+    /**
+     * @internal
+     * Should only be used for testing
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * @internal
+ */
+export declare function resolveLinearBackoffSettings(settings: LinearBackoffSettings): Required<LinearBackoffSettings>;
+/**
+ * Linear backoff policy with jitter
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
+ */
+export declare function linearBackoff(settings?: DynamicBackoffPolicy<LinearBackoffSettings>): BackoffPolicy;
+/**
+ * @internal
+ */
+export type SerializedLinearBackoffSettings = {
+    maxDelay?: number;
+    minDelay?: number;
+    jitter?: number | null;
+    _mathRandom?: number;
+};
+/**
+ * @internal
+ */
+export declare function serializeLinearBackoffSettings(settings: LinearBackoffSettings): Required<SerializedLinearBackoffSettings>;