@oscarpalmer/mora 0.38.0 → 0.39.0

package/src/helpers/is.ts

@@ -4,10 +4,11 @@ import {
 	NAME_ARRAY,
 	NAME_COMPUTED,
 	NAME_EFFECT,
-	NAME_MORA,
 	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE,
+	SYMBOL_READONLY,
+	SYMBOL_STATE,
 } from '../constants';
 import type {
 	Computed,
@@ -41,13 +42,22 @@ export function isEffect(value: unknown): value is Effect {
 	return isMora<Effect>(value, NAME_EFFECT);
 }
 
-function isMora<Instance>(value: unknown, name: string | Set<string>): value is Instance {
-	return (
-		typeof value === 'object' &&
-		value != null &&
-		NAME_MORA in value &&
-		(typeof name === 'string' ? value[NAME_MORA] === name : name.has(value[NAME_MORA] as never))
-	);
+function isMora<Instance>(input: unknown, value: string | Set<string>): input is Instance {
+	if (typeof input !== 'object' || input === null) {
+		return false;
+	}
+
+	if (value === NAME_READONLY) {
+		return SYMBOL_READONLY in input;
+	}
+
+	if (!(SYMBOL_STATE in input)) {
+		return false;
+	}
+
+	const state = (input as PlainObject)[SYMBOL_STATE] as PlainObject;
+
+	return typeof value === 'string' ? state.name === value : value.has(state.name as never);
 }
 
 /**

package/src/helpers/misc.ts

@@ -1,10 +1,129 @@
-import type {ReactiveOptions, ReactiveState} from '../models';
+import {noop} from '@oscarpalmer/atoms/function';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {SYMBOL_EFFECT, SYMBOL_READONLY, SYMBOL_STATE} from '../constants';
+import {deactivateEffect} from '../effect';
+import type {
+	InternalArray,
+	InternalComputed,
+	InternalReactive,
+	InternalReadonly,
+	InternalStore,
+	ReactiveOptions,
+	ReactiveState,
+} from '../models';
+import {peekSignalValue} from './value';
 
 // #region Functions
 
-export function getState(value: unknown, options?: ReactiveOptions<unknown>): ReactiveState {
+export function deactivateComputed(this: InternalComputed): void {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return;
+	}
+
+	deactivateEffect(this[SYMBOL_EFFECT].instance);
+
+	deactivateReactive.call(this);
+}
+
+export function deactivateProxy(this: InternalArray | InternalStore): void {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return;
+	}
+
+	if (state.derived != null) {
+		for (const computed of state.derived) {
+			computed.deactivate();
+		}
+
+		state.derived.clear();
+
+		state.derived = undefined;
+	}
+
+	if (state.mapped != null) {
+		for (const [, computed] of state.mapped) {
+			computed.deactivate();
+		}
+
+		state.mapped.clear();
+
+		state.mapped = undefined;
+	}
+
+	deactivateReactive.call(this);
+}
+
+export function deactivateReactive(this: InternalReactive): void {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return;
+	}
+
+	state.active = false;
+
+	state.computeds?.clear();
+	state.effects?.clear();
+	state.promises?.clear();
+	state.readonlies?.frozen?.deactivate();
+	state.readonlies?.original?.deactivate();
+	state.subscriptions?.clear();
+
+	state.equal = noop as never;
+	state.promise = undefined;
+
+	state.computeds = undefined;
+	state.effects = undefined;
+	state.promises = undefined;
+	state.readonlies = undefined;
+	state.subscriptions = undefined;
+}
+
+export function deactivateReadonly(this: InternalReadonly): void {
+	const readonly = this[SYMBOL_READONLY];
+	const signal = this[SYMBOL_STATE];
+
+	if (!readonly.active) {
+		return;
+	}
+
+	(signal.readonlies as PlainObject)![readonly.name] = undefined;
+
+	if (readonly.subscriptions != null) {
+		for (const subscription of readonly.subscriptions) {
+			subscription.unsubscribe();
+		}
+
+		readonly.subscriptions.clear();
+
+		readonly.subscriptions = undefined;
+	}
+
+	readonly.active = false;
+	readonly.value = peekSignalValue.call(this, true);
+}
+
+export function getReactiveActive(this: InternalReactive): boolean {
+	return this[SYMBOL_STATE].active;
+}
+
+export function getReadonlyActive(this: InternalReadonly): boolean {
+	return this[SYMBOL_READONLY].active;
+}
+
+export function getState(
+	name: string,
+	value: unknown,
+	options?: ReactiveOptions<unknown>,
+): ReactiveState {
 	return {
+		name,
 		value,
+		active: true,
 		equal:
 			typeof options === 'object' && typeof options?.equal === 'function'
 				? options.equal

package/src/helpers/proxy.ts

@@ -5,10 +5,17 @@ import type {
 	Key,
 	PlainObject,
 } from '@oscarpalmer/atoms/models';
-import {attempt} from '@oscarpalmer/atoms/result';
+import {getNumber} from '@oscarpalmer/atoms/number';
+import {getString} from '@oscarpalmer/atoms/string';
 import {startBatch, stopBatch} from '../batch';
-import {PROPERTY_LENGTH, SYMBOL_EFFECT, SYMBOL_STATE} from '../constants';
-import type {InternalArray, InternalComputed, InternalStore, ReactiveProxyState} from '../models';
+import {MESSAGE_UPDATE_CALLBACK, PROPERTY_LENGTH, SYMBOL_EFFECT, SYMBOL_STATE} from '../constants';
+import type {
+	Computed,
+	InternalArray,
+	InternalComputed,
+	InternalStore,
+	ReactiveProxyState,
+} from '../models';
 import {internalComputed} from '../value/computed';
 import {emitValue, getSignalValue, peekSignalValue} from './value';
 
@@ -22,7 +29,7 @@ export function getReactiveValueInProxy(
 
 	state.mapped ??= new Map();
 
-	const mapKey = String(key);
+	const mapKey = getString(key);
 
 	let item = state.mapped.get(mapKey);
 
@@ -40,9 +47,15 @@ export function getReactiveValueInProxy(
 }
 
 export function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return peekValueInProxy.call(this, first);
+	}
+
 	let signal: InternalComputed | undefined;
 
-	if (this[SYMBOL_STATE].isArray ? typeof first === 'number' : isKey(first)) {
+	if (state.isArray ? typeof first === 'number' : isKey(first)) {
 		signal = getReactiveValueInProxy(this, first as Key);
 	}
 
@@ -50,7 +63,7 @@ export function getValueInProxy(this: InternalArray | InternalStore, first?: unk
 }
 
 function isProxyKey(isArray: boolean, value: unknown): value is Key {
-	return isArray ? typeof value === 'number' : isKey(value);
+	return (isArray && typeof value === 'number') || isKey(value);
 }
 
 function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainObject {
@@ -60,6 +73,10 @@ function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainO
 export function notifyProxyValue(this: InternalArray | InternalStore): void {
 	const state = this[SYMBOL_STATE];
 
+	if (!state.active) {
+		return;
+	}
+
 	state.mapped ??= new Map();
 
 	const values = [...state.mapped.values()];
@@ -157,6 +174,10 @@ export function setProxyValue(
 ): void {
 	const state = this[SYMBOL_STATE];
 
+	if (!state.active) {
+		return;
+	}
+
 	if (state.isArray && first === PROPERTY_LENGTH) {
 		(state.value as unknown[]).length = second as number;
 
@@ -232,8 +253,12 @@ export function setValueInProxy(
 ): boolean {
 	const state = instance[SYMBOL_STATE];
 
+	if (!state.active) {
+		return true;
+	}
+
 	if (state.isArray) {
-		const isIndex = !Number.isNaN(Number(property));
+		const isIndex = !Number.isNaN(getNumber(property));
 		const isLength = property === PROPERTY_LENGTH;
 
 		if (!(isIndex || isLength)) {
@@ -256,12 +281,37 @@ export function setValueInProxy(
 	return true;
 }
 
+export function updateProxyDerivations(
+	instance: InternalArray | InternalStore,
+	value: Computed<unknown[]>,
+): Computed<unknown[]> {
+	const state = instance[SYMBOL_STATE];
+
+	if (state.derived == null) {
+		state.derived = new Set([value]);
+
+		return value;
+	}
+
+	for (const computed of state.derived) {
+		if (!computed.active) {
+			state.derived.delete(computed);
+		}
+	}
+
+	state.derived.add(value);
+
+	return value;
+}
+
 export function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void {
 	if (typeof callback !== 'function') {
-		throw new TypeError('Callback must be a function');
+		throw new TypeError(MESSAGE_UPDATE_CALLBACK);
 	}
 
-	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+	if (this[SYMBOL_STATE].active) {
+		setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+	}
 }
 
 // #endregion

package/src/helpers/subscription.ts

@@ -2,6 +2,7 @@ import {isKey} from '@oscarpalmer/atoms/is';
 import type {Key} from '@oscarpalmer/atoms/models';
 import {subscriptions, type Subscription} from '@oscarpalmer/atoms/subscription';
 import {
+	MESSAGE_DEACTIVATED_SUBSCRIPTION,
 	SUBSCRIPTION_PROPERTY,
 	SUBSCRIPTION_TYPE_COPY,
 	SUBSCRIPTION_TYPE_FROZEN,
@@ -9,6 +10,7 @@ import {
 	SUBSCRIPTION_TYPE_READONLY,
 	SUBSCRIPTION_TYPES,
 	SUBSCRIPTION_TYPES_COPY,
+	SYMBOL_READONLY,
 	SYMBOL_STATE,
 } from '../constants';
 import type {
@@ -30,6 +32,10 @@ export function subscribeToProxy(
 	second?: Subscriber<unknown> | boolean,
 	third?: boolean,
 ): Subscription {
+	if (!this[SYMBOL_STATE].active) {
+		throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
+	}
+
 	if (isKey(first)) {
 		return getReactiveValueInProxy(this, first).subscribe(second as Subscriber<unknown>, third);
 	}
@@ -42,12 +48,18 @@ function subscribeToReactive(
 	type: SubscriptionType,
 	subscriber: Subscriber<unknown>,
 ): Subscription {
-	this[SYMBOL_STATE].subscriptions ??= subscriptions({
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
+	}
+
+	state.subscriptions ??= subscriptions({
 		keys: SUBSCRIPTION_TYPES,
 		property: SUBSCRIPTION_PROPERTY,
 	});
 
-	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
+	const [subscription, existing] = state.subscriptions.create({
 		key: type,
 		value: subscriber,
 	});
@@ -55,7 +67,7 @@ function subscribeToReactive(
 	if (!existing) {
 		subscriber(
 			type === SUBSCRIPTION_TYPE_FROZEN
-				? getFrozenValue(this[SYMBOL_STATE].value)
+				? getFrozenValue(state.value)
 				: peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)),
 			subscription,
 		);
@@ -68,11 +80,29 @@ export function subscribeToReadonly(
 	this: InternalReadonly,
 	subscriber: Subscriber<unknown>,
 ): Subscription {
-	return subscribeToReactive.call(
+	const state = this[SYMBOL_READONLY];
+
+	if (!state.active) {
+		throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
+	}
+
+	const subscription = subscribeToReactive.call(
 		this,
 		this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY,
 		subscriber,
 	);
+
+	state.subscriptions ??= new Set();
+
+	for (const existing of state.subscriptions) {
+		if (!existing.active) {
+			state.subscriptions.delete(existing);
+		}
+	}
+
+	state.subscriptions.add(subscription);
+
+	return subscription;
 }
 
 export function subscribeToSignal(

package/src/helpers/value.ts

@@ -1,6 +1,5 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
-import {round} from '@oscarpalmer/atoms/math';
-import {attempt} from '@oscarpalmer/atoms/result';
+import {min, round} from '@oscarpalmer/atoms/math';
 import {flushHandlers} from '../batch';
 import {
 	ACTIVE,
@@ -8,13 +7,21 @@ import {
 	ARRAY_PEEK,
 	ARRAY_THRESHOLD,
 	BATCH,
+	MESSAGE_UPDATE_CALLBACK,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPES,
 	SUBSCRIPTION_TYPES_COPY,
 	SYMBOL_EFFECT,
+	SYMBOL_READONLY,
 	SYMBOL_STATE,
 } from '../constants';
-import type {InternalArray, InternalComputed, InternalStateful, InternalStore} from '../models';
+import type {
+	InternalArray,
+	InternalComputed,
+	InternalReadonly,
+	InternalStateful,
+	InternalStore,
+} from '../models';
 
 // #region Types
 
@@ -29,13 +36,21 @@ export function emitValue(instance: InternalStateful, notify?: boolean): void {
 
 	if (state.computeds != null && state.computeds.size > 0) {
 		for (const computed of state.computeds) {
-			computed.dirty = true;
+			if (computed.instance.active) {
+				computed.dirty = true;
+			} else {
+				state.computeds.delete(computed);
+			}
 		}
 	}
 
 	if (state.effects != null && state.effects.size > 0) {
 		for (const effect of state.effects) {
-			BATCH.handlers.set(effect, effect);
+			if (effect.active) {
+				BATCH.handlers.set(effect, effect);
+			} else {
+				state.effects.delete(effect);
+			}
 		}
 	}
 
@@ -45,9 +60,9 @@ export function emitValue(instance: InternalStateful, notify?: boolean): void {
 		const mapped = state.mapped as Map<unknown, InternalComputed>;
 
 		for (const [, item] of mapped) {
-			const fx = item[SYMBOL_EFFECT];
+			const {instance} = item[SYMBOL_EFFECT];
 
-			BATCH.handlers.set(fx.instance, fx.instance);
+			BATCH.handlers.set(instance, instance);
 		}
 	}
 
@@ -89,7 +104,7 @@ export function equalArrays(
 
 	if (length >= ARRAY_THRESHOLD) {
 		offset = round(length / ARRAY_PEEK);
-		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
+		offset = min([offset, ARRAY_OFFSET]);
 
 		for (let index = 0; index < offset; index += 1) {
 			if (
@@ -126,13 +141,21 @@ export function getFrozenValue(value: unknown): unknown {
 	return frozen;
 }
 
-export function getJsonValue(this: InternalStateful): unknown {
+export function getJsonValue(this: InternalReadonly | InternalStateful): unknown {
+	if (SYMBOL_READONLY in this && !this[SYMBOL_READONLY].active) {
+		return this[SYMBOL_READONLY].value;
+	}
+
 	return this[SYMBOL_STATE].value;
 }
 
 export function getSignalValue(this: InternalStateful): unknown {
 	const state = this[SYMBOL_STATE];
 
+	if (!state.active) {
+		return state.value;
+	}
+
 	if (ACTIVE.computed != null) {
 		state.computeds ??= new Set();
 
@@ -148,10 +171,14 @@ export function getSignalValue(this: InternalStateful): unknown {
 	return state.value;
 }
 
-export function getStringValue(this: InternalStateful, json?: boolean): string {
-	return json === true
-		? JSON.stringify(this[SYMBOL_STATE].value)
-		: String(this[SYMBOL_STATE].value);
+export function getStringValue(this: InternalReadonly | InternalStateful, json?: boolean): string {
+	let {value} = this[SYMBOL_STATE];
+
+	if (SYMBOL_READONLY in this && !this[SYMBOL_READONLY].active) {
+		value = this[SYMBOL_READONLY].value;
+	}
+
+	return json === true ? JSON.stringify(value) : String(value);
 }
 
 export function handleSignal(
@@ -163,6 +190,10 @@ export function handleSignal(
 ): void {
 	const state = instance[SYMBOL_STATE];
 
+	if (!state.active) {
+		return;
+	}
+
 	try {
 		let actual = typeof origin === 'function' ? (origin as () => unknown)() : origin;
 
@@ -217,10 +248,12 @@ export function updateSignal(
 	setValue: (instance: InternalStateful, value: unknown) => void,
 ): void {
 	if (typeof callback !== 'function') {
-		throw new TypeError('Callback must be a function');
+		throw new TypeError(MESSAGE_UPDATE_CALLBACK);
 	}
 
-	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	if (instance[SYMBOL_STATE].active) {
+		handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	}
 }
 
 // #endregion

package/src/models.ts

@@ -1,6 +1,6 @@
 import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import type {Subscription, Subscriptions} from '@oscarpalmer/atoms/subscription';
-import {SYMBOL_EFFECT, SYMBOL_STATE, type PROPERTY_LENGTH} from './constants';
+import {SYMBOL_EFFECT, SYMBOL_READONLY, SYMBOL_STATE, type PROPERTY_LENGTH} from './constants';
 
 // #region Types
 
@@ -23,10 +23,21 @@ export type ComputedEffect = {
 	notify: boolean;
 };
 
-export type Effect = {};
+export type Effect = {
+	/**
+	 * Is the effect active?
+	 */
+	get active(): boolean;
+	/**
+	 * Stop the effect
+	 */
+	stop(): void;
+};
 
 export type EffectState = {
+	active: boolean;
 	callback: GenericCallback;
+	name: string;
 };
 
 export type InternalArray = {
@@ -38,8 +49,16 @@ export type InternalComputed = {
 } & Computed<unknown> &
 	InternalStateful;
 
+export type InternalEffect = {
+	[SYMBOL_STATE]: EffectState;
+} & Effect;
+
+export type InternalReactive = {
+	[SYMBOL_STATE]: SignalState;
+} & Reactive<unknown>;
+
 export type InternalReadonly = {
-	frozen: boolean;
+	[SYMBOL_READONLY]: ReadonlyState;
 } & InternalStateful &
 	ReadonlySignal<unknown>;
 
@@ -54,6 +73,16 @@ export type InternalStore = {
 } & ReactiveStore<PlainObject>;
 
 export type Reactive<Value> = {
+	/**
+	 * Is the signal active?
+	 */
+	get active(): boolean;
+
+	/**
+	 * Deactivate the signal, preventing further updates
+	 */
+	deactivate(): void;
+
 	/**
 	 * Get the value
 	 *
@@ -323,15 +352,18 @@ export type ReactiveOptions<Value> = {
 };
 
 export type ReactiveProxyState = {
+	derived?: Set<Computed<unknown>>;
 	isArray: boolean;
 	length?: Signal<number>;
 	mapped?: Map<string, InternalComputed>;
 } & SignalState;
 
 export type ReactiveState<Value = unknown, Item = Value> = {
+	active: boolean;
 	computeds?: Set<ComputedEffect>;
 	effects?: Set<EffectState>;
 	equal?: (first: Item, second: Item) => boolean;
+	name: string;
 	promise?: Promise<unknown>;
 	promises?: Map<Key, Promise<never>>;
 	subscriptions?: Subscriptions<GenericCallback>;
@@ -506,6 +538,13 @@ export type ReadonlySignalValue<Value> = Value extends unknown[]
 		? Readonly<Value>
 		: Value;
 
+export type ReadonlyState = {
+	active: boolean;
+	name: string;
+	subscriptions?: Set<Subscription>;
+	value?: unknown;
+};
+
 export type Signal<Value> = {
 	/**
 	 * Get a readonly version of the signal