@oscarpalmer/mora 0.32.0 → 0.33.0

package/src/helpers/proxy.ts

@@ -1,131 +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,
-	Signal,
+	InternalProxy,
 } from '../models';
 import {internalComputed} from '../value/computed';
-import {emitValue, getSimpleValue, peekSimpleValue} from './value';
+import {emitValue, getSignalValue, peekSignalValue} from './value';
 
-// #region Types
-
-type SetObjectCallback<Value, Item> = (
-	state: ReactiveState<Value, Item>,
-	value: Value | undefined,
-) => void;
+// #region Functions
 
-type SetPropertyCallback<Value, Item> = (
-	state: ReactiveState<Value, Item>,
-	property: unknown,
-	value: Item,
-) => void;
+export function emitProxyValues(this: InternalProxy): void {
+	const state = this[SYMBOL_STATE];
 
-// #endregion
-
-// #region Functions
+	state.mapped ??= new Map();
 
-export function emitProxyValues<Value, Item = Value>(
-	state: ReactiveState<Value, Item>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-): void {
-	const values = [...mapped.values()];
+	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>(
-	reactive: ReactiveArray<Value> | ReactiveStore<Value>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
+export function getReactiveValueInProxy(
+	instance: ReactiveArray<unknown> | ReactiveStore<unknown>,
 	key: Key,
-	isArray: boolean,
 ): Computed<unknown> {
+	const state = (instance as unknown as InternalProxy)[SYMBOL_STATE];
+
+	state.mapped ??= new Map();
+
 	const mapKey = String(key);
 
-	let item = mapped.get(mapKey);
+	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(mapKey, item);
+		state.mapped.set(mapKey, item);
 	}
 
 	return item[0];
 }
 
-export function getValueInProxy<Value, Item = Value>(
-	isArray: boolean,
-	instance: ReactiveArray<Value> | ReactiveStore<Value>,
-	state: ReactiveState<Value, Item>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	first?: unknown,
-): unknown {
-	if (isArray ? typeof first === 'number' : isKey(first)) {
-		return getReactiveValueInProxy(instance, mapped, first as Key, isArray).get();
+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 getSimpleValue(state);
+	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<Value, Item = Value>(
-	isArray: boolean,
-	state: ReactiveState<Value, Item>,
-	first?: unknown,
-	second?: boolean,
-): unknown {
+export function peekValueInProxy(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+	const state = this[SYMBOL_STATE];
+
 	let value: unknown;
 
-	if (isArray ? typeof first === 'number' : isKey(first)) {
-		value = isArray
+	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 peekSimpleValue(value, first === true || second === true);
+	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();
 }
 
-export function setProxyValue<Value, Item = Value>(
-	isArray: boolean,
-	state: ReactiveState<Value, Item>,
-	setObject: SetObjectCallback<Value, Item>,
-	setProperty: SetPropertyCallback<Value, Item>,
-	first?: unknown,
-	second?: unknown,
-): void {
-	if (isArray && first === PROPERTY_LENGTH) {
+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 (isProxyObject(isArray, first)) {
-		setObject(state, first as Value);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 
 		return;
 	}
 
-	const property = isArray ? typeof first === 'number' : isKey(first);
+	const property = state.isArray ? typeof first === 'number' : isKey(first);
 
-	if (isArray && property && Number.isNaN(first)) {
+	if (state.isArray && property && Number.isNaN(first)) {
 		return;
 	}
 
@@ -153,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 && isProxyObject(isArray, value) && state.promise === actual) {
+				if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
 					state.promise = undefined;
 
-					setObject(state, value as Value);
+					setProxyObject(state, value);
 				}
 			})
 			.catch(() => {
@@ -172,21 +205,21 @@ export function setProxyValue<Value, Item = Value>(
 				}
 			});
 	} else if (property) {
-		setProperty(state, first, actual as Item);
-	} else if (isProxyObject(isArray, actual)) {
-		setObject(state, actual as Value);
+		setProxyProperty(state, first, actual);
+	} else if (isProxyObject(state.isArray, actual)) {
+		setProxyObject(state, actual);
 	}
 }
 
-export function setValueInProxy<Value, Item = Value>(
-	isArray: boolean,
-	state: ReactiveState<Value, Item>,
+export function setValueInProxy(
+	instance: InternalProxy,
 	target: object,
 	property: PropertyKey,
 	value: unknown,
-	length?: Signal<number>,
 ): boolean {
-	if (isArray) {
+	const state = instance[SYMBOL_STATE];
+
+	if (state.isArray) {
 		const isIndex = !Number.isNaN(Number(property));
 		const isLength = property === PROPERTY_LENGTH;
 
@@ -197,31 +230,25 @@ export function setValueInProxy<Value, Item = Value>(
 
 	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<Value, Item = Value>(
-	isArray: boolean,
-	state: ReactiveState<Value, Item>,
-	setObject: SetObjectCallback<Value, Item>,
-	setProperty: SetPropertyCallback<Value, Item>,
-	callback: unknown,
-): void {
+export function updateProxyValue(this: InternalProxy, callback: unknown): void {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Callback must be a function');
 	}
 
-	setProxyValue(isArray, state, setObject, setProperty, callback(state.value));
+	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
 }
 
 // #endregion

package/src/helpers/subscription.ts

@@ -6,73 +6,84 @@ import {
 	SUBSCRIPTION_TYPE_COPY,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPE_ORIGINAL,
+	SUBSCRIPTION_TYPE_READONLY,
 	SUBSCRIPTION_TYPES,
 	SUBSCRIPTION_TYPES_COPY,
+	SYMBOL_STATE,
 } from '../constants';
 import type {
-	Computed,
-	ComputedEffect,
-	ReactiveArray,
-	ReactiveState,
-	ReactiveStore,
+	InternalProxy,
+	InternalReadonly,
+	InternalSignal,
+	Subscriber,
 	SubscriptionType,
 } from '../models';
 import {getReactiveValueInProxy} from './proxy';
-import {getFrozenValue, peekSimpleValue} from './value';
+import {getFrozenValue, peekSignalValue} from './value';
 
-export function subscribeToProxy<Value, Item = Value>(
-	isArray: boolean,
-	instance: ReactiveArray<Value> | ReactiveStore<Value>,
-	state: ReactiveState<Value, Item>,
-	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
-	first: Key | ((value: unknown) => unknown),
-	second?: ((value: unknown) => unknown) | boolean,
+// #region Functions
+
+export function subscribeToProxy(
+	this: InternalProxy,
+	first: Key | Subscriber<unknown>,
+	second?: Subscriber<unknown> | boolean,
 	third?: boolean,
 ): Subscription {
 	if (isKey(first)) {
-		return getReactiveValueInProxy(instance as never, mapped, first, isArray).subscribe(
-			second as never,
-			third as never,
-		);
+		return getReactiveValueInProxy(this as never, first).subscribe(second as never, third as never);
 	}
 
-	return subscribeToSignal(state, first, second === true);
+	return subscribeToSignal.call(this, first, second);
 }
 
-export function subscribeToReactive<Value, Item = Value>(
+function subscribeToReactive(
+	this: InternalSignal,
 	type: SubscriptionType,
-	state: ReactiveState<Value, Item>,
-	callback: (value: unknown) => unknown,
+	subscriber: Subscriber<unknown>,
 ): Subscription {
-	state.subscriptions ??= subscriptions({
+	this[SYMBOL_STATE].subscriptions ??= subscriptions({
 		keys: SUBSCRIPTION_TYPES,
 		property: SUBSCRIPTION_PROPERTY,
 	});
 
-	const [subscription, existing] = state.subscriptions.create({
+	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
 		key: type,
-		value: callback,
+		value: subscriber,
 	});
 
 	if (!existing) {
-		callback(
+		subscriber(
 			type === SUBSCRIPTION_TYPE_FROZEN
-				? getFrozenValue(state.value)
-				: peekSimpleValue(state.value, SUBSCRIPTION_TYPES_COPY.has(type)),
+				? getFrozenValue(this[SYMBOL_STATE].value)
+				: peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)),
+			subscription,
 		);
 	}
 
 	return subscription;
 }
 
-export function subscribeToSignal<Value, Item = Value>(
-	state: ReactiveState<Value, Item>,
-	callback: (value: unknown) => unknown,
-	copy: boolean,
+export function subscribeToReadonly(
+	this: InternalReadonly,
+	subscriber: Subscriber<unknown>,
 ): Subscription {
-	return subscribeToReactive(
-		copy ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL,
-		state,
-		callback,
+	return subscribeToReactive.call(
+		this,
+		this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY,
+		subscriber,
 	);
 }
+
+export function subscribeToSignal(
+	this: InternalSignal,
+	subscriber: Subscriber<unknown>,
+	copy?: unknown,
+): Subscription {
+	return subscribeToReactive.call(
+		this,
+		copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL,
+		subscriber,
+	);
+}
+
+// #endregion

package/src/helpers/value.ts

@@ -9,27 +9,35 @@ import {
 	SUBSCRIPTION_TYPES_COPY,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPES,
+	SYMBOL_STATE,
 } from '../constants';
-import type {ReactiveState} from '../models';
+import type {ReactiveState, InternalSignal} from '../models';
 
 // #region Functions
 
-export function emitValue<Value>(state: ReactiveState<Value, never>): void {
-	for (const computed of state.computeds) {
-		computed.dirty = true;
+export function emitValue(instance: InternalSignal): void {
+	const state = instance[SYMBOL_STATE];
+
+	if (state.computeds != null && state.computeds.size > 0) {
+		for (const computed of state.computeds) {
+			computed.dirty = true;
+		}
 	}
 
-	for (const effect of state.effects) {
-		BATCH.handlers.set(effect, effect);
+	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) {
 		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
 
-		if (subscriptions != null) {
+		if (subscriptions != null && subscriptions.size > 0) {
 			for (const [subscription, callback] of subscriptions) {
 				BATCH.handlers.set(subscription, {
 					callback,
+					instance,
 					state,
 					frozen: type === SUBSCRIPTION_TYPE_FROZEN,
 					copy: SUBSCRIPTION_TYPES_COPY.has(type),
@@ -43,17 +51,15 @@ export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	}
 }
 
-export function equalArrays<Value>(
-	state: ReactiveState<Value[], Value>,
-	first: Value[],
-	second: Value[],
-): boolean {
-	let {length} = first;
+export function equalArrays(state: ReactiveState, first: unknown[], second: unknown[]): boolean {
+	const {length} = first;
 
 	if (length !== second.length) {
 		return false;
 	}
 
+	const eq = state.equal ?? Object.is;
+
 	let offset = 0;
 
 	if (length >= ARRAY_THRESHOLD) {
@@ -61,16 +67,21 @@ export function equalArrays<Value>(
 		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {
-			if (!state.equal(first[index], second[index])) {
+			if (
+				!(
+					eq(first[index], second[index]) &&
+					eq(first[length - index - 1], second[length - index - 1])
+				)
+			) {
 				return false;
 			}
 		}
 	}
 
-	length -= offset;
+	const end = length - offset;
 
-	for (let index = offset; index < length; index += 1) {
-		if (!state.equal(first[index], second[index])) {
+	for (let index = offset; index < end; index += 1) {
+		if (!eq(first[index], second[index])) {
 			return false;
 		}
 	}
@@ -90,24 +101,36 @@ export function getFrozenValue(value: unknown): unknown {
 	return frozen;
 }
 
-export function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value {
+export function getSignalValue(this: InternalSignal): unknown {
 	if (ACTIVE.computed != null) {
-		state.computeds.add(ACTIVE.computed);
+		this[SYMBOL_STATE].computeds ??= new Set();
+
+		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
 	}
 
 	if (ACTIVE.effect != null) {
-		state.effects.add(ACTIVE.effect);
+		this[SYMBOL_STATE].effects ??= new Set();
+
+		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
 	}
 
-	return state.value;
+	return this[SYMBOL_STATE].value;
+}
+
+export function getStringValue(this: InternalSignal, json?: boolean): string {
+	return json === true
+		? JSON.stringify(this[SYMBOL_STATE].value)
+		: String(this[SYMBOL_STATE].value);
 }
 
-export function handleSimpleValue<Value>(
-	state: ReactiveState<Value, Value>,
-	origin: Value | (() => Value | Promise<Value>) | Promise<Value>,
-	setValue: (state: ReactiveState<Value, Value>, value: Value) => void,
+export function handleSignalValue(
+	instance: InternalSignal,
+	origin: unknown,
+	setValue: (instance: InternalSignal, value: unknown) => void,
 	onAfter?: () => void,
 ): void {
+	const state = instance[SYMBOL_STATE];
+
 	try {
 		let actual = typeof origin === 'function' ? (origin as () => unknown)() : origin;
 
@@ -119,7 +142,7 @@ export function handleSimpleValue<Value>(
 					if (actual === state.promise) {
 						state.promise = undefined;
 
-						setValue(state, value);
+						setValue(instance, value);
 					}
 				})
 				.catch(() => {
@@ -128,7 +151,7 @@ export function handleSimpleValue<Value>(
 					}
 				});
 		} else {
-			setValue(state, actual as Value);
+			setValue(instance, actual);
 		}
 	} catch {
 		// ?
@@ -137,10 +160,13 @@ export function handleSimpleValue<Value>(
 	}
 }
 
-export function peekSimpleValue(value: unknown, copy: boolean): unknown {
-	let peeked: unknown = value;
+export function peekSignalValue(
+	this: InternalSignal | [InternalSignal, unknown],
+	copy?: boolean,
+): unknown {
+	let peeked: unknown = Array.isArray(this) ? this[1] : this[SYMBOL_STATE].value;
 
-	if (!copy) {
+	if (copy !== true) {
 		return peeked;
 	}
 
@@ -153,16 +179,16 @@ export function peekSimpleValue(value: unknown, copy: boolean): unknown {
 	return peeked;
 }
 
-export function updateSimpleValue<Value>(
-	state: ReactiveState<Value, Value>,
-	callback: (value: Value) => Value,
-	setValue: (state: ReactiveState<Value, Value>, value: Value) => void,
+export function updateSignalValue(
+	instance: InternalSignal,
+	callback: (value: unknown) => unknown,
+	setValue: (instance: InternalSignal, value: unknown) => void,
 ): void {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Callback must be a function');
 	}
 
-	handleSimpleValue(state, callback(state.value), setValue);
+	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 
 // #endregion