@oscarpalmer/mora 0.29.0 → 0.30.0

package/dist/batch.mjs

@@ -1,13 +1,22 @@
 import { BATCH } from "./constants.mjs";
 import { runEffect } from "./effect.mjs";
-import { isEffect } from "./helpers/is.mjs";
 //#region src/batch.ts
 function flushHandlers() {
-	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
-		const handlers = [...BATCH.handlers];
-		BATCH.handlers.clear();
-		for (const handler of handlers) if (isEffect(handler)) runEffect(handler);
-		else handler.callback(handler.state.value);
+	if (BATCH.flushing) return;
+	BATCH.flushing = true;
+	try {
+		while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+			const handlers = [...BATCH.handlers];
+			const { length } = handlers;
+			BATCH.handlers.clear();
+			for (let index = 0; index < length; index += 1) {
+				const handler = handlers[index];
+				if (typeof handler.destroy === "function") handler.callback(handler.state.value);
+				else runEffect(handler);
+			}
+		}
+	} finally {
+		BATCH.flushing = false;
 	}
 }
 /**

package/dist/constants.d.mts

@@ -1,5 +1,4 @@
 import { Active, Batch } from "./models.mjs";
-
 //#region src/constants.d.ts
 declare const ACTIVE: Active;
 declare const ARRAY_THRESHOLD = 100;

package/dist/constants.mjs

@@ -5,15 +5,16 @@ const ARRAY_OFFSET = 25;
 const ARRAY_PEEK = 10;
 const BATCH = {
 	depth: 0,
+	flushing: false,
 	handlers: /* @__PURE__ */ new Set()
 };
-const METHODS_AFFECTING_LENGTH = new Set([
+const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
 	"push",
 	"shift",
 	"unshift"
 ]);
