@oscarpalmer/mora 0.3.0 → 0.5.0

package/types/signal.d.ts

@@ -1,14 +1,24 @@
-import { Computed } from './computed';
+import { type Computed } from './computed';
 import { type Effect } from './effect';
 type SignalState<Value> = {
-    observers: Set<Computed<never> | Effect>;
+    computeds: Set<Computed<unknown>>;
+    effects: Set<Effect>;
     value: Value;
 };
 export declare class Signal<Value> {
     readonly state: SignalState<Value>;
     constructor(value: Value);
+    /**
+     * Get the value
+     */
     get(): Value;
+    /**
+     * Set the value
+     */
     set(value: Value): void;
+    /**
+     * Update the value
+     */
     update(callback: (value: Value) => Value): void;
 }
 export declare function signal<Value>(value: Value): Signal<Value>;

package/dist/mora.iife.js

@@ -1,129 +0,0 @@
-var Mora = (function (exports) {
-    'use strict';
-
-    let activeEffect;
-    class Effect {
-        callback;
-        signals = new Set();
-    }
-    function runEffect(effect) {
-        for (const signal of effect.signals) {
-            signal.state.observers.delete(effect);
-        }
-        effect.signals.clear();
-        const previousEffect = activeEffect;
-        activeEffect = effect;
-        try {
-            effect.callback();
-        }
-        finally {
-            activeEffect = previousEffect;
-        }
-    }
-    function effect(callback) {
-        const instance = new Effect();
-        instance.callback = callback;
-        runEffect(instance);
-        return instance;
-    }
-
-    class Computed extends Effect {
-        dirty = true;
-        effects = new Set();
-        value;
-        constructor(callback) {
-            super();
-            this.callback = () => {
-                if (this.dirty) {
-                    this.value = callback();
-                    this.dirty = false;
-                }
-            };
-            runEffect(this);
-        }
-        get() {
-            if (activeEffect != null && activeEffect !== this) {
-                this.effects.add(activeEffect);
-            }
-            if (this.dirty) {
-                runEffect(this);
-            }
-            return this.value;
-        }
-    }
-    function computed(callback) {
-        return new Computed(callback);
-    }
-
-    const dirtyEffects = new Set();
-    let batchDepth = 0;
-    class Signal {
-        state;
-        constructor(value) {
-            this.state = {
-                value,
-                observers: new Set(),
-            };
-        }
-        get() {
-            if (activeEffect != null) {
-                this.state.observers.add(activeEffect);
-                activeEffect.signals.add(this);
-            }
-            return this.state.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;
-                }
-            }
-        }
-        update(callback) {
-            this.set(callback(this.state.value));
-        }
-    }
-    function signal(value) {
-        return new Signal(value);
-    }
-
-    exports.computed = computed;
-    exports.effect = effect;
-    exports.signal = signal;
-
-    return exports;
-
-})({});