@oscarpalmer/mora 0.27.0 → 0.29.0

package/dist/constants.d.mts

@@ -1,2 +1,20 @@
-import { a as BATCH, c as NAME_ALL, d as NAME_EFFECT, f as NAME_MORA, h as PROPERTY_LENGTH, i as ARRAY_THRESHOLD, l as NAME_ARRAY, m as NAME_STORE, n as ARRAY_OFFSET, o as METHODS_AFFECTING_LENGTH, p as NAME_SIGNAL, r as ARRAY_PEEK, s as METHODS_UPDATE, t as ACTIVE, u as NAME_COMPUTED } from "./constants-Cy6_M9Vk.mjs";
+import { Active, Batch } from "./models.mjs";
+
+//#region src/constants.d.ts
+declare const ACTIVE: Active;
+declare const ARRAY_THRESHOLD = 100;
+declare const ARRAY_OFFSET = 25;
+declare const ARRAY_PEEK = 10;
+declare const BATCH: Batch;
+declare const METHODS_AFFECTING_LENGTH: Set<string>;
+declare const METHODS_UPDATE: Set<string>;
+declare const NAME_ARRAY = "array";
+declare const NAME_COMPUTED = "computed";
+declare const NAME_EFFECT = "effect";
+declare const NAME_MORA = "$mora";
+declare const NAME_SIGNAL = "signal";
+declare const NAME_STORE = "store";
+declare const NAME_ALL: Set<string>;
+declare const PROPERTY_LENGTH = "length";
+//#endregion
 export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };

package/dist/effect.d.mts

@@ -1,2 +1,27 @@
-import { n as effect, r as runEffect, t as Effect } from "./effect-BkupB1p9.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/effect.d.ts
+declare class Effect {
+  /**
+   * Internal name of the effect
+   *
+   * @internal
+   */
+  private readonly $mora;
+  /**
+   * Internal state of the effect
+   *
+   * @internal
+   */
+  private readonly state;
+  constructor(callback: GenericCallback);
+}
+declare function runEffect(effect: Effect): void;
+/**
+ * Create an effect
+ * @param callback Callback for handling signal effects
+ * @returns Effect
+ */
+declare function effect(callback: GenericCallback): Effect;
+//#endregion
 export { Effect, effect, runEffect };

package/dist/helpers/is.d.mts

@@ -1,5 +1,7 @@
-import { t as Effect } from "../effect-BkupB1p9.mjs";
-import { d as Signal, h as Reactive, p as Computed } from "../models-QwNga87R.mjs";
+import { Effect } from "../effect.mjs";
+import { Reactive } from "../value/reactive.mjs";
+import { Computed } from "../value/computed.mjs";
+import { Signal } from "../value/signal.mjs";
 import { ReactiveArray } from "../value/array.mjs";
 import { Store } from "../value/store.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";

package/dist/helpers/proxy.d.mts

@@ -1,4 +1,5 @@
-import { c as ReactiveState, l as SetValueInProxyParameters, p as Computed } from "../models-QwNga87R.mjs";
+import { Computed } from "../value/computed.mjs";
+import { ReactiveState, SetValueInProxyParameters } from "../models.mjs";
 import { ReactiveArray } from "../value/array.mjs";
 import { Store } from "../value/store.mjs";
 import { ArrayOrPlainObject, Key, PlainObject } from "@oscarpalmer/atoms/models";
@@ -8,7 +9,7 @@ declare function emityProxyValues<Value>(state: ReactiveState<Value, Value>, map
 declare function emityProxyValues<Value>(state: ReactiveState<Value[], Value>, mapped: Map<Key, Computed<unknown>>): void;
 declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): Computed<unknown>;
 declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): Computed<unknown>;
-declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
+declare 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;
 declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(parameters: SetValueInProxyParameters<Value, Equal>): boolean;
 //#endregion
 export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/proxy.mjs

@@ -1,5 +1,4 @@
 import "../constants.mjs";
-import { startBatch, stopBatch } from "../batch.mjs";
 import { computed } from "../value/computed.mjs";
 import { emitValue } from "./value.mjs";
 //#region src/helpers/proxy.ts
@@ -17,21 +16,44 @@ function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	}
 	return item;
 }
