@mtkruto/browser 0.128.0 → 0.130.0

package/script/deps/jsr.io/@std/async/1.2.0/retry.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetryError = void 0;
-exports.retry = retry;
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-const delay_js_1 = require("./delay.js");
-const _util_js_1 = require("./_util.js");
-/**
- * Error thrown in {@linkcode retry} once the maximum number of failed attempts
- * has been reached.
- *
- * @example Usage
- * ```ts no-assert ignore
- * import { RetryError } from "@std/async/retry";
- *
- * throw new RetryError({ foo: "bar" }, 3);
- * ```
- */
-class RetryError extends Error {
-    /**
-     * Constructs a new {@linkcode RetryError} instance.
-     *
-     * @param cause the cause for this error.
-     * @param attempts the number of retry attempts made.
-     */
-    constructor(cause, attempts) {
-        super(`Retrying exceeded the maxAttempts (${attempts}).`);
-        this.name = "RetryError";
-        this.cause = cause;
-    }
-}
-exports.RetryError = RetryError;
-/**
- * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
- * Retries as long as the given function throws. If the attempts are exhausted,
- * throws a {@linkcode RetryError} with `cause` set to the inner exception.
- *
- * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
- * How long the actual delay is, depends on `jitter`.
- *
- * When `jitter` is the default value of `1`, waits between two attempts for a
- * randomized amount between 0 and the backoff time. With the default options
- * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
- * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
- *
- * When `jitter` is `0`, waits the full backoff time.
- *
- * @example Example configuration 1
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- * const req = async () => {
- *  // some function that throws sometimes
- * };
- *
- * // Below resolves to the first non-error result of `req`
- * const retryPromise = await retry(req, {
- *  multiplier: 2,
- *  maxTimeout: 60000,
- *  maxAttempts: 5,
- *  minTimeout: 100,
- *  jitter: 1,
- * });
- * ```
- *
- * @example Example configuration 2
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- * const req = async () => {
- *  // some function that throws sometimes
- * };
- *
- * // Make sure we wait at least 1 minute, but at most 2 minutes
- * const retryPromise = await retry(req, {
- *  multiplier: 2.34,
- *  maxTimeout: 80000,
- *  maxAttempts: 7,
- *  minTimeout: 1000,
- *  jitter: 0.5,
- * });
- * ```
- *
- * @example Only retry on specific error types
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- *
- * class HttpError extends Error {
- *   status: number;
- *   constructor(status: number) {
- *     super(`HTTP ${status}`);
- *     this.status = status;
- *   }
- * }
- *
- * const req = async () => {
- *   // some function that throws HttpError
- * };
- *
- * // Only retry on 429 (rate limit) or 5xx (server) errors
- * const retryPromise = await retry(req, {
- *   isRetriable: (err) =>
- *     err instanceof HttpError && (err.status === 429 || err.status >= 500),
- * });
- * ```
- *
- * @typeParam T The return type of the function to retry and returned promise.
- * @param fn The function to retry.
- * @param options Additional options.
- * @returns The promise that resolves with the value returned by the function to retry.
- * @throws {RetryError} If the function fails after `maxAttempts` attempts.
- * @throws If the `signal` is aborted, throws the signal's reason.
- * @throws If `isRetriable` returns `false` for an error, throws that error immediately.
- */
-async function retry(fn, options) {
-    const { multiplier = 2, maxTimeout = 60000, maxAttempts = 5, minTimeout = 1000, jitter = 1, isRetriable = () => true, signal, } = options ?? {};
-    if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-        throw new RangeError(`Cannot retry as 'maxAttempts' must be a positive integer: current value is ${maxAttempts}`);
-    }
-    if (!Number.isFinite(multiplier) || multiplier < 1) {
-        throw new RangeError(`Cannot retry as 'multiplier' must be a finite number >= 1: current value is ${multiplier}`);
-    }
-    if (Number.isNaN(maxTimeout) || maxTimeout <= 0) {
-        throw new RangeError(`Cannot retry as 'maxTimeout' must be a positive number: current value is ${maxTimeout}`);
-    }
-    if (Number.isNaN(minTimeout) || minTimeout < 0) {
-        throw new RangeError(`Cannot retry as 'minTimeout' must be >= 0: current value is ${minTimeout}`);
-    }
-    if (minTimeout > maxTimeout) {
-        throw new RangeError(`Cannot retry as 'minTimeout' must be <= 'maxTimeout': current values 'minTimeout=${minTimeout}', 'maxTimeout=${maxTimeout}'`);
-    }
-    if (Number.isNaN(jitter) || jitter < 0 || jitter > 1) {
-        throw new RangeError(`Cannot retry as 'jitter' must be between 0 and 1: current value is ${jitter}`);
-    }
-    let attempt = 0;
-    while (true) {
-        signal?.throwIfAborted();
-        try {
-            return await fn();
-        }
-        catch (error) {
-            if (!isRetriable(error)) {
-                throw error;
-            }
-            if (attempt + 1 >= maxAttempts) {
-                throw new RetryError(error, maxAttempts);
-            }
-            const timeout = (0, _util_js_1.exponentialBackoffWithJitter)(maxTimeout, minTimeout, attempt, multiplier, jitter);
-            await (0, delay_js_1.delay)(timeout, signal ? { signal } : undefined);
-        }
-        attempt++;
-    }
-}

