@oscarpalmer/mora 0.31.0 → 0.33.0

package/dist/value/store.mjs

@@ -1,90 +1,32 @@
-import { NAME_MORA, NAME_STORE } from "../constants.mjs";
-import { startBatch, stopBatch } from "../batch.mjs";
-import { getSimpleValue } from "../helpers/value.mjs";
-import { noop, subscribe, unsubscribe } from "../subscription.mjs";
-import { reactive } from "./reactive.mjs";
-import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.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 { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlyInstance } from "./readonly.mjs";
-import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/value/store.ts
-function isStoreObject(value) {
-	return value == null || isPlainObject(value);
-}
-function setObject(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 peekStoreValue(state, first, second) {
-	let value;
-	if (isKey(first)) value = state.value[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 setProperty(state, key, value) {
-	state.value[key] = value;
-}
-function store(value, options) {
-	const [rx, state] = reactive(void 0, options);
-	const keyed = /* @__PURE__ */ new Map();
-	const readonlies = {};
-	let instance = {};
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
-		target,
-		property,
-		state,
-		value,
+function ReactiveStore(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
 		isArray: false
-	}) });
-	const handlers = {
-		...rx,
-		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
-		peek: (first, second) => peekStoreValue(state, first, second),
-		subscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		}
-	};
-	instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		notify() {
-			emityProxyValues(state, keyed);
-		},
-		set: (first, second) => {
-			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
-		},
-		update: (callback) => {
-			const updated = callback(state.value);
-			if (updated == null || isPlainObject(updated)) setObject(state, updated);
-		}
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_STORE
-	});
-	instance.set(value);
-	return Object.freeze(instance);
+	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) {
+	return new ReactiveStore(value, options);
 }
 //#endregion
 export { store };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.31.0",
+	"version": "0.33.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,17 +39,17 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.190"
+		"@oscarpalmer/atoms": "^0.202"
 	},
 	"devDependencies": {
-		"@types/node": "^26.2",
-		"@vitest/coverage-istanbul": "4.1.10",
+		"@types/node": "^26.5",
+		"@vitest/coverage-istanbul": "^4.1",
 		"jsdom": "^30",
-		"tsdown": "^0.22",
+		"tsdown": "^0.23",
 		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
 	},
-	"packageManager": "npm@11.11.1"
+	"packageManager": "npm@11.19.0"
 }

package/src/batch.ts

@@ -1,6 +1,9 @@
 import {BATCH} from './constants';
 import {runEffect} from './effect';
