@scaleway/sdk-client 2.2.1 → 2.2.2

package/dist/_virtual/_rolldown/runtime.js

@@ -1,3 +1,4 @@
+//#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -8,4 +9,5 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
+//#endregion
 export { __exportAll };

package/dist/bridge.js

@@ -0,0 +1,8 @@
+import { isJSONObject } from "./helpers/json.js";
+import { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from "./helpers/marshalling.js";
+import { waitForResource } from "./internal/async/interval-retrier.js";
+import { API } from "./scw/api.js";
+import { Decimal } from "./scw/custom-types.js";
+import { marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalDecimal, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from "./scw/custom-marshalling.js";
+import { enrichForPagination } from "./scw/fetch/resource-paginator.js";
+export { API, Decimal, enrichForPagination, isJSONObject, marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalDecimal, unmarshalMapOfObject, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint, urlParams, validatePathParam, waitForResource };

package/dist/helpers/__tests__/is-browser.browser.test.js

@@ -0,0 +1,10 @@
+import { isBrowser } from "../is-browser.js";
+import { describe, expect, it } from "vitest";
+//#region src/helpers/__tests__/is-browser.browser.test.ts
+// @vitest-environment jsdom
+describe("isBrowser", () => {
+	it("returns true by default", () => {
+		expect(isBrowser()).toBe(true);
+	});
+});
+//#endregion

package/dist/helpers/__tests__/is-browser.node.test.js

@@ -0,0 +1,10 @@
+import { isBrowser } from "../is-browser.js";
+import { describe, expect, it } from "vitest";
+//#region src/helpers/__tests__/is-browser.node.test.ts
+// @vitest-environment node
+describe("isBrowser", () => {
+	it("returns false by default", () => {
+		expect(isBrowser()).toBe(false);
+	});
+});
+//#endregion

package/dist/helpers/__tests__/json.test.js

@@ -0,0 +1,48 @@
+import { isJSON, isJSONObject } from "../json.js";
+import { describe, expect, test } from "vitest";
+//#region src/helpers/__tests__/json.test.ts
+describe("isJSON", () => {
+	test.each([
+		"str",
+		200,
+		true,
+		null,
+		[
+			true,
+			"two",
+			3
+		],
+		{ key: "value" }
+	])(`accepts %s as a valid JSON value`, (obj) => {
+		expect(isJSON(obj)).toBeTruthy();
+	});
+	test.each([
+		void 0,
+		() => {},
+		Symbol(42)
+	])(`rejects %s as a valid JSON value`, (obj) => {
+		expect(isJSON(obj)).toBeFalsy();
+	});
+});
+describe("isJSONObject", () => {
+	test.each([{ key: "value" }])(`accepts %s as a valid JSONObject value`, (obj) => {
+		expect(isJSONObject(obj)).toBeTruthy();
+	});
+	test.each([
+		"str",
+		200,
+		true,
+		null,
+		[
+			true,
+			"two",
+			3
+		],
+		void 0,
+		() => {},
+		Symbol(42)
+	])(`rejects %s as a valid JSONObject value`, (obj) => {
+		expect(isJSONObject(obj)).toBeFalsy();
+	});
+});
+//#endregion

package/dist/helpers/__tests__/marshalling.test.js

@@ -0,0 +1,177 @@
+import { isJSONObject } from "../json.js";
+import { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from "../marshalling.js";
+import { describe, expect, it } from "vitest";
+//#region src/helpers/__tests__/marshalling.test.ts
+describe("validatePathParam", () => {
+	it("returns parameter for a non-empty string", () => {
+		expect(validatePathParam("keyName", "value")).toBe("value");
+	});
+	it("returns parameter for a number", () => {
+		expect(validatePathParam("keyName", 42)).toBe("42");
+	});
+	it("throws error for an undefined value", () => {
+		expect(() => {
+			validatePathParam("keyName", void 0);
+		}).toThrow(/* @__PURE__ */ new TypeError(`param keyName cannot be empty in request`));
+	});
+	it("throws error for an empty string", () => {
+		expect(() => {
+			validatePathParam("keyName", "");
+		}).toThrow(/* @__PURE__ */ new TypeError(`param keyName cannot be empty in request`));
+	});
+});
+describe("urlParams", () => {
+	it("accepts non-empty string | number | boolean values", () => {
+		expect(urlParams(["key1", "myValue"], ["key2", 0], ["key3", false]).toString()).toStrictEqual("key1=myValue&key2=0&key3=false");
+	});
+	it("accepts Date value", () => {
+		const now = /* @__PURE__ */ new Date();
+		expect(urlParams(["key1", now]).toString()).toStrictEqual(`key1=${encodeURIComponent(now.toISOString())}`);
+	});
+	it("accepts array of string", () => {
+		expect(urlParams(["my_param", ["value-1", "value-2"]]).toString()).toStrictEqual("my_param=value-1&my_param=value-2");
+	});
+	it("accepts array of different objects", () => {
+		const now = /* @__PURE__ */ new Date();
+		expect(urlParams(["my_param", ["value-1", now]]).toString()).toStrictEqual(`my_param=value-1&my_param=${encodeURIComponent(now.toISOString())}`);
+	});
+	it("accepts array of string with a null value", () => {
+		expect(urlParams(["my_param", ["value-1", null]]).toString()).toStrictEqual("my_param=value-1");
+	});
+	it("filters null or undefined values", () => {
+		expect(urlParams(["key1", null], ["key2", void 0]).toString()).toStrictEqual("");
+	});
+	it("filters non-string keys", () => {
+		expect(urlParams([0, "valid"], [null, "valid"]).toString()).toStrictEqual("");
+	});
+	it("properly resolves input from resolveOneOf", () => {
+		const value = resolveOneOf([{
+			param: "one_of_param",
+			value: 42
+		}]);
+		expect(urlParams(["my_param", "my-value"], ...Object.entries(value)).toString()).toStrictEqual("my_param=my-value&one_of_param=42");
+	});
+});
+describe("resolveOneOf", () => {
+	it("returns the value for 1 element", () => {
+		expect(resolveOneOf([{
+			default: void 0,
+			param: "my_key",
+			value: "42"
+		}], true)).toStrictEqual({ my_key: "42" });
+	});
+	it("returns the only defined value for 2 elements", () => {
+		expect(resolveOneOf([{
+			default: void 0,
+			param: "my_key_1",
+			value: void 0
+		}, {
+			default: void 0,
+			param: "my_key_2",
+			value: "42"
+		}], true)).toStrictEqual({ my_key_2: "42" });
+	});
+	it("returns the default value with undefined values", () => {
+		expect(resolveOneOf([{
+			default: "42",
+			param: "my_key_1",
+			value: void 0
+		}, {
+			default: void 0,
+			param: "my_key_2",
+			value: void 0
+		}], true)).toStrictEqual({ my_key_1: "42" });
+		expect(resolveOneOf([{
+			default: void 0,
+			param: "my_key_2",
+			value: void 0
+		}, {
+			default: "42",
+			param: "my_key_1",
+			value: void 0
+		}], true)).toStrictEqual({ my_key_1: "42" });
+	});
+	it("throws an error when no value has been found", () => {
+		expect(() => {
+			resolveOneOf([{
+				default: void 0,
+				param: "my_key_1",
+				value: void 0
+			}, {
+				default: void 0,
+				param: "my_key_2",
+				value: void 0
+			}], true);
+		}).toThrow(/* @__PURE__ */ new TypeError(`one of my_key_1 or my_key_2 must be indicated in the request`));
+	});
+	it("returns an empty record in case the resolve is optional", () => {
+		expect(resolveOneOf([{
+			default: void 0,
+			param: "my_key_1",
+			value: void 0
+		}, {
+			default: void 0,
+			param: "my_key_2",
+			value: void 0
+		}], false)).toStrictEqual({});
+	});
+	it("handles false kind values, like boolean.false", () => {
+		expect(resolveOneOf([{
+			default: void 0,
+			param: "my_key_1",
+			value: false
+		}, {
+			default: void 0,
+			param: "my_key_2",
+			value: true
+		}], false)).toStrictEqual({ my_key_1: false });
+	});
+});
+describe("unmarshalDate", () => {
+	it("unmarshals valid input", () => {
+		expect(unmarshalDate("2019-08-08T15:00:00Z")).toStrictEqual(/* @__PURE__ */ new Date("2019-08-08T15:00:00Z"));
+	});
+	it(`doesn't unmarshal invalid input type`, () => {
+		expect(unmarshalDate(42)).toBeUndefined();
+	});
+	it(`doesn't unmarshal invalid string format`, () => {
+		expect(unmarshalDate("not a date")).toBeUndefined();
+	});
+});
+describe("unmarshalArrayOfObject", () => {
+	const unmarshaller = (data) => {
+		if (!isJSONObject(data)) throw new Error("Should not happen");
+		return { myNumber: data.my_number };
+	};
+	it("unmarshals valid array of object", () => {
+		expect(unmarshalArrayOfObject([{ my_number: 42 }, { my_number: 94 }], unmarshaller)).toStrictEqual([{ myNumber: 42 }, { myNumber: 94 }]);
+	});
+	it(`doesn't unmarshal invalid input, with empty array as fallback`, () => {
+		expect(unmarshalArrayOfObject(null, unmarshaller)).toStrictEqual([]);
+	});
+	it(`doesn't unmarshal invalid input, with undefined as fallback`, () => {
+		expect(unmarshalArrayOfObject(null, unmarshaller, false)).toBeUndefined();
+	});
+});
+describe("unmarshalMapOfObject", () => {
+	const unmarshaller = (data) => {
+		if (!isJSONObject(data)) throw new Error("Should not happen");
+		return { myNumber: data.my_number };
+	};
+	it("unmarshals valid array of object", () => {
+		expect(unmarshalMapOfObject({
+			"first-key": { my_number: 42 },
+			"second-key": { my_number: 94 }
+		}, unmarshaller)).toStrictEqual({
+			"first-key": { myNumber: 42 },
+			"second-key": { myNumber: 94 }
+		});
+	});
+	it(`doesn't unmarshal invalid input, with empty record as fallback`, () => {
+		expect(unmarshalMapOfObject(null, unmarshaller)).toStrictEqual({});
+	});
+	it(`doesn't unmarshal invalid input, with undefined as fallback`, () => {
+		expect(unmarshalMapOfObject(null, unmarshaller, false)).toBeUndefined();
+	});
+});
+//#endregion

package/dist/helpers/is-browser.js

@@ -1,2 +1,4 @@
-const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+//#region src/helpers/is-browser.ts
+var isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+//#endregion
 export { isBrowser };

package/dist/helpers/is-response.js

@@ -1,3 +1,4 @@
+//#region src/helpers/is-response.ts
 /**
 * Validates an object is of type Response without using `instanceof`.
 *
@@ -5,5 +6,6 @@
 *
 * @internal
 */
-const isResponse = (obj) => obj !== null && obj !== void 0 && typeof obj === "object" && "status" in obj && typeof obj.status === "number" && "statusText" in obj && typeof obj.statusText === "string" && "headers" in obj && typeof obj.headers === "object" && "body" in obj && typeof obj.body !== "undefined";
+var isResponse = (obj) => obj !== null && obj !== void 0 && typeof obj === "object" && "status" in obj && typeof obj.status === "number" && "statusText" in obj && typeof obj.statusText === "string" && "headers" in obj && typeof obj.headers === "object" && "body" in obj && typeof obj.body !== "undefined";
+//#endregion
 export { isResponse };

package/dist/helpers/json.js

@@ -1,9 +1,14 @@
+//#region src/helpers/json.ts
+var isJSON = (obj) => {
+	const objT = typeof obj;
+	return obj !== void 0 && (obj === null || objT === "string" || objT === "number" || objT === "boolean" || Array.isArray(obj) || objT === "object");
+};
 /**
 * Validates an unknown object is a JSON Object.
 *
 * @internal
 */
-const isJSONObject = (obj) => {
+var isJSONObject = (obj) => {
 	const objT = typeof obj;
 	return obj !== void 0 && obj !== null && objT !== "string" && objT !== "number" && objT !== "boolean" && !Array.isArray(obj) && objT === "object";
 };
@@ -15,7 +20,7 @@ const isJSONObject = (obj) => {
 *
 * @internal
 */
-const camelize = (str) => {
+var camelize = (str) => {
 	const strLength = str.length;
 	if (strLength <= 0) return str;
 	let out = "";
@@ -38,7 +43,7 @@ const camelize = (str) => {
 *
 * @internal
 */
-const camelizeKeys = (obj, ignoreKeys = []) => {
+var camelizeKeys = (obj, ignoreKeys = []) => {
 	if (Array.isArray(obj)) return obj.map((v) => camelizeKeys(v, ignoreKeys));
 	if (obj && typeof obj === "object" && !(obj instanceof Date)) {
 		const result = {};
@@ -50,4 +55,5 @@ const camelizeKeys = (obj, ignoreKeys = []) => {
 	}
 	return obj;
 };
-export { camelizeKeys, isJSONObject };
+//#endregion
+export { camelize, camelizeKeys, isJSON, isJSONObject };

package/dist/helpers/marshalling.js

@@ -1,3 +1,4 @@
+//#region src/helpers/marshalling.ts
 /**
 * Returns the parameter if it's valid as path parameter
 * (string and not empty, or number), else throws an exception.
@@ -28,7 +29,7 @@ function validatePathParam(name, param) {
 *
 * @internal
 */
-const resolveOneOf = (list, isRequired = false) => {
+var resolveOneOf = (list, isRequired = false) => {
 	const elt = list.find((obj) => obj.value !== void 0) ?? list.find((obj) => obj.default !== void 0);
 	const value = elt?.value ?? elt?.default;
 	if (elt && value !== void 0) return { [elt.param]: value };
@@ -51,7 +52,7 @@ var toParamString = (v) => {
 	if (v instanceof Date) return v.toISOString();
 	return v.toString();
 };
-const urlParams = (...paramTuples) => {
+var urlParams = (...paramTuples) => {
 	const params = new URLSearchParams();
 	for (const [key, value] of paramTuples) {
 		if (typeof key !== "string" || value == null) continue;
@@ -72,7 +73,7 @@ const urlParams = (...paramTuples) => {
 *
 * @internal
 */
-const unmarshalDate = (data) => {
+var unmarshalDate = (data) => {
 	if (typeof data !== "string") return;
 	const date = new Date(data);
 	if (Number.isNaN(date.getTime())) return;
@@ -83,7 +84,7 @@ const unmarshalDate = (data) => {
 *
 * @internal
 */
-const unmarshalArrayOfObject = (data, unmarshaller, emptyFallback = true) => {
+var unmarshalArrayOfObject = (data, unmarshaller, emptyFallback = true) => {
 	if (!Array.isArray(data)) return emptyFallback ? [] : void 0;
 	return data.map((elt) => unmarshaller(elt));
 };
@@ -92,10 +93,11 @@ const unmarshalArrayOfObject = (data, unmarshaller, emptyFallback = true) => {
 *
 * @internal
 */
-const unmarshalMapOfObject = (data, unmarshaller, emptyFallback = true) => {
+var unmarshalMapOfObject = (data, unmarshaller, emptyFallback = true) => {
 	if (!data || typeof data !== "object" || !(data instanceof Object) || Array.isArray(data)) return emptyFallback ? {} : void 0;
 	const out = {};
 	for (const [key, value] of Object.entries(data)) out[key] = unmarshaller(value);
 	return out;
 };
+//#endregion
 export { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam };

package/dist/index.js

@@ -1,14 +1,14 @@
-import { enableConsoleLogger, setLogger } from "./internal/logger/index.js";
 import { isJSONObject } from "./helpers/json.js";
 import { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from "./helpers/marshalling.js";
 import { createExponentialBackoffStrategy, tryAtIntervals, waitForResource } from "./internal/async/interval-retrier.js";
-import { addAsyncHeaderInterceptor } from "./internal/interceptors/helpers.js";
 import { API } from "./scw/api.js";
-import { AUTH_HEADER_KEY, SESSION_HEADER_KEY } from "./scw/constants.js";
-import { authenticateWithSessionToken } from "./scw/auth.js";
 import { Decimal } from "./scw/custom-types.js";
 import { marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalAnyRes, unmarshalDecimal, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from "./scw/custom-marshalling.js";
 import { enrichForPagination } from "./scw/fetch/resource-paginator.js";
+import { enableConsoleLogger, setLogger } from "./internal/logger/index.js";
+import { addAsyncHeaderInterceptor } from "./internal/interceptors/helpers.js";
+import { AUTH_HEADER_KEY, SESSION_HEADER_KEY } from "./scw/constants.js";
+import { authenticateWithSessionToken } from "./scw/auth.js";
 import "./internals.js";
 import { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withProfile, withUserAgent, withUserAgentSuffix } from "./scw/client-ini-factory.js";
 import { createAdvancedClient, createClient } from "./scw/client.js";

package/dist/internal/async/__tests__/interval-retrier.test.js

@@ -0,0 +1,121 @@
+import { sleep } from "../sleep.js";
+import { createExponentialBackoffStrategy, createFibonacciIntervalStrategy, createFixedIntervalStrategy, tryAtIntervals, waitForResource } from "../interval-retrier.js";
+import { describe, expect, it } from "vitest";
+//#region src/internal/async/__tests__/interval-retrier.test.ts
+describe("createFixedIntervalStrategy", () => {
+	it("always returns the same interval", () => {
+		const fixedInterval = .5;
+		const strategy = createFixedIntervalStrategy(fixedInterval);
+		for (let i = 0; i < 100; i += 1) expect(strategy.next(0).value).toBe(fixedInterval);
+	});
+});
+describe("createFibonacciIntervalStrategy", () => {
+	it("returns a fibonacci sequence with default base and factor", () => {
+		const strategy = createFibonacciIntervalStrategy();
+		for (const expectedNumber of [
+			1,
+			1,
+			2,
+			3,
+			5,
+			8,
+			13,
+			21,
+			34
+		]) expect(strategy.next(0).value).toBe(expectedNumber);
+	});
+	it("returns a fibonacci sequence with custom base and factor", () => {
+		const strategy = createFibonacciIntervalStrategy(500, 2);
+		for (const expectedNumber of [
+			500,
+			1e3,
+			2500,
+			6e3,
+			14500,
+			35e3
+		]) expect(strategy.next(0).value).toBe(expectedNumber);
+	});
+});
+describe("createExponentialBackoffStrategy", () => {
+	it("returns a sequence where all numbers are between min and max", () => {
+		const strategy = createExponentialBackoffStrategy(1, 5);
+		for (let index = 0; index < 10; index += 1) {
+			const next = strategy.next(0).value;
+			expect(next >= 1 && next <= 100).toBe(true);
+		}
+	});
+	it("uses the same number if min and max are the same", () => {
+		const strategy = createExponentialBackoffStrategy(5, 5);
+		for (let index = 0; index < 10; index += 1) {
+			const next = strategy.next(0).value;
+			expect(next).toBe(5);
+		}
+	});
+	it(`throws if minDelay isn't valid`, () => {
+		try {
+			createExponentialBackoffStrategy(0, 5).next(0);
+		} catch (err) {
+			expect(err.message).toBe(`Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay`);
+		}
+	});
+	it(`throws if maxDelay isn't valid`, () => {
+		try {
+			createExponentialBackoffStrategy(1, 0).next(0);
+		} catch (err) {
+			expect(err.message).toBe(`Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay`);
+		}
+		try {
+			createExponentialBackoffStrategy(2, 1).next(0);
+		} catch (err) {
+			expect(err.message).toBe(`Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay`);
+		}
+	});
+});
+var mockLogic = (iterations, workingTime) => {
+	let startDate;
+	let counter = 0;
+	return async () => {
+		if (counter === 0) startDate = /* @__PURE__ */ new Date();
+		counter += 1;
+		await sleep(workingTime);
+		return {
+			done: counter >= iterations,
+			value: {
+				doneIterations: counter,
+				totalDuration: Date.now() - startDate.getTime()
+			}
+		};
+	};
+};
+describe("tryAtIntervals", () => {
+	const zeroIntervalStrat = createFixedIntervalStrategy(0);
+	it("does the proper number of iterations", async () => {
+		expect((await tryAtIntervals(mockLogic(3, 0), zeroIntervalStrat, .5)).doneIterations).toBe(3);
+	});
+	it("timeouts after 0s", () => expect(tryAtIntervals(mockLogic(3, 5), zeroIntervalStrat, 0)).rejects.toThrow(`Timeout after 0s`));
+	it("timeouts after 10ms", () => expect(tryAtIntervals(mockLogic(3, 5), zeroIntervalStrat, .01)).rejects.toThrow(`Timeout after 0.01s`));
+	it("uses default timeout", async () => {
+		expect((await tryAtIntervals(mockLogic(3, 0), zeroIntervalStrat)).doneIterations).toBe(3);
+	});
+});
+describe("waitForResource", () => {
+	it("resolves with non-transient status", () => {
+		return expect(waitForResource((res) => Promise.resolve(!["transient-one", "transient-two"].includes(res.status)), () => Promise.resolve({
+			message: "All went fine.",
+			status: "final"
+		}), { resourceId: "random-uuid" }, {
+			maxDelay: 1,
+			minDelay: 1
+		})).resolves.toStrictEqual({
+			message: "All went fine.",
+			status: "final"
+		});
+	});
+	it("rejects after timeout as transient status is being returned", () => {
+		return expect(waitForResource((res) => Promise.resolve(!["transient-one", "transient-two"].includes(res.status)), () => Promise.resolve({
+			message: "Still processing.",
+			status: "transient-two"
+		}), { resourceId: "random-uuid" }, { timeout: .01 })).rejects.toThrow();
+	});
+});
+//#endregion

package/dist/internal/async/__tests__/sleep.test.js

@@ -0,0 +1,19 @@
+import { sleep } from "../sleep.js";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+//#region src/internal/async/__tests__/sleep.test.ts
+beforeAll(() => {
+	vi.useFakeTimers();
+	vi.spyOn(global, "setTimeout");
+});
+afterAll(() => {
+	vi.useRealTimers();
+});
+describe("sleep", () => {
+	it("delays the proper amount of time", () => {
+		const delay = 50;
+		sleep(delay).catch(() => {});
+		expect(setTimeout).toHaveBeenCalledTimes(1);
+		expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), delay);
+	});
+});
+//#endregion

package/dist/internal/async/interval-retrier.d.ts

@@ -61,7 +61,7 @@ export declare const tryAtIntervals: <T>(retry: Retry<T>, strategy: IntervalStra
  *
  * @public
  */
-export type WaitForStopCondition<T> = (obj: T) => Promise<boolean>;
+export type WaitForStopCondition<T> = (obj: T) => Promise<boolean> | boolean;
 /**
  * The options to wait until a resource is ready.
  *

package/dist/internal/async/interval-retrier.js

@@ -1,8 +1,37 @@
 import { sleep } from "./sleep.js";
+//#region src/internal/async/interval-retrier.ts
 var DEFAULT_TIMEOUT_SECONDS = 300;
 var DEFAULT_MIN_DELAY_SECONDS = 1;
 var DEFAULT_MAX_DELAY_SECONDS = 30;
 /**
+* Creates a fixed interval strategy.
+* It returns the same interval value whatever the retry count.
+*
+* @param interval - The time interval (in seconds) to wait between each run
+* @returns A fixed interval generator
+*
+* @internal
+*/
+function* createFixedIntervalStrategy(interval) {
+	while (true) yield interval;
+}
+/**
+* Creates a fibonacci interval strategy.
+*
+* @param base - The base interval (in seconds) that will be multiplicated with the fibonacci number
+* @param factor - The factor so the fibonacci suite will go slower or faster
+* @returns A fibonnacci generator
+*
+* @internal
+*/
+function* createFibonacciIntervalStrategy(base = 1, factor = 1) {
+	let [prev, current] = [0, 1];
+	while (true) {
+		yield current * base;
+		[prev, current] = [current, prev + current * factor];
+	}
+}
+/**
 * Creates an exponential backoff interval strategy.
 *
 * @param minDelay - The minimum delay before the next try in seconds
@@ -33,7 +62,7 @@ function* createExponentialBackoffStrategy(minDelay, maxDelay) {
 *
 * @internal
 */
-const tryAtIntervals = async (retry, strategy, timeout = DEFAULT_TIMEOUT_SECONDS) => {
+var tryAtIntervals = async (retry, strategy, timeout = DEFAULT_TIMEOUT_SECONDS) => {
 	const timeoutTimestamp = Date.now() + timeout * 1e3;
 	let retryCount = 0;
 	while (Date.now() <= timeoutTimestamp) {
@@ -59,11 +88,12 @@ const tryAtIntervals = async (retry, strategy, timeout = DEFAULT_TIMEOUT_SECONDS
 *
 * @public
 */
-const waitForResource = (stop, fetcher, request, options, strategy = createExponentialBackoffStrategy(options?.minDelay ?? DEFAULT_MIN_DELAY_SECONDS, options?.maxDelay ?? DEFAULT_MAX_DELAY_SECONDS)) => tryAtIntervals(async () => {
+var waitForResource = (stop, fetcher, request, options, strategy = createExponentialBackoffStrategy(options?.minDelay ?? DEFAULT_MIN_DELAY_SECONDS, options?.maxDelay ?? DEFAULT_MAX_DELAY_SECONDS)) => tryAtIntervals(async () => {
 	const value = await fetcher(request);
 	return {
 		done: await stop(value),
 		value
 	};
 }, strategy, options?.timeout);
-export { createExponentialBackoffStrategy, tryAtIntervals, waitForResource };
+//#endregion
+export { createExponentialBackoffStrategy, createFibonacciIntervalStrategy, createFixedIntervalStrategy, tryAtIntervals, waitForResource };

package/dist/internal/async/sleep.js

@@ -1,3 +1,4 @@
+//#region src/internal/async/sleep.ts
 /**
 * Sleep for a specified number of time.
 *
@@ -6,7 +7,8 @@
 *
 * @internal
 */
-const sleep = (ms) => new Promise((resolve) => {
+var sleep = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
+//#endregion
 export { sleep };