@oscarpalmer/mora 0.31.0 → 0.32.0

package/src/effect.ts

@@ -1,7 +1,9 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT} from './constants';
+import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
 import type {Effect, EffectState} from './models';
 
+// #region Functions
+
 /**
  * Create an effect
  *
@@ -22,7 +24,7 @@ function getEffect(callback: GenericCallback): [Effect, EffectState] {
 	};
 
 	const instance = Object.freeze({
-		$mora: NAME_EFFECT,
+		[NAME_MORA]: NAME_EFFECT,
 	});
 
 	runEffect(state);
@@ -45,3 +47,5 @@ export function runEffect(state: EffectState): void {
 		ACTIVE.effect = previousEffect;
 	}
 }
+
+// #endregion

package/src/helpers/is.ts

@@ -19,6 +19,8 @@ import type {
 	Signal,
 } from '../models';
 
+// #region Functions
+
 /**
  * Is the value a computed signal?
  *
@@ -92,6 +94,14 @@ export function isReactiveStore<Value extends PlainObject>(
 	return isMora<ReactiveStore<Value>>(value, NAME_STORE);
 }
 
+/**
+ * Is the value a readonly signal?
+ *
+ * @param value Value to check
+ * @returns True if value is a {@link ReadonlySignal}
+ */
 export function isReadonlySignal<Value>(value: unknown): value is ReadonlySignal<Value> {
 	return isMora<ReadonlySignal<Value>>(value, NAME_READONLY);
 }
+
+// #endregion

package/src/helpers/proxy.ts

