@oscarpalmer/mora 0.32.0 → 0.33.0

package/src/value/readonly.ts

@@ -2,58 +2,71 @@ import {
 	NAME_MORA,
 	NAME_READONLY,
 	SUBSCRIPTION_TYPE_FROZEN,
-	SUBSCRIPTION_TYPE_READONLY,
+	SUBSCRIPTION_TYPE_ORIGINAL,
+	SYMBOL_STATE,
 } from '../constants';
-import {subscribeToReactive} from '../helpers/subscription';
-import {getFrozenValue, getSimpleValue, peekSimpleValue} from '../helpers/value';
-import type {
-	ReactiveState,
-	ReadonlyFrozenSignal,
-	ReadonlyInstances,
-	ReadonlySignal,
-} from '../models';
+import {subscribeToReadonly} from '../helpers/subscription';
+import {getFrozenValue, getSignalValue, getStringValue, peekSignalValue} from '../helpers/value';
+import type {ReadonlyFrozenSignal, ReadonlySignal, SignalState, InternalSignal} from '../models';
+
+// #region Instance
+
+function Readonly(this: any, state: SignalState, frozen: boolean) {
+	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?: 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>(
-	state: ReactiveState<Value, never>,
-	instances: ReadonlyInstances<Value>,
-	frozen: boolean,
+	this: InternalSignal,
+	frozen?: never,
 ): ReadonlySignal<Value> {
-	const key = frozen ? 'frozen' : 'original';
+	const key = (frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL) as never;
+
+	this[SYMBOL_STATE].readonlies ??= {};
 
-	instances[key] ??= getReadonlySignal(state, frozen) as never;
+	this[SYMBOL_STATE].readonlies[key] ??= getReadonlySignal(
+		this[SYMBOL_STATE],
+		frozen === true,
+	) as never;
 
-	return instances[key] as never;
+	return this[SYMBOL_STATE].readonlies[key] as never;
 }
 
-export function getReadonlySignal<Value>(
-	state: ReactiveState<Value, never>,
+export function getReadonlySignal(
+	state: SignalState,
 	frozen: boolean,
-): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value> {
-	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
-
-	const instance = {
-		get: () => getReadonlyValue(state, false, frozen),
-		peek: (copy?: boolean) => getReadonlyValue(state, true, frozen, copy),
-		subscribe: (callback: never) => subscribeToReactive(type, state, callback),
-	};
-
-	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			value: NAME_READONLY,
-		},
-		frozen: {
-			enumerable: true,
-			value: frozen,
-		},
-	});
-
-	return Object.freeze(instance) as never;
+): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown> {
+	// @ts-expect-error All good, no worries :-)
+	return new Readonly(state, frozen);
 }
 
