@oscarpalmer/atoms 0.198.0 → 0.200.0

package/dist/array/flatten.d.mts

@@ -11,6 +11,6 @@ import { NestedArray } from "../models.mjs";
  * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
  * ```
  */
-declare function flatten<Item>(array: Item[]): NestedArray<Item>[];
+declare function flatten<Item>(array: Item[]): Array<NestedArray<Item>>;
 //#endregion
 export { flatten };

package/dist/array/from.d.mts

@@ -62,7 +62,7 @@ declare function times(length: number): number[];
  * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
  * ```
  */
-declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
+declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): Array<ReturnType<Callback>>;
 /**
  * Get an array with a specified length, filled with a specified value
  *

package/dist/array/group-by.d.mts

@@ -155,7 +155,7 @@ declare namespace groupBy {
  *    // }
  * ```
  */
-declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *
@@ -201,7 +201,7 @@ declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (it
  *    // }
  * ```
  */
-declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
+declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ValueCallback>>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *

package/dist/array/sort.d.mts

@@ -172,6 +172,8 @@ declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorters Sorters to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -181,6 +183,8 @@ declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>
 /**
  * Is the array sorted according to the sorter _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorter Sorter to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_

package/dist/array/to-map.d.mts

@@ -152,7 +152,7 @@ declare namespace toMap {
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a callback and value, grouping values into arrays
  *
@@ -192,7 +192,7 @@ declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
+declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a key and value, grouping values into arrays
  *

package/dist/array/to-record.d.mts

@@ -152,7 +152,7 @@ declare namespace toRecord {
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
  *
@@ -192,7 +192,7 @@ declare function toRecordArrays<Item extends PlainObject, Callback extends (item
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
+declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
  *

package/dist/beacon.mjs

@@ -1,6 +1,6 @@
 import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
-import { createSubscriptions, isSubscription } from "./internal/subscription.mjs";
+import { SUBSCRIPTION_NAME, isSubscription, subscriptions } from "./internal/subscription.mjs";
 //#region src/beacon.ts
 /**
 * Create a new beacon
@@ -14,8 +14,8 @@ function beacon(value, options) {
 		value,
 		active: true,
 		observable: void 0,
-		options: getBeaconOptions(options),
-		subscriptions: createSubscriptions({ property: beaconSubscription })
+		options: createBeaconOptions(options),
+		subscriptions: subscriptions({ property: beaconSubscription })
 	};
 	const instance = {
 		deactivate: () => finishBeacon(state, false),
@@ -40,28 +40,32 @@ function beacon(value, options) {
 	});
 	return Object.freeze(instance);
 }
-function finishBeacon(state, emit) {
-	if (!state.active) return;
-	state.active = false;
-	for (const [, observer] of state.subscriptions.state.values.to.any) if (emit) observer.complete?.();
-	state.subscriptions.clear();
-	state.observable?.deactivate();
-	state.observable = void 0;
-}
-function getBeaconOptions(input) {
+function createBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
 	return options;
 }
-function getObservable(state) {
-	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
-	state.observable ??= observeBeacon(state);
-	return state.observable;
-}
-function getObservableCallback(value) {
-	return typeof value === "function" ? value : noop;
+function createObservable(beacon) {
+	const state = {
+		beacon,
+		active: beacon.active
+	};
+	const instance = {
+		deactivate: () => {
+			state.active = false;
+		},
+		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
+	};
+	Object.defineProperties(instance, {
+		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
+		active: {
+			enumerable: true,
+			get: () => beacon.active && state.active
+		}
+	});
+	return Object.freeze(instance);
 }
-function getObserver(first, second, third) {
+function createObserver(first, second, third) {
 	let observer = { next: noop };
 	if (typeof first === "function") observer = {
 		error: getObservableCallback(second),
@@ -75,6 +79,22 @@ function getObserver(first, second, third) {
 	}
 	return observer;
 }
+function finishBeacon(state, emit) {
+	if (!state.active) return;
+	state.active = false;
+	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
+	state.subscriptions.clear();
+	state.observable?.deactivate();
+	state.observable = void 0;
+}
+function getObservable(state) {
+	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
+	state.observable ??= createObservable(state);
+	return state.observable;
+}
+function getObservableCallback(value) {
+	return typeof value === "function" ? value : noop;
+}
 /**
 * Is the value a beacon?
 *
@@ -105,29 +125,9 @@ function isBeaconSubscription(value) {
 function isObservable(value) {
 	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function observeBeacon(beacon) {
-	const state = {
-		beacon,
-		active: beacon.active
-	};
-	const instance = {
-		deactivate: () => {
-			state.active = false;
-		},
-		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
-	};
-	Object.defineProperties(instance, {
-		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
-		active: {
-			enumerable: true,
-			get: () => beacon.active && state.active
-		}
-	});
-	return Object.freeze(instance);
-}
 function subscribeToObservable(state, first, second, third) {
 	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
-	const observer = getObserver(first, second, third);
+	const observer = createObserver(first, second, third);
 	const [subscription] = state.beacon.subscriptions.create({
 		isActive: () => state.beacon.active && state.active,
 		value: observer
@@ -141,7 +141,7 @@ function updateBeacon(type, state, value, finish) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.subscriptions.state.values.to.any) observer[type]?.(value);
+	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
 	if (finish === true) finishBeacon(state, true);
 }
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
@@ -151,6 +151,9 @@ const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
-const beaconSubscription = { key: BEACON_PROPERTY };
+const beaconSubscription = {
+	key: BEACON_PROPERTY,
+	value: SUBSCRIPTION_NAME
+};
 //#endregion
 export { beacon, isBeacon, isBeaconSubscription, isObservable };

package/dist/color/instance.mjs

@@ -1,3 +1,4 @@
+import { SUBSCRIPTION_NAME } from "../internal/subscription.mjs";
 import { herald } from "../internal/herald.mjs";
 import { COLOR_PROPERTY, COLOR_TYPE } from "./constants.mjs";
 import { getAlpha } from "./misc/alpha.mjs";
@@ -31,22 +32,22 @@ function color(value) {
 			enumerable: true,
 			value: changes.events
 		},
-		hex: getColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
-		hexa: getColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
-		hsl: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
-		hsla: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
-		hwb: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
-		hwba: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
+		hex: createColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
+		hexa: createColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
+		hsl: createColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
+		hsla: createColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
+		hwb: createColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
+		hwba: createColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
-		rgba: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
+		rgb: createColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
+		rgba: createColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
 	});
 	return Object.freeze(instance);
 }
-function getColorProperty(space, color, state, changes, alpha) {
+function createColorProperty(space, color, state, changes, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
@@ -71,7 +72,10 @@ function onCreateSubscription(instance, event, callback) {
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
-const colorSubscription = { key: COLOR_PROPERTY.name };
+const colorSubscription = {
+	key: COLOR_PROPERTY.name,
+	value: SUBSCRIPTION_NAME
+};
 const setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,

package/dist/function/retry.mjs

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../internal/is.mjs";
+import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 //#region src/function/retry.ts
 /**
@@ -35,7 +36,7 @@ async function asyncRetry(callback, options) {
 			}
 		}
 	}
-	const { delay, times, when } = getRetryOptions(options);
+	const { delay, times, when } = createRetryOptions(options);
 	const timer = getTimer(TIMER_WAIT, handle, delay);
 	let attempts = 0;
 	let rejector;
@@ -46,14 +47,11 @@ async function asyncRetry(callback, options) {
 		handle();
 	});
 }
-function getRetryNumber(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
-function getRetryOptions(input) {
+function createRetryOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
-		delay: getRetryNumber(options.delay),
-		times: getRetryNumber(options.times),
+		delay: getNumberOrDefault(options.delay, 0),
+		times: getNumberOrDefault(options.times, 0),
 		when: typeof options.when === "function" ? options.when : shouldRetry
 	};
 }
@@ -66,7 +64,7 @@ function getRetryOptions(input) {
 */
 function retry(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
-	const { times, when } = getRetryOptions(options);
+	const { times, when } = createRetryOptions(options);
 	let last;
 	for (let index = 0; index <= times; index += 1) try {
 		return callback();