@oscarpalmer/mora 0.29.0 → 0.31.0

package/src/effect.ts

@@ -1,52 +1,47 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-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) {
-		Object.defineProperty(this, NAME_MORA, {
-			value: NAME_EFFECT,
-		});
-
-		this.state = {
-			callback,
-		};
-
-		runEffect(this);
+import {ACTIVE, NAME_EFFECT} from './constants';
+import type {Effect, EffectState} from './models';
+
+/**
+ * Create an effect
+ *
+ * @param callback Callback for handling signal effects
+ * @returns Effect
+ */
+export function effect(callback: GenericCallback): Effect {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Effect callback must be a function');
 	}
+
+	return getEffect(callback)[0];
 }
 
-export function runEffect(effect: Effect): void {
+function getEffect(callback: GenericCallback): [Effect, EffectState] {
+	const state: EffectState = {
+		callback,
+	};
+
+	const instance = Object.freeze({
+		$mora: NAME_EFFECT,
+	});
+
+	runEffect(state);
+
+	return [instance, state];
+}
+
+export function internalEffect(callback: GenericCallback): EffectState {
+	return getEffect(callback)[1];
+}
+
+export function runEffect(state: EffectState): void {
 	const previousEffect = ACTIVE.effect;
 
-	ACTIVE.effect = effect;
+	ACTIVE.effect = state;
 
 	try {
-		(effect as unknown as InternalEffect).state.callback();
+		state.callback();
 	} finally {
 		ACTIVE.effect = previousEffect;
 	}
 }
-
-/**
- * Create an effect
- * @param callback Callback for handling signal effects
- * @returns Effect
- */
-export function effect(callback: GenericCallback): Effect {
-	return typeof callback === 'function' ? new Effect(callback) : (undefined as never);
-}

package/src/helpers/is.ts

@@ -5,27 +5,23 @@ import {
 	NAME_COMPUTED,
 	NAME_EFFECT,
 	NAME_MORA,
+	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE,
 } from '../constants';
-import type {Effect} from '../effect';
-import type {ReactiveArray} from '../value/array';
-import type {Computed} from '../value/computed';
-import type {Reactive} from '../value/reactive';
-import type {Signal} from '../value/signal';
-import type {Store} from '../value/store';
-
-/**
- * Is the value a reactive array?
- * @param value Value to check
- * @returns True if value is a {@link ReactiveArray}
- */
-export function isArray<Item>(value: unknown): value is ReactiveArray<Item> {
-	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
-}
+import type {
+	Computed,
+	Effect,
+	Reactive,
+	ReactiveArray,
+	ReactiveStore,
+	ReadonlySignal,
+	Signal,
+} from '../models';
 
 /**
  * Is the value a computed signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
@@ -35,6 +31,7 @@ export 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}
  */
@@ -42,7 +39,7 @@ export function isEffect(value: unknown): value is Effect {
 	return isMora<Effect>(value, NAME_EFFECT);
 }
 
-function isMora<T>(value: unknown, name: string | Set<string>): value is T {
+function isMora<Instance>(value: unknown, name: string | Set<string>): value is Instance {
 	return (
 		typeof value === 'object' &&
 		value != null &&
@@ -55,15 +52,17 @@ function isMora<T>(value: unknown, name: string | Set<string>): value is T {
 
 /**
  * Is the value reactive?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Reactive}
  */
-export function isReactive<Value, Equal = Value>(value: unknown): value is Reactive<Value, Equal> {
-	return isMora<Reactive<Value, Equal>>(value, NAME_ALL);
+export function isReactive<Value>(value: unknown): value is Reactive<Value> {
+	return isMora<Reactive<Value>>(value, NAME_ALL);
 }
 
 /**
  * Is the value a signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Signal}
  */
@@ -71,11 +70,28 @@ export function isSignal<Value>(value: unknown): value is Signal<Value> {
 	return isMora<Signal<Value>>(value, NAME_SIGNAL);
 }
 
+/**
+ * Is the value a reactive array?
+ *
+ * @param value Value to check
+ * @returns True if value is a {@link ReactiveArray}
+ */
+export function isReactiveArray<Item>(value: unknown): value is ReactiveArray<Item> {
+	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
+}
+
 /**
  * Is the value a reactive store?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Store}
  */
-export function isStore<Value extends PlainObject>(value: unknown): value is Store<Value> {
-	return isMora<Store<Value>>(value, NAME_STORE);
+export function isReactiveStore<Value extends PlainObject>(
+	value: unknown,
+): value is ReactiveStore<Value> {
+	return isMora<ReactiveStore<Value>>(value, NAME_STORE);
+}
+
+export function isReadonlySignal<Value>(value: unknown): value is ReadonlySignal<Value> {
+	return isMora<ReadonlySignal<Value>>(value, NAME_READONLY);
 }

package/src/helpers/proxy.ts

@@ -1,68 +1,73 @@
 import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {PROPERTY_LENGTH} from '../constants';
-import type {InternalComputed, ReactiveState, SetValueInProxyParameters} from '../models';
-import type {ReactiveArray} from '../value/array';
-import {type Computed, computed} from '../value/computed';
-import type {Store} from '../value/store';
+import type {
+	Computed,
+	ComputedEffect,
+	ReactiveArray,
+	ReactiveState,
+	ReactiveStore,
+	SetValueInProxyParameters,
+} from '../models';
+import {internalComputed} from '../value/computed';
 import {emitValue} from './value';
 
 export function emityProxyValues<Value>(
 	state: ReactiveState<Value, Value>,
-	mapped: Map<Key, Computed<unknown>>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 ): void;
 
 export function emityProxyValues<Value>(
 	state: ReactiveState<Value[], Value>,
-	mapped: Map<Key, Computed<unknown>>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 ): void;
 
 export function emityProxyValues(
 	state: ReactiveState<unknown, unknown>,
-	mapped: Map<Key, Computed<unknown>>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 ): void {
 	const values = [...mapped.values()];
 	const {length} = values;
 
 	for (let index = 0; index < length; index += 1) {
-		(values[index] as unknown as InternalComputed).effect.dirty = true;
+		values[index][1].dirty = true;
 	}
 
 	emitValue(state);
 }
 
-export function getReactiveValueInProxy<Value>(
+export function getReactiveValueInProxy<Value, Result = Value>(
 	array: ReactiveArray<Value>,
-	mapped: Map<Key, Computed<unknown>>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 	index: number,
 	isArray: true,
-): Computed<unknown>;
+): Computed<Result>;
 
 export function getReactiveValueInProxy<Value extends PlainObject>(
-	store: Store<Value>,
-	mapped: Map<Key, Computed<unknown>>,
+	store: ReactiveStore<Value>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 	key: Key,
 	isArray: false,
 ): Computed<unknown>;
 
 export function getReactiveValueInProxy(
-	reactive: ReactiveArray<unknown> | Store<PlainObject>,
-	mapped: Map<Key, Computed<unknown>>,
+	reactive: ReactiveArray<unknown> | ReactiveStore<PlainObject>,
+	mapped: Map<Key, [Computed<unknown>, ComputedEffect]>,
 	key: Key,
 	isArray: boolean,
 ): Computed<unknown> {
 	let item = mapped.get(key);
 
 	if (item == null) {
-		item = computed(() =>
+		item = internalComputed(() =>
 			isArray
 				? (reactive.get() as unknown[]).at(key as number)
 				: (reactive.get() as PlainObject)[key],
-		) as Computed<unknown>;
+		);
 
 		mapped.set(key, item);
 	}
 
-	return item;
+	return item[0];
 }
 
 export function setProxyValue<Value, Item = Value>(

package/src/helpers/value.ts

@@ -1,11 +1,10 @@
-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';
+import type {ReactiveState} from '../models';
 
 export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	for (const computed of state.computeds) {
-		(computed as unknown as InternalComputed).effect.dirty = true;
+		computed.dirty = true;
 	}
 
 	for (const effect of state.effects) {
@@ -35,7 +34,7 @@ export function equalArrays<Value>(
 	let offset = 0;
 
 	if (length >= ARRAY_THRESHOLD) {
-		offset = round(length / ARRAY_PEEK);
+		offset = Math.round(length / ARRAY_PEEK);
 		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {
@@ -56,7 +55,7 @@ export function equalArrays<Value>(
 	return true;
 }
 
-export function getValue<Value>(state: ReactiveState<Value, never>): Value {
+export function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value {
 	if (ACTIVE.computed != null) {
 		state.computeds.add(ACTIVE.computed);
 	}
@@ -67,3 +66,38 @@ export function getValue<Value>(state: ReactiveState<Value, never>): Value {
 
 	return state.value;
 }
+
+export 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 {
+	try {
+		let actual = typeof origin === 'function' ? (origin as () => unknown)() : origin;
+
+		if (actual instanceof Promise) {
+			state.promise = actual;
+
+			void actual
+				.then(value => {
+					if (actual === state.promise) {
+						state.promise = undefined;
+
+						setValue(state, value);
+					}
+				})
+				.catch(() => {
+					if (actual === state.promise) {
+						state.promise = undefined;
+					}
+				});
+		} else {
+			setValue(state, actual as Value);
+		}
+	} catch {
+		// ?
+	} finally {
+		onAfter?.();
+	}
+}

package/src/index.ts

@@ -1,9 +1,24 @@
 export {startBatch, stopBatch} from './batch';
-export {effect, type Effect} from './effect';
-export {isArray, isComputed, isEffect, isReactive, isSignal} from './helpers/is';
-export type {Unsubscribe} from './models';
-export {array, type ReactiveArray} from './value/array';
-export {computed, type Computed} from './value/computed';
-export type {Reactive} from './value/reactive';
-export {signal, type Signal} from './value/signal';
-export {store, type Store} from './value/store';
+export {effect} from './effect';
+export {
+	isComputed,
+	isEffect,
+	isReactive,
+	isReactiveArray,
+	isReactiveStore,
+	isReadonlySignal,
+	isSignal,
+} from './helpers/is';
+export type {
+	Computed,
+	Effect,
+	ReactiveArray,
+	ReactiveStore,
+	ReadonlySignal,
+	Signal,
+	Unsubscribe,
+} from './models';
+export {array} from './value/array';
+export {computed} from './value/computed';
+export {signal} from './value/signal';
+export {store} from './value/store';