@oscarpalmer/mora 0.34.0 → 0.35.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
@@ -689,10 +693,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 +719,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 +782,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 +801,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 +827,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 +842,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 +892,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 +944,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 +965,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 +1043,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 +1061,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

package/dist/value/computed.mjs

@@ -1,6 +1,6 @@
 import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
 import { internalEffect, runEffect } from "../effect.mjs";
-import { getStringValue, handleSignalValue, peekSignalValue } from "../helpers/value.mjs";
+import { getJsonValue, getStringValue, handleSignal, peekSignalValue } from "../helpers/value.mjs";
 import { flushHandlers } from "../batch.mjs";
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
@@ -13,10 +13,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
 *
@@ -41,7 +39,7 @@ function getComputedEffect(instance, callback) {
 		if (fx.dirty) {
 			const previousComputed = ACTIVE.computed;
 			ACTIVE.computed = fx;
-			handleSignalValue(instance, callback, setAndEmit, () => {
+			handleSignal(instance, callback, setAndEmit, () => {
 				ACTIVE.computed = previousComputed;
 			});
 			fx.dirty = false;

package/dist/value/readonly.d.mts

@@ -1,5 +1,5 @@
 import { InternalSignal, ReadonlyFrozenSignal, ReadonlySignal, SignalState } from "../models.mjs";
 //#region src/value/readonly.d.ts
-export declare function getReadonlyInstance<Value>(this: InternalSignal, frozen?: never): ReadonlySignal<Value>;
-export declare function getReadonlySignal(state: SignalState, frozen: boolean): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown>;
+export declare function getReadonlyInstance(state: SignalState, frozen: boolean): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown>;
+export declare function getReadonlySignal<Value>(this: InternalSignal, frozen?: never): ReadonlySignal<Value>;
 //#endregion

package/dist/value/readonly.mjs

@@ -1,40 +1,37 @@
 import { NAME_MORA, NAME_READONLY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SYMBOL_STATE } from "../constants.mjs";
-import { getFrozenValue, getSignalValue, getStringValue, peekSignalValue } from "../helpers/value.mjs";
+import { getFrozenValue, getJsonValue, getSignalValue, getStringValue, peekSignalValue } from "../helpers/value.mjs";
 import { subscribeToReadonly } from "../helpers/subscription.mjs";
 //#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
 export { getReadonlyInstance, getReadonlySignal };