@oscarpalmer/mora 0.9.0 → 0.10.0

package/dist/batch.cjs

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const effect = require("./effect.cjs");
+const is = require("./is.cjs");
 function flushEffects() {
-  while (exports.batchDepth === 0 && effect.dirtyEffects.size > 0) {
-    const effects = [...effect.dirtyEffects];
-    effect.dirtyEffects.clear();
-    for (const effect$1 of effects) {
-      effect.runEffect(effect$1);
+  while (exports.batchDepth === 0 && batchedHandlers.size > 0) {
+    const handlers = [...batchedHandlers];
+    batchedHandlers.clear();
+    for (const handler of handlers) {
+      if (is.isEffect(handler)) {
+        effect.runEffect(handler);
+      } else {
+        handler.callback(handler.state.value);
+      }
     }
   }
 }
@@ -19,7 +24,9 @@ function stopBatch() {
   }
   flushEffects();
 }
+const batchedHandlers = /* @__PURE__ */ new Set();
 exports.batchDepth = 0;
+exports.batchedHandlers = batchedHandlers;
 exports.flushEffects = flushEffects;
 exports.startBatch = startBatch;
 exports.stopBatch = stopBatch;

package/dist/batch.js

@@ -1,10 +1,15 @@
-import { dirtyEffects, runEffect } from "./effect.js";
+import { runEffect } from "./effect.js";
+import { isEffect } from "./is.js";
 function flushEffects() {
-  while (batchDepth === 0 && dirtyEffects.size > 0) {
-    const effects = [...dirtyEffects];
-    dirtyEffects.clear();
-    for (const effect of effects) {
-      runEffect(effect);
+  while (batchDepth === 0 && batchedHandlers.size > 0) {
+    const handlers = [...batchedHandlers];
+    batchedHandlers.clear();
+    for (const handler of handlers) {
+      if (isEffect(handler)) {
+        runEffect(handler);
+      } else {
+        handler.callback(handler.state.value);
+      }
     }
   }
 }
@@ -17,9 +22,11 @@ function stopBatch() {
   }
   flushEffects();
 }
+const batchedHandlers = /* @__PURE__ */ new Set();
 let batchDepth = 0;
 export {
   batchDepth,
+  batchedHandlers,
   flushEffects,
   startBatch,
   stopBatch

package/dist/computed.cjs

@@ -5,6 +5,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batch = require("./batch.cjs");
 const effect = require("./effect.cjs");
+const subscription = require("./subscription.cjs");
 exports.activeComputed = void 0;
 class Computed {
   constructor(callback) {
@@ -17,6 +18,7 @@ class Computed {
       dirty: true,
       effect: void 0,
       effects: /* @__PURE__ */ new Set(),
+      subscriptions: /* @__PURE__ */ new Map(),
       value: void 0
     };
     this.state.effect = effect.effect(() => {
@@ -31,7 +33,10 @@ class Computed {
             computed2.state.dirty = true;
           }
           for (const effect2 of this.state.effects) {
-            effect.dirtyEffects.add(effect2);
+            batch.batchedHandlers.add(effect2);
+          }
+          for (const [, subscription2] of this.state.subscriptions) {
+            subscription2.callback(value);
           }
         }
         this.state.dirty = false;
@@ -59,6 +64,18 @@ class Computed {
   peek() {
     return this.state.value;
   }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(callback) {
+    return subscription.subscribe(this.state, callback);
+  }
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(callback) {
+    subscription.unsubscribe(this.state, callback);
+  }
 }
 function computed(callback) {
   return new Computed(callback);

package/dist/computed.js

@@ -1,8 +1,9 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { batchDepth } from "./batch.js";
-import { effect, dirtyEffects, activeEffect, runEffect } from "./effect.js";
+import { batchedHandlers, batchDepth } from "./batch.js";
+import { effect, activeEffect, runEffect } from "./effect.js";
+import { subscribe, unsubscribe } from "./subscription.js";
 let activeComputed;
 class Computed {
   constructor(callback) {
@@ -15,6 +16,7 @@ class Computed {
       dirty: true,
       effect: void 0,
       effects: /* @__PURE__ */ new Set(),
+      subscriptions: /* @__PURE__ */ new Map(),
       value: void 0
     };
     this.state.effect = effect(() => {
@@ -29,7 +31,10 @@ class Computed {
             computed2.state.dirty = true;
           }
           for (const effect2 of this.state.effects) {
-            dirtyEffects.add(effect2);
+            batchedHandlers.add(effect2);
+          }
+          for (const [, subscription] of this.state.subscriptions) {
+            subscription.callback(value);
           }
         }
         this.state.dirty = false;
@@ -57,6 +62,18 @@ class Computed {
   peek() {
     return this.state.value;
   }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(callback) {
+    return subscribe(this.state, callback);
+  }
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(callback) {
+    unsubscribe(this.state, callback);
+  }
 }
 function computed(callback) {
   return new Computed(callback);

package/dist/effect.cjs

@@ -24,8 +24,6 @@ function effect(callback) {
   return new Effect(callback);
 }
 exports.activeEffect = void 0;
-const dirtyEffects = /* @__PURE__ */ new Set();
 exports.Effect = Effect;
-exports.dirtyEffects = dirtyEffects;
 exports.effect = effect;
 exports.runEffect = runEffect;

package/dist/effect.js

@@ -22,11 +22,9 @@ function effect(callback) {
   return new Effect(callback);
 }
 let activeEffect;
-const dirtyEffects = /* @__PURE__ */ new Set();
 export {
   Effect,
   activeEffect,
-  dirtyEffects,
   effect,
   runEffect
 };

package/dist/mora.full.js

@@ -26,14 +26,43 @@ function effect(callback) {
     return new Effect(callback);
 }
 let activeEffect;
-const dirtyEffects = new Set();
+
+/**
+ * Is the value a computed signal?
+ */
+function isComputed(value) {
+    return isMora(value, 'computed');
+}
+/**
+ * Is the value an effect?
+ */
+function isEffect(value) {
+    return isMora(value, 'effect');
+}
+function isMora(value, name) {
+    return (typeof value === 'object' &&
+        value != null &&
+        '$mora' in value &&
+        value.$mora === name);
+}
+/**
+ * Is the value a signal?
+ */
+function isSignal(value) {
+    return isMora(value, 'signal');
+}
 
 function flushEffects() {
-    while (batchDepth === 0 && dirtyEffects.size > 0) {
-        const effects = [...dirtyEffects];
-        dirtyEffects.clear();
-        for (const effect of effects) {
-            runEffect(effect);
+    while (batchDepth === 0 && batchedHandlers.size > 0) {
+        const handlers = [...batchedHandlers];
+        batchedHandlers.clear();
+        for (const handler of handlers) {
+            if (isEffect(handler)) {
+                runEffect(handler);
+            }
+            else {
+                handler.callback(handler.state.value);
+            }
         }
     }
 }
@@ -52,8 +81,37 @@ function stopBatch() {
     }
     flushEffects();
 }
+const batchedHandlers = new Set();
 let batchDepth = 0;
 
+class Subscription {
+    state;
+    callback;
+    constructor(state, callback) {
+        this.state = state;
+        this.callback = callback;
+        callback(state.value);
+    }
+}
+function noop() { }
+function subscribe(state, callback) {
+    if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
+        return noop;
+    }
+    state.subscriptions.set(callback, new Subscription(state, callback));
+    return () => {
+        unsubscribe(state, callback);
+    };
+}
+function unsubscribe(state, callback) {
+    const subscription = state.subscriptions.get(callback);
+    state.subscriptions.delete(callback);
+    if (subscription != null) {
+        subscription.callback = noop;
+        subscription.state = undefined;
+    }
+}
+
 let activeComputed;
 class Computed {
     state;
@@ -66,6 +124,7 @@ class Computed {
             dirty: true,
             effect: undefined,
             effects: new Set(),
+            subscriptions: new Map(),
             value: undefined,
         };
         this.state.effect = effect(() => {
@@ -80,7 +139,10 @@ class Computed {
                         computed.state.dirty = true;
                     }
                     for (const effect of this.state.effects) {
-                        dirtyEffects.add(effect);
+                        batchedHandlers.add(effect);
+                    }
+                    for (const [, subscription] of this.state.subscriptions) {
+                        subscription.callback(value);
                     }
                 }
                 this.state.dirty = false;
@@ -108,6 +170,18 @@ class Computed {
     peek() {
         return this.state.value;
     }
+    /**
+     * Subscribe to changes
+     */
+    subscribe(callback) {
+        return subscribe(this.state, callback);
+    }
+    /**
+     * Unsubscribe from changes
+     */
+    unsubscribe(callback) {
+        unsubscribe(this.state, callback);
+    }
 }
 /**
  * Create a computed value
@@ -116,31 +190,6 @@ function computed(callback) {
     return new Computed(callback);
 }
 
-/**
- * Is the value a computed signal?
- */
-function isComputed(value) {
-    return isMora(value, 'computed');
-}
-/**
- * Is the value an effect?
- */
-function isEffect(value) {
-    return isMora(value, 'effect');
-}
-function isMora(value, name) {
-    return (typeof value === 'object' &&
-        value != null &&
-        '$mora' in value &&
-        value.$mora === name);
-}
-/**
- * Is the value a signal?
- */
-function isSignal(value) {
-    return isMora(value, 'signal');
-}
-
 class Signal {
     state;
     constructor(value) {
@@ -151,6 +200,7 @@ class Signal {
             value,
             computeds: new Set(),
             effects: new Set(),
+            subscriptions: new Map(),
         };
     }
     /**
@@ -183,12 +233,27 @@ class Signal {
             computed.state.dirty = true;
         }
         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) {
             flushEffects();
         }
     }
+    /**
+     * Subscribe to changes
+     */
+    subscribe(callback) {
+        return subscribe(this.state, callback);
+    }
+    /**
+     * Unsubscribe from changes
+     */
+    unsubscribe(callback) {
+        unsubscribe(this.state, callback);
+    }
     /**
      * Update the value
      */

package/dist/signal.cjs

@@ -6,6 +6,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
+const subscription = require("./subscription.cjs");
 class Signal {
   constructor(value) {
     __publicField(this, "state");
@@ -15,7 +16,8 @@ class Signal {
     this.state = {
       value,
       computeds: /* @__PURE__ */ new Set(),
-      effects: /* @__PURE__ */ new Set()
+      effects: /* @__PURE__ */ new Set(),
+      subscriptions: /* @__PURE__ */ new Map()
     };
   }
   /**
@@ -47,13 +49,28 @@ class Signal {
     for (const computed2 of this.state.computeds) {
       computed2.state.dirty = true;
     }
-    for (const effect$1 of this.state.effects) {
-      effect.dirtyEffects.add(effect$1);
+    for (const effect2 of this.state.effects) {
+      batch.batchedHandlers.add(effect2);
+    }
+    for (const [, subscription2] of this.state.subscriptions) {
+      batch.batchedHandlers.add(subscription2);
     }
     if (batch.batchDepth === 0) {
       batch.flushEffects();
     }
   }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(callback) {
+    return subscription.subscribe(this.state, callback);
+  }
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(callback) {
+    subscription.unsubscribe(this.state, callback);
+  }
   /**
    * Update the value
    */

package/dist/signal.js

@@ -1,9 +1,10 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { flushEffects, batchDepth } from "./batch.js";
+import { batchedHandlers, flushEffects, batchDepth } from "./batch.js";
 import { activeComputed } from "./computed.js";
-import { activeEffect, dirtyEffects } from "./effect.js";
+import { activeEffect } from "./effect.js";
+import { subscribe, unsubscribe } from "./subscription.js";
 class Signal {
   constructor(value) {
     __publicField(this, "state");
@@ -13,7 +14,8 @@ class Signal {
     this.state = {
       value,
       computeds: /* @__PURE__ */ new Set(),
-      effects: /* @__PURE__ */ new Set()
+      effects: /* @__PURE__ */ new Set(),
+      subscriptions: /* @__PURE__ */ new Map()
     };
   }
   /**
@@ -46,12 +48,27 @@ class Signal {
       computed.state.dirty = true;
     }
     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) {
       flushEffects();
     }
   }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(callback) {
+    return subscribe(this.state, callback);
+  }
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(callback) {
+    unsubscribe(this.state, callback);
+  }
   /**
    * Update the value
    */

package/dist/subscription.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class Subscription {
+  constructor(state, callback) {
+    this.state = state;
+    this.callback = callback;
+    callback(state.value);
+  }
+}
+function noop() {
+}
+function subscribe(state, callback) {
+  if (typeof callback !== "function" || state.subscriptions.has(callback)) {
+    return noop;
+  }
+  state.subscriptions.set(callback, new Subscription(state, callback));
+  return () => {
+    unsubscribe(state, callback);
+  };
+}
+function unsubscribe(state, callback) {
+  const subscription = state.subscriptions.get(callback);
+  state.subscriptions.delete(callback);
+  if (subscription != null) {
+    subscription.callback = noop;
+    subscription.state = void 0;
+  }
+}
+exports.Subscription = Subscription;
+exports.noop = noop;
+exports.subscribe = subscribe;
+exports.unsubscribe = unsubscribe;

package/dist/subscription.js

@@ -0,0 +1,32 @@
+class Subscription {
+  constructor(state, callback) {
+    this.state = state;
+    this.callback = callback;
+    callback(state.value);
+  }
+}
+function noop() {
+}
+function subscribe(state, callback) {
+  if (typeof callback !== "function" || state.subscriptions.has(callback)) {
+    return noop;
+  }
+  state.subscriptions.set(callback, new Subscription(state, callback));
+  return () => {
+    unsubscribe(state, callback);
+  };
+}
+function unsubscribe(state, callback) {
+  const subscription = state.subscriptions.get(callback);
+  state.subscriptions.delete(callback);
+  if (subscription != null) {
+    subscription.callback = noop;
+    subscription.state = void 0;
+  }
+}
+export {
+  Subscription,
+  noop,
+  subscribe,
+  unsubscribe
+};

package/package.json

@@ -54,5 +54,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.9.0"
+	"version": "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;