@oscarpalmer/mora 0.27.0 → 0.29.0

package/dist/value/array.d.mts

@@ -1,5 +1,7 @@
-import { h as Reactive, p as Computed, s as ReactiveOptions, u as Unsubscribe } from "../models-QwNga87R.mjs";
-import { h as PROPERTY_LENGTH } from "../constants-Cy6_M9Vk.mjs";
+import { Reactive } from "./reactive.mjs";
+import { Computed } from "./computed.mjs";
+import { ReactiveOptions, Unsubscribe } from "../models.mjs";
+import { PROPERTY_LENGTH } from "../constants.mjs";
 
 //#region src/value/array.d.ts
 declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
@@ -81,13 +83,13 @@ declare 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
@@ -129,6 +131,20 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
    */
   update(callback: (value: Item[]) => Item[]): void;
 }
+/**
+ * Create a reactive array from a function result
+ * @param value Initial array of items
+ * @param options Reactivity options
+ * @returns Reactive array
+ */
+declare 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
+ */
+declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 /**
  * Create a reactive array
  * @param value Initial array of items

package/dist/value/array.mjs

@@ -3,7 +3,7 @@ import { noop, subscribe } from "../subscription.mjs";
 import { Reactive } from "./reactive.mjs";
 import { computed } from "./computed.mjs";
 import { emitValue, equalArrays, getValue } from "../helpers/value.mjs";
-import { emityProxyValues, getReactiveValueInProxy, setValueInProxy } from "../helpers/proxy.mjs";
+import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
 import { signal } from "./signal.mjs";
 //#region src/value/array.ts
 var ReactiveArray = class extends Reactive {
@@ -72,7 +72,7 @@ var ReactiveArray = class extends Reactive {
 	}
 	peek(value) {
 		if (value === "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();
 	}
 	/**
 	* Remove and return the last item of the array
@@ -90,9 +90,7 @@ var ReactiveArray = class extends Reactive {
 		return this.state.value.push(...items);
 	}
 	set(first, second) {
-		if (first == null || Array.isArray(first)) this.state.value.splice(0, this.state.value.length, ...first ?? []);
-		else if (first === "length") this.length = second;
-		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
+		setProxyValue(true, this.state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
 	}
 	/**
 	* Remove and return the first item of the array
@@ -132,18 +130,20 @@ var ReactiveArray = class extends Reactive {
 		if (updated == null || Array.isArray(updated)) this.set(updated);
 	}
 };
-/**
-* Create a reactive array
-* @param value Initial array of items
-* @param options Reactivity options
-* @returns Reactive array
-*/
 function array(value, options) {
-	return new ReactiveArray(Array.isArray(value) ? value : [], options);
+	const instance = new ReactiveArray([], options);
+	instance.set(value);
+	return instance;
+}
+function isArrayIndex(value) {
+	return typeof value === "number";
+}
+function isArrayValue(value) {
+	return value == null || Array.isArray(value);
 }
 function updateArray(type, array, state, length) {
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
-	const previousArray = affectsLength ? [] : [...array];
+	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
@@ -154,9 +154,12 @@ function updateArray(type, array, state, length) {
 		return result;
 	};
 }
