@oscarpalmer/mora 0.33.0 → 0.35.0

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