@oscarpalmer/mora 0.38.0 → 0.39.0

package/dist/batch.d.mts

@@ -1,4 +1,3 @@
-//#region src/batch.d.ts
 export declare function flushHandlers(): void;
 /**
  * Start batching effects
@@ -9,5 +8,4 @@ export declare function startBatch(): void;
 /**
  * Stop batching effects and flush _(run)_ them
  */
-export declare function stopBatch(): void;
-//#endregion
+export declare function stopBatch(): void;

package/dist/batch.mjs

@@ -1,8 +1,7 @@
 import { BATCH } from "./constants.mjs";
 import { runEffect } from "./effect.mjs";
 import { getFrozenValue, peekSignalValue } from "./helpers/value.mjs";
-import "@oscarpalmer/atoms/result";
-//#region src/batch.ts
+// src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
 	BATCH.flushing = true;
@@ -12,7 +11,8 @@ function flushHandlers() {
 			const { length } = handlers;
 			BATCH.handlers.clear();
 			for (let index = 0; index < length; index += 1) {
-				const [, handler] = handlers[index];
+				const [owner, handler] = handlers[index];
+				if (!owner.active) continue;
 				const subscription = handler;
 				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSignalValue.call(subscription.instance, subscription.copy));
 				else runEffect(handler);
@@ -37,5 +37,4 @@ function stopBatch() {
 	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
-//#endregion
 export { flushHandlers, startBatch, stopBatch };

package/dist/constants.d.mts

@@ -1,30 +1,36 @@
 import { Active, Batch, SubscriptionType } from "./models.mjs";
 import { SubscriptionProperty } from "@oscarpalmer/atoms/subscription";
-//#region src/constants.d.ts
 export declare const ACTIVE: Active;
 export declare const ARRAY_THRESHOLD = 100;
 export declare const ARRAY_OFFSET = 25;
 export declare const ARRAY_PEEK = 10;
 export declare const BATCH: Batch;
+export declare const MESSAGE_COMPUTED_CALLBACK = "Computed callback must be a function";
+export declare const MESSAGE_DEACTIVATED_ARRAY_FILTER = "Cannot filter an inactive reactive array";
+export declare const MESSAGE_DEACTIVATED_ARRAY_MAP = "Cannot map an inactive reactive array";
+export declare const MESSAGE_DEACTIVATED_ARRAY_SELECT = "Cannot select from an inactive reactive array";
+export declare const MESSAGE_DEACTIVATED_READONLY = "Cannot create readonly variant of inactive signal";
+export declare const MESSAGE_DEACTIVATED_SUBSCRIPTION = "Cannot subscribe to inactive signal";
+export declare const MESSAGE_EFFECT_CALLBACK = "Effect callback must be a function";
+export declare const MESSAGE_UPDATE_CALLBACK = "Update callback must be a function";
 export declare const METHODS_AFFECTING_LENGTH: Set<string | symbol>;
 export declare const METHODS_UPDATE: Set<string | symbol>;
 export declare const NAME_ARRAY = "array";
 export declare const NAME_COMPUTED = "computed";
 export declare const NAME_EFFECT = "effect";
-export declare const NAME_MORA = "$mora";
 export declare const NAME_READONLY = "readonly";
 export declare const NAME_SIGNAL = "signal";
 export declare const NAME_STORE = "store";
 export declare const NAME_SUBSCRIPTION = "subscription";
 export declare const NAME_ALL: Set<string>;
 export declare const PROPERTY_LENGTH = "length";
-export declare const SYMBOL_EFFECT: symbol;
-export declare const SYMBOL_STATE: symbol;
+export declare const SYMBOL_EFFECT: unique symbol;
+export declare const SYMBOL_READONLY: unique symbol;
+export declare const SYMBOL_STATE: unique symbol;
 export declare const SUBSCRIPTION_PROPERTY: SubscriptionProperty;
-export declare const SUBSCRIPTION_TYPE_COPY: SubscriptionType;
-export declare const SUBSCRIPTION_TYPE_FROZEN: SubscriptionType;
-export declare const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType;
-export declare const SUBSCRIPTION_TYPE_READONLY: SubscriptionType;
+export declare const SUBSCRIPTION_TYPE_COPY: "copy";
+export declare const SUBSCRIPTION_TYPE_FROZEN: "frozen";
+export declare const SUBSCRIPTION_TYPE_ORIGINAL: "original";
+export declare const SUBSCRIPTION_TYPE_READONLY: "readonly";
 export declare const SUBSCRIPTION_TYPES_COPY: Set<SubscriptionType>;
-export declare const SUBSCRIPTION_TYPES: Set<SubscriptionType>;
-//#endregion
+export declare const SUBSCRIPTION_TYPES: Set<SubscriptionType>;

package/dist/constants.mjs

@@ -1,4 +1,4 @@
-//#region src/constants.ts
+// src/constants.ts
 const ACTIVE = {};
 const ARRAY_THRESHOLD = 100;
 const ARRAY_OFFSET = 25;
@@ -8,6 +8,14 @@ const BATCH = {
 	flushing: false,
 	handlers: /* @__PURE__ */ new Map()
 };
+const MESSAGE_COMPUTED_CALLBACK = "Computed callback must be a function";
+const MESSAGE_DEACTIVATED_ARRAY_FILTER = "Cannot filter an inactive reactive array";
+const MESSAGE_DEACTIVATED_ARRAY_MAP = "Cannot map an inactive reactive array";
+const MESSAGE_DEACTIVATED_ARRAY_SELECT = "Cannot select from an inactive reactive array";
+const MESSAGE_DEACTIVATED_READONLY = "Cannot create readonly variant of inactive signal";
+const MESSAGE_DEACTIVATED_SUBSCRIPTION = "Cannot subscribe to inactive signal";
+const MESSAGE_EFFECT_CALLBACK = "Effect callback must be a function";
+const MESSAGE_UPDATE_CALLBACK = "Update callback must be a function";
 const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
 	"push",
@@ -25,7 +33,6 @@ const METHODS_UPDATE = /* @__PURE__ */ new Set([
 const NAME_ARRAY = "array";
 const NAME_COMPUTED = "computed";
 const NAME_EFFECT = "effect";
-const NAME_MORA = "$mora";
 const NAME_READONLY = "readonly";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
@@ -33,15 +40,15 @@ const NAME_SUBSCRIPTION = "subscription";
 const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
-	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
 const PROPERTY_LENGTH = "length";
 const SYMBOL_EFFECT = Symbol("effect");
+const SYMBOL_READONLY = Symbol("readonly");
 const SYMBOL_STATE = Symbol("state");
 const SUBSCRIPTION_PROPERTY = {
-	key: NAME_MORA,
+	key: "$mora",
 	value: NAME_SUBSCRIPTION
 };
 const SUBSCRIPTION_TYPE_COPY = "copy";
@@ -54,5 +61,4 @@ const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPE_ORIGINAL
 ]);
-//#endregion
-export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_READONLY, NAME_SIGNAL, NAME_STORE, NAME_SUBSCRIPTION, PROPERTY_LENGTH, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_EFFECT, SYMBOL_STATE };
+export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, MESSAGE_COMPUTED_CALLBACK, MESSAGE_DEACTIVATED_ARRAY_FILTER, MESSAGE_DEACTIVATED_ARRAY_MAP, MESSAGE_DEACTIVATED_ARRAY_SELECT, MESSAGE_DEACTIVATED_READONLY, MESSAGE_DEACTIVATED_SUBSCRIPTION, MESSAGE_EFFECT_CALLBACK, MESSAGE_UPDATE_CALLBACK, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_READONLY, NAME_SIGNAL, NAME_STORE, NAME_SUBSCRIPTION, PROPERTY_LENGTH, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_EFFECT, SYMBOL_READONLY, SYMBOL_STATE };

