@oscarpalmer/mora 0.3.0 → 0.5.0

package/dist/batch.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const effect = require("./effect.cjs");
+function flushEffects() {
+  while (effect.dirtyEffects.size > 0) {
+    const effects = [...effect.dirtyEffects];
+    effect.dirtyEffects.clear();
+    for (const effect$1 of effects) {
+      effect.runEffect(effect$1);
+    }
+  }
+}
+function startBatch() {
+  exports.batchDepth += 1;
+}
+function stopBatch() {
+  if (exports.batchDepth > 0) {
+    exports.batchDepth -= 1;
+  }
+  if (exports.batchDepth === 0) {
+    flushEffects();
+  }
+}
+exports.batchDepth = 0;
+exports.flushEffects = flushEffects;
+exports.startBatch = startBatch;
+exports.stopBatch = stopBatch;

package/dist/batch.js

@@ -0,0 +1,28 @@
+import { dirtyEffects, runEffect } from "./effect.js";
+function flushEffects() {
+  while (dirtyEffects.size > 0) {
+    const effects = [...dirtyEffects];
+    dirtyEffects.clear();
+    for (const effect of effects) {
+      runEffect(effect);
+    }
+  }
+}
+function startBatch() {
+  batchDepth += 1;
+}
+function stopBatch() {
+  if (batchDepth > 0) {
+    batchDepth -= 1;
+  }
+  if (batchDepth === 0) {
+    flushEffects();
+  }
+}
+let batchDepth = 0;
+export {
+  batchDepth,
+  flushEffects,
+  startBatch,
+  stopBatch
+};

package/dist/computed.cjs

