@oscarpalmer/mora 0.28.0 → 0.30.0

package/src/value/reactive.ts

@@ -1,72 +1,24 @@
-import {NAME_MORA} from '../constants';
-import type {ReactiveOptions, ReactiveState, Unsubscribe} from '../models';
-import {subscribe, unsubscribe} from '../subscription';
+import type {Reactive, ReactiveOptions, ReactiveState} from '../models';
 
-export abstract class Reactive<Value, Equal = Value> {
-	protected readonly state: ReactiveState<Value, Equal> = {
+export function reactive<Value, Equal = Value>(
+	value: Value,
+	options?: ReactiveOptions<Equal>,
+): [Reactive<Value>, ReactiveState<Value, Equal>] {
+	const state: ReactiveState<Value, Equal> = {
 		computeds: new Set(),
 		effects: new Set(),
-		equal: Object.is,
+		equal:
+			typeof options === 'object' && typeof options?.equal === 'function'
+				? options.equal
+				: Object.is,
 		subscriptions: new Map(),
-		value: undefined as never,
+		value: value as Value,
 	};
 
-	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>) {
-		this.state.value = value;
-
-		if (typeof options === 'object' && typeof options.equal === 'function') {
-			this.state.equal = options.equal;
-		}
-
-		Object.defineProperty(this, NAME_MORA, {
-			value: name,
-		});
-	}
-
-	/**
-	 * Get the value
-	 * @return Current value
-	 */
-	abstract get(): Value;
-
-	/**
-	 * Get the value _(without reactivity)_
-	 * @return Current value
-	 */
-	peek(): Value {
-		return this.state.value;
-	}
-
-	/**
-	 * Subscribe to changes
-	 * @param callback Callback for changes
-	 * @return Unsubscribe callback
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe {
-		return subscribe(this.state, callback);
-	}
-
-	/**
-	 * JSON representation of the value
-	 * @return JSON value
-	 */
-	toJSON(): Value {
-		return this.get();
-	}
-
-	/**
-	 * String representation of the value
-	 * @return Value as string
-	 */
-	toString(): string {
-		return String(this.get());
-	}
+	const instance = {
+		toJSON: () => state.value,
+		toString: () => String(state.value),
+	};
 
-	/**
-	 * Unsubscribe from changes
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(callback: (value: Value) => void): void {
-		unsubscribe(this.state, callback);
-	}
+	return [instance, state];
 }

package/src/value/signal.ts

@@ -1,36 +1,8 @@
-import {NAME_SIGNAL} from '../constants';
-import {emitValue, getValue} from '../helpers/value';
-import type {ReactiveOptions, ReactiveState} from '../models';
-import {Reactive} from './reactive';
-
-export class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value, options?: ReactiveOptions<Value>) {
-		super(NAME_SIGNAL, value, options);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	get(): Value {
-		return getValue(this.state);
-	}
-
-	/**
-	 * Set the value
-	 * @param value New value
-	 */
-	set(value: Value | (() => Value | Promise<Value>) | Promise<Value>): void {
-		setValue<Value>(this.state, value);
-	}
-
-	/**
-	 * Update the value _(based on the current value)_
-	 * @param callback Callback to update the value
-	 */
-	update(callback: (value: Value) => Value): void {
-		this.set(callback(this.state.value));
-	}
-}
+import {NAME_MORA, NAME_SIGNAL} from '../constants';
+import {emitValue, getSimpleValue, handleSimpleValue} from '../helpers/value';
+import type {ReactiveOptions, ReactiveState, Signal} from '../models';
+import {subscribe} from '../subscription';
+import {reactive} from './reactive';
 
 function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): void {
 	if (!state.equal(state.value, value)) {
@@ -40,41 +12,9 @@ function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): vo
 	}
 }
 