@@ -1,3 +1,4 @@
+import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {PROPERTY_LENGTH} from '../constants';
 import type {
@@ -6,23 +7,30 @@ import type {
 	ReactiveArray,
 	ReactiveState,
 	ReactiveStore,
-	SetValueInProxyParameters,
+	Signal,
 } from '../models';
 import {internalComputed} from '../value/computed';
-import {emitValue} from './value';
+import {emitValue, getSimpleValue, peekSimpleValue} from './value';
 
-export function emityProxyValues<Value>(
-	state: ReactiveState<Value, Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void;
+// #region Types
 
-export function emityProxyValues<Value>(
-	state: ReactiveState<Value[], Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void;
+type SetObjectCallback<Value, Item> = (
+	state: ReactiveState<Value, Item>,
+	value: Value | undefined,
+) => void;
+
+type SetPropertyCallback<Value, Item> = (
+	state: ReactiveState<Value, Item>,
+	property: unknown,
+	value: Item,
+) => void;
+
+// #endregion
 
-export function emityProxyValues(
-	state: ReactiveState<unknown, unknown>,
+// #region Functions
+
+export function emitProxyValues<Value, Item = Value>(
+	state: ReactiveState<Value, Item>,
 	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 ): void {
 	const values = [...mapped.values()];
@@ -35,27 +43,15 @@ export function emityProxyValues(
 	emitValue(state);
 }
 
-export function getReactiveValueInProxy<Value, Result = Value>(
-	array: ReactiveArray<Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	index: number,
-	isArray: true,
-): Computed<Result>;
-
-export function getReactiveValueInProxy<Value extends PlainObject>(
-	store: ReactiveStore<Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	key: Key,
-	isArray: false,
-): Computed<unknown>;
-
-export function getReactiveValueInProxy(
-	reactive: ReactiveArray<unknown> | ReactiveStore<PlainObject>,
+export function getReactiveValueInProxy<Value>(
+	reactive: ReactiveArray<Value> | ReactiveStore<Value>,
 	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 	key: Key,
 	isArray: boolean,
 ): Computed<unknown> {
-	let item = mapped.get(key);
+	const mapKey = String(key);
+
+	let item = mapped.get(mapKey);
 
 	if (item == null) {
 		item = internalComputed(() =>
@@ -64,37 +60,72 @@ export function getReactiveValueInProxy(
 				: (reactive.get() as PlainObject)[key],
 		);
 
-		mapped.set(key, item);
+		mapped.set(mapKey, item);
 	}
 
 	return item[0];
 }
 
+export function getValueInProxy<Value, Item = Value>(
+	isArray: boolean,
+	instance: ReactiveArray<Value> | ReactiveStore<Value>,
+	state: ReactiveState<Value, Item>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
+	first?: unknown,
+): unknown {
+	if (isArray ? typeof first === 'number' : isKey(first)) {
+		return getReactiveValueInProxy(instance, mapped, first as Key, isArray).get();
+	}
+
+	return getSimpleValue(state);
+}
+
+function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainObject {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+
+export function peekValueInProxy<Value, Item = Value>(
+	isArray: boolean,
+	state: ReactiveState<Value, Item>,
+	first?: unknown,
+	second?: boolean,
+): unknown {
+	let value: unknown;
+
+	if (isArray ? typeof first === 'number' : isKey(first)) {
+		value = isArray
+			? (state.value as unknown[]).at(first as number)
+			: (state.value as PlainObject)[first as Key];
+	} else {
+		value = state.value;
+	}
+
+	return peekSimpleValue(value, first === true || second === true);
+}
+
 export function setProxyValue<Value, Item = Value>(
-	array: boolean,
+	isArray: boolean,
 	state: ReactiveState<Value, Item>,
-	isObject: (value: unknown) => value is Value | undefined,
-	isProperty: (value: unknown) => boolean,
-	setObject: (state: ReactiveState<Value, Item>, value: Value | undefined) => void,
-	setProperty: (state: ReactiveState<Value, Item>, property: unknown, value: Item) => void,
+	setObject: SetObjectCallback<Value, Item>,
+	setProperty: SetPropertyCallback<Value, Item>,
 	first?: unknown,
 	second?: unknown,
 ): void {
-	if (array && first === PROPERTY_LENGTH) {
+	if (isArray && first === PROPERTY_LENGTH) {
 		(state.value as unknown[]).length = second as number;
 
 		return;
 	}
 
-	if (isObject(first)) {
-		setObject(state, first);
+	if (isProxyObject(isArray, first)) {
+		setObject(state, first as Value);
 
 		return;
 	}
 
-	const property = isProperty(first);
+	const property = isArray ? typeof first === 'number' : isKey(first);
 
-	if (array && property && Number.isNaN(first)) {
+	if (isArray && property && Number.isNaN(first)) {
 		return;
 	}
 
@@ -127,10 +158,10 @@ export function setProxyValue<Value, Item = Value>(
 					return;
 				}
 
-				if (!property && isObject(value) && state.promise === actual) {
+				if (!property && isProxyObject(isArray, value) && state.promise === actual) {
 					state.promise = undefined;
 
-					setObject(state, value);
+					setObject(state, value as Value);
 				}
 			})
 			.catch(() => {
@@ -142,16 +173,19 @@ export function setProxyValue<Value, Item = Value>(
 			});
 	} else if (property) {
 		setProperty(state, first, actual as Item);
-	} else if (isObject(actual)) {
-		setObject(state, actual);
+	} else if (isProxyObject(isArray, actual)) {
+		setObject(state, actual as Value);
 	}
 }
 
-export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
-	parameters: SetValueInProxyParameters<Value, Equal>,
+export function setValueInProxy<Value, Item = Value>(
+	isArray: boolean,
+	state: ReactiveState<Value, Item>,
+	target: object,
+	property: PropertyKey,
+	value: unknown,
+	length?: Signal<number>,
 ): boolean {
-	const {isArray, length, property, state, target, value} = parameters;
-
 	if (isArray) {
 		const isIndex = !Number.isNaN(Number(property));
 		const isLength = property === PROPERTY_LENGTH;
@@ -161,7 +195,7 @@ export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
 		}
 	}
 
-	const previous = Reflect.get(target, property);
+	const previous = Reflect.get(target as object, property);
 
 	if (!state.equal(previous as never, value as never)) {
 		Reflect.set(target, property, value);
@@ -175,3 +209,19 @@ export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
 
 	return true;
 }
+
+export function updateProxyValue<Value, Item = Value>(
+	isArray: boolean,
+	state: ReactiveState<Value, Item>,
+	setObject: SetObjectCallback<Value, Item>,
+	setProperty: SetPropertyCallback<Value, Item>,
+	callback: unknown,
+): void {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Callback must be a function');
+	}
+
+	setProxyValue(isArray, state, setObject, setProperty, callback(state.value));
+}
+
+// #endregion

package/src/helpers/subscription.ts

@@ -0,0 +1,78 @@
+import {isKey} from '@oscarpalmer/atoms/is';
+import type {Key} from '@oscarpalmer/atoms/models';
+import {subscriptions, type Subscription} from '@oscarpalmer/atoms/subscription';
+import {
+	SUBSCRIPTION_PROPERTY,
+	SUBSCRIPTION_TYPE_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL,
+	SUBSCRIPTION_TYPES,
+	SUBSCRIPTION_TYPES_COPY,
+} from '../constants';
+import type {
+	Computed,
+	ComputedEffect,
+	ReactiveArray,
+	ReactiveState,
+	ReactiveStore,
+	SubscriptionType,
+} from '../models';
+import {getReactiveValueInProxy} from './proxy';
+import {getFrozenValue, peekSimpleValue} from './value';
+
+export function subscribeToProxy<Value, Item = Value>(
+	isArray: boolean,
+	instance: ReactiveArray<Value> | ReactiveStore<Value>,
+	state: ReactiveState<Value, Item>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
+	first: Key | ((value: unknown) => unknown),
+	second?: ((value: unknown) => unknown) | boolean,
+	third?: boolean,
+): Subscription {
+	if (isKey(first)) {
+		return getReactiveValueInProxy(instance as never, mapped, first, isArray).subscribe(
+			second as never,
+			third as never,
+		);
+	}
+
+	return subscribeToSignal(state, first, second === true);
+}
+
+export function subscribeToReactive<Value, Item = Value>(
+	type: SubscriptionType,
+	state: ReactiveState<Value, Item>,
+	callback: (value: unknown) => unknown,
+): Subscription {
+	state.subscriptions ??= subscriptions({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY,
+	});
+
+	const [subscription, existing] = state.subscriptions.create({
+		key: type,
+		value: callback,
+	});
+
+	if (!existing) {
+		callback(
+			type === SUBSCRIPTION_TYPE_FROZEN
+				? getFrozenValue(state.value)
+				: peekSimpleValue(state.value, SUBSCRIPTION_TYPES_COPY.has(type)),
+		);
+	}
+
+	return subscription;
+}
+
+export function subscribeToSignal<Value, Item = Value>(
+	state: ReactiveState<Value, Item>,
+	callback: (value: unknown) => unknown,
+	copy: boolean,
+): Subscription {
+	return subscribeToReactive(
+		copy ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL,
+		state,
+		callback,
+	);
+}

package/src/helpers/value.ts

@@ -1,18 +1,41 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
 import {flushHandlers} from '../batch';
-import {ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH} from '../constants';
+import {
+	ACTIVE,
+	ARRAY_OFFSET,
+	ARRAY_PEEK,
+	ARRAY_THRESHOLD,
+	BATCH,
+	SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPES,
+} from '../constants';
 import type {ReactiveState} from '../models';
 
+// #region Functions
+
 export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	for (const computed of state.computeds) {
 		computed.dirty = true;
 	}
 
 	for (const effect of state.effects) {
-		BATCH.handlers.add(effect);
+		BATCH.handlers.set(effect, effect);
 	}
 
-	for (const [, subscription] of state.subscriptions) {
-		BATCH.handlers.add(subscription);
+	for (const type of SUBSCRIPTION_TYPES) {
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+
+		if (subscriptions != null) {
+			for (const [subscription, callback] of subscriptions) {
+				BATCH.handlers.set(subscription, {
+					callback,
+					state,
+					frozen: type === SUBSCRIPTION_TYPE_FROZEN,
+					copy: SUBSCRIPTION_TYPES_COPY.has(type),
+				});
+			}
+		}
 	}
 
 	if (BATCH.depth === 0) {
@@ -55,6 +78,18 @@ export function equalArrays<Value>(
 	return true;
 }
 
+export function getFrozenValue(value: unknown): unknown {
+	let frozen = value;
+
+	if (Array.isArray(frozen)) {
+		frozen = Object.freeze(frozen.slice());
+	} else if (isPlainObject(frozen)) {
+		frozen = Object.freeze({...frozen});
+	}
+
+	return frozen;
+}
+
 export function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value {
 	if (ACTIVE.computed != null) {
 		state.computeds.add(ACTIVE.computed);
@@ -101,3 +136,33 @@ export function handleSimpleValue<Value>(
 		onAfter?.();
 	}
 }
+
+export function peekSimpleValue(value: unknown, copy: boolean): unknown {
+	let peeked: unknown = value;
+
+	if (!copy) {
+		return peeked;
+	}
+
+	if (Array.isArray(peeked)) {
+		peeked = peeked.slice();
+	} else if (isPlainObject(peeked)) {
+		peeked = {...peeked};
+	}
+
+	return peeked;
+}
+
+export function updateSimpleValue<Value>(
+	state: ReactiveState<Value, Value>,
+	callback: (value: Value) => Value,
+	setValue: (state: ReactiveState<Value, Value>, value: Value) => void,
+): void {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Callback must be a function');
+	}
+
+	handleSimpleValue(state, callback(state.value), setValue);
+}
+
+// #endregion

package/src/index.ts

@@ -1,3 +1,4 @@
+export type {Subscription} from '@oscarpalmer/atoms/subscription';
 export {startBatch, stopBatch} from './batch';
 export {effect} from './effect';
 export {
@@ -16,7 +17,6 @@ export type {
 	ReactiveStore,
 	ReadonlySignal,
 	Signal,
-	Unsubscribe,
 } from './models';
 export {array} from './value/array';
 export {computed} from './value/computed';

package/src/models.ts

@@ -1,6 +1,9 @@
 import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {Subscription, Subscriptions} from '@oscarpalmer/atoms/subscription';
 import type {PROPERTY_LENGTH} from './constants';
 
+// #region Types
+
 export type Active = {
 	computed?: ComputedEffect;
 	effect?: EffectState;
@@ -9,7 +12,7 @@ export type Active = {
 export type Batch = {
 	depth: number;
 	flushing: boolean;
-	handlers: Set<EffectState | Subscription>;
+	handlers: Map<EffectState | Subscription, EffectState | StoredSubscription>;
 };
 
 export type Computed<Value> = Reactive<Value> & SimpleReactive<Value>;
@@ -228,18 +231,24 @@ export type ReactiveArray<Item> = {
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy Copy the array? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	subscribe(callback: (value: Item[]) => void, copy?: boolean): Subscription;
 
 	/**
 	 * Subscribe to changes at a specific index
 	 *
 	 * @param index Index of item to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the item is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
+	subscribe(
+		index: number,
+		callback: (value: Item | undefined) => void,
+		copy?: boolean,
+	): Subscription;
 
 	/**
 	 * Add items to the beginning of the array
@@ -248,21 +257,6 @@ export type ReactiveArray<Item> = {
 	 */
 	unshift(...items: Item[]): number;
 
-	/**
-	 * Unsubscribe from changes for a specific index
-	 *
-	 * @param index Index of the value to unsubscribe from
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(index: number, callback: (item: Item | undefined) => void): void;
-
-	/**
-	 * Unsubscribe from changes
-	 *
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(callback: (array: Item[]) => void): void;
-
 	/**
 	 * Update the value _(based on the current value)_
 	 *
@@ -282,13 +276,13 @@ export type ReactiveOptions<Value> = {
 	equal?: (first: Value, second: Value) => boolean;
 };
 
-export type ReactiveState<Value, Equal> = {
+export type ReactiveState<Value, Item = Value> = {
 	computeds: Set<ComputedEffect>;
 	effects: Set<EffectState>;
-	equal: (first: Equal, second: Equal) => boolean;
+	equal: (first: Item, second: Item) => boolean;
 	promise?: Promise<Value>;
 	promises?: Map<Key, Promise<never>>;
-	subscriptions: Map<GenericCallback, Subscription>;
+	subscriptions?: Subscriptions<GenericCallback>;
 	value: Value;
 };
 
@@ -403,56 +397,34 @@ export type ReactiveStore<Store> = {
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy Copy the store? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Store) => void): Unsubscribe;
+	subscribe(callback: (value: Store) => void, copy?: boolean): Subscription;
 
 	/**
 	 * Subscribe to changes for a specific key
 	 *
 	 * @param key Key of the value to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
 	subscribe<Key extends keyof Store>(
 		key: Key,
 		callback: (value: Store[Key] | undefined) => void,
-	): Unsubscribe;
+		copy?: boolean,
+	): Subscription;
 
 	/**
 	 * Subscribe to changes for a specific key
 	 *
 	 * @param key Key of the value to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
-	 */
-	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
-
-	/**
-	 * Unsubscribe from changes for a specific key
-	 *
-	 * @param key Key of the value to unsubscribe from
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe<Key extends keyof Store>(
-		key: Key,
-		callback: (value: Store[Key] | undefined) => void,
-	): void;
-
-	/**
-	 * Unsubscribe from changes for a specific key
-	 *
-	 * @param key Key of the value to unsubscribe from
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(key: Key, callback: (value: unknown | undefined) => void): void;
-
-	/**
-	 * Unsubscribe from changes
-	 *
-	 * @param callback Callback to unsubscribe
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	unsubscribe(callback: (value: Store) => void): void;
+	subscribe(key: Key, callback: (value: unknown) => void, copy?: boolean): Subscription;
 
 	/**
 	 * Update the value _(based on the current value)_
@@ -483,15 +455,6 @@ export type ReadonlySignalValue<Value> = Value extends unknown[]
 		? Readonly<Value>
 		: Value;
 
-export type SetValueInProxyParameters<Value, Equal> = {
-	target: Value;
-	property: PropertyKey;
-	value: unknown;
-	state: ReactiveState<Value, Equal>;
-	isArray: boolean;
-	length?: Signal<number>;
-};
-
 export type Signal<Value> = {
 	/**
 	 * Get a readonly version of the signal
@@ -538,34 +501,28 @@ type SimpleReactive<Value> = {
 	/**
 	 * Get the value _(without reactivity)_
 	 *
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
 	 * @returns Current value
 	 */
-	peek(): Value;
+	peek(copy?: boolean): Value;
 
 	/**
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
-
-	/**
-	 * Unsubscribe from changes
-	 *
-	 * @param callback Callback to unsubscribe
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	unsubscribe(callback: (value: Value) => void): void;
+	subscribe(callback: (value: Value) => void, copy?: boolean): Subscription;
 };
 
-export type Subscription = {
+export type StoredSubscription = {
 	callback: GenericCallback;
+	copy: boolean;
+	frozen: boolean;
 	state: ReactiveState<unknown, never>;
-
-	destroy(): void;
 };
 
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
+export type SubscriptionType = 'copy' | 'frozen' | 'original' | 'readonly';
+
+// #endregion