async-reactivity 1.1.2 → 1.1.3

package/lib/computed.js

@@ -1,129 +1,130 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const tracker_js_1 = __importDefault(require("./tracker.js"));
-var ComputedState;
-(function (ComputedState) {
-    ComputedState[ComputedState["Invalid"] = 0] = "Invalid";
-    ComputedState[ComputedState["Valid"] = 1] = "Valid";
-    ComputedState[ComputedState["Uncertain"] = 2] = "Uncertain";
-    ComputedState[ComputedState["Computing"] = 3] = "Computing";
-})(ComputedState || (ComputedState = {}));
-;
-class CircularDependencyError extends Error {
-}
-class Computed extends tracker_js_1.default {
-    constructor(getter) {
-        super();
-        this.state = ComputedState.Invalid;
-        this.dependencies = new Map();
-        this.trackDependency = this.innerTrackDependency.bind(this);
-        this.getter = getter;
-        this.prepareComputePromise();
-    }
-    prepareComputePromise() {
-        this.computePromise = new Promise((resolve, reject) => {
-            this.computePromiseActions = {
-                resolve,
-                reject
-            };
-        });
-    }
-    get value() {
-        if (this.state === ComputedState.Invalid || this.state === ComputedState.Uncertain) {
-            return this.compute();
-        }
-        return this._value;
-    }
-    compute() {
-        if (this.state === ComputedState.Uncertain) {
-            for (const dependency of this.dependencies.keys()) {
-                this.dependencies.set(dependency, true);
-            }
-            if ([...this.dependencies.keys()].every(d => {
-                d.value;
-                return !this.dependencies.get(d);
-            })) {
-                this.finalizeComputing();
-                this.validateDependents();
-                return this._value;
-            }
-        }
-        this.state = ComputedState.Computing;
-        this.clearDependencies();
-        const lastValue = this._value;
-        this._value = this.getter(this.trackDependency);
-        if (this._value instanceof Promise) {
-            const computeAttemptPromise = this._value
-                .then(result => this.handlePromiseThen(computeAttemptPromise, result))
-                .catch(error => this.handlePromiseCatch(computeAttemptPromise, error));
-            this.lastComputeAttemptPromise = computeAttemptPromise;
-            this._value = this.computePromise;
-        }
-        else {
-            this.handlePromiseThen(this.lastComputeAttemptPromise, this._value);
-            if (lastValue === this._value) {
-                this.validateDependents();
-            }
-        }
-        return this._value;
-    }
-    clearDependencies() {
-        for (const dependency of this.dependencies.keys()) {
-            dependency.removeDependent(this);
-        }
-        this.dependencies.clear();
-    }
-    handlePromiseThen(computeAttemptPromise, result) {
-        if (this.lastComputeAttemptPromise === computeAttemptPromise) {
-            this.computePromiseActions.resolve(result);
-            this.finalizeComputing();
-        }
-    }
-    handlePromiseCatch(computeAttemptPromise, error) {
-        if (this.lastComputeAttemptPromise === computeAttemptPromise) {
-            this.computePromiseActions.reject(error);
-            this.finalizeComputing();
-        }
-    }
-    innerTrackDependency(dependency) {
-        if (this.dependents.has(dependency)) {
-            throw new CircularDependencyError();
-        }
-        this.dependencies.set(dependency, true);
-        dependency.addDependent(this);
-        return dependency.value;
-    }
-    finalizeComputing() {
-        this.state = ComputedState.Valid;
-        this.lastComputeAttemptPromise = undefined;
-        this.prepareComputePromise();
-    }
-    invalidate() {
-        if (this.state === ComputedState.Computing) {
-            setTimeout(this.compute.bind(this));
-        }
-        else if (this.state === ComputedState.Valid) {
-            this.state = ComputedState.Uncertain;
-            super.invalidate();
-        }
-    }
-    validate(dependency) {
-        this.dependencies.set(dependency, false);
-    }
-    validateDependents() {
-        for (const dependent of this.dependents.keys()) {
-            dependent.validate(this);
-        }
-    }
-    dispose() {
-        this.clearDependencies();
-        this.state = ComputedState.Invalid;
-        this._value = undefined;
-        this.lastComputeAttemptPromise = undefined;
-        this.prepareComputePromise();
-    }
-}
-exports.default = Computed;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tracker_js_1 = __importDefault(require("./tracker.js"));
+var ComputedState;
+(function (ComputedState) {
+    ComputedState[ComputedState["Invalid"] = 0] = "Invalid";
+    ComputedState[ComputedState["Valid"] = 1] = "Valid";
+    ComputedState[ComputedState["Uncertain"] = 2] = "Uncertain";
+    ComputedState[ComputedState["Computing"] = 3] = "Computing";
+})(ComputedState || (ComputedState = {}));
+;
+class CircularDependencyError extends Error {
+}
+class Computed extends tracker_js_1.default {
+    constructor(getter) {
+        super();
+        this.state = ComputedState.Invalid;
+        this.dependencies = new Map();
+        this.trackDependency = this.innerTrackDependency.bind(this);
+        this.getter = getter;
+        this.prepareComputePromise();
+    }
+    prepareComputePromise() {
+        this.computePromise = new Promise((resolve, reject) => {
+            this.computePromiseActions = {
+                resolve,
+                reject
+            };
+        });
+    }
+    get value() {
+        if (this.state === ComputedState.Invalid || this.state === ComputedState.Uncertain) {
+            return this.compute();
+        }
+        return this._value;
+    }
+    compute() {
+        if (this.state === ComputedState.Uncertain) {
+            for (const dependency of this.dependencies.keys()) {
+                this.dependencies.set(dependency, true);
+            }
+            if ([...this.dependencies.keys()].every(d => {
+                d.value;
+                return !this.dependencies.get(d);
+            })) {
+                this.finalizeComputing();
+                this.validateDependents();
+                return this._value;
+            }
+        }
+        this.state = ComputedState.Computing;
+        this.clearDependencies();
+        const lastValue = this._value;
+        this._value = this.getter(this.trackDependency);
+        if (this._value instanceof Promise) {
+            const computeAttemptPromise = this._value
+                .then(result => this.handlePromiseThen(computeAttemptPromise, result))
+                .catch(error => this.handlePromiseCatch(computeAttemptPromise, error));
+            this.lastComputeAttemptPromise = computeAttemptPromise;
+            this._value = this.computePromise;
+        }
+        else {
+            this.handlePromiseThen(this.lastComputeAttemptPromise, this._value);
+            if (lastValue === this._value) {
+                this.validateDependents();
+            }
+        }
+        return this._value;
+    }
+    clearDependencies() {
+        for (const dependency of this.dependencies.keys()) {
+            dependency.removeDependent(this);
+        }
+        this.dependencies.clear();
+    }
+    handlePromiseThen(computeAttemptPromise, result) {
+        if (this.lastComputeAttemptPromise === computeAttemptPromise) {
+            this.computePromiseActions.resolve(result);
+            this.finalizeComputing();
+        }
+    }
+    handlePromiseCatch(computeAttemptPromise, error) {
+        if (this.lastComputeAttemptPromise === computeAttemptPromise) {
+            this.computePromiseActions.reject(error);
+            this.finalizeComputing();
+        }
+    }
+    innerTrackDependency(dependency) {
+        if (this.dependents.has(dependency)) {
+            throw new CircularDependencyError();
+        }
+        this.dependencies.set(dependency, true);
+        dependency.addDependent(this);
+        return dependency.value;
+    }
+    finalizeComputing() {
+        this.state = ComputedState.Valid;
+        this.lastComputeAttemptPromise = undefined;
+        this.prepareComputePromise();
+    }
+    invalidate() {
+        if (this.state === ComputedState.Computing) {
+            this.lastComputeAttemptPromise = undefined; // prevent finalizeComputing if it is in the event loop already
+            Promise.resolve().then(this.compute.bind(this));
+        }
+        else if (this.state === ComputedState.Valid) {
+            this.state = ComputedState.Uncertain;
+            super.invalidate();
+        }
+    }
+    validate(dependency) {
+        this.dependencies.set(dependency, false);
+    }
+    validateDependents() {
+        for (const dependent of this.dependents.keys()) {
+            dependent.validate(this);
+        }
+    }
+    dispose() {
+        this.clearDependencies();
+        this.state = ComputedState.Invalid;
+        this._value = undefined;
+        this.lastComputeAttemptPromise = undefined;
+        this.prepareComputePromise();
+    }
+}
+exports.default = Computed;

package/lib/dependency.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dependent.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.js

@@ -1,12 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Watcher = exports.Ref = exports.Computed = void 0;
-var computed_js_1 = require("./computed.js");
-Object.defineProperty(exports, "Computed", { enumerable: true, get: function () { return __importDefault(computed_js_1).default; } });
-var ref_js_1 = require("./ref.js");
-Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return __importDefault(ref_js_1).default; } });
-var watcher_js_1 = require("./watcher.js");
-Object.defineProperty(exports, "Watcher", { enumerable: true, get: function () { return __importDefault(watcher_js_1).default; } });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watcher = exports.Ref = exports.Computed = void 0;
+var computed_js_1 = require("./computed.js");
+Object.defineProperty(exports, "Computed", { enumerable: true, get: function () { return __importDefault(computed_js_1).default; } });
+var ref_js_1 = require("./ref.js");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return __importDefault(ref_js_1).default; } });
+var watcher_js_1 = require("./watcher.js");
+Object.defineProperty(exports, "Watcher", { enumerable: true, get: function () { return __importDefault(watcher_js_1).default; } });