@oscarpalmer/mora 0.34.0 → 0.35.0

package/src/models.ts

@@ -15,7 +15,7 @@ export type Batch = {
 	handlers: Map<EffectState | Subscription, EffectState | StoredSubscription>;
 };
 
-export type Computed<Value> = Reactive<Value> & SimpleReactive<Value>;
+export type Computed<Value> = Reactive<Value>;
 
 export type ComputedEffect = {
 	dirty: boolean;
@@ -28,23 +28,46 @@ export type EffectState = {
 	callback: GenericCallback;
 };
 
+export type InternalArray = {
+	[SYMBOL_STATE]: ReactiveProxyState;
+} & ReactiveArray<unknown>;
+
 export type InternalComputed = {
 	[SYMBOL_EFFECT]: ComputedEffect;
-} & InternalSignal;
-
-export type InternalProxy = {
-	[SYMBOL_STATE]: ReactiveProxyState;
-};
+	[SYMBOL_STATE]: SignalState;
+} & Computed<unknown>;
 
 export type InternalReadonly = {
 	frozen: boolean;
-} & InternalSignal;
+} & InternalStateful &
+	ReadonlySignal<unknown>;
 
-export type InternalSignal = {
+export type InternalSignal = InternalStateful & Signal<unknown>;
+
+export type InternalStateful = {
 	[SYMBOL_STATE]: SignalState;
 };
 
+export type InternalStore = {
+	[SYMBOL_STATE]: ReactiveProxyState;
+} & ReactiveStore<PlainObject>;
+
 export type Reactive<Value> = {
+	/**
+	 * Get the value
+	 *
+	 * @returns Current value
+	 */
+	get(): Value;
+
+	/**
+	 * Get the value _(without reactivity)_
+	 *
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Current value
+	 */
+	peek(copy?: boolean): Value;
+
 	/**
 	 * _JSON_ representation of the value
 	 *
@@ -59,6 +82,15 @@ export type Reactive<Value> = {
 	 * @returns Value as string
 	 */
 	toString(json?: boolean): string;
+
+	/**
+	 * Subscribe to changes
+	 *
+	 * @param subscriber Callback for changes
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
+	 */
+	subscribe(subscriber: Subscriber<Value>, copy?: boolean): Subscription;
 };
 
 export type ReactiveArray<Item> = {
@@ -292,17 +324,17 @@ export type ReactiveOptions<Value> = {
 export type ReactiveProxyState = {
 	isArray: boolean;
 	length?: Signal<number>;
-	mapped?: Map<string, [Computed<unknown>, ComputedEffect]>;
+	mapped?: Map<string, [InternalComputed, ComputedEffect]>;
 } & SignalState;
 
-export type ReactiveState = {
+export type ReactiveState<Value = unknown, Item = Value> = {
 	computeds?: Set<ComputedEffect>;
 	effects?: Set<EffectState>;
-	equal?: (first: unknown, second: unknown) => boolean;
+	equal?: (first: Item, second: Item) => boolean;
 	promise?: Promise<unknown>;
 	promises?: Map<Key, Promise<never>>;
 	subscriptions?: Subscriptions<GenericCallback>;
-	value: unknown;
+	value: Value;
 };
 
 export type ReactiveStore<Store> = {
@@ -465,8 +497,7 @@ export type ReadonlySignal<Value> = {
 	 * Is the signal frozen?
 	 */
 	get frozen(): boolean;
-} & Reactive<Value> &
-	SimpleReactive<Value>;
+} & Reactive<Value>;
 
 export type ReadonlySignalValue<Value> = Value extends unknown[]
 	? Readonly<Value>
@@ -506,44 +537,17 @@ export type Signal<Value> = {
 	 * @param callback Callback to update the value
 	 */
 	update(callback: (value: Value) => Value): void;
-} & Reactive<Value> &
-	SimpleReactive<Value>;
+} & Reactive<Value>;
 
 export type SignalState = {
 	readonlies?: ReadonlyInstances<unknown>;
 } & ReactiveState;
 
-type SimpleReactive<Value> = {
-	/**
-	 * Get the value
-	 *
-	 * @returns Current value
-	 */
-	get(): Value;
-
-	/**
-	 * Get the value _(without reactivity)_
-	 *
-	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
-	 * @returns Current value
-	 */
-	peek(copy?: boolean): Value;
-
-	/**
-	 * Subscribe to changes
-	 *
-	 * @param subscriber Callback for changes
-	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
-	 * @returns Subscription
-	 */
-	subscribe(subscriber: Subscriber<Value>, copy?: boolean): Subscription;
-};
-
 export type StoredSubscription = {
 	callback: GenericCallback;
 	copy: boolean;
 	frozen: boolean;
-	instance: InternalSignal;
+	instance: InternalStateful;
 	state: SignalState;
 };
 

package/src/value/array.ts

@@ -18,10 +18,10 @@ import {
 	updateProxyValue,
 } from '../helpers/proxy';
 import {subscribeToProxy} from '../helpers/subscription';
-import {emitValue, equalArrays, getStringValue} from '../helpers/value';
-import type {InternalProxy, ReactiveArray, ReactiveOptions, ReactiveState} from '../models';
+import {emitValue, equalArrays, getJsonValue, getStringValue} from '../helpers/value';
+import type {Computed, InternalArray, ReactiveArray, ReactiveOptions} from '../models';
 import {computed} from './computed';
-import {getReadonlyInstance} from './readonly';
+import {getReadonlySignal} from './readonly';
 import {signal} from './signal';
 
 // #region Instance
@@ -35,73 +35,43 @@ function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unkn
 
 	this[SYMBOL_STATE].value = new Proxy([], {
 		get: (target, property) =>
-			METHODS_UPDATE.has(property as string)
-				? updateArray(this, property as string, target)
+			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: number) => 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: never) {
-	return computed(() => filter(getArrayValues.call(this) as never, callback) as never);
-};
-
-ReactiveArray.prototype.map = function (callback: never) {
-	return computed(() => (getArrayValues.call(this) as unknown[]).map(callback));
-};
-
-ReactiveArray.prototype.pop = function () {
-	return this[SYMBOL_STATE].value.pop();
-};
-
-ReactiveArray.prototype.push = function (...items: unknown[]) {
-	return this[SYMBOL_STATE].value.push(...items);
-};
-
-ReactiveArray.prototype.select = function (filter: never, map: never) {
-	return computed(() => select(getArrayValues.call(this) as unknown[], filter, map));
-};
-
-ReactiveArray.prototype.shift = function () {
-	return this[SYMBOL_STATE].value.shift();
-};
-
-ReactiveArray.prototype.splice = function (from: never, to?: never, ...items: unknown[]) {
-	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: unknown[]) {
-	return this[SYMBOL_STATE].value.unshift(...items);
-};
-
 // #endregion
 
 // #region Functions
@@ -144,30 +114,75 @@ export function array(value: unknown, options?: ReactiveOptions<unknown>): React
 	return new ReactiveArray(value, options);
 }
 
-function getArrayValues(this: InternalProxy, value?: unknown): unknown {
+function clearArrayValues(this: InternalArray): void {
+	(this[SYMBOL_STATE].value as unknown[]).length = 0;
+}
+
+function filterArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
+	return computed(() => filter(getArrayValues.call(this) as never, callback) as never);
+}
+
+function getArrayLength(this: InternalArray): number {
+	return this[SYMBOL_STATE].length!.get();
+}
+
+function getArrayValues(this: InternalArray, value?: unknown): unknown {
 	return value === PROPERTY_LENGTH
 		? this[SYMBOL_STATE].length!.get()
 		: getValueInProxy.call(this, value);
 }
 
-function peekArrayValue(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+function mapArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
+	return computed(() => (getArrayValues.call(this) as unknown[]).map(callback));
+}
+
+function peekArrayValue(this: InternalArray, first?: unknown, second?: boolean): unknown {
 	return first === PROPERTY_LENGTH
 		? this[SYMBOL_STATE].length!.peek()
 		: peekValueInProxy.call(this, first, second);
 }
 
-function setArrayLength(state: ReactiveState, value: number): void {
-	if (
-		typeof value === 'number' &&
-		!Number.isNaN(value) &&
-		value >= 0 &&
-		value !== (state.value as unknown[]).length
-	) {
-		(state.value as unknown[]).length = value;
+function popArrayValue(this: InternalArray): unknown {
+	return (this[SYMBOL_STATE].value as unknown[]).pop();
+}
+
+function pushArrayValues(this: InternalArray, ...items: unknown[]): number {
+	return (this[SYMBOL_STATE].value as unknown[]).push(...items);
+}
+
+function selectArrayValues(this: InternalArray, filter: never, map: never): Computed<unknown[]> {
+	return computed(() => select(getArrayValues.call(this) as unknown[], filter, map));
+}
+
+function setArrayLength(this: InternalArray, value: number): void {
+	const state = this[SYMBOL_STATE];
+	const values = state.value as unknown[];
+
+	if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value !== values.length) {
+		values.length = value;
 	}
 }
 
-function updateArray(instance: InternalProxy, type: string, array: unknown[]): unknown {
+function shiftArrayValue(this: InternalArray): unknown {
+	return (this[SYMBOL_STATE].value as unknown[]).shift();
+}
+
+function spliceArrayValues(
+	this: InternalArray,
+	from: never,
+	to?: never,
+	...items: unknown[]
+): unknown[] {
+	const values = this[SYMBOL_STATE].value as unknown[];
+
+	return values.splice(from, to ?? values.length, ...items);
+}
+
+function unshiftArrayValues(this: InternalArray, ...items: unknown[]): number {
+	return (this[SYMBOL_STATE].value as unknown[]).unshift(...items);
+}
+
+function updateArray(instance: InternalArray, type: string | symbol, array: unknown[]): unknown {
 	const state = instance[SYMBOL_STATE];
 
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
@@ -178,7 +193,9 @@ function updateArray(instance: InternalProxy, type: string, array: unknown[]): u
 		const result = (array[type as never] as (...args: unknown[]) => unknown)(...args);
 
 		if (
-			affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)
+			affectsLength
+				? array.length !== previousLength
+				: !equalArrays(previousArray, array, state.equal)
 		) {
 			emitValue(instance);
 

package/src/value/computed.ts

@@ -14,20 +14,19 @@ import {
 import {internalEffect, runEffect} from '../effect';
 import {getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
-import {getStringValue, handleSignalValue, peekSignalValue} from '../helpers/value';
+import {getJsonValue, getStringValue, handleSignal, peekSignalValue} from '../helpers/value';
 import type {
 	Computed,
 	ComputedEffect,
-	ReactiveOptions,
 	InternalComputed,
-	InternalSignal,
+	InternalStateful,
+	ReactiveOptions,
 } from '../models';
 
 // #region Instance
 
 function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>) {
 	this[SYMBOL_STATE] = getState(undefined, options);
-
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
 
@@ -36,12 +35,9 @@ 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;
-};
-
 // #endregion
 
 // #region Functions
@@ -57,13 +53,13 @@ export function computed<Value>(
 	callback: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): Computed<Value> {
-	return getComputed(callback, options)[0];
+	return getComputed(callback, options)[0] as Computed<Value>;
 }
 
 function getComputed<Value>(
 	callback: GenericCallback,
 	options?: ReactiveOptions<Value>,
-): [Computed<Value>, ComputedEffect] {
+): [InternalComputed, ComputedEffect] {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Computed callback must be a function');
 	}
@@ -71,11 +67,11 @@ function getComputed<Value>(
 	// @ts-expect-error All good, no worries :-)
 	const instance = new Computed(callback, options);
 
-	return [instance as never, instance[SYMBOL_EFFECT]];
+	return [instance, instance[SYMBOL_EFFECT]];
 }
 
 function getComputedEffect(
-	instance: InternalSignal,
+	instance: InternalStateful,
 	callback: GenericAsyncCallback,
 ): ComputedEffect {
 	const fx: ComputedEffect = {
@@ -89,7 +85,7 @@ function getComputedEffect(
 
 			ACTIVE.computed = fx;
 
-			handleSignalValue(instance, callback, setAndEmit, () => {
+			handleSignal(instance, callback, setAndEmit, () => {
 				ACTIVE.computed = previousComputed;
 			});
 
@@ -126,14 +122,14 @@ function getComputedValue(this: InternalComputed): unknown {
 export function internalComputed(
 	callback: GenericCallback,
 	options?: ReactiveOptions<unknown>,
-): [Computed<unknown>, ComputedEffect] {
+): [InternalComputed, ComputedEffect] {
 	return getComputed(callback, options);
 }
 
-function setAndEmit(instance: InternalSignal, value: unknown): void {
+function setAndEmit(instance: InternalStateful, value: unknown): void {
 	const state = instance[SYMBOL_STATE];
 
-	if ((state.equal ?? Object.is)(state.value as never, value as never)) {
+	if ((state.equal ?? Object.is)(state.value, value)) {
 		return;
 	}
 

package/src/value/readonly.ts

@@ -6,42 +6,51 @@ import {
 	SYMBOL_STATE,
 } from '../constants';
 import {subscribeToReadonly} from '../helpers/subscription';
-import {getFrozenValue, getSignalValue, getStringValue, peekSignalValue} from '../helpers/value';
-import type {ReadonlyFrozenSignal, ReadonlySignal, SignalState, InternalSignal} from '../models';
+import {
+	getFrozenValue,
+	getJsonValue,
+	getSignalValue,
+	getStringValue,
+	peekSignalValue,
+} from '../helpers/value';
+import type {InternalSignal, ReadonlyFrozenSignal, ReadonlySignal, SignalState} from '../models';
+
+// #region Types
+
+type InternalReadonly = {
+	[SUBSCRIPTION_TYPE_FROZEN]: boolean;
+} & InternalSignal;
+
+// #endregion
 
 // #region Instance
 
 function Readonly(this: any, state: SignalState, frozen: boolean) {
+	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?: boolean) {
-	return getReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
-};
-
-Readonly.prototype.toJSON = function () {
-	return this[SYMBOL_STATE].value;
-};
-
 // #endregion
 
 // #region Functions
 
-export function getReadonlyInstance<Value>(
+export function getReadonlyInstance(
+	state: SignalState,
+	frozen: boolean,
+): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown> {
+	// @ts-expect-error All good, no worries :-)
+	return new Readonly(state, frozen);
+}
+
+export function getReadonlySignal<Value>(
 	this: InternalSignal,
 	frozen?: never,
 ): ReadonlySignal<Value> {
@@ -49,7 +58,7 @@ export function getReadonlyInstance<Value>(
 
 	this[SYMBOL_STATE].readonlies ??= {};
 
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlySignal(
+	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(
 		this[SYMBOL_STATE],
 		frozen === true,
 	) as never;
@@ -57,16 +66,12 @@ export function getReadonlyInstance<Value>(
 	return this[SYMBOL_STATE].readonlies[key] as never;
 }
 
-export function getReadonlySignal(
-	state: SignalState,
-	frozen: boolean,
-): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown> {
-	// @ts-expect-error All good, no worries :-)
-	return new Readonly(state, frozen);
+function getReadonlyValue(this: InternalReadonly) {
+	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
 }
 
-function getReadonlyValue(
-	instance: InternalSignal,
+function handleReadonlyValue(
+	instance: InternalReadonly,
 	peek: boolean,
 	frozen: boolean,
 	copy?: boolean,
@@ -82,4 +87,8 @@ function getReadonlyValue(
 	return frozen ? getFrozenValue(value) : value;
 }
 
+function peekReadonlyValue(this: InternalReadonly, copy?: boolean) {
+	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+}
+
 // #endregion

package/src/value/signal.ts

@@ -3,57 +3,53 @@ import {getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
 import {
 	emitValue,
+	getJsonValue,
 	getSignalValue,
 	getStringValue,
-	handleSignalValue,
+	handleSignal,
 	peekSignalValue,
-	updateSignalValue,
+	updateSignal,
 } from '../helpers/value';
-import type {ReactiveOptions, Signal, InternalSignal} from '../models';
-import {getReadonlyInstance} from './readonly';
+import type {InternalSignal, InternalStateful, ReactiveOptions, Signal} from '../models';
+import {getReadonlySignal} from './readonly';
 
 // #region Instance
 
 function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>) {
 	this[SYMBOL_STATE] = getState(undefined, 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: never) {
-	return handleSignalValue(this, value, setAndEmit);
-};
-
-Signal.prototype.toJSON = function () {
-	return this[SYMBOL_STATE].value;
-};
-
-Signal.prototype.update = function (callback: never) {
-	return updateSignalValue(this, callback, setAndEmit);
-};
+Signal.prototype.toJSON = getJsonValue;
+Signal.prototype.update = updateSignalValue;
 
 // #endregion
 
 // #region Functions
 
-function setAndEmit(instance: InternalSignal, value: unknown): void {
+function setAndEmit(instance: InternalStateful, value: unknown): void {
 	const state = instance[SYMBOL_STATE];
 
-	if (!(state.equal ?? Object.is)(state.value as never, value as never)) {
+	if (!(state.equal ?? Object.is)(state.value, value)) {
 		state.value = value;
 
 		emitValue(instance);
 	}
 }
 
+function setSignalValue(this: InternalSignal, value: unknown): void {
+	handleSignal(this, value, setAndEmit);
+}
+
 /**
  * Create a reactive value from a function result
  *
@@ -92,4 +88,8 @@ export function signal(value: unknown, options?: ReactiveOptions<unknown>): Sign
 	return new Signal(value, options);
 }
 
+function updateSignalValue(this: InternalSignal, callback: never): void {
+	updateSignal(this, callback, setAndEmit);
+}
+
 // #endregion

package/src/value/store.ts

@@ -10,9 +10,9 @@ import {
 	updateProxyValue,
 } from '../helpers/proxy';
 import {subscribeToProxy} from '../helpers/subscription';
-import {getStringValue} from '../helpers/value';
+import {getJsonValue, getStringValue} from '../helpers/value';
 import type {ReactiveOptions, ReactiveStore} from '../models';
-import {getReadonlyInstance} from './readonly';
+import {getReadonlySignal} from './readonly';
 
 // #region Instance
 
@@ -34,19 +34,16 @@ function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknow
 
 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;
-};
-
 // #endregion
 
 // #region Functions