package/dist/effect.d.mts

@@ -1,6 +1,6 @@
 import { Effect, EffectState } from "./models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
-//#region src/effect.d.ts
+export declare function deactivateEffect(state: EffectState): void;
 /**
  * Create an effect
  *
@@ -9,5 +9,4 @@ import { GenericCallback } from "@oscarpalmer/atoms/models";
  */
 export declare function effect(callback: GenericCallback): Effect;
 export declare function internalEffect(callback: GenericCallback): EffectState;
-export declare function runEffect(state: EffectState): void;
-//#endregion
+export declare function runEffect(state: EffectState): void;

package/dist/effect.mjs

@@ -1,11 +1,24 @@
-import { ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE } from "./constants.mjs";
-import "@oscarpalmer/atoms/result";
-//#region src/effect.ts
+import { ACTIVE, BATCH, MESSAGE_EFFECT_CALLBACK, NAME_EFFECT, SYMBOL_STATE } from "./constants.mjs";
+import { noop } from "@oscarpalmer/atoms/function";
+// src/effect.ts
 function Effect(callback) {
-	this[SYMBOL_STATE] = { callback };
+	this[SYMBOL_STATE] = {
+		callback,
+		active: true,
+		name: NAME_EFFECT
+	};
 	runEffect(this[SYMBOL_STATE]);
 }
