@oscarpalmer/mora 0.26.0 → 0.28.0

package/dist/batch.d.mts

@@ -0,0 +1,14 @@
+//#region src/batch.d.ts
+declare function flushHandlers(): void;
+/**
+ * Start batching effects
+ *
+ * _(Use {@link stopBatch} to flush and run batched effects)_
+ */
+declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+declare function stopBatch(): void;
+//#endregion
+export { flushHandlers, startBatch, stopBatch };

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

@@ -1,6 +1,7 @@
-import { BATCH } from "./constants.js";
-import { runEffect } from "./effect.js";
-import { isEffect } from "./helpers/is.js";
+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];
@@ -9,11 +10,20 @@ function flushHandlers() {
 		else handler.callback(handler.state.value);
 	}
 }
+/**
+* Start batching effects
+*
+* _(Use {@link stopBatch} to flush and run batched effects)_
+*/
 function startBatch() {
 	BATCH.depth += 1;
 }
+/**
+* Stop batching effects and flush _(run)_ them
+*/
 function stopBatch() {
 	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
+//#endregion
 export { flushHandlers, startBatch, stopBatch };

package/dist/constants.d.mts

@@ -0,0 +1,20 @@
+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/{constants.js → constants.mjs}

@@ -1,3 +1,4 @@
+//#region src/constants.ts
 const ACTIVE = {};
 const ARRAY_THRESHOLD = 100;
 const ARRAY_OFFSET = 25;
@@ -33,4 +34,5 @@ const NAME_ALL = new Set([
 	NAME_STORE
 ]);
 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

@@ -0,0 +1,17 @@
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/effect.d.ts
+declare class Effect {
+  private readonly $mora;
+  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/{effect.js → effect.mjs}

@@ -1,4 +1,5 @@
-import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.js";
+import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.mjs";
+//#region src/effect.ts
 var Effect = class {
 	constructor(callback) {
 		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
@@ -6,16 +7,22 @@ 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;
 	}
 }
+/**
+* Create an effect
+* @param callback Callback for handling signal effects
+* @returns Effect
+*/
 function effect(callback) {
 	return typeof callback === "function" ? new Effect(callback) : void 0;
 }
+//#endregion
 export { Effect, effect, runEffect };

package/dist/helpers/is.d.mts

@@ -0,0 +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 { 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>;
+/**
+ * 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>;
+//#endregion
+export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/is.mjs

@@ -0,0 +1,55 @@
+import { NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_SIGNAL, NAME_STORE } from "../constants.mjs";
+//#region src/helpers/is.ts
+/**
+* Is the value a reactive array?
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
+*/
+function isArray(value) {
+	return isMora(value, NAME_ARRAY);
+}
+/**
+* Is the value a computed signal?
+* @param value Value to check
+* @returns True if value is a {@link Computed}
+*/
+function isComputed(value) {
+	return isMora(value, NAME_COMPUTED);
+}
+/**
+* Is the value an effect?
+* @param value Value to check
+* @returns True if value is an {@link Effect}
+*/
+function isEffect(value) {
+	return isMora(value, NAME_EFFECT);
+}
+function isMora(value, name) {
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+}
+/**
+* Is the value reactive?
+* @param value Value to check
+* @returns True if value is a {@link Reactive}
+*/
+function isReactive(value) {
+	return isMora(value, NAME_ALL);
+}
+/**
+* Is the value a signal?
+* @param value Value to check
+* @returns True if value is a {@link Signal}
+*/
+function isSignal(value) {
+	return isMora(value, NAME_SIGNAL);
+}
+/**
+* Is the value a reactive store?
+* @param value Value to check
+* @returns True if value is a {@link Store}
+*/
+function isStore(value) {
+	return isMora(value, NAME_STORE);
+}
+//#endregion
+export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/proxy.d.mts

@@ -0,0 +1,15 @@
+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";
+
+//#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 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

@@ -0,0 +1,72 @@
+import "../constants.mjs";
+import { computed } from "../value/computed.mjs";
+import { emitValue } from "./value.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;
+	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]);
+		mapped.set(key, item);
+	}
+	return item;
+}
+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;
+	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) length?.set(target.length);
+	}
+	return true;
+}
+//#endregion
+export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/value.d.mts

@@ -0,0 +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;
+//#endregion
+export { emitValue, equalArrays, getValue };

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

@@ -1,5 +1,6 @@
-import { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH } from "../constants.js";
-import { flushHandlers } from "../batch.js";
+import { ACTIVE, BATCH } from "../constants.mjs";
+import { flushHandlers } from "../batch.mjs";
+//#region src/helpers/value.ts
 function emitValue(state) {
 	for (const computed of state.computeds) computed.effect.dirty = true;
 	for (const effect of state.effects) BATCH.handlers.add(effect);
@@ -24,4 +25,5 @@ function getValue(state) {
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
+//#endregion
 export { emitValue, equalArrays, getValue };

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+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 { 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 };

package/dist/index.mjs

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

package/dist/models.d.mts

@@ -0,0 +1,62 @@
+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/models.mjs

@@ -0,0 +1 @@
+export {};