@@ -4,28 +4,51 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const effect = require("./effect.cjs");
-class Computed extends effect.Effect {
+exports.activeComputed = void 0;
+class Computed {
   constructor(callback) {
-    super();
-    __publicField(this, "dirty", true);
-    __publicField(this, "effects", /* @__PURE__ */ new Set());
-    __publicField(this, "value");
-    this.callback = () => {
-      if (this.dirty) {
-        this.value = callback();
-        this.dirty = false;
-      }
+    __publicField(this, "state");
+    this.state = {
+      computeds: /* @__PURE__ */ new Set(),
+      dirty: true,
+      effect: void 0,
+      effects: /* @__PURE__ */ new Set(),
+      value: void 0
     };
-    effect.runEffect(this);
+    this.state.effect = effect.effect(() => {
+      if (this.state.dirty) {
+        const previousComputed = exports.activeComputed;
+        exports.activeComputed = this;
+        const value = callback();
+        exports.activeComputed = previousComputed;
+        if (!Object.is(this.state.value, value)) {
+          this.state.value = value;
+          for (const comp of this.state.computeds) {
+            comp.state.dirty = true;
+            effect.dirtyEffects.add(comp.state.effect);
+          }
+          for (const effect2 of this.state.effects) {
+            effect.dirtyEffects.add(effect2);
+          }
+        }
+        this.state.dirty = false;
+      }
+    });
   }
+  /**
+   * Get the value
+   */
   get() {
-    if (effect.activeEffect != null && effect.activeEffect !== this) {
-      this.effects.add(effect.activeEffect);
+    if (exports.activeComputed != null && exports.activeComputed !== this) {
+      this.state.computeds.add(exports.activeComputed);
+    }
+    if (effect.activeEffect != null && effect.activeEffect !== this.state.effect) {
+      this.state.effects.add(effect.activeEffect);
     }
-    if (this.dirty) {
-      effect.runEffect(this);
+    if (this.state.dirty) {
+      effect.runEffect(this.state.effect);
     }
-    return this.value;
+    return this.state.value;
   }
 }
 function computed(callback) {

package/dist/computed.js

@@ -1,29 +1,52 @@
 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 { Effect, runEffect, activeEffect } from "./effect.js";
-class Computed extends Effect {
+import { effect, dirtyEffects, activeEffect, runEffect } from "./effect.js";
+let activeComputed;
+class Computed {
   constructor(callback) {
-    super();
-    __publicField(this, "dirty", true);
-    __publicField(this, "effects", /* @__PURE__ */ new Set());
-    __publicField(this, "value");
-    this.callback = () => {
-      if (this.dirty) {
-        this.value = callback();
-        this.dirty = false;
-      }
+    __publicField(this, "state");
+    this.state = {
+      computeds: /* @__PURE__ */ new Set(),
+      dirty: true,
+      effect: void 0,
+      effects: /* @__PURE__ */ new Set(),
+      value: void 0
     };
-    runEffect(this);
+    this.state.effect = effect(() => {
+      if (this.state.dirty) {
+        const previousComputed = activeComputed;
+        activeComputed = this;
+        const value = callback();
+        activeComputed = previousComputed;
+        if (!Object.is(this.state.value, value)) {
+          this.state.value = value;
+          for (const comp of this.state.computeds) {
+            comp.state.dirty = true;
+            dirtyEffects.add(comp.state.effect);
+          }
+          for (const effect2 of this.state.effects) {
+            dirtyEffects.add(effect2);
+          }
+        }
+        this.state.dirty = false;
+      }
+    });
   }
+  /**
+   * Get the value
+   */
   get() {
-    if (activeEffect != null && activeEffect !== this) {
-      this.effects.add(activeEffect);
+    if (activeComputed != null && activeComputed !== this) {
+      this.state.computeds.add(activeComputed);
+    }
+    if (activeEffect != null && activeEffect !== this.state.effect) {
+      this.state.effects.add(activeEffect);
     }
-    if (this.dirty) {
-      runEffect(this);
+    if (this.state.dirty) {
+      runEffect(this.state.effect);
     }
-    return this.value;
+    return this.state.value;
   }
 }
 function computed(callback) {
@@ -31,5 +54,6 @@ function computed(callback) {
 }
 export {
   Computed,
+  activeComputed,
   computed
 };

package/dist/effect.cjs

@@ -3,32 +3,30 @@ 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);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-exports.activeEffect = void 0;
 class Effect {
-  constructor() {
-    __publicField(this, "callback");
-    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  constructor(callback) {
+    __publicField(this, "state");
+    this.state = {
+      callback
+    };
+    runEffect(this);
   }
 }
 function runEffect(effect2) {
-  for (const signal of effect2.signals) {
-    signal.state.observers.delete(effect2);
-  }
-  effect2.signals.clear();
   const previousEffect = exports.activeEffect;
   exports.activeEffect = effect2;
   try {
-    effect2.callback();
+    effect2.state.callback();
   } finally {
     exports.activeEffect = previousEffect;
   }
 }
 function effect(callback) {
-  const instance = new Effect();
-  instance.callback = callback;
-  runEffect(instance);
-  return instance;
+  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

@@ -1,35 +1,33 @@
 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);
-let activeEffect;
 class Effect {
-  constructor() {
-    __publicField(this, "callback");
-    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  constructor(callback) {
+    __publicField(this, "state");
+    this.state = {
+      callback
+    };
+    runEffect(this);
   }
 }
 function runEffect(effect2) {
-  for (const signal of effect2.signals) {
-    signal.state.observers.delete(effect2);
-  }
-  effect2.signals.clear();
   const previousEffect = activeEffect;
   activeEffect = effect2;
   try {
-    effect2.callback();
+    effect2.state.callback();
   } finally {
     activeEffect = previousEffect;
   }
 }
 function effect(callback) {
-  const instance = new Effect();
-  instance.callback = callback;
-  runEffect(instance);
-  return instance;
+  return new Effect(callback);
 }
+let activeEffect;
+const dirtyEffects = /* @__PURE__ */ new Set();
 export {
   Effect,
   activeEffect,
+  dirtyEffects,
   effect,
   runEffect
 };

package/dist/index.cjs

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
 const signal = require("./signal.cjs");
+exports.startBatch = batch.startBatch;
+exports.stopBatch = batch.stopBatch;
 exports.computed = computed.computed;
 exports.effect = effect.effect;
 exports.signal = signal.signal;

package/dist/index.js

@@ -1,8 +1,11 @@
+import { startBatch, stopBatch } from "./batch.js";
 import { computed } from "./computed.js";
 import { effect } from "./effect.js";
 import { signal } from "./signal.js";
 export {
   computed,
   effect,
-  signal
+  signal,
+  startBatch,
+  stopBatch
 };

package/dist/mora.full.js

@@ -0,0 +1,162 @@
+class Effect {
+    state;
+    constructor(callback) {
+        this.state = {
+            callback,
+        };
+        runEffect(this);
+    }
+}
+function runEffect(effect) {
+    const previousEffect = activeEffect;
+    activeEffect = effect;
+    try {
+        effect.state.callback();
+    }
+    finally {
+        activeEffect = previousEffect;
+    }
+}
+/**
+ * Create an effect
+ */
+function effect(callback) {
+    return new Effect(callback);
+}
+let activeEffect;
+const dirtyEffects = new Set();
+
+function flushEffects() {
+    while (dirtyEffects.size > 0) {
+        const effects = [...dirtyEffects];
+        dirtyEffects.clear();
+        for (const effect of effects) {
+            runEffect(effect);
+        }
+    }
+}
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+function startBatch() {
+    batchDepth += 1;
+}
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+function stopBatch() {
+    if (batchDepth > 0) {
+        batchDepth -= 1;
+    }
+    if (batchDepth === 0) {
+        flushEffects();
+    }
+}
+let batchDepth = 0;
+
+let activeComputed;
+class Computed {
+    state;
+    constructor(callback) {
+        this.state = {
+            computeds: new Set(),
+            dirty: true,
+            effect: undefined,
+            effects: new Set(),
+            value: undefined,
+        };
+        this.state.effect = effect(() => {
+            if (this.state.dirty) {
+                const previousComputed = activeComputed;
+                activeComputed = this;
+                const value = callback();
+                activeComputed = previousComputed;
+                if (!Object.is(this.state.value, value)) {
+                    this.state.value = value;
+                    for (const comp of this.state.computeds) {
+                        comp.state.dirty = true;
+                        dirtyEffects.add(comp.state.effect);
+                    }
+                    for (const effect of this.state.effects) {
+                        dirtyEffects.add(effect);
+                    }
+                }
+                this.state.dirty = false;
+            }
+        });
+    }
+    /**
+     * Get the value
+     */
+    get() {
+        if (activeComputed != null && activeComputed !== this) {
+            this.state.computeds.add(activeComputed);
+        }
+        if (activeEffect != null && activeEffect !== this.state.effect) {
+            this.state.effects.add(activeEffect);
+        }
+        if (this.state.dirty) {
+            runEffect(this.state.effect);
+        }
+        return this.state.value;
+    }
+}
+/**
+ * Create a computed value
+ */
+function computed(callback) {
+    return new Computed(callback);
+}
+
+class Signal {
+    state;
+    constructor(value) {
+        this.state = {
+            value,
+            computeds: new Set(),
+            effects: new Set(),
+        };
+    }
+    /**
+     * Get the value
+     */
+    get() {
+        if (activeComputed != null) {
+            this.state.computeds.add(activeComputed);
+        }
+        if (activeEffect != null) {
+            this.state.effects.add(activeEffect);
+        }
+        return this.state.value;
+    }
+    /**
+     * Set the value
+     */
+    set(value) {
+        if (Object.is(this.state.value, value)) {
+            return;
+        }
+        this.state.value = value;
+        for (const computed of this.state.computeds) {
+            computed.state.dirty = true;
+            dirtyEffects.add(computed.state.effect);
+        }
+        for (const effect of this.state.effects) {
+            dirtyEffects.add(effect);
+        }
+        if (batchDepth === 0) {
+            flushEffects();
+        }
+    }
+    /**
+     * Update the value
+     */
+    update(callback) {
+        this.set(callback(this.state.value));
+    }
+}
+function signal(value) {
+    return new Signal(value);
+}
+
+export { computed, effect, signal, startBatch, stopBatch };

package/dist/signal.cjs

@@ -3,62 +3,52 @@ 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);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
-const dirtyEffects = /* @__PURE__ */ new Set();
-let batchDepth = 0;
 class Signal {
   constructor(value) {
     __publicField(this, "state");
     this.state = {
       value,
-      observers: /* @__PURE__ */ new Set()
+      computeds: /* @__PURE__ */ new Set(),
+      effects: /* @__PURE__ */ new Set()
     };
   }
+  /**
+   * Get the value
+   */
   get() {
+    if (computed.activeComputed != null) {
+      this.state.computeds.add(computed.activeComputed);
+    }
     if (effect.activeEffect != null) {
-      this.state.observers.add(effect.activeEffect);
-      effect.activeEffect.signals.add(this);
+      this.state.effects.add(effect.activeEffect);
     }
     return this.state.value;
   }
+  /**
+   * Set the value
+   */
   set(value) {
     if (Object.is(this.state.value, value)) {
       return;
     }
     this.state.value = value;
-    const isOutermostBatch = batchDepth === 0;
-    batchDepth += 1;
-    try {
-      for (const observer of this.state.observers) {
-        if (observer instanceof computed.Computed) {
-          observer.dirty = true;
-          dirtyEffects.add(observer);
-          for (const effect2 of observer.effects) {
-            dirtyEffects.add(effect2);
-          }
-        } else {
-          dirtyEffects.add(observer);
-        }
-      }
-      if (isOutermostBatch) {
-        queueMicrotask(() => {
-          try {
-            for (const effect$1 of dirtyEffects) {
-              effect.runEffect(effect$1);
-            }
-          } finally {
-            dirtyEffects.clear();
-            batchDepth = 0;
-          }
-        });
-      }
-    } finally {
-      if (isOutermostBatch) {
-        batchDepth -= 1;
-      }
+    for (const computed2 of this.state.computeds) {
+      computed2.state.dirty = true;
+      effect.dirtyEffects.add(computed2.state.effect);
+    }
+    for (const effect$1 of this.state.effects) {
+      effect.dirtyEffects.add(effect$1);
+    }
+    if (batch.batchDepth === 0) {
+      batch.flushEffects();
     }
   }
+  /**
+   * Update the value
+   */
   update(callback) {
     this.set(callback(this.state.value));
   }

package/dist/signal.js

@@ -1,62 +1,52 @@
 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 { Computed } from "./computed.js";
-import { activeEffect, runEffect } from "./effect.js";
-const dirtyEffects = /* @__PURE__ */ new Set();
-let batchDepth = 0;
+import { flushEffects, batchDepth } from "./batch.js";
+import { activeComputed } from "./computed.js";
+import { activeEffect, dirtyEffects } from "./effect.js";
 class Signal {
   constructor(value) {
     __publicField(this, "state");
     this.state = {
       value,
-      observers: /* @__PURE__ */ new Set()
+      computeds: /* @__PURE__ */ new Set(),
+      effects: /* @__PURE__ */ new Set()
     };
   }
+  /**
+   * Get the value
+   */
   get() {
+    if (activeComputed != null) {
+      this.state.computeds.add(activeComputed);
+    }
     if (activeEffect != null) {
-      this.state.observers.add(activeEffect);
-      activeEffect.signals.add(this);
+      this.state.effects.add(activeEffect);
     }
     return this.state.value;
   }
+  /**
+   * Set the value
+   */
   set(value) {
     if (Object.is(this.state.value, value)) {
       return;
     }
     this.state.value = value;
-    const isOutermostBatch = batchDepth === 0;
-    batchDepth += 1;
-    try {
-      for (const observer of this.state.observers) {
-        if (observer instanceof Computed) {
-          observer.dirty = true;
-          dirtyEffects.add(observer);
-          for (const effect of observer.effects) {
-            dirtyEffects.add(effect);
-          }
-        } else {
-          dirtyEffects.add(observer);
-        }
-      }
-      if (isOutermostBatch) {
-        queueMicrotask(() => {
-          try {
-            for (const effect of dirtyEffects) {
-              runEffect(effect);
-            }
-          } finally {
-            dirtyEffects.clear();
-            batchDepth = 0;
-          }
-        });
-      }
-    } finally {
-      if (isOutermostBatch) {
-        batchDepth -= 1;
-      }
+    for (const computed of this.state.computeds) {
+      computed.state.dirty = true;
+      dirtyEffects.add(computed.state.effect);
+    }
+    for (const effect of this.state.effects) {
+      dirtyEffects.add(effect);
+    }
+    if (batchDepth === 0) {
+      flushEffects();
     }
   }
+  /**
+   * Update the value
+   */
   update(callback) {
     this.set(callback(this.state.value));
   }