@oscarpalmer/mora 0.31.0 → 0.32.0

package/src/value/array.ts

@@ -1,8 +1,5 @@
 import {select} from '@oscarpalmer/atoms/array';
 import {filter} from '@oscarpalmer/atoms/array/filter';
-import {noop} from '@oscarpalmer/atoms/function';
-import {isPlainObject} from '@oscarpalmer/atoms/is';
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {
 	METHODS_AFFECTING_LENGTH,
 	METHODS_UPDATE,
@@ -11,12 +8,15 @@ import {
 	PROPERTY_LENGTH,
 } from '../constants';
 import {
-	emityProxyValues,
-	getReactiveValueInProxy,
+	emitProxyValues,
+	getValueInProxy,
+	peekValueInProxy,
 	setProxyValue,
 	setValueInProxy,
+	updateProxyValue,
 } from '../helpers/proxy';
-import {emitValue, equalArrays, getSimpleValue} from '../helpers/value';
+import {subscribeToProxy} from '../helpers/subscription';
+import {emitValue, equalArrays} from '../helpers/value';
 import type {
 	Computed,
 	ComputedEffect,
@@ -26,12 +26,13 @@ import type {
 	ReadonlyInstances,
 	Signal,
 } from '../models';
-import {subscribe, unsubscribe} from '../subscription';
 import {computed} from './computed';
 import {reactive} from './reactive';
 import {getReadonlyInstance} from './readonly';
 import {signal} from './signal';
 
+// #region Functions
+
 /**
  * Create a reactive array from a function result
  *
@@ -71,26 +72,18 @@ export function array<Item>(
 ): ReactiveArray<Item> {
 	const [rx, state] = reactive<Item[], Item>([], options);
 
-	const indiced = new Map<number, [Computed<unknown>, ComputedEffect]>();
+	const isArray = true;
 	const length = signal(0);
+	const mapped = new Map<number, [Computed<unknown>, ComputedEffect]>();
 	const readonlies: ReadonlyInstances<Item[]> = {};
 
-	let instance: Record<string, unknown> = {};
-
 	state.value = new Proxy([], {
 		get: (target: Item[], property: PropertyKey) =>
 			METHODS_UPDATE.has(property as string)
 				? updateArray(property as string, target, state, length)
 				: Reflect.get(target, property),
 		set: (target: Item[], property: PropertyKey, value: Item) =>
-			setValueInProxy({
-				length,
-				property,
-				state,
-				target,
-				value,
-				isArray: true,
-			}),
+			setValueInProxy(isArray, state, target, property, value, length),
 	});
 
 	function get(): Item[];
@@ -98,85 +91,43 @@ export function array<Item>(
 	function get(property: typeof PROPERTY_LENGTH): number;
 	function get(value?: unknown): number | Item | Item[] | undefined;
 
-	function get(value?: unknown): number | Item | Item[] | undefined {
-		return getArrayValue(instance as ReactiveArray<Item>, indiced, state, length, value);
+	function get(value?: unknown): unknown {
+		return value === PROPERTY_LENGTH
+			? length.get()
+			: getValueInProxy(isArray, instance as never, state, mapped, value);
 	}
 
-	function set(first?: unknown, second?: unknown): void {
-		setProxyValue<Item[], Item>(
-			true,
-			state,
-			isArrayValue,
-			isArrayIndex,
-			setArray,
-			setAtIndex,
-			first,
-			second,
-		);
+	function set(first?: never, second?: never): void {
+		setProxyValue<Item[], Item>(true, state, setArrayValue, setAtIndex, first, second);
 	}
 
-	const handlers = {
+	const instance = {
 		...rx,
-		get: (value?: number | typeof PROPERTY_LENGTH) => get(value),
-		peek: (first?: unknown, second?: boolean) => peekArrayValue(state, length, first, second),
-		subscribe: (first: number | GenericCallback, second?: GenericCallback) => {
-			if (typeof first === 'number' && typeof second === 'function') {
-				return getReactiveValueInProxy(
-					instance as ReactiveArray<Item>,
-					indiced,
-					first,
-					true,
-				).subscribe(second);
-			}
-
-			return typeof first === 'function' ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first: number | GenericCallback, second?: GenericCallback) => {
-			if (typeof first === 'number' && typeof second === 'function') {
-				getReactiveValueInProxy(instance as ReactiveArray<Item>, indiced, first, true)?.unsubscribe(
-					second,
-				);
-			} else if (typeof first === 'function') {
-				unsubscribe(state, first);
-			}
-		},
-	};
-
-	instance = {
-		...handlers,
-		asReadonly: (frozen?: unknown) =>
-			getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		at: (index: number): Item | undefined => get(index),
+		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
+		at: (index: never) => get(index),
 		clear: () => {
 			state.value.length = 0;
 		},
-		filter: (callback: (item: Item, index: number, array: Item[]) => boolean) =>
-			computed(() => filter(get(), callback)),
-		map: <Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped) =>
-			computed(() => get().map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
+		filter: (callback: never) => computed(() => filter(get(), callback)),
+		get: (value?: never) => get(value),
+		map: (callback: never) => computed(() => get().map(callback)),
+		notify: () => emitProxyValues(state, mapped),
+		peek: (first?: never, second?: never) => peekArrayValue(state, length, first, second),
 		pop: () => state.value.pop(),
 		push: (...items: Item[]) => state.value.push(...items),
-		select: <Mapped>(
-			filter: (item: Item, index: number, array: Item[]) => boolean,
-			map: (item: Item, index: number, array: Item[]) => Mapped,
-		) => computed(() => select(get() as Item[], filter, map)),
-		set: (first?: unknown, second?: unknown) => {
-			set(first, second);
-		},
+		select: (filter: never, map: never) => computed(() => select(get(), filter, map)),
+		set: (first?: never, second?: never) => set(first, second),
 		shift: () => state.value.shift(),
-		splice: (from: number, to?: number, ...items: Item[]) =>
+		splice: (from: never, to?: never, ...items: Item[]) =>
 			state.value.splice(from, to ?? state.value.length, ...items),
+		subscribe: (first: never, second?: never, third?: never) =>
+			subscribeToProxy(isArray, instance as never, state, mapped, first, second, third),
 		unshift: (...items: Item[]) => state.value.unshift(...items),
-		update: (callback: (value: Item[]) => Item[]) =>
-			updateArrayValue(instance as ReactiveArray<Item>, state, callback),
+		update: (callback: never) => updateProxyValue(true, state, setArrayValue, setAtIndex, callback),
 	};
 
 	Object.defineProperties(instance, {
 		[NAME_MORA]: {
-			enumerable: false,
 			value: NAME_ARRAY,
 		},
 		length: {
@@ -186,31 +137,9 @@ export function array<Item>(
 		},
 	});
 
-	set(value);
+	set(value as never);
 
-	return Object.freeze(instance) as ReactiveArray<Item>;
-}
-
-function getArrayValue<Item>(
-	instance: ReactiveArray<Item>,
-	indiced: Map<number, [Computed<unknown>, ComputedEffect]>,
-	state: ReactiveState<Item[], Item>,
-	length: Signal<number>,
-	first?: unknown,
-): number | Item | Item[] | undefined {
-	if (typeof first === 'number') {
-		return getReactiveValueInProxy(instance, indiced, first, true).get();
-	}
-
-	return first === PROPERTY_LENGTH ? length.get() : getSimpleValue(state);
-}
-
-function isArrayIndex(value: unknown): boolean {
-	return typeof value === 'number';
-}
-
-function isArrayValue<Item>(value: unknown): value is Item[] | undefined {
-	return value == null || Array.isArray(value);
+	return Object.freeze(instance) as never;
 }
 
 function peekArrayValue<Item>(
@@ -218,49 +147,41 @@ function peekArrayValue<Item>(
 	length: Signal<number>,
 	first?: unknown,
 	second?: boolean,
-): number | Item | Item[] | undefined {
-	if (first === PROPERTY_LENGTH) {
-		return length.peek();
-	}
-
-	let value: Item | Item[] | undefined;
-
-	if (typeof first === 'number') {
-		value = state.value.at(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 setArray<Item>(state: ReactiveState<Item[], Item>, value: Item[] | undefined): void {
-	state.value.splice(0, state.value.length, ...(value ?? []));
+): unknown {
+	return first === PROPERTY_LENGTH ? length.peek() : peekValueInProxy(true, state, first, second);
 }
 
 function setArrayLength<Item>(state: ReactiveState<Item[], Item>, value: number): void {
-	if (typeof value === 'number' && value >= 0 && value !== state.value.length) {
+	if (
+		typeof value === 'number' &&
+		!Number.isNaN(value) &&
+		value >= 0 &&
+		value !== state.value.length
+	) {
 		state.value.length = value;
 	}
 }
 
-function setAtIndex<Item>(state: ReactiveState<Item[], Item>, index: unknown, value: Item): void {
-	const actual = (index as number) < 0 ? state.value.length + (index as number) : (index as number);
+function setArrayValue<Value, Item = Value>(state: ReactiveState<Value, Item>, value: Value): void {
+	(state.value as unknown[]).splice(
+		0,
+		(state.value as unknown[]).length,
+		...((value as unknown[]) ?? []),
+	);
+}
+
+function setAtIndex<Value, Item = Value>(
+	state: ReactiveState<Value, Item>,
+	index: unknown,
+	value: Item,
+): void {
+	const actual =
+		(index as number) < 0
+			? (state.value as unknown[]).length + (index as number)
+			: (index as number);
 
 	if (actual > -1) {
-		state.value[actual] = value;
+		(state.value as unknown[])[actual] = value;
 	}
 }
 
@@ -274,7 +195,7 @@ function updateArray<Item>(
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
 
-	return (...args: unknown[]): unknown => {
+	return (...args: unknown[]) => {
 		const result = (array[type as never] as (...args: unknown[]) => unknown)(...args);
 
 		if (
@@ -289,14 +210,4 @@ function updateArray<Item>(
 	};
 }
 
-function updateArrayValue<Item>(
-	instance: ReactiveArray<Item>,
-	state: ReactiveState<Item[], Item>,
-	callback: (value: Item[]) => Item[],
-): void {
-	const updated = callback(state.value);
-
-	if (updated == null || Array.isArray(updated)) {
-		instance.set(updated);
-	}
-}
+// #endregion

package/src/value/computed.ts

@@ -1,11 +1,21 @@
 import {flushHandlers} from '../batch';
-import {ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA} from '../constants';
+import {
+	ACTIVE,
+	BATCH,
+	NAME_COMPUTED,
+	NAME_MORA,
+	SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPES,
+} from '../constants';
 import {internalEffect, runEffect} from '../effect';
-import {handleSimpleValue} from '../helpers/value';
+import {subscribeToSignal} from '../helpers/subscription';
+import {handleSimpleValue, peekSimpleValue} from '../helpers/value';
 import type {Computed, ComputedEffect, ReactiveOptions, ReactiveState} from '../models';
-import {subscribe} from '../subscription';
 import {reactive} from './reactive';
 
+// #region Functions
+
 /**
  * Create a computed value
  *
@@ -24,6 +34,10 @@ function getComputed<Value>(
 	callback: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): [Computed<Value>, ComputedEffect] {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Computed callback must be a function');
+	}
+
 	const [rx, state] = reactive<Value>(undefined as never, options);
 
 	let fx: ComputedEffect;
@@ -31,21 +45,17 @@ function getComputed<Value>(
 	const instance = {
 		...rx,
 		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback: (value: Value) => void) => subscribe(state, callback),
-		unsubscribe: (callback: (value: Value) => void) => {
-			state.subscriptions.delete(callback);
-		},
+		peek: (copy?: never) => peekSimpleValue(state.value, copy === true),
+		subscribe: (callback: never, copy?: never) => subscribeToSignal(state, callback, copy === true),
 	};
 
 	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
 		value: NAME_COMPUTED,
 	});
 
 	fx = getComputedEffect(state, callback);
 
-	return [Object.freeze(instance), fx];
+	return [Object.freeze(instance) as never, fx];
 }
 
 function getComputedEffect<Value>(
@@ -109,12 +119,25 @@ function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): vo
 	}
 
 	for (const effect of state.effects) {
-		BATCH.handlers.add(effect);
+		BATCH.handlers.set(effect, effect);
 	}
 
-	for (const [, subscription] of state.subscriptions) {
-		subscription.callback(value);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === SUBSCRIPTION_TYPE_FROZEN) {
+			continue;
+		}
+
+		const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+
+		if (subscriptions != null) {
+			for (const [, callback] of subscriptions) {
+				callback(peekSimpleValue(state.value, copy));
+			}
+		}
 	}
 
 	flushHandlers();
 }
+
+// #endregion

package/src/value/reactive.ts

@@ -1,17 +1,18 @@
 import type {Reactive, ReactiveOptions, ReactiveState} from '../models';
 
-export function reactive<Value, Equal = Value>(
+// #region Functions
+
+export function reactive<Value, Item = Value>(
 	value: Value,
-	options?: ReactiveOptions<Equal>,
-): [Reactive<Value>, ReactiveState<Value, Equal>] {
-	const state: ReactiveState<Value, Equal> = {
+	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,
-		subscriptions: new Map(),
 		value: value as Value,
 	};
 
@@ -22,3 +23,5 @@ export function reactive<Value, Equal = Value>(
 
 	return [instance, state];
 }
+
+// #endregion

package/src/value/readonly.ts

@@ -1,42 +1,46 @@
-import {isPlainObject} from '@oscarpalmer/atoms/is';
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {NAME_MORA, NAME_READONLY} from '../constants';
-import {getSimpleValue} from '../helpers/value';
+import {
+	NAME_MORA,
+	NAME_READONLY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_READONLY,
+} from '../constants';
+import {subscribeToReactive} from '../helpers/subscription';
+import {getFrozenValue, getSimpleValue, peekSimpleValue} from '../helpers/value';
 import type {
 	ReactiveState,
 	ReadonlyFrozenSignal,
 	ReadonlyInstances,
 	ReadonlySignal,
-	ReadonlySignalValue,
 } from '../models';
 
+// #region Functions
+
 export function getReadonlyInstance<Value>(
 	state: ReactiveState<Value, never>,
 	instances: ReadonlyInstances<Value>,
-	handlers: Record<string, GenericCallback>,
 	frozen: boolean,
 ): ReadonlySignal<Value> {
 	const key = frozen ? 'frozen' : 'original';
 
-	instances[key] ??= getReadonlySignal(state, handlers, frozen) as never;
+	instances[key] ??= getReadonlySignal(state, frozen) as never;
 
-	return instances[key] as ReadonlySignal<Value>;
+	return instances[key] as never;
 }
 
 export function getReadonlySignal<Value>(
 	state: ReactiveState<Value, never>,
-	handlers: Record<string, GenericCallback>,
 	frozen: boolean,
 ): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value> {
+	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
+
 	const instance = {
-		...handlers,
 		get: () => getReadonlyValue(state, false, frozen),
-		peek: () => getReadonlyValue(state, true, frozen),
+		peek: (copy?: boolean) => getReadonlyValue(state, true, frozen, copy),
+		subscribe: (callback: never) => subscribeToReactive(type, state, callback),
 	};
 
 	Object.defineProperties(instance, {
 		[NAME_MORA]: {
-			enumerable: false,
 			value: NAME_READONLY,
 		},
 		frozen: {
@@ -45,27 +49,24 @@ export function getReadonlySignal<Value>(
 		},
 	});
 
-	return Object.freeze(instance) as ReadonlySignal<Value>;
+	return Object.freeze(instance) as never;
 }
 
 function getReadonlyValue<Value>(
 	state: ReactiveState<Value, never>,
 	peek: boolean,
 	frozen: boolean,
-): Value | ReadonlySignalValue<Value> {
-	let value = peek ? state.value : getSimpleValue(state);
+	copy?: boolean,
+): unknown {
+	let value: unknown;
 
-	if (!frozen) {
-		return value;
-	}
-
-	if (Array.isArray(state.value)) {
-		value = [...state.value] as Value;
-	} else if (isPlainObject(state.value)) {
-		value = {...state.value} as Value;
+	if (peek) {
+		value = peekSimpleValue(state.value, copy === true);
 	} else {
-		value = state.value;
+		value = getSimpleValue(state);
 	}
 
-	return Object.freeze(value);
+	return frozen ? getFrozenValue(value) : value;
 }
+
+// #endregion

package/src/value/signal.ts

@@ -1,10 +1,18 @@
 import {NAME_MORA, NAME_SIGNAL} from '../constants';
-import {emitValue, getSimpleValue, handleSimpleValue} from '../helpers/value';
+import {subscribeToSignal} from '../helpers/subscription';
+import {
+	emitValue,
+	getSimpleValue,
+	handleSimpleValue,
+	peekSimpleValue,
+	updateSimpleValue,
+} from '../helpers/value';
 import type {ReactiveOptions, ReactiveState, ReadonlyInstances, Signal} from '../models';
-import {subscribe} from '../subscription';
 import {reactive} from './reactive';
 import {getReadonlyInstance} from './readonly';
 
+// #region Functions
+
 function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): void {
 	if (!state.equal(state.value, value)) {
 		state.value = value;
@@ -54,34 +62,23 @@ export function signal<Value>(
 
 	const readonlies: ReadonlyInstances<Value> = {};
 
-	const handlers = {
-		...rx,
-		subscribe: (callback: (value: Value) => void) => subscribe(state, callback),
-		unsubscribe: (callback: (value: Value) => void) => {
-			state.subscriptions.delete(callback);
-		},
-	};
-
 	const instance = {
-		...handlers,
-		asReadonly: (frozen?: unknown) =>
-			getReadonlyInstance(state, readonlies, handlers, frozen === true),
+		...rx,
+		asReadonly: (frozen?: never) => getReadonlyInstance(state, readonlies, frozen === true),
 		get: () => getSimpleValue(state),
-		peek: () => state.value,
-		set: (value: Value | (() => Value | Promise<Value>) | Promise<Value>) => {
-			handleSimpleValue(state, value, setAndEmit);
-		},
-		update: (callback: (value: Value) => Value) => {
-			handleSimpleValue(state, callback(state.value), setAndEmit);
-		},
+		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, {
-		enumerable: false,
 		value: NAME_SIGNAL,
 	});
 
 	handleSimpleValue(state, value, setAndEmit);
 
-	return Object.freeze(instance) as Signal<Value>;
+	return Object.freeze(instance) as never;
 }
+
+// #endregion