package/script/deps/jsr.io/@std/async/1.2.0/tee.d.ts

@@ -1,43 +0,0 @@
-/**
- * Utility for representing n-tuple. Used in {@linkcode tee}.
- *
- * @internal
- */
-export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;
-/**
- * Utility for representing n-tuple of. Used in {@linkcode Tuple}.
- *
- * @internal
- */
-export type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
-/**
- * Branches the given async iterable into the `n` branches.
- *
- * @example Usage
- * ```ts
- * import { tee } from "@std/async/tee";
- * import { assertEquals } from "@std/assert";
- *
- * const gen = async function* gen() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * };
- *
- * const [branch1, branch2] = tee(gen());
- *
- * const result1 = await Array.fromAsync(branch1);
- * assertEquals(result1, [1, 2, 3]);
- *
- * const result2 = await Array.fromAsync(branch2);
- * assertEquals(result2, [1, 2, 3]);
- * ```
- *
- * @typeParam T The type of the provided async iterable and the returned async iterables.
- * @typeParam N The amount of branches to tee into.
- * @param iterable The iterable to tee.
- * @param n The amount of branches to tee into.
- * @returns The tuple where each element is an async iterable.
- */
-export declare function tee<T, N extends number = 2>(iterable: AsyncIterable<T>, n?: N): Tuple<AsyncIterable<T>, N>;
-//# sourceMappingURL=tee.d.ts.map

package/script/deps/jsr.io/@std/async/1.2.0/tee.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/tee.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAChD,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAC1C,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAC1D,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAuC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,GAAE,CAAU,GACZ,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAuB5B"}

package/script/deps/jsr.io/@std/async/1.2.0/tee.js

@@ -1,82 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tee = tee;
-class Queue {
-    #source;
-    #queue;
-    head;
-    done;
-    constructor(iterable) {
-        this.#source = iterable[Symbol.asyncIterator]();
-        this.#queue = {
-            value: undefined,
-            next: undefined,
-        };
-        this.head = this.#queue;
-        this.done = false;
-    }
-    async next() {
-        const result = await this.#source.next();
-        if (!result.done) {
-            const nextNode = {
-                value: result.value,
-                next: undefined,
-            };
-            this.#queue.next = nextNode;
-            this.#queue = nextNode;
-        }
-        else {
-            this.done = true;
-        }
-    }
-}
-/**
- * Branches the given async iterable into the `n` branches.
- *
- * @example Usage
- * ```ts
- * import { tee } from "@std/async/tee";
- * import { assertEquals } from "@std/assert";
- *
- * const gen = async function* gen() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * };
- *
- * const [branch1, branch2] = tee(gen());
- *
- * const result1 = await Array.fromAsync(branch1);
- * assertEquals(result1, [1, 2, 3]);
- *
- * const result2 = await Array.fromAsync(branch2);
- * assertEquals(result2, [1, 2, 3]);
- * ```
- *
- * @typeParam T The type of the provided async iterable and the returned async iterables.
- * @typeParam N The amount of branches to tee into.
- * @param iterable The iterable to tee.
- * @param n The amount of branches to tee into.
- * @returns The tuple where each element is an async iterable.
- */
-function tee(iterable, n = 2) {
-    const queue = new Queue(iterable);
-    async function* generator() {
-        let buffer = queue.head;
-        while (true) {
-            if (buffer.next) {
-                buffer = buffer.next;
-                yield buffer.value;
-            }
-            else if (queue.done) {
-                return;
-            }
-            else {
-                await queue.next();
-            }
-        }
-    }
-    return Array.from({ length: n }).map(() => generator());
-}