@torthu/jacketui-bring 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# JacketUI Bring
+
+Bring is a fetch wrapper that provides a simple API for making HTTP requests. It supports retrying, timeouts and callbacks. And will return a Result ({ok: true, value} | {ok: false, error}) instead of throwing errors.
+
+## Philosophy
+
+We want flexibility in our components and escape hatches in order to solve edge cases and make components truly expandable and reusable.
+
+In order to achieve this we need to create flexible components, meaning expandable and full of escape hatches in order to cater for edge cases.
+
+## In practice

package/dist/bring.d.ts

@@ -0,0 +1,38 @@
+import { Result, AbortablePromise } from "@torthu/jacketui-core";
+import { BringInit } from "./types/BringInit";
+import { BringError } from "./errors";
+/** bring({url: string | URL})
+ *
+ * A wrapper around the fetch API that adds support for timeouts, retries, and aborts.
+ * It also adds support for custom error handling and success handling.
+ * It returns a promise that resolves to a Result object.
+ * The returned promise is extended with an abort method that can be used to abort the fetch request.
+ *
+ * The Result object contains either a Response object or a BringError.
+ *
+ * @param init {BringInit | BringError} RequestInit + retries, timeout, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError
+ * @param init.url The URL to fetch.
+ * @param init.abortController (optional) An AbortController object to abort the fetch request. (default: new AbortController())
+ * @param init.timeout (optional) The timeout in milliseconds. (default: 0)
+ * @param init.retry (optional) The number of times to retry the fetch request. (default: 0)
+ * @param init.onSuccess (optional) A callback function that is called when the fetch request is successful.
+ * @param init.onError (optional) A callback function that is called when the fetch request fails.
+ * @param init.onAbort (optional) A callback function that is called when the fetch request is aborted.
+ * @param init.onRetry (optional) A callback function that is called when the fetch request is retried.
+ * @param init.onTimeout (optional) A callback function that is called when the fetch request times out.
+ * @param init.onClientError (optional) A callback function that is called when the fetch request fails with a client error.
+ * @param init.onServerError (optional) A callback function that is called when the fetch request fails with a server error.
+ * @param init.body (optional) The body of the fetch request.
+ * @param init.headers (optional) The headers of the fetch request.
+ * @param init.method (optional) The method of the fetch request.
+ * @param init.mode (optional) The mode of the fetch request.
+ * @param init.credentials (optional) The credentials of the fetch request.
+ * @param init.cache (optional) The cache of the fetch request.
+ * @param init.redirect (optional) The redirect of the fetch request.
+ * @param init.referrer (optional) The referrer of the fetch request.
+ * @param init.referrerPolicy (optional) The referrerPolicy of the fetch request.
+ * @param init.integrity (optional) The integrity of the fetch request.
+ * @param init.keepalive (optional) The keepalive of the fetch request.
+ * @returns AbortablePromise<Result<Response, BringError>>
+ */
+export declare const bring: (init: BringInit | BringError) => AbortablePromise<Result<Response, BringError>>;

package/dist/bring.js

