@oscarpalmer/mora 0.31.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
  *
@@ -7,7 +8,7 @@ import { ReactiveArray, ReactiveOptions } from "../models.mjs";
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 /**
  * Create a reactive array from a promise
  *
@@ -15,7 +16,7 @@ declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: Re
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 /**
  * Create a reactive array
  *
@@ -23,6 +24,5 @@ declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<I
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
-//#endregion
-export { array };
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+//#endregion

package/dist/value/array.mjs

@@ -1,135 +1,96 @@
-import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, NAME_MORA } from "../constants.mjs";
-import { emitValue, equalArrays, getSimpleValue } from "../helpers/value.mjs";
-import { subscribe, unsubscribe } from "../subscription.mjs";
-import { reactive } from "./reactive.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 { computed } from "./computed.mjs";
-import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
+import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlyInstance } from "./readonly.mjs";
 import { signal } from "./signal.mjs";
 import { select } from "@oscarpalmer/atoms/array";
 import { filter } from "@oscarpalmer/atoms/array/filter";
-import { noop } from "@oscarpalmer/atoms/function";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/value/array.ts
-function array(value, options) {
-	const [rx, state] = reactive([], options);
-	const indiced = /* @__PURE__ */ new Map();
-	const length = signal(0);
-	const readonlies = {};
-	let instance = {};
-	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({
-			length,
-			property,
-			state,
-			target,
-			value,
-			isArray: true
-		})
-	});
-	function get(value) {
-		return getArrayValue(instance, indiced, state, length, value);
-	}
-	function set(first, second) {
-		setProxyValue(true, state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
-	}
-	const handlers = {
-		...rx,
-		get: (value) => get(value),
-		peek: (first, second) => peekArrayValue(state, length, first, second),
-		subscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(instance, indiced, first, true).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") getReactiveValueInProxy(instance, indiced, first, true)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		}
+function ReactiveArray(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: true,
+		length: signal(0)
 	};
-	instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		at: (index) => get(index),
-		clear: () => {
-			state.value.length = 0;
-		},
-		filter: (callback) => computed(() => filter(get(), callback)),
-		map: (callback) => computed(() => get().map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
-		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),
-		unshift: (...items) => state.value.unshift(...items),
-		update: (callback) => updateArrayValue(instance, state, callback)
-	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			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);
-}
-function getArrayValue(instance, indiced, state, length, first) {
-	if (typeof first === "number") return getReactiveValueInProxy(instance, indiced, first, true).get();
-	return first === "length" ? length.get() : getSimpleValue(state);
-}
-function isArrayIndex(value) {
-	return typeof value === "number";
+	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 isArrayValue(value) {
-	return value == null || Array.isArray(value);
+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 peekArrayValue(state, length, first, second) {
-	if (first === "length") return length.peek();
-	let value;
-	if (typeof first === "number") value = state.value.at(first);
-	else value = state.value;
-	if (!(first === true || second === true)) return value;
-	if (Array.isArray(value)) return value.slice();
-	if (isPlainObject(value)) return { ...value };
-	return value;
+function getArrayValues(value) {
+	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
-function setArray(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 setArrayLength(state, value) {
-	if (typeof value === "number" && value >= 0 && value !== state.value.length) state.value.length = value;
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
 }
-function setAtIndex(state, index, value) {
-	const actual = index < 0 ? state.value.length + index : index;
-	if (actual > -1) state.value[actual] = 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;
 	};
 }
-function updateArrayValue(instance, state, callback) {
-	const updated = callback(state.value);
-	if (updated == null || Array.isArray(updated)) instance.set(updated);
-}
 //#endregion
 export { array };

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

package/dist/value/computed.mjs

@@ -1,10 +1,22 @@
-import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA } 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 { getStringValue, handleSignalValue, peekSignalValue } from "../helpers/value.mjs";
 import { flushHandlers } from "../batch.mjs";
-import { handleSimpleValue } from "../helpers/value.mjs";
-import { subscribe } from "../subscription.mjs";
-import { reactive } from "./reactive.mjs";
+import { getState } from "../helpers/misc.mjs";
+import { subscribeToSignal } from "../helpers/subscription.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
 *
@@ -16,25 +28,11 @@ function computed(callback, options) {
 	return getComputed(callback, options)[0];
 }
 function getComputed(callback, options) {
-	const [rx, state] = reactive(void 0, options);
-	let fx;
-	const instance = {
-		...rx,
-		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
-	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_COMPUTED
-	});
-	fx = getComputedEffect(state, callback);
-	return [Object.freeze(instance), fx];
+	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
+	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
@@ -43,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;
@@ -51,21 +49,37 @@ 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.add(effect);
-	for (const [, subscription] of state.subscriptions) subscription.callback(value);
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === "frozen") continue;
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		if (subscriptions != null && subscriptions.size > 0) {
+			const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+			for (const [, callback] of subscriptions) callback(peekSignalValue.call(instance, copy));
+		}
+	}
 	flushHandlers();
 }
 //#endregion