-Effect.prototype[NAME_MORA] = NAME_EFFECT;
+Effect.prototype.stop = stopEffect;
+Object.defineProperties(Effect.prototype, { active: {
+	enumerable: true,
+	get: getActive
+} });
+function deactivateEffect(state) {
+	state.active = false;
+	state.callback = noop;
+	BATCH.handlers.delete(state);
+}
 /**
 * Create an effect
 *
@@ -13,9 +26,12 @@ Effect.prototype[NAME_MORA] = NAME_EFFECT;
 * @returns Effect
 */
 function effect(callback) {
-	if (typeof callback !== "function") throw new TypeError("Effect callback must be a function");
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EFFECT_CALLBACK);
 	return getEffect(callback)[0];
 }
+function getActive() {
+	return this[SYMBOL_STATE].active;
+}
 function getEffect(callback) {
 	const instance = new Effect(callback);
 	return [instance, instance[SYMBOL_STATE]];
@@ -32,5 +48,8 @@ function runEffect(state) {
 		ACTIVE.effect = previousEffect;
 	}
 }
-//#endregion
-export { effect, internalEffect, runEffect };
+function stopEffect() {
+	const state = this[SYMBOL_STATE];
+	if (state.active) deactivateEffect(state);
+}
+export { deactivateEffect, effect, internalEffect, runEffect };

package/dist/helpers/is.d.mts

@@ -1,6 +1,5 @@
 import { Computed, Effect, Reactive, ReactiveArray, ReactiveStore, ReadonlySignal, Signal } from "../models.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
-//#region src/helpers/is.d.ts
 /**
  * Is the value a computed signal?
  *
@@ -49,5 +48,4 @@ export declare function isReactiveStore<Value extends PlainObject = PlainObject>
  * @param value Value to check
  * @returns True if value is a {@link ReadonlySignal}
  */
-export declare function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value>;
-//#endregion
+export declare function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value>;

package/dist/helpers/is.mjs

