@oscarpalmer/mora 0.25.0 → 0.27.0

package/dist/{mora.full.js → mora.full.mjs}

@@ -1,7 +1,5 @@
+//#region src/constants.ts
 const ACTIVE = {};
-const ARRAY_THRESHOLD = 100;
-const ARRAY_OFFSET = 25;
-const ARRAY_PEEK = 10;
 const BATCH = {
 	depth: 0,
 	handlers: /* @__PURE__ */ new Set()
@@ -32,8 +30,8 @@ const NAME_ALL = new Set([
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
-const PROPERTY_LENGTH = "length";
-
+//#endregion
+//#region src/effect.ts
 var Effect = class {
 	constructor(callback) {
 		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
@@ -41,11 +39,11 @@ var Effect = class {
 		runEffect(this);
 	}
 };
-function runEffect(effect$1) {
+function runEffect(effect) {
 	const previousEffect = ACTIVE.effect;
-	ACTIVE.effect = effect$1;
+	ACTIVE.effect = effect;
 	try {
-		effect$1.state.callback();
+		effect.state.callback();
 	} finally {
 		ACTIVE.effect = previousEffect;
 	}
@@ -58,7 +56,8 @@ function runEffect(effect$1) {
 function effect(callback) {
 	return typeof callback === "function" ? new Effect(callback) : void 0;
 }
-
+//#endregion
+//#region src/helpers/is.ts
 /**
 * Is the value a reactive array?
 * @param value Value to check
@@ -84,7 +83,7 @@ function isEffect(value) {
 	return isMora(value, NAME_EFFECT);
 }
 function isMora(value, name) {
-	return typeof value === "object" && value != null && NAME_MORA in value && (typeof name === "string" ? value[NAME_MORA] === name : name.has(value[NAME_MORA]));
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
 }
 /**
 * Is the value reactive?
@@ -102,7 +101,8 @@ function isReactive(value) {
 function isSignal(value) {
 	return isMora(value, NAME_SIGNAL);
 }
-
+//#endregion
+//#region src/batch.ts
 function flushHandlers() {
 	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
 		const handlers = [...BATCH.handlers];
@@ -126,7 +126,8 @@ function stopBatch() {
 	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
-
+//#endregion
+//#region src/subscription.ts
 var Subscription = class {
 	callback;
 	state;
@@ -152,7 +153,8 @@ function unsubscribe(state, callback) {
 	state.subscriptions.get(callback)?.destroy();
 	state.subscriptions.delete(callback);
 }
-
+//#endregion
+//#region src/value/reactive.ts
 var Reactive = class {
 	state = {
 		computeds: /* @__PURE__ */ new Set(),
@@ -203,7 +205,8 @@ var Reactive = class {
 		unsubscribe(this.state, callback);
 	}
 };
-
+//#endregion
+//#region src/value/computed.ts
 var Computed = class extends Reactive {
 	effect = {
 		dirty: true,
@@ -219,8 +222,8 @@ var Computed = class extends Reactive {
 			ACTIVE.computed = previousComputed;
 			if (!this.state.equal(this.state.value, value)) {
 				this.state.value = value;
-				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
-				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				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);
 			}
 			this.effect.dirty = false;
@@ -245,10 +248,11 @@ var Computed = class extends Reactive {
 function computed(callback, options) {
 	return new Computed(callback, options);
 }
-
+//#endregion
+//#region src/helpers/value.ts
 function emitValue(state) {
-	for (const computed$1 of state.computeds) computed$1.effect.dirty = true;
-	for (const effect$1 of state.effects) BATCH.handlers.add(effect$1);
+	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) BATCH.handlers.add(subscription);
 	if (BATCH.depth === 0) flushHandlers();
 }
@@ -256,9 +260,9 @@ function equalArrays(state, first, second) {
 	let { length } = first;
 	if (length !== second.length) return false;
 	let offset = 0;
-	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK);
-		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
+	if (length >= 100) {
+		offset = Math.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;
 	}
 	length -= offset;
@@ -270,17 +274,18 @@ function getValue(state) {
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
-
+//#endregion
+//#region src/helpers/proxy.ts
 function emityProxyValues(state, mapped) {
 	const values = [...mapped.values()];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) values[index].effect.dirty = true;
 	emitValue(state);
 }
-function getReactiveValueInProxy(reactive, mapped, key, isArray$1) {
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	let item = mapped.get(key);
 	if (item == null) {
-		item = computed(() => isArray$1 ? reactive.get().at(key) : reactive.get()[key]);
+		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
 		mapped.set(key, item);
 	}
 	return item;
@@ -302,19 +307,20 @@ function setProxyValue(proxy, value) {
 	stopBatch();
 }
 function setValueInProxy(parameters) {
-	const { isArray: isArray$1, length, property, state, target, value } = parameters;
-	if (isArray$1) {
-		if (!(!Number.isNaN(Number(property)) || property === PROPERTY_LENGTH)) return Reflect.set(target, property, value);
+	const { isArray, length, property, state, target, value } = parameters;
+	if (isArray) {
+		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
 	if (!state.equal(previous, value)) {
 		Reflect.set(target, property, value);
 		emitValue(state);
-		if (isArray$1) length?.set(target.length);
+		if (isArray) length?.set(target.length);
 	}
 	return true;
 }
-
+//#endregion
+//#region src/value/signal.ts
 var Signal = class extends Reactive {
 	constructor(value, options) {
 		super(NAME_SIGNAL, value, options);
@@ -352,7 +358,8 @@ var Signal = class extends Reactive {
 function signal(value, options) {
 	return new Signal(value, options);
 }
-
+//#endregion
+//#region src/value/array.ts
 var ReactiveArray = class extends Reactive {
 	#indiced = /* @__PURE__ */ new Map();
 	#size = signal(0);
@@ -371,10 +378,10 @@ var ReactiveArray = class extends Reactive {
 	constructor(value, options) {
 		super(NAME_ARRAY, new Proxy(value, {
 			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
-			set: (target, property, value$1) => setValueInProxy({
+			set: (target, property, value) => setValueInProxy({
 				property,
 				target,
-				value: value$1,
+				value,
 				isArray: true,
 				state: this.state,
 				length: this.#size
@@ -398,7 +405,7 @@ var ReactiveArray = class extends Reactive {
 	}
 	get(first) {
 		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
-		return first === PROPERTY_LENGTH ? this.length : getValue(this.state);
+		return first === "length" ? this.length : getValue(this.state);
 	}
 	/**
 	* Create a computed, mapped array
@@ -488,54 +495,53 @@ var ReactiveArray = class extends Reactive {
 function array(value, options) {
 	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
-function updateArray(type, array$1, state, length) {
+function updateArray(type, array, state, length) {
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
-	const previousArray = affectsLength ? [] : [...array$1];
-	const previousLength = array$1.length;
+	const previousArray = affectsLength ? [] : [...array];
+	const previousLength = array.length;
 	return (...args) => {
-		const result = array$1[type](...args);
-		if (affectsLength ? array$1.length !== previousLength : !equalArrays(state, previousArray, array$1)) {
+		const result = array[type](...args);
+		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
 			emitValue(state);
-			length.set(array$1.length);
+			length.set(array.length);
 		}
 		return result;
 	};
 }
-function setAtIndex(array$1, index, value) {
-	const actual = index < 0 ? array$1.length + index : index;
-	if (actual > -1) array$1[actual] = value;
+function setAtIndex(array, index, value) {
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = 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;
 }
-var TYPED_ARRAYS = new Set([
-	Int8Array,
-	Uint8Array,
-	Uint8ClampedArray,
-	Int16Array,
-	Uint16Array,
-	Int32Array,
-	Uint32Array,
-	Float32Array,
-	Float64Array,
-	BigInt64Array,
-	BigUint64Array
-]);
-
+//#endregion
+//#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$1) => setValueInProxy({
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value) => setValueInProxy({
 			target,
 			property,
-			value: value$1,
+			value,
 			isArray: false,
 			state: this.state
 		}) }), options);
@@ -581,5 +587,5 @@ var Store = class extends Reactive {
 function store(value, options) {
 	return new Store(isPlainObject(value) ? value : {}, options);
 }
-
-export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };
+//#endregion
+export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/subscription.d.mts

@@ -0,0 +1,2 @@
+import { _ as noop, g as Subscription, v as subscribe, y as unsubscribe } from "./models-QwNga87R.mjs";
+export { Subscription, noop, subscribe, unsubscribe };

package/dist/{subscription.js → subscription.mjs}

@@ -1,3 +1,4 @@
+//#region src/subscription.ts
 var Subscription = class {
 	callback;
 	state;
@@ -23,4 +24,5 @@ function unsubscribe(state, callback) {
 	state.subscriptions.get(callback)?.destroy();
 	state.subscriptions.delete(callback);
 }
+//#endregion
 export { Subscription, noop, subscribe, unsubscribe };

package/dist/value/array.d.mts

@@ -0,0 +1,140 @@
+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";
+
+//#region src/value/array.d.ts
+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;
+  /**
+   * Create a computed, filtered array
+   * @param callback Callback to evaluate each item
+   * @return Computed array of filtered items
+   */
+  filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+  /**
+   * @inheritdoc
+   */
+  get(): Item[];
+  /**
+   * Get the value at an index
+   * @param index Index of item to get _(if negative, starts from the end)_
+   * @returns Item at index, or `undefined` if it doesn't exist
+   */
+  get(index: number): Item | undefined;
+  /**
+   * Get the length of the array
+   * @returns Length of the array
+   */
+  get(property: typeof PROPERTY_LENGTH): number;
+  /**
+   * Create a computed, mapped array
+   * @param callback Callback to transform each item
+   * @return Computed array of mapped items
+   */
+  map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
+  /**
+   * 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;
+  /**
+   * @inheritdoc
+   */
+  peek(): Item[];
+  /**
+   * Get the value at an index _(without reactivity)_
+   * @param index Index of item to get _(if negative, starts from the end)_
+   * @returns Item at index, or `undefined` if it doesn't exist
+   */
+  peek(index: number): Item | undefined;
+  /**
+   * Get the length of the array _(without reactivity)_
+   * @returns Length of the array
+   */
+  peek(property: typeof PROPERTY_LENGTH): number;
+  /**
+   * Remove and return the last item of the array
+   * @returns Removed item, or `undefined` if the array is empty
+   */
+  pop(): Item | undefined;
+  /**
+   * Add items to the end of the array
+   * @param items Items to add
+   * @returns New array length
+   */
+  push(...items: Item[]): number;
+  /**
+   * Set the value
+   * @param value New array of items _(defaults to an empty array)_
+   */
+  set(value?: 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 the length of the array
+   * @param value New array length
+   */
+  set(property: typeof PROPERTY_LENGTH, value: number): void;
+  /**
+   * Remove and return the first item of the array
+   * @returns Removed item, or `undefined` if the array is empty
+   */
+  shift(): Item | undefined;
+  /**
+   * Remove and return items from the array _(and optionally add new items)_
+   * @param from Index to start removing items from
+   * @param to Index to stop removing items at _(defaults to the end of the array)_
+   * @param items Optional items to add
+   * @returns Removed items
+   */
+  splice(from: number, to?: number, ...items: Item[]): Item[];
+  /**
+   * @inheritdoc
+   */
+  subscribe(callback: (value: Item[]) => void): Unsubscribe;
+  /**
+   * Subscribe to changes at a specific index
+   * @param index Index of item to subscribe to
+   * @param callback Callback for changes
+   * @returns Unsubscribe callback
+   */
+  subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
+  /**
+   * Add items to the beginning of the array
+   * @param items Items to add
+   * @returns New array length
+   */
+  unshift(...items: Item[]): number;
+  /**
+   * Update the value _(based on the current value)_
+   * @param callback Callback to update the value
+   */
+  update(callback: (value: Item[]) => Item[]): void;
+}
+/**
+ * Create a reactive array
+ * @param value Initial array of items
+ * @param options Reactivity options
+ * @returns Reactive array
+ */
+declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+//#endregion
+export { ReactiveArray, array };

package/dist/value/{array.js → array.mjs}

@@ -1,26 +1,33 @@
-import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, PROPERTY_LENGTH } from "../constants.js";
-import { noop, subscribe } from "../subscription.js";
-import { Reactive } from "./reactive.js";
-import { computed } from "./computed.js";
-import { emitValue, equalArrays, getValue } from "../helpers/value.js";
-import { emityProxyValues, getReactiveValueInProxy, setValueInProxy } from "../helpers/proxy.js";
-import { signal } from "./signal.js";
+import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY } from "../constants.mjs";
+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 { signal } from "./signal.mjs";
+//#region src/value/array.ts
 var ReactiveArray = class extends Reactive {
 	#indiced = /* @__PURE__ */ new Map();
 	#size = signal(0);
+	/**
+	* The length of the array
+	*/
 	get length() {
 		return this.#size.get();
 	}
+	/**
+	* Set the length of the array
+	*/
 	set length(value) {
 		if (typeof value === "number" && value >= 0 && value !== this.state.value.length) this.get().length = value;
 	}
 	constructor(value, options) {
 		super(NAME_ARRAY, new Proxy(value, {
 			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
-			set: (target, property, value$1) => setValueInProxy({
+			set: (target, property, value) => setValueInProxy({
 				property,
 				target,
-				value: value$1,
+				value,
 				isArray: true,
 				state: this.state,
 				length: this.#size
@@ -28,9 +35,17 @@ var ReactiveArray = class extends Reactive {
 		}), options);
 		this.#size.set(value.length);
 	}
+	/**
+	* Clear the array
+	*/
 	clear() {
 		this.length = 0;
 	}
+	/**
+	* Create a computed, filtered array
+	* @param callback Callback to evaluate each item
+	* @return Computed array of filtered items
+	*/
 	filter(callback) {
 		return computed(() => this.get().filter(callback));
 	}
@@ -38,9 +53,20 @@ var ReactiveArray = class extends Reactive {
 		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
 		return first === "length" ? this.length : getValue(this.state);
 	}
+	/**
+	* Create a computed, mapped array
+	* @param callback Callback to transform each item
+	* @return Computed array of mapped items
+	*/
 	map(callback) {
 		return computed(() => this.get().map(callback));
 	}
+	/**
+	* 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.#indiced);
 	}
@@ -48,9 +74,18 @@ var ReactiveArray = class extends Reactive {
 		if (value === "length") return this.#size.peek();
 		return typeof value === "number" ? this.state.value.at(value) : [...this.state.value];
 	}
+	/**
+	* Remove and return the last item of the array
+	* @returns Removed item, or `undefined` if the array is empty
+	*/
 	pop() {
 		return this.state.value.pop();
 	}
+	/**
+	* Add items to the end of the array
+	* @param items Items to add
+	* @returns New array length
+	*/
 	push(...items) {
 		return this.state.value.push(...items);
 	}
@@ -59,9 +94,20 @@ var ReactiveArray = class extends Reactive {
 		else if (first === "length") this.length = second;
 		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
 	}
+	/**
+	* Remove and return the first item of the array
+	* @returns Removed item, or `undefined` if the array is empty
+	*/
 	shift() {
 		return this.state.value.shift();
 	}
+	/**
+	* Remove and return items from the array _(and optionally add new items)_
+	* @param from Index to start removing items from
+	* @param to Index to stop removing items at _(defaults to the end of the array)_
+	* @param items Optional items to add
+	* @returns Removed items
+	*/
 	splice(from, to, ...items) {
 		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
 	}
@@ -69,32 +115,48 @@ var ReactiveArray = class extends Reactive {
 		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
+	* @param items Items to add
+	* @returns New array length
+	*/
 	unshift(...items) {
 		return this.state.value.unshift(...items);
 	}
+	/**
+	* 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 || 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);
 }
-function updateArray(type, array$1, state, length) {
+function updateArray(type, array, state, length) {
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
-	const previousArray = affectsLength ? [] : [...array$1];
-	const previousLength = array$1.length;
+	const previousArray = affectsLength ? [] : [...array];
+	const previousLength = array.length;
 	return (...args) => {
-		const result = array$1[type](...args);
-		if (affectsLength ? array$1.length !== previousLength : !equalArrays(state, previousArray, array$1)) {
+		const result = array[type](...args);
+		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
 			emitValue(state);
-			length.set(array$1.length);
+			length.set(array.length);
 		}
 		return result;
 	};
 }
-function setAtIndex(array$1, index, value) {
-	const actual = index < 0 ? array$1.length + index : index;
-	if (actual > -1) array$1[actual] = value;
+function setAtIndex(array, index, value) {
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = value;
 }
+//#endregion
 export { ReactiveArray, array };

package/dist/value/computed.d.mts

@@ -0,0 +1,2 @@
+import { m as computed, p as Computed } from "../models-QwNga87R.mjs";
+export { Computed, computed };

package/dist/value/{computed.js → computed.mjs}

@@ -1,6 +1,7 @@
-import { ACTIVE, BATCH, NAME_COMPUTED } from "../constants.js";
-import { effect, runEffect } from "../effect.js";
-import { Reactive } from "./reactive.js";
+import { ACTIVE, BATCH, NAME_COMPUTED } from "../constants.mjs";
+import { effect, runEffect } from "../effect.mjs";
+import { Reactive } from "./reactive.mjs";
+//#region src/value/computed.ts
 var Computed = class extends Reactive {
 	effect = {
 		dirty: true,
@@ -16,13 +17,16 @@ var Computed = class extends Reactive {
 			ACTIVE.computed = previousComputed;
 			if (!this.state.equal(this.state.value, value)) {
 				this.state.value = value;
-				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
-				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				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);
 			}
 			this.effect.dirty = false;
 		});
 	}
+	/**
+	* @inheritdoc
+	*/
 	get() {
 		if (ACTIVE.computed != null && this !== ACTIVE.computed) this.state.computeds.add(ACTIVE.computed);
 		if (ACTIVE.effect != null && ACTIVE.effect !== this.effect.instance) this.state.effects.add(ACTIVE.effect);
@@ -30,7 +34,14 @@ var Computed = class extends Reactive {
 		return this.state.value;
 	}
 };
+/**
+* Create a computed value
+* @param callback Callback to compute the value
+* @param options Reactivity options
+* @returns Computed value
+*/
 function computed(callback, options) {
 	return new Computed(callback, options);
 }
+//#endregion
 export { Computed, computed };

package/dist/value/reactive.d.mts

@@ -0,0 +1,2 @@
+import { h as Reactive } from "../models-QwNga87R.mjs";
+export { Reactive };