@oscarpalmer/mora 0.29.0 → 0.31.0

package/src/value/store.ts

@@ -1,183 +1,26 @@
 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,
+	ReadonlyInstances,
+	Unsubscribe,
+} from '../models';
+import {noop, subscribe, unsubscribe} from '../subscription';
+import {reactive} from './reactive';
+import {getReadonlyInstance} from './readonly';
 
 function isStoreObject<Value extends PlainObject>(value: unknown): value is Value | undefined {
 	return value == null || isPlainObject(value);
@@ -215,6 +58,34 @@ function setObject(state: ReactiveState<PlainObject, never>, value: PlainObject
 	stopBatch();
 }
 
+function peekStoreValue<Value extends PlainObject>(
+	state: ReactiveState<Value, Value>,
+	first?: unknown,
+	second?: boolean,
+): unknown {
+	let value: unknown;
+
+	if (isKey(first)) {
+		value = state.value[first];
+	} else {
+		value = state.value;
+	}
+
+	if (!(first === true || second === true)) {
+		return value;
+	}
+
+	if (Array.isArray(value)) {
+		return value.slice();
+	}
+
+	if (isPlainObject(value)) {
+		return {...value};
+	}
+
+	return value;
+}
+
 function setProperty<Value extends PlainObject>(
 	state: ReactiveState<Value, Value>,
 	key: unknown,
@@ -225,6 +96,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 +104,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 +116,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 +128,94 @@ 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]>();
+	const readonlies: ReadonlyInstances<Value> = {};
+
+	let instance: Record<string, GenericCallback> = {};
+
+	state.value = new Proxy({} as Value, {
+		set: (target: Value, property: PropertyKey, value: unknown) =>
+			setValueInProxy({
+				target,
+				property,
+				state,
+				value,
+				isArray: false,
+			}),
+	});
+
+	const handlers = {
+		...rx,
+		get: (value?: unknown): unknown =>
+			isKey(value)
+				? getReactiveValueInProxy(instance as ReactiveStore<Value>, keyed, value, false).get()
+				: getSimpleValue(state),
+		peek: (first?: unknown, second?: boolean): unknown => peekStoreValue(state, first, second),
+		subscribe: (first: Key | GenericCallback, second?: GenericCallback): Unsubscribe => {
+			if (isKey(first) && typeof second === 'function') {
+				return getReactiveValueInProxy(
+					instance as ReactiveStore<Value>,
+					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 as ReactiveStore<Value>, keyed, first, false)?.unsubscribe(
+					second,
+				);
+			} else if (typeof first === 'function') {
+				unsubscribe(state, first);
+			}
+		},
+	};
+
+	instance = {
+		...handlers,
+		asReadonly: (frozen?: unknown) =>
+			getReadonlyInstance(state, readonlies, handlers, frozen === true),
+		notify(): void {
+			emityProxyValues(state, keyed);
+		},
+		set: (first?: unknown, second?: unknown) => {
+			setProxyValue<Value>(
+				false,
+				state,
+				isStoreObject,
+				isKey,
+				setObject,
+				setProperty,
+				first,
+				second,
+			);
+		},
+		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>;
 }

package/types/constants.d.ts

@@ -12,5 +12,5 @@ export declare const NAME_EFFECT = "effect";
 export declare const NAME_MORA = "$mora";
 export declare const NAME_SIGNAL = "signal";
 export declare const NAME_STORE = "store";
-export declare const NAMES: Set<string>;
+export declare const NAME_ALL: Set<string>;
 export declare const PROPERTY_LENGTH = "length";

package/types/index.d.ts

@@ -1,6 +1,6 @@
 export { startBatch, stopBatch } from './batch';
 export { effect, type Effect } from './effect';
-export { isArray, isComputed, isEffect, isReactive, isSignal, } from './helpers/is';
+export { isArray, isComputed, isEffect, isReactive, isSignal } from './helpers/is';
 export type { Unsubscribe } from './models';
 export { array, type ReactiveArray } from './value/array';
 export { computed, type Computed } from './value/computed';

package/types/value/array.d.ts

@@ -131,7 +131,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 /**
  * Create a reactive array
  * @param value Initial array of items
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive array
  */
 export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.ts

@@ -10,5 +10,8 @@ export declare class Computed<Value> extends Reactive<Value> {
 }
 /**
  * Create a computed value
+ * @param callback Callback to compute the value
+ * @param options Reactivity options
+ * @returns Computed value
  */
 export declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;

package/types/value/signal.d.ts

@@ -20,7 +20,7 @@ export declare class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  * @param value Initial value
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive value
  */
 export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;

package/types/value/store.d.ts

@@ -88,7 +88,7 @@ export declare class Store<Value extends PlainObject> extends Reactive<Value, Va
 /**
  * Create a reactive store
  * @param value Initial object value
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive store
  */
 export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;