@oscarpalmer/mora 0.26.0 → 0.28.0

package/dist/value/store.d.mts

@@ -0,0 +1,112 @@
+import { Reactive } from "./reactive.mjs";
+import { ReactiveOptions, Unsubscribe } from "../models.mjs";
+import { Key, PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/value/store.d.ts
+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
+   * @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 a value by key
+   * @param key Key of the value to get
+   * @returns Value for the specified key, or `undefined` if it doesn't exist
+   */
+  get(key: Key): unknown;
+  /**
+   * Notify dependents of changes
+   *
+   * _This bypasses equality checks and will immediately notify dependents.
+   * Use this only if you're modifying nested data that would be ignored by equality checks._
+   */
+  notify(): void;
+  /**
+   * Get the value _(without reactivity)_
+   * @returns The current value
+   */
+  peek(): Value;
+  /**
+   * Get a value by key _(without reactivity)_
+   * @param key Key of the value to get
+   * @returns Value for the specified key, or `undefined` if it doesn't exist
+   */
+  peek<Key extends keyof Value>(key: Key): Value[Key];
+  /**
+   * Get a value by key _(without reactivity)_
+   * @param key Key of the value to get
+   * @returns Value for the specified key, or `undefined` if it doesn't exist
+   */
+  peek(key: Key): unknown;
+  /**
+   * Set the value
+   * @param value New value _(defaults to an empty object)_
+   */
+  set(value?: Value | (() => null | undefined | Value | Promise<null | undefined | Value>) | Promise<null | undefined | Value>): void;
+  /**
+   * Set a value by key
+   * @param key Key of the value to set
+   * @param value New value
+   */
+  set<Key extends keyof Value>(key: Key, value: Value[Key] | (() => Value[Key] | Promise<Value[Key]>) | Promise<Value[Key]>): void;
+  /**
+   * Set a value by key
+   * @param key Key of the value to set
+   * @param value New value
+   */
+  set(key: Key, value: unknown): void;
+  /**
+   * @inheritdoc
+   */
+  subscribe(callback: (value: Value) => void): Unsubscribe;
+  /**
+   * Subscribe to changes for a specific key
+   * @param key Key of the value to subscribe to
+   * @param callback Callback for changes
+   * @returns Unsubscribe callback
+   */
+  subscribe<Key extends keyof Value>(key: Key, callback: (value: Value[Key] | undefined) => void): Unsubscribe;
+  /**
+   * Subscribe to changes for a specific key
+   * @param key Key of the value to subscribe to
+   * @param callback Callback for changes
+   * @returns Unsubscribe callback
+   */
+  subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+  /**
+   * Update the value _(based on the current value)_
+   * @param callback Callback to update the value
+   */
+  update(callback: (value: Value) => Value): void;
+}
+/**
+ * Create a reactive store from a function result
+ * @param value Initial object value
+ * @param options Reactivity options
+ * @returns Reactive store
+ */
+declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Store<Value>;
+/**
+ * Create a reactive store from a promise
+ * @param value Initial object value
+ * @param options Reactivity options
+ * @returns Reactive store
+ */
+declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): Store<Value>;
+/**
+ * Create a reactive store
+ * @param value Initial object value
+ * @param options Reactivity options
+ * @returns Reactive store
+ */
+declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;
+//#endregion
+export { Store, store };

package/dist/value/store.mjs

