@oscarpalmer/mora 0.36.0 → 0.37.0

package/dist/helpers/proxy.d.mts

@@ -1,9 +1,9 @@
 import { InternalArray, InternalComputed, InternalStore } from "../models.mjs";
 import { Key } from "@oscarpalmer/atoms/models";
 //#region src/helpers/proxy.d.ts
-export declare function emitProxyValues(this: InternalArray | InternalStore): void;
 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;

package/dist/helpers/proxy.mjs

@@ -1,17 +1,9 @@
-import { SYMBOL_STATE } from "../constants.mjs";
+import { 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 { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/proxy.ts
-function emitProxyValues() {
-	const state = this[SYMBOL_STATE];
-	state.mapped ??= /* @__PURE__ */ new Map();
-	const values = [...state.mapped.values()];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
-	emitValue(this);
-}
 function getReactiveValueInProxy(instance, key) {
 	const state = instance[SYMBOL_STATE];
 	state.mapped ??= /* @__PURE__ */ new Map();
@@ -21,7 +13,7 @@ function getReactiveValueInProxy(instance, key) {
 		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
 		state.mapped.set(mapKey, item);
 	}
-	return item[0];
+	return item;
 }
 function getValueInProxy(first) {
 	let signal;
@@ -34,6 +26,17 @@ function isProxyKey(isArray, value) {
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
+function notifyProxyValue() {
+	const state = this[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const values = [...state.mapped.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		values[index][SYMBOL_EFFECT].dirty = true;
+		values[index][SYMBOL_EFFECT].notify = true;
+	}
+	emitValue(this, true);
+}
 function peekValueInProxy(first, second) {
 	const state = this[SYMBOL_STATE];
 	let value;
@@ -132,4 +135,4 @@ function updateProxyValue(callback) {
 	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
 }
 //#endregion
-export { emitProxyValues, getReactiveValueInProxy, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue };
+export { getReactiveValueInProxy, getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue };

package/dist/helpers/value.d.mts

@@ -1,12 +1,13 @@
 import { InternalStateful } from "../models.mjs";
 //#region src/helpers/value.d.ts
-export declare function emitValue(instance: InternalStateful): void;
+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 getSignalValue(this: InternalStateful): unknown;
 export declare function getStringValue(this: InternalStateful, json?: boolean): string;
-export declare function handleSignal(instance: InternalStateful, origin: unknown, setValue: (instance: InternalStateful, value: unknown) => void, onAfter?: () => void): void;
+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

package/dist/helpers/value.mjs

@@ -1,11 +1,18 @@
-import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN, SYMBOL_STATE } from "../constants.mjs";
+import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
 import { flushHandlers } from "../batch.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/value.ts
-function emitValue(instance) {
+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 (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);
+		}
+	}
 	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, {
@@ -56,7 +63,7 @@ function getSignalValue() {
 function getStringValue(json) {
 	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSignal(instance, origin, setValue, onAfter) {
+function handleSignal(instance, origin, setValue, onAfter, notify) {
 	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
@@ -65,12 +72,12 @@ function handleSignal(instance, origin, setValue, onAfter) {
 			actual.then((value) => {
 				if (actual === state.promise) {
 					state.promise = void 0;
-					setValue(instance, value);
+					setValue(instance, value, notify ?? false);
 				}
 			}).catch(() => {
 				if (actual === state.promise) state.promise = void 0;
 			});
-		} else setValue(instance, actual);
+		} else setValue(instance, actual, notify ?? false);
 	} catch {} finally {
 		onAfter?.();
 	}

package/dist/models.d.mts

@@ -15,6 +15,7 @@ export type Computed<Value> = Reactive<Value>;
 export type ComputedEffect = {
   dirty: boolean;
   instance: EffectState;
+  notify: boolean;
 };
 export type Effect = {};
 export type EffectState = {
@@ -266,7 +267,7 @@ export type ReactiveOptions<Value> = {
 export type ReactiveProxyState = {
   isArray: boolean;
   length?: Signal<number>;
-  mapped?: Map<string, [InternalComputed, ComputedEffect]>;
+  mapped?: Map<string, InternalComputed>;
 } & SignalState;
 export type ReactiveState<Value = unknown, Item = Value> = {
   computeds?: Set<ComputedEffect>;

package/dist/mora.full.mjs

@@ -109,10 +109,17 @@ function isPlainObject(value) {
 }
 //#endregion
 //#region src/helpers/value.ts
-function emitValue(instance) {
+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 (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);
+		}
+	}
 	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, {
@@ -163,7 +170,7 @@ function getSignalValue() {
 function getStringValue(json) {
 	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSignal(instance, origin, setValue, onAfter) {
+function handleSignal(instance, origin, setValue, onAfter, notify) {
 	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
@@ -172,12 +179,12 @@ function handleSignal(instance, origin, setValue, onAfter) {
 			actual.then((value) => {
 				if (actual === state.promise) {
 					state.promise = void 0;
-					setValue(instance, value);
+					setValue(instance, value, notify ?? false);
 				}
 			}).catch(() => {
 				if (actual === state.promise) state.promise = void 0;
 			});
-		} else setValue(instance, actual);
+		} else setValue(instance, actual, notify ?? false);
 	} catch {} finally {
 		onAfter?.();
 	}
@@ -701,17 +708,17 @@ Computed.prototype.toString = getStringValue;
 * @returns Computed value
 */
 function computed(callback, options) {
-	return getComputed(callback, options)[0];
+	return getComputed(callback, options);
 }
 function getComputed(callback, options) {
 	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
-	const instance = new Computed(callback, options);
-	return [instance, instance[SYMBOL_EFFECT]];
+	return new Computed(callback, options);
 }
 function getComputedEffect(instance, callback) {
 	const fx = {
 		dirty: true,
-		instance: void 0
+		instance: void 0,
+		notify: false
 	};
 	fx.instance = internalEffect(() => {
 		if (fx.dirty) {
@@ -719,7 +726,8 @@ function getComputedEffect(instance, callback) {
 			ACTIVE.computed = fx;
 			handleSignal(instance, callback, setAndEmit$1, () => {
 				ACTIVE.computed = previousComputed;
-			});
+				fx.notify = false;
+			}, fx.notify);
 			fx.dirty = false;
 		}
 	});
@@ -742,9 +750,9 @@ function getComputedValue() {
 function internalComputed(callback, options) {
 	return getComputed(callback, options);
 }
-function setAndEmit$1(instance, value) {
+function setAndEmit$1(instance, value, notify) {
 	const state = instance[SYMBOL_STATE];
-	if ((state.equal ?? Object.is)(state.value, value)) return;
+	if (!notify && (state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
 	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);
@@ -760,14 +768,6 @@ function setAndEmit$1(instance, value) {
 }
 //#endregion
 //#region src/helpers/proxy.ts
-function emitProxyValues() {
-	const state = this[SYMBOL_STATE];
-	state.mapped ??= /* @__PURE__ */ new Map();
-	const values = [...state.mapped.values()];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
-	emitValue(this);
-}
 function getReactiveValueInProxy(instance, key) {
 	const state = instance[SYMBOL_STATE];
 	state.mapped ??= /* @__PURE__ */ new Map();
@@ -777,7 +777,7 @@ function getReactiveValueInProxy(instance, key) {
 		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
 		state.mapped.set(mapKey, item);
 	}
-	return item[0];
+	return item;
 }
 function getValueInProxy(first) {
 	let signal;
@@ -790,6 +790,17 @@ function isProxyKey(isArray, value) {
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
+function notifyProxyValue() {
+	const state = this[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const values = [...state.mapped.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		values[index][SYMBOL_EFFECT].dirty = true;
+		values[index][SYMBOL_EFFECT].notify = true;
+	}
+	emitValue(this, true);
+}
 function peekValueInProxy(first, second) {
 	const state = this[SYMBOL_STATE];
 	let value;
@@ -977,7 +988,7 @@ ReactiveArray.prototype.clear = clearArrayValues;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
-ReactiveArray.prototype.notify = emitProxyValues;
+ReactiveArray.prototype.notify = notifyProxyValue;
 ReactiveArray.prototype.peek = peekArrayValue;
 ReactiveArray.prototype.pop = popArrayValue;
 ReactiveArray.prototype.push = pushArrayValues;
@@ -1061,7 +1072,7 @@ function ReactiveStore(value, options) {
 ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
-ReactiveStore.prototype.notify = emitProxyValues;
+ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;

package/dist/value/array.mjs

@@ -3,7 +3,7 @@ import { emitValue, equalArrays, getJsonValue, getStringValue } from "../helpers
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { computed } from "./computed.mjs";
-import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
+import { getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlySignal } from "./readonly.mjs";
 import { signal } from "./signal.mjs";
 import { select } from "@oscarpalmer/atoms/array";
@@ -33,7 +33,7 @@ ReactiveArray.prototype.clear = clearArrayValues;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
-ReactiveArray.prototype.notify = emitProxyValues;
+ReactiveArray.prototype.notify = notifyProxyValue;
 ReactiveArray.prototype.peek = peekArrayValue;
 ReactiveArray.prototype.pop = popArrayValue;
 ReactiveArray.prototype.push = pushArrayValues;

package/dist/value/computed.d.mts

@@ -1,4 +1,4 @@
-import { Computed, ComputedEffect, InternalComputed, ReactiveOptions } from "../models.mjs";
+import { Computed, InternalComputed, ReactiveOptions } from "../models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
 //#region src/value/computed.d.ts
 declare function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>): void;
@@ -10,5 +10,5 @@ declare function Computed(this: any, callback: GenericCallback, options?: Reacti
  * @returns Computed value
  */
 export declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
-export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): [InternalComputed, ComputedEffect];
+export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): InternalComputed;
 //#endregion

package/dist/value/computed.mjs

@@ -23,17 +23,17 @@ Computed.prototype.toString = getStringValue;
 * @returns Computed value
 */
 function computed(callback, options) {
-	return getComputed(callback, options)[0];
+	return getComputed(callback, options);
 }
 function getComputed(callback, options) {
 	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
-	const instance = new Computed(callback, options);
-	return [instance, instance[SYMBOL_EFFECT]];
+	return new Computed(callback, options);
 }
 function getComputedEffect(instance, callback) {
 	const fx = {
 		dirty: true,
-		instance: void 0
+		instance: void 0,
+		notify: false
 	};
 	fx.instance = internalEffect(() => {
 		if (fx.dirty) {
@@ -41,7 +41,8 @@ function getComputedEffect(instance, callback) {
 			ACTIVE.computed = fx;
 			handleSignal(instance, callback, setAndEmit, () => {
 				ACTIVE.computed = previousComputed;
-			});
+				fx.notify = false;
+			}, fx.notify);
 			fx.dirty = false;
 		}
 	});
@@ -64,9 +65,9 @@ function getComputedValue() {
 function internalComputed(callback, options) {
 	return getComputed(callback, options);
 }
-function setAndEmit(instance, value) {
+function setAndEmit(instance, value, notify) {
 	const state = instance[SYMBOL_STATE];
-	if ((state.equal ?? Object.is)(state.value, value)) return;
+	if (!notify && (state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
 	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);

package/dist/value/store.mjs

@@ -2,7 +2,7 @@ import { NAME_MORA, NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
 import { getJsonValue, getStringValue } from "../helpers/value.mjs";
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
-import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
+import { getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlySignal } from "./readonly.mjs";
 //#region src/value/store.ts
 function ReactiveStore(value, options) {
@@ -16,7 +16,7 @@ function ReactiveStore(value, options) {
 ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
-ReactiveStore.prototype.notify = emitProxyValues;
+ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.36.0",
+	"version": "0.37.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",

package/src/helpers/proxy.ts

@@ -6,28 +6,13 @@ import type {
 	PlainObject,
 } from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
-import {PROPERTY_LENGTH, SYMBOL_STATE} from '../constants';
+import {PROPERTY_LENGTH, SYMBOL_EFFECT, SYMBOL_STATE} from '../constants';
 import type {InternalArray, InternalComputed, InternalStore, ReactiveProxyState} from '../models';
 import {internalComputed} from '../value/computed';
 import {emitValue, getSignalValue, peekSignalValue} from './value';
 
 // #region Functions
 
-export function emitProxyValues(this: InternalArray | InternalStore): void {
-	const state = this[SYMBOL_STATE];
-
-	state.mapped ??= new Map();
-
-	const values = [...state.mapped.values()];
-	const {length} = values;
-
-	for (let index = 0; index < length; index += 1) {
-		values[index][1].dirty = true;
-	}
-
-	emitValue(this);
-}
-
 export function getReactiveValueInProxy(
 	instance: InternalArray | InternalStore,
 	key: Key,
@@ -50,7 +35,7 @@ export function getReactiveValueInProxy(
 		state.mapped.set(mapKey, item);
 	}
 
-	return item[0];
+	return item;
 }
 
 export function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown {
@@ -71,6 +56,22 @@ function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainO
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
 
+export function notifyProxyValue(this: InternalArray | InternalStore): void {
+	const state = this[SYMBOL_STATE];
+
+	state.mapped ??= new Map();
+
+	const values = [...state.mapped.values()];
+	const {length} = values;
+
+	for (let index = 0; index < length; index += 1) {
+		values[index][SYMBOL_EFFECT].dirty = true;
+		values[index][SYMBOL_EFFECT].notify = true;
+	}
+
+	emitValue(this, true);
+}
+
 export function peekValueInProxy(
 	this: InternalArray | InternalStore,
 	first?: unknown,

package/src/helpers/value.ts

@@ -9,13 +9,20 @@ import {
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPES,
 	SUBSCRIPTION_TYPES_COPY,
+	SYMBOL_EFFECT,
 	SYMBOL_STATE,
 } from '../constants';
-import type {InternalStateful} from '../models';
+import type {InternalArray, InternalComputed, InternalStateful, InternalStore} from '../models';
+
+// #region Types
+
+type SetValue = (instance: InternalStateful, value: unknown, notify: boolean) => void;
+
+// #endregion
 
 // #region Functions
 
-export function emitValue(instance: InternalStateful): void {
+export function emitValue(instance: InternalStateful, notify?: boolean): void {
 	const state = instance[SYMBOL_STATE];
 
 	if (state.computeds != null && state.computeds.size > 0) {
@@ -30,6 +37,18 @@ export function emitValue(instance: InternalStateful): void {
 		}
 	}
 
+	if (notify ?? false) {
+		const proxy = instance as InternalArray | InternalStore;
+		const state = proxy[SYMBOL_STATE];
+		const mapped = state.mapped as Map<unknown, InternalComputed>;
+
+		for (const [, item] of mapped) {
+			const fx = item[SYMBOL_EFFECT];
+
+			BATCH.handlers.set(fx.instance, fx.instance);
+		}
+	}
+
 	for (const type of SUBSCRIPTION_TYPES) {
 		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
 
@@ -136,8 +155,9 @@ export function getStringValue(this: InternalStateful, json?: boolean): string {
 export function handleSignal(
 	instance: InternalStateful,
 	origin: unknown,
-	setValue: (instance: InternalStateful, value: unknown) => void,
+	setValue: SetValue,
 	onAfter?: () => void,
+	notify?: boolean,
 ): void {
 	const state = instance[SYMBOL_STATE];
 
@@ -152,7 +172,7 @@ export function handleSignal(
 					if (actual === state.promise) {
 						state.promise = undefined;
 
-						setValue(instance, value);
+						setValue(instance, value, notify ?? false);
 					}
 				})
 				.catch(() => {
@@ -161,7 +181,7 @@ export function handleSignal(
 					}
 				});
 		} else {
-			setValue(instance, actual);
+			setValue(instance, actual, notify ?? false);
 		}
 	} catch {
 		// ?

package/src/models.ts

@@ -20,6 +20,7 @@ export type Computed<Value> = Reactive<Value>;
 export type ComputedEffect = {
 	dirty: boolean;
 	instance: EffectState;
+	notify: boolean;
 };
 
 export type Effect = {};
@@ -324,7 +325,7 @@ export type ReactiveOptions<Value> = {
 export type ReactiveProxyState = {
 	isArray: boolean;
 	length?: Signal<number>;
-	mapped?: Map<string, [InternalComputed, ComputedEffect]>;
+	mapped?: Map<string, InternalComputed>;
 } & SignalState;
 
 export type ReactiveState<Value = unknown, Item = Value> = {

package/src/value/array.ts

@@ -10,7 +10,7 @@ import {
 } from '../constants';
 import {getState} from '../helpers/misc';
 import {
-	emitProxyValues,
+	notifyProxyValue,
 	getValueInProxy,
 	peekValueInProxy,
 	setProxyValue,
@@ -58,7 +58,7 @@ ReactiveArray.prototype.clear = clearArrayValues;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
-ReactiveArray.prototype.notify = emitProxyValues;
+ReactiveArray.prototype.notify = notifyProxyValue;
 ReactiveArray.prototype.peek = peekArrayValue;
 ReactiveArray.prototype.pop = popArrayValue;
 ReactiveArray.prototype.push = pushArrayValues;

package/src/value/computed.ts

@@ -53,21 +53,19 @@ export function computed<Value>(
 	callback: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): Computed<Value> {
-	return getComputed(callback, options)[0] as Computed<Value>;
+	return getComputed(callback, options) as Computed<Value>;
 }
 
 function getComputed<Value>(
 	callback: GenericCallback,
 	options?: ReactiveOptions<Value>,
-): [InternalComputed, ComputedEffect] {
+): InternalComputed {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Computed callback must be a function');
 	}
 
 	// @ts-expect-error All good, no worries :-)
-	const instance = new Computed(callback, options);
-
-	return [instance, instance[SYMBOL_EFFECT]];
+	return new Computed(callback, options);
 }
 
 function getComputedEffect(
@@ -77,6 +75,7 @@ function getComputedEffect(
 	const fx: ComputedEffect = {
 		dirty: true,
 		instance: undefined as never,
+		notify: false,
 	};
 
 	fx.instance = internalEffect(() => {
@@ -85,9 +84,17 @@ function getComputedEffect(
 
 			ACTIVE.computed = fx;
 
-			handleSignal(instance, callback, setAndEmit, () => {
-				ACTIVE.computed = previousComputed;
-			});
+			handleSignal(
+				instance,
+				callback,
+				setAndEmit,
+				() => {
+					ACTIVE.computed = previousComputed;
+
+					fx.notify = false;
+				},
+				fx.notify,
+			);
 
 			fx.dirty = false;
 		}
@@ -122,14 +129,14 @@ function getComputedValue(this: InternalComputed): unknown {
 export function internalComputed(
 	callback: GenericCallback,
 	options?: ReactiveOptions<unknown>,
-): [InternalComputed, ComputedEffect] {
+): InternalComputed {
 	return getComputed(callback, options);
 }
 
-function setAndEmit(instance: InternalStateful, value: unknown): void {
+function setAndEmit(instance: InternalStateful, value: unknown, notify: boolean): void {
 	const state = instance[SYMBOL_STATE];
 
-	if ((state.equal ?? Object.is)(state.value, value)) {
+	if (!notify && (state.equal ?? Object.is)(state.value, value)) {
 		return;
 	}
 

package/src/value/store.ts

@@ -2,7 +2,7 @@ import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {NAME_MORA, NAME_STORE, SYMBOL_STATE} from '../constants';
 import {getState} from '../helpers/misc';
 import {
-	emitProxyValues,
+	notifyProxyValue,
 	getValueInProxy,
 	peekValueInProxy,
 	setProxyValue,
@@ -36,7 +36,7 @@ ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
-ReactiveStore.prototype.notify = emitProxyValues;
+ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;