@oscarpalmer/mora 0.33.0 → 0.35.0

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 };

package/dist/value/signal.mjs

@@ -1,28 +1,22 @@
 import { NAME_MORA, NAME_SIGNAL, SYMBOL_STATE } from "../constants.mjs";
-import { emitValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue } from "../helpers/value.mjs";
+import { emitValue, getJsonValue, getSignalValue, getStringValue, handleSignal, peekSignalValue, updateSignal } from "../helpers/value.mjs";
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
-import { getReadonlyInstance } from "./readonly.mjs";
+import { getReadonlySignal } from "./readonly.mjs";
 //#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)) {
@@ -30,8 +24,14 @@ 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
 export { signal };

package/dist/value/store.mjs

@@ -1,9 +1,9 @@
 import { NAME_MORA, NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
-import { getStringValue } from "../helpers/value.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 { getReadonlyInstance } from "./readonly.mjs";
+import { getReadonlySignal } from "./readonly.mjs";
 //#region src/value/store.ts
 function ReactiveStore(value, options) {
 	this[SYMBOL_STATE] = {
@@ -14,17 +14,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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.33.0",
+	"version": "0.35.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,7 +39,7 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.202"
+		"@oscarpalmer/atoms": "^0.203"
 	},
 	"devDependencies": {
 		"@types/node": "^26.5",

package/src/batch.ts

@@ -1,7 +1,7 @@
 import {BATCH} from './constants';
 import {runEffect} from './effect';
 import {getFrozenValue, peekSignalValue} from './helpers/value';
-import type {EffectState, StoredSubscription} from './models';
+import type {StoredSubscription} from './models';
 
 // #region Functions
 
@@ -30,7 +30,7 @@ export function flushHandlers(): void {
 							: peekSignalValue.call(subscription.instance, subscription.copy),
 					);
 				} else {
-					runEffect(handler as EffectState);
+					runEffect(handler);
 				}
 			}
 		}

package/src/constants.ts

@@ -16,9 +16,14 @@ export const BATCH: Batch = {
 	handlers: new Map(),
 };
 
-export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);
+export const METHODS_AFFECTING_LENGTH = new Set<string | symbol>([
+	'pop',
+	'push',
+	'shift',
+	'unshift',
+]);
 
