@oscarpalmer/atoms 0.202.0 → 0.203.0

package/dist/function/once.mjs

@@ -1,5 +1,73 @@
 import { assert } from "../internal/function/assert.mjs";
 //#region src/function/once.ts
+const ONCE_NAME_ASYNC = "asyncOnce";
+const ONCE_NAME_SYNC = "once";
+const ONCE_PROPERTY = "$once";
+function AsyncOnce(callback) {
+	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+		callback,
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	} });
+}
+Object.defineProperties(AsyncOnce.prototype, {
+	[ONCE_PROPERTY]: { value: ONCE_NAME_ASYNC },
+	called: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].called;
+		}
+	},
+	clear: { value: clearOnce },
+	cleared: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].cleared;
+		}
+	},
+	error: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].error;
+		}
+	},
+	finished: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].finished;
+		}
+	},
+	run: { value: runOnceAsync }
+});
+function Once(callback) {
+	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+		callback,
+		called: false,
+		cleared: false,
+		value: void 0
+	} });
+}
+Object.defineProperties(Once.prototype, {
+	[ONCE_PROPERTY]: { value: ONCE_NAME_SYNC },
+	clear: { value: clearOnce },
+	called: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].called;
+		}
+	},
+	cleared: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].cleared;
+		}
+	},
+	run: { value: runOnce }
+});
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
 *
@@ -10,59 +78,12 @@ import { assert } from "../internal/function/assert.mjs";
 */
 function asyncOnce(callback) {
 	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		error: false,
-		finished: false,
-		items: [],
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		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((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-		});
-		state.called = true;
-		return new Promise((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-			callback(...parameters).then((value) => {
-				handleOnceResult(state, value, false);
-			}).catch((error) => {
-				handleOnceResult(state, error, true);
-			});
-		});
-	};
-	Object.defineProperties(fn, {
-		called: {
-			enumerable: true,
-			get: () => state.called
-		},
-		clear: { value: () => clearState(state) },
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		},
-		error: {
-			enumerable: true,
-			get: () => state.error
-		},
-		finished: {
-			enumerable: true,
-			get: () => state.finished
-		}
-	});
-	return fn;
+	return new AsyncOnce(callback);
 }
-function clearState(state) {
+function clearOnce() {
+	const state = this[ONCE_SYMBOL];
 	if (!state.called || state.cleared) return;
+	state.callback = void 0;
 	state.cleared = true;
 	state.value = void 0;
 }
@@ -79,6 +100,27 @@ function handleOnceResult(state, value, error) {
 	}
 }
 /**
+* Is the value an asynchronous once callback?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous once callback, otherwise `false`
+*/
+function isAsyncOnce(value) {
+	return isOnceInstance(value, ONCE_NAME_ASYNC);
+}
+/**
+* Is the value a once callback?
+*
+* @param value Value to check
+* @returns `true` if the value is a once callback, otherwise `false`
+*/
+function isOnce(value) {
+	return isOnceInstance(value, ONCE_NAME_SYNC);
+}
+function isOnceInstance(value, name) {
+	return typeof value === "object" && value !== null && ONCE_PROPERTY in value && value[ONCE_PROPERTY] === name;
+}
+/**
 * Create a function that can only be called once, returning the same value on subsequent calls
 *
 * @param callback Callback to use once
@@ -86,34 +128,51 @@ function handleOnceResult(state, value, error) {
 */
 function once(callback) {
 	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		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: {
-			enumerable: true,
-			get: () => state.called
-		},
-		clear: { value: () => clearState(state) },
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		}
+	return new Once(callback);
+}
+function runOnce(...parameters) {
+	const state = this[ONCE_SYMBOL];
+	if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
+	if (state.called) return state.value;
+	state.called = true;
+	state.value = state.callback(...parameters);
+	return state.value;
+}
+function runOnceAsync(...parameters) {
+	const state = this[ONCE_SYMBOL];
+	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((resolve, reject) => {
+		state.items.push({
+			reject,
+			resolve
+		});
+	});
+	state.called = true;
+	return new Promise((resolve, reject) => {
+		state.items.push({
+			reject,
+			resolve
+		});
+		state.callback(...parameters).then((value) => {
+			handleOnceResult(state, value, false);
+		}).catch((error) => {
+			handleOnceResult(state, error, true);
+		});
 	});
-	return fn;
 }
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
+asyncOnce.is = isAsyncOnce;
 once.async = asyncOnce;
-Object.defineProperty(once, "async", { value: asyncOnce });
+once.is = isOnce;
+once.isAsync = isAsyncOnce;
+Object.defineProperty(asyncOnce, "is", { value: isAsyncOnce });
+Object.defineProperties(once, {
+	async: { value: asyncOnce },
+	is: { value: isOnce },
+	isAsync: { value: isAsyncOnce }
+});
 //#endregion
-export { asyncOnce, once };
+export { asyncOnce, isAsyncOnce, isOnce, once };

package/dist/function/retry.d.mts

@@ -3,11 +3,11 @@ import { GenericAsyncCallback, GenericCallback } from "../models.mjs";
 /**
  * An error thrown when a retry fails
  */
-declare class RetryError extends Error {
+export declare class RetryError extends Error {
   readonly original: unknown;
   constructor(message: string, original: unknown);
 }
-type RetryOptions = {
+export type RetryOptions = {
   delay?: number;
   times?: number;
   when?: (error: unknown) => boolean;
@@ -39,9 +39,8 @@ declare function asyncRetry<Callback extends GenericCallback>(callback: Callback
  * @param options Retry options
  * @returns Callback result
  */
-declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
-declare namespace retry {
+export declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
+export declare namespace retry {
   var async: typeof asyncRetry;
 }
-//#endregion
-export { RetryError, RetryOptions, retry };
+//#endregion

package/dist/function/retry.mjs

@@ -1,6 +1,6 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
-import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
+import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
 //#region src/function/retry.ts
 /**
 * An error thrown when a retry fails
@@ -32,12 +32,12 @@ async function asyncRetry(callback, options) {
 			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
 			else {
 				attempts += 1;
-				timer();
+				limiter.run();
 			}
 		}
 	}
 	const { delay, times, when } = createRetryOptions(options);
-	const timer = getTimer(TIMER_WAIT, handle, delay);
+	const limiter = getLimiter(LIMITER_WAIT, handle, delay);
 	let attempts = 0;
 	let rejector;
 	let resolver;