package/dist/value/readonly.d.mts

@@ -1,7 +1,5 @@
-import { ReactiveState, ReadonlyFrozenSignal, ReadonlyInstances, ReadonlySignal } from "../models.mjs";
-import { GenericCallback } from "@oscarpalmer/atoms/models";
+import { InternalSignal, ReadonlyFrozenSignal, ReadonlySignal, SignalState } from "../models.mjs";
 //#region src/value/readonly.d.ts
-declare function getReadonlyInstance<Value>(state: ReactiveState<Value, never>, instances: ReadonlyInstances<Value>, handlers: Record<string, GenericCallback>, frozen: boolean): ReadonlySignal<Value>;
-declare function getReadonlySignal<Value>(state: ReactiveState<Value, never>, handlers: Record<string, GenericCallback>, frozen: boolean): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value>;
-//#endregion
-export { getReadonlyInstance, getReadonlySignal };
+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,37 +1,40 @@
-import { NAME_MORA, NAME_READONLY } from "../constants.mjs";
-import { getSimpleValue } from "../helpers/value.mjs";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
+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, handlers, frozen) {
-	const key = frozen ? "frozen" : "original";
-	instances[key] ??= getReadonlySignal(state, handlers, frozen);
-	return instances[key];
-}
-function getReadonlySignal(state, handlers, frozen) {
-	const instance = {
-		...handlers,
-		get: () => getReadonlyValue(state, false, frozen),
-		peek: () => getReadonlyValue(state, true, frozen)
-	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			value: NAME_READONLY
-		},
-		frozen: {
-			enumerable: true,
-			value: frozen
-		}
+function Readonly(state, frozen) {
+	this[SYMBOL_STATE] = state;
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
+		enumerable: true,
+		value: frozen
 	});
-	return Object.freeze(instance);
 }
-function getReadonlyValue(state, peek, frozen) {
-	let value = peek ? state.value : getSimpleValue(state);
-	if (!frozen) return value;
-	if (Array.isArray(state.value)) value = [...state.value];
-	else if (isPlainObject(state.value)) value = { ...state.value };
-	else value = state.value;
-	return Object.freeze(value);
+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) {
+	return new Readonly(state, frozen);
+}
+function getReadonlyValue(instance, peek, frozen, copy) {
+	let value;
+	if (peek) value = peekSignalValue.call(instance, copy === true);
+	else value = getSignalValue.call(instance);
+	return frozen ? getFrozenValue(value) : value;
 }
 //#endregion
 export { getReadonlyInstance, getReadonlySignal };

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
  *
@@ -7,7 +8,7 @@ import { ReactiveOptions, Signal } from "../models.mjs";
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+export declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value from a promise
  *
@@ -15,7 +16,7 @@ declare function signal<Value>(value: () => Value | Promise<Value>, options?: Re
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+export declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value
  *
@@ -23,6 +24,5 @@ declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
-//#endregion
-export { signal };
+export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
+//#endregion

package/dist/value/signal.mjs

@@ -1,43 +1,37 @@
-import { NAME_MORA, NAME_SIGNAL } from "../constants.mjs";
-import { emitValue, getSimpleValue, handleSimpleValue } from "../helpers/value.mjs";
-import { subscribe } from "../subscription.mjs";
-import { reactive } from "./reactive.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 { 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 handlers = {
-		...rx,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
-	};
-	const instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		get: () => getSimpleValue(state),
-		peek: () => state.value,
-		set: (value) => {
-			handleSimpleValue(state, value, setAndEmit);
-		},
-		update: (callback) => {
-			handleSimpleValue(state, callback(state.value), setAndEmit);
-		}
-	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		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
  *
@@ -8,7 +9,7 @@ import { PlainObject } from "@oscarpalmer/atoms/models";
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+export declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store from a promise
  *
@@ -16,7 +17,7 @@ declare function store<Value extends PlainObject>(value: () => Value | Promise<V
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+export declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store
  *
@@ -24,6 +25,5 @@ declare function store<Value extends PlainObject>(value: Promise<Value>, options
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
-//#endregion
-export { store };
+export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+//#endregion