-function setProxyValue(proxy, value) {
-	startBatch();
-	const proxyKeys = Object.keys(proxy);
-	const valueKeys = Object.keys(value);
-	let { length } = proxyKeys;
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
+function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
+	if (array && first === "length") {
+		state.value.length = second;
+		return;
 	}
-	length = valueKeys.length;
-	for (let index = 0; index < length; index += 1) {
-		const key = valueKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = value[key];
+	if (isObject(first)) {
+		setObject(state, first);
+		return;
 	}
-	stopBatch();
+	const property = isProperty(first);
+	if (array && property && Number.isNaN(first)) return;
+	let actual = property ? second : first;
+	if (typeof actual === "function") try {
+		actual = actual();
+	} catch {
+		return;
+	}
+	if (actual instanceof Promise) {
+		if (property) {
+			state.promises ??= /* @__PURE__ */ new Map();
+			state.promises.set(first, actual);
+		} else state.promise = actual;
+		actual.then((value) => {
+			if (property && state.promises.get(first) === actual) {
+				state.promises.delete(first);
+				setProperty(state, first, value);
+				return;
+			}
+			if (!property && isObject(value) && state.promise === actual) {
+				state.promise = void 0;
+				setObject(state, value);
+			}
+		}).catch(() => {
+			if (property && state.promises.get(first) === actual) state.promises.delete(first);
+			else if (!property && state.promise === actual) state.promise = void 0;
+		});
+	} else if (property) setProperty(state, first, actual);
+	else if (isObject(actual)) setObject(state, actual);
 }
 function setValueInProxy(parameters) {
 	const { isArray, length, property, state, target, value } = parameters;

package/dist/helpers/value.d.mts

@@ -1,4 +1,4 @@
-import { c as ReactiveState } from "../models-QwNga87R.mjs";
+import { ReactiveState } from "../models.mjs";
 
 //#region src/helpers/value.d.ts
 declare function emitValue<Value>(state: ReactiveState<Value, never>): void;

package/dist/helpers/value.mjs

@@ -1,5 +1,6 @@
 import { ACTIVE, BATCH } from "../constants.mjs";
 import { flushHandlers } from "../batch.mjs";
+import { round } from "@oscarpalmer/atoms/math";
 //#region src/helpers/value.ts
 function emitValue(state) {
 	for (const computed of state.computeds) computed.effect.dirty = true;
@@ -12,7 +13,7 @@ function equalArrays(state, first, second) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= 100) {
-		offset = Math.round(length / 10);
+		offset = round(length / 10);
 		offset = offset > 25 ? 25 : offset;
 		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
 	}

package/dist/index.d.mts

@@ -1,6 +1,9 @@
 import { startBatch, stopBatch } from "./batch.mjs";
-import { n as effect, t as Effect } from "./effect-BkupB1p9.mjs";
-import { d as Signal, f as signal, h as Reactive, m as computed, p as Computed, u as Unsubscribe } from "./models-QwNga87R.mjs";
+import { Effect, effect } from "./effect.mjs";
+import { Reactive } from "./value/reactive.mjs";
+import { Computed, computed } from "./value/computed.mjs";
+import { Signal, signal } from "./value/signal.mjs";
+import { Unsubscribe } from "./models.mjs";
 import { ReactiveArray, array } from "./value/array.mjs";
 import { Store, store } from "./value/store.mjs";
 import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";

package/dist/models.d.mts

@@ -1,2 +1,62 @@
-import { a as InternalComputed, c as ReactiveState, i as EffectState, l as SetValueInProxyParameters, n as Batch, o as InternalEffect, r as ComputedEffect, s as ReactiveOptions, t as Active, u as Unsubscribe } from "./models-QwNga87R.mjs";
+import { Effect } from "./effect.mjs";
+import { Subscription } from "./subscription.mjs";
+import { Computed } from "./value/computed.mjs";
+import { Signal } from "./value/signal.mjs";
+import { GenericCallback, Key } from "@oscarpalmer/atoms/models";
+
+//#region src/models.d.ts
+type Active = {
+  computed?: Computed<unknown>;
+  effect?: Effect;
+};
+type Batch = {
+  depth: number;
+  handlers: Set<Effect | Subscription>;
+};
+type ComputedEffect = {
+  dirty: boolean;
+  instance: Effect;
+};
+type EffectState = {
+  callback: GenericCallback;
+};
+type InternalComputed = {
+  readonly effect: ComputedEffect;
+  readonly state: ReactiveState<unknown, unknown>;
+};
+type InternalEffect = {
+  state: EffectState;
+};
+type ReactiveOptions<Value> = {
+  /**
+   * Method for comparing values for equality
+   * @param first First value
+   * @param second Second value
+   * @returns Are the values equal?
+   * @default Object.is
+   */
+  equal?: (first: Value, second: Value) => boolean;
+};
+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;
+};
+type SetValueInProxyParameters<Value, Equal> = {
+  target: Value;
+  property: PropertyKey;
+  value: unknown;
+  state: ReactiveState<Value, Equal>;
+  isArray: boolean;
+  length?: Signal<number>;
+};
+/**
+ * Unsubscribe from changes
+ */
+type Unsubscribe = () => void;
+//#endregion
 export { Active, Batch, ComputedEffect, EffectState, InternalComputed, InternalEffect, ReactiveOptions, ReactiveState, SetValueInProxyParameters, Unsubscribe };

package/dist/mora.full.mjs

@@ -156,6 +156,11 @@ function unsubscribe(state, callback) {
 //#endregion
 //#region src/value/reactive.ts
 var Reactive = class {
+	/**
+	* Internal state of the reactive value
+	*
+	* @internal
+	*/
 	state = {
 		computeds: /* @__PURE__ */ new Set(),
 		effects: /* @__PURE__ */ new Set(),
@@ -215,18 +220,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$1(this, this.state, callback);
+				this.effect.dirty = false;
 			}
-			this.effect.dirty = false;
 		});
 	}
 	/**
@@ -248,6 +245,72 @@ var Computed = class extends Reactive {
 function computed(callback, options) {
 	return new Computed(callback, options);
 }
+function setAndEmit$1(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$1(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$1(state, resolvedValue);
+				}
+			}).catch(() => {
+				if (state.promise === value) state.promise = void 0;
+			});
+		} else setAndEmit$1(state, value);
+	} finally {
+		ACTIVE.computed = previousComputed;
+	}
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+/**
+* Is the value a key?
+* @param value Value to check
+* @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
+*/
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+/**
+* Is the value a plain object?
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/math.mjs
+/**
+* Round a number
+* @param value Number to round
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `NaN` if the value if unable to be rounded
+*/
+function round(value, decimals) {
+	return roundNumber(Math.round, value, decimals);
+}
+function roundNumber(callback, value, decimals) {
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return callback(value);
+	const mod = 10 ** decimals;
+	return callback((value + Number.EPSILON) * mod) / mod;
+}
 //#endregion
 //#region src/helpers/value.ts
 function emitValue(state) {
@@ -261,7 +324,7 @@ function equalArrays(state, first, second) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= 100) {
-		offset = Math.round(length / 10);
+		offset = round(length / 10);
 		offset = offset > 25 ? 25 : offset;
 		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
 	}