-import type {EffectState, Subscription} from './models';
+import {getFrozenValue, peekSignalValue} from './helpers/value';
+import type {EffectState, StoredSubscription} from './models';
+
+// #region Functions
 
 export function flushHandlers(): void {
 	if (BATCH.flushing) {
@@ -17,10 +20,15 @@ export function flushHandlers(): void {
 			BATCH.handlers.clear();
 
 			for (let index = 0; index < length; index += 1) {
-				const handler = handlers[index];
-
-				if (typeof (handler as Subscription).destroy === 'function') {
-					(handler as Subscription).callback((handler as Subscription).state.value);
+				const [, handler] = handlers[index];
+				const subscription = handler as StoredSubscription;
+
+				if (typeof subscription.frozen === 'boolean') {
+					subscription.callback(
+						subscription.frozen
+							? getFrozenValue(subscription.state.value)
+							: peekSignalValue.call(subscription.instance, subscription.copy),
+					);
 				} else {
 					runEffect(handler as EffectState);
 				}
@@ -50,3 +58,5 @@ export function stopBatch(): void {
 
 	flushHandlers();
 }
+
+// #endregion

package/src/constants.ts

@@ -1,4 +1,6 @@
-import type {Active, Batch, EffectState, Subscription} from './models';
+import type {Active, Batch, SubscriptionType} from './models';
+
+// #region Variables
 
 export const ACTIVE: Active = {};
 
@@ -11,7 +13,7 @@ export const ARRAY_PEEK = 10;
 export const BATCH: Batch = {
 	depth: 0,
 	flushing: false,
-	handlers: new Set<EffectState | Subscription>(),
+	handlers: new Map(),
 };
 
 export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);
@@ -39,6 +41,8 @@ export const NAME_SIGNAL = 'signal';
 
 export const NAME_STORE = 'store';
 
+export const NAME_SUBSCRIPTION = 'subscription';
+
 export const NAME_ALL = new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
@@ -48,3 +52,33 @@ 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,
+};
+
+export const SUBSCRIPTION_TYPE_COPY: SubscriptionType = 'copy';
+
+export const SUBSCRIPTION_TYPE_FROZEN: SubscriptionType = 'frozen';
+
+export const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType = 'original';
+
+export const SUBSCRIPTION_TYPE_READONLY: SubscriptionType = 'readonly';
+
+export const SUBSCRIPTION_TYPES_COPY = new Set<SubscriptionType>([
+	SUBSCRIPTION_TYPE_COPY,
+	SUBSCRIPTION_TYPE_READONLY,
+]);
+
+export const SUBSCRIPTION_TYPES: Set<SubscriptionType> = new Set([
+	...SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL,
+]);
+
+// #endregion

package/src/effect.ts

@@ -1,7 +1,21 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT} 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
+
 /**
  * Create an effect
  *
@@ -17,17 +31,10 @@ export function effect(callback: GenericCallback): Effect {
 }
 
 function getEffect(callback: GenericCallback): [Effect, EffectState] {
-	const state: EffectState = {
-		callback,
-	};
-
-	const instance = Object.freeze({
-		$mora: NAME_EFFECT,
-	});
+	// @ts-expect-error All good, no worries :-)
+	const instance = new Effect(callback);
 
-	runEffect(state);
-
-	return [instance, state];
+	return [instance, instance[SYMBOL_STATE]];
 }
 
 export function internalEffect(callback: GenericCallback): EffectState {
@@ -45,3 +52,5 @@ export function runEffect(state: EffectState): void {
 		ACTIVE.effect = previousEffect;
 	}
 }
+
+// #endregion

package/src/helpers/is.ts

@@ -19,13 +19,15 @@ import type {
 	Signal,
 } from '../models';
 
+// #region Functions
+
 /**
  * Is the value a computed signal?
  *
  * @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);
 }
 
@@ -56,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);
 }
 
@@ -66,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);
 }
 
@@ -76,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);
 }
 
@@ -86,12 +88,20 @@ 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);
 }
 
-export function isReadonlySignal<Value>(value: unknown): value is ReadonlySignal<Value> {
+/**
+ * Is the value a readonly signal?
+ *
+ * @param value Value to check
+ * @returns True if value is a {@link ReadonlySignal}
+ */
+export function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value> {
 	return isMora<ReadonlySignal<Value>>(value, NAME_READONLY);
 }
+
+// #endregion

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

package/src/helpers/proxy.ts

@@ -1,100 +1,164 @@
+import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
-import {PROPERTY_LENGTH} from '../constants';
+import {startBatch, stopBatch} from '../batch';
+import {PROPERTY_LENGTH, SYMBOL_STATE} from '../constants';
 import type {
 	Computed,
-	ComputedEffect,
 	ReactiveArray,
-	ReactiveState,
+	ReactiveProxyState,
 	ReactiveStore,
-	SetValueInProxyParameters,
+	InternalProxy,
 } from '../models';
 import {internalComputed} from '../value/computed';
-import {emitValue} from './value';
-
-export function emityProxyValues<Value>(
-	state: ReactiveState<Value, Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void;
-
-export function emityProxyValues<Value>(
-	state: ReactiveState<Value[], Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void;
-
-export function emityProxyValues(
-	state: ReactiveState<unknown, unknown>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void {
-	const values = [...mapped.values()];
+import {emitValue, getSignalValue, peekSignalValue} from './value';
+
+// #region Functions
+
+export function emitProxyValues(this: InternalProxy): void {
+	const state = this[SYMBOL_STATE];
+
+	state.mapped ??= new Map();
+
+	const values = [...state.mapped.values()];
 	const {length} = values;
 
 	for (let index = 0; index < length; index += 1) {
 		values[index][1].dirty = true;
 	}
 
-	emitValue(state);
+	emitValue(this);
 }
 
-export function getReactiveValueInProxy<Value, Result = Value>(
-	array: ReactiveArray<Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	index: number,
-	isArray: true,
-): Computed<Result>;
-
-export function getReactiveValueInProxy<Value extends PlainObject>(
-	store: ReactiveStore<Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	key: Key,
-	isArray: false,
-): Computed<unknown>;
-
 export function getReactiveValueInProxy(
-	reactive: ReactiveArray<unknown> | ReactiveStore<PlainObject>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
+	instance: ReactiveArray<unknown> | ReactiveStore<unknown>,
 	key: Key,
-	isArray: boolean,
 ): Computed<unknown> {
-	let item = mapped.get(key);
+	const state = (instance as unknown as InternalProxy)[SYMBOL_STATE];
+
+	state.mapped ??= new Map();
+
+	const mapKey = String(key);
+
+	let item = state.mapped.get(mapKey);
 
 	if (item == null) {
 		item = internalComputed(() =>
-			isArray
-				? (reactive.get() as unknown[]).at(key as number)
-				: (reactive.get() as PlainObject)[key],
+			state.isArray
+				? (instance.get() as unknown[]).at(key as number)
+				: (instance.get() as PlainObject)[key],
 		);
 
-		mapped.set(key, item);
+		state.mapped.set(mapKey, item);
 	}
 
 	return item[0];
 }
 
-export function setProxyValue<Value, Item = Value>(
-	array: boolean,
-	state: ReactiveState<Value, Item>,
-	isObject: (value: unknown) => value is Value | undefined,
-	isProperty: (value: unknown) => boolean,
-	setObject: (state: ReactiveState<Value, Item>, value: Value | undefined) => void,
-	setProperty: (state: ReactiveState<Value, Item>, property: unknown, value: Item) => void,
-	first?: unknown,
-	second?: unknown,
-): void {
-	if (array && first === PROPERTY_LENGTH) {
+export function getValueInProxy(this: InternalProxy, first?: unknown): unknown {
+	if (this[SYMBOL_STATE].isArray ? typeof first === 'number' : isKey(first)) {
+		return getReactiveValueInProxy(this as never, first as Key).get();
+	}
+
+	return getSignalValue.call(this);
+}
+
+function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainObject {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+
+export function peekValueInProxy(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+	const state = this[SYMBOL_STATE];
+
+	let value: unknown;
+
+	if (state.isArray ? typeof first === 'number' : isKey(first)) {
+		value = state.isArray
+			? (state.value as unknown[]).at(first as number)
+			: (state.value as PlainObject)[first as Key];
+	} else {
+		value = state.value;
+	}
+
+	return peekSignalValue.call([this, value], first === true || second === true);
+}
+
+function setProxyObject(state: ReactiveProxyState, value: unknown): void {
+	if (state.isArray) {
+		(state.value as unknown[]).splice(
+			0,
+			(state.value as unknown[]).length,
+			...((value ?? []) as unknown[]),
+		);
+
+		return;
+	}
+
+	startBatch();
+
+	const actual = (value as Record<string, unknown>) ?? {};
+	const proxy = state.value as PlainObject;
+
+	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] : undefined;
+	}
+
+	length = actualKeys.length;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = actualKeys[index];
+
+		if (!proxyKeys.includes(key)) {
+			const keyedValue = actual[key];
+
+			proxy[key] = keyedValue;
+		}
+	}
+
+	stopBatch();
+}
+
+function setProxyProperty(state: ReactiveProxyState, property: unknown, value: unknown): void {
+	if (!state.isArray) {
+		(state.value as PlainObject)[property as Key] = value;
+
+		return;
+	}
+
+	const actual =
+		(property as number) < 0
+			? (state.value as unknown[]).length + (property as number)
+			: (property as number);
+
+	if (actual > -1) {
+		(state.value as unknown[])[actual] = value;
+	}
+}
+
+export function setProxyValue(this: InternalProxy, first?: unknown, second?: unknown): void {
+	const state = this[SYMBOL_STATE] as ReactiveProxyState;
+
+	if (state.isArray && first === PROPERTY_LENGTH) {
 		(state.value as unknown[]).length = second as number;
 
 		return;
 	}
 
-	if (isObject(first)) {
-		setObject(state, first);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 
 		return;
 	}
 
-	const property = isProperty(first);
+	const property = state.isArray ? typeof first === 'number' : isKey(first);
 
-	if (array && property && Number.isNaN(first)) {
+	if (state.isArray && property && Number.isNaN(first)) {
 		return;
 	}
 
@@ -122,15 +186,15 @@ export function setProxyValue<Value, Item = Value>(
 				if (property && state.promises!.get(first as Key) === actual) {
 					state.promises!.delete(first as Key);
 
-					setProperty(state, first, value);
+					setProxyProperty(state, first, value);
 
 					return;
 				}
 
-				if (!property && isObject(value) && state.promise === actual) {
+				if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
 					state.promise = undefined;
 
-					setObject(state, value);
+					setProxyObject(state, value);
 				}
 			})
 			.catch(() => {
@@ -141,18 +205,21 @@ export function setProxyValue<Value, Item = Value>(
 				}
 			});
 	} else if (property) {
-		setProperty(state, first, actual as Item);
-	} else if (isObject(actual)) {
-		setObject(state, actual);
+		setProxyProperty(state, first, actual);
+	} else if (isProxyObject(state.isArray, actual)) {
+		setProxyObject(state, actual);
 	}
 }
 
-export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
-	parameters: SetValueInProxyParameters<Value, Equal>,
+export function setValueInProxy(
+	instance: InternalProxy,
+	target: object,
+	property: PropertyKey,
+	value: unknown,
 ): boolean {
-	const {isArray, length, property, state, target, value} = parameters;
+	const state = instance[SYMBOL_STATE];
 
-	if (isArray) {
+	if (state.isArray) {
 		const isIndex = !Number.isNaN(Number(property));
 		const isLength = property === PROPERTY_LENGTH;
 
@@ -161,17 +228,27 @@ export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
 		}
 	}
 
-	const previous = Reflect.get(target, property);
+	const previous = Reflect.get(target as object, property);
 
-	if (!state.equal(previous as never, value as never)) {
+	if (!(state.equal ?? Object.is)(previous as never, value as never)) {
 		Reflect.set(target, property, value);
 
-		emitValue(state);
+		emitValue(instance);
 
-		if (isArray) {
-			length?.set((target as unknown[]).length);
+		if (state.isArray) {
+			state.length?.set((target as unknown[]).length);
 		}
 	}
 
 	return true;
 }
+
+export function updateProxyValue(this: InternalProxy, callback: unknown): void {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Callback must be a function');
+	}
+
+	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+}
+
+// #endregion