@@ -1,5 +1,5 @@
-import { NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_READONLY, NAME_SIGNAL, NAME_STORE } from "../constants.mjs";
-//#region src/helpers/is.ts
+import { NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_READONLY, NAME_SIGNAL, NAME_STORE, SYMBOL_READONLY, SYMBOL_STATE } from "../constants.mjs";
+// src/helpers/is.ts
 /**
 * Is the value a computed signal?
 *
@@ -18,8 +18,12 @@ function isComputed(value) {
 function isEffect(value) {
 	return isMora(value, NAME_EFFECT);
 }
-function isMora(value, name) {
-	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+function isMora(input, value) {
+	if (typeof input !== "object" || input === null) return false;
+	if (value === "readonly") return SYMBOL_READONLY in input;
+	if (!(SYMBOL_STATE in input)) return false;
+	const state = input[SYMBOL_STATE];
+	return typeof value === "string" ? state.name === value : value.has(state.name);
 }
 /**
 * Is the value reactive?
@@ -66,5 +70,4 @@ function isReactiveStore(value) {
 function isReadonlySignal(value) {
 	return isMora(value, NAME_READONLY);
 }
-//#endregion
 export { isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal };

package/dist/helpers/misc.d.mts

@@ -1,4 +1,8 @@
-import { ReactiveOptions, ReactiveState } from "../models.mjs";
-//#region src/helpers/misc.d.ts
-export declare function getState(value: unknown, options?: ReactiveOptions<unknown>): ReactiveState;
-//#endregion
+import { InternalArray, InternalComputed, InternalReactive, InternalReadonly, InternalStore, ReactiveOptions, ReactiveState } from "../models.mjs";
+export declare function deactivateComputed(this: InternalComputed): void;
+export declare function deactivateProxy(this: InternalArray | InternalStore): void;
+export declare function deactivateReactive(this: InternalReactive): void;
+export declare function deactivateReadonly(this: InternalReadonly): void;
+export declare function getReactiveActive(this: InternalReactive): boolean;
+export declare function getReadonlyActive(this: InternalReadonly): boolean;
+export declare function getState(name: string, value: unknown, options?: ReactiveOptions<unknown>): ReactiveState;

package/dist/helpers/misc.mjs

@@ -1,9 +1,71 @@
-//#region src/helpers/misc.ts
-function getState(value, options) {
+import { SYMBOL_EFFECT, SYMBOL_READONLY, SYMBOL_STATE } from "../constants.mjs";
+import { deactivateEffect } from "../effect.mjs";
+import { peekSignalValue } from "./value.mjs";
+import { noop } from "@oscarpalmer/atoms/function";
+// src/helpers/misc.ts
+function deactivateComputed() {
+	if (!this[SYMBOL_STATE].active) return;
+	deactivateEffect(this[SYMBOL_EFFECT].instance);
+	deactivateReactive.call(this);
+}
+function deactivateProxy() {
+	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 = void 0;
+	}
+	if (state.mapped != null) {
+		for (const [, computed] of state.mapped) computed.deactivate();
+		state.mapped.clear();
+		state.mapped = void 0;
+	}
+	deactivateReactive.call(this);
+}
+function deactivateReactive() {
+	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;
+	state.promise = void 0;
+	state.computeds = void 0;
+	state.effects = void 0;
+	state.promises = void 0;
+	state.readonlies = void 0;
+	state.subscriptions = void 0;
+}
+function deactivateReadonly() {
+	const readonly = this[SYMBOL_READONLY];
+	const signal = this[SYMBOL_STATE];
+	if (!readonly.active) return;
+	signal.readonlies[readonly.name] = void 0;
+	if (readonly.subscriptions != null) {
+		for (const subscription of readonly.subscriptions) subscription.unsubscribe();
+		readonly.subscriptions.clear();
+		readonly.subscriptions = void 0;
+	}
+	readonly.active = false;
+	readonly.value = peekSignalValue.call(this, true);
+}
+function getReactiveActive() {
+	return this[SYMBOL_STATE].active;
+}
+function getReadonlyActive() {
+	return this[SYMBOL_READONLY].active;
+}
+function getState(name, value, options) {
 	return {
+		name,
 		value,
+		active: true,
 		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : void 0
 	};
 }
-//#endregion
-export { getState };
+export { deactivateComputed, deactivateProxy, deactivateReactive, deactivateReadonly, getReactiveActive, getReadonlyActive, getState };

package/dist/helpers/proxy.d.mts

@@ -1,11 +1,10 @@
-import { InternalArray, InternalComputed, InternalStore } from "../models.mjs";
+import { Computed, InternalArray, InternalComputed, InternalStore } from "../models.mjs";
 import { Key } from "@oscarpalmer/atoms/models";
-//#region src/helpers/proxy.d.ts
 export declare function getReactiveValueInProxy(instance: InternalArray | InternalStore, key: Key): InternalComputed;
 export declare function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown;
 export declare function notifyProxyValue(this: InternalArray | InternalStore): void;
 export declare function peekValueInProxy(this: InternalArray | InternalStore, first?: unknown, second?: boolean): unknown;
 export declare function setProxyValue(this: InternalArray | InternalStore, first?: unknown, second?: unknown): void;
 export declare function setValueInProxy(instance: InternalArray | InternalStore, target: object, property: PropertyKey, value: unknown): boolean;
-export declare function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void;
-//#endregion
+export declare function updateProxyDerivations(instance: InternalArray | InternalStore, value: Computed<unknown[]>): Computed<unknown[]>;
+export declare function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void;

package/dist/helpers/proxy.mjs

@@ -1,14 +1,15 @@
-import { SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
+import { MESSAGE_UPDATE_CALLBACK, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
 import { emitValue, getSignalValue, peekSignalValue } from "./value.mjs";
 import { startBatch, stopBatch } from "../batch.mjs";
 import { internalComputed } from "../value/computed.mjs";
-import "@oscarpalmer/atoms/result";
 import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
-//#region src/helpers/proxy.ts
+import { getNumber } from "@oscarpalmer/atoms/number";
+import { getString } from "@oscarpalmer/atoms/string";
+// src/helpers/proxy.ts
 function getReactiveValueInProxy(instance, key) {
 	const state = instance[SYMBOL_STATE];
 	state.mapped ??= /* @__PURE__ */ new Map();
