@oscarpalmer/mora 0.30.0 → 0.32.0

package/src/models.ts

@@ -1,6 +1,9 @@
-import type {GenericCallback, Key} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {Subscription, Subscriptions} from '@oscarpalmer/atoms/subscription';
 import type {PROPERTY_LENGTH} from './constants';
 
+// #region Types
+
 export type Active = {
 	computed?: ComputedEffect;
 	effect?: EffectState;
@@ -9,7 +12,7 @@ export type Active = {
 export type Batch = {
 	depth: number;
 	flushing: boolean;
-	handlers: Set<EffectState | Subscription>;
+	handlers: Map<EffectState | Subscription, EffectState | StoredSubscription>;
 };
 
 export type Computed<Value> = Reactive<Value> & SimpleReactive<Value>;
@@ -52,6 +55,24 @@ export type ReactiveArray<Item> = {
 	 */
 	set length(value: number);
 
+	/**
+	 * Get a readonly version of the reactive array
+	 *
+	 * @param frozen Freeze the array? _(defaults to `false`)_
+	 * @returns Readonly reactive array
+	 */
+	asReadonly(frozen: true): ReadonlyFrozenSignal<Item[]>;
+
+	/**
+	 * Get a readonly version of the reactive array
+	 *
+	 * @param frozen Freeze the array? _(defaults to `false`)_
+	 * @returns Readonly reactive array
+	 */
+	asReadonly(
+		frozen?: boolean,
+	): typeof frozen extends true ? ReadonlyFrozenSignal<Item[]> : ReadonlySignal<Item[]>;
+
 	/**
 	 * Get the value at an index
 	 *
@@ -114,17 +135,19 @@ export type ReactiveArray<Item> = {
 	/**
 	 * Get the array _(without reactivity)_
 	 *
+	 * @param copy Copy the array? _(defaults to `false`)_
 	 * @returns Array of items
 	 */
-	peek(): Item[];
+	peek(copy?: boolean): Item[];
 
 	/**
 	 * Get the value at an index _(without reactivity)_
 	 *
 	 * @param index Index of item to get _(if negative, starts from the end)_
+	 * @param copy If the item is an array or record, should it be copied? _(defaults to `false`)_
 	 * @returns Item at index, or `undefined` if it doesn't exist
 	 */
-	peek(index: number): Item | undefined;
+	peek(index: number, copy?: boolean): Item | undefined;
 
 	/**
 	 * Get the length of the array _(without reactivity)_
@@ -208,18 +231,24 @@ export type ReactiveArray<Item> = {
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy Copy the array? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	subscribe(callback: (value: Item[]) => void, copy?: boolean): Subscription;
 
 	/**
 	 * Subscribe to changes at a specific index
 	 *
 	 * @param index Index of item to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the item is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
+	subscribe(
+		index: number,
+		callback: (value: Item | undefined) => void,
+		copy?: boolean,
+	): Subscription;
 
 	/**
 	 * Add items to the beginning of the array
@@ -228,21 +257,6 @@ export type ReactiveArray<Item> = {
 	 */
 	unshift(...items: Item[]): number;
 
-	/**
-	 * Unsubscribe from changes for a specific index
-	 *
-	 * @param index Index of the value to unsubscribe from
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(index: number, callback: (item: Item | undefined) => void): void;
-
-	/**
-	 * Unsubscribe from changes
-	 *
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(callback: (array: Item[]) => void): void;
-
 	/**
 	 * Update the value _(based on the current value)_
 	 *
@@ -262,23 +276,41 @@ export type ReactiveOptions<Value> = {
 	equal?: (first: Value, second: Value) => boolean;
 };
 
-export type ReactiveState<Value, Equal> = {
+export type ReactiveState<Value, Item = Value> = {
 	computeds: Set<ComputedEffect>;
 	effects: Set<EffectState>;
-	equal: (first: Equal, second: Equal) => boolean;
+	equal: (first: Item, second: Item) => boolean;
 	promise?: Promise<Value>;
 	promises?: Map<Key, Promise<never>>;
-	subscriptions: Map<GenericCallback, Subscription>;
+	subscriptions?: Subscriptions<GenericCallback>;
 	value: Value;
 };
 
-export type ReactiveStore<Value> = {
+export type ReactiveStore<Store> = {
+	/**
+	 * Get a readonly version of the reactive store
+	 *
+	 * @param frozen Freeze the store? _(defaults to `false`)_
+	 * @returns Readonly reactive store
+	 */
+	asReadonly(frozen: true): ReadonlyFrozenSignal<Store>;
+
+	/**
+	 * Get a readonly version of the reactive store
+	 *
+	 * @param frozen Freeze the store? _(defaults to `false`)_
+	 * @returns Readonly reactive store
+	 */
+	asReadonly(
+		frozen?: boolean,
+	): typeof frozen extends true ? ReadonlyFrozenSignal<Store> : ReadonlySignal<Store>;
+
 	/**
 	 * Get the value
 	 *
 	 * @returns Current value
 	 */
-	get(): Value;
+	get(): Store;
 
 	/**
 	 * Get a value by key
@@ -286,7 +318,7 @@ export type ReactiveStore<Value> = {
 	 * @param key Key of the value to get
 	 * @returns Value for the specified key, or `undefined` if it doesn't exist
 	 */
-	get<Key extends keyof Value>(key: Key): Value[Key];
+	get<Key extends keyof Store>(key: Key): Store[Key];
 
 	/**
 	 * Get a value by key
@@ -307,25 +339,28 @@ export type ReactiveStore<Value> = {
 	/**
 	 * Get the value _(without reactivity)_
 	 *
+	 * @param copy Copy the store? _(defaults to `false`)_
 	 * @returns Current value
 	 */
-	peek(): Value;
+	peek(copy?: boolean): Store;
 
 	/**
 	 * Get a value by key _(without reactivity)_
 	 *
 	 * @param key Key of the value to get
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
 	 * @returns Value for the specified key, or `undefined` if it doesn't exist
 	 */
-	peek<Key extends keyof Value>(key: Key): Value[Key];
+	peek<Key extends keyof Store>(key: Key, copy?: boolean): Store[Key];
 
 	/**
 	 * Get a value by key _(without reactivity)_
 	 *
 	 * @param key Key of the value to get
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
 	 * @returns Value for the specified key, or `undefined` if it doesn't exist
 	 */
-	peek(key: Key): unknown;
+	peek(key: Key, copy?: boolean): unknown;
 
 	/**
 	 * Set the value
@@ -334,9 +369,9 @@ export type ReactiveStore<Value> = {
 	 */
 	set(
 		value?:
-			| Value
-			| (() => null | undefined | Value | Promise<null | undefined | Value>)
-			| Promise<null | undefined | Value>,
+			| Store
+			| (() => null | undefined | Store | Promise<null | undefined | Store>)
+			| Promise<null | undefined | Store>,
 	): void;
 
 	/**
@@ -345,9 +380,9 @@ export type ReactiveStore<Value> = {
 	 * @param key Key of the value to set
 	 * @param value New value
 	 */
-	set<Key extends keyof Value>(
+	set<Key extends keyof Store>(
 		key: Key,
-		value: Value[Key] | (() => Value[Key] | Promise<Value[Key]>) | Promise<Value[Key]>,
+		value: Store[Key] | (() => Store[Key] | Promise<Store[Key]>) | Promise<Store[Key]>,
 	): void;
 
 	/**
@@ -362,67 +397,83 @@ export type ReactiveStore<Value> = {
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy Copy the store? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
+	subscribe(callback: (value: Store) => void, copy?: boolean): Subscription;
 
 	/**
 	 * Subscribe to changes for a specific key
 	 *
 	 * @param key Key of the value to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe<Key extends keyof Value>(
+	subscribe<Key extends keyof Store>(
 		key: Key,
-		callback: (value: Value[Key] | undefined) => void,
-	): Unsubscribe;
+		callback: (value: Store[Key] | undefined) => void,
+		copy?: boolean,
+	): Subscription;
 
 	/**
 	 * Subscribe to changes for a specific key
 	 *
 	 * @param key Key of the value to subscribe to
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+	subscribe(key: Key, callback: (value: unknown) => void, copy?: boolean): Subscription;
 
 	/**
-	 * Unsubscribe from changes for a specific key
+	 * Update the value _(based on the current value)_
 	 *
-	 * @param key Key of the value to unsubscribe from
-	 * @param callback Callback to unsubscribe
+	 * @param callback Callback to update the value
 	 */
-	unsubscribe<Key extends keyof Value>(
-		key: Key,
-		callback: (value: Value[Key] | undefined) => void,
-	): void;
+	update(callback: (value: Store) => Store): void;
+} & Reactive<Store>;
+
+export type ReadonlyInstances<Value> = {
+	frozen?: ReadonlyFrozenSignal<Value>;
+	original?: ReadonlySignal<Value>;
+};
+
+export type ReadonlyFrozenSignal<Value> = ReadonlySignal<ReadonlySignalValue<Value>>;
 
+export type ReadonlySignal<Value> = {
 	/**
-	 * Unsubscribe from changes
+	 * Is the signal frozen?
+	 */
+	get frozen(): boolean;
+} & Reactive<Value> &
+	SimpleReactive<Value>;
+
+export type ReadonlySignalValue<Value> = Value extends unknown[]
+	? Readonly<Value>
+	: Value extends PlainObject
+		? Readonly<Value>
+		: Value;
+
+export type Signal<Value> = {
+	/**
+	 * Get a readonly version of the signal
 	 *
-	 * @param callback Callback to unsubscribe
+	 * @param frozen Freeze the signal? _(defaults to `false`)_
+	 * @returns Readonly signal
 	 */
-	unsubscribe(callback: (value: Value) => void): void;
+	asReadonly(frozen: true): ReadonlyFrozenSignal<Value>;
 
 	/**
-	 * Update the value _(based on the current value)_
+	 * Get a readonly version of the signal
 	 *
-	 * @param callback Callback to update the value
+	 * @param frozen Freeze the signal? _(defaults to `false`)_
+	 * @returns Readonly signal
 	 */
-	update(callback: (value: Value) => Value): void;
-} & Reactive<Value>;
-
-export type SetValueInProxyParameters<Value, Equal> = {
-	target: Value;
-	property: PropertyKey;
-	value: unknown;
-	state: ReactiveState<Value, Equal>;
-	isArray: boolean;
-	length?: Signal<number>;
-};
+	asReadonly(
+		frozen?: boolean,
+	): typeof frozen extends true ? ReadonlyFrozenSignal<Value> : ReadonlySignal<Value>;
 
-export type Signal<Value> = {
 	/**
 	 * Set the value
 	 *
@@ -450,34 +501,28 @@ type SimpleReactive<Value> = {
 	/**
 	 * Get the value _(without reactivity)_
 	 *
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
 	 * @returns Current value
 	 */
-	peek(): Value;
+	peek(copy?: boolean): Value;
 
 	/**
 	 * Subscribe to changes
 	 *
 	 * @param callback Callback for changes
-	 * @returns Unsubscribe callback
+	 * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+	 * @returns Subscription
 	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
-
-	/**
-	 * Unsubscribe from changes
-	 *
-	 * @param callback Callback to unsubscribe
-	 */
-	unsubscribe(callback: (value: Value) => void): void;
+	subscribe(callback: (value: Value) => void, copy?: boolean): Subscription;
 };
 
-export type Subscription = {
+export type StoredSubscription = {
 	callback: GenericCallback;
+	copy: boolean;
+	frozen: boolean;
 	state: ReactiveState<unknown, never>;
-
-	destroy(): void;
 };
 
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
+export type SubscriptionType = 'copy' | 'frozen' | 'original' | 'readonly';
+
+// #endregion

package/src/value/array.ts

@@ -1,7 +1,5 @@
 import {select} from '@oscarpalmer/atoms/array';
 import {filter} from '@oscarpalmer/atoms/array/filter';
-import {noop} from '@oscarpalmer/atoms/function';
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {
 	METHODS_AFFECTING_LENGTH,
 	METHODS_UPDATE,
@@ -10,25 +8,31 @@ 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,
 	ReactiveArray,
 	ReactiveOptions,
 	ReactiveState,
+	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
  *
@@ -68,8 +72,10 @@ 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[]> = {};
 
 	state.value = new Proxy([], {
 		get: (target: Item[], property: PropertyKey) =>
@@ -77,14 +83,7 @@ export function array<Item>(
 				? 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[];
@@ -92,76 +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?: never, second?: never): void {
+		setProxyValue<Item[], Item>(true, state, setArrayValue, setAtIndex, first, second);
 	}
 
 	const instance = {
 		...rx,
-		length: state.value.length,
-		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)),
-		get: (value?: number | typeof PROPERTY_LENGTH) => get(value),
-		map: <Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped) =>
-			computed(() => (get() as Item[]).map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
-		peek: (value?: unknown) => peekArrayValue(state, length, value),
+		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) => {
-			setProxyValue<Item[], Item>(
-				true,
-				state,
-				isArrayValue,
-				isArrayIndex,
-				setArray,
-				setAtIndex,
-				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: 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;
-		},
+		subscribe: (first: never, second?: never, third?: never) =>
+			subscribeToProxy(isArray, instance as never, state, mapped, first, second, third),
 		unshift: (...items: Item[]) => state.value.unshift(...items),
-		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);
-			}
-		},
-		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: {
@@ -171,60 +137,51 @@ export function array<Item>(
 		},
 	});
 
-	instance.set(value);
-
-	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);
-}
+	set(value as never);
 
-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>(
 	state: ReactiveState<Item[], Item>,
 	length: Signal<number>,
-	value?: unknown,
-): number | Item | Item[] | undefined {
-	if (value === PROPERTY_LENGTH) {
-		return length.peek();
-	}
-
-	return typeof value === 'number' ? state.value.at(value) : state.value.slice();
-}
-
-function setArray<Item>(state: ReactiveState<Item[], Item>, value: Item[] | undefined): void {
-	state.value.splice(0, state.value.length, ...(value ?? []));
+	first?: unknown,
+	second?: boolean,
+): 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;
 	}
 }
 
@@ -238,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 (
@@ -253,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