@oscarpalmer/mora 0.31.0 → 0.33.0

package/src/helpers/subscription.ts

@@ -0,0 +1,89 @@
+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_TYPE_READONLY,
+	SUBSCRIPTION_TYPES,
+	SUBSCRIPTION_TYPES_COPY,
+	SYMBOL_STATE,
+} from '../constants';
+import type {
+	InternalProxy,
+	InternalReadonly,
+	InternalSignal,
+	Subscriber,
+	SubscriptionType,
+} from '../models';
+import {getReactiveValueInProxy} from './proxy';
+import {getFrozenValue, peekSignalValue} from './value';
+
+// #region Functions
+
+export function subscribeToProxy(
+	this: InternalProxy,
+	first: Key | Subscriber<unknown>,
+	second?: Subscriber<unknown> | boolean,
+	third?: boolean,
+): Subscription {
+	if (isKey(first)) {
+		return getReactiveValueInProxy(this as never, first).subscribe(second as never, third as never);
+	}
+
+	return subscribeToSignal.call(this, first, second);
+}
+
+function subscribeToReactive(
+	this: InternalSignal,
+	type: SubscriptionType,
+	subscriber: Subscriber<unknown>,
+): Subscription {
+	this[SYMBOL_STATE].subscriptions ??= subscriptions({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY,
+	});
+
+	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
+		key: type,
+		value: subscriber,
+	});
+
+	if (!existing) {
+		subscriber(
+			type === SUBSCRIPTION_TYPE_FROZEN
+				? getFrozenValue(this[SYMBOL_STATE].value)
+				: peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)),
+			subscription,
+		);
+	}
+
+	return subscription;
+}
+
+export function subscribeToReadonly(
+	this: InternalReadonly,
+	subscriber: Subscriber<unknown>,
+): Subscription {
+	return subscribeToReactive.call(
+		this,
+		this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY,
+		subscriber,
+	);
+}
+
+export function subscribeToSignal(
+	this: InternalSignal,
+	subscriber: Subscriber<unknown>,
+	copy?: unknown,
+): Subscription {
+	return subscribeToReactive.call(
+		this,
+		copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL,
+		subscriber,
+	);
+}
+
+// #endregion

package/src/helpers/value.ts

@@ -1,18 +1,49 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
 import {flushHandlers} from '../batch';