-function setAtIndex(array, index, value) {
-	const actual = index < 0 ? array.length + index : index;
-	if (actual > -1) array[actual] = value;
+function setArray(state, value) {
+	state.value.splice(0, state.value.length, ...value ?? []);
+}
+function setAtIndex(state, index, value) {
+	const actual = index < 0 ? state.value.length + index : index;
+	if (actual > -1) state.value[actual] = value;
 }
 //#endregion
 export { ReactiveArray, array };

package/dist/value/computed.d.mts

@@ -1,2 +1,21 @@
-import { m as computed, p as Computed } from "../models-QwNga87R.mjs";
+import { Reactive } from "./reactive.mjs";
+import { ReactiveOptions } from "../models.mjs";
+
+//#region src/value/computed.d.ts
+declare class Computed<Value> extends Reactive<Value> {
+  private readonly effect;
+  constructor(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>);
+  /**
+   * @inheritdoc
+   */
+  get(): Value;
+}
+/**
+ * Create a computed value
+ * @param callback Callback to compute the value
+ * @param options Reactivity options
+ * @returns Computed value
+ */
+declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
+//#endregion
 export { Computed, computed };

package/dist/value/computed.mjs

@@ -1,5 +1,6 @@
 import { ACTIVE, BATCH, NAME_COMPUTED } from "../constants.mjs";
 import { effect, runEffect } from "../effect.mjs";
+import { flushHandlers } from "../batch.mjs";
 import { Reactive } from "./reactive.mjs";
 //#region src/value/computed.ts
 var Computed = class extends Reactive {
@@ -10,18 +11,10 @@ var Computed = class extends Reactive {
 	constructor(callback, options) {
 		super(NAME_COMPUTED, void 0, options);
 		this.effect.instance = effect(() => {
-			if (!this.effect.dirty) return;
-			const previousComputed = ACTIVE.computed;
-			ACTIVE.computed = this;
-			const value = callback();
-			ACTIVE.computed = previousComputed;
-			if (!this.state.equal(this.state.value, value)) {
-				this.state.value = value;
-				for (const computed of this.state.computeds) computed.effect.dirty = true;
-				for (const effect of this.state.effects) BATCH.handlers.add(effect);
-				for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
+			if (this.effect.dirty) {
+				setValue(this, this.state, callback);
+				this.effect.dirty = false;
 			}
-			this.effect.dirty = false;
 		});
 	}
 	/**
@@ -43,5 +36,33 @@ var Computed = class extends Reactive {
 function computed(callback, options) {
 	return new Computed(callback, options);
 }
+function setAndEmit(state, value) {
+	if (state.equal(state.value, value)) return;
+	state.value = value;
+	for (const computed of state.computeds) computed.effect.dirty = true;
+	for (const effect of state.effects) BATCH.handlers.add(effect);
+	for (const [, subscription] of state.subscriptions) subscription.callback(value);
+	flushHandlers();
+}
+function setValue(instance, state, callback) {
+	const previousComputed = ACTIVE.computed;
+	ACTIVE.computed = instance;
+	try {
+		const value = callback();
+		if (value instanceof Promise) {
+			state.promise = value;
+			value.then((resolvedValue) => {
+				if (state.promise === value) {
+					state.promise = void 0;
+					setAndEmit(state, resolvedValue);
+				}
+			}).catch(() => {
+				if (state.promise === value) state.promise = void 0;
+			});
+		} else setAndEmit(state, value);
+	} finally {
+		ACTIVE.computed = previousComputed;
+	}
+}
 //#endregion
 export { Computed, computed };

package/dist/value/reactive.d.mts

@@ -1,2 +1,51 @@
-import { h as Reactive } from "../models-QwNga87R.mjs";
+import { ReactiveOptions, ReactiveState, Unsubscribe } from "../models.mjs";
+
+//#region src/value/reactive.d.ts
+declare abstract class Reactive<Value, Equal = Value> {
+  /**
+   * Internal name of the reactive value
+   *
+   * @internal
+   */
+  protected readonly $mora: string;
+  /**
+   * Internal state of the reactive value
+   *
+   * @internal
+   */
+  protected readonly state: ReactiveState<Value, Equal>;
+  constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+  /**
+   * Get the value
+   * @return Current value
+   */
+  abstract get(): Value;
+  /**
+   * Get the value _(without reactivity)_
+   * @return Current value
+   */
+  peek(): Value;
+  /**
+   * Subscribe to changes
+   * @param callback Callback for changes
+   * @return Unsubscribe callback
+   */
+  subscribe(callback: (value: Value) => void): Unsubscribe;
+  /**
+   * JSON representation of the value
+   * @return JSON value
+   */
+  toJSON(): Value;
+  /**
+   * String representation of the value
+   * @return Value as string
+   */
+  toString(): string;
+  /**
+   * Unsubscribe from changes
+   * @param callback Callback to unsubscribe
+   */
+  unsubscribe(callback: (value: Value) => void): void;
+}
+//#endregion
 export { Reactive };

package/dist/value/reactive.mjs

@@ -2,6 +2,11 @@ import { NAME_MORA } from "../constants.mjs";
 import { subscribe, unsubscribe } from "../subscription.mjs";
 //#region src/value/reactive.ts
 var Reactive = class {
+	/**
+	* Internal state of the reactive value
+	*
+	* @internal
+	*/
 	state = {
 		computeds: /* @__PURE__ */ new Set(),
 		effects: /* @__PURE__ */ new Set(),

package/dist/value/signal.d.mts

@@ -1,2 +1,44 @@
-import { d as Signal, f as signal } from "../models-QwNga87R.mjs";
+import { Reactive } from "./reactive.mjs";
+import { ReactiveOptions } from "../models.mjs";
+
+//#region src/value/signal.d.ts
+declare class Signal<Value> extends Reactive<Value> {
+  constructor(value: Value, options?: ReactiveOptions<Value>);
+  /**
+   * @inheritdoc
+   */
+  get(): Value;
+  /**
+   * Set the value
+   * @param value New value
+   */
+  set(value: Value | (() => Value | Promise<Value>) | Promise<Value>): void;
+  /**
+   * Update the value _(based on the current value)_
+   * @param callback Callback to update the value
+   */
+  update(callback: (value: Value) => Value): void;
+}
+/**
+ * Create a reactive value from a function result
+ * @param value Initial value
+ * @param options Reactivity options
+ * @returns Reactive value
+ */
+declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+/**
+ * Create a reactive value from a promise
+ * @param value Initial value
+ * @param options Reactivity options
+ * @returns Reactive value
+ */
+declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+/**
+ * Create a reactive value
+ * @param value Initial value
+ * @param options Reactivity options
+ * @returns Reactive value
+ */
+declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
+//#endregion
 export { Signal, signal };

package/dist/value/signal.mjs

@@ -17,10 +17,7 @@ var Signal = class extends Reactive {
 	* @param value New value
 	*/
 	set(value) {
-		if (!this.state.equal(this.state.value, value)) {
-			this.state.value = value;
-			emitValue(this.state);
-		}
+		setValue(this.state, value);
 	}
 	/**
 	* Update the value _(based on the current value)_
@@ -30,14 +27,33 @@ var Signal = class extends Reactive {
 		this.set(callback(this.state.value));
 	}
 };
-/**
-* Create a reactive value
-* @param value Initial value
-* @param options Reactivity options
-* @returns Reactive value
-*/
+function setAndEmit(state, value) {
+	if (!state.equal(state.value, value)) {
+		state.value = value;
+		emitValue(state);
+	}
+}
+function setValue(state, value) {
+	try {
+		let actual = value;
+		if (typeof value === "function") actual = value();
+		if (actual instanceof Promise) {
+			state.promise = actual;
+			actual.then((value) => {
+				if (actual === state.promise) {
+					state.promise = void 0;
+					setAndEmit(state, value);
+				}
+			}).catch(() => {
+				if (actual === state.promise) state.promise = void 0;
+			});
+		} else setAndEmit(state, actual);
+	} catch {}
+}
 function signal(value, options) {
-	return new Signal(value, options);
+	const instance = new Signal(void 0, options);
+	instance.set(value);
+	return instance;
 }
 //#endregion
 export { Signal, signal };

package/dist/value/store.d.mts

@@ -1,4 +1,5 @@
-import { h as Reactive, s as ReactiveOptions, u as Unsubscribe } from "../models-QwNga87R.mjs";
+import { Reactive } from "./reactive.mjs";
+import { ReactiveOptions, Unsubscribe } from "../models.mjs";
 import { Key, PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/value/store.d.ts
@@ -49,13 +50,13 @@ declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
    * Set the value
    * @param value New value _(defaults to an empty object)_
    */
-  set(value?: Value): void;
+  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]): void;
+  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
@@ -86,6 +87,20 @@ declare class Store<Value extends PlainObject> extends Reactive<Value, 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

package/dist/value/store.mjs

@@ -1,4 +1,5 @@
 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";
@@ -32,8 +33,7 @@ var Store = class extends Reactive {
 		return isKey(key) ? this.state.value[key] : { ...this.state.value };
 	}
 	set(first, second) {
-		if (isKey(first)) this.state.value[first] = second;
-		else if (first == null || isPlainObject(first)) setProxyValue(this.state.value, first ?? {});
+		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);
@@ -44,18 +44,38 @@ var Store = class extends Reactive {
 	* @param callback Callback to update the value
 	*/
 	update(callback) {
-		const updated = callback({ ...this.state.value });
-		if (updated == null || isPlainObject(updated)) setProxyValue(this.state.value, updated ?? {});
+		const updated = callback(this.state.value);
+		if (updated == null || isPlainObject(updated)) setObject(this.state, updated);
 	}
 };
-/**
-* Create a reactive store
-* @param value Initial object value
-* @param options Reactivity options
-* @returns Reactive store
-*/
+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) {
-	return new Store(isPlainObject(value) ? value : {}, options);
+	const instance = new Store({}, options);
+	instance.set(value);
+	return instance;
 }
 //#endregion
 export { Store, store };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.27.0",
+	"version": "0.29.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -35,16 +35,17 @@
 		"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": "npx vp test run --coverage",
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.165"
+		"@oscarpalmer/atoms": "^0.184"
 	},
 	"devDependencies": {
-		"@types/node": "^25.5",
+		"@oxlint/plugins": "^1.62",
+		"@types/node": "^25.6",
 		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^28.1",
+		"jsdom": "^29.1",
 		"tsdown": "^0.21",
 		"typescript": "^5.9",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",

package/src/effect.ts

@@ -3,8 +3,18 @@ import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
 import type {EffectState, InternalEffect} from './models';
 
 export class Effect {
+	/**
+	 * Internal name of the effect
+	 *
+	 * @internal
+	 */
 	declare private readonly $mora: string;
 
+	/**
+	 * Internal state of the effect
+	 *
+	 * @internal
+	 */
 	declare private readonly state: EffectState;
 
 	constructor(callback: GenericCallback) {

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/helpers/value.ts

@@ -1,3 +1,4 @@
+import {round} from '@oscarpalmer/atoms/math';
 import {flushHandlers} from '../batch';
 import {ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH} from '../constants';
 import type {InternalComputed, ReactiveState} from '../models';
@@ -34,7 +35,7 @@ export function equalArrays<Value>(
 	let offset = 0;
 
 	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK);
+		offset = round(length / ARRAY_PEEK);
 		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {

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;
 };