@daiso-tech/core/dist/backoff-policies/implementations/polynomial-backoff/polynomial-backoff.js

The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.

/**
 * @module BackoffPolicy
 */
import {} from "../../../backoff-policies/contracts/_module.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 resolvePolynomialBackoffSettings(settings) {
    const { maxDelay = TimeSpan.fromSeconds(60), minDelay = TimeSpan.fromMilliseconds(500), degree = 2, jitter = 0.5, _mathRandom = Math.random, } = settings;
    if (!(minDelay[TO_MILLISECONDS]() > 0)) {
        throw new TypeError("'minDelay' must be positive");
    }
    if (!(maxDelay[TO_MILLISECONDS]() >= minDelay[TO_MILLISECONDS]())) {
        throw new TypeError("'maxDelay' must be greater than or equal to 'minDelay'");
    }
    if (!(degree > 0)) {
        throw new TypeError("'degree' must be positive");
    }
    if (jitter !== null && !(jitter >= 0 && jitter <= 1)) {
        throw new TypeError("'jitter' must be between 0 and 1 or null");
    }
    return {
        maxDelay,
        minDelay,
        degree,
        jitter,
        _mathRandom,
    };
}
/**
 * Polynomial backoff policy with jitter
 *
 * IMPORT_PATH: `"@daiso-tech/core/backoff-policies"`
 * @group Implementations
 */
export function polynomialBackoff(settings = {}) {
    return (attempt, error) => {
        if (isInvokable(settings)) {
            const dynamicSettings = callInvokable(settings, error);
            if (dynamicSettings === undefined) {
                settings = {};
            }
            else {
                settings = dynamicSettings;
            }
        }
        const { maxDelay, minDelay, degree, jitter, _mathRandom } = resolvePolynomialBackoffSettings(settings);
        const polynomial = Math.min(maxDelay[TO_MILLISECONDS](), minDelay[TO_MILLISECONDS]() * Math.pow(attempt, degree));
        return TimeSpan.fromMilliseconds(withJitter({
            jitter,
            value: polynomial,
            randomValue: _mathRandom(),
        }));
    };
}
/**
 * @internal
 */
export function serializePolynomialBackoffSettings(settings) {
    const { maxDelay, minDelay, degree, jitter, _mathRandom } = resolvePolynomialBackoffSettings(settings);
    return {
        maxDelay: maxDelay[TO_MILLISECONDS](),
        minDelay: minDelay[TO_MILLISECONDS](),
        degree,
        jitter,
        _mathRandom: _mathRandom(),
    };
}
//# sourceMappingURL=polynomial-backoff.js.map