@oscarpalmer/atoms 0.184.1 → 0.185.0

package/dist/function/memoize.d.mts

@@ -1,6 +1,9 @@
 import { GenericCallback } from "../models.mjs";
 
 //#region src/function/memoize.d.ts
+/**
+ * A memoized function, caching and retrieving results based on the its parameters _(or a custom cache key)_
+ */
 declare class Memoized<Callback extends GenericCallback> {
   #private;
   /**

package/dist/function/memoize.mjs

@@ -2,6 +2,9 @@ import { isPlainObject } from "../internal/is.mjs";
 import { getString, join } from "../internal/string.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/function/memoize.ts
+/**
+* A memoized function, caching and retrieving results based on the its parameters _(or a custom cache key)_
+*/
 var Memoized = class {
 	#state;
 	/**

package/dist/function/once.mjs

@@ -8,7 +8,7 @@ import { assert } from "./assert.mjs";
 * @returns Once callback
 */
 function asyncOnce(callback) {
-	assert(() => typeof callback === "function", MESSAGE_EXPECTATION);
+	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
 	const state = {
 		called: false,
 		cleared: false,
@@ -18,7 +18,7 @@ function asyncOnce(callback) {
 		value: void 0
 	};
 	const fn = (...parameters) => {
-		if (state.cleared) return Promise.reject(new Error(MESSAGE_CLEARED));
+		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({
@@ -33,9 +33,9 @@ function asyncOnce(callback) {
 				resolve
 			});
 			callback(...parameters).then((value) => {
-				handleResult(state, value, false);
+				handleOnceResult(state, value, false);
 			}).catch((error) => {
-				handleResult(state, error, true);
+				handleOnceResult(state, error, true);
 			});
 		});
 	};
@@ -52,7 +52,7 @@ function asyncOnce(callback) {
 	};
 	return fn;
 }
-function handleResult(state, value, error) {
+function handleOnceResult(state, value, error) {
 	state.error = error;
 	state.finished = true;
 	state.value = value;
@@ -70,14 +70,14 @@ function handleResult(state, value, error) {
 * @returns Once callback
 */
 function once(callback) {
-	assert(() => typeof callback === "function", MESSAGE_EXPECTATION);
+	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(MESSAGE_CLEARED);
+		if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
 		if (state.called) return state.value;
 		state.called = true;
 		state.value = callback(...parameters);
@@ -95,7 +95,7 @@ function once(callback) {
 	return fn;
 }
 once.async = asyncOnce;
-const MESSAGE_CLEARED = "Once has been cleared";
-const MESSAGE_EXPECTATION = "Once expected a function";
+const ONCE_MESSAGE_CLEARED = "Once has been cleared";
+const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 //#endregion
 export { asyncOnce, once };

package/dist/function/retry.d.mts

@@ -1,6 +1,9 @@
 import { GenericAsyncCallback, GenericCallback } from "../models.mjs";
 
 //#region src/function/retry.d.ts
+/**
+ * An error thrown when a retry fails
+ */
 declare class RetryError extends Error {
   readonly original: unknown;
   constructor(message: string, original: unknown);

package/dist/function/retry.mjs

@@ -1,11 +1,14 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 //#region src/function/retry.ts
+/**
+* An error thrown when a retry fails
+*/
 var RetryError = class extends Error {
 	constructor(message, original) {
 		super(message);
 		this.original = original;
-		this.name = ERROR_NAME;
+		this.name = RETRY_ERROR_NAME;
 	}
 };
 /**
@@ -17,13 +20,13 @@ var RetryError = class extends Error {
 * @returns Callback result
 */
 async function asyncRetry(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	if (typeof callback !== "function") throw new TypeError(RETRY_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));
+			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
 			else {
 				attempts += 1;
 				timer();
@@ -59,7 +62,7 @@ function getRetryOptions(input) {
 * @returns Callback result
 */
 function retry(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_EXPECTATION);
+	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
 	const { times, when } = getRetryOptions(options);
 	let last;
 	for (let index = 0; index <= times; index += 1) try {
@@ -70,14 +73,14 @@ function retry(callback, options) {
 			break;
 		}
 	}
-	throw new RetryError(MESSAGE_FAILED, last);
+	throw new RetryError(RETRY_MESSAGE_FAILED, last);
 }
 retry.async = asyncRetry;
 function shouldRetry() {
 	return true;
 }
-const ERROR_NAME = "RetryError";
-const MESSAGE_EXPECTATION = "Retry expected a function";
-const MESSAGE_FAILED = "Retry failed";
+const RETRY_ERROR_NAME = "RetryError";
+const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
+const RETRY_MESSAGE_FAILED = "Retry failed";
 //#endregion
 export { RetryError, retry };

package/dist/function/work.mjs

@@ -1,5 +1,5 @@
-import { assert } from "./assert.mjs";
 import { isError, isOk } from "../internal/result.mjs";
+import { assert } from "./assert.mjs";
 //#region src/function/work.ts
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);