@oscarpalmer/mora 0.30.0 → 0.32.0

package/src/helpers/is.ts

@@ -5,20 +5,21 @@ import {
 	NAME_COMPUTED,
 	NAME_EFFECT,
 	NAME_MORA,
+	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE,
 } from '../constants';
-import type {Computed, Effect, Reactive, ReactiveArray, ReactiveStore, Signal} from '../models';
+import type {
+	Computed,
+	Effect,
+	Reactive,
+	ReactiveArray,
+	ReactiveStore,
+	ReadonlySignal,
+	Signal,
+} from '../models';
 
-/**
- * Is the value a reactive array?
- *
- * @param value Value to check
- * @returns True if value is a {@link ReactiveArray}
- */
-export function isArray<Item>(value: unknown): value is ReactiveArray<Item> {
-	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
-}
+// #region Functions
 
 /**
  * Is the value a computed signal?
@@ -40,7 +41,7 @@ export function isEffect(value: unknown): value is Effect {
 	return isMora<Effect>(value, NAME_EFFECT);
 }
 
-function isMora<T>(value: unknown, name: string | Set<string>): value is T {
+function isMora<Instance>(value: unknown, name: string | Set<string>): value is Instance {
 	return (
 		typeof value === 'object' &&
 		value != null &&
@@ -71,12 +72,36 @@ export function isSignal<Value>(value: unknown): value is Signal<Value> {
 	return isMora<Signal<Value>>(value, NAME_SIGNAL);
 }
 
+/**
+ * Is the value a reactive array?
+ *
+ * @param value Value to check
+ * @returns True if value is a {@link ReactiveArray}
+ */
+export function isReactiveArray<Item>(value: unknown): value is ReactiveArray<Item> {
+	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
+}
+
 /**
  * Is the value a reactive store?
  *
  * @param value Value to check
  * @returns True if value is a {@link Store}
  */
-export function isStore<Value extends PlainObject>(value: unknown): value is ReactiveStore<Value> {
+export function isReactiveStore<Value extends PlainObject>(
+	value: unknown,
+): value is ReactiveStore<Value> {
 	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,7 +1,23 @@
+export type {Subscription} from '@oscarpalmer/atoms/subscription';
 export {startBatch, stopBatch} from './batch';
 export {effect} from './effect';
-export {isArray, isComputed, isEffect, isReactive, isSignal} from './helpers/is';
-export type {Computed, Effect, ReactiveArray, ReactiveStore, Signal, Unsubscribe} from './models';
+export {
+	isComputed,
+	isEffect,
+	isReactive,
+	isReactiveArray,
+	isReactiveStore,
+	isReadonlySignal,
+	isSignal,
+} from './helpers/is';
+export type {
+	Computed,
+	Effect,
+	ReactiveArray,
+	ReactiveStore,
+	ReadonlySignal,
+	Signal,
+} from './models';
 export {array} from './value/array';
 export {computed} from './value/computed';
 export {signal} from './value/signal';