@@ -0,0 +1,142 @@
+import { success, failure, withResolvers, } from "@torthu/jacketui-core";
+import { isClientErrorResponse } from "./types/ClientErrorResponse";
+import { isServerErrorResponse } from "./types/ServerErrorResponse";
+import { AbortError, ClientError, BringError, ServerError, TimeoutError, } from "./errors";
+import { tryFetch } from "./tryFetch";
+/** bring({url: string | URL})
+ *
+ * A wrapper around the fetch API that adds support for timeouts, retries, and aborts.
+ * It also adds support for custom error handling and success handling.
+ * It returns a promise that resolves to a Result object.
+ * The returned promise is extended with an abort method that can be used to abort the fetch request.
+ *
+ * The Result object contains either a Response object or a BringError.
+ *
+ * @param init {BringInit | BringError} RequestInit + retries, timeout, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError
+ * @param init.url The URL to fetch.
+ * @param init.abortController (optional) An AbortController object to abort the fetch request. (default: new AbortController())
+ * @param init.timeout (optional) The timeout in milliseconds. (default: 0)
+ * @param init.retry (optional) The number of times to retry the fetch request. (default: 0)
+ * @param init.onSuccess (optional) A callback function that is called when the fetch request is successful.
+ * @param init.onError (optional) A callback function that is called when the fetch request fails.
+ * @param init.onAbort (optional) A callback function that is called when the fetch request is aborted.
+ * @param init.onRetry (optional) A callback function that is called when the fetch request is retried.
+ * @param init.onTimeout (optional) A callback function that is called when the fetch request times out.
+ * @param init.onClientError (optional) A callback function that is called when the fetch request fails with a client error.
+ * @param init.onServerError (optional) A callback function that is called when the fetch request fails with a server error.
+ * @param init.body (optional) The body of the fetch request.
+ * @param init.headers (optional) The headers of the fetch request.
+ * @param init.method (optional) The method of the fetch request.
+ * @param init.mode (optional) The mode of the fetch request.
+ * @param init.credentials (optional) The credentials of the fetch request.
+ * @param init.cache (optional) The cache of the fetch request.
+ * @param init.redirect (optional) The redirect of the fetch request.
+ * @param init.referrer (optional) The referrer of the fetch request.
+ * @param init.referrerPolicy (optional) The referrerPolicy of the fetch request.
+ * @param init.integrity (optional) The integrity of the fetch request.
+ * @param init.keepalive (optional) The keepalive of the fetch request.
+ * @returns AbortablePromise<Result<Response, BringError>>
+ */
+export const bring = (init) => {
+    if (init instanceof BringError)
+        init = init.requestInit;
+    const { url, abortController = new AbortController(), timeout = 0, retry = 0, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError, ...requestInit } = init;
+    // Configure promise
+    const { promise, resolve } = withResolvers();
+    const abortablePromise = promise;
+    abortablePromise.abort = abortController.abort;
+    // Configure timeout signal
+    const timeoutSignal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+    const signal = AbortSignal.any([abortController.signal, timeoutSignal].filter((s) => !!s));
+    tryFetch(url, {
+        ...requestInit,
+        signal,
+    }, init, 0).then(({ error, value }) => {
+        if (error) {
+            if (abortController.signal.aborted) {
+                const abortError = new AbortError(abortController.signal.reason, {
+                    context: {
+                        url: url,
+                        method: requestInit.method ?? "GET",
+                        reason: abortController.signal.reason,
+                    },
+                    url,
+                    requestInit: init,
+                });
+                resolve(failure(abortError));
+                onAbort?.(abortError);
+                onError?.(abortError);
+                return;
+            }
+            if (timeoutSignal?.aborted) {
+                const error = new TimeoutError("Timeout", {
+                    context: { reason: timeoutSignal.reason, timeout },
+                    url,
+                    requestInit: init,
+                });
+                resolve(failure(error));
+                onTimeout?.(error);
+                onError?.(error);
+                return;
+            }
+            if (error instanceof Error) {
+                resolve(failure(new BringError(error.message, {
+                    cause: error,
+                    context: { url, method: requestInit.method ?? "GET" },
+                    url,
+                    requestInit: init,
+                })));
+                return;
+            }
+            if (typeof error === "string") {
+                resolve(failure(new BringError(error, { url, requestInit: init })));
+                return;
+            }
+            resolve(failure(new BringError("Unknown error", { url, requestInit: init })));
+        }
+        else {
+            const response = value;
+            if (response.ok) {
+                resolve(success(response));
+                onSuccess?.(response);
+            }
+            else {
+                if (isClientErrorResponse(response)) {
+                    return failure(new ClientError(response.statusText, {
+                        context: {
+                            status: response.status,
+                            statusText: response.statusText,
+                        },
+                        response,
+                        requestInit: init,
+                        url,
+                    }));
+                }
+                if (isServerErrorResponse(response)) {
+                    return failure(new ServerError(response.statusText, {
+                        response,
+                        requestInit: init,
+                        url,
+                        context: {
+                            status: response.status,
+                            statusText: response.statusText,
+                        },
+                    }));
+                }
+                const error = new BringError("Fetch failed", {
+                    context: {
+                        url,
+                        status: response.status,
+                        statusText: response.statusText,
+                    },
+                    url: url,
+                    requestInit: init,
+                    response,
+                });
+                resolve(failure(error));
+                onError?.(error);
+            }
+        }
+    });
+    return abortablePromise;
+};