-	const mapKey = String(key);
+	const mapKey = getString(key);
 	let item = state.mapped.get(mapKey);
 	if (item == null) {
 		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
@@ -17,18 +18,21 @@ function getReactiveValueInProxy(instance, key) {
 	return item;
 }
 function getValueInProxy(first) {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return peekValueInProxy.call(this, first);
 	let signal;
-	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
+	if (state.isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
 	return getSignalValue.call(signal ?? this);
 }
 function isProxyKey(isArray, value) {
-	return isArray ? typeof value === "number" : isKey(value);
+	return isArray && typeof value === "number" || isKey(value);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
 function notifyProxyValue() {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
 	state.mapped ??= /* @__PURE__ */ new Map();
 	const values = [...state.mapped.values()];
 	const { length } = values;
@@ -80,6 +84,7 @@ function setProxyProperty(state, property, value) {
 }
 function setProxyValue(first, second) {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
 	if (state.isArray && first === "length") {
 		state.value.length = second;
 		return;
@@ -120,8 +125,9 @@ function setProxyValue(first, second) {
 }
 function setValueInProxy(instance, target, property, value) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return true;
 	if (state.isArray) {
-		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
+		if (!(!Number.isNaN(getNumber(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
 	if (!(state.equal ?? Object.is)(previous, value)) {
@@ -131,9 +137,18 @@ function setValueInProxy(instance, target, property, value) {
 	}
 	return true;
 }
+function updateProxyDerivations(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if (state.derived == null) {
+		state.derived = /* @__PURE__ */ new Set([value]);
+		return value;
+	}
+	for (const computed of state.derived) if (!computed.active) state.derived.delete(computed);
+	state.derived.add(value);
+	return value;
+}
 function updateProxyValue(callback) {
-	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_UPDATE_CALLBACK);
+	if (this[SYMBOL_STATE].active) setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
 }
-//#endregion
-export { getReactiveValueInProxy, getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue };
+export { getReactiveValueInProxy, getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyDerivations, updateProxyValue };

package/dist/helpers/subscription.d.mts

@@ -1,8 +1,6 @@
 import { InternalArray, InternalReadonly, InternalStateful, InternalStore, Subscriber } from "../models.mjs";
 import { Subscription } from "@oscarpalmer/atoms/subscription";
 import { Key } from "@oscarpalmer/atoms/models";
-//#region src/helpers/subscription.d.ts
 export declare function subscribeToProxy(this: InternalArray | InternalStore, first: Key | Subscriber<unknown>, second?: Subscriber<unknown> | boolean, third?: boolean): Subscription;
 export declare function subscribeToReadonly(this: InternalReadonly, subscriber: Subscriber<unknown>): Subscription;
-export declare function subscribeToSignal(this: InternalStateful, subscriber: Subscriber<unknown>, copy?: unknown): Subscription;
-//#endregion
+export declare function subscribeToSignal(this: InternalStateful, subscriber: Subscriber<unknown>, copy?: unknown): Subscription;

package/dist/helpers/subscription.mjs

@@ -1,30 +1,38 @@
-import { SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_STATE } from "../constants.mjs";
+import { MESSAGE_DEACTIVATED_SUBSCRIPTION, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_READONLY, SYMBOL_STATE } from "../constants.mjs";
 import { getFrozenValue, peekSignalValue } from "./value.mjs";
 import { getReactiveValueInProxy } from "./proxy.mjs";
 import { isKey } from "@oscarpalmer/atoms/is";
 import { subscriptions } from "@oscarpalmer/atoms/subscription";
-//#region src/helpers/subscription.ts
+// src/helpers/subscription.ts
 function subscribeToProxy(first, second, third) {
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
 	if (isKey(first)) return getReactiveValueInProxy(this, first).subscribe(second, third);
 	return subscribeToSignal.call(this, first, second);
 }
 function subscribeToReactive(type, subscriber) {
-	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
 	});
-	if (!existing) subscriber(type === "frozen" ? getFrozenValue(this[SYMBOL_STATE].value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
+	if (!existing) subscriber(type === "frozen" ? getFrozenValue(state.value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
 	return subscription;
 }
 function subscribeToReadonly(subscriber) {
-	return subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
+	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 ??= /* @__PURE__ */ new Set();
+	for (const existing of state.subscriptions) if (!existing.active) state.subscriptions.delete(existing);
+	state.subscriptions.add(subscription);
+	return subscription;
 }
 function subscribeToSignal(subscriber, copy) {
 	return subscribeToReactive.call(this, copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, subscriber);
 }
-//#endregion
 export { subscribeToProxy, subscribeToReadonly, subscribeToSignal };

package/dist/helpers/value.d.mts

@@ -1,13 +1,12 @@
-import { InternalStateful } from "../models.mjs";
-//#region src/helpers/value.d.ts
+import { InternalReadonly, InternalStateful } from "../models.mjs";
 type SetValue = (instance: InternalStateful, value: unknown, notify: boolean) => void;
 export declare function emitValue(instance: InternalStateful, notify?: boolean): void;
 export declare function equalArrays(first: unknown[], second: unknown[], equal?: (first: unknown, second: unknown) => boolean): boolean;
 export declare function getFrozenValue(value: unknown): unknown;
-export declare function getJsonValue(this: InternalStateful): unknown;
+export declare function getJsonValue(this: InternalReadonly | InternalStateful): unknown;
 export declare function getSignalValue(this: InternalStateful): unknown;
-export declare function getStringValue(this: InternalStateful, json?: boolean): string;
+export declare function getStringValue(this: InternalReadonly | InternalStateful, json?: boolean): string;
 export declare function handleSignal(instance: InternalStateful, origin: unknown, setValue: SetValue, onAfter?: () => void, notify?: boolean): void;
 export declare function peekSignalValue(this: InternalStateful | [InternalStateful, unknown], copy?: boolean): unknown;
 export declare function updateSignal(instance: InternalStateful, callback: (value: unknown) => unknown, setValue: (instance: InternalStateful, value: unknown) => void): void;
-//#endregion
+export {};

package/dist/helpers/value.mjs

@@ -1,18 +1,19 @@
-import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
+import { ACTIVE, BATCH, MESSAGE_UPDATE_CALLBACK, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN, SYMBOL_EFFECT, SYMBOL_READONLY, SYMBOL_STATE } from "../constants.mjs";
 import { flushHandlers } from "../batch.mjs";
-import "@oscarpalmer/atoms/result";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
-import { round } from "@oscarpalmer/atoms/math";
-//#region src/helpers/value.ts
+import { min, round } from "@oscarpalmer/atoms/math";
+// src/helpers/value.ts
 function emitValue(instance, notify) {
 	const state = instance[SYMBOL_STATE];
-	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
-	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) 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) if (effect.active) BATCH.handlers.set(effect, effect);
+	else state.effects.delete(effect);
 	if (notify ?? false) {
 		const mapped = instance[SYMBOL_STATE].mapped;
 		for (const [, item] of mapped) {
-			const fx = item[SYMBOL_EFFECT];
-			BATCH.handlers.set(fx.instance, fx.instance);
+			const { instance } = item[SYMBOL_EFFECT];
+			BATCH.handlers.set(instance, instance);
 		}
 	}
 	for (const type of SUBSCRIPTION_TYPES) {
@@ -34,7 +35,7 @@ function equalArrays(first, second, equal) {
 	let offset = 0;
 	if (length >= 100) {
 		offset = round(length / 10);
-		offset = offset > 25 ? 25 : offset;
+		offset = min([offset, 25]);
 		for (let index = 0; index < offset; index += 1) if (!(eq(first[index], second[index]) && eq(first[length - index - 1], second[length - index - 1]))) return false;
 	}
 	const end = length - offset;
@@ -48,10 +49,12 @@ function getFrozenValue(value) {
 	return frozen;
 }
 function getJsonValue() {
+	if (SYMBOL_READONLY in this && !this[SYMBOL_READONLY].active) return this[SYMBOL_READONLY].value;
 	return this[SYMBOL_STATE].value;
 }
 function getSignalValue() {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return state.value;
 	if (ACTIVE.computed != null) {
 		state.computeds ??= /* @__PURE__ */ new Set();
 		state.computeds.add(ACTIVE.computed);
@@ -63,10 +66,13 @@ function getSignalValue() {
 	return state.value;
 }
 function getStringValue(json) {
-	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
+	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);
 }
 function handleSignal(instance, origin, setValue, onAfter, notify) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return;
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
 		if (actual instanceof Promise) {
@@ -92,8 +98,7 @@ function peekSignalValue(copy) {
 	return peeked;
 }
 function updateSignal(instance, callback, setValue) {
-	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_UPDATE_CALLBACK);
+	if (instance[SYMBOL_STATE].active) handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
-//#endregion
 export { emitValue, equalArrays, getFrozenValue, getJsonValue, getSignalValue, getStringValue, handleSignal, peekSignalValue, updateSignal };