@@ -0,0 +1,81 @@
+import { NAME_STORE } from "../constants.mjs";
+import { startBatch, stopBatch } from "../batch.mjs";
+import { noop, subscribe } from "../subscription.mjs";
+import { Reactive } from "./reactive.mjs";
+import { getValue } from "../helpers/value.mjs";
+import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
+import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/value/store.ts
+var Store = class extends Reactive {
+	#keyed = /* @__PURE__ */ new Map();
+	constructor(value, options) {
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value) => setValueInProxy({
+			target,
+			property,
+			value,
+			isArray: false,
+			state: this.state
+		}) }), options);
+	}
+	get(key) {
+		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);
+	}
+	/**
+	* Notify dependents of changes
+	*
+	* _This bypasses equality checks and will immediately notify dependents.
+	* Use this only if you're modifying nested data that would be ignored by equality checks._
+	*/
+	notify() {
+		emityProxyValues(this.state, this.#keyed);
+	}
+	peek(key) {
+		return isKey(key) ? this.state.value[key] : { ...this.state.value };
+	}
+	set(first, second) {
+		setProxyValue(false, this.state, isStoreObject, isKey, setObject, setProperty, first, second);
+	}
+	subscribe(first, second) {
+		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)_
+	* @param callback Callback to update the value
+	*/
+	update(callback) {
+		const updated = callback(this.state.value);
+		if (updated == null || isPlainObject(updated)) setObject(this.state, updated);
+	}
+};
+function isStoreObject(value) {
+	return value == null || isPlainObject(value);
+}
+function setObject(state, value) {
+	startBatch();
+	const actual = value ?? {};
+	const proxy = state.value;
+	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] : void 0;
+	}
+	length = actualKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = actualKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+	}
+	stopBatch();
+}
+function setProperty(state, key, value) {
+	state.value[key] = value;
+}
+function store(value, options) {
+	const instance = new Store({}, options);
+	instance.set(value);
+	return instance;
+}
+//#endregion
+export { Store, store };

package/package.json

@@ -1,49 +1,55 @@
 {
+	"name": "@oscarpalmer/mora",
+	"version": "0.28.0",
+	"description": "Signals and stuff…",
+	"keywords": [
+		"reactive",
+		"signal",
+		"signals"
+	],
+	"license": "MIT",
 	"author": {
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
-	"dependencies": {
-		"@oscarpalmer/atoms": "^0.124"
-	},
-	"description": "Signals and stuff…",
-	"devDependencies": {
-		"@types/node": "^25",
-		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.3",
-		"oxfmt": "^0.21",
-		"oxlint": "^1.36",
-		"rolldown": "1.0.0-beta.58",
-		"tslib": "^2.8",
-		"typescript": "^5.9",
-		"vite": "8.0.0-beta.5",
-		"vitest": "^4"
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oscarpalmer/mora.git"
 	},
+	"files": [
+		"dist",
+		"src",
+		"types"
+	],
+	"type": "module",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-			"types": "./types/index.d.ts",
-			"default": "./dist/index.js"
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
 		}
 	},
-	"files": ["dist", "src", "types"],
-	"keywords": ["signal", "signals", "reactive"],
-	"license": "MIT",
-	"module": "./dist/index.js",
-	"name": "@oscarpalmer/mora",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/oscarpalmer/mora.git"
-	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
-		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rolldown:build": "npx rolldown -c",
-		"rolldown:watch": "npx rolldown -c --watch",
-		"test": "npx vitest --coverage",
-		"watch": "npx vite build --watch"
+		"build": "vpx vp run tsdown:build && vpx vp pack",
+		"tsdown:build": "vpx tsdown -c ./tsdown.config.ts",
+		"tsdown:watch": "vpx tsdown -c ./tsdown.config.ts --watch",
+		"test": "vpx vp test run --coverage",
+		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
-	"type": "module",
-	"types": "./types/index.d.ts",
-	"version": "0.26.0"
+	"dependencies": {
+		"@oscarpalmer/atoms": "^0.172"
+	},
+	"devDependencies": {
+		"@types/node": "^25.5",
+		"@vitest/coverage-istanbul": "^4.1",
+		"jsdom": "^29",
+		"tsdown": "^0.21",
+		"typescript": "^5.9",
+		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
+		"vite-plus": "latest",
+		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+	},
+	"packageManager": "npm@11.11.1"
 }

package/src/constants.ts

@@ -15,12 +15,7 @@ export const BATCH: Batch = {
 	handlers: new Set<Effect | Subscription>(),
 };
 