-function setValue<Value>(
-	state: ReactiveState<Value, Value>,
-	value: Value | (() => Value | Promise<Value>) | Promise<Value>,
-): void {
-	try {
-		let actual = value;
-
-		if (typeof value === 'function') {
-			actual = (value as () => Value | Promise<Value>)() as Value | Promise<Value>;
-		}
-
-		if (actual instanceof Promise) {
-			state.promise = actual;
-
-			void actual
-				.then(value => {
-					if (actual === state.promise) {
-						state.promise = undefined;
-
-						setAndEmit(state, value);
-					}
-				})
-				.catch(() => {
-					if (actual === state.promise) {
-						state.promise = undefined;
-					}
-				});
-		} else {
-			setAndEmit(state, actual as Value);
-		}
-	} catch {}
-}
-
 /**
  * Create a reactive value from a function result
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
@@ -86,6 +26,7 @@ export function signal<Value>(
 
 /**
  * Create a reactive value from a promise
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
@@ -97,6 +38,7 @@ export function signal<Value>(
 
 /**
  * Create a reactive value
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
@@ -107,9 +49,30 @@ export function signal<Value>(
 	value: Value | (() => Value | Promise<Value>) | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): Signal<Value> {
-	const instance = new Signal<Value>(undefined as unknown as Value, options);
-
-	instance.set(value);
-
-	return instance;
+	const [rx, state] = reactive<Value>(undefined as unknown as Value, options);
+
+	const instance = {
+		...rx,
+		get: () => getSimpleValue(state),
+		peek: () => state.value,
+		set: (value: Value | (() => Value | Promise<Value>) | Promise<Value>) => {
+			handleSimpleValue(state, value, setAndEmit);
+		},
+		update: (callback: (value: Value) => Value) => {
+			handleSimpleValue(state, callback(state.value), setAndEmit);
+		},
+		subscribe: (callback: (value: Value) => void) => subscribe(state, callback),
+		unsubscribe: (callback: (value: Value) => void) => {
+			state.subscriptions.delete(callback);
+		},
+	};
+
+	Object.defineProperty(instance, NAME_MORA, {
+		enumerable: false,
+		value: NAME_SIGNAL,
+	});
+
+	handleSimpleValue(state, value, setAndEmit);
+
+	return Object.freeze(instance) as Signal<Value>;
 }

package/src/value/store.ts

@@ -1,183 +1,24 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
-import {NAME_STORE} from '../constants';
+import {NAME_MORA, NAME_STORE} from '../constants';
 import {
 	emityProxyValues,
 	getReactiveValueInProxy,
 	setProxyValue,
 	setValueInProxy,
 } from '../helpers/proxy';
-import {getValue} from '../helpers/value';
-import type {ReactiveOptions, ReactiveState, Unsubscribe} from '../models';
-import {noop, subscribe} from '../subscription';
-import type {Computed} from './computed';
-import {Reactive} from './reactive';
-
-export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
-	readonly #keyed = new Map<Key, Computed<unknown>>();
-
-	constructor(value: Value, options?: ReactiveOptions<Value>) {
-		super(
-			NAME_STORE,
-			new Proxy(value, {
-				set: (target: Value, property: PropertyKey, value: unknown) =>
-					setValueInProxy({
-						target,
-						property,
-						value,
-						isArray: false,
-						state: this.state,
-					}),
-			}),
-			options,
-		);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	get(): Value;
-
-	/**
-	 * Get a value by key
-	 * @param key Key of the value to get
-	 * @returns Value for the specified key, or `undefined` if it doesn't exist
-	 */
-	get<Key extends keyof Value>(key: Key): Value[Key];
-
-	/**
-	 * Get a value by key
-	 * @param key Key of the value to get
-	 * @returns Value for the specified key, or `undefined` if it doesn't exist
-	 */
-	get(key: Key): unknown;
-
-	get(key?: unknown): unknown {
-		return isKey(key)
-			? getReactiveValueInProxy(this, this.#keyed, key, false).get()
-			: getValue(this.state);
-	}
-
-	/**
-	 * Notify dependents of changes
-	 *
-	 * _This bypasses equality checks and will immediately notify dependents.
-	 * Use this only if you're modifying nested data that would be ignored by equality checks._
-	 */
-	notify(): void {
-		emityProxyValues(this.state, this.#keyed);
-	}
-
-	/**
-	 * Get the value _(without reactivity)_
-	 * @returns The current value
-	 */
-	override peek(): Value;
-
-	/**
-	 * Get a value by key _(without reactivity)_
-	 * @param key Key of the value to get
-	 * @returns Value for the specified key, or `undefined` if it doesn't exist
-	 */
-	override peek<Key extends keyof Value>(key: Key): Value[Key];
-
-	/**
-	 * Get a value by key _(without reactivity)_
-	 * @param key Key of the value to get
-	 * @returns Value for the specified key, or `undefined` if it doesn't exist
-	 */
-	override peek(key: Key): unknown;
-
-	override peek(key?: unknown): unknown {
-		return isKey(key) ? this.state.value[key] : {...this.state.value};
-	}
-
-	/**
-	 * Set the value
-	 * @param value New value _(defaults to an empty object)_
-	 */
-	set(
-		value?:
-			| Value
-			| (() => null | undefined | Value | Promise<null | undefined | Value>)
-			| Promise<null | undefined | Value>,
-	): void;
-
-	/**
-	 * Set a value by key
-	 * @param key Key of the value to set
-	 * @param value New value
-	 */
-	set<Key extends keyof Value>(
-		key: Key,
-		value: Value[Key] | (() => Value[Key] | Promise<Value[Key]>) | Promise<Value[Key]>,
-	): void;
-
-	/**
-	 * Set a value by key
-	 * @param key Key of the value to set
-	 * @param value New value
-	 */
-	set(key: Key, value: unknown): void;
-
-	set(first?: unknown, second?: unknown): void {
-		setProxyValue<Value>(
-			false,
-			this.state,
-			isStoreObject,
-			isKey,
-			setObject,
-			setProperty,
-			first,
-			second,
-		);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	override subscribe(callback: (value: Value) => void): Unsubscribe;
-
-	/**
-	 * Subscribe to changes for a specific key
-	 * @param key Key of the value to subscribe to
-	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
-	 */
-	override subscribe<Key extends keyof Value>(
-		key: Key,
-		callback: (value: Value[Key] | undefined) => void,
-	): Unsubscribe;
-
-	/**
-	 * Subscribe to changes for a specific key
-	 * @param key Key of the value to subscribe to
-	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
-	 */
-	override subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
-
-	override subscribe(first: Key | GenericCallback, second?: GenericCallback): Unsubscribe {
-		if (isKey(first) && typeof second === 'function') {
-			return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
-		}
-
-		return typeof first === 'function' ? subscribe(this.state, first) : noop;
-	}
-
-	/**
-	 * Update the value _(based on the current value)_
-	 * @param callback Callback to update the value
-	 */
-	update(callback: (value: Value) => Value): void {
-		const updated = callback(this.state.value);
-
-		if (updated == null || isPlainObject(updated)) {
-			setObject(this.state, updated);
-		}
-	}
-}
+import {getSimpleValue} from '../helpers/value';
+import type {
+	Computed,
+	ComputedEffect,
+	ReactiveOptions,
+	ReactiveState,
+	ReactiveStore,
+	Unsubscribe,
+} from '../models';
+import {noop, subscribe, unsubscribe} from '../subscription';
+import {reactive} from './reactive';
 
 function isStoreObject<Value extends PlainObject>(value: unknown): value is Value | undefined {
 	return value == null || isPlainObject(value);
@@ -225,6 +66,7 @@ function setProperty<Value extends PlainObject>(
 
 /**
  * Create a reactive store from a function result
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
@@ -232,10 +74,11 @@ function setProperty<Value extends PlainObject>(
 export function store<Value extends PlainObject>(
 	value: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
-): Store<Value>;
+): ReactiveStore<Value>;
 
 /**
  * Create a reactive store from a promise
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
@@ -243,10 +86,11 @@ export function store<Value extends PlainObject>(
 export function store<Value extends PlainObject>(
 	value: Promise<Value>,
 	options?: ReactiveOptions<Value>,
-): Store<Value>;
+): ReactiveStore<Value>;
 
 /**
  * Create a reactive store
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
@@ -254,15 +98,78 @@ export function store<Value extends PlainObject>(
 export function store<Value extends PlainObject>(
 	value: Value,
 	options?: ReactiveOptions<Value>,
-): Store<Value>;
+): ReactiveStore<Value>;
 
 export function store<Value extends PlainObject>(
 	value: Value | (() => Value | Promise<Value>) | Promise<Value>,
 	options?: ReactiveOptions<Value>,
-): Store<Value> {
-	const instance = new Store({} as unknown as Value, options);
+): ReactiveStore<Value> {
+	const [rx, state] = reactive<Value>(undefined as never, options);
+
+	const keyed = new Map<Key, [Computed<unknown>, ComputedEffect]>();
+
+	state.value = new Proxy({} as Value, {
+		set: (target: Value, property: PropertyKey, value: unknown) =>
+			setValueInProxy({
+				target,
+				property,
+				state,
+				value,
+				isArray: false,
+			}),
+	});
+
+	const instance = {
+		...rx,
+		get: (value?: unknown): unknown =>
+			isKey(value)
+				? getReactiveValueInProxy(instance, keyed, value, false).get()
+				: getSimpleValue(state),
+		notify(): void {
+			emityProxyValues(state, keyed);
+		},
+		peek: (value?: unknown): unknown => (isKey(value) ? state.value[value] : {...state.value}),
+		set: (first?: unknown, second?: unknown) => {
+			setProxyValue<Value>(
+				false,
+				state,
+				isStoreObject,
+				isKey,
+				setObject,
+				setProperty,
+				first,
+				second,
+			);
+		},
+		subscribe: (first: Key | GenericCallback, second?: GenericCallback): Unsubscribe => {
+			if (isKey(first) && typeof second === 'function') {
+				return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
+			}
+
+			return typeof first === 'function' ? subscribe(state, first) : noop;
+		},
+		unsubscribe: (first: Key | GenericCallback, second?: GenericCallback) => {
+			if (isKey(first) && typeof second === 'function') {
+				getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
+			} else if (typeof first === 'function') {
+				unsubscribe(state, first);
+			}
+		},
+		update: (callback: (value: Value) => Value) => {
+			const updated = callback(state.value);
+
+			if (updated == null || isPlainObject(updated)) {
+				setObject(state, updated);
+			}
+		},
+	};
+
+	Object.defineProperty(instance, NAME_MORA, {
+		enumerable: false,
+		value: NAME_STORE,
+	});
 
 	instance.set(value);
 
-	return instance;
+	return Object.freeze(instance) as ReactiveStore<Value>;
 }