@oscarpalmer/atoms 0.193.0 → 0.194.0

package/src/function/once.ts

@@ -1,200 +0,0 @@
-import type {
-	GenericAsyncCallback,
-	GenericCallback,
-	OnceAsyncCallback,
-	OnceCallback,
-} from '../models';
-import {assert} from './assert';
-
-// #region Types
-
-type OnceAsyncItem<Value> = {
-	reject: (reason?: unknown) => void;
-	resolve: (value: Value) => void;
-};
-
-type OnceAsyncState<Value> = {
-	error: boolean;
-	finished: boolean;
-	items: OnceAsyncItem<Value>[];
-} & OnceState<Value>;
-
-type OnceState<Value> = {
-	called: boolean;
-	cleared: boolean;
-	value: Value;
-};
-
-// #endregion
-
-// #region Functions
-
-/**
- * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
- *
- * _Available as `asyncOnce` and `once.async`_
- *
- * @param callback Callback to use once
- * @returns _Once_ callback
- */
-export function asyncOnce<Callback extends GenericAsyncCallback>(
-	callback: Callback,
-): OnceAsyncCallback<Callback> {
-	assert(() => typeof callback === 'function', ONCE_MESSAGE_EXPECTATION);
-
-	const state: OnceAsyncState<Awaited<ReturnType<Callback>>> = {
-		called: false,
-		cleared: false,
-		error: false,
-		finished: false,
-		items: [],
-		value: undefined as never,
-	};
-
-	const fn = (...parameters: Parameters<Callback>): Promise<Awaited<ReturnType<Callback>>> => {
-		if (state.cleared) {
-			return Promise.reject(new Error(ONCE_MESSAGE_CLEARED));
-		}
-
-		if (state.finished) {
-			return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
-		}
-
-		if (state.called) {
-			return new Promise<Awaited<ReturnType<Callback>>>((resolve, reject) => {
-				state.items.push({reject, resolve});
-			});
-		}
-
-		state.called = true;
-
-		return new Promise<Awaited<ReturnType<Callback>>>((resolve, reject) => {
-			state.items.push({reject, resolve});
-
-			void callback(...parameters)
-				.then(value => {
-					handleOnceResult(state, value, false);
-				})
-				.catch(error => {
-					handleOnceResult(state, error, true);
-				});
-		});
-	};
-
-	Object.defineProperties(fn, {
-		called: {
-			enumerable: true,
-			get: (): boolean => state.called,
-		},
-		cleared: {
-			enumerable: true,
-			get: (): boolean => state.cleared,
-		},
-		error: {
-			enumerable: true,
-			get: (): boolean => state.error,
-		},
-		finished: {
-			enumerable: true,
-			get: (): boolean => state.finished,
-		},
-	});
-
-	fn.clear = (): void => {
-		if (!state.called || !state.finished || state.cleared) {
-			return;
-		}
-
-		state.cleared = true;
-		state.value = undefined as never;
-	};
-
-	return fn as OnceAsyncCallback<Callback>;
-}
-
-function handleOnceResult<Value>(
-	state: OnceAsyncState<Value>,
-	value: unknown,
-	error: boolean,
-): void {
-	state.error = error;
-	state.finished = true;
-	state.value = value as Value;
-
-	const items = state.items.splice(0);
-	const {length} = items;
-
-	for (let index = 0; index < length; index += 1) {
-		const {reject, resolve} = items[index];
-
-		if (error) {
-			reject(value);
-		} else {
-			resolve(value as Value);
-		}
-	}
-}
-
-/**
- * Create a function that can only be called once, returning the same value on subsequent calls
- *
- * @param callback Callback to use once
- * @returns _Once_ callback
- */
-export function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback> {
-	assert(() => typeof callback === 'function', ONCE_MESSAGE_EXPECTATION);
-
-	const state: OnceState<ReturnType<Callback>> = {
-		called: false,
-		cleared: false,
-		value: undefined as never,
-	};
-
-	const fn = (...parameters: Parameters<Callback>): ReturnType<Callback> => {
-		if (state.cleared) {
-			throw new Error(ONCE_MESSAGE_CLEARED);
-		}
-
-		if (state.called) {
-			return state.value;
-		}
-
-		state.called = true;
-
-		state.value = callback(...parameters);
-
-		return state.value;
-	};
-
-	Object.defineProperties(fn, {
-		called: {
-			get: (): boolean => state.called,
-		},
-		cleared: {
-			get: (): boolean => state.cleared,
-		},
-	});
-
-	fn.clear = (): void => {
-		if (!state.called || state.cleared) {
-			return;
-		}
-
-		state.cleared = true;
-		state.value = undefined as never;
-	};
-
-	return fn as OnceCallback<Callback>;
-}
-
-once.async = asyncOnce;
-
-// #endregion
-
-// #region Variables
-
-const ONCE_MESSAGE_CLEARED = 'Once has been cleared';
-
-const ONCE_MESSAGE_EXPECTATION = 'Once expected a function';
-
-// #endregion

package/src/function/retry.ts

@@ -1,175 +0,0 @@
-import {getTimer, TIMER_WAIT} from '../internal/function/timer';
-import {isPlainObject} from '../internal/is';
-import type {GenericAsyncCallback, GenericCallback} from '../models';
-
-// #region Types
-
-/**
- * An error thrown when a retry fails
- */
-export class RetryError extends Error {
-	constructor(
-		message: string,
-		readonly original: unknown,
-	) {
-		super(message);
-
-		this.name = RETRY_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
- *
- * _Available as `asyncRetry` and `retry.async`_
- *
- * @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
- *
- * _Available as `asyncRetry` and `retry.async`_
- *
- * @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
- *
- * _Available as `asyncRetry` and `retry.async`_
- *
- * @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(RETRY_MESSAGE_EXPECTATION);
-	}
-
-	async function handle(): Promise<void> {
-		try {
-			const result = await callback();
-
-			resolver(result);
-		} catch (error) {
-			if (attempts >= times || !when(error)) {
-				rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
-			} else {
-				attempts += 1;
-
-				void 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;
-
-		void 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(RETRY_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(RETRY_MESSAGE_FAILED, last);
-}
-
-retry.async = asyncRetry;
-
-function shouldRetry(): boolean {
-	return true;
-}
-
-// #endregion
-
-// #region Variables
-
-const RETRY_ERROR_NAME = 'RetryError';
-
-const RETRY_MESSAGE_EXPECTATION = 'Retry expected a function';
-
-const RETRY_MESSAGE_FAILED = 'Retry failed';
-
-// #endregion