@oscarpalmer/mora 0.32.0 → 0.33.0

package/dist/value/array.d.mts

@@ -1,5 +1,6 @@
 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

@@ -1,7 +1,7 @@
-import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, NAME_MORA } from "../constants.mjs";
-import { emitValue, equalArrays } from "../helpers/value.mjs";
+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 { getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
-import { reactive } from "./reactive.mjs";
 import { computed } from "./computed.mjs";
 import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlyInstance } from "./readonly.mjs";
@@ -9,77 +9,85 @@ import { signal } from "./signal.mjs";
 import { select } from "@oscarpalmer/atoms/array";
 import { filter } from "@oscarpalmer/atoms/array/filter";
 //#region src/value/array.ts
-function array(value, options) {
-	const [rx, state] = reactive([], options);
-	const isArray = true;
-	const length = signal(0);
-	const mapped = /* @__PURE__ */ new Map();
-	const readonlies = {};
-	state.value = new Proxy([], {
-		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, state, length) : Reflect.get(target, property),
-		set: (target, property, value) => setValueInProxy(isArray, state, target, property, value, length)
-	});
-	function get(value) {
-		return value === "length" ? length.get() : getValueInProxy(isArray, instance, state, mapped, value);
-	}
-	function set(first, second) {
-		setProxyValue(true, state, setArrayValue, setAtIndex, first, second);
-	}
-	const instance = {
-		...rx,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
-		at: (index) => get(index),
-		clear: () => {
-			state.value.length = 0;
-		},
-		filter: (callback) => computed(() => filter(get(), callback)),
-		get: (value) => get(value),
-		map: (callback) => computed(() => get().map(callback)),
-		notify: () => emitProxyValues(state, mapped),
-		peek: (first, second) => peekArrayValue(state, length, first, second),
-		pop: () => state.value.pop(),
-		push: (...items) => state.value.push(...items),
-		select: (filter, map) => computed(() => select(get(), filter, map)),
-		set: (first, second) => set(first, second),
-		shift: () => state.value.shift(),
-		splice: (from, to, ...items) => state.value.splice(from, to ?? state.value.length, ...items),
-		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, mapped, first, second, third),
-		unshift: (...items) => state.value.unshift(...items),
-		update: (callback) => updateProxyValue(true, state, setArrayValue, setAtIndex, callback)
+function ReactiveArray(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: true,
+		length: signal(0)
 	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: { value: NAME_ARRAY },
-		length: {
-			enumerable: true,
-			get: () => length.get(),
-			set: (value) => setArrayLength(state, value)
-		}
+	this[SYMBOL_STATE].value = new Proxy([], {
+		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(this, property, target) : Reflect.get(target, property),
+		set: (target, property, value) => setValueInProxy(this, target, property, value)
 	});
-	set(value);
-	return Object.freeze(instance);
+	Object.defineProperty(this, PROPERTY_LENGTH, {
+		enumerable: true,
+		get: () => this[SYMBOL_STATE].length.get(),
+		set: (value) => setArrayLength(this[SYMBOL_STATE], value)
+	});
+	setProxyValue.call(this, value);
 }