-export const METHODS_AFFECTING_LENGTH = new Set<string>([
-	'pop',
-	'push',
-	'shift',
-	'unshift',
-]);
+export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);
 
 export const METHODS_UPDATE = new Set<string>([
 	...METHODS_AFFECTING_LENGTH,

package/src/helpers/is.ts

@@ -1,12 +1,12 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {
+	NAME_ALL,
 	NAME_ARRAY,
 	NAME_COMPUTED,
 	NAME_EFFECT,
 	NAME_MORA,
 	NAME_SIGNAL,
 	NAME_STORE,
-	NAME_ALL,
 } from '../constants';
 import type {Effect} from '../effect';
 import type {ReactiveArray} from '../value/array';

package/src/helpers/proxy.ts

@@ -1,5 +1,4 @@
 import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
-import {startBatch, stopBatch} from '../batch';
 import {PROPERTY_LENGTH} from '../constants';
 import type {InternalComputed, ReactiveState, SetValueInProxyParameters} from '../models';
 import type {ReactiveArray} from '../value/array';
@@ -66,33 +65,81 @@ export function getReactiveValueInProxy(
 	return item;
 }
 
-export function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void {
-	startBatch();
+export function setProxyValue<Value, Item = Value>(
+	array: boolean,
+	state: ReactiveState<Value, Item>,
+	isObject: (value: unknown) => value is Value | undefined,
+	isProperty: (value: unknown) => boolean,
+	setObject: (state: ReactiveState<Value, Item>, value: Value | undefined) => void,
+	setProperty: (state: ReactiveState<Value, Item>, property: unknown, value: Item) => void,
+	first?: unknown,
+	second?: unknown,
+): void {
+	if (array && first === PROPERTY_LENGTH) {
+		(state.value as unknown[]).length = second as number;
 
-	const proxyKeys = Object.keys(proxy);
-	const valueKeys = Object.keys(value);
+		return;
+	}
 
-	let {length} = proxyKeys;
+	if (isObject(first)) {
+		setObject(state, first);
 
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-
-		(proxy as PlainObject)[key] = valueKeys.includes(key) ? (value as PlainObject)[key] : undefined;
+		return;
 	}
 
-	length = valueKeys.length;
+	const property = isProperty(first);
 
-	for (let index = 0; index < length; index += 1) {
-		const key = valueKeys[index];
+	if (array && property && Number.isNaN(first)) {
+		return;
+	}
 
-		if (!proxyKeys.includes(key)) {
-			const keyedValue = (value as PlainObject)[key];
+	let actual = property ? second : first;
 
-			(proxy as PlainObject)[key] = keyedValue;
+	if (typeof actual === 'function') {
+		try {
+			actual = (actual as Function)();
+		} catch {
+			return;
 		}
 	}
 
-	stopBatch();
+	if (actual instanceof Promise) {
+		if (property) {
+			state.promises ??= new Map();
+
+			state.promises.set(first as Key, actual as Promise<never>);
+		} else {
+			state.promise = actual as Promise<never>;
+		}
+
+		void actual
+			.then(value => {
+				if (property && state.promises!.get(first as Key) === actual) {
+					state.promises!.delete(first as Key);
+
+					setProperty(state, first, value);
+
+					return;
+				}
+
+				if (!property && isObject(value) && state.promise === actual) {
+					state.promise = undefined;
+
+					setObject(state, value);
+				}
+			})
+			.catch(() => {
+				if (property && state.promises!.get(first as Key) === actual) {
+					state.promises!.delete(first as Key);
+				} else if (!property && state.promise === actual) {
+					state.promise = undefined;
+				}
+			});
+	} else if (property) {
+		setProperty(state, first, actual as Item);
+	} else if (isObject(actual)) {
+		setObject(state, actual);
+	}
 }
 
 export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(

package/src/models.ts

@@ -1,4 +1,4 @@
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, Key} from '@oscarpalmer/atoms/models';
 import type {Effect} from './effect';
 import type {Subscription} from './subscription';
 import type {Computed} from './value/computed';
@@ -47,6 +47,8 @@ export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
 	equal: (first: Equal, second: Equal) => boolean;
+	promise?: Promise<Value>;
+	promises?: Map<Key, Promise<never>>;
 	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };

package/src/value/array.ts

@@ -1,6 +1,11 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, PROPERTY_LENGTH} from '../constants';
-import {emityProxyValues, getReactiveValueInProxy, setValueInProxy} from '../helpers/proxy';
+import {
+	emityProxyValues,
+	getReactiveValueInProxy,
+	setProxyValue,
+	setValueInProxy,
+} from '../helpers/proxy';
 import {emitValue, equalArrays, getValue} from '../helpers/value';
 import type {ReactiveOptions, ReactiveState, Unsubscribe} from '../models';
 import {noop, subscribe} from '../subscription';
@@ -85,7 +90,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Get the length of the array
 	 * @returns Length of the array
 	 */
-	get(property: 'length'): number;
+	get(property: typeof PROPERTY_LENGTH): number;
 
 	get(first?: unknown): unknown {
 		if (typeof first === 'number') {
@@ -130,14 +135,14 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Get the length of the array _(without reactivity)_
 	 * @returns Length of the array
 	 */
-	override peek(property: 'length'): number;
+	override peek(property: typeof PROPERTY_LENGTH): number;
 
 	override peek(value?: unknown): unknown {
-		if (value === 'length') {
+		if (value === PROPERTY_LENGTH) {
 			return this.#size.peek();
 		}
 
-		return typeof value === 'number' ? this.state.value.at(value) : [...this.state.value];
+		return typeof value === 'number' ? this.state.value.at(value) : this.state.value.slice();
 	}
 
 	/**
@@ -161,29 +166,37 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Set the value
 	 * @param value New array of items _(defaults to an empty array)_
 	 */
-	set(value?: Item[]): void;
+	set(
+		value?:
+			| Item[]
+			| (() => null | undefined | Item[] | Promise<null | undefined | Item[]>)
+			| Promise<null | undefined | Item[]>,
+	): void;
 
 	/**
 	 * Set the value at an index
 	 * @param index Index of item to set __(if negative, starts from the end)_
 	 * @param value New item
 	 */
-	set(index: number, value: Item): void;
+	set(index: number, value: Item | (() => Item | Promise<Item>) | Promise<Item>): void;
 
 	/**
 	 * Set the length of the array
 	 * @param value New array length
 	 */
-	set(property: 'length', value: number): void;
-
-	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' && !Number.isNaN(first)) {
-			setAtIndex(this.state.value, first, second as Item);
-		}
+	set(property: typeof PROPERTY_LENGTH, value: number): void;
+
+	set(first?: unknown, second?: unknown): void {
+		setProxyValue<Item[], Item>(
+			true,
+			this.state,
+			isArrayValue,
+			isArrayIndex,
+			setArray,
+			setAtIndex,
+			first,
+			second,
+		);
 	}
 
 	/**
@@ -248,14 +261,53 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	}
 }
 
+/**
+ * Create a reactive array from a function result
+ * @param value Initial array of items
+ * @param options Reactivity options
+ * @returns Reactive array
+ */
+export function array<Item>(
+	value: () => Item[] | Promise<Item[]>,
+	options?: ReactiveOptions<Item>,
+): ReactiveArray<Item>;
+
+/**
+ * Create a reactive array from a promise
+ * @param value Initial array of items
+ * @param options Reactivity options
+ * @returns Reactive array
+ */
+export function array<Item>(
+	value: Promise<Item[]>,
+	options?: ReactiveOptions<Item>,
+): ReactiveArray<Item>;
+
 /**
  * Create a reactive array
  * @param value Initial array of items
  * @param options Reactivity options
  * @returns Reactive array
  */
-export function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item> {
-	return new ReactiveArray(Array.isArray(value) ? value : [], options);
+export function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+
+export function array<Item>(
+	value: Item[] | (() => Item[] | Promise<Item[]>) | Promise<Item[]>,
+	options?: ReactiveOptions<Item>,
+): ReactiveArray<Item> {
+	const instance = new ReactiveArray([], options);
+
+	instance.set(value);
+
+	return instance;
+}
+
+function isArrayIndex(value: unknown): boolean {
+	return typeof value === 'number';
+}
+
+function isArrayValue<Item>(value: unknown): value is Item[] | undefined {
+	return value == null || Array.isArray(value);
 }
 
 function updateArray<Item>(
@@ -265,7 +317,7 @@ function updateArray<Item>(
 	length: Signal<number>,
 ): unknown {
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
-	const previousArray = affectsLength ? [] : [...array];
+	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
 
 	return (...args: unknown[]): unknown => {
@@ -283,10 +335,14 @@ function updateArray<Item>(
 	};
 }
 
-function setAtIndex<Item>(array: Item[], index: number, value: Item): void {
-	const actual = index < 0 ? array.length + index : index;
+function setArray<Item>(state: ReactiveState<Item[], Item>, value: Item[] | undefined): void {
+	state.value.splice(0, 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);
 
 	if (actual > -1) {
-		array[actual] = value;
+		state.value[actual] = value;
 	}
 }