package/dist/errors/AbortError.d.ts

@@ -0,0 +1,11 @@
+import { BringError } from "./BringError";
+export declare class AbortError extends BringError {
+    tag: string;
+}
+/** isAbortError
+ *
+ * Checks if error is AbortError.
+ * An AbortError is either an instance of AbortError or a BringError with tag "AbortError".
+ *
+ */
+export declare const isAbortError: (error: unknown) => error is AbortError;

package/dist/errors/AbortError.js

@@ -0,0 +1,14 @@
+import { BringError } from "./BringError";
+export class AbortError extends BringError {
+    tag = "AbortError";
+}
+/** isAbortError
+ *
+ * Checks if error is AbortError.
+ * An AbortError is either an instance of AbortError or a BringError with tag "AbortError".
+ *
+ */
+export const isAbortError = (error) => {
+    return (error instanceof AbortError ||
+        (error instanceof BringError && error.tag === "AbortError"));
+};

package/dist/errors/BringError.d.ts

@@ -0,0 +1,15 @@
+import { BringInit } from "../types/BringInit";
+import { JuiError, JuiErrorOptions } from "@torthu/jacketui-core";
+export interface BringErrorOptions extends JuiErrorOptions {
+    response?: Response;
+    request?: Request;
+    requestInit: BringInit;
+    url: string | URL;
+}
+export declare class BringError extends JuiError {
+    readonly response?: BringErrorOptions["response"];
+    readonly request?: BringErrorOptions["request"];
+    readonly requestInit: BringErrorOptions["requestInit"];
+    readonly url: BringErrorOptions["url"];
+    constructor(message: string, options: BringErrorOptions);
+}

package/dist/errors/BringError.js

@@ -0,0 +1,14 @@
+import { JuiError } from "@torthu/jacketui-core";
+export class BringError extends JuiError {
+    response;
+    request;
+    requestInit;
+    url;
+    constructor(message, options) {
+        super(message, options);
+        this.response = options.response;
+        this.request = options.request;
+        this.requestInit = options.requestInit;
+        this.url = options.url;
+    }
+}

package/dist/errors/ClientError.d.ts

@@ -0,0 +1,11 @@
+import { BringError } from "./BringError";
+export declare class ClientError extends BringError {
+    tag: string;
+}
+/** isClientError
+ *
+ * Checks if error is ClientError.
+ * A ClientError is either an instance of ClientError or a BringError with a status code between 400 and 499.
+ *
+ */
+export declare const isClientError: (error: unknown) => error is ClientError;

package/dist/errors/ClientError.js

@@ -0,0 +1,19 @@
+import { BringError } from "./BringError";
+export class ClientError extends BringError {
+    tag = "ClientError";
+}
+/** isClientError
+ *
+ * Checks if error is ClientError.
+ * A ClientError is either an instance of ClientError or a BringError with a status code between 400 and 499.
+ *
+ */
+export const isClientError = (error) => {
+    if (error instanceof ClientError) {
+        return true;
+    }
+    return (error instanceof BringError &&
+        !!error.response &&
+        error.response.status >= 400 &&
+        error.response.status < 500);
+};

package/dist/errors/NetworkError.d.ts

@@ -0,0 +1,11 @@
+import { BringError } from "./BringError";
+export declare class NetworkError extends BringError {
+    tag: string;
+}
+/** isNetworkError
+ *
+ * Checks if error is NetworkError.
+ * A NetworkError is either an instance of NetworkError or a BringError with status code 0.
+ *
+ */
+export declare const isNetworkError: (error: unknown) => error is NetworkError;

package/dist/errors/NetworkError.js

@@ -0,0 +1,18 @@
+import { BringError } from "./BringError";
+export class NetworkError extends BringError {
+    tag = "NetworkError";
+}
+/** isNetworkError
+ *
+ * Checks if error is NetworkError.
+ * A NetworkError is either an instance of NetworkError or a BringError with status code 0.
+ *
+ */
+export const isNetworkError = (error) => {
+    if (error instanceof NetworkError) {
+        return true;
+    }
+    return (error instanceof BringError &&
+        !!error.response &&
+        error.response.status === 0);
+};