-function getReadonlyValue<Value>(
-	state: ReactiveState<Value, never>,
+function getReadonlyValue(
+	instance: InternalSignal,
 	peek: boolean,
 	frozen: boolean,
 	copy?: boolean,
@@ -61,9 +74,9 @@ function getReadonlyValue<Value>(
 	let value: unknown;
 
 	if (peek) {
-		value = peekSimpleValue(state.value, copy === true);
+		value = peekSignalValue.call(instance, copy === true);
 	} else {
-		value = getSimpleValue(state);
+		value = getSignalValue.call(instance);
 	}
 
 	return frozen ? getFrozenValue(value) : value;

package/src/value/signal.ts

@@ -1,23 +1,56 @@
-import {NAME_MORA, NAME_SIGNAL} from '../constants';
+import {NAME_MORA, NAME_SIGNAL, SYMBOL_STATE} from '../constants';
+import {getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
 import {
 	emitValue,
-	getSimpleValue,
-	handleSimpleValue,
-	peekSimpleValue,
-	updateSimpleValue,
+	getSignalValue,
+	getStringValue,
+	handleSignalValue,
+	peekSignalValue,
+	updateSignalValue,
 } from '../helpers/value';
-import type {ReactiveOptions, ReactiveState, ReadonlyInstances, Signal} from '../models';
-import {reactive} from './reactive';
+import type {ReactiveOptions, Signal, InternalSignal} from '../models';
 import {getReadonlyInstance} from './readonly';
 
+// #region Instance
+
+function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>) {
+	this[SYMBOL_STATE] = getState(undefined, 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: 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);
+};
+
+// #endregion
+
 // #region Functions
 
-function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): void {
-	if (!state.equal(state.value, value)) {
+function setAndEmit(instance: InternalSignal, value: unknown): void {
+	const state = instance[SYMBOL_STATE];
+
+	if (!(state.equal ?? Object.is)(state.value as never, value as never)) {
 		state.value = value;
 
-		emitValue(state);
+		emitValue(instance);
 	}
 }
 
@@ -54,31 +87,9 @@ export function signal<Value>(
  */
 export function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
 
-export function signal<Value>(
-	value: Value | (() => Value | Promise<Value>) | Promise<Value>,
-	options?: ReactiveOptions<Value>,
-): Signal<Value> {
-	const [rx, state] = reactive<Value>(undefined as unknown as Value, options);
-
-	const readonlies: ReadonlyInstances<Value> = {};
-
-	const instance = {
-		...rx,
-		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
-		get: () => getSimpleValue(state),
-		peek: (copy?: boolean) => peekSimpleValue(state.value, copy === true),
-		set: (value: never) => handleSimpleValue(state, value, setAndEmit),
-		subscribe: (callback: never, copy?: never) => subscribeToSignal(state, callback, copy === true),
-		update: (callback: never) => updateSimpleValue(state, callback, setAndEmit),
-	};
-
-	Object.defineProperty(instance, NAME_MORA, {
-		value: NAME_SIGNAL,
-	});
-
-	handleSimpleValue(state, value, setAndEmit);
-
-	return Object.freeze(instance) as never;
+export function signal(value: unknown, options?: ReactiveOptions<unknown>): Signal<unknown> {
+	// @ts-expect-error All good, no worries :-)
+	return new Signal(value, options);
 }
 
 // #endregion

package/src/value/store.ts

@@ -1,6 +1,6 @@
-import type {Key, PlainObject} from '@oscarpalmer/atoms/models';
-import {startBatch, stopBatch} from '../batch';
-import {NAME_MORA, NAME_STORE} from '../constants';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {NAME_MORA, NAME_STORE, SYMBOL_STATE} from '../constants';
+import {getState} from '../helpers/misc';
 import {
 	emitProxyValues,
 	getValueInProxy,
@@ -10,61 +10,46 @@ import {
 	updateProxyValue,
 } from '../helpers/proxy';
 import {subscribeToProxy} from '../helpers/subscription';
-import type {
-	Computed,
-	ComputedEffect,
-	ReactiveOptions,
-	ReactiveState,
-	ReactiveStore,
-	ReadonlyInstances,
-} from '../models';
-import {reactive} from './reactive';
+import {getStringValue} from '../helpers/value';
+import type {ReactiveOptions, ReactiveStore} from '../models';
 import {getReadonlyInstance} from './readonly';
 
-// #region Functions
-
-function setPropertyValue<Value extends PlainObject, Item = Value>(
-	state: ReactiveState<Value, Item>,
-	key: unknown,
-	value: unknown,
-): void {
-	(state.value as PlainObject)[key as Key] = value;
-}
-
-function setStoreValue<Value extends PlainObject, Item = Value>(
-	state: ReactiveState<Value, Item>,
-	value: PlainObject | undefined,
-): void {
-	startBatch();
-
-	const actual = value ?? {};
-	const proxy = state.value as PlainObject;
+// #region Instance
 
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-
-	let {length} = proxyKeys;
+function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknown>) {
+	this[SYMBOL_STATE] = {
+		...getState(undefined, options),
+		isArray: false,
+	};
 
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
+	this[SYMBOL_STATE].value = new Proxy(
+		{},
+		{
+			set: (target, property, value) => setValueInProxy(this, target, property, value),
+		},
+	);
 
-		proxy[key] = actualKeys.includes(key) ? actual[key] : undefined;
-	}
+	setProxyValue.call(this, value);
+}
 
-	length = actualKeys.length;
+ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 
-	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
+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;
 
-		if (!proxyKeys.includes(key)) {
-			const keyedValue = actual[key];
+ReactiveStore.prototype.toJSON = function () {
+	return this[SYMBOL_STATE].value;
+};
 
-			proxy[key] = keyedValue;
-		}
-	}
+// #endregion
 
-	stopBatch();
-}
+// #region Functions
 
 /**
  * Create a reactive store from a function result
@@ -102,41 +87,9 @@ export function store<Value extends PlainObject>(
 	options?: ReactiveOptions<Value>,
 ): ReactiveStore<Value>;
 
-export function store<Value extends PlainObject>(
-	value: Value | (() => Value | Promise<Value>) | Promise<Value>,
-	options?: ReactiveOptions<Value>,
-): ReactiveStore<Value> {
-	const [rx, state] = reactive<Value>(undefined as never, options);
-
-	const isArray = false;
-	const keyed = new Map<Key, [Computed<unknown>, ComputedEffect]>();
-	const readonlies: ReadonlyInstances<Value> = {};
-
-	state.value = new Proxy({} as Value, {
-		set: (target, property, value) => setValueInProxy(isArray, state, target, property, value),
-	});
-
-	const instance = {
-		...rx,
-		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
-		get: (value?: never) => getValueInProxy(isArray, instance as never, state, keyed, value),
-		notify: () => emitProxyValues(state, keyed),
-		peek: (first?: never, second?: never) => peekValueInProxy(isArray, state, first, second),
-		set: (first?: never, second?: never) =>
-			setProxyValue<Value>(isArray, state, setStoreValue, setPropertyValue, first, second),
-		subscribe: (first: never, second?: never, third?: never) =>
-			subscribeToProxy(isArray, instance as never, state, keyed, first, second, third),
-		update: (callback: never) =>
-			updateProxyValue(isArray, state, setStoreValue, setPropertyValue, callback),
-	};
-
-	Object.defineProperty(instance, NAME_MORA, {
-		value: NAME_STORE,
-	});
-
-	instance.set(value as never);
-
-	return Object.freeze(instance) as never;
+export function store(value: unknown, options?: ReactiveOptions<unknown>): ReactiveStore<unknown> {
+	// @ts-expect-error All good, no worries :-)
+	return new ReactiveStore(value, options);
 }
 
 // #endregion

package/dist/value/reactive.d.mts

@@ -1,4 +0,0 @@
-import { Reactive, ReactiveOptions, ReactiveState } from "../models.mjs";
-//#region src/value/reactive.d.ts
-export declare function reactive<Value, Item = Value>(value: Value, options?: ReactiveOptions<Item>): [Reactive<Value>, ReactiveState<Value, Item>];
-//#endregion

package/dist/value/reactive.mjs

@@ -1,15 +0,0 @@
-//#region src/value/reactive.ts
-function reactive(value, options) {
-	const state = {
-		computeds: /* @__PURE__ */ new Set(),
-		effects: /* @__PURE__ */ new Set(),
-		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : Object.is,
-		value
-	};
-	return [{
-		toJSON: () => state.value,
-		toString: () => String(state.value)
-	}, state];
-}
-//#endregion
-export { reactive };

package/src/value/reactive.ts

@@ -1,27 +0,0 @@
-import type {Reactive, ReactiveOptions, ReactiveState} from '../models';
-
-// #region Functions
-
-export function reactive<Value, Item = Value>(
-	value: Value,
-	options?: ReactiveOptions<Item>,
-): [Reactive<Value>, ReactiveState<Value, Item>] {
-	const state: ReactiveState<Value, Item> = {
-		computeds: new Set(),
-		effects: new Set(),
-		equal:
-			typeof options === 'object' && typeof options?.equal === 'function'
-				? options.equal
-				: Object.is,
-		value: value as Value,
-	};
-
-	const instance = {
-		toJSON: () => state.value,
-		toString: () => String(state.value),
-	};
-
-	return [instance, state];
-}
-
-// #endregion