@oscarpalmer/mora 0.18.2 → 0.20.0

package/src/value/array.ts

@@ -1,11 +1,14 @@
+import type {GenericCallback} from '@oscarpalmer/atoms';
 import {arrayName} from '../helpers/is';
-import {setValueInProxy} from '../helpers/proxy';
+import {getReactiveValueInProxy, setValueInProxy} from '../helpers/proxy';
 import {emitValue, equalArrays, getValue} from '../helpers/value';
+import {type Unsubscribe, noop, subscribe} from '../subscription';
 import {type Computed, computed} from './computed';
 import {Reactive, type ReactiveOptions, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
 
 export class ReactiveArray<Item> extends Reactive<Item[], Item> {
+	#indiced = new Map<number, Computed<unknown>>();
 	#size = signal(0);
 
 	/**
@@ -52,13 +55,6 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 		this.#size.set(value.length);
 	}
 
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined {
-		return this.get().at(index);
-	}
-
 	/**
 	 * Clear the array
 	 */
@@ -69,7 +65,27 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	/**
 	 * @inheritdoc
 	 */
-	get(): Item[] {
+	get(): Item[];
+
+	/**
+	 * Get the value at an index
+	 */
+	get(index: number): Item | undefined;
+
+	/**
+	 * Get the length of the array
+	 */
+	get(property: 'length'): number;
+
+	get(first?: unknown): unknown {
+		if (typeof first === 'number') {
+			return getReactiveValueInProxy(this, this.#indiced, first, true).get();
+		}
+
+		if (first === 'length') {
+			return this.length;
+		}
+
 		return getValue(this.state);
 	}
 
@@ -122,7 +138,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	/**
 	 * Set the value
 	 */
-	set(value: Item[]): void;
+	set(value?: Item[]): void;
 
 	/**
 	 * Set the value at an index
@@ -134,9 +150,9 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 */
 	set(property: 'length', value: number): void;
 
-	set(first: number | 'length' | Item[], second?: number | Item): void {
-		if (Array.isArray(first)) {
-			this.state.value.splice(0, this.state.value.length, ...first);
+	set(first?: number | 'length' | Item[], second?: number | Item): void {
+		if (first == null || Array.isArray(first)) {
+			this.state.value.splice(0, this.state.value.length, ...(first ?? []));
 		} else if (first === 'length') {
 			this.length = second as number;
 		} else if (typeof first === 'number') {
@@ -162,12 +178,52 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 		);
 	}
 
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+
+	/**
+	 * Subscribe to changes at a specific index
+	 */
+	subscribe(
+		index: number,
+		callback: (value: Item | undefined) => void,
+	): Unsubscribe;
+
+	subscribe(
+		first: number | GenericCallback,
+		second?: GenericCallback,
+	): Unsubscribe {
+		if (typeof first === 'number' && typeof second === 'function') {
+			return getReactiveValueInProxy(
+				this,
+				this.#indiced,
+				first,
+				true,
+			).subscribe(second);
+		}
+
+		return typeof first === 'function' ? subscribe(this.state, first) : noop;
+	}
+
 	/**
 	 * Add items to the beginning of the array
 	 */
 	unshift(...items: Item[]): number {
 		return this.state.value.unshift(...items);
 	}
+
+	/**
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Item[]) => Item[]): void {
+		const updated = callback(this.state.value);
+
+		if (updated == null || Array.isArray(updated)) {
+			this.set(updated);
+		}
+	}
 }
 
 /**

package/src/value/reactive.ts

@@ -1,3 +1,4 @@
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import type {Effect} from '../effect';
 import {
 	type Subscription,
@@ -80,6 +81,6 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };

package/src/value/signal.ts

@@ -26,7 +26,7 @@ export class Signal<Value> extends Reactive<Value> {
 	}
 
 	/**
-	 * Update the value
+	 * Update the value _(based on the current value)_
 	 */
 	update(callback: (value: Value) => Value): void {
 		this.set(callback(this.state.value));

package/src/value/store.ts

@@ -1,11 +1,23 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {
+	GenericCallback,
+	Key,
+	PlainObject,
+} from '@oscarpalmer/atoms/models';
 import {storeName} from '../helpers/is';
-import {setProxyValue, setValueInProxy} from '../helpers/proxy';
+import {
+	getReactiveValueInProxy,
+	setProxyValue,
+	setValueInProxy,
+} from '../helpers/proxy';
 import {getValue} from '../helpers/value';
+import {type Unsubscribe, noop, subscribe} from '../subscription';
+import type {Computed} from './computed';
 import {Reactive, type ReactiveOptions} from './reactive';
 
 export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#keyed = new Map<Key, Computed<unknown>>();
+
 	constructor(value: Value, options?: ReactiveOptions<Value>) {
 		super(
 			storeName,
@@ -33,7 +45,9 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	get(key: Key): unknown;
 
 	get(key?: unknown): unknown {
-		return isKey(key) ? this.state.value[key] : getValue(this.state);
+		return isKey(key)
+			? getReactiveValueInProxy(this, this.#keyed, key, false).get()
+			: getValue(this.state);
 	}
 
 	/**
@@ -77,6 +91,48 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 			setProxyValue(this.state.value, first ?? {});
 		}
 	}
+
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe<Key extends keyof Value>(
+		key: Key,
+		callback: (value: Value[Key] | undefined) => void,
+	): Unsubscribe;
+
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+
+	subscribe(
+		first: Key | GenericCallback,
+		second?: GenericCallback,
+	): Unsubscribe {
+		if (isKey(first) && typeof second === 'function') {
+			return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(
+				second,
+			);
+		}
+
+		return typeof first === 'function' ? subscribe(this.state, first) : noop;
+	}
+
+	/**
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Value) => Value): void {
+		const updated = callback({...this.state.value});
+
+		if (updated == null || isPlainObject(updated)) {
+			setProxyValue(this.state.value, updated ?? {});
+		}
+	}
 }
 
 /**

package/types/batch.d.cts

@@ -52,13 +52,13 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
-declare class Subscription<Value> {
-	state: ReactiveState<Value, never>;
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
@@ -73,7 +73,7 @@ export declare function startBatch(): void;
  * Stop batching effects and flush _(run)_ them
  */
 export declare function stopBatch(): void;
-export declare const batchedHandlers: Set<Effect | Subscription<unknown>>;
+export declare const batchedHandlers: Set<Effect | Subscription>;
 export declare let batchDepth: number;
 
 export {};

package/types/batch.d.ts

@@ -9,5 +9,5 @@ export declare function startBatch(): void;
  * Stop batching effects and flush _(run)_ them
  */
 export declare function stopBatch(): void;
-export declare const batchedHandlers: Set<Effect | Subscription<unknown>>;
+export declare const batchedHandlers: Set<Subscription | Effect>;
 export declare let batchDepth: number;

package/types/helpers/is.d.cts

@@ -60,13 +60,13 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
-declare class Subscription<Value> {
-	state: ReactiveState<Value, never>;
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
@@ -83,10 +83,6 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 */
 	set length(value: number);
 	constructor(value: Item[], options?: ReactiveOptions<Item>);
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined;
 	/**
 	 * Clear the array
 	 */
@@ -95,6 +91,14 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	/**
+	 * Get the value at an index
+	 */
+	get(index: number): Item | undefined;
+	/**
+	 * Get the length of the array
+	 */
+	get(property: "length"): number;
 	/**
 	 * Create a computed, filtered array
 	 */
@@ -122,7 +126,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	/**
 	 * Set the value
 	 */
-	set(value: Item[]): void;
+	set(value?: Item[]): void;
 	/**
 	 * Set the value at an index
 	 */
@@ -139,10 +143,22 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Remove and return items from the array _(and optionally add new items)_
 	 */
 	splice(from: number, to?: number, ...items: Item[]): Item[];
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes at a specific index
+	 */
+	subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
 	/**
 	 * Add items to the beginning of the array
 	 */
 	unshift(...items: Item[]): number;
+	/**
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Item[]) => Item[]): void;
 }
 declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value, options?: ReactiveOptions<Value>);
@@ -155,11 +171,12 @@ declare class Signal<Value> extends Reactive<Value> {
 	 */
 	set(value: Value): void;
 	/**
-	 * Update the value
+	 * Update the value _(based on the current value)_
 	 */
 	update(callback: (value: Value) => Value): void;
 }
 declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
@@ -197,6 +214,22 @@ declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	 * Set a value by key
 	 */
 	set(key: Key, value: unknown): void;
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe<Key extends keyof Value>(key: Key, callback: (value: Value[Key] | undefined) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+	/**
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Value) => Value): void;
 }
 /**
  * Is the value a reactive array?

package/types/helpers/proxy.d.cts

@@ -5,6 +5,14 @@
  */
 export type ArrayOrPlainObject = unknown[] | Record<PropertyKey, unknown>;
 export type GenericCallback = (...args: any[]) => any;
+/**
+ * A useful key type
+ */
+export type Key = number | string;
+/**
+ * A generic object
+ */
+export type PlainObject = Record<PropertyKey, unknown>;
 declare class Effect {
 	private readonly $mora;
 	private readonly state;
@@ -56,18 +64,106 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
-declare class Subscription<Value> {
-	state: ReactiveState<Value, never>;
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
+declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
+	#private;
+	/**
+	 * The length of the array
+	 */
+	get length(): number;
+	/**
+	 * Set the length of the array
+	 */
+	set length(value: number);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
+	/**
+	 * @inheritdoc
+	 */
+	get(): Item[];
+	/**
+	 * Get the value at an index
+	 */
+	get(index: number): Item | undefined;
+	/**
+	 * Get the length of the array
+	 */
+	get(property: "length"): number;
+	/**
+	 * Create a computed, filtered array
+	 */
+	filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+	/**
+	 * Create a computed, mapped array
+	 */
+	map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
+	/**
+	 * @inheritdoc
+	 */
+	peek(): Item[];
+	/**
+	 * Get the length of the array _(without reactivity)_
+	 */
+	peek(length: true): number;
+	/**
+	 * Remove and return the last item of the array
+	 */
+	pop(): Item | undefined;
+	/**
+	 * Add items to the end of the array
+	 */
+	push(...items: Item[]): number;
+	/**
+	 * Set the value
+	 */
+	set(value?: Item[]): void;
+	/**
+	 * Set the value at an index
+	 */
+	set(index: number, value: Item): void;
+	/**
+	 * Set the length of the array
+	 */
+	set(property: "length", value: number): void;
+	/**
+	 * Remove and return the first item of the array
+	 */
+	shift(): Item | undefined;
+	/**
+	 * Remove and return items from the array _(and optionally add new items)_
+	 */
+	splice(from: number, to?: number, ...items: Item[]): Item[];
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes at a specific index
+	 */
+	subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
+	/**
+	 * Add items to the beginning of the array
+	 */
+	unshift(...items: Item[]): number;
+	/**
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Item[]) => Item[]): void;
+}
 declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
@@ -79,10 +175,68 @@ declare class Signal<Value> extends Reactive<Value> {
 	 */
 	set(value: Value): void;
 	/**
-	 * Update the value
+	 * Update the value _(based on the current value)_
+	 */
+	update(callback: (value: Value) => Value): void;
+}
+declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
+	constructor(value: Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: Key): unknown;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: Key): unknown;
+	/**
+	 * Set the value
+	 */
+	set(value?: Value): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: keyof Value, value: Value[keyof Value]): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: Key, value: unknown): void;
+	/**
+	 * @inheritdoc
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe<Key extends keyof Value>(key: Key, callback: (value: Value[Key] | undefined) => void): Unsubscribe;
+	/**
+	 * Subscribe to changes for a specific key
+	 */
+	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+	/**
+	 * Update the value _(based on the current value)_
 	 */
 	update(callback: (value: Value) => Value): void;
 }
+export declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): Computed<unknown>;
+export declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): Computed<unknown>;
 export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
 export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;
 

package/types/helpers/proxy.d.ts

@@ -1,5 +1,10 @@
-import type { ArrayOrPlainObject } from '@oscarpalmer/atoms/models';
+import type { ArrayOrPlainObject, Key, PlainObject } from '@oscarpalmer/atoms/models';
+import type { ReactiveArray } from '../value/array';
+import { type Computed } from '../value/computed';
 import type { ReactiveState } from '../value/reactive';
 import type { Signal } from '../value/signal';
+import type { Store } from '../value/store';
+export declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): Computed<unknown>;
+export declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): Computed<unknown>;
 export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
 export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;

package/types/helpers/value.d.cts

@@ -52,13 +52,13 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
-declare class Subscription<Value> {
-	state: ReactiveState<Value, never>;
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes