@oscarpalmer/mora 0.30.0 → 0.32.0

package/src/value/computed.ts

@@ -1,11 +1,21 @@
 import {flushHandlers} from '../batch';
-import {ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA} from '../constants';
+import {
+	ACTIVE,
+	BATCH,
+	NAME_COMPUTED,
+	NAME_MORA,
+	SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPES,
+} from '../constants';
 import {internalEffect, runEffect} from '../effect';
-import {handleSimpleValue} from '../helpers/value';
+import {subscribeToSignal} from '../helpers/subscription';
+import {handleSimpleValue, peekSimpleValue} from '../helpers/value';
 import type {Computed, ComputedEffect, ReactiveOptions, ReactiveState} from '../models';
-import {subscribe} from '../subscription';
 import {reactive} from './reactive';
 
+// #region Functions
+
 /**
  * Create a computed value
  *
@@ -24,6 +34,10 @@ function getComputed<Value>(
 	callback: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): [Computed<Value>, ComputedEffect] {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Computed callback must be a function');
+	}
+
 	const [rx, state] = reactive<Value>(undefined as never, options);
 
 	let fx: ComputedEffect;
@@ -31,21 +45,17 @@ function getComputed<Value>(
 	const instance = {
 		...rx,
 		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback: (value: Value) => void) => subscribe(state, callback),
-		unsubscribe: (callback: (value: Value) => void) => {
-			state.subscriptions.delete(callback);
-		},
+		peek: (copy?: never) => peekSimpleValue(state.value, copy === true),
+		subscribe: (callback: never, copy?: never) => subscribeToSignal(state, callback, copy === true),
 	};
 
 	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
 		value: NAME_COMPUTED,
 	});
 
 	fx = getComputedEffect(state, callback);
 
-	return [Object.freeze(instance), fx];
+	return [Object.freeze(instance) as never, fx];
 }
 
 function getComputedEffect<Value>(
@@ -109,12 +119,25 @@ function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): vo
 	}
 
 	for (const effect of state.effects) {
-		BATCH.handlers.add(effect);
+		BATCH.handlers.set(effect, effect);
 	}
 
-	for (const [, subscription] of state.subscriptions) {
-		subscription.callback(value);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === SUBSCRIPTION_TYPE_FROZEN) {
+			continue;
+		}
+
+		const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+
+		if (subscriptions != null) {
+			for (const [, callback] of subscriptions) {
+				callback(peekSimpleValue(state.value, copy));
+			}
+		}
 	}
 
 	flushHandlers();
 }
+
+// #endregion

package/src/value/reactive.ts

@@ -1,17 +1,18 @@
 import type {Reactive, ReactiveOptions, ReactiveState} from '../models';
 
-export function reactive<Value, Equal = Value>(
+// #region Functions
+
+export function reactive<Value, Item = Value>(
 	value: Value,
-	options?: ReactiveOptions<Equal>,
-): [Reactive<Value>, ReactiveState<Value, Equal>] {
-	const state: ReactiveState<Value, Equal> = {
+	options?: ReactiveOptions<Item>,
+): [Reactive<Value>, ReactiveState<Value, Item>] {
+	const state: ReactiveState<Value, Item> = {
 		computeds: new Set(),
 		effects: new Set(),
 		equal:
 			typeof options === 'object' && typeof options?.equal === 'function'
 				? options.equal
 				: Object.is,
-		subscriptions: new Map(),
 		value: value as Value,
 	};
 
@@ -22,3 +23,5 @@ export function reactive<Value, Equal = Value>(
 
 	return [instance, state];
 }
+
+// #endregion

package/src/value/readonly.ts

@@ -0,0 +1,72 @@
+import {
+	NAME_MORA,
+	NAME_READONLY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_READONLY,
+} from '../constants';
+import {subscribeToReactive} from '../helpers/subscription';
+import {getFrozenValue, getSimpleValue, peekSimpleValue} from '../helpers/value';
+import type {
+	ReactiveState,
+	ReadonlyFrozenSignal,
+	ReadonlyInstances,
+	ReadonlySignal,
+} from '../models';
+
+// #region Functions
+
+export function getReadonlyInstance<Value>(
+	state: ReactiveState<Value, never>,
+	instances: ReadonlyInstances<Value>,
+	frozen: boolean,
+): ReadonlySignal<Value> {
+	const key = frozen ? 'frozen' : 'original';
+
+	instances[key] ??= getReadonlySignal(state, frozen) as never;
+
+	return instances[key] as never;
+}
+
+export function getReadonlySignal<Value>(
+	state: ReactiveState<Value, never>,
+	frozen: boolean,
+): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value> {
+	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
+
+	const instance = {
+		get: () => getReadonlyValue(state, false, frozen),
+		peek: (copy?: boolean) => getReadonlyValue(state, true, frozen, copy),
+		subscribe: (callback: never) => subscribeToReactive(type, state, callback),
+	};
+
+	Object.defineProperties(instance, {
+		[NAME_MORA]: {
+			value: NAME_READONLY,
+		},
+		frozen: {
+			enumerable: true,
+			value: frozen,
+		},
+	});
+
+	return Object.freeze(instance) as never;
+}
+
+function getReadonlyValue<Value>(
+	state: ReactiveState<Value, never>,
+	peek: boolean,
+	frozen: boolean,
+	copy?: boolean,
+): unknown {
+	let value: unknown;
+
+	if (peek) {
+		value = peekSimpleValue(state.value, copy === true);
+	} else {
+		value = getSimpleValue(state);
+	}
+
+	return frozen ? getFrozenValue(value) : value;
+}
+
+// #endregion

package/src/value/signal.ts

@@ -1,8 +1,17 @@
 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 {subscribeToSignal} from '../helpers/subscription';
+import {
+	emitValue,
+	getSimpleValue,
+	handleSimpleValue,
+	peekSimpleValue,
+	updateSimpleValue,
+} from '../helpers/value';
+import type {ReactiveOptions, ReactiveState, ReadonlyInstances, Signal} from '../models';
 import {reactive} from './reactive';
+import {getReadonlyInstance} from './readonly';
+
+// #region Functions
 
 function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): void {
 	if (!state.equal(state.value, value)) {
@@ -51,28 +60,25 @@ export function signal<Value>(
 ): Signal<Value> {
 	const [rx, state] = reactive<Value>(undefined as unknown as Value, options);
 
+	const readonlies: ReadonlyInstances<Value> = {};
+
 	const instance = {
 		...rx,
+		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
 		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);
-		},
+		peek: (copy?: boolean) => peekSimpleValue(state.value, copy === true),
+		set: (value: never) => handleSimpleValue(state, value, setAndEmit),
+		subscribe: (callback: never, copy?: never) => subscribeToSignal(state, callback, copy === true),
+		update: (callback: never) => updateSimpleValue(state, callback, setAndEmit),
 	};
 
 	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
 		value: NAME_SIGNAL,
 	});
 
 	handleSimpleValue(state, value, setAndEmit);
 
-	return Object.freeze(instance) as Signal<Value>;
+	return Object.freeze(instance) as never;
 }
+
+// #endregion

package/src/value/store.ts

@@ -1,30 +1,40 @@
-import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
 import {NAME_MORA, NAME_STORE} from '../constants';
 import {
-	emityProxyValues,
-	getReactiveValueInProxy,
+	emitProxyValues,
+	getValueInProxy,
+	peekValueInProxy,
 	setProxyValue,
 	setValueInProxy,
+	updateProxyValue,
 } from '../helpers/proxy';
-import {getSimpleValue} from '../helpers/value';
+import {subscribeToProxy} from '../helpers/subscription';
 import type {
 	Computed,
 	ComputedEffect,
 	ReactiveOptions,
 	ReactiveState,
 	ReactiveStore,
-	Unsubscribe,
+	ReadonlyInstances,
 } 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);
+// #region Functions
+
+function setPropertyValue<Value extends PlainObject, Item = Value>(
+	state: ReactiveState<Value, Item>,
+	key: unknown,
+	value: unknown,
+): void {
+	(state.value as PlainObject)[key as Key] = value;
 }
 
-function setObject(state: ReactiveState<PlainObject, never>, value: PlainObject | undefined): void {
+function setStoreValue<Value extends PlainObject, Item = Value>(
+	state: ReactiveState<Value, Item>,
+	value: PlainObject | undefined,
+): void {
 	startBatch();
 
 	const actual = value ?? {};
@@ -56,14 +66,6 @@ function setObject(state: ReactiveState<PlainObject, never>, value: PlainObject
 	stopBatch();
 }
 
-function setProperty<Value extends PlainObject>(
-	state: ReactiveState<Value, Value>,
-	key: unknown,
-	value: unknown,
-): void {
-	(state.value as PlainObject)[key as Key] = value;
-}
-
 /**
  * Create a reactive store from a function result
  *
@@ -106,70 +108,35 @@ export function store<Value extends PlainObject>(
 ): ReactiveStore<Value> {
 	const [rx, state] = reactive<Value>(undefined as never, options);
 
+	const isArray = false;
 	const keyed = new Map<Key, [Computed<unknown>, ComputedEffect]>();
+	const readonlies: ReadonlyInstances<Value> = {};
 
 	state.value = new Proxy({} as Value, {
-		set: (target: Value, property: PropertyKey, value: unknown) =>
-			setValueInProxy({
-				target,
-				property,
-				state,
-				value,
-				isArray: false,
-			}),
+		set: (target, property, value) => setValueInProxy(isArray, state, target, property, value),
 	});
 
 	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);
-			}
-		},
+		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
+		get: (value?: never) => getValueInProxy(isArray, instance as never, state, keyed, value),
+		notify: () => emitProxyValues(state, keyed),
+		peek: (first?: never, second?: never) => peekValueInProxy(isArray, state, first, second),
+		set: (first?: never, second?: never) =>
+			setProxyValue<Value>(isArray, state, setStoreValue, setPropertyValue, first, second),
+		subscribe: (first: never, second?: never, third?: never) =>
+			subscribeToProxy(isArray, instance as never, state, keyed, first, second, third),
+		update: (callback: never) =>
+			updateProxyValue(isArray, state, setStoreValue, setPropertyValue, callback),
 	};
 
 	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
 		value: NAME_STORE,
 	});
 
-	instance.set(value);
+	instance.set(value as never);
 
-	return Object.freeze(instance) as ReactiveStore<Value>;
+	return Object.freeze(instance) as never;
 }
+
+// #endregion

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 NAME_ALL: Set<string>;
+export declare const NAMES: 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 Reactivity options
+ * @param options Optional reactivity options
  * @returns Reactive array
  */
 export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.ts

