@oscarpalmer/mora 0.30.0 → 0.31.0

package/src/value/array.ts

@@ -1,6 +1,7 @@
 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,
@@ -22,11 +23,13 @@ import type {
 	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';
 
 /**
@@ -70,6 +73,9 @@ export function array<Item>(
 
 	const indiced = new Map<number, [Computed<unknown>, ComputedEffect]>();
 	const length = signal(0);
+	const readonlies: ReadonlyInstances<Item[]> = {};
+
+	let instance: Record<string, unknown> = {};
 
 	state.value = new Proxy([], {
 		get: (target: Item[], property: PropertyKey) =>
@@ -96,43 +102,23 @@ export function array<Item>(
 		return getArrayValue(instance as ReactiveArray<Item>, indiced, state, length, value);
 	}
 
-	const instance = {
+	function set(first?: unknown, second?: unknown): void {
+		setProxyValue<Item[], Item>(
+			true,
+			state,
+			isArrayValue,
+			isArrayIndex,
+			setArray,
+			setAtIndex,
+			first,
+			second,
+		);
+	}
+
+	const handlers = {
 		...rx,
-		length: state.value.length,
-		at: (index: number): Item | undefined => 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),
-		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,
-			);
-		},
-		shift: () => state.value.shift(),
-		splice: (from: number, to?: number, ...items: Item[]) =>
-			state.value.splice(from, to ?? state.value.length, ...items),
+		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(
@@ -145,7 +131,6 @@ export function array<Item>(
 
 			return typeof first === 'function' ? subscribe(state, first) : noop;
 		},
-		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(
@@ -155,6 +140,36 @@ export function array<Item>(
 				unsubscribe(state, first);
 			}
 		},
+	};
+
+	instance = {
+		...handlers,
+		asReadonly: (frozen?: unknown) =>
+			getReadonlyInstance(state, readonlies, handlers, frozen === true),
+		at: (index: number): Item | undefined => 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);
+		},
+		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);
+		},
+		shift: () => state.value.shift(),
+		splice: (from: number, to?: number, ...items: Item[]) =>
+			state.value.splice(from, to ?? state.value.length, ...items),
+		unshift: (...items: Item[]) => state.value.unshift(...items),
 		update: (callback: (value: Item[]) => Item[]) =>
 			updateArrayValue(instance as ReactiveArray<Item>, state, callback),
 	};
@@ -171,7 +186,7 @@ export function array<Item>(
 		},
 	});
 
-	instance.set(value);
+	set(value);
 
 	return Object.freeze(instance) as ReactiveArray<Item>;
 }
@@ -201,13 +216,34 @@ function isArrayValue<Item>(value: unknown): value is Item[] | undefined {
 function peekArrayValue<Item>(
 	state: ReactiveState<Item[], Item>,
 	length: Signal<number>,
-	value?: unknown,
+	first?: unknown,
+	second?: boolean,
 ): number | Item | Item[] | undefined {
-	if (value === PROPERTY_LENGTH) {
+	if (first === PROPERTY_LENGTH) {
 		return length.peek();
 	}
 
-	return typeof value === 'number' ? state.value.at(value) : state.value.slice();
+	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 {

package/src/value/readonly.ts

@@ -0,0 +1,71 @@
+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 type {
+	ReactiveState,
+	ReadonlyFrozenSignal,
+	ReadonlyInstances,
+	ReadonlySignal,
+	ReadonlySignalValue,
+} from '../models';
+
+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;
+
+	return instances[key] as ReadonlySignal<Value>;
+}
+
+export function getReadonlySignal<Value>(
+	state: ReactiveState<Value, never>,
+	handlers: Record<string, GenericCallback>,
+	frozen: boolean,
+): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value> {
+	const instance = {
+		...handlers,
+		get: () => getReadonlyValue(state, false, frozen),
+		peek: () => getReadonlyValue(state, true, frozen),
+	};
+
+	Object.defineProperties(instance, {
+		[NAME_MORA]: {
+			enumerable: false,
+			value: NAME_READONLY,
+		},
+		frozen: {
+			enumerable: true,
+			value: frozen,
+		},
+	});
+
+	return Object.freeze(instance) as ReadonlySignal<Value>;
+}
+
+function getReadonlyValue<Value>(
+	state: ReactiveState<Value, never>,
+	peek: boolean,
+	frozen: boolean,
+): Value | ReadonlySignalValue<Value> {
+	let value = peek ? state.value : getSimpleValue(state);
+
+	if (!frozen) {
+		return value;
+	}
+
+	if (Array.isArray(state.value)) {
+		value = [...state.value] as Value;
+	} else if (isPlainObject(state.value)) {
+		value = {...state.value} as Value;
+	} else {
+		value = state.value;
+	}
+
+	return Object.freeze(value);
+}

package/src/value/signal.ts

@@ -1,8 +1,9 @@
 import {NAME_MORA, NAME_SIGNAL} from '../constants';
 import {emitValue, getSimpleValue, handleSimpleValue} from '../helpers/value';
-import type {ReactiveOptions, ReactiveState, Signal} from '../models';
+import type {ReactiveOptions, ReactiveState, ReadonlyInstances, Signal} from '../models';
 import {subscribe} from '../subscription';
 import {reactive} from './reactive';
+import {getReadonlyInstance} from './readonly';
 
 function setAndEmit<Value>(state: ReactiveState<Value, Value>, value: Value): void {
 	if (!state.equal(state.value, value)) {
@@ -51,8 +52,20 @@ export function signal<Value>(
 ): Signal<Value> {
 	const [rx, state] = reactive<Value>(undefined as unknown as Value, options);
 
-	const instance = {
+	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),
 		get: () => getSimpleValue(state),
 		peek: () => state.value,
 		set: (value: Value | (() => Value | Promise<Value>) | Promise<Value>) => {
@@ -61,10 +74,6 @@ export function signal<Value>(
 		update: (callback: (value: Value) => Value) => {
 			handleSimpleValue(state, callback(state.value), setAndEmit);
 		},
-		subscribe: (callback: (value: Value) => void) => subscribe(state, callback),
-		unsubscribe: (callback: (value: Value) => void) => {
-			state.subscriptions.delete(callback);
-		},
 	};
 
 	Object.defineProperty(instance, NAME_MORA, {

package/src/value/store.ts

@@ -15,10 +15,12 @@ import type {
 	ReactiveOptions,
 	ReactiveState,
 	ReactiveStore,
+	ReadonlyInstances,
 	Unsubscribe,
 } from '../models';
 import {noop, subscribe, unsubscribe} from '../subscription';
 import {reactive} from './reactive';
+import {getReadonlyInstance} from './readonly';
 
 function isStoreObject<Value extends PlainObject>(value: unknown): value is Value | undefined {
 	return value == null || isPlainObject(value);
@@ -56,6 +58,34 @@ function setObject(state: ReactiveState<PlainObject, never>, value: PlainObject
 	stopBatch();
 }
 
+function peekStoreValue<Value extends PlainObject>(
+	state: ReactiveState<Value, Value>,
+	first?: unknown,
+	second?: boolean,
+): unknown {
+	let value: unknown;
+
+	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<Value extends PlainObject>(
 	state: ReactiveState<Value, Value>,
 	key: unknown,
@@ -107,6 +137,9 @@ export function store<Value extends PlainObject>(
 	const [rx, state] = reactive<Value>(undefined as never, options);
 
 	const keyed = new Map<Key, [Computed<unknown>, ComputedEffect]>();
+	const readonlies: ReadonlyInstances<Value> = {};
+
+	let instance: Record<string, GenericCallback> = {};
 
 	state.value = new Proxy({} as Value, {
 		set: (target: Value, property: PropertyKey, value: unknown) =>
@@ -119,16 +152,43 @@ export function store<Value extends PlainObject>(
 			}),
 	});
 
-	const instance = {
+	const handlers = {
 		...rx,
 		get: (value?: unknown): unknown =>
 			isKey(value)
-				? getReactiveValueInProxy(instance, keyed, value, false).get()
+				? getReactiveValueInProxy(instance as ReactiveStore<Value>, keyed, value, false).get()
 				: getSimpleValue(state),
+		peek: (first?: unknown, second?: boolean): unknown => peekStoreValue(state, first, second),
+		subscribe: (first: Key | GenericCallback, second?: GenericCallback): Unsubscribe => {
+			if (isKey(first) && typeof second === 'function') {
+				return getReactiveValueInProxy(
+					instance as ReactiveStore<Value>,
+					keyed,
+					first,
+					false,
+				).subscribe(second);
+			}
+
+			return typeof first === 'function' ? subscribe(state, first) : noop;
+		},
+		unsubscribe: (first: Key | GenericCallback, second?: GenericCallback) => {
+			if (isKey(first) && typeof second === 'function') {
+				getReactiveValueInProxy(instance as ReactiveStore<Value>, keyed, first, false)?.unsubscribe(
+					second,
+				);
+			} else if (typeof first === 'function') {
+				unsubscribe(state, first);
+			}
+		},
+	};
+
+	instance = {
+		...handlers,
+		asReadonly: (frozen?: unknown) =>
+			getReadonlyInstance(state, readonlies, handlers, frozen === true),
 		notify(): void {
 			emityProxyValues(state, keyed);
 		},
-		peek: (value?: unknown): unknown => (isKey(value) ? state.value[value] : {...state.value}),
 		set: (first?: unknown, second?: unknown) => {
 			setProxyValue<Value>(
 				false,
@@ -141,20 +201,6 @@ export function store<Value extends PlainObject>(
 				second,
 			);
 		},
-		subscribe: (first: Key | GenericCallback, second?: GenericCallback): Unsubscribe => {
-			if (isKey(first) && typeof second === 'function') {
-				return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
-			}
-
-			return typeof first === 'function' ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first: Key | GenericCallback, second?: GenericCallback) => {
-			if (isKey(first) && typeof second === 'function') {
-				getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
-			} else if (typeof first === 'function') {
-				unsubscribe(state, first);
-			}
-		},
 		update: (callback: (value: Value) => Value) => {
 			const updated = callback(state.value);