@oscarpalmer/atoms 0.189.0 → 0.190.0

package/dist/string/fuzzy.mjs

@@ -3,45 +3,6 @@ import { getString } from "../internal/string.mjs";
 import { lowerCase } from "./case.mjs";
 import { includes } from "./match.mjs";
 //#region src/string/fuzzy.ts
-/**
-* Fuzzy searcher for an array of items
-*/
-var Fuzzy = class {
-	#state;
-	/**
-	* Get items currently being searched through
-	*
-	* @returns Original items
-	*/
-	get items() {
-		return this.#state.items.slice();
-	}
-	/**
-	* Set new items to search through
-	*
-	* @param items New items to search through
-	*/
-	set items(items) {
-		if (Array.isArray(items)) {
-			this.#state.items = items.slice();
-			this.#state.strings = items.map(this.#state.handler);
-		}
-	}
-	/**
-	* Get strings currently being searched through _(the stringified version of `items`)_
-	*
-	* @returns Stringified items
-	*/
-	get strings() {
-		return this.#state.strings.slice();
-	}
-	constructor(state) {
-		this.#state = state;
-	}
-	search(value, options) {
-		return search(this.#state.items, this.#state.strings, value, options == null ? this.#state : getFuzzyOptions(options, this.#state));
-	}
-};
 function getHandler(input) {
 	if (input == null || input === getString) return getString;
 	switch (typeof input) {
@@ -80,7 +41,20 @@ function getTolerance(input, state) {
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-	return new Fuzzy(getFuzzyState(items, configuration));
+	const state = getFuzzyState(items, configuration);
+	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
+	Object.defineProperties(instance, {
+		items: {
+			get: () => state.items.slice(),
+			set: (items) => {
+				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+				state.items = items.slice();
+				state.strings = items.map(state.handler);
+			}
+		},
+		strings: { get: () => state.strings.slice() }
+	});
+	return Object.freeze(instance);
 }
 fuzzy.match = fuzzyMatch;
 /**
@@ -88,7 +62,7 @@ fuzzy.match = fuzzyMatch;
 *
 * @param haystack Haystack to search through
 * @param needle Needle to search for
-* @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+* @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`
 */
 function fuzzyMatch(haystack, needle) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.189.0",
+	"version": "0.190.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",
@@ -259,7 +259,7 @@
 	"devDependencies": {
 		"@oxlint/plugins": "^1.78",
 		"@types/node": "^26.2",
-		"@vitest/coverage-istanbul": "^4.1",
+		"@vitest/coverage-istanbul": "4.1.10",
 		"eslint": "^10.8",
 		"jsdom": "^30",
 		"tsdown": "^0.22",

package/src/beacon.ts

@@ -7,54 +7,31 @@ import type {PlainObject} from './models';
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
  */
-class Beacon<Value> {
-	readonly #options: Options;
-	readonly #state: BeaconState<Value>;
-
+export type Beacon<Value> = {
 	/**
 	 * Is the beacon active?
 	 */
-	get active(): boolean {
-		return this.#state.active;
-	}
+	get active(): boolean;
 
 	/**
-	 * The observable that can be subscribed to
+	 * Is the beacon closed?
 	 */
-	get observable(): Observable<Value> {
-		if (!this.#state.active) {
-			throw new Error(MESSAGE_BEACON);
-		}
+	get closed(): boolean;
 
-		return this.#state.observable;
-	}
+	/**
+	 * The observable that can be subscribed to
+	 */
+	get observable(): Observable<Value>;
 
 	/**
 	 * The current value
 	 */
-	get value(): Value {
-		return this.#state.value;
-	}
-
-	constructor(value: Value, options?: BeaconOptions<Value>) {
-		const observers = new Map<Subscription<Value>, Observer<Value>>();
-
-		this.#options = getBeaconOptions(options);
-
-		this.#state = {
-			observers,
-			value,
-			active: true,
-			observable: new Observable(this, observers),
-		};
-	}
+	get value(): Value;
 
 	/**
-	 * Destroy the beacon
+	 * Close the beacon
 	 */
-	destroy(): void {
-		finishBeacon(this.#state, false);
-	}
+	close(): void;
 
 	/**
 	 * Emit a new value
@@ -62,9 +39,7 @@ class Beacon<Value> {
 	 * @param value Value to set and emit
 	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
 	 */
-	emit(value: Value, finish?: boolean): void {
-		this.#on(TYPE_NEXT, value, finish);
-	}
+	emit(value: Value, finish?: boolean): void;
 
 	/**
 	 * Emit an error
@@ -72,44 +47,18 @@ class Beacon<Value> {
 	 * @param value Error to emit
 	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
 	 */
-	error(value: Error, finish?: boolean): void {
-		this.#on(TYPE_ERROR, value, finish);
-	}
+	error(value: Error, finish?: boolean): void;
 
 	/**
 	 * Finish the beacon
 	 */
-	finish(): void {
-		finishBeacon(this.#state, true);
-	}
-
-	#on(type: keyof Observer<never>, value: Error | Value, finish?: boolean): void {
-		if (!this.#state.active) {
-			return;
-		}
-
-		if (type === TYPE_NEXT) {
-			if (this.#options.equal(this.#state.value, value as Value)) {
-				return;
-			}
-
-			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);
-		}
-	}
-}
+	finish(): void;
+};
 
 /**
  * Options for Beacon
  */
-type BeaconOptions<Value> = {
+export type BeaconOptions<Value> = {
 	/**
 	 * Method for comparing values for equality
 	 *
@@ -124,30 +73,26 @@ type BeaconOptions<Value> = {
 type BeaconState<Value> = {
 	active: boolean;
 	observable: Observable<Value>;
-	observers: Map<Subscription<Value>, Observer<Value>>;
+	observers: Map<Subscription, Observer<Value>>;
+	options: Required<BeaconOptions<Value>>;
 	value: Value;
 };
 
-/**
- * An observable holds a value and allows observers to subscribe to changes in that value
- */
-class Observable<Value> {
-	readonly #state: ObservableState<Value>;
-
-	constructor(instance: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>) {
-		this.#state = {
-			observers,
-			beacon: instance,
-			closed: false,
-		};
-	}
+export type Observable<Value> = {
+	/**
+	 * Is the observable active?
+	 */
+	get active(): boolean;
 
 	/**
-	 * Destroy the observable
+	 * Is the observable closed?
 	 */
-	destroy(): void {
-		this.#state.closed = true;
-	}
+	get closed(): boolean;
+
+	/**
+	 * Close the observable
+	 */
+	close(): void;
 
 	/**
 	 * Subscribe to value changes
@@ -161,7 +106,7 @@ class Observable<Value> {
 		onNext: (value: Value) => void,
 		onError?: (error: Error) => void,
 		onComplete?: () => void,
-	): Subscription<Value>;
+	): Subscription;
 
 	/**
 	 * Subscribe to value changes
@@ -169,32 +114,12 @@ class Observable<Value> {
 	 * @param observer Observer for changes
 	 * @returns Subscription to the observable
 	 */
-	subscribe(observer: Observer<Value>): Subscription<Value>;
-
-	subscribe(
-		first: Observer<Value> | ((value: Value) => void),
-		second?: (error: Error) => void,
-		third?: () => void,
-	): Subscription<Value> {
-		if (this.#state.closed) {
-			throw new Error(MESSAGE_OBSERVABLE);
-		}
-
-		const observer = getObserver(first, second, third);
-		const instance = new Subscription(this.#state);
-
-		this.#state.observers.set(instance, observer);
-
-		observer.next?.(this.#state.beacon.value);
-
-		return instance;
-	}
-}
+	subscribe(observer: Observer<Value>): Subscription;
+};
 
 type ObservableState<Value> = {
-	beacon: Beacon<Value>;
-	closed: boolean;
-	observers: Map<Subscription<Value>, Observer<Value>>;
+	active: boolean;
+	beacon: BeaconState<Value>;
 };
 
 /**
@@ -215,53 +140,26 @@ type Observer<Value> = {
 	next?: (value: Value) => void;
 };
 
-type Options = Required<BeaconOptions<unknown>>;
-
-/**
- * A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
- */
-class Subscription<Value> {
-	readonly #state: SubscriptionState<Value>;
-
-	constructor(state: ObservableState<Value>) {
-		this.#state = {
-			...state,
-			closed: false,
-		};
-	}
+export type Subscription = {
+	/**
+	 * Is the subscription active?
+	 */
+	get active(): boolean;
 
 	/**
 	 * Is the subscription closed?
 	 */
-	get closed(): boolean {
-		return this.#state.closed || !this.#state.beacon.active;
-	}
+	get closed(): boolean;
 
 	/**
-	 * Destroy the subscription
+	 * Close the subscription
 	 */
-	destroy(): void {
-		if (!this.#state.closed) {
-			this.unsubscribe();
-		}
-	}
+	close(): void;
 
 	/**
 	 * Unsubscribe from its observable
 	 */
-	unsubscribe(): void {
-		if (!this.#state.closed) {
-			this.#state.closed = true;
-
-			this.#state.observers.delete(this);
-		}
-	}
-}
-
-type SubscriptionState<Value> = {
-	closed: boolean;
-	beacon: Beacon<Value>;
-	observers: Map<Subscription<Value>, Observer<Value>>;
+	unsubscribe(): void;
 };
 
 // #endregion
@@ -276,7 +174,61 @@ type SubscriptionState<Value> = {
  * @returns Beacon instance
  */
 export function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value> {
-	return new Beacon(value, options);
+	const state: BeaconState<Value> = {
+		value,
+		active: true,
+		observable: undefined as never,
+		observers: new Map(),
+		options: getBeaconOptions(options),
+	};
+
+	const instance = {
+		close: (): void => {
+			finishBeacon(state, false);
+		},
+		emit: (value: Value, finish?: boolean): void => {
+			update(TYPE_NEXT, state, value, finish);
+		},
+		error: (value: Error, finish?: boolean): void => {
+			update(TYPE_ERROR, state, value, finish);
+		},
+		finish: (): void => {
+			finishBeacon(state, true);
+		},
+	};
+
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_BEACON,
+		},
+		active: {
+			enumerable: true,
+			get: () => state.active,
+		},
+		closed: {
+			enumerable: true,
+			get: () => !state.active,
+		},
+		observable: {
+			enumerable: true,
+			get: () => {
+				if (!state.active) {
+					throw new Error(MESSAGE_BEACON);
+				}
+
+				state.observable ??= observe(state);
+
+				return state.observable;
+			},
+		},
+		value: {
+			enumerable: true,
+			get: () => state.value,
+		},
+	});
+
+	return Object.freeze(instance) as Beacon<Value>;
 }
 
 function finishBeacon<Value>(state: BeaconState<Value>, emit: boolean): void {
@@ -296,20 +248,21 @@ function finishBeacon<Value>(state: BeaconState<Value>, emit: boolean): void {
 			observer.complete?.();
 		}
 
-		subscription.destroy();
+		subscription.close();
 	}
 
-	state.observable?.destroy();
-
+	state.observable?.close();
 	state.observers.clear();
+
+	state.observable = undefined as never;
 }
 
-function getBeaconOptions(input?: BeaconOptions<never>): Options {
-	const options: Partial<Options> = isPlainObject(input) ? (input as PlainObject) : {};
+function getBeaconOptions<Value>(input?: BeaconOptions<Value>): Required<BeaconOptions<Value>> {
+	const options: BeaconOptions<Value> = isPlainObject(input) ? (input as PlainObject) : {};
 
 	options.equal = typeof options.equal === 'function' ? options.equal : Object.is;
 
-	return options as Options;
+	return options as Required<BeaconOptions<Value>>;
 }
 
 function getObservableCallback<Callback>(value: Callback): Callback {
@@ -340,22 +293,171 @@ function getObserver<Value>(
 	return observer;
 }
 
+/**
+ * Is the value a beacon?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a beacon, otherwise `false`
+ */
+export function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value> {
+	return isBeaconInstance<Beacon<Value>>(NAME_BEACON, value);
+}
+
+function isBeaconInstance<Instance>(name: string, value: unknown): value is Instance {
+	return isPlainObject(value) && (value as PlainObject)[KEY_BEACON] === name;
+}
+
+/**
+ * Is the value an observable?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an observable, otherwise `false`
+ */
+export function isObservable<Value = unknown>(value: unknown): value is Observable<Value> {
+	return isBeaconInstance<Observable<Value>>(NAME_OBSERVABLE, value);
+}
+
+/**
+ * Is the value a subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a subscription, otherwise `false`
+ */
+export function isSubscription(value: unknown): value is Subscription {
+	return isBeaconInstance<Subscription>(NAME_SUBSCRIPTION, value);
+}
+
+function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
+	const state: ObservableState<Value> = {
+		beacon,
+		active: beacon.active,
+	};
+
+	const instance = {
+		close: (): void => {
+			state.active = false;
+		},
+		subscribe(
+			first: Observer<Value> | ((value: Value) => void),
+			second?: (error: Error) => void,
+			third?: () => void,
+		): Subscription {
+			if (!beacon.active || !state.active) {
+				throw new Error(MESSAGE_OBSERVABLE);
+			}
+
+			const observer = getObserver(first, second, third);
+			const subscription = subscribe(state);
+
+			beacon.observers.set(subscription, observer);
+
+			observer.next?.(beacon.value);
+
+			return subscription;
+		},
+	};
+
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_OBSERVABLE,
+		},
+		active: {
+			enumerable: true,
+			get: () => beacon.active && state.active,
+		},
+		closed: {
+			enumerable: true,
+			get: () => !beacon.active || !state.active,
+		},
+	});
+
+	return Object.freeze(instance) as Observable<Value>;
+}
+
+function subscribe<Value>(observable: ObservableState<Value>): Subscription {
+	function unsubscribe(): void {
+		if (active) {
+			active = false;
+
+			observable.beacon.observers.delete(instance as Subscription);
+		}
+	}
+
+	let active = true;
+
+	const instance = {
+		close: (): void => {
+			unsubscribe();
+		},
+		unsubscribe: (): void => {
+			unsubscribe();
+		},
+	};
+
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_SUBSCRIPTION,
+		},
+		active: {
+			enumerable: true,
+			get: () => observable.beacon.active && observable.active && active,
+		},
+		closed: {
+			enumerable: true,
+			get: () => !observable.beacon.active || !observable.active || !active,
+		},
+	});
+
+	return Object.freeze(instance) as Subscription;
+}
+
+function update<Value>(
+	type: keyof Observer<never>,
+	state: BeaconState<Value>,
+	value: Error | Value,
+	finish?: boolean,
+): void {
+	if (!state.active) {
+		return;
+	}
+
+	if (type === TYPE_NEXT) {
+		if (state.options.equal(state.value, value as Value)) {
+			return;
+		}
+
+		state.value = value as Value;
+	}
+
+	for (const [, observer] of state.observers) {
+		observer[type]?.(value as never);
+	}
+
+	if (finish === true) {
+		finishBeacon(state, true);
+	}
+}
+
 // #endregion
 
 // #region Variables
 
