@oscarpalmer/atoms 0.202.0 → 0.204.0

package/dist/color/space/rgb.mjs

@@ -3,6 +3,7 @@ import { COLOR_DEFAULTS, COLOR_MAX, COLOR_TYPE } from "../constants.mjs";
 import { getAlpha, getAlphaValue } from "../misc/alpha.mjs";
 import { getHexValue } from "../misc/get.mjs";
 import { isRgbLike } from "../misc/is.mjs";
+import { getStateValue, setStateValue } from "../misc/state.mjs";
 //#region src/color/space/rgb.ts
 function convertRgbToHex(rgb, alpha) {
 	const hex = `${join([
@@ -18,7 +19,7 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	const lightness = (min + max) / 2;
 	let hue = 0;
@@ -36,7 +37,7 @@ function convertRgbToHsla(value) {
 	};
 }
 function convertRgbToHwba(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	let hue = 0;
 	if (delta !== 0) {
@@ -62,22 +63,7 @@ function getColorFromRgb(state, type) {
 	}
 	return state[type];
 }
-function getRgbHue(values) {
-	const { blue, delta, green, max, red } = values;
-	switch (max) {
-		case blue: return (red - green) / delta + 4;
-		case green: return (blue - red) / delta + 2;
-		default: return (green - blue) / delta + (green < blue ? 6 : 0);
-	}
-}
-function getRgbValue(value) {
-	return {
-		blue: getHexValue(value.blue),
-		green: getHexValue(value.green),
-		red: getHexValue(value.red)
-	};
-}
-function getRgbValues(rgb) {
+function getRgbCalculationValues(rgb) {
 	const blue = rgb.blue / COLOR_MAX.hex;
 	const green = rgb.green / COLOR_MAX.hex;
 	const red = rgb.red / COLOR_MAX.hex;
@@ -92,6 +78,27 @@ function getRgbValues(rgb) {
 		red
 	};
 }
+function getRgbColor() {
+	return getStateValue(this, COLOR_TYPE.rgb, false);
+}
+function getRgbaColor() {
+	return getStateValue(this, COLOR_TYPE.rgb, true);
+}
+function getRgbHue(values) {
+	const { blue, delta, green, max, red } = values;
+	switch (max) {
+		case blue: return (red - green) / delta + 4;
+		case green: return (blue - red) / delta + 2;
+		default: return (green - blue) / delta + (green < blue ? 6 : 0);
+	}
+}
+function getRgbValues(value) {
+	return {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+}
 /**
 * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
 *
@@ -102,7 +109,7 @@ function getRgbValues(rgb) {
 * @returns Hex color string
 */
 function rgbToHex(rgb, alpha) {
-	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValues(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
 }
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
@@ -166,5 +173,19 @@ function rgbToHwb(rgb) {
 function rgbToHwba(rgb) {
 	return convertRgbToHwba(rgb);
 }
+function setRgbValue(value) {
+	setRgbColorValueInState(this, value, false);
+}
+function setRgbColorValueInState(instance, value, alpha) {
+	if (!isRgbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.rgb, {
+		red: getHexValue(value.red),
+		green: getHexValue(value.green),
+		blue: getHexValue(value.blue)
+	}, alpha ? value.alpha : void 0);
+}
+function setRgbaValue(value) {
+	setRgbColorValueInState(this, value, true);
+}
 //#endregion
-export { convertRgbToHex, convertRgbToHsla, convertRgbToHwba, getColorFromRgb, getRgbValue, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba };
+export { convertRgbToHex, convertRgbToHsla, convertRgbToHwba, getColorFromRgb, getRgbColor, getRgbValues, getRgbaColor, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, setRgbValue, setRgbaValue };

package/dist/function/limit.d.mts

@@ -1,4 +1,5 @@
-import { AsyncCancelableCallback, CancelableCallback, GenericAsyncCallback, GenericCallback } from "../models.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../models.mjs";
+import { AsyncLimiter, Limiter } from "../internal/function/limit.mjs";
 //#region src/function/limit.d.ts
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -12,7 +13,7 @@ import { AsyncCancelableCallback, CancelableCallback, GenericAsyncCallback, Gene
  * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
  * @returns Debounced callback handler with a `cancel` method
  */
-declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncCancelableCallback<Callback>;
+export declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncLimiter<Callback>;
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  *
@@ -25,7 +26,7 @@ declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCa
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
  * @returns Throttled callback handler with a `cancel` method
  */
-declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncCancelableCallback<Callback>;
+export declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncLimiter<Callback>;
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
  *
@@ -35,8 +36,8 @@ declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCa
  * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
  * @returns Debounced callback handler with a `cancel` method
  */
-declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
-declare namespace debounce {
+export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
+export declare namespace debounce {
   var async: typeof asyncDebounce;
 }
 /**
@@ -46,9 +47,9 @@ declare namespace debounce {
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
  * @returns Throttled callback handler with a `cancel` method
  */
-declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
-declare namespace throttle {
+export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
+export declare namespace throttle {
   var async: typeof asyncThrottle;
 }
 //#endregion
-export { asyncDebounce, asyncThrottle, debounce, throttle };
+export type { AsyncLimiter, Limiter };

package/dist/function/limit.mjs

@@ -1,4 +1,4 @@
-import { TIMER_DEBOUNCE, TIMER_THROTTLE, getAsyncTimer, getTimer } from "../internal/function/timer.mjs";
+import { LIMITER_DEBOUNCE, LIMITER_THROTTLE, getAsyncLimiter, getLimiter } from "../internal/function/limit.mjs";
 //#region src/function/limit.ts
 /**
 * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -13,7 +13,7 @@ import { TIMER_DEBOUNCE, TIMER_THROTTLE, getAsyncTimer, getTimer } from "../inte
 * @returns Debounced callback handler with a `cancel` method
 */
 function asyncDebounce(callback, time) {
-	return getAsyncTimer(TIMER_DEBOUNCE, callback, time);
+	return getAsyncLimiter(LIMITER_DEBOUNCE, callback, time);
 }
 /**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
@@ -28,7 +28,7 @@ function asyncDebounce(callback, time) {
 * @returns Throttled callback handler with a `cancel` method
 */
 function asyncThrottle(callback, time) {
-	return getAsyncTimer(TIMER_THROTTLE, callback, time);
+	return getAsyncLimiter(LIMITER_THROTTLE, callback, time);
 }
 /**
 * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -40,7 +40,7 @@ function asyncThrottle(callback, time) {
 * @returns Debounced callback handler with a `cancel` method
 */
 function debounce(callback, time) {
-	return getTimer(TIMER_DEBOUNCE, callback, time);
+	return getLimiter(LIMITER_DEBOUNCE, callback, time);
 }
 /**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
@@ -50,11 +50,9 @@ function debounce(callback, time) {
 * @returns Throttled callback handler with a `cancel` method
 */
 function throttle(callback, time) {
-	return getTimer(TIMER_THROTTLE, callback, time);
+	return getLimiter(LIMITER_THROTTLE, callback, time);
 }
 debounce.async = asyncDebounce;
 throttle.async = asyncThrottle;
-Object.defineProperty(debounce, "async", { value: asyncDebounce });
-Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
 export { asyncDebounce, asyncThrottle, debounce, throttle };

package/dist/function/once.d.mts

@@ -1,5 +1,7 @@
-import { GenericAsyncCallback, GenericCallback, OnceAsyncCallback, OnceCallback } from "../models.mjs";
+import { GenericAsyncCallback, GenericCallback, Once, OnceAsync } from "../models.mjs";
 //#region src/function/once.d.ts
+declare function OnceAsync(this: any, callback: GenericAsyncCallback): void;
+declare function Once(this: any, callback: GenericCallback): void;
 /**
  * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
  *
@@ -8,16 +10,34 @@ import { GenericAsyncCallback, GenericCallback, OnceAsyncCallback, OnceCallback
  * @param callback Callback to use once
  * @returns _Once_ callback
  */
-declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsyncCallback<Callback>;
+export declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsync<Callback>;
+export declare namespace asyncOnce {
+  var is: typeof isAsyncOnce;
+}
+/**
+ * Is the value an asynchronous once callback?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous once callback, otherwise `false`
+ */
+export declare function isAsyncOnce(value: unknown): boolean;
+/**
+ * Is the value a once callback?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a once callback, otherwise `false`
+ */
+export declare function isOnce(value: unknown): boolean;
 /**
  * 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
  */
-declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
-declare namespace once {
+export declare function once<Callback extends GenericCallback>(callback: Callback): Once<Callback>;
+export declare namespace once {
   var async: typeof asyncOnce;
+  var is: typeof isOnce;
+  var isAsync: typeof isAsyncOnce;
 }
-//#endregion
-export { asyncOnce, once };
+//#endregion

package/dist/function/once.mjs

@@ -1,5 +1,61 @@
 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) {
+	this[ONCE_SYMBOL] = {
+		callback,
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	};
+}
+AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
+AsyncOnce.prototype.clear = clearOnce;
+AsyncOnce.prototype.run = runOnceAsync;
+Object.defineProperties(AsyncOnce.prototype, {
+	called: {
+		enumerable: true,
+		get: getOnceCalled
+	},
+	cleared: {
+		enumerable: true,
+		get: getOnceCleared
+	},
+	error: {
+		enumerable: true,
+		get: getAsyncOnceError
+	},
+	finished: {
+		enumerable: true,
+		get: getAsyncOnceFinished
+	}
+});
+function Once(callback) {
+	this[ONCE_SYMBOL] = {
+		callback,
+		called: false,
+		cleared: false,
+		value: void 0
+	};
+}
+Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
+Once.prototype.clear = clearOnce;
+Once.prototype.run = runOnce;
+Object.defineProperties(Once.prototype, {
+	called: {
+		enumerable: true,
+		get: getOnceCalled
+	},
+	cleared: {
+		enumerable: true,
+		get: getOnceCleared
+	}
+});
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
 *
@@ -10,62 +66,27 @@ 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;
 }
+function getAsyncOnceError() {
+	return this[ONCE_SYMBOL].error;
+}
+function getAsyncOnceFinished() {
+	return this[ONCE_SYMBOL].finished;
+}
+function getOnceCalled() {
+	return this[ONCE_SYMBOL].called;
+}
+function getOnceCleared() {
+	return this[ONCE_SYMBOL].cleared;
+}
 function handleOnceResult(state, value, error) {
 	state.error = error;
 	state.finished = true;
@@ -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,45 @@ 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;
 //#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;
@@ -83,6 +83,5 @@ const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
-Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 export { RetryError, retry };