@oscarpalmer/mora 0.8.0 → 0.10.0

package/src/batch.ts

@@ -1,13 +1,19 @@
-import {dirtyEffects, runEffect} from './effect';
+import {type Effect, runEffect} from './effect';
+import {isEffect} from './is';
+import type {Subscription} from './subscription';
 
 export function flushEffects(): void {
-	while (batchDepth === 0 && dirtyEffects.size > 0) {
-		const effects = [...dirtyEffects];
+	while (batchDepth === 0 && batchedHandlers.size > 0) {
+		const handlers = [...batchedHandlers];
 
-		dirtyEffects.clear();
+		batchedHandlers.clear();
 
-		for (const effect of effects) {
-			runEffect(effect);
+		for (const handler of handlers) {
+			if (isEffect(handler)) {
+				runEffect(handler);
+			} else {
+				handler.callback(handler.state.value);
+			}
 		}
 	}
 }
@@ -30,4 +36,6 @@ export function stopBatch(): void {
 	flushEffects();
 }
 
+export const batchedHandlers = new Set<Effect | Subscription>();
+
 export let batchDepth = 0;

package/src/computed.ts

@@ -1,17 +1,19 @@
-import {batchDepth} from './batch';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {batchDepth, batchedHandlers} from './batch';
+import {type Effect, activeEffect, effect, runEffect} from './effect';
 import {
-	type Effect,
-	activeEffect,
-	dirtyEffects,
-	effect,
-	runEffect,
-} from './effect';
-
-type ComputedState<Value> = {
+	type Subscription,
+	type Unsubscribe,
+	subscribe,
+	unsubscribe,
+} from './subscription';
+
+export type ComputedState<Value> = {
 	computeds: Set<Computed<unknown>>;
 	dirty: boolean;
 	effect: Effect;
 	effects: Set<Effect>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
 
@@ -22,14 +24,21 @@ export type InternalComputed = {
 export let activeComputed: Computed<unknown> | undefined;
 
 export class Computed<Value> {
+	private declare readonly $mora: string;
+
 	private readonly state: ComputedState<Value>;
 
 	constructor(callback: () => Value) {
+		Object.defineProperty(this, '$mora', {
+			value: 'computed',
+		});
+
 		this.state = {
 			computeds: new Set(),
 			dirty: true,
 			effect: undefined as never,
 			effects: new Set(),
+			subscriptions: new Map(),
 			value: undefined as never,
 		};
 
@@ -51,7 +60,11 @@ export class Computed<Value> {
 					}
 
 					for (const effect of this.state.effects) {
-						dirtyEffects.add(effect);
+						batchedHandlers.add(effect);
+					}
+
+					for (const [, subscription] of this.state.subscriptions) {
+						subscription.callback(value);
 					}
 				}
 
@@ -85,6 +98,20 @@ export class Computed<Value> {
 	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/effect.ts

@@ -9,16 +9,22 @@ type InternalEffect = {
 };
 
 export class Effect {
-	private declare readonly state: EffectState;
+		private declare readonly $mora: string;
 
-	constructor(callback: GenericCallback) {
-		this.state = {
-			callback,
-		};
+		private declare readonly state: EffectState;
 
-		runEffect(this);
+		constructor(callback: GenericCallback) {
+			Object.defineProperty(this, '$mora', {
+				value: 'effect',
+			});
+
+			this.state = {
+				callback,
+			};
+
+			runEffect(this);
+		}
 	}
-}
 
 export function runEffect(effect: Effect): void {
 	const previousEffect = activeEffect;
@@ -40,5 +46,3 @@ export function effect(callback: GenericCallback): Effect {
 }
 
 export let activeEffect: Effect | undefined;
-
-export const dirtyEffects = new Set<Effect>();

package/src/index.ts

@@ -1,4 +1,5 @@
 export {startBatch, stopBatch} from './batch';
 export {computed, type Computed} from './computed';
 export {effect, type Effect} from './effect';
+export {isComputed, isEffect, isSignal} from './is';
 export {signal, type Signal} from './signal';

package/src/is.ts

@@ -0,0 +1,34 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {Computed} from './computed';
+import type {Effect} from './effect';
+import type {Signal} from './signal';
+
+/**
+ * Is the value a computed signal?
+ */
+export function isComputed(value: unknown): value is Computed<unknown> {
+	return isMora<Computed<unknown>>(value, 'computed');
+}
+
+/**
+ * Is the value an effect?
+ */
+export function isEffect(value: unknown): value is Effect {
+	return isMora<Effect>(value, 'effect');
+}
+
+function isMora<T>(value: unknown, name: string): value is T {
+	return (
+		typeof value === 'object' &&
+		value != null &&
+		'$mora' in value &&
+		(value as PlainObject).$mora === name
+	);
+}
+
+/**
+ * Is the value a signal?
+ */
+export function isSignal(value: unknown): value is Signal<unknown> {
+	return isMora<Signal<unknown>>(value, 'signal');
+}

package/src/signal.ts

@@ -1,21 +1,36 @@
-import {batchDepth, flushEffects} from './batch';
+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, dirtyEffects} from './effect';
+import {type Effect, activeEffect} from './effect';
+import {
+	type Subscription,
+	type Unsubscribe,
+	subscribe,
+	unsubscribe,
+} from './subscription';
 
-type SignalState<Value> = {
+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>;
 
 	constructor(value: Value) {
+		Object.defineProperty(this, '$mora', {
+			value: 'signal',
+		});
+
 		this.state = {
 			value,
 			computeds: new Set(),
 			effects: new Set(),
+			subscriptions: new Map(),
 		};
 	}
 
@@ -56,7 +71,11 @@ export class Signal<Value> {
 		}
 
 		for (const effect of this.state.effects) {
-			dirtyEffects.add(effect);
+			batchedHandlers.add(effect);
+		}
+
+		for (const [, subscription] of this.state.subscriptions) {
+			batchedHandlers.add(subscription);
 		}
 
 		if (batchDepth === 0) {
@@ -64,6 +83,20 @@ 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

@@ -0,0 +1,45 @@
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import type {ComputedState} from './computed';
+import type {SignalState} from './signal';
+
+export class Subscription {
+	constructor(
+		public state: ComputedState<unknown> | SignalState<unknown>,
+		public callback: GenericCallback,
+	) {
+		callback(state.value);
+	}
+}
+
+export type Unsubscribe = () => void;
+
+export function noop(): void {}
+
+export function subscribe(
+	state: ComputedState<unknown> | SignalState<unknown>,
+	callback: GenericCallback,
+): Unsubscribe {
+	if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
+		return noop;
+	}
+
+	state.subscriptions.set(callback, new Subscription(state, callback));
+
+	return () => {
+		unsubscribe(state, callback);
+	};
+}
+
+export function unsubscribe(
+	state: ComputedState<unknown> | SignalState<unknown>,
+	callback: GenericCallback,
+): void {
+	const subscription = state.subscriptions.get(callback);
+
+	state.subscriptions.delete(callback);
+
+	if (subscription != null) {
+		subscription.callback = noop;
+		subscription.state = undefined as never;
+	}
+}

package/types/batch.d.cts

@@ -1,5 +1,52 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	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;
+	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;
+}
+export type SignalState<Value> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+declare class Subscription {
+	state: ComputedState<unknown> | SignalState<unknown>;
+	callback: GenericCallback;
+	constructor(state: ComputedState<unknown> | SignalState<unknown>, callback: GenericCallback);
+}
+export type Unsubscribe = () => void;
 export declare function flushEffects(): void;
 /**
  * Start batching effects _(use `stopBatch` to flush and run batched effects)_
@@ -9,6 +56,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 let batchDepth: number;
 
 export {};

package/types/batch.d.ts

@@ -1,3 +1,5 @@
+import { type Effect } from './effect';
+import type { Subscription } from './subscription';
 export declare function flushEffects(): void;
 /**
  * Start batching effects _(use `stopBatch` to flush and run batched effects)_
@@ -7,4 +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 let batchDepth: number;

package/types/computed.d.cts

@@ -2,6 +2,7 @@
 
 export type GenericCallback = (...args: any[]) => any;
 declare class Effect {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
@@ -10,6 +11,7 @@ export type ComputedState<Value> = {
 	dirty: boolean;
 	effect: Effect;
 	effects: Set<Effect>;
+	subscriptions: Map<GenericCallback, Subscription>;
 	value: Value;
 };
 export type InternalComputed = {
@@ -17,6 +19,7 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: () => Value);
 	/**
@@ -27,10 +30,30 @@ export declare class Computed<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 type SignalState<Value> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+declare class Subscription {
+	state: ComputedState<unknown> | SignalState<unknown>;
+	callback: GenericCallback;
+	constructor(state: ComputedState<unknown> | SignalState<unknown>, callback: GenericCallback);
+}
+export type Unsubscribe = () => void;
 
 export {};

package/types/computed.d.ts

@@ -1,9 +1,12 @@
+import type { GenericCallback } from '@oscarpalmer/atoms/models';
 import { type Effect } from './effect';
-type ComputedState<Value> = {
+import { type Subscription, type Unsubscribe } from './subscription';
+export type ComputedState<Value> = {
     computeds: Set<Computed<unknown>>;
     dirty: boolean;
     effect: Effect;
     effects: Set<Effect>;
+    subscriptions: Map<GenericCallback, Subscription>;
     value: Value;
 };
 export type InternalComputed = {
@@ -11,6 +14,7 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
+    private readonly $mora;
     private readonly state;
     constructor(callback: () => Value);
     /**
@@ -21,9 +25,16 @@ export declare class Computed<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/effect.d.cts

@@ -2,6 +2,7 @@
 
 export type GenericCallback = (...args: any[]) => any;
 export declare class Effect {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
@@ -11,6 +12,5 @@ export declare function runEffect(effect: Effect): void;
  */
 export declare function effect(callback: GenericCallback): Effect;
 export declare let activeEffect: Effect | undefined;
-export declare const dirtyEffects: Set<Effect>;
 
 export {};

package/types/effect.d.ts

@@ -1,5 +1,6 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
 export declare class Effect {
+    private readonly $mora;
     private readonly state;
     constructor(callback: GenericCallback);
 }
@@ -9,4 +10,3 @@ export declare function runEffect(effect: Effect): void;
  */
 export declare function effect(callback: GenericCallback): Effect;
 export declare let activeEffect: Effect | undefined;
-export declare const dirtyEffects: Set<Effect>;

package/types/index.d.cts

@@ -1,6 +1,42 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export type GenericCallback = (...args: any[]) => any;
+export declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+/**
+ * Create an effect
+ */
+export declare function effect(callback: GenericCallback): Effect;
+export declare class Computed<Value> {
+	private readonly $mora;
+	private readonly state;
+	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 declare class Signal<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(value: Value);
 	/**
@@ -15,44 +51,40 @@ export declare class Signal<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;
 /**
- * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ * Is the value a computed signal?
  */
-export declare function startBatch(): void;
+export declare function isComputed(value: unknown): value is Computed<unknown>;
 /**
- * Stop batching effects and flush _(run)_ them
+ * Is the value an effect?
  */
-export declare function stopBatch(): void;
-export type GenericCallback = (...args: any[]) => any;
-export declare class Effect {
-	private readonly state;
-	constructor(callback: GenericCallback);
-}
+export declare function isEffect(value: unknown): value is Effect;
 /**
- * Create an effect
+ * Is the value a signal?
  */
-export declare function effect(callback: GenericCallback): Effect;
-export declare class Computed<Value> {
-	private readonly state;
-	constructor(callback: () => Value);
-	/**
-	 * Get the value
-	 */
-	get(): Value;
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value;
-}
+export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**
- * Create a computed value
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
 
 export {};

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export { startBatch, stopBatch } from './batch';
 export { computed, type Computed } from './computed';
 export { effect, type Effect } from './effect';
+export { isComputed, isEffect, isSignal } from './is';
 export { signal, type Signal } from './signal';