@@ -290,21 +353,44 @@ function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	}
 	return item;
 }
-function setProxyValue(proxy, value) {
-	startBatch();
-	const proxyKeys = Object.keys(proxy);
-	const valueKeys = Object.keys(value);
-	let { length } = proxyKeys;
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
-	}
-	length = valueKeys.length;
-	for (let index = 0; index < length; index += 1) {
-		const key = valueKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = value[key];
-	}
-	stopBatch();
+function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
+	if (array && first === "length") {
+		state.value.length = second;
+		return;
+	}
+	if (isObject(first)) {
+		setObject(state, first);
+		return;
+	}
+	const property = isProperty(first);
+	if (array && property && Number.isNaN(first)) return;
+	let actual = property ? second : first;
+	if (typeof actual === "function") try {
+		actual = actual();
+	} catch {
+		return;
+	}
+	if (actual instanceof Promise) {
+		if (property) {
+			state.promises ??= /* @__PURE__ */ new Map();
+			state.promises.set(first, actual);
+		} else state.promise = actual;
+		actual.then((value) => {
+			if (property && state.promises.get(first) === actual) {
+				state.promises.delete(first);
+				setProperty(state, first, value);
+				return;
+			}
+			if (!property && isObject(value) && state.promise === actual) {
+				state.promise = void 0;
+				setObject(state, value);
+			}
+		}).catch(() => {
+			if (property && state.promises.get(first) === actual) state.promises.delete(first);
+			else if (!property && state.promise === actual) state.promise = void 0;
+		});
+	} else if (property) setProperty(state, first, actual);
+	else if (isObject(actual)) setObject(state, actual);
 }
 function setValueInProxy(parameters) {
 	const { isArray, length, property, state, target, value } = parameters;
@@ -336,10 +422,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)_
@@ -349,14 +432,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
 //#region src/value/array.ts
@@ -426,7 +528,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
@@ -444,9 +546,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
@@ -486,18 +586,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);
@@ -508,30 +610,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 ?? []);
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
-/**
-* Is the value a key?
-* @param value Value to check
-* @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
-*/
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
-}
-/**
-* Is the value a plain object?
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+function setAtIndex(state, index, value) {
+	const actual = index < 0 ? state.value.length + index : index;
+	if (actual > -1) state.value[actual] = value;
 }
 //#endregion
 //#region src/value/store.ts
@@ -562,8 +646,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);
@@ -574,18 +657,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 { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/subscription.d.mts

@@ -1,2 +1,15 @@
-import { _ as noop, g as Subscription, v as subscribe, y as unsubscribe } from "./models-QwNga87R.mjs";
+import { ReactiveState, Unsubscribe } from "./models.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/subscription.d.ts
+declare class Subscription {
+  callback: GenericCallback;
+  state: ReactiveState<unknown, never>;
+  constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
+  destroy(): void;
+}
+declare function noop(): void;
+declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
+declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;
+//#endregion
 export { Subscription, noop, subscribe, unsubscribe };