@oscarpalmer/mora 0.10.0 → 0.11.0

package/src/computed.ts

@@ -1,52 +1,33 @@
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {batchDepth, batchedHandlers} from './batch';
 import {type Effect, activeEffect, effect, runEffect} from './effect';
-import {
-	type Subscription,
-	type Unsubscribe,
-	subscribe,
-	unsubscribe,
-} from './subscription';
-
-export type ComputedState<Value> = {
-	computeds: Set<Computed<unknown>>;
+import {Reactive, type ReactiveState} from './reactive';
+
+type ComputedEffect = {
 	dirty: boolean;
-	effect: Effect;
-	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
-	value: Value;
+	instance: Effect;
 };
 
 export type InternalComputed = {
-	readonly state: ComputedState<unknown>;
+	readonly effect: ComputedEffect;
+	readonly state: ReactiveState<unknown>;
 };
 
 export let activeComputed: Computed<unknown> | undefined;
 
-export class Computed<Value> {
-	private declare readonly $mora: string;
-
-	private readonly state: ComputedState<Value>;
+export class Computed<Value> extends Reactive<Value> {
+	private readonly effect: ComputedEffect = {
+		dirty: true,
+		instance: undefined as never,
+	};
 
 	constructor(callback: () => Value) {
-		Object.defineProperty(this, '$mora', {
-			value: 'computed',
-		});
+		super('computed', undefined as never);
 
-		this.state = {
-			computeds: new Set(),
-			dirty: true,
-			effect: undefined as never,
-			effects: new Set(),
-			subscriptions: new Map(),
-			value: undefined as never,
-		};
-
-		this.state.effect = effect(() => {
-			if (this.state.dirty) {
+		this.effect.instance = effect(() => {
+			if (this.effect.dirty) {
 				const previousComputed = activeComputed;
 
-				activeComputed = this;
+				activeComputed = this as never;
 
 				const value = callback();
 
@@ -56,7 +37,7 @@ export class Computed<Value> {
 					this.state.value = value;
 
 					for (const computed of this.state.computeds) {
-						computed.state.dirty = true;
+						computed.effect.dirty = true;
 					}
 
 					for (const effect of this.state.effects) {
@@ -68,7 +49,7 @@ export class Computed<Value> {
 					}
 				}
 
-				this.state.dirty = false;
+				this.effect.dirty = false;
 			}
 		});
 	}
@@ -81,37 +62,16 @@ export class Computed<Value> {
 			this.state.computeds.add(activeComputed);
 		}
 
-		if (activeEffect != null && activeEffect !== this.state.effect) {
+		if (activeEffect != null && activeEffect !== this.effect.instance) {
 			this.state.effects.add(activeEffect);
 		}
 
-		if (this.state.dirty && batchDepth === 0) {
-			runEffect(this.state.effect);
+		if (this.effect.dirty && batchDepth === 0) {
+			runEffect(this.effect.instance);
 		}
 
 		return this.state.value;
 	}
-
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value {
-		return this.state.value;
-	}
-
-	/**
-	 * Subscribe to changes
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe {
-		return subscribe(this.state, callback);
-	}
-
-	/**
-	 * Unsubscribe from changes
-	 */
-	unsubscribe(callback: (value: Value) => void): void {
-		unsubscribe(this.state, callback);
-	}
 }
 
 /**

package/src/is.ts

@@ -1,6 +1,7 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import type {Computed} from './computed';
 import type {Effect} from './effect';
+import type {Reactive} from './reactive';
 import type {Signal} from './signal';
 
 /**
@@ -26,6 +27,10 @@ function isMora<T>(value: unknown, name: string): value is T {
 	);
 }
 
+export function isReactive(value: unknown): value is Reactive<unknown> {
+	return isComputed(value) || isSignal(value);
+}
+
 /**
  * Is the value a signal?
  */

package/src/reactive.ts

@@ -0,0 +1,53 @@
+import type {Computed} from './computed';
+import type {Effect} from './effect';
+import {
+	type Subscription,
+	type Unsubscribe,
+	subscribe,
+	unsubscribe,
+} from './subscription';
+
+export abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value> = {
+		computeds: new Set(),
+		effects: new Set(),
+		subscriptions: new Map(),
+		value: undefined as never,
+	};
+
+	constructor(name: string, value: Value) {
+		this.state.value = value;
+
+		Object.defineProperty(this, '$mora', {
+			value: name,
+		});
+	}
+
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value {
+		return this.state.value;
+	}
+
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe {
+		return subscribe(this.state, callback);
+	}
+
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void {
+		unsubscribe(this.state, callback);
+	}
+}
+
+export type ReactiveState<Value> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	value: Value;
+};

package/src/signal.ts

@@ -1,37 +1,11 @@
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {batchDepth, batchedHandlers, flushEffects} from './batch';
-import {type Computed, type InternalComputed, activeComputed} from './computed';
-import {type Effect, activeEffect} from './effect';
-import {
-	type Subscription,
-	type Unsubscribe,
-	subscribe,
-	unsubscribe,
-} from './subscription';
-
-export type SignalState<Value> = {
-	computeds: Set<Computed<unknown>>;
-	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
-	value: Value;
-};
-
-export class Signal<Value> {
-	private declare readonly $mora: string;
-
-	private readonly state: SignalState<Value>;
+import {type InternalComputed, activeComputed} from './computed';
+import {activeEffect} from './effect';
+import {Reactive} from './reactive';
 
+export class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value) {
-		Object.defineProperty(this, '$mora', {
-			value: 'signal',
-		});
-
-		this.state = {
-			value,
-			computeds: new Set(),
-			effects: new Set(),
-			subscriptions: new Map(),
-		};
+		super('signal', value);
 	}
 
 	/**
@@ -49,13 +23,6 @@ export class Signal<Value> {
 		return this.state.value;
 	}
 
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value {
-		return this.state.value;
-	}
-
 	/**
 	 * Set the value
 	 */
@@ -67,7 +34,7 @@ export class Signal<Value> {
 		this.state.value = value;
 
 		for (const computed of this.state.computeds) {
-			(computed as unknown as InternalComputed).state.dirty = true;
+			(computed as unknown as InternalComputed).effect.dirty = true;
 		}
 
 		for (const effect of this.state.effects) {
@@ -75,7 +42,7 @@ export class Signal<Value> {
 		}
 
 		for (const [, subscription] of this.state.subscriptions) {
-			batchedHandlers.add(subscription);
+			batchedHandlers.add(subscription as never);
 		}
 
 		if (batchDepth === 0) {
@@ -83,20 +50,6 @@ export class Signal<Value> {
 		}
 	}
 
-	/**
-	 * Subscribe to changes
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe {
-		return subscribe(this.state, callback);
-	}
-
-	/**
-	 * Unsubscribe from changes
-	 */
-	unsubscribe(callback: (value: Value) => void): void {
-		unsubscribe(this.state, callback);
-	}
-
 	/**
 	 * Update the value
 	 */

package/src/subscription.ts

@@ -1,23 +1,25 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import type {ComputedState} from './computed';
-import type {SignalState} from './signal';
+import type {ReactiveState} from './reactive';
 
-export class Subscription {
+export class Subscription<Value> {
 	constructor(
-		public state: ComputedState<unknown> | SignalState<unknown>,
+		public state: ReactiveState<Value>,
 		public callback: GenericCallback,
 	) {
 		callback(state.value);
 	}
 }
 
+/**
+ * Unsubscribe from changes
+ */
 export type Unsubscribe = () => void;
 
 export function noop(): void {}
 
-export function subscribe(
-	state: ComputedState<unknown> | SignalState<unknown>,
-	callback: GenericCallback,
+export function subscribe<Value>(
+	state: ReactiveState<Value>,
+	callback: (value: Value) => void,
 ): Unsubscribe {
 	if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
 		return noop;
@@ -30,9 +32,9 @@ export function subscribe(
 	};
 }
 
-export function unsubscribe(
-	state: ComputedState<unknown> | SignalState<unknown>,
-	callback: GenericCallback,
+export function unsubscribe<Value>(
+	state: ReactiveState<Value>,
+	callback: (value: Value) => void,
 ): void {
 	const subscription = state.subscriptions.get(callback);
 

package/types/batch.d.cts

@@ -6,22 +6,17 @@ declare class Effect {
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
-export type ComputedState<Value> = {
-	computeds: Set<Computed<unknown>>;
-	dirty: boolean;
-	effect: Effect;
-	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
-	value: Value;
-};
-declare class Computed<Value> {
-	private readonly $mora;
-	private readonly state;
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
 	constructor(callback: () => Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
+}
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value _(without reactivity)_
 	 */
@@ -35,17 +30,20 @@ declare class Computed<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type SignalState<Value> = {
+export type ReactiveState<Value> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
-declare class Subscription {
-	state: ComputedState<unknown> | SignalState<unknown>;
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ComputedState<unknown> | SignalState<unknown>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
+/**
+ * Unsubscribe from changes
+ */
 export type Unsubscribe = () => void;
 export declare function flushEffects(): void;
 /**
@@ -56,7 +54,7 @@ export declare function startBatch(): void;
  * Stop batching effects and flush _(run)_ them
  */
 export declare function stopBatch(): void;
-export declare const batchedHandlers: Set<Effect | Subscription>;
+export declare const batchedHandlers: Set<Effect | Subscription<unknown>>;
 export declare let batchDepth: number;
 
 export {};

package/types/batch.d.ts

@@ -9,5 +9,5 @@ export declare function startBatch(): void;
  * Stop batching effects and flush _(run)_ them
  */
 export declare function stopBatch(): void;
-export declare const batchedHandlers: Set<Effect | Subscription>;
+export declare const batchedHandlers: Set<Effect | Subscription<unknown>>;
 export declare let batchDepth: number;

package/types/computed.d.cts

@@ -6,26 +6,30 @@ declare class Effect {
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
-export type ComputedState<Value> = {
-	computeds: Set<Computed<unknown>>;
+export type ComputedEffect = {
 	dirty: boolean;
-	effect: Effect;
-	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
-	value: Value;
+	instance: Effect;
 };
 export type InternalComputed = {
-	readonly state: ComputedState<unknown>;
+	readonly effect: ComputedEffect;
+	readonly state: ReactiveState<unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
-export declare class Computed<Value> {
-	private readonly $mora;
-	private readonly state;
+export declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
 	constructor(callback: () => Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
+}
+/**
+ * Create a computed value
+ */
+export declare function computed<Value>(callback: () => Value): Computed<Value>;
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value _(without reactivity)_
 	 */
@@ -39,21 +43,20 @@ export declare class Computed<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-/**
- * Create a computed value
- */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export type SignalState<Value> = {
+export type ReactiveState<Value> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
-	subscriptions: Map<GenericCallback, Subscription>;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
-declare class Subscription {
-	state: ComputedState<unknown> | SignalState<unknown>;
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ComputedState<unknown> | SignalState<unknown>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
+/**
+ * Unsubscribe from changes
+ */
 export type Unsubscribe = () => void;
 
 export {};

package/types/computed.d.ts

@@ -1,40 +1,24 @@
-import type { GenericCallback } from '@oscarpalmer/atoms/models';
 import { type Effect } from './effect';
-import { type Subscription, type Unsubscribe } from './subscription';
-export type ComputedState<Value> = {
-    computeds: Set<Computed<unknown>>;
+import { Reactive, type ReactiveState } from './reactive';
+type ComputedEffect = {
     dirty: boolean;
-    effect: Effect;
-    effects: Set<Effect>;
-    subscriptions: Map<GenericCallback, Subscription>;
-    value: Value;
+    instance: Effect;
 };
 export type InternalComputed = {
-    readonly state: ComputedState<unknown>;
+    readonly effect: ComputedEffect;
+    readonly state: ReactiveState<unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
-export declare class Computed<Value> {
-    private readonly $mora;
-    private readonly state;
+export declare class Computed<Value> extends Reactive<Value> {
+    private readonly effect;
     constructor(callback: () => Value);
     /**
      * Get the value
      */
     get(): Value;
-    /**
-     * Get the value _(without reactivity)_
-     */
-    peek(): Value;
-    /**
-     * Subscribe to changes
-     */
-    subscribe(callback: (value: Value) => void): Unsubscribe;
-    /**
-     * Unsubscribe from changes
-     */
-    unsubscribe(callback: (value: Value) => void): void;
 }
 /**
  * Create a computed value
  */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
+export {};

package/types/index.d.cts

@@ -10,14 +10,21 @@ export declare class Effect {
  * Create an effect
  */
 export declare function effect(callback: GenericCallback): Effect;
-export declare class Computed<Value> {
-	private readonly $mora;
-	private readonly state;
+export declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
 	constructor(callback: () => Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
+}
+/**
+ * Create a computed value
+ */
+export declare function computed<Value>(callback: () => Value): Computed<Value>;
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value _(without reactivity)_
 	 */
@@ -31,41 +38,37 @@ export declare class Computed<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
+export type ReactiveState<Value> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	value: Value;
+};
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+}
 /**
- * Create a computed value
+ * Unsubscribe from changes
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export declare class Signal<Value> {
-	private readonly $mora;
-	private readonly state;
+export type Unsubscribe = () => void;
+export declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value;
 	/**
 	 * Set the value
 	 */
 	set(value: Value): void;
-	/**
-	 * Subscribe to changes
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
-	/**
-	 * Unsubscribe from changes
-	 */
-	unsubscribe(callback: (value: Value) => void): void;
 	/**
 	 * Update the value
 	 */
 	update(callback: (value: Value) => Value): void;
 }
 export declare function signal<Value>(value: Value): Signal<Value>;
-export type Unsubscribe = () => void;
 /**
  * Is the value a computed signal?
  */

package/types/is.d.cts

@@ -6,14 +6,17 @@ declare class Effect {
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
-declare class Computed<Value> {
-	private readonly $mora;
-	private readonly state;
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
 	constructor(callback: () => Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
+}
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value _(without reactivity)_
 	 */
@@ -27,36 +30,36 @@ declare class Computed<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-declare class Signal<Value> {
-	private readonly $mora;
-	private readonly state;
+export type ReactiveState<Value> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	value: Value;
+};
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value;
 	/**
 	 * Set the value
 	 */
 	set(value: Value): void;
-	/**
-	 * Subscribe to changes
-	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
-	/**
-	 * Unsubscribe from changes
-	 */
-	unsubscribe(callback: (value: Value) => void): void;
 	/**
 	 * Update the value
 	 */
 	update(callback: (value: Value) => Value): void;
 }
-export type Unsubscribe = () => void;
 /**
  * Is the value a computed signal?
  */
@@ -65,6 +68,7 @@ export declare function isComputed(value: unknown): value is Computed<unknown>;
  * Is the value an effect?
  */
 export declare function isEffect(value: unknown): value is Effect;
+export declare function isReactive(value: unknown): value is Reactive<unknown>;
 /**
  * Is the value a signal?
  */