-function peekArrayValue(state, length, first, second) {
-	return first === "length" ? length.peek() : peekValueInProxy(true, state, first, second);
+ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
+ReactiveArray.prototype.asReadonly = getReadonlyInstance;
+ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.notify = emitProxyValues;
+ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.subscribe = subscribeToProxy;
+ReactiveArray.prototype.toString = getStringValue;
+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 setArrayLength(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
+function getArrayValues(value) {
+	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
-function setArrayValue(state, value) {
-	state.value.splice(0, state.value.length, ...value ?? []);
+function peekArrayValue(first, second) {
+	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
-function setAtIndex(state, index, value) {
-	const actual = index < 0 ? state.value.length + index : index;
-	if (actual > -1) state.value[actual] = value;
+function setArrayLength(state, value) {
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
 }
-function updateArray(type, array, state, length) {
+function updateArray(instance, type, array) {
+	const state = instance[SYMBOL_STATE];
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
 		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
-			emitValue(state);
-			length.set(array.length);
+			emitValue(instance);
+			state.length.set(array.length);
 		}
 		return result;
 	};

package/dist/value/computed.d.mts

@@ -1,5 +1,7 @@
 import { Computed, ComputedEffect, 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
  *
@@ -8,5 +10,5 @@ import { Computed, ComputedEffect, ReactiveOptions } from "../models.mjs";
  * @returns Computed value
  */
 export declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
-export declare function internalComputed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): [Computed<Value>, ComputedEffect];
+export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): [Computed<unknown>, ComputedEffect];
 //#endregion

package/dist/value/computed.mjs

@@ -1,10 +1,22 @@
-import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY } from "../constants.mjs";
+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 { handleSimpleValue, peekSimpleValue } from "../helpers/value.mjs";
+import { getStringValue, handleSignalValue, peekSignalValue } from "../helpers/value.mjs";
 import { flushHandlers } from "../batch.mjs";
+import { getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
-import { reactive } from "./reactive.mjs";
 //#region src/value/computed.ts
+function Computed(callback, options) {
+	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
+}
+Computed.prototype[NAME_MORA] = NAME_COMPUTED;
+Computed.prototype.get = getComputedValue;
+Computed.prototype.peek = peekSignalValue;
+Computed.prototype.subscribe = subscribeToSignal;
+Computed.prototype.toString = getStringValue;
+Computed.prototype.toJSON = function() {
+	return this[SYMBOL_STATE].value;
+};
 /**
 * Create a computed value
 *
@@ -17,19 +29,10 @@ function computed(callback, options) {
 }
 function getComputed(callback, options) {
 	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
-	const [rx, state] = reactive(void 0, options);
-	let fx;
-	const instance = {
-		...rx,
-		get: () => getValue(state, fx),
-		peek: (copy) => peekSimpleValue(state.value, copy === true),
-		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true)
-	};
-	Object.defineProperty(instance, NAME_MORA, { value: NAME_COMPUTED });
-	fx = getComputedEffect(state, callback);
-	return [Object.freeze(instance), fx];
+	const instance = new Computed(callback, options);
+	return [instance, instance[SYMBOL_EFFECT]];
 }
-function getComputedEffect(state, callback) {
+function getComputedEffect(instance, callback) {
 	const fx = {
 		dirty: true,
 		instance: void 0
@@ -38,7 +41,7 @@ function getComputedEffect(state, callback) {
 		if (fx.dirty) {
 			const previousComputed = ACTIVE.computed;
 			ACTIVE.computed = fx;
-			handleSimpleValue(state, callback, setAndEmit, () => {
+			handleSignalValue(instance, callback, setAndEmit, () => {
 				ACTIVE.computed = previousComputed;
 			});
 			fx.dirty = false;
@@ -46,25 +49,36 @@ function getComputedEffect(state, callback) {
 	});
 	return fx;
 }
-function getValue(state, fx) {
-	if (ACTIVE.computed != null && fx !== ACTIVE.computed) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null && ACTIVE.effect !== fx.instance) state.effects.add(ACTIVE.effect);
+function getComputedValue() {
+	const fx = this[SYMBOL_EFFECT];
+	const state = this[SYMBOL_STATE];
+	if (ACTIVE.computed != null && fx !== ACTIVE.computed) {
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
+	}
+	if (ACTIVE.effect != null && ACTIVE.effect !== fx.instance) {
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
+	}
 	if (fx.dirty && BATCH.depth === 0) runEffect(fx.instance);
 	return state.value;
 }
 function internalComputed(callback, options) {
 	return getComputed(callback, options);
 }
-function setAndEmit(state, value) {
-	if (state.equal(state.value, value)) return;
+function setAndEmit(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if ((state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
-	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	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);
 	for (const type of SUBSCRIPTION_TYPES) {
 		if (type === "frozen") continue;
-		const copy = SUBSCRIPTION_TYPES_COPY.has(type);
 		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
-		if (subscriptions != null) for (const [, callback] of subscriptions) callback(peekSimpleValue(state.value, copy));
+		if (subscriptions != null && subscriptions.size > 0) {
+			const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+			for (const [, callback] of subscriptions) callback(peekSignalValue.call(instance, copy));
+		}
 	}
 	flushHandlers();
 }

package/dist/value/readonly.d.mts

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

package/dist/value/readonly.mjs

@@ -1,32 +1,39 @@
-import { NAME_MORA, NAME_READONLY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_READONLY } from "../constants.mjs";
-import { getFrozenValue, getSimpleValue, peekSimpleValue } from "../helpers/value.mjs";
-import { subscribeToReactive } from "../helpers/subscription.mjs";
+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 { subscribeToReadonly } from "../helpers/subscription.mjs";
 //#region src/value/readonly.ts
-function getReadonlyInstance(state, instances, frozen) {
-	const key = frozen ? "frozen" : "original";
-	instances[key] ??= getReadonlySignal(state, frozen);
-	return instances[key];
+function Readonly(state, frozen) {
+	this[SYMBOL_STATE] = state;
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
+		enumerable: true,
+		value: frozen
+	});
+}
+Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.subscribe = subscribeToReadonly;
+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) {
+	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);
+	return this[SYMBOL_STATE].readonlies[key];
 }
 function getReadonlySignal(state, frozen) {
-	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
-	const instance = {
-		get: () => getReadonlyValue(state, false, frozen),
-		peek: (copy) => getReadonlyValue(state, true, frozen, copy),
-		subscribe: (callback) => subscribeToReactive(type, state, callback)
-	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: { value: NAME_READONLY },
-		frozen: {
-			enumerable: true,
-			value: frozen
-		}
-	});
-	return Object.freeze(instance);
+	return new Readonly(state, frozen);
 }
-function getReadonlyValue(state, peek, frozen, copy) {
+function getReadonlyValue(instance, peek, frozen, copy) {
 	let value;
-	if (peek) value = peekSimpleValue(state.value, copy === true);
-	else value = getSimpleValue(state);
+	if (peek) value = peekSignalValue.call(instance, copy === true);
+	else value = getSignalValue.call(instance);
 	return frozen ? getFrozenValue(value) : value;
 }
 //#endregion

package/dist/value/signal.d.mts

@@ -1,5 +1,6 @@
 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/signal.mjs

@@ -1,30 +1,37 @@
-import { NAME_MORA, NAME_SIGNAL } from "../constants.mjs";
-import { emitValue, getSimpleValue, handleSimpleValue, peekSimpleValue, updateSimpleValue } from "../helpers/value.mjs";
+import { NAME_MORA, NAME_SIGNAL, SYMBOL_STATE } from "../constants.mjs";
+import { emitValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue } from "../helpers/value.mjs";
+import { getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
-import { reactive } from "./reactive.mjs";
 import { getReadonlyInstance } from "./readonly.mjs";
 //#region src/value/signal.ts
-function setAndEmit(state, value) {
-	if (!state.equal(state.value, value)) {
+function Signal(value, options) {
+	this[SYMBOL_STATE] = getState(void 0, options);
+	handleSignalValue(this, value, setAndEmit);
+}
+Signal.prototype[NAME_MORA] = NAME_SIGNAL;
+Signal.prototype.asReadonly = getReadonlyInstance;
+Signal.prototype.get = getSignalValue;
+Signal.prototype.peek = peekSignalValue;
+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);
+};
+function setAndEmit(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if (!(state.equal ?? Object.is)(state.value, value)) {
 		state.value = value;
-		emitValue(state);
+		emitValue(instance);
 	}
 }
 function signal(value, options) {
-	const [rx, state] = reactive(void 0, options);
-	const readonlies = {};
-	const instance = {
-		...rx,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
-		get: () => getSimpleValue(state),
-		peek: (copy) => peekSimpleValue(state.value, copy === true),
-		set: (value) => handleSimpleValue(state, value, setAndEmit),
-		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true),
-		update: (callback) => updateSimpleValue(state, callback, setAndEmit)
-	};
-	Object.defineProperty(instance, NAME_MORA, { value: NAME_SIGNAL });
-	handleSimpleValue(state, value, setAndEmit);
-	return Object.freeze(instance);
+	return new Signal(value, options);
 }
 //#endregion
 export { signal };

package/dist/value/store.d.mts

@@ -1,6 +1,7 @@
 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

@@ -1,50 +1,32 @@
-import { NAME_MORA, NAME_STORE } from "../constants.mjs";
-import { startBatch, stopBatch } from "../batch.mjs";
+import { NAME_MORA, NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
+import { getStringValue } from "../helpers/value.mjs";
+import { getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
-import { reactive } from "./reactive.mjs";
 import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlyInstance } from "./readonly.mjs";
 //#region src/value/store.ts
-function setPropertyValue(state, key, value) {
-	state.value[key] = value;
-}
-function setStoreValue(state, value) {
-	startBatch();
-	const actual = value ?? {};
-	const proxy = state.value;
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-	let { length } = proxyKeys;
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
-	}
-	length = actualKeys.length;
-	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
-	}
-	stopBatch();
+function ReactiveStore(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: false
+	};
+	this[SYMBOL_STATE].value = new Proxy({}, { set: (target, property, value) => setValueInProxy(this, target, property, value) });
+	setProxyValue.call(this, value);
 }
+ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
+ReactiveStore.prototype.asReadonly = getReadonlyInstance;
+ReactiveStore.prototype.get = getValueInProxy;
+ReactiveStore.prototype.notify = emitProxyValues;
+ReactiveStore.prototype.peek = peekValueInProxy;
+ReactiveStore.prototype.set = setProxyValue;
+ReactiveStore.prototype.subscribe = subscribeToProxy;
+ReactiveStore.prototype.toString = getStringValue;
+ReactiveStore.prototype.update = updateProxyValue;
+ReactiveStore.prototype.toJSON = function() {
+	return this[SYMBOL_STATE].value;
+};
 function store(value, options) {
-	const [rx, state] = reactive(void 0, options);
-	const isArray = false;
-	const keyed = /* @__PURE__ */ new Map();
-	const readonlies = {};
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy(isArray, state, target, property, value) });
-	const instance = {
-		...rx,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
-		get: (value) => getValueInProxy(isArray, instance, state, keyed, value),
-		notify: () => emitProxyValues(state, keyed),
-		peek: (first, second) => peekValueInProxy(isArray, state, first, second),
-		set: (first, second) => setProxyValue(isArray, state, setStoreValue, setPropertyValue, first, second),
-		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, keyed, first, second, third),
-		update: (callback) => updateProxyValue(isArray, state, setStoreValue, setPropertyValue, callback)
-	};
-	Object.defineProperty(instance, NAME_MORA, { value: NAME_STORE });
-	instance.set(value);
-	return Object.freeze(instance);
+	return new ReactiveStore(value, options);
 }
 //#endregion
 export { store };

package/package.json

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

package/src/batch.ts

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

package/src/constants.ts

@@ -53,6 +53,10 @@ export const NAME_ALL = new Set([
 
 export const PROPERTY_LENGTH = 'length';
 
+export const SYMBOL_EFFECT = Symbol('effect');
+
+export const SYMBOL_STATE = Symbol('state');
+
 export const SUBSCRIPTION_PROPERTY = {
 	key: NAME_MORA,
 	value: NAME_SUBSCRIPTION,

package/src/effect.ts

@@ -1,7 +1,19 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
+import {ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE} from './constants';
 import type {Effect, EffectState} from './models';
 
+// #region Instance
+
+function Effect(this: any, callback: GenericCallback) {
+	this[SYMBOL_STATE] = {callback};
+
+	runEffect(this[SYMBOL_STATE]);
+}
+
+Effect.prototype[NAME_MORA] = NAME_EFFECT;
+
+// #endregion
+
 // #region Functions
 
 /**
@@ -19,17 +31,10 @@ export function effect(callback: GenericCallback): Effect {
 }
 
 function getEffect(callback: GenericCallback): [Effect, EffectState] {
-	const state: EffectState = {
-		callback,
-	};
-
-	const instance = Object.freeze({
-		[NAME_MORA]: NAME_EFFECT,
-	});
-
-	runEffect(state);
+	// @ts-expect-error All good, no worries :-)
+	const instance = new Effect(callback);
 
-	return [instance, state];
+	return [instance, instance[SYMBOL_STATE]];
 }
 
 export function internalEffect(callback: GenericCallback): EffectState {

package/src/helpers/is.ts

@@ -27,7 +27,7 @@ import type {
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
-export function isComputed<Value>(value: unknown): value is Computed<Value> {
+export function isComputed<Value = unknown>(value: unknown): value is Computed<Value> {
 	return isMora<Computed<Value>>(value, NAME_COMPUTED);
 }
 
@@ -58,7 +58,7 @@ function isMora<Instance>(value: unknown, name: string | Set<string>): value is
  * @param value Value to check
  * @returns True if value is a {@link Reactive}
  */
-export function isReactive<Value>(value: unknown): value is Reactive<Value> {
+export function isReactive<Value = unknown>(value: unknown): value is Reactive<Value> {
 	return isMora<Reactive<Value>>(value, NAME_ALL);
 }
 
@@ -68,7 +68,7 @@ export function isReactive<Value>(value: unknown): value is Reactive<Value> {
  * @param value Value to check
  * @returns True if value is a {@link Signal}
  */
-export function isSignal<Value>(value: unknown): value is Signal<Value> {
+export function isSignal<Value = unknown>(value: unknown): value is Signal<Value> {
 	return isMora<Signal<Value>>(value, NAME_SIGNAL);
 }
 
@@ -78,7 +78,7 @@ export function isSignal<Value>(value: unknown): value is Signal<Value> {
  * @param value Value to check
  * @returns True if value is a {@link ReactiveArray}
  */
-export function isReactiveArray<Item>(value: unknown): value is ReactiveArray<Item> {
+export function isReactiveArray<Item = unknown>(value: unknown): value is ReactiveArray<Item> {
 	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
 }
 
@@ -88,7 +88,7 @@ export function isReactiveArray<Item>(value: unknown): value is ReactiveArray<It
  * @param value Value to check
  * @returns True if value is a {@link Store}
  */
-export function isReactiveStore<Value extends PlainObject>(
+export function isReactiveStore<Value extends PlainObject = PlainObject>(
 	value: unknown,
 ): value is ReactiveStore<Value> {
 	return isMora<ReactiveStore<Value>>(value, NAME_STORE);
@@ -100,7 +100,7 @@ export function isReactiveStore<Value extends PlainObject>(
  * @param value Value to check
  * @returns True if value is a {@link ReadonlySignal}
  */
-export function isReadonlySignal<Value>(value: unknown): value is ReadonlySignal<Value> {
+export function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value> {
 	return isMora<ReadonlySignal<Value>>(value, NAME_READONLY);
 }
 

package/src/helpers/misc.ts

@@ -0,0 +1,15 @@
+import type {ReactiveOptions, ReactiveState} from '../models';
+
+// #region Functions
+
+export function getState(value: unknown, options?: ReactiveOptions<unknown>): ReactiveState {
+	return {
+		value,
+		equal:
+			typeof options === 'object' && typeof options?.equal === 'function'
+				? options.equal
+				: undefined,
+	};
+}
+
+// #endregion