@oscarpalmer/atoms 0.117.0 → 0.118.0

package/dist/array/get.js

@@ -1,6 +1,7 @@
 import { isPlainObject } from "../internal/is.js";
 function getArray(value, indiced) {
 	if (Array.isArray(value)) return value;
+	if (value instanceof Map || value instanceof Set) return [...value.values()];
 	if (!isPlainObject(value)) return [value];
 	if (indiced !== true) return Object.values(value);
 	const keys = Object.keys(value);

package/dist/array/sort.js

@@ -1,6 +1,5 @@
 import { isPlainObject } from "../internal/is.js";
 import { compare } from "../internal/value/compare.js";
-import "../is.js";
 function getCallback(value, key, forObject) {
 	if (key != null) return;
 	if (forObject && typeof value.value === "function") return value.value;

package/dist/atoms.full.js

@@ -178,6 +178,7 @@ function flatten(array) {
 }
 function getArray(value, indiced) {
 	if (Array.isArray(value)) return value;
+	if (value instanceof Map || value instanceof Set) return [...value.values()];
 	if (!isPlainObject(value)) return [value];
 	if (indiced !== true) return Object.values(value);
 	const keys = Object.keys(value);
@@ -354,32 +355,6 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
-function isEmpty(value) {
-	const values = Object.values(value);
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) if (values[index] != null) return false;
-	return true;
-}
-function isNullable(value) {
-	return value == null;
-}
-function isNullableOrEmpty(value) {
-	return value == null || getString(value) === "";
-}
-function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
-}
-function isNumerical(value) {
-	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null || typeof value === "function";
-}
-function isPrimitive(value) {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
-}
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
-const EXPRESSION_WHITESPACE = /^\s*$/;
 function getCallback(value, key, forObject) {
 	if (key != null) return;
 	if (forObject && typeof value.value === "function") return value.value;
@@ -476,18 +451,21 @@ function unique(array, key) {
 }
 function noop() {}
 var Beacon = class {
+	#options;
 	#state;
 	get active() {
 		return this.#state.active;
 	}
 	get observable() {
+		if (!this.#state.active) throw new Error(DESTROYED_BEACON);
 		return this.#state.observable;
 	}
 	get value() {
 		return this.#state.value;
 	}
-	constructor(value) {
+	constructor(value, options) {
 		const observers = /* @__PURE__ */ new Map();
+		this.#options = getBeaconOptions(options);
 		this.#state = {
 			observers,
 			value,
@@ -499,28 +477,30 @@ var Beacon = class {
 		finishBeacon(this.#state, false);
 	}
 	emit(value, finish) {
-		this.#on("next", finish ?? false, value);
+		this.#on("next", value, finish);
 	}
 	error(error, finish) {
-		this.#on("error", finish ?? false, error);
+		this.#on("error", error, finish);
 	}
 	finish() {
 		finishBeacon(this.#state, true);
 	}
-	#on(type, finish, value) {
-		if (this.#state.active) {
-			if (type === "next") this.#state.value = value;
-			for (const [, observer] of this.#state.observers) observer[type]?.(value);
-			if (finish === true) finishBeacon(this.#state, true);
+	#on(type, value, finish) {
+		if (!this.#state.active) return;
+		if (type === "next") {
+			if (this.#options.equal(this.#state.value, value)) return;
+			this.#state.value = value;
 		}
+		for (const [, observer] of this.#state.observers) observer[type]?.(value);
+		if (finish === true) finishBeacon(this.#state, true);
 	}
 };
 var Observable = class {
 	#state;
-	constructor(emitter, observers) {
+	constructor(instance, observers) {
 		this.#state = {
 			observers,
-			beacon: emitter,
+			beacon: instance,
 			closed: false
 		};
 	}
@@ -528,7 +508,7 @@ var Observable = class {
 		this.#state.closed = true;
 	}
 	subscribe(first, second, third) {
-		if (this.#state.closed) throw new Error("Cannot subscribe to a destroyed observable");
+		if (this.#state.closed) throw new Error(DESTROYED_OBSERVABLE);
 		const observer = getObserver(first, second, third);
 		const instance = new Subscription(this.#state);
 		this.#state.observers.set(instance, observer);
@@ -557,40 +537,46 @@ var Subscription = class {
 		}
 	}
 };
-function beacon(value) {
-	return new Beacon(value);
+function beacon(value, options) {
+	return new Beacon(value, options);
 }
 function finishBeacon(state, emit) {
-	if (state.active) {
-		state.active = false;
-		const entries = [...state.observers.entries()];
-		const { length } = entries;
-		for (let index = 0; index < length; index += 1) {
-			const [subscription, observer] = entries[index];
-			if (emit) observer.complete?.();
-			subscription.destroy();
-		}
-		state.observable?.destroy();
-		state.observers.clear();
+	if (!state.active) return;
+	state.active = false;
+	const entries = [...state.observers.entries()];
+	const { length } = entries;
+	for (let index = 0; index < length; index += 1) {
+		const [subscription, observer] = entries[index];
+		if (emit) observer.complete?.();
+		subscription.destroy();
 	}
+	state.observable?.destroy();
+	state.observers.clear();
+}
+function getBeaconOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
+	return options;
 }
-function getFunction(value, defaultValue) {
-	return typeof value === "function" ? value : defaultValue;
+function getObservableCallback(value) {
+	return typeof value === "function" ? value : noop;
 }
 function getObserver(first, second, third) {
 	let observer = { next: noop };
 	if (typeof first === "function") observer = {
-		error: getFunction(second, noop),
-		next: getFunction(first, noop),
-		complete: getFunction(third, noop)
+		error: getObservableCallback(second),
+		next: getObservableCallback(first),
+		complete: getObservableCallback(third)
 	};
 	else if (typeof first === "object") {
-		observer.complete = getFunction(first?.complete, noop);
-		observer.error = getFunction(first?.error, noop);
-		observer.next = getFunction(first?.next, noop);
+		observer.complete = getObservableCallback(first?.complete);
+		observer.error = getObservableCallback(first?.error);
+		observer.next = getObservableCallback(first?.next);
 	}
 	return observer;
 }
+const DESTROYED_BEACON = "Cannot retrieve observable from a destroyed beacon";
+const DESTROYED_OBSERVABLE = "Cannot subscribe to a destroyed observable";
 const ALPHA_FULL_HEX_SHORT = "f";
 const ALPHA_FULL_HEX_LONG = `${ALPHA_FULL_HEX_SHORT}${ALPHA_FULL_HEX_SHORT}`;
 const ALPHA_FULL_VALUE = 1;
@@ -1287,6 +1273,34 @@ function throttle(callback, time) {
 	return throttler;
 }
 const DEFAULT_CACHE_SIZE = 65536;
+function isEmpty(value) {
+	if (value == null) return true;
+	if (typeof value === "string") return value.length === 0;
+	const values = getArray(value);
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) if (values[index] != null) return false;
+	return true;
+}
+function isNullable(value) {
+	return value == null;
+}
+function isNullableOrEmpty(value) {
+	return value == null || getString(value) === "";
+}
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+}
+function isNumerical(value) {
+	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPrimitive(value) {
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+}
+const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
+const EXPRESSION_WHITESPACE = /^\s*$/;
 let enabled = true;
 var Logger = class {
 	get debug() {

package/dist/beacon.js

@@ -1,17 +1,21 @@
+import { isPlainObject } from "./internal/is.js";
 import { noop } from "./internal/function.js";
 var Beacon = class {
+	#options;
 	#state;
 	get active() {
 		return this.#state.active;
 	}
 	get observable() {
+		if (!this.#state.active) throw new Error(DESTROYED_BEACON);
 		return this.#state.observable;
 	}
 	get value() {
 		return this.#state.value;
 	}
-	constructor(value) {
+	constructor(value, options) {
 		const observers = /* @__PURE__ */ new Map();
+		this.#options = getBeaconOptions(options);
 		this.#state = {
 			observers,
 			value,
@@ -23,28 +27,30 @@ var Beacon = class {
 		finishBeacon(this.#state, false);
 	}
 	emit(value, finish) {
-		this.#on("next", finish ?? false, value);
+		this.#on("next", value, finish);
 	}
 	error(error, finish) {
-		this.#on("error", finish ?? false, error);
+		this.#on("error", error, finish);
 	}
 	finish() {
 		finishBeacon(this.#state, true);
 	}
-	#on(type, finish, value) {
-		if (this.#state.active) {
-			if (type === "next") this.#state.value = value;
-			for (const [, observer] of this.#state.observers) observer[type]?.(value);
-			if (finish === true) finishBeacon(this.#state, true);
+	#on(type, value, finish) {
+		if (!this.#state.active) return;
+		if (type === "next") {
+			if (this.#options.equal(this.#state.value, value)) return;
+			this.#state.value = value;
 		}
+		for (const [, observer] of this.#state.observers) observer[type]?.(value);
+		if (finish === true) finishBeacon(this.#state, true);
 	}
 };
 var Observable = class {
 	#state;
-	constructor(emitter, observers) {
+	constructor(instance, observers) {
 		this.#state = {
 			observers,
-			beacon: emitter,
+			beacon: instance,
 			closed: false
 		};
 	}
@@ -52,7 +58,7 @@ var Observable = class {
 		this.#state.closed = true;
 	}
 	subscribe(first, second, third) {
-		if (this.#state.closed) throw new Error("Cannot subscribe to a destroyed observable");
+		if (this.#state.closed) throw new Error(DESTROYED_OBSERVABLE);
 		const observer = getObserver(first, second, third);
 		const instance = new Subscription(this.#state);
 		this.#state.observers.set(instance, observer);
@@ -81,38 +87,44 @@ var Subscription = class {
 		}
 	}
 };
-function beacon(value) {
-	return new Beacon(value);
+function beacon(value, options) {
+	return new Beacon(value, options);
 }
 function finishBeacon(state, emit) {
-	if (state.active) {
-		state.active = false;
-		const entries = [...state.observers.entries()];
-		const { length } = entries;
-		for (let index = 0; index < length; index += 1) {
-			const [subscription, observer] = entries[index];
-			if (emit) observer.complete?.();
-			subscription.destroy();
-		}
-		state.observable?.destroy();
-		state.observers.clear();
-	}
+	if (!state.active) return;
+	state.active = false;
+	const entries = [...state.observers.entries()];
+	const { length } = entries;
+	for (let index = 0; index < length; index += 1) {
+		const [subscription, observer] = entries[index];
+		if (emit) observer.complete?.();
+		subscription.destroy();
+	}
+	state.observable?.destroy();
+	state.observers.clear();
+}
+function getBeaconOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
+	return options;
 }
-function getFunction(value, defaultValue) {
-	return typeof value === "function" ? value : defaultValue;
+function getObservableCallback(value) {
+	return typeof value === "function" ? value : noop;
 }
 function getObserver(first, second, third) {
 	let observer = { next: noop };
 	if (typeof first === "function") observer = {
-		error: getFunction(second, noop),
-		next: getFunction(first, noop),
-		complete: getFunction(third, noop)
+		error: getObservableCallback(second),
+		next: getObservableCallback(first),
+		complete: getObservableCallback(third)
 	};
 	else if (typeof first === "object") {
-		observer.complete = getFunction(first?.complete, noop);
-		observer.error = getFunction(first?.error, noop);
-		observer.next = getFunction(first?.next, noop);
+		observer.complete = getObservableCallback(first?.complete);
+		observer.error = getObservableCallback(first?.error);
+		observer.next = getObservableCallback(first?.next);
 	}
 	return observer;
 }
+var DESTROYED_BEACON = "Cannot retrieve observable from a destroyed beacon";
+var DESTROYED_OBSERVABLE = "Cannot subscribe to a destroyed observable";
 export { beacon };

package/dist/index.js

@@ -15,7 +15,6 @@ import { push } from "./array/push.js";
 import { max } from "./internal/math/aggregate.js";
 import { getString, join, words } from "./internal/string.js";
 import { compare } from "./internal/value/compare.js";
-import { isEmpty, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
 import { sort } from "./array/sort.js";
 import { splice } from "./array/splice.js";
 import { toMap } from "./array/to-map.js";
@@ -36,6 +35,7 @@ import { getColor } from "./color/index.js";
 import frame_rate_default from "./internal/frame-rate.js";
 import { SizedMap, SizedSet } from "./sized.js";
 import { debounce, memoize, throttle } from "./function.js";
+import { isEmpty, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
 import { logger } from "./logger.js";
 import { average, count, min, round, sum } from "./math.js";
 import { setValue } from "./internal/value/set.js";

package/dist/is.js

@@ -1,7 +1,10 @@
 import { isArrayOrPlainObject, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
+import { getArray } from "./array/get.js";
 import { getString } from "./internal/string.js";
 function isEmpty(value) {
-	const values = Object.values(value);
+	if (value == null) return true;
+	if (typeof value === "string") return value.length === 0;
+	const values = getArray(value);
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) if (values[index] != null) return false;
 	return true;

package/package.json

@@ -10,7 +10,7 @@
 		"jsdom": "^27.3",
 		"oxfmt": "^0.19",
 		"oxlint": "^1.34",
-		"rolldown": "1.0.0-beta.55",
+		"rolldown": "1.0.0-beta.56",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
 		"vite": "8.0.0-beta.2",
@@ -101,5 +101,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.117.0"
+	"version": "0.118.0"
 }

package/src/array/get.ts

@@ -45,6 +45,10 @@ export function getArray(value: unknown, indiced?: unknown): unknown[] {
 		return value;
 	}
 
+	if (value instanceof Map || value instanceof Set) {
+		return [...value.values()];
+	}
+
 	if (!isPlainObject(value)) {
 		return [value];
 	}

package/src/array/sort.ts

@@ -1,5 +1,5 @@
 import {compare} from '../internal/value/compare';
-import {isPlainObject} from '../is';
+import {isPlainObject} from '../internal/is';
 import type {GenericCallback, PlainObject, Primitive} from '../models';
 import type {CallbackSorter, KeySorter} from './models';
 

package/src/beacon.ts

@@ -1,6 +1,9 @@
 import {noop} from './internal/function';
+import {isPlainObject} from './internal/is';
+import type {PlainObject} from './models';
 
 class Beacon<Value> {
+	readonly #options: Options;
 	readonly #state: BeaconState<Value>;
 
 	/**
@@ -14,6 +17,10 @@ class Beacon<Value> {
 	 * The observable that can be subscribed to
 	 */
 	get observable(): Observable<Value> {
+		if (!this.#state.active) {
+			throw new Error(DESTROYED_BEACON);
+		}
+
 		return this.#state.observable;
 	}
 
@@ -24,9 +31,11 @@ class Beacon<Value> {
 		return this.#state.value;
 	}
 
-	constructor(value: Value) {
+	constructor(value: Value, options?: BeaconOptions<Value>) {
 		const observers = new Map<Subscription<Value>, Observer<Value>>();
 
+		this.#options = getBeaconOptions(options);
+
 		this.#state = {
 			observers,
 			value,
@@ -48,7 +57,7 @@ class Beacon<Value> {
 	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
 	 */
 	emit(value: Value, finish?: boolean): void {
-		this.#on('next', finish ?? false, value);
+		this.#on('next', value, finish);
 	}
 
 	/**
@@ -57,7 +66,7 @@ class Beacon<Value> {
 	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
 	 */
 	error(error: Error, finish?: boolean): void {
-		this.#on('error', finish ?? false, error);
+		this.#on('error', error, finish);
 	}
 
 	/**
@@ -67,23 +76,40 @@ class Beacon<Value> {
 		finishBeacon(this.#state, true);
 	}
 
-	#on(type: keyof Observer<never>, finish: boolean, value: Error | Value): void {
-		if (this.#state.active) {
-			if (type === 'next') {
-				this.#state.value = value as Value;
-			}
+	#on(type: keyof Observer<never>, value: Error | Value, finish?: boolean): void {
+		if (!this.#state.active) {
+			return;
+		}
 
-			for (const [, observer] of this.#state.observers) {
-				observer[type]?.(value as never);
+		if (type === 'next') {
+			if (this.#options.equal(this.#state.value, value as Value)) {
+				return;
 			}
 
-			if (finish === true) {
-				finishBeacon(this.#state, true);
-			}
+			this.#state.value = value as Value;
+		}
+
+		for (const [, observer] of this.#state.observers) {
+			observer[type]?.(value as never);
+		}
+
+		if (finish === true) {
+			finishBeacon(this.#state, true);
 		}
 	}
 }
 
+type BeaconOptions<Value> = {
+	/**
+	 * Method for comparing values for equality
+	 * @param first First value
+	 * @param second Second value
+	 * @returns `true` if the values are equal, otherwise `false`
+	 * @default Object.is
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+
 type BeaconState<Value> = {
 	active: boolean;
 	observable: Observable<Value>;
@@ -94,10 +120,10 @@ type BeaconState<Value> = {
 class Observable<Value> {
 	readonly #state: ObservableState<Value>;
 
-	constructor(emitter: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>) {
+	constructor(instance: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>) {
 		this.#state = {
 			observers,
-			beacon: emitter,
+			beacon: instance,
 			closed: false,
 		};
 	}
@@ -135,7 +161,7 @@ class Observable<Value> {
 		third?: () => void,
 	): Subscription<Value> {
 		if (this.#state.closed) {
-			throw new Error('Cannot subscribe to a destroyed observable');
+			throw new Error(DESTROYED_OBSERVABLE);
 		}
 
 		const observer = getObserver(first, second, third);
@@ -170,6 +196,8 @@ type Observer<Value> = {
 	next?: (value: Value) => void;
 };
 
+type Options = Required<BeaconOptions<unknown>>;
+
 class Subscription<Value> {
 	readonly #state: SubscriptionState<Value>;
 
@@ -214,40 +242,53 @@ type SubscriptionState<Value> = {
 	observers: Map<Subscription<Value>, Observer<Value>>;
 };
 
+//
+
 /**
  * Create a new beacon
  * @param value Initial value
+ * @param options Beacon options
  * @returns Beacon instance
  */
-export function beacon<Value>(value: Value): Beacon<Value> {
-	return new Beacon(value);
+export function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value> {
+	return new Beacon(value, options);
 }
 
 function finishBeacon<Value>(state: BeaconState<Value>, emit: boolean): void {
-	if (state.active) {
-		state.active = false;
+	if (!state.active) {
+		return;
+	}
 
-		const entries = [...state.observers.entries()];
-		const {length} = entries;
+	state.active = false;
 
-		for (let index = 0; index < length; index += 1) {
-			const [subscription, observer] = entries[index];
+	const entries = [...state.observers.entries()];
+	const {length} = entries;
 
-			if (emit) {
-				observer.complete?.();
-			}
+	for (let index = 0; index < length; index += 1) {
+		const [subscription, observer] = entries[index];
 
-			subscription.destroy();
+		if (emit) {
+			observer.complete?.();
 		}
 
-		state.observable?.destroy();
-
-		state.observers.clear();
+		subscription.destroy();
 	}
+
+	state.observable?.destroy();
+
+	state.observers.clear();
 }
 
-function getFunction<Callback>(value: Callback, defaultValue: Callback): Callback {
-	return typeof value === 'function' ? value : defaultValue;
+function getBeaconOptions(input?: BeaconOptions<never>): Options {
+	const options: Partial<Options> = isPlainObject(input) ? (input as PlainObject) : {};
+
+	options.equal = typeof options.equal === 'function' ? options.equal : Object.is;
+
+	return options as Options;
+}
+
+function getObservableCallback<Callback>(value: Callback): Callback {
+	return typeof value === 'function' ? value : (noop as Callback);
 }
 
 function getObserver<Value>(
@@ -261,17 +302,23 @@ function getObserver<Value>(
 
 	if (typeof first === 'function') {
 		observer = {
-			error: getFunction(second, noop),
-			next: getFunction(first, noop),
-			complete: getFunction(third, noop),
+			error: getObservableCallback(second),
+			next: getObservableCallback(first),
+			complete: getObservableCallback(third),
 		};
 	} else if (typeof first === 'object') {
-		observer.complete = getFunction(first?.complete, noop);
-		observer.error = getFunction(first?.error, noop);
-		observer.next = getFunction(first?.next, noop);
+		observer.complete = getObservableCallback(first?.complete);
+		observer.error = getObservableCallback(first?.error);
+		observer.next = getObservableCallback(first?.next);
 	}
 
 	return observer;
 }
 
+//
+
+const DESTROYED_BEACON = 'Cannot retrieve observable from a destroyed beacon';
+
+const DESTROYED_OBSERVABLE = 'Cannot subscribe to a destroyed observable';
+
 export type {Beacon, Observable, Observer, Subscription};

package/src/internal/math/aggregate.ts

@@ -1,4 +1,4 @@
-import type {GenericCallback, PlainObject} from '../../models';
+import type {GenericCallback, NumericalValues, PlainObject} from '../../models';
 
 type Aggregation = {
 	count: number;
@@ -9,13 +9,6 @@ type AggregationCallback = (current: number, value: number, notNumber: boolean)
 
 type AggregationType = 'average' | 'max' | 'min' | 'sum';
 
-/**
- * The numerical values of an object
- */
-export type OnlyNumericalKeys<Item> = {
-	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
-};
-
 export function aggregate(type: AggregationType, array: unknown[], key: unknown): Aggregation {
 	const length = Array.isArray(array) ? array.length : 0;
 
@@ -73,7 +66,7 @@ export function max<Item extends PlainObject>(
  */
 export function max<Item extends PlainObject>(
 	items: Item[],
-	key: keyof OnlyNumericalKeys<Item>,
+	key: keyof NumericalValues<Item>,
 ): number;
 
 /**

package/src/is.ts

@@ -1,14 +1,23 @@
+import {getArray} from './array/get';
 import {isNumber} from './internal/is';
 import {getString} from './internal/string';
-import type {ArrayOrPlainObject, Primitive} from './models';
+import type {Primitive} from './models';
 
 /**
- * Is the array or object completely empty, or only containing `null` or `undefined` values?
- * @param value Array or object to check
- * @returns `true` if the value is considered empty, otherwise `false`
+ * Is the value empty, or only containing `null` or `undefined` values?
+ * @param value Object to check
+ * @returns `true` if the object is considered empty, otherwise `false`
  */
-export function isEmpty(value: ArrayOrPlainObject): boolean {
-	const values = Object.values(value);
+export function isEmpty(value: unknown): boolean {
+	if (value == null) {
+		return true;
+	}
+
+	if (typeof value === 'string') {
+		return value.length === 0;
+	}
+
+	const values = getArray(value);
 	const {length} = values;
 
 	for (let index = 0; index < length; index += 1) {

package/src/math.ts

@@ -1,5 +1,5 @@
-import {aggregate, type OnlyNumericalKeys} from './internal/math/aggregate';
-import type {PlainObject} from './models';
+import {aggregate} from './internal/math/aggregate';
+import type {NumericalValues, PlainObject} from './models';
 
 /**
  * Get the average value from a list of items
@@ -20,7 +20,7 @@ export function average<Item extends PlainObject>(
  */
 export function average<Item extends PlainObject>(
 	items: Item[],
-	key: keyof OnlyNumericalKeys<Item>,
+	key: keyof NumericalValues<Item>,
 ): number;
 
 /**
@@ -119,7 +119,7 @@ export function min<Item extends PlainObject>(
  */
 export function min<Item extends PlainObject>(
 	items: Item[],
-	key: keyof OnlyNumericalKeys<Item>,
+	key: keyof NumericalValues<Item>,
 ): number;
 
 /**
@@ -174,7 +174,7 @@ export function sum<Item extends PlainObject>(
  */
 export function sum<Item extends PlainObject>(
 	items: Item[],
-	key: keyof OnlyNumericalKeys<Item>,
+	key: keyof NumericalValues<Item>,
 ): number;
 
 /**
@@ -190,4 +190,5 @@ export function sum(array: unknown[], key?: unknown): number {
 	return aggregated.count > 0 ? aggregated.value : Number.NaN;
 }
 
-export {max, type OnlyNumericalKeys} from './internal/math/aggregate';
+export {max} from './internal/math/aggregate';
+export type {NumericalValues}

package/src/models.ts

@@ -38,6 +38,9 @@ export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends Propert
 export type NestedArray<Value> =
 	Value extends Array<infer NestedValue> ? NestedArray<NestedValue> : Value;
 
+/**
+ * All nested keys of an object as dot notation strings _(up to 5 levels deep)_
+ */
 export type NestedKeys<Value extends PlainObject> = _NestedKeys<Value>;
 
 type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0
@@ -47,11 +50,9 @@ type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0
 			? // Tuple: extract actual indices
 				{
 					[Key in keyof Value]-?: Key extends `${number}`
-						? Value[Key] extends readonly any[]
-							? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}`
-							: Value[Key] extends PlainObject
-								? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}`
-								: `${Key}`
+						? NonNullable<Value[Key]> extends readonly any[] | PlainObject
+							? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}`
+							: `${Key}`
 						: never;
 				}[number]
 			: // Array: use no indices
@@ -59,11 +60,9 @@ type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0
 		: Value extends PlainObject
 			? {
 					[Key in keyof Value]-?: Key extends number | string
-						? Value[Key] extends readonly any[]
-							? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}`
-							: Value[Key] extends PlainObject
-								? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}`
-								: `${Key}`
+						? NonNullable<Value[Key]> extends readonly any[] | PlainObject
+							? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}`
+							: `${Key}`
 						: never;
 				}[keyof Value]
 			: never;
@@ -75,30 +74,43 @@ export type NestedPartial<T> = {
 	[K in keyof T]?: T[K] extends object ? NestedPartial<T[K]> : T[K];
 };
 
-export type NestedValue<Value extends PlainObject, Path extends string> = Simplify<
-	_NestedValue<Value, Path>
->;
-
-export type _NestedValue<Value, Path extends string> = Path extends keyof Value
-	? Value[Path]
-	: Path extends `${infer Key}.${infer Rest}`
-		? Key extends keyof Value
-			? _NestedValue<Value[Key], Rest>
-			: Key extends `${number}`
-				? Value extends readonly any[]
-					? _NestedValue<Value[number], Rest>
-					: never
-				: never
-		: Path extends `${number}`
+/**
+ * The value for a nested key of an object
+ */
+export type NestedValue<Value extends PlainObject, Path extends string> = _NestedValue<Value, Path>;
+
+type _NestedValue<Value, Path extends string> = Path extends `${infer Key}.${infer Rest}`
+	? Key extends keyof Value
+		? undefined extends Value[Key]
+			? _NestedValue<Exclude<Value[Key], undefined>, Rest> | undefined
+			: _NestedValue<Value[Key], Rest>
+		: Key extends `${number}`
 			? Value extends readonly any[]
-				? Value[number]
+				? _NestedValue<Value[number], Rest>
 				: never
+			: never
+	: Path extends `${number}`
+		? Value extends readonly any[]
+			? Value[number]
+			: never
+		: Path extends keyof Value
+			? Value[Path]
 			: never;
 
+/**
+ * The nested (keyed) values of an object _(up to 5 levels deep)_
+ */
 export type NestedValues<Value extends PlainObject> = {
 	[Path in NestedKeys<Value>]: NestedValue<Value, Path>;
 };
 
+/**
+ * The numerical values of an object
+ */
+export type NumericalValues<Item extends PlainObject> = {
+	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
+
 /**
  * A generic object
  */

package/src/sized.ts

@@ -206,6 +206,6 @@ function getMaximum(first?: unknown, second?: unknown): number {
 
 //
 
-const MAXIMUM_ABSOLUTE = 16_777_216;
+const MAXIMUM_ABSOLUTE = 16_777_216; // 2^24
 
-const MAXIMUM_DEFAULT = 1_048_576;
+const MAXIMUM_DEFAULT = 1_048_576; // 2^20

package/types/beacon.d.ts

@@ -12,7 +12,7 @@ declare class Beacon<Value> {
      * The current value
      */
     get value(): Value;
-    constructor(value: Value);
+    constructor(value: Value, options?: BeaconOptions<Value>);
     /**
      * Destroy the beacon
      */
@@ -34,9 +34,19 @@ declare class Beacon<Value> {
      */
     finish(): void;
 }
+type BeaconOptions<Value> = {
+    /**
+     * Method for comparing values for equality
+     * @param first First value
+     * @param second Second value
+     * @returns `true` if the values are equal, otherwise `false`
+     * @default Object.is
+     */
+    equal?: (first: Value, second: Value) => boolean;
+};
 declare class Observable<Value> {
     #private;
-    constructor(emitter: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>);
+    constructor(instance: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>);
     /**
      * Destroy the observable
      */
@@ -94,7 +104,8 @@ declare class Subscription<Value> {
 /**
  * Create a new beacon
  * @param value Initial value
+ * @param options Beacon options
  * @returns Beacon instance
  */
-export declare function beacon<Value>(value: Value): Beacon<Value>;
+export declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value>;
 export type { Beacon, Observable, Observer, Subscription };

package/types/internal/math/aggregate.d.ts

@@ -1,15 +1,9 @@
-import type { PlainObject } from '../../models';
+import type { NumericalValues, PlainObject } from '../../models';
 type Aggregation = {
     count: number;
     value: number;
 };
 type AggregationType = 'average' | 'max' | 'min' | 'sum';
-/**
- * The numerical values of an object
- */
-export type OnlyNumericalKeys<Item> = {
-    [Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
-};
 export declare function aggregate(type: AggregationType, array: unknown[], key: unknown): Aggregation;
 /**
  * Get the maximum value from a list of items
@@ -24,7 +18,7 @@ export declare function max<Item extends PlainObject>(items: Item[], callback: (
  * @param key Key to use for value
  * @returns Maximum value, or `NaN` if no maximum can be found
  */
-export declare function max<Item extends PlainObject>(items: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function max<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the maximum value from a list of numbers
  * @param values List of numbers

package/types/is.d.ts

@@ -1,10 +1,10 @@
-import type { ArrayOrPlainObject, Primitive } from './models';
+import type { Primitive } from './models';
 /**
- * Is the array or object completely empty, or only containing `null` or `undefined` values?
- * @param value Array or object to check
- * @returns `true` if the value is considered empty, otherwise `false`
+ * Is the value empty, or only containing `null` or `undefined` values?
+ * @param value Object to check
+ * @returns `true` if the object is considered empty, otherwise `false`
  */
-export declare function isEmpty(value: ArrayOrPlainObject): boolean;
+export declare function isEmpty(value: unknown): boolean;
 /**
  * Is the value `undefined` or `null`?
  * @param value Value to check

package/types/math.d.ts

@@ -1,5 +1,4 @@
-import { type OnlyNumericalKeys } from './internal/math/aggregate';
-import type { PlainObject } from './models';
+import type { NumericalValues, PlainObject } from './models';
 /**
  * Get the average value from a list of items
  * @param items List of items
@@ -13,7 +12,7 @@ export declare function average<Item extends PlainObject>(items: Item[], callbac
  * @param key Key to use for value
  * @returns Average value, or `NaN` if no average can be calculated
  */
-export declare function average<Item extends PlainObject>(items: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function average<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the average value from a list of numbers
  * @param numbers List of numbers
@@ -55,7 +54,7 @@ export declare function min<Item extends PlainObject>(items: Item[], callback: (
  * @param key Key to use for value
  * @returns Minimum value, or `NaN` if no minimum can be found
  */
-export declare function min<Item extends PlainObject>(items: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the minimum value from a list of numbers
  * @param values List of numbers
@@ -82,11 +81,12 @@ export declare function sum<Item extends PlainObject>(items: Item[], callback: (
  * @param key Key to use for value
  * @returns Sum of the values, or `NaN` if no sum can be calculated
  */
-export declare function sum<Item extends PlainObject>(items: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function sum<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the sum of a list of numbers
  * @param values List of numbers
  * @returns Sum of the numbers, or `NaN` if no sum can be calculated
  */
 export declare function sum(values: number[]): number;
-export { max, type OnlyNumericalKeys } from './internal/math/aggregate';
+export { max } from './internal/math/aggregate';
+export type { NumericalValues };

package/types/models.d.ts

@@ -28,11 +28,14 @@ export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends Propert
  * A nested array
  */
 export type NestedArray<Value> = Value extends Array<infer NestedValue> ? NestedArray<NestedValue> : Value;
+/**
+ * All nested keys of an object as dot notation strings _(up to 5 levels deep)_
+ */
 export type NestedKeys<Value extends PlainObject> = _NestedKeys<Value>;
 type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0 ? never : Value extends readonly any[] ? Value extends readonly [any, ...any] ? {
-    [Key in keyof Value]-?: Key extends `${number}` ? Value[Key] extends readonly any[] ? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}` : Value[Key] extends PlainObject ? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}` : `${Key}` : never;
+    [Key in keyof Value]-?: Key extends `${number}` ? NonNullable<Value[Key]> extends readonly any[] | PlainObject ? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}` : `${Key}` : never;
 }[number] : never : Value extends PlainObject ? {
-    [Key in keyof Value]-?: Key extends number | string ? Value[Key] extends readonly any[] ? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}` : Value[Key] extends PlainObject ? `${Key}` | `${Key}.${_NestedKeys<Value[Key], SubtractDepth<Depth>>}` : `${Key}` : never;
+    [Key in keyof Value]-?: Key extends number | string ? NonNullable<Value[Key]> extends readonly any[] | PlainObject ? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}` : `${Key}` : never;
 }[keyof Value] : never;
 /**
  * An extended version of `Partial` that allows for nested properties to be optional
@@ -40,11 +43,23 @@ type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0 ? never : Va
 export type NestedPartial<T> = {
     [K in keyof T]?: T[K] extends object ? NestedPartial<T[K]> : T[K];
 };
-export type NestedValue<Value extends PlainObject, Path extends string> = Simplify<_NestedValue<Value, Path>>;
-export type _NestedValue<Value, Path extends string> = Path extends keyof Value ? Value[Path] : Path extends `${infer Key}.${infer Rest}` ? Key extends keyof Value ? _NestedValue<Value[Key], Rest> : Key extends `${number}` ? Value extends readonly any[] ? _NestedValue<Value[number], Rest> : never : never : Path extends `${number}` ? Value extends readonly any[] ? Value[number] : never : never;
+/**
+ * The value for a nested key of an object
+ */
+export type NestedValue<Value extends PlainObject, Path extends string> = _NestedValue<Value, Path>;
+type _NestedValue<Value, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof Value ? undefined extends Value[Key] ? _NestedValue<Exclude<Value[Key], undefined>, Rest> | undefined : _NestedValue<Value[Key], Rest> : Key extends `${number}` ? Value extends readonly any[] ? _NestedValue<Value[number], Rest> : never : never : Path extends `${number}` ? Value extends readonly any[] ? Value[number] : never : Path extends keyof Value ? Value[Path] : never;
+/**
+ * The nested (keyed) values of an object _(up to 5 levels deep)_
+ */
 export type NestedValues<Value extends PlainObject> = {
     [Path in NestedKeys<Value>]: NestedValue<Value, Path>;
 };
+/**
+ * The numerical values of an object
+ */
+export type NumericalValues<Item extends PlainObject> = {
+    [Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
 /**
  * A generic object
  */