package/dist/errors/ServerError.d.ts

@@ -0,0 +1,11 @@
+import { BringError } from "./BringError";
+export declare class ServerError extends BringError {
+    tag: string;
+}
+/** isServerError
+ *
+ * Checks if error is ServerError.
+ * A ServerError is either an instance of ServerError or a BringError with status code >= 500 and < 600.
+ *
+ */
+export declare const isServerError: (error: unknown) => error is ServerError;

package/dist/errors/ServerError.js

@@ -0,0 +1,19 @@
+import { BringError } from "./BringError";
+export class ServerError extends BringError {
+    tag = "ServerError";
+}
+/** isServerError
+ *
+ * Checks if error is ServerError.
+ * A ServerError is either an instance of ServerError or a BringError with status code >= 500 and < 600.
+ *
+ */
+export const isServerError = (error) => {
+    if (error instanceof ServerError) {
+        return true;
+    }
+    return (error instanceof BringError &&
+        !!error.response &&
+        error.response.status >= 500 &&
+        error.response.status < 600);
+};

package/dist/errors/TimeoutError.d.ts

@@ -0,0 +1,11 @@
+import { BringError } from "./BringError";
+export declare class TimeoutError extends BringError {
+    tag: string;
+}
+/** isTimeoutError
+ *
+ * Checks if error is TimeoutError.
+ * A TimeoutError is either an instance of TimeoutError or a BringError with tag "TimeoutError".
+ *
+ */
+export declare const isTimeoutError: (error: unknown) => error is TimeoutError;

package/dist/errors/TimeoutError.js