-export const METHODS_UPDATE = new Set<string>([
+export const METHODS_UPDATE = new Set<string | symbol>([
 	...METHODS_AFFECTING_LENGTH,
 	'copyWithin',
 	'fill',

package/src/helpers/is.ts

@@ -46,9 +46,7 @@ function isMora<Instance>(value: unknown, name: string | Set<string>): value is
 		typeof value === 'object' &&
 		value != null &&
 		NAME_MORA in value &&
-		(typeof name === 'string'
-			? (value as PlainObject)[NAME_MORA] === name
-			: name.has((value as PlainObject)[NAME_MORA] as never))
+		(typeof name === 'string' ? value[NAME_MORA] === name : name.has(value[NAME_MORA] as never))
 	);
 }
 

package/src/helpers/proxy.ts

@@ -1,20 +1,19 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {
+	ArrayOrPlainObject,
+	GenericCallback,
+	Key,
+	PlainObject,
+} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
 import {PROPERTY_LENGTH, SYMBOL_STATE} from '../constants';
-import type {
-	Computed,
-	ReactiveArray,
-	ReactiveProxyState,
-	ReactiveStore,
-	InternalProxy,
-} from '../models';
+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: InternalProxy): void {
+export function emitProxyValues(this: InternalArray | InternalStore): void {
 	const state = this[SYMBOL_STATE];
 
 	state.mapped ??= new Map();
@@ -30,10 +29,10 @@ export function emitProxyValues(this: InternalProxy): void {
 }
 
 export function getReactiveValueInProxy(
-	instance: ReactiveArray<unknown> | ReactiveStore<unknown>,
+	instance: InternalArray | InternalStore,
 	key: Key,
-): Computed<unknown> {
-	const state = (instance as unknown as InternalProxy)[SYMBOL_STATE];
+): InternalComputed {
+	const state = instance[SYMBOL_STATE];
 
 	state.mapped ??= new Map();
 
@@ -54,19 +53,29 @@ export function getReactiveValueInProxy(
 	return item[0];
 }
 
-export function getValueInProxy(this: InternalProxy, first?: unknown): unknown {
+export function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown {
+	let signal: InternalComputed | undefined;
+
 	if (this[SYMBOL_STATE].isArray ? typeof first === 'number' : isKey(first)) {
-		return getReactiveValueInProxy(this as never, first as Key).get();
+		signal = getReactiveValueInProxy(this, first as Key);
 	}
 
-	return getSignalValue.call(this);
+	return getSignalValue.call(signal ?? this);
+}
+
+function isProxyKey(isArray: boolean, value: unknown): value is Key {
+	return isArray ? typeof value === 'number' : isKey(value);
 }
 
 function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainObject {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
 
-export function peekValueInProxy(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+export function peekValueInProxy(
+	this: InternalArray | InternalStore,
+	first?: unknown,
+	second?: boolean,
+): unknown {
 	const state = this[SYMBOL_STATE];
 
 	let value: unknown;
@@ -84,40 +93,38 @@ export function peekValueInProxy(this: InternalProxy, first?: unknown, second?:
 
 function setProxyObject(state: ReactiveProxyState, value: unknown): void {
 	if (state.isArray) {
-		(state.value as unknown[]).splice(
-			0,
-			(state.value as unknown[]).length,
-			...((value ?? []) as unknown[]),
-		);
+		const values = state.value as unknown[];
+
+		values.splice(0, values.length, ...((value ?? []) as unknown[]));
 
 		return;
 	}
 
 	startBatch();
 
-	const actual = (value as Record<string, unknown>) ?? {};
-	const proxy = state.value as PlainObject;
+	const current = state.value as PlainObject;
+	const next = (value as Record<string, unknown>) ?? {};
 
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
 
-	let {length} = proxyKeys;
+	let {length} = currentKeys;
 
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
+		const key = currentKeys[index];
 
-		proxy[key] = actualKeys.includes(key) ? actual[key] : undefined;
+		current[key] = nextKeys.includes(key) ? next[key] : undefined;
 	}
 
-	length = actualKeys.length;
+	length = nextKeys.length;
 
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
+		const key = nextKeys[index];
 
-		if (!proxyKeys.includes(key)) {
-			const keyedValue = actual[key];
+		if (!currentKeys.includes(key)) {
+			const keyedValue = next[key];
 
-			proxy[key] = keyedValue;
+			current[key] = keyedValue;
 		}
 	}
 
@@ -131,18 +138,22 @@ function setProxyProperty(state: ReactiveProxyState, property: unknown, value: u
 		return;
 	}
 
-	const actual =
-		(property as number) < 0
-			? (state.value as unknown[]).length + (property as number)
-			: (property as number);
+	const array = state.value as unknown[];
+	const index = property as number;
+
+	const actual = index < 0 ? array.length + index : index;
 
 	if (actual > -1) {
-		(state.value as unknown[])[actual] = value;
+		array[actual] = value;
 	}
 }
 
-export function setProxyValue(this: InternalProxy, first?: unknown, second?: unknown): void {
-	const state = this[SYMBOL_STATE] as ReactiveProxyState;
+export function setProxyValue(
+	this: InternalArray | InternalStore,
+	first?: unknown,
+	second?: unknown,
+): void {
+	const state = this[SYMBOL_STATE];
 
 	if (state.isArray && first === PROPERTY_LENGTH) {
 		(state.value as unknown[]).length = second as number;
@@ -156,55 +167,55 @@ export function setProxyValue(this: InternalProxy, first?: unknown, second?: unk
 		return;
 	}
 
-	const property = state.isArray ? typeof first === 'number' : isKey(first);
+	const keyed = isProxyKey(state.isArray, first);
 
-	if (state.isArray && property && Number.isNaN(first)) {
+	if (state.isArray && keyed && Number.isNaN(first)) {
 		return;
 	}
 
-	let actual = property ? second : first;
+	let actual = keyed ? second : first;
 
 	if (typeof actual === 'function') {
 		try {
-			actual = (actual as Function)();
+			actual = (actual as GenericCallback)();
 		} catch {
 			return;
 		}
 	}
 
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= new Map();
 
-			state.promises.set(first as Key, actual as Promise<never>);
+			state.promises.set(first, actual as Promise<never>);
 		} else {
 			state.promise = actual as Promise<never>;
 		}
 
 		void actual
 			.then(value => {
-				if (property && state.promises!.get(first as Key) === actual) {
-					state.promises!.delete(first as Key);
+				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 = undefined;
 
 					setProxyObject(state, value);
 				}
 			})
 			.catch(() => {
-				if (property && state.promises!.get(first as Key) === actual) {
-					state.promises!.delete(first as Key);
-				} else if (!property && state.promise === actual) {
+				if (keyed && state.promises?.get(first) === actual) {
+					state.promises?.delete(first);
+				} else if (!keyed && state.promise === actual) {
 					state.promise = undefined;
 				}
 			});
-	} else if (property) {
+	} else if (keyed) {
 		setProxyProperty(state, first, actual);
 	} else if (isProxyObject(state.isArray, actual)) {
 		setProxyObject(state, actual);
@@ -212,7 +223,7 @@ export function setProxyValue(this: InternalProxy, first?: unknown, second?: unk
 }
 
 export function setValueInProxy(
-	instance: InternalProxy,
+	instance: InternalArray | InternalStore,
 	target: object,
 	property: PropertyKey,
 	value: unknown,
@@ -228,9 +239,9 @@ export function setValueInProxy(
 		}
 	}
 
-	const previous = Reflect.get(target as object, property);
+	const previous = Reflect.get(target, property);
 
-	if (!(state.equal ?? Object.is)(previous as never, value as never)) {
+	if (!(state.equal ?? Object.is)(previous, value)) {
 		Reflect.set(target, property, value);
 
 		emitValue(instance);
@@ -243,7 +254,7 @@ export function setValueInProxy(
 	return true;
 }
 
-export function updateProxyValue(this: InternalProxy, callback: unknown): void {
+export function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Callback must be a function');
 	}