-const MESSAGE_BEACON = 'Cannot retrieve observable from a destroyed beacon';
+const KEY_BEACON = '$beacon';
 
-const MESSAGE_OBSERVABLE = 'Cannot subscribe to a destroyed observable';
+const MESSAGE_BEACON = 'Cannot retrieve observable from a closed beacon';
 
-const TYPE_ERROR = 'error';
+const MESSAGE_OBSERVABLE = 'Cannot subscribe to a closed observable';
 
-const TYPE_NEXT = 'next';
+const NAME_BEACON = 'beacon';
 
-// #endregion
+const NAME_OBSERVABLE = 'observable';
+
+const NAME_SUBSCRIPTION = 'subscription';
 
-// #region Exports
+const TYPE_ERROR = 'error';
 
-export type {Beacon, BeaconOptions, Observable, Observer, Subscription};
+const TYPE_NEXT = 'next';
 
 // #endregion

package/src/color/index.ts

@@ -1,6 +1,6 @@
-import {Color} from './instance';
+import {color} from './instance';
 import {isColor} from './misc/is';
-import type {HSLAColor, HSLColor, HWBColor, HWBAColor, RGBAColor, RGBColor} from './models';
+import type {Color, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor} from './models';
 
 // #region Functions
 
@@ -14,7 +14,7 @@ import type {HSLAColor, HSLColor, HWBColor, HWBAColor, RGBAColor, RGBColor} from
  * @returns _Color_ instance
  */
 export function getColor(value: unknown): Color {
-	return isColor(value) ? value : new Color(value);
+	return isColor(value) ? value : color(value);
 }
 
 // #endregion
@@ -27,8 +27,8 @@ export {
 	getHexColor,
 	getHslaColor,
 	getHslColor,
-	getHwbColor,
 	getHwbaColor,
+	getHwbColor,
 	getRgbaColor,
 	getRgbColor,
 } from './misc/get';
@@ -36,16 +36,16 @@ export {
 export {
 	isColor,
 	isHexColor,
+	isHslaColor,
 	isHslColor,
 	isHslLike,
-	isHslaColor,
-	isHwbColor,
-	isHwbLike,
 	isHwbaColor,
 	isHwbaLike,
+	isHwbColor,
+	isHwbLike,
+	isRgbaColor,
 	isRgbColor,
 	isRgbLike,
-	isRgbaColor,
 } from './misc/is';
 
 export {