-import {ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH} from '../constants';
-import type {ReactiveState} from '../models';
-
-export function emitValue<Value>(state: ReactiveState<Value, never>): void {
-	for (const computed of state.computeds) {
-		computed.dirty = true;
+import {
+	ACTIVE,
+	ARRAY_OFFSET,
+	ARRAY_PEEK,
+	ARRAY_THRESHOLD,
+	BATCH,
+	SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPES,
+	SYMBOL_STATE,
+} from '../constants';
+import type {ReactiveState, InternalSignal} from '../models';
+
+// #region Functions
+
+export function emitValue(instance: InternalSignal): void {
+	const state = instance[SYMBOL_STATE];
+
+	if (state.computeds != null && state.computeds.size > 0) {
+		for (const computed of state.computeds) {
+			computed.dirty = true;
+		}
 	}
 
-	for (const effect of state.effects) {
-		BATCH.handlers.add(effect);
+	if (state.effects != null && state.effects.size > 0) {
+		for (const effect of state.effects) {
+			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 && subscriptions.size > 0) {
+			for (const [subscription, callback] of subscriptions) {
+				BATCH.handlers.set(subscription, {
+					callback,
+					instance,
+					state,
+					frozen: type === SUBSCRIPTION_TYPE_FROZEN,
+					copy: SUBSCRIPTION_TYPES_COPY.has(type),
+				});
+			}
+		}
 	}
 
 	if (BATCH.depth === 0) {
@@ -20,17 +51,15 @@ export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	}
 }
 
-export function equalArrays<Value>(
-	state: ReactiveState<Value[], Value>,
-	first: Value[],
-	second: Value[],
-): boolean {
-	let {length} = first;
+export function equalArrays(state: ReactiveState, first: unknown[], second: unknown[]): boolean {
+	const {length} = first;
 
 	if (length !== second.length) {
 		return false;
 	}
 
+	const eq = state.equal ?? Object.is;
+
 	let offset = 0;
 
 	if (length >= ARRAY_THRESHOLD) {
@@ -38,16 +67,21 @@ export function equalArrays<Value>(
 		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {
-			if (!state.equal(first[index], second[index])) {
+			if (
+				!(
+					eq(first[index], second[index]) &&
+					eq(first[length - index - 1], second[length - index - 1])
+				)
+			) {
 				return false;
 			}
 		}
 	}
 
-	length -= offset;
+	const end = length - offset;
 
-	for (let index = offset; index < length; index += 1) {
-		if (!state.equal(first[index], second[index])) {
+	for (let index = offset; index < end; index += 1) {
+		if (!eq(first[index], second[index])) {
 			return false;
 		}
 	}
@@ -55,24 +89,48 @@ export function equalArrays<Value>(
 	return true;
 }
 
-export function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value {
+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 getSignalValue(this: InternalSignal): unknown {
 	if (ACTIVE.computed != null) {
-		state.computeds.add(ACTIVE.computed);
+		this[SYMBOL_STATE].computeds ??= new Set();
+
+		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
 	}
 
 	if (ACTIVE.effect != null) {
-		state.effects.add(ACTIVE.effect);
+		this[SYMBOL_STATE].effects ??= new Set();
+
+		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
 	}
 
-	return state.value;
+	return this[SYMBOL_STATE].value;
+}
+
+export function getStringValue(this: InternalSignal, json?: boolean): string {
+	return json === true
+		? JSON.stringify(this[SYMBOL_STATE].value)
+		: String(this[SYMBOL_STATE].value);
 }
 
-export function handleSimpleValue<Value>(
-	state: ReactiveState<Value, Value>,
-	origin: Value | (() => Value | Promise<Value>) | Promise<Value>,
-	setValue: (state: ReactiveState<Value, Value>, value: Value) => void,
+export function handleSignalValue(
+	instance: InternalSignal,
+	origin: unknown,
+	setValue: (instance: InternalSignal, value: unknown) => void,
 	onAfter?: () => void,
 ): void {
+	const state = instance[SYMBOL_STATE];
+
 	try {
 		let actual = typeof origin === 'function' ? (origin as () => unknown)() : origin;
 
@@ -84,7 +142,7 @@ export function handleSimpleValue<Value>(
 					if (actual === state.promise) {
 						state.promise = undefined;
 
-						setValue(state, value);
+						setValue(instance, value);
 					}
 				})
 				.catch(() => {
@@ -93,7 +151,7 @@ export function handleSimpleValue<Value>(
 					}
 				});
 		} else {
-			setValue(state, actual as Value);
+			setValue(instance, actual);
 		}
 	} catch {
 		// ?
@@ -101,3 +159,36 @@ export function handleSimpleValue<Value>(
 		onAfter?.();
 	}
 }
+
+export function peekSignalValue(
+	this: InternalSignal | [InternalSignal, unknown],
+	copy?: boolean,
+): unknown {
+	let peeked: unknown = Array.isArray(this) ? this[1] : this[SYMBOL_STATE].value;
+
+	if (copy !== true) {
+		return peeked;
+	}
+
+	if (Array.isArray(peeked)) {
+		peeked = peeked.slice();
+	} else if (isPlainObject(peeked)) {
+		peeked = {...peeked};
+	}
+
+	return peeked;
+}
+
+export function updateSignalValue(
+	instance: InternalSignal,
+	callback: (value: unknown) => unknown,
+	setValue: (instance: InternalSignal, value: unknown) => void,
+): void {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Callback must be a function');
+	}
+
+	handleSignalValue(instance, callback(instance[SYMBOL_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,5 +1,8 @@
 import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
-import type {PROPERTY_LENGTH} from './constants';
+import type {Subscription, Subscriptions} from '@oscarpalmer/atoms/subscription';
+import {SYMBOL_EFFECT, SYMBOL_STATE, type PROPERTY_LENGTH} from './constants';
+
+// #region Types
 
 export type Active = {
 	computed?: ComputedEffect;
@@ -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>;
@@ -25,20 +28,37 @@ export type EffectState = {
 	callback: GenericCallback;
 };
 
+export type InternalComputed = {
+	[SYMBOL_EFFECT]: ComputedEffect;
+} & InternalSignal;
+
+export type InternalProxy = {
+	[SYMBOL_STATE]: ReactiveProxyState;
+};
+
+export type InternalReadonly = {
+	frozen: boolean;
+} & InternalSignal;
+
+export type InternalSignal = {
+	[SYMBOL_STATE]: SignalState;
+};
+
 export type Reactive<Value> = {
 	/**
-	 * JSON representation of the value
+	 * _JSON_ representation of the value
 	 *
-	 * @returns JSON value
+	 * @returns _JSON_ value
 	 */
 	toJSON(): Value;
 
 	/**
 	 * String representation of the value
 	 *
+	 * @param json When `true`, returns the _JSON_ string representation of the value _(defaults to `false`)_
 	 * @returns Value as string
 	 */
-	toString(): string;
+	toString(json?: boolean): string;
 };
 
 export type ReactiveArray<Item> = {
@@ -227,19 +247,21 @@ export type ReactiveArray<Item> = {
 	/**
 	 * Subscribe to changes
 	 *
-	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param subscriber Callback for changes
+	 * @param copy Copy the array? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	subscribe(subscriber: Subscriber<Item[]>, 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 subscriber Callback for changes
+	 * @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, subscriber: Subscriber<Item | undefined>, copy?: boolean): Subscription;
 
 	/**
 	 * Add items to the beginning of the array
@@ -248,21 +270,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,14 +289,20 @@ export type ReactiveOptions<Value> = {
 	equal?: (first: Value, second: Value) => boolean;
 };
 
-export type ReactiveState<Value, Equal> = {
-	computeds: Set<ComputedEffect>;
-	effects: Set<EffectState>;
-	equal: (first: Equal, second: Equal) => boolean;
-	promise?: Promise<Value>;
+export type ReactiveProxyState = {
+	isArray: boolean;
+	length?: Signal<number>;
+	mapped?: Map<string, [Computed<unknown>, ComputedEffect]>;
+} & SignalState;
+
+export type ReactiveState = {
+	computeds?: Set<ComputedEffect>;
+	effects?: Set<EffectState>;
+	equal?: (first: unknown, second: unknown) => boolean;
+	promise?: Promise<unknown>;
 	promises?: Map<Key, Promise<never>>;
-	subscriptions: Map<GenericCallback, Subscription>;
-	value: Value;
+	subscriptions?: Subscriptions<GenericCallback>;
+	value: unknown;
 };
 
 export type ReactiveStore<Store> = {
@@ -402,57 +415,35 @@ export type ReactiveStore<Store> = {
 	/**
 	 * Subscribe to changes
 	 *
-	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param subscriber Callback for changes
+	 * @param copy Copy the store? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Store) => void): Unsubscribe;
+	subscribe(subscriber: Subscriber<Store>, 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 subscriber Callback for changes
+	 * @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;
+		subscriber: Subscriber<Store[Key] | undefined>,
+		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 subscriber Callback for changes
+	 * @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, subscriber: Subscriber<unknown>, copy?: boolean): Subscription;
 
 	/**
 	 * Update the value _(based on the current value)_
@@ -462,7 +453,7 @@ export type ReactiveStore<Store> = {
 	update(callback: (value: Store) => Store): void;
 } & Reactive<Store>;
 
-export type ReadonlyInstances<Value> = {
+type ReadonlyInstances<Value> = {
 	frozen?: ReadonlyFrozenSignal<Value>;
 	original?: ReadonlySignal<Value>;
 };
@@ -483,15 +474,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
@@ -527,6 +509,10 @@ export type Signal<Value> = {
 } & Reactive<Value> &
 	SimpleReactive<Value>;
 
+export type SignalState = {
+	readonlies?: ReadonlyInstances<unknown>;
+} & ReactiveState;
+
 type SimpleReactive<Value> = {
 	/**
 	 * Get the value
@@ -538,34 +524,31 @@ 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 subscriber Callback for changes
+	 * @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(subscriber: Subscriber<Value>, copy?: boolean): Subscription;
 };
 
-export type Subscription = {
+export type StoredSubscription = {
 	callback: GenericCallback;
-	state: ReactiveState<unknown, never>;
-
-	destroy(): void;
+	copy: boolean;
+	frozen: boolean;
+	instance: InternalSignal;
+	state: SignalState;
 };
 
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
+export type Subscriber<Value> = (value: Value, subscription: Subscription) => void;
+
+export type SubscriptionType = 'copy' | 'frozen' | 'original' | 'readonly';
+
+// #endregion