@@ -10,8 +10,5 @@ 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 Reactivity options
+ * @param options Optional 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 Reactivity options
+ * @param options Optional reactivity options
  * @returns Reactive store
  */
 export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;

package/dist/subscription.d.mts

@@ -1,7 +0,0 @@
-import { ReactiveState, Unsubscribe } from "./models.mjs";
-//#region src/subscription.d.ts
-declare function noop(): void;
-declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
-declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;
-//#endregion
-export { noop, subscribe, unsubscribe };

package/dist/subscription.mjs

@@ -1,27 +0,0 @@
-//#region src/subscription.ts
-function noop() {}
-function subscribe(state, callback) {
-	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
-	state.subscriptions.set(callback, subscription(state, callback));
-	return () => {
-		unsubscribe(state, callback);
-	};
-}
-function subscription(state, callback) {
-	const instance = {
-		callback,
-		state,
-		destroy: () => {
-			instance.callback = noop;
-			instance.state = void 0;
-		}
-	};
-	callback(state.value);
-	return instance;
-}
-function unsubscribe(state, callback) {
-	state.subscriptions.get(callback)?.destroy();
-	state.subscriptions.delete(callback);
-}
-//#endregion
-export { noop, subscribe, unsubscribe };

package/src/subscription.ts

@@ -1,45 +0,0 @@
-import type {ReactiveState, Subscription, Unsubscribe} from './models';
-
-export function noop(): void {}
-
-export function subscribe<Value>(
-	state: ReactiveState<Value, never>,
-	callback: (value: Value) => void,
-): Unsubscribe {
-	if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
-		return noop;
-	}
-
-	state.subscriptions.set(callback, subscription(state, callback));
-
-	return () => {
-		unsubscribe(state, callback);
-	};
-}
-
-function subscription<Value>(
-	state: ReactiveState<Value, never>,
-	callback: (value: Value) => void,
-): Subscription {
-	const instance: Subscription = {
-		callback,
-		state,
-		destroy: () => {
-			instance.callback = noop;
-			instance.state = undefined as never;
-		},
-	};
-
-	callback(state.value);
-
-	return instance;
-}
-
-export function unsubscribe<Value>(
-	state: ReactiveState<Value, never>,
-	callback: (value: Value) => void,
-): void {
-	state.subscriptions.get(callback)?.destroy();
-
-	state.subscriptions.delete(callback);
-}