-const METHODS_UPDATE = new Set([
+const METHODS_UPDATE = /* @__PURE__ */ new Set([
 	...METHODS_AFFECTING_LENGTH,
 	"copyWithin",
 	"fill",
@@ -27,7 +28,7 @@ const NAME_EFFECT = "effect";
 const NAME_MORA = "$mora";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
-const NAME_ALL = new Set([
+const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
 	NAME_SIGNAL,

package/dist/effect.d.mts

@@ -1,27 +1,14 @@
+import { Effect, EffectState } from "./models.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;
+declare function internalEffect(callback: GenericCallback): EffectState;
+declare function runEffect(state: EffectState): void;
 //#endregion
-export { Effect, effect, runEffect };
+export { effect, internalEffect, runEffect };

package/dist/effect.mjs

@@ -1,28 +1,32 @@
-import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.mjs";
+import { ACTIVE, NAME_EFFECT } from "./constants.mjs";
 //#region src/effect.ts
-var Effect = class {
-	constructor(callback) {
-		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
-		this.state = { callback };
-		runEffect(this);
-	}
-};
-function runEffect(effect) {
-	const previousEffect = ACTIVE.effect;
-	ACTIVE.effect = effect;
-	try {
-		effect.state.callback();
-	} finally {
-		ACTIVE.effect = previousEffect;
-	}
-}
 /**
 * Create an effect
+*
 * @param callback Callback for handling signal effects
 * @returns Effect
 */
 function effect(callback) {
-	return typeof callback === "function" ? new Effect(callback) : void 0;
+	if (typeof callback !== "function") throw new TypeError("Effect callback must be a function");
+	return getEffect(callback)[0];
+}
+function getEffect(callback) {
+	const state = { callback };
+	const instance = Object.freeze({ $mora: NAME_EFFECT });
+	runEffect(state);
+	return [instance, state];
+}
+function internalEffect(callback) {
+	return getEffect(callback)[1];
+}
+function runEffect(state) {
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = state;
+	try {
+		state.callback();
+	} finally {
+		ACTIVE.effect = previousEffect;
+	}
 }
 //#endregion
-export { Effect, effect, runEffect };
+export { effect, internalEffect, runEffect };

package/dist/helpers/is.d.mts

@@ -1,47 +1,47 @@
-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 { Computed, Effect, Reactive, ReactiveArray, ReactiveStore, Signal } from "../models.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
-
 //#region src/helpers/is.d.ts
 /**
  * Is the value a reactive array?
+ *
  * @param value Value to check
  * @returns True if value is a {@link ReactiveArray}
  */
 declare function isArray<Item>(value: unknown): value is ReactiveArray<Item>;
 /**
  * Is the value a computed signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
 declare function isComputed<Value>(value: unknown): value is Computed<Value>;
 /**
  * Is the value an effect?
+ *
  * @param value Value to check
  * @returns True if value is an {@link Effect}
  */
 declare function isEffect(value: unknown): value is Effect;
 /**
  * Is the value reactive?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Reactive}
  */
-declare function isReactive<Value, Equal = Value>(value: unknown): value is Reactive<Value, Equal>;
+declare function isReactive<Value>(value: unknown): value is Reactive<Value>;
 /**
  * Is the value a signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Signal}
  */
 declare function isSignal<Value>(value: unknown): value is Signal<Value>;
 /**
  * Is the value a reactive store?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Store}
  */
-declare function isStore<Value extends PlainObject>(value: unknown): value is Store<Value>;
+declare function isStore<Value extends PlainObject>(value: unknown): value is ReactiveStore<Value>;
 //#endregion
 export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/is.mjs

@@ -2,6 +2,7 @@ import { NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_SIGNAL, NAME_STO
 //#region src/helpers/is.ts
 /**
 * Is the value a reactive array?
+*
 * @param value Value to check
 * @returns True if value is a {@link ReactiveArray}
 */
@@ -10,6 +11,7 @@ function isArray(value) {
 }
 /**
 * Is the value a computed signal?
+*
 * @param value Value to check
 * @returns True if value is a {@link Computed}
 */
@@ -18,6 +20,7 @@ function isComputed(value) {
 }
 /**
 * Is the value an effect?
+*
 * @param value Value to check
 * @returns True if value is an {@link Effect}
 */
@@ -29,6 +32,7 @@ function isMora(value, name) {
 }
 /**
 * Is the value reactive?
+*
 * @param value Value to check
 * @returns True if value is a {@link Reactive}
 */
@@ -37,6 +41,7 @@ function isReactive(value) {
 }
 /**
 * Is the value a signal?
+*
 * @param value Value to check
 * @returns True if value is a {@link Signal}
 */
@@ -45,6 +50,7 @@ function isSignal(value) {
 }
 /**
 * Is the value a reactive store?
+*
 * @param value Value to check
 * @returns True if value is a {@link Store}
 */

package/dist/helpers/proxy.d.mts

@@ -1,14 +1,10 @@
-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 { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, SetValueInProxyParameters } from "../models.mjs";
 import { ArrayOrPlainObject, Key, PlainObject } from "@oscarpalmer/atoms/models";
-
 //#region src/helpers/proxy.d.ts
-declare function emityProxyValues<Value>(state: ReactiveState<Value, Value>, mapped: Map<Key, Computed<unknown>>): void;
-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 emityProxyValues<Value>(state: ReactiveState<Value, Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>): void;
+declare function emityProxyValues<Value>(state: ReactiveState<Value[], Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>): void;
+declare function getReactiveValueInProxy<Value, Result = Value>(array: ReactiveArray<Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, index: number, isArray: true): Computed<Result>;
+declare function getReactiveValueInProxy<Value extends PlainObject>(store: ReactiveStore<Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, key: Key, isArray: false): Computed<unknown>;
 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

package/dist/helpers/proxy.mjs

@@ -1,20 +1,20 @@
 import "../constants.mjs";
-import { computed } from "../value/computed.mjs";
 import { emitValue } from "./value.mjs";
+import { internalComputed } from "../value/computed.mjs";
 //#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;
+	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
 	emitValue(state);
 }
 function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	let item = mapped.get(key);
 	if (item == null) {
-		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
+		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
 		mapped.set(key, item);
 	}
-	return item;
+	return item[0];
 }
 function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
 	if (array && first === "length") {

package/dist/helpers/value.d.mts

@@ -1,8 +1,8 @@
 import { ReactiveState } from "../models.mjs";
-
 //#region src/helpers/value.d.ts
 declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
 declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
-declare function getValue<Value>(state: ReactiveState<Value, never>): Value;
+declare function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value;
+declare function handleSimpleValue<Value>(state: ReactiveState<Value, Value>, origin: Value | (() => Value | Promise<Value>) | Promise<Value>, setValue: (state: ReactiveState<Value, Value>, value: Value) => void, onAfter?: () => void): void;
 //#endregion
-export { emitValue, equalArrays, getValue };
+export { emitValue, equalArrays, getSimpleValue, handleSimpleValue };

package/dist/helpers/value.mjs

@@ -1,9 +1,8 @@
 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;
+	for (const computed of state.computeds) computed.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();
@@ -13,7 +12,7 @@ function equalArrays(state, first, second) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= 100) {
-		offset = round(length / 10);
+		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;
 	}
@@ -21,10 +20,28 @@ function equalArrays(state, first, second) {
 	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
 	return true;
 }
-function getValue(state) {
+function getSimpleValue(state) {
 	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
+function handleSimpleValue(state, origin, setValue, onAfter) {
+	try {
+		let actual = typeof origin === "function" ? origin() : origin;
+		if (actual instanceof Promise) {
+			state.promise = actual;
+			actual.then((value) => {
+				if (actual === state.promise) {
+					state.promise = void 0;
+					setValue(state, value);
+				}
+			}).catch(() => {
+				if (actual === state.promise) state.promise = void 0;
+			});
+		} else setValue(state, actual);
+	} catch {} finally {
+		onAfter?.();
+	}
+}
 //#endregion
-export { emitValue, equalArrays, getValue };
+export { emitValue, equalArrays, getSimpleValue, handleSimpleValue };

package/dist/index.d.mts

@@ -1,10 +1,9 @@
 import { startBatch, stopBatch } from "./batch.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 { Computed, Effect, ReactiveArray, ReactiveStore, Signal, Unsubscribe } from "./models.mjs";
+import { effect } from "./effect.mjs";
 import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";
-export { type Computed, type Effect, type Reactive, type ReactiveArray, type Signal, type Store, type Unsubscribe, array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };
+import { array } from "./value/array.mjs";
+import { computed } from "./value/computed.mjs";
+import { signal } from "./value/signal.mjs";
+import { store } from "./value/store.mjs";
+export { type Computed, type Effect, type ReactiveArray, type ReactiveStore, type Signal, type Unsubscribe, array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { effect } from "./effect.mjs";
-import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";
 import { startBatch, stopBatch } from "./batch.mjs";
+import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";
 import { computed } from "./value/computed.mjs";
 import { signal } from "./value/signal.mjs";
 import { array } from "./value/array.mjs";