@@ -0,0 +1,14 @@
+import { BringError } from "./BringError";
+export class TimeoutError extends BringError {
+    tag = "TimeoutError";
+}
+/** isTimeoutError
+ *
+ * Checks if error is TimeoutError.
+ * A TimeoutError is either an instance of TimeoutError or a BringError with tag "TimeoutError".
+ *
+ */
+export const isTimeoutError = (error) => {
+    return (error instanceof TimeoutError ||
+        (error instanceof BringError && error.tag === "TimeoutError"));
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./AbortError";
+export * from "./ClientError";
+export * from "./BringError";
+export * from "./NetworkError";
+export * from "./ServerError";
+export * from "./TimeoutError";

package/dist/errors/index.js

@@ -0,0 +1,6 @@
+export * from "./AbortError";
+export * from "./ClientError";
+export * from "./BringError";
+export * from "./NetworkError";
+export * from "./ServerError";
+export * from "./TimeoutError";

package/dist/fetch.d.ts

@@ -0,0 +1,30 @@
+import { BringInit } from "./types/BringInit";
+/** fetch(url: string, init?: Omit<BringInit, "url">): AbortablePromise<Result<Response, BringError>>
+ *
+ * Wraps bring in a fetch-like API.
+ * This is a convenience function for bring.
+ *
+ * Some caveats:
+ * - BringInit expects and AbortController instead of a signal.
+ * - The first argument cannot be a Request object.
+ *
+ * @note This is not a drop-in replacement for the Fetch API.
+ *
+ * @note bring does not throw errors, but will return a Result.
+ *
+ * @example
+ *   const result = await fetch("https://example.com", { method: "GET" });
+ *   if (result.ok) {
+ *     const data = await result.value.json();
+ *     console.log(data);
+ *   } else {
+ *     console.error(result.error);
+ *   }
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+ *
+ * @param url string | URL - The URL to fetch.
+ * @param init BringInit - extends RequestInit from the Fetch API.
+ * @returns AbortablePromise<Result<Response, BringError>> - A promise that resolves to a Result object containing either a Response or a BringError.
+ */
+export declare const fetch: (url: string | URL, init?: Omit<BringInit, "url">) => import("@torthu/jacketui-core").AbortablePromise<import("@torthu/jacketui-core").Result<Response, import("./errors").BringError>>;

package/dist/fetch.js

@@ -0,0 +1,32 @@
+import { bring } from "./bring";
+/** fetch(url: string, init?: Omit<BringInit, "url">): AbortablePromise<Result<Response, BringError>>
+ *
+ * Wraps bring in a fetch-like API.
+ * This is a convenience function for bring.
+ *
+ * Some caveats:
+ * - BringInit expects and AbortController instead of a signal.
+ * - The first argument cannot be a Request object.
+ *
+ * @note This is not a drop-in replacement for the Fetch API.
+ *
+ * @note bring does not throw errors, but will return a Result.
+ *
+ * @example
+ *   const result = await fetch("https://example.com", { method: "GET" });
+ *   if (result.ok) {
+ *     const data = await result.value.json();
+ *     console.log(data);
+ *   } else {
+ *     console.error(result.error);
+ *   }
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+ *
+ * @param url string | URL - The URL to fetch.
+ * @param init BringInit - extends RequestInit from the Fetch API.
+ * @returns AbortablePromise<Result<Response, BringError>> - A promise that resolves to a Result object containing either a Response or a BringError.
+ */
+export const fetch = (url, init) => {
+    return bring({ url, ...init });
+};

package/dist/helpers/exponentialBackoff.d.ts

@@ -0,0 +1,21 @@
+export interface BackoffOptions {
+    base?: number;
+    factor?: number;
+    max?: number;
+    min?: number;
+}
+/** backoff(retryNum: number): number
+ *
+ * Backoff is the time to wait before retrying a request. It is calculated using an exponential backoff algorithm.
+ *
+ *  The formula is: base * factor^(retryNum - 1)
+ *
+ * @param retryNum The number of times the request has been retried
+ * @param options
+ * @param options.base Base backoff time in milliseconds
+ * @param options.factor Multiplier for the backoff time
+ * @param options.max Maximum backoff time in milliseconds
+ * @param options.min Minimum backoff time in milliseconds
+ * @returns number
+ */
+export declare const exponentialBackoff: (retryNum: number, { base, factor, max, min }?: BackoffOptions) => number;

package/dist/helpers/exponentialBackoff.js

@@ -0,0 +1,18 @@
+/** backoff(retryNum: number): number
+ *
+ * Backoff is the time to wait before retrying a request. It is calculated using an exponential backoff algorithm.
+ *
+ *  The formula is: base * factor^(retryNum - 1)
+ *
+ * @param retryNum The number of times the request has been retried
+ * @param options
+ * @param options.base Base backoff time in milliseconds
+ * @param options.factor Multiplier for the backoff time
+ * @param options.max Maximum backoff time in milliseconds
+ * @param options.min Minimum backoff time in milliseconds
+ * @returns number
+ */
+export const exponentialBackoff = (retryNum, { base = 500, factor = 1.5, max = 10000, min = 500 } = {}) => {
+    const calculatedBackoff = base * Math.pow(factor, retryNum - 1);
+    return Math.min(Math.max(calculatedBackoff, min), max);
+};

package/dist/helpers/extractCallbacks.d.ts

@@ -0,0 +1,2 @@
+import { BringCallbacks, BringInit } from "../types/BringInit";
+export declare const extractCallbacks: (init: BringInit) => BringCallbacks;

package/dist/helpers/extractCallbacks.js

@@ -0,0 +1,12 @@
+export const extractCallbacks = (init) => {
+    const { onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError, } = init;
+    return {
+        onSuccess,
+        onError,
+        onAbort,
+        onRetry,
+        onTimeout,
+        onClientError,
+        onServerError,
+    };
+};

package/dist/helpers/extractRequestInit.d.ts

@@ -0,0 +1,2 @@
+import { BringInit, RequestInit } from "../types/BringInit";
+export declare const extractRequestInit: (init: BringInit) => RequestInit;

package/dist/helpers/extractRequestInit.js

@@ -0,0 +1,16 @@
+export const extractRequestInit = (init) => {
+    const { method, headers, body, mode, credentials, cache, redirect, referrer, referrerPolicy, integrity, keepalive, } = init;
+    return {
+        method,
+        headers,
+        body,
+        mode,
+        credentials,
+        cache,
+        redirect,
+        referrer,
+        referrerPolicy,
+        integrity,
+        keepalive,
+    };
+};

package/dist/helpers/randomJitter.d.ts

@@ -0,0 +1,15 @@
+export interface JitterOptions {
+    min?: number;
+    max?: number;
+}
+/** jitter(backoff: number): number
+ *
+ *  Jitter is a random value added to the backoff time to prevent a thundering herd problem (when multiple clients retry at the same time).
+ *
+ * @param backoff The backoff time in milliseconds
+ * @param options
+ * @param options.min (default 0) Minimum jitter time in milliseconds
+ * @param options.max (default 100) Maximum jitter time in milliseconds
+ * @returns number
+ */
+export declare const randomJitter: ({ min, max, }?: JitterOptions) => number;

package/dist/helpers/randomJitter.js

@@ -0,0 +1,14 @@
+/** jitter(backoff: number): number
+ *
+ *  Jitter is a random value added to the backoff time to prevent a thundering herd problem (when multiple clients retry at the same time).
+ *
+ * @param backoff The backoff time in milliseconds
+ * @param options
+ * @param options.min (default 0) Minimum jitter time in milliseconds
+ * @param options.max (default 100) Maximum jitter time in milliseconds
+ * @returns number
+ */
+export const randomJitter = ({ min = 0, max = 100, } = {}) => {
+    const jitter = Math.random() * max;
+    return jitter < min ? min : jitter;
+};

package/dist/helpers/shouldRetry.d.ts

@@ -0,0 +1,22 @@
+import { Failure } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+interface RetryOptions {
+    retryStatuses?: number[];
+}
+/** shouldRetry(failure: Failure<BringError>, options?: RetryOptions): boolean
+ *
+ * Determines if a request should be retried based on the failure and options.
+ * By default, it retries on 0, 408, 425, 429, 500, 502, 503, and 504 status codes.
+ *
+ * Additionally if there is no response (i.e the request failed before a response was received),
+ * it will retry.
+ *
+ * You can override this behavior by passing a custom `retryStatuses` array.
+ *
+ * @param failure Failure<BringError>
+ * @param options RetryOptions
+ * @param options.retryStatuses Array of status codes to retry on
+ * @returns boolean
+ */
+export declare const shouldRetry: (failure: Failure<BringError>, { retryStatuses }?: RetryOptions) => boolean;
+export {};

package/dist/helpers/shouldRetry.js

@@ -0,0 +1,28 @@
+const defaultRetryStatuses = [0, 408, 425, 429, 500, 502, 503, 504];
+/** shouldRetry(failure: Failure<BringError>, options?: RetryOptions): boolean
+ *
+ * Determines if a request should be retried based on the failure and options.
+ * By default, it retries on 0, 408, 425, 429, 500, 502, 503, and 504 status codes.
+ *
+ * Additionally if there is no response (i.e the request failed before a response was received),
+ * it will retry.
+ *
+ * You can override this behavior by passing a custom `retryStatuses` array.
+ *
+ * @param failure Failure<BringError>
+ * @param options RetryOptions
+ * @param options.retryStatuses Array of status codes to retry on
+ * @returns boolean
+ */
+export const shouldRetry = (failure, { retryStatuses = defaultRetryStatuses } = {}) => {
+    const error = failure.error;
+    if (error.response) {
+        if (retryStatuses.includes(error.response.status)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./bring";
+export * from "./tryFetch";
+export * from "./errors";
+export * from "./pipe-helpers";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./bring";
+export * from "./tryFetch";
+export * from "./errors";
+export * from "./pipe-helpers";

package/dist/pipe-helpers/backoff.d.ts

@@ -0,0 +1,14 @@
+import { BackoffOptions } from "../helpers/exponentialBackoff";
+import { BringInitDecorator } from "../types/BringDecorator";
+/** backoff(options?: BackoffOptions): BringInitDecorator
+ *
+ * Sets a exponential backoff function for retrying requests.
+ *
+ * @param options (optional) Backoff options
+ * @param options.base Base backoff time in milliseconds
+ * @param options.factor Multiplier for the backoff time
+ * @param options.max Maximum backoff time in milliseconds
+ * @param options.min Minimum backoff time in milliseconds
+ * @returns BringInitDecorator
+ */
+export declare const backoff: (options?: BackoffOptions) => BringInitDecorator;