@oscarpalmer/mora 0.34.0 → 0.36.0

package/dist/mora.full.mjs

@@ -125,10 +125,10 @@ function emitValue(instance) {
 	}
 	if (BATCH.depth === 0) flushHandlers();
 }
-function equalArrays(state, first, second) {
+function equalArrays(first, second, equal) {
 	const { length } = first;
 	if (length !== second.length) return false;
-	const eq = state.equal ?? Object.is;
+	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
 		offset = Math.round(length / 10);
@@ -145,21 +145,25 @@ function getFrozenValue(value) {
 	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
 	return frozen;
 }
+function getJsonValue() {
+	return this[SYMBOL_STATE].value;
+}
 function getSignalValue() {
+	const state = this[SYMBOL_STATE];
 	if (ACTIVE.computed != null) {
-		this[SYMBOL_STATE].computeds ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
 	}
 	if (ACTIVE.effect != null) {
-		this[SYMBOL_STATE].effects ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
 	}
-	return this[SYMBOL_STATE].value;
+	return state.value;
 }
 function getStringValue(json) {
 	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSignalValue(instance, origin, setValue, onAfter) {
+function handleSignal(instance, origin, setValue, onAfter) {
 	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
@@ -185,9 +189,9 @@ function peekSignalValue(copy) {
 	else if (isPlainObject(peeked)) peeked = { ...peeked };
 	return peeked;
 }
-function updateSignalValue(instance, callback, setValue) {
+function updateSignal(instance, callback, setValue) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 //#endregion
 //#region src/batch.ts
@@ -401,7 +405,6 @@ function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
 indexOf.last = lastIndexOf;
-Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
 function find(array, ...parameters) {
@@ -411,7 +414,6 @@ function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
 find.last = findLast;
-Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
 function reverseSelect(array, ...parameters) {
@@ -430,7 +432,6 @@ function selectValues(array, parameters) {
 	}).matched;
 }
 select.reverse = reverseSelect;
-Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
 function exclude(array, ...parameters) {
@@ -440,7 +441,6 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
-Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
 //#region src/helpers/misc.ts
 function getState(value, options) {
@@ -450,7 +450,7 @@ function getState(value, options) {
 	};
 }
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/abort.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/aborter.mjs
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
 	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
@@ -468,40 +468,32 @@ const SUBSCRIPTION_NAME = "subscription";
 const SUBSCRIPTION_PROPERTY = "$subscription";
 const SUBSCRIPTION_STORE = "subscriptions";
 function Subscription(state, property, parameters) {
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
 	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
-	Object.defineProperties(this, {
-		[property.key]: { value: property.value },
-		active: {
-			enumerable: true,
-			get: () => (state.parameters?.isActive?.() ?? true) && state.active
-		}
-	});
 	addSubscription(this);
 }
-Object.defineProperties(Subscription.prototype, {
-	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
-	unsubscribe: { value: removeSubscription }
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
 });
 function Subscriptions(parameters) {
 	const { keys, property } = createSubscriptionsParameters(parameters);
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
 }
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
 Object.defineProperties(Subscriptions.prototype, {
-	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
-	clear: { value: clearSubscriptions },
-	create: { value: createSubscription },
 	items: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].items;
-		}
+		get: getSubscriptionsItems
 	},
 	values: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].values;
-		}
+		get: getSubscriptionsValues
 	}
 });
 function addSubscription(instance) {
@@ -564,6 +556,16 @@ function getExistingSubscription(subscriptions, state) {
 	const { parameters } = state;
 	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
+}
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
 function createSubscriptionParameters(input) {
 	const values = isPlainObject(input) ? input : {};
 	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
@@ -689,10 +691,8 @@ Computed.prototype[NAME_MORA] = NAME_COMPUTED;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
+Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
-Computed.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
 /**
 * Create a computed value
 *
@@ -717,7 +717,7 @@ function getComputedEffect(instance, callback) {
 		if (fx.dirty) {
 			const previousComputed = ACTIVE.computed;
 			ACTIVE.computed = fx;
-			handleSignalValue(instance, callback, setAndEmit$1, () => {
+			handleSignal(instance, callback, setAndEmit$1, () => {
 				ACTIVE.computed = previousComputed;
 			});
 			fx.dirty = false;
@@ -780,8 +780,12 @@ function getReactiveValueInProxy(instance, key) {
 	return item[0];
 }
 function getValueInProxy(first) {
-	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(this, first).get();
-	return getSignalValue.call(this);
+	let signal;
+	if (this[SYMBOL_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);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
@@ -795,23 +799,24 @@ function peekValueInProxy(first, second) {
 }
 function setProxyObject(state, value) {
 	if (state.isArray) {
-		state.value.splice(0, state.value.length, ...value ?? []);
+		const values = state.value;
+		values.splice(0, values.length, ...value ?? []);
 		return;
 	}
 	startBatch();
-	const actual = value ?? {};
-	const proxy = state.value;
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-	let { length } = proxyKeys;
+	const current = state.value;
+	const next = value ?? {};
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
+	let { length } = currentKeys;
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+		const key = currentKeys[index];
+		current[key] = nextKeys.includes(key) ? next[key] : void 0;
 	}
-	length = actualKeys.length;
+	length = nextKeys.length;
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+		const key = nextKeys[index];
+		if (!currentKeys.includes(key)) current[key] = next[key];
 	}
 	stopBatch();
 }
@@ -820,8 +825,10 @@ function setProxyProperty(state, property, value) {
 		state.value[property] = value;
 		return;
 	}
-	const actual = property < 0 ? state.value.length + property : property;
-	if (actual > -1) state.value[actual] = value;
+	const array = state.value;
+	const index = property;
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = value;
 }
 function setProxyValue(first, second) {
 	const state = this[SYMBOL_STATE];
@@ -833,34 +840,34 @@ function setProxyValue(first, second) {
 		setProxyObject(state, first);
 		return;
 	}
-	const property = state.isArray ? typeof first === "number" : isKey(first);
-	if (state.isArray && property && Number.isNaN(first)) return;
-	let actual = property ? second : first;
+	const keyed = isProxyKey(state.isArray, first);
+	if (state.isArray && keyed && Number.isNaN(first)) return;
+	let actual = keyed ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
 	} catch {
 		return;
 	}
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= /* @__PURE__ */ new Map();
 			state.promises.set(first, actual);
 		} else state.promise = actual;
 		actual.then((value) => {
-			if (property && state.promises.get(first) === actual) {
-				state.promises.delete(first);
+			if (keyed && state.promises?.get(first) === actual) {
+				state.promises?.delete(first);
 				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
+			if (!keyed && isProxyObject(state.isArray, value) && state.promise === actual) {
 				state.promise = void 0;
 				setProxyObject(state, value);
 			}
 		}).catch(() => {
-			if (property && state.promises.get(first) === actual) state.promises.delete(first);
-			else if (!property && state.promise === actual) state.promise = void 0;
+			if (keyed && state.promises?.get(first) === actual) state.promises?.delete(first);
+			else if (!keyed && state.promise === actual) state.promise = void 0;
 		});
-	} else if (property) setProxyProperty(state, first, actual);
+	} else if (keyed) setProxyProperty(state, first, actual);
 	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
 function setValueInProxy(instance, target, property, value) {
@@ -883,60 +890,51 @@ function updateProxyValue(callback) {
 //#endregion
 //#region src/value/readonly.ts
 function Readonly(state, frozen) {
+	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
 	this[SYMBOL_STATE] = state;
-	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
-		enumerable: true,
-		value: frozen
-	});
 }
 Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.get = getReadonlyValue;
+Readonly.prototype.peek = peekReadonlyValue;
 Readonly.prototype.subscribe = subscribeToReadonly;
+Readonly.prototype.toJSON = getJsonValue;
 Readonly.prototype.toString = getStringValue;
-Readonly.prototype.get = function() {
-	return getReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
-};
-Readonly.prototype.peek = function(copy) {
-	return getReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
-};
-Readonly.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-function getReadonlyInstance(frozen) {
+function getReadonlyInstance(state, frozen) {
+	return new Readonly(state, frozen);
+}
+function getReadonlySignal(frozen) {
 	const key = frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL;
 	this[SYMBOL_STATE].readonlies ??= {};
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlySignal(this[SYMBOL_STATE], frozen === true);
+	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(this[SYMBOL_STATE], frozen === true);
 	return this[SYMBOL_STATE].readonlies[key];
 }
-function getReadonlySignal(state, frozen) {
-	return new Readonly(state, frozen);
+function getReadonlyValue() {
+	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
 }
-function getReadonlyValue(instance, peek, frozen, copy) {
+function handleReadonlyValue(instance, peek, frozen, copy) {
 	let value;
 	if (peek) value = peekSignalValue.call(instance, copy === true);
 	else value = getSignalValue.call(instance);
 	return frozen ? getFrozenValue(value) : value;
 }
+function peekReadonlyValue(copy) {
+	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+}
 //#endregion
 //#region src/value/signal.ts
 function Signal(value, options) {
 	this[SYMBOL_STATE] = getState(void 0, options);
-	handleSignalValue(this, value, setAndEmit);
+	handleSignal(this, value, setAndEmit);
 }
 Signal.prototype[NAME_MORA] = NAME_SIGNAL;
-Signal.prototype.asReadonly = getReadonlyInstance;
+Signal.prototype.asReadonly = getReadonlySignal;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
+Signal.prototype.set = setSignalValue;
 Signal.prototype.subscribe = subscribeToSignal;
 Signal.prototype.toString = getStringValue;
-Signal.prototype.set = function(value) {
-	return handleSignalValue(this, value, setAndEmit);
-};
-Signal.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-Signal.prototype.update = function(callback) {
-	return updateSignalValue(this, callback, setAndEmit);
-};
+Signal.prototype.toJSON = getJsonValue;
+Signal.prototype.update = updateSignalValue;
 function setAndEmit(instance, value) {
 	const state = instance[SYMBOL_STATE];
 	if (!(state.equal ?? Object.is)(state.value, value)) {
@@ -944,9 +942,15 @@ function setAndEmit(instance, value) {
 		emitValue(instance);
 	}
 }
+function setSignalValue(value) {
+	handleSignal(this, value, setAndEmit);
+}
 function signal(value, options) {
 	return new Signal(value, options);
 }
+function updateSignalValue(callback) {
+	updateSignal(this, callback, setAndEmit);
+}
 //#endregion
 //#region src/value/array.ts
 function ReactiveArray(value, options) {
@@ -959,64 +963,76 @@ function ReactiveArray(value, options) {
 		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(this, property, target) : Reflect.get(target, property),
 		set: (target, property, value) => setValueInProxy(this, target, property, value)
 	});
-	Object.defineProperty(this, PROPERTY_LENGTH, {
-		enumerable: true,
-		get: () => this[SYMBOL_STATE].length.get(),
-		set: (value) => setArrayLength(this[SYMBOL_STATE], value)
-	});
 	setProxyValue.call(this, value);
 }
 ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-ReactiveArray.prototype.asReadonly = getReadonlyInstance;
+Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
+	enumerable: true,
+	get: getArrayLength,
+	set: setArrayLength
+});
+ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.map = mapArrayValues;
 ReactiveArray.prototype.notify = emitProxyValues;
 ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.pop = popArrayValue;
+ReactiveArray.prototype.push = pushArrayValues;
+ReactiveArray.prototype.select = selectArrayValues;
+ReactiveArray.prototype.shift = shiftArrayValue;
 ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.splice = spliceArrayValues;
 ReactiveArray.prototype.subscribe = subscribeToProxy;
 ReactiveArray.prototype.toString = getStringValue;
+ReactiveArray.prototype.toJSON = getJsonValue;
+ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
-ReactiveArray.prototype.clear = function() {
-	this[SYMBOL_STATE].value.length = 0;
-};
-ReactiveArray.prototype.filter = function(callback) {
-	return computed(() => filter(getArrayValues.call(this), callback));
-};
-ReactiveArray.prototype.map = function(callback) {
-	return computed(() => getArrayValues.call(this).map(callback));
-};
-ReactiveArray.prototype.pop = function() {
-	return this[SYMBOL_STATE].value.pop();
-};
-ReactiveArray.prototype.push = function(...items) {
-	return this[SYMBOL_STATE].value.push(...items);
-};
-ReactiveArray.prototype.select = function(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
-};
-ReactiveArray.prototype.shift = function() {
-	return this[SYMBOL_STATE].value.shift();
-};
-ReactiveArray.prototype.splice = function(from, to, ...items) {
-	return this[SYMBOL_STATE].value.splice(from, to ?? this[SYMBOL_STATE].value.length, ...items);
-};
-ReactiveArray.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-ReactiveArray.prototype.unshift = function(...items) {
-	return this[SYMBOL_STATE].value.unshift(...items);
-};
 function array(value, options) {
 	return new ReactiveArray(value, options);
 }
+function clearArrayValues() {
+	this[SYMBOL_STATE].value.length = 0;
+}
+function filterArrayValues(callback) {
+	return computed(() => filter(getArrayValues.call(this), callback));
+}
+function getArrayLength() {
+	return this[SYMBOL_STATE].length.get();
+}
 function getArrayValues(value) {
 	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
+function mapArrayValues(callback) {
+	return computed(() => getArrayValues.call(this).map(callback));
+}
 function peekArrayValue(first, second) {
 	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
-function setArrayLength(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
+function popArrayValue() {
+	return this[SYMBOL_STATE].value.pop();
+}
+function pushArrayValues(...items) {
+	return this[SYMBOL_STATE].value.push(...items);
+}
+function selectArrayValues(filter, map) {
+	return computed(() => select(getArrayValues.call(this), filter, map));
+}
+function setArrayLength(value) {
+	const values = this[SYMBOL_STATE].value;
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== values.length) values.length = value;
+}
+function shiftArrayValue() {
+	return this[SYMBOL_STATE].value.shift();
+}
+function spliceArrayValues(from, to, ...items) {
+	const values = this[SYMBOL_STATE].value;
+	return values.splice(from, to ?? values.length, ...items);
+}
+function unshiftArrayValues(...items) {
+	return this[SYMBOL_STATE].value.unshift(...items);
 }
 function updateArray(instance, type, array) {
 	const state = instance[SYMBOL_STATE];
@@ -1025,7 +1041,7 @@ function updateArray(instance, type, array) {
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
-		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
+		if (affectsLength ? array.length !== previousLength : !equalArrays(previousArray, array, state.equal)) {
 			emitValue(instance);
 			state.length.set(array.length);
 		}
@@ -1043,17 +1059,15 @@ function ReactiveStore(value, options) {
 	setProxyValue.call(this, value);
 }
 ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
-ReactiveStore.prototype.asReadonly = getReadonlyInstance;
+ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = emitProxyValues;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;
+ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
-ReactiveStore.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
 function store(value, options) {
 	return new ReactiveStore(value, options);
 }

package/dist/value/array.mjs

@@ -1,10 +1,10 @@
 import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, NAME_MORA, PROPERTY_LENGTH, SYMBOL_STATE } from "../constants.mjs";
-import { emitValue, equalArrays, getStringValue } from "../helpers/value.mjs";
+import { emitValue, equalArrays, getJsonValue, getStringValue } from "../helpers/value.mjs";
 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 { getReadonlyInstance } from "./readonly.mjs";
+import { getReadonlySignal } from "./readonly.mjs";
 import { signal } from "./signal.mjs";
 import { select } from "@oscarpalmer/atoms/array";
 import { filter } from "@oscarpalmer/atoms/array/filter";
@@ -19,64 +19,76 @@ function ReactiveArray(value, options) {
 		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(this, property, target) : Reflect.get(target, property),
 		set: (target, property, value) => setValueInProxy(this, target, property, value)
 	});
-	Object.defineProperty(this, PROPERTY_LENGTH, {
-		enumerable: true,
-		get: () => this[SYMBOL_STATE].length.get(),
-		set: (value) => setArrayLength(this[SYMBOL_STATE], value)
-	});
 	setProxyValue.call(this, value);
 }
 ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-ReactiveArray.prototype.asReadonly = getReadonlyInstance;
+Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
+	enumerable: true,
+	get: getArrayLength,
+	set: setArrayLength
+});
+ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.map = mapArrayValues;
 ReactiveArray.prototype.notify = emitProxyValues;
 ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.pop = popArrayValue;
+ReactiveArray.prototype.push = pushArrayValues;
+ReactiveArray.prototype.select = selectArrayValues;
+ReactiveArray.prototype.shift = shiftArrayValue;
 ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.splice = spliceArrayValues;
 ReactiveArray.prototype.subscribe = subscribeToProxy;
 ReactiveArray.prototype.toString = getStringValue;
+ReactiveArray.prototype.toJSON = getJsonValue;
+ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
-ReactiveArray.prototype.clear = function() {
-	this[SYMBOL_STATE].value.length = 0;
-};
-ReactiveArray.prototype.filter = function(callback) {
-	return computed(() => filter(getArrayValues.call(this), callback));
-};
-ReactiveArray.prototype.map = function(callback) {
-	return computed(() => getArrayValues.call(this).map(callback));
-};
-ReactiveArray.prototype.pop = function() {
-	return this[SYMBOL_STATE].value.pop();
-};
-ReactiveArray.prototype.push = function(...items) {
-	return this[SYMBOL_STATE].value.push(...items);
-};
-ReactiveArray.prototype.select = function(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
-};
-ReactiveArray.prototype.shift = function() {
-	return this[SYMBOL_STATE].value.shift();
-};
-ReactiveArray.prototype.splice = function(from, to, ...items) {
-	return this[SYMBOL_STATE].value.splice(from, to ?? this[SYMBOL_STATE].value.length, ...items);
-};
-ReactiveArray.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-ReactiveArray.prototype.unshift = function(...items) {
-	return this[SYMBOL_STATE].value.unshift(...items);
-};
 function array(value, options) {
 	return new ReactiveArray(value, options);
 }
+function clearArrayValues() {
+	this[SYMBOL_STATE].value.length = 0;
+}
+function filterArrayValues(callback) {
+	return computed(() => filter(getArrayValues.call(this), callback));
+}
+function getArrayLength() {
+	return this[SYMBOL_STATE].length.get();
+}
 function getArrayValues(value) {
 	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
+function mapArrayValues(callback) {
+	return computed(() => getArrayValues.call(this).map(callback));
+}
 function peekArrayValue(first, second) {
 	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
-function setArrayLength(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
+function popArrayValue() {
+	return this[SYMBOL_STATE].value.pop();
+}
+function pushArrayValues(...items) {
+	return this[SYMBOL_STATE].value.push(...items);
+}
+function selectArrayValues(filter, map) {
+	return computed(() => select(getArrayValues.call(this), filter, map));
+}
+function setArrayLength(value) {
+	const values = this[SYMBOL_STATE].value;
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== values.length) values.length = value;
+}
+function shiftArrayValue() {
+	return this[SYMBOL_STATE].value.shift();
+}
+function spliceArrayValues(from, to, ...items) {
+	const values = this[SYMBOL_STATE].value;
+	return values.splice(from, to ?? values.length, ...items);
+}
+function unshiftArrayValues(...items) {
+	return this[SYMBOL_STATE].value.unshift(...items);
 }
 function updateArray(instance, type, array) {
 	const state = instance[SYMBOL_STATE];
@@ -85,7 +97,7 @@ function updateArray(instance, type, array) {
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
-		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
+		if (affectsLength ? array.length !== previousLength : !equalArrays(previousArray, array, state.equal)) {
 			emitValue(instance);
 			state.length.set(array.length);
 		}

package/dist/value/computed.d.mts

@@ -1,4 +1,4 @@
-import { Computed, ComputedEffect, ReactiveOptions } from "../models.mjs";
+import { Computed, ComputedEffect, 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>): [Computed<unknown>, ComputedEffect];
+export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): [InternalComputed, ComputedEffect];
 //#endregion