@oscarpalmer/mora 0.36.0 → 0.38.0

package/dist/batch.mjs

@@ -1,6 +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
 function flushHandlers() {
 	if (BATCH.flushing) return;

package/dist/constants.d.mts

@@ -1,4 +1,5 @@
 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;
@@ -17,12 +18,9 @@ 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: unique symbol;
-export declare const SYMBOL_STATE: unique symbol;
-export declare const SUBSCRIPTION_PROPERTY: {
-  key: string;
-  value: string;
-};
+export declare const SYMBOL_EFFECT: symbol;
+export declare const SYMBOL_STATE: 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;

package/dist/effect.d.mts

@@ -1,7 +1,6 @@
 import { Effect, EffectState } from "./models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
 //#region src/effect.d.ts
-declare function Effect(this: any, callback: GenericCallback): void;
 /**
  * Create an effect
  *

package/dist/effect.mjs

@@ -1,4 +1,5 @@
 import { ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE } from "./constants.mjs";
+import "@oscarpalmer/atoms/result";
 //#region src/effect.ts
 function Effect(callback) {
 	this[SYMBOL_STATE] = { callback };

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,10 @@
-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 "@oscarpalmer/atoms/result";
 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 +14,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 +27,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 +136,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,20 @@
-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 "@oscarpalmer/atoms/result";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { round } from "@oscarpalmer/atoms/math";
 //#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, {
@@ -24,7 +33,7 @@ function equalArrays(first, second, equal) {
 	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
-		offset = Math.round(length / 10);
+		offset = round(length / 10);
 		offset = offset > 25 ? 25 : offset;
 		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;
 	}
@@ -56,7 +65,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 +74,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 = {
@@ -25,8 +26,7 @@ export type InternalArray = {
 } & ReactiveArray<unknown>;
 export type InternalComputed = {
   [SYMBOL_EFFECT]: ComputedEffect;
-  [SYMBOL_STATE]: SignalState;
-} & Computed<unknown>;
+} & Computed<unknown> & InternalStateful;
 export type InternalReadonly = {
   frozen: boolean;
 } & InternalStateful & ReadonlySignal<unknown>;
@@ -266,7 +266,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>;
@@ -446,5 +446,5 @@ export type StoredSubscription = {
   state: SignalState;
 };
 export type Subscriber<Value> = (value: Value, subscription: Subscription) => void;
-export type SubscriptionType = 'copy' | 'frozen' | 'original' | 'readonly';
+export type SubscriptionType = "copy" | "frozen" | "original" | "readonly";
 //#endregion

package/dist/mora.full.mjs

@@ -1,3 +1,85 @@
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+/**
+* Is the value a _Key_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
+*/
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+/**
+* Is the value a plain object?
+*
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/result/misc.mjs
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
+	};
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
+}
+function isError(value, extended) {
+	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
+}
+function isOk(value) {
+	return isResultValue(value, true);
+}
+function isResultValue(value, okValue) {
+	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+}
+/**
+* Creates an ok result
+*
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
+error.is = isError;
+ok.is = isOk;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/result/index.mjs
+async function asyncAttempt(value, err) {
+	try {
+		let result;
+		if (typeof value === "function") result = value();
+		else result = value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
+//#endregion
 //#region src/constants.ts
 const ACTIVE = {};
 const BATCH = {
@@ -84,35 +166,55 @@ function runEffect(state) {
 		ACTIVE.effect = previousEffect;
 	}
 }
+function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
+	if (notNumber || condition(aggregation, value)) {
+		if (aggregation.array) {
+			aggregation.items ??= {};
+			aggregation.items[value] ??= [];
+			aggregation.items[value].push(item);
+		}
+		return value;
+	}
+	return aggregation.value;
+}
+function isMaxValue(aggregation, value) {
+	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
+}
+function isMinValue(aggregation, value) {
+	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
+}
+getAbsoluteValue.bind(void 0, isMaxValue), getAbsoluteValue.bind(void 0, isMinValue);
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/math/misc.mjs
 /**
-* Is the value a _Key_?
+* Round a number
 *
-* @param value Value to check
-* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
+* @param value Number to round
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
 */
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
+function round(value, decimals) {
+	return roundNumber(Math.round, value, decimals);
 }
-/**
-* Is the value a plain object?
-*
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+function roundNumber(callback, value, decimals) {
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return callback(value);
+	const mod = 10 ** decimals;
+	return callback((value + Number.EPSILON) * mod) / mod;
 }
 //#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, {
@@ -131,7 +233,7 @@ function equalArrays(first, second, equal) {
 	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
-		offset = Math.round(length / 10);
+		offset = round(length / 10);
 		offset = offset > 25 ? 25 : offset;
 		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;
 	}
@@ -163,7 +265,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 +274,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?.();
 	}
@@ -324,29 +426,6 @@ function createFindParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
-function findValue(type, array, parameters, reversed) {
-	const findIndex = type === FIND_VALUE_INDEX;
-	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
-	const { bool, key, value } = createFindParameters(parameters);
-	const callbacks = getArrayCallbacks(bool, key);
-	if (callbacks?.bool == null && callbacks?.keyed == null) {
-		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
-		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
-	}
-	if (callbacks.bool != null) {
-		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
-		return findIndex ? index : array[index];
-	}
-	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);
-}
-function findValueInArray(array, callback, value, findIndex, reversed) {
-	const { length } = array;
-	for (let index = 0; index < length; index += 1) {
-		const item = reversed ? array.at(-(index + 1)) : array[index];
-		if (Object.is(callback?.(item, index, array), value)) return findIndex ? index : item;
-	}
-	return findIndex ? -1 : void 0;
-}
 function findValues(type, array, parameters, mapper) {
 	const result = {
 		matched: [],
@@ -393,54 +472,34 @@ function findValues(type, array, parameters, mapper) {
 	}
 	return result;
 }
-const FIND_VALUE_INDEX = "index";
-const FIND_VALUE_ITEM = "item";
 const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/array/index-of.mjs
-function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, false);
-}
-function lastIndexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, true);
-}
-indexOf.last = lastIndexOf;
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
-function find(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, false);
+//#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
+function exclude(array, ...parameters) {
+	return findValues("all", array, parameters).notMatched;
 }
-function findLast(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+function filter(array, ...parameters) {
+	return findValues("all", array, parameters).matched;
 }
-find.last = findLast;
+filter.remove = exclude;
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
-function reverseSelect(array, ...parameters) {
+function filterAndMap(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function mapAndFilter(array, ...parameters) {
 	return findValues("all", array, parameters, {
 		callback: parameters.shift(),
 		reverse: true
 	}).matched;
 }
-function select(array, ...parameters) {
-	return selectValues(array, parameters);
-}
 function selectValues(array, parameters) {
 	return findValues("all", array, parameters, {
 		callback: parameters.pop(),
 		reverse: false
 	}).matched;
 }
-select.reverse = reverseSelect;
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
-function exclude(array, ...parameters) {
-	return findValues("all", array, parameters).notMatched;
-}
-function filter(array, ...parameters) {
-	return findValues("all", array, parameters).matched;
-}
-filter.remove = exclude;
+filterAndMap.reverse = mapAndFilter;
 //#endregion
 //#region src/helpers/misc.ts
 function getState(value, options) {
@@ -701,17 +760,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 +778,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 +802,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 +820,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 +829,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 +842,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 +1040,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;
@@ -1018,7 +1081,7 @@ function pushArrayValues(...items) {
 	return this[SYMBOL_STATE].value.push(...items);
 }
 function selectArrayValues(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
+	return computed(() => filterAndMap(getArrayValues.call(this), filter, map));
 }
 function setArrayLength(value) {
 	const values = this[SYMBOL_STATE].value;
@@ -1061,7 +1124,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.d.mts

@@ -1,6 +1,5 @@
 import { ReactiveArray, ReactiveOptions } from "../models.mjs";
 //#region src/value/array.d.ts
-declare function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unknown>): void;
 /**
  * Create a reactive array from a function result
  *

package/dist/value/array.mjs

@@ -3,11 +3,11 @@ 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";
 import { filter } from "@oscarpalmer/atoms/array/filter";
+import { select } from "@oscarpalmer/atoms/array/select";
 //#region src/value/array.ts
 function ReactiveArray(value, options) {
 	this[SYMBOL_STATE] = {
@@ -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,7 +1,6 @@
-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;
 /**
  * Create a computed value
  *
@@ -10,5 +9,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/signal.d.mts

@@ -1,6 +1,5 @@
 import { ReactiveOptions, Signal } from "../models.mjs";
 //#region src/value/signal.d.ts
-declare function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>): void;
 /**
  * Create a reactive value from a function result
  *

package/dist/value/store.d.mts

@@ -1,7 +1,6 @@
 import { ReactiveOptions, ReactiveStore } from "../models.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 //#region src/value/store.d.ts
-declare function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknown>): void;
 /**
  * Create a reactive store from a function result
  *

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.38.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,17 +39,21 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.204"
+		"@oscarpalmer/atoms": "^0.205"
 	},
 	"devDependencies": {
-		"@types/node": "^26.5",
-		"@vitest/coverage-istanbul": "^4.1",
+		"@types/node": "^26.6",
+		"@vitest/coverage-istanbul": "5.0.1",
 		"jsdom": "^30.1",
 		"tsdown": "^0.23",
-		"typescript": "^6",
-		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
-		"vite-plus": "latest",
-		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+		"typescript": "^7",
+		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
+		"vite-plus": "1.0.0",
+		"vitest": "5.0.1"
+	},
+	"overrides": {
+		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
+		"vitest": "5.0.1"
 	},
 	"packageManager": "npm@11.19.0"
 }

package/src/batch.ts

@@ -1,3 +1,4 @@
+import {attempt} from '@oscarpalmer/atoms/result';
 import {BATCH} from './constants';
 import {runEffect} from './effect';
 import {getFrozenValue, peekSignalValue} from './helpers/value';

package/src/constants.ts

@@ -1,3 +1,4 @@
+import type {SubscriptionProperty} from '@oscarpalmer/atoms/subscription';
 import type {Active, Batch, SubscriptionType} from './models';
 
 // #region Variables
@@ -16,14 +17,14 @@ export const BATCH: Batch = {
 	handlers: new Map(),
 };
 
-export const METHODS_AFFECTING_LENGTH = new Set<string | symbol>([
+export const METHODS_AFFECTING_LENGTH: Set<string | symbol> = new Set([
 	'pop',
 	'push',
 	'shift',
 	'unshift',
 ]);
 
-export const METHODS_UPDATE = new Set<string | symbol>([
+export const METHODS_UPDATE: Set<string | symbol> = new Set([
 	...METHODS_AFFECTING_LENGTH,
 	'copyWithin',
 	'fill',
@@ -48,7 +49,7 @@ export const NAME_STORE = 'store';
 
 export const NAME_SUBSCRIPTION = 'subscription';
 
-export const NAME_ALL = new Set([
+export const NAME_ALL: Set<string> = new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
 	NAME_READONLY,
@@ -58,11 +59,11 @@ export const NAME_ALL = new Set([
 
 export const PROPERTY_LENGTH = 'length';
 
-export const SYMBOL_EFFECT = Symbol('effect');
+export const SYMBOL_EFFECT: symbol = Symbol('effect');
 
-export const SYMBOL_STATE = Symbol('state');
+export const SYMBOL_STATE: symbol = Symbol('state');
 
-export const SUBSCRIPTION_PROPERTY = {
+export const SUBSCRIPTION_PROPERTY: SubscriptionProperty = {
 	key: NAME_MORA,
 	value: NAME_SUBSCRIPTION,
 };
@@ -75,7 +76,7 @@ export const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType = 'original';
 
 export const SUBSCRIPTION_TYPE_READONLY: SubscriptionType = 'readonly';
 
-export const SUBSCRIPTION_TYPES_COPY = new Set<SubscriptionType>([
+export const SUBSCRIPTION_TYPES_COPY: Set<SubscriptionType> = new Set([
 	SUBSCRIPTION_TYPE_COPY,
 	SUBSCRIPTION_TYPE_READONLY,
 ]);

package/src/effect.ts

@@ -1,10 +1,11 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {attempt} from '@oscarpalmer/atoms/result';
 import {ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE} from './constants';
 import type {Effect, EffectState} from './models';
 
 // #region Instance
 
-function Effect(this: any, callback: GenericCallback) {
+function Effect(this: any, callback: GenericCallback): void {
 	this[SYMBOL_STATE] = {callback};
 
 	runEffect(this[SYMBOL_STATE]);

package/src/helpers/proxy.ts

@@ -5,29 +5,15 @@ import type {
 	Key,
 	PlainObject,
 } from '@oscarpalmer/atoms/models';
+import {attempt} from '@oscarpalmer/atoms/result';
 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 +36,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 +57,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

@@ -1,4 +1,6 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {round} from '@oscarpalmer/atoms/math';
+import {attempt} from '@oscarpalmer/atoms/result';
 import {flushHandlers} from '../batch';
 import {
 	ACTIVE,
@@ -9,13 +11,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 +39,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);
 
@@ -67,7 +88,7 @@ export function equalArrays(
 	let offset = 0;
 
 	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK);
+		offset = round(length / ARRAY_PEEK);
 		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {
@@ -136,8 +157,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 +174,7 @@ export function handleSignal(
 					if (actual === state.promise) {
 						state.promise = undefined;
 
-						setValue(instance, value);
+						setValue(instance, value, notify ?? false);
 					}
 				})
 				.catch(() => {
@@ -161,7 +183,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 = {};
@@ -34,8 +35,8 @@ export type InternalArray = {
 
 export type InternalComputed = {
 	[SYMBOL_EFFECT]: ComputedEffect;
-	[SYMBOL_STATE]: SignalState;
-} & Computed<unknown>;
+} & Computed<unknown> &
+	InternalStateful;
 
 export type InternalReadonly = {
 	frozen: boolean;
@@ -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

@@ -1,5 +1,5 @@
-import {select} from '@oscarpalmer/atoms/array';
 import {filter} from '@oscarpalmer/atoms/array/filter';
+import {select} from '@oscarpalmer/atoms/array/select';
 import {
 	METHODS_AFFECTING_LENGTH,
 	METHODS_UPDATE,
@@ -10,8 +10,8 @@ import {
 } from '../constants';
 import {getState} from '../helpers/misc';
 import {
-	emitProxyValues,
 	getValueInProxy,
+	notifyProxyValue,
 	peekValueInProxy,
 	setProxyValue,
 	setValueInProxy,
@@ -26,7 +26,7 @@ import {signal} from './signal';
 
 // #region Instance
 
-function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unknown>) {
+function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = {
 		...getState(undefined, options),
 		isArray: true,
@@ -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

@@ -25,7 +25,7 @@ import type {
 
 // #region Instance
 
-function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>) {
+function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = getState(undefined, options);
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
@@ -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/readonly.ts

@@ -25,7 +25,7 @@ type InternalReadonly = {
 
 // #region Instance
 
-function Readonly(this: any, state: SignalState, frozen: boolean) {
+function Readonly(this: any, state: SignalState, frozen: boolean): void {
 	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
 	this[SYMBOL_STATE] = state;
 }

package/src/value/signal.ts

@@ -15,7 +15,7 @@ import {getReadonlySignal} from './readonly';
 
 // #region Instance
 
-function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>) {
+function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = getState(undefined, options);
 
 	handleSignal(this, value, setAndEmit);

package/src/value/store.ts

@@ -2,8 +2,8 @@ import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {NAME_MORA, NAME_STORE, SYMBOL_STATE} from '../constants';
 import {getState} from '../helpers/misc';
 import {
-	emitProxyValues,
 	getValueInProxy,
+	notifyProxyValue,
 	peekValueInProxy,
 	setProxyValue,
 	setValueInProxy,
@@ -16,7 +16,7 @@ import {getReadonlySignal} from './readonly';
 
 // #region Instance
 
-function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknown>) {
+function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = {
 		...getState(undefined, options),
 		isArray: false,
@@ -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;