@oscarpalmer/atoms 0.152.0 → 0.153.0

package/dist/atoms.full.js

@@ -937,6 +937,82 @@ function debounce(callback, time) {
 function throttle(callback, time) {
 	return getTimer(TIMER_THROTTLE, callback, time);
 }
+var RetryError = class extends Error {
+	constructor(message, original) {
+		super(message);
+		this.original = original;
+		this.name = ERROR_NAME$1;
+	}
+};
+/**
+* Retry a callback a specified number of times, with a delay between attempts
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+async function asyncRetry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	async function handle() {
+		try {
+			const result = await callback();
+			resolver(result);
+		} catch (error) {
+			if (attempts >= times || !when(error)) rejector(new RetryError(MESSAGE_FAILED, error));
+			else {
+				attempts += 1;
+				timer();
+			}
+		}
+	}
+	const { delay, times, when } = getRetryOptions(options);
+	const timer = getTimer(TIMER_WAIT, handle, delay);
+	let attempts = 0;
+	let rejector;
+	let resolver;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+		handle();
+	});
+}
+function getRetryNumber(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getRetryOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		delay: getRetryNumber(options.delay),
+		times: getRetryNumber(options.times),
+		when: typeof options.when === "function" ? options.when : shouldRetry
+	};
+}
+/**
+* Retry a callback a specified number of times
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+function retry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	const { times, when } = getRetryOptions(options);
+	let last;
+	for (let index = 0; index <= times; index += 1) try {
+		return callback();
+	} catch (error) {
+		if (index >= times || !when(error)) {
+			last = error;
+			break;
+		}
+	}
+	throw new RetryError(MESSAGE_FAILED, last);
+}
+retry.async = asyncRetry;
+function shouldRetry() {
+	return true;
+}
+const ERROR_NAME$1 = "RetryError";
+const MESSAGE_EXPECTATION = "Retry expected a function";
+const MESSAGE_FAILED = "Retry failed";
 function _isResult(value, okValue) {
 	if (!isPlainObject(value)) return false;
 	return value.ok === okValue && (okValue ? "value" : "error") in value;
@@ -3696,4 +3772,4 @@ var SizedSet = class extends Set {
 		}
 	}
 };
-export { CancelablePromise, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/dist/function/retry.js

@@ -0,0 +1,79 @@
+import { isPlainObject } from "../internal/is.js";
+import { TIMER_WAIT, getTimer } from "../internal/function/timer.js";
+var RetryError = class extends Error {
+	constructor(message, original) {
+		super(message);
+		this.original = original;
+		this.name = ERROR_NAME;
+	}
+};
+/**
+* Retry a callback a specified number of times, with a delay between attempts
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+async function asyncRetry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	async function handle() {
+		try {
+			const result = await callback();
+			resolver(result);
+		} catch (error) {
+			if (attempts >= times || !when(error)) rejector(new RetryError(MESSAGE_FAILED, error));
+			else {
+				attempts += 1;
+				timer();
+			}
+		}
+	}
+	const { delay, times, when } = getRetryOptions(options);
+	const timer = getTimer(TIMER_WAIT, handle, delay);
+	let attempts = 0;
+	let rejector;
+	let resolver;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+		handle();
+	});
+}
+function getRetryNumber(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getRetryOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		delay: getRetryNumber(options.delay),
+		times: getRetryNumber(options.times),
+		when: typeof options.when === "function" ? options.when : shouldRetry
+	};
+}
+/**
+* Retry a callback a specified number of times
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+function retry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	const { times, when } = getRetryOptions(options);
+	let last;
+	for (let index = 0; index <= times; index += 1) try {
+		return callback();
+	} catch (error) {
+		if (index >= times || !when(error)) {
+			last = error;
+			break;
+		}
+	}
+	throw new RetryError(MESSAGE_FAILED, last);
+}
+retry.async = asyncRetry;
+function shouldRetry() {
+	return true;
+}
+var ERROR_NAME = "RetryError";
+var MESSAGE_EXPECTATION = "Retry expected a function";
+var MESSAGE_FAILED = "Retry failed";
+export { RetryError, retry };

package/dist/index.js

@@ -39,6 +39,7 @@ import { getColor } from "./color/index.js";
 import { SizedMap } from "./sized/map.js";
 import { memoize } from "./function/memoize.js";
 import { debounce, throttle } from "./function/index.js";
+import { RetryError, retry } from "./function/retry.js";
 import { isError, isOk, isResult } from "./internal/result.js";
 import { flow, pipe } from "./function/work.js";
 import { equal } from "./internal/value/equal.js";
@@ -70,4 +71,4 @@ import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
 import { attempt } from "./result/index.js";
 import { SizedSet } from "./sized/set.js";
-export { CancelablePromise, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/package.json

@@ -51,8 +51,12 @@
 			"default": "./dist/color/index.js"
 		},
 		"./function": {
-			"types": "./types/function/memoize.d.ts",
-			"default": "./dist/function/memoize.js"
+			"types": "./types/function/index.d.ts",
+			"default": "./dist/function/index.js"
+		},
+		"./function/retry": {
+			"types": "./types/function/retry.d.ts",
+			"default": "./dist/function/retry.js"
 		},
 		"./function/work": {
 			"types": "./types/function/work.d.ts",
@@ -176,5 +180,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.152.0"
+	"version": "0.153.0"
 }

package/src/function/retry.ts

@@ -0,0 +1,162 @@
+import {getTimer, TIMER_WAIT} from '../internal/function/timer';
+import {isPlainObject} from '../internal/is';
+import type {GenericAsyncCallback, GenericCallback} from '../models';
+
+// #region Types
+
+export class RetryError extends Error {
+	constructor(
+		message: string,
+		readonly original: unknown,
+	) {
+		super(message);
+
+		this.name = ERROR_NAME;
+	}
+}
+
+export type RetryOptions = {
+	delay?: number;
+	times?: number;
+	when?: (error: unknown) => boolean;
+};
+
+// #endregion
+
+// #region Functions
+
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+async function asyncRetry<Callback extends GenericAsyncCallback>(
+	callback: Callback,
+	options?: RetryOptions,
+): Promise<Awaited<ReturnType<Callback>>>;
+
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+async function asyncRetry<Callback extends GenericCallback>(
+	callback: Callback,
+	options?: RetryOptions,
+): Promise<ReturnType<Callback>>;
+
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+async function asyncRetry<Callback extends GenericCallback>(
+	callback: Callback,
+	options?: RetryOptions,
+): Promise<ReturnType<Callback>> {
+	if (typeof callback !== 'function') {
+		throw new TypeError(MESSAGE_EXPECTATION);
+	}
+
+	async function handle(): Promise<void> {
+		try {
+			const result = await callback();
+
+			resolver(result);
+		} catch (error) {
+			if (attempts >= times || !when(error)) {
+				rejector(new RetryError(MESSAGE_FAILED, error));
+			} else {
+				attempts += 1;
+
+				timer();
+			}
+		}
+	}
+
+	const {delay, times, when} = getRetryOptions(options);
+
+	const timer = getTimer(TIMER_WAIT, handle, delay);
+
+	let attempts = 0;
+
+	let rejector: (reason?: unknown) => void;
+	let resolver: (value: Awaited<ReturnType<Callback>>) => void;
+
+	return new Promise<Awaited<ReturnType<Callback>>>((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+
+		handle();
+	});
+}
+
+function getRetryNumber(value?: unknown): number {
+	return typeof value === 'number' && value > 0 ? value : 0;
+}
+
+function getRetryOptions(input?: RetryOptions): Required<RetryOptions> {
+	const options = isPlainObject(input) ? input : {};
+
+	return {
+		delay: getRetryNumber(options.delay),
+		times: getRetryNumber(options.times),
+		when: typeof options.when === 'function' ? options.when : shouldRetry,
+	};
+}
+
+/**
+ * Retry a callback a specified number of times
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+export function retry<Callback extends GenericCallback>(
+	callback: Callback,
+	options?: Omit<RetryOptions, 'delay'>,
+): ReturnType<Callback> {
+	if (typeof callback !== 'function') {
+		throw new TypeError(MESSAGE_EXPECTATION);
+	}
+
+	const {times, when} = getRetryOptions(options);
+
+	let last: unknown;
+
+	for (let index = 0; index <= times; index += 1) {
+		try {
+			const result = callback();
+
+			return result;
+		} catch (error) {
+			if (index >= times || !when(error)) {
+				last = error;
+
+				break;
+			}
+		}
+	}
+
+	throw new RetryError(MESSAGE_FAILED, last);
+}
+
+retry.async = asyncRetry;
+
+function shouldRetry(): boolean {
+	return true;
+}
+
+// #endregion
+
+// #region Variables
+
+const ERROR_NAME = 'RetryError';
+
+const MESSAGE_EXPECTATION = 'Retry expected a function';
+
+const MESSAGE_FAILED = 'Retry failed';
+
+// #endregion

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './array/to-record';
 export * from './array/unique';
 
 export * from './function/index';
+export * from './function/retry';
 export * from './function/work';
 
 export * from './internal/function/misc';

package/types/function/retry.d.ts

@@ -0,0 +1,35 @@
+import type { GenericAsyncCallback, GenericCallback } from '../models';
+export declare class RetryError extends Error {
+    readonly original: unknown;
+    constructor(message: string, original: unknown);
+}
+export type RetryOptions = {
+    delay?: number;
+    times?: number;
+    when?: (error: unknown) => boolean;
+};
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericAsyncCallback>(callback: Callback, options?: RetryOptions): Promise<Awaited<ReturnType<Callback>>>;
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericCallback>(callback: Callback, options?: RetryOptions): Promise<ReturnType<Callback>>;
+/**
+ * Retry a callback a specified number of times
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+export declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
+export declare namespace retry {
+    var async: typeof asyncRetry;
+}
+export {};

package/types/index.d.ts

@@ -4,6 +4,7 @@ export * from './array/to-map';
 export * from './array/to-record';
 export * from './array/unique';
 export * from './function/index';
+export * from './function/retry';
 export * from './function/work';
 export * from './internal/function/misc';
 export * from './internal/string';