async-reactivity 2.0.0 → 2.0.2

package/lib/computed.js

@@ -1,123 +1,124 @@
-import Tracker from "./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 {
-}
-export default class Computed extends Tracker {
-    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();
-    }
-}
+import Tracker from "./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 {
+}
+export default class Computed extends Tracker {
+    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();
+    }
+}

package/lib/computed.test.js

@@ -0,0 +1,245 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import 'mocha';
+import assert from 'assert';
+import { Computed, Ref } from './index.js';
+describe('computed', function () {
+    it('lazy compute', function () {
+        let gate = false;
+        const a = new Computed(() => {
+            gate = true;
+            return 5;
+        });
+        assert.strictEqual(gate, false);
+        assert.strictEqual(a.value, 5);
+        assert.strictEqual(gate, true);
+    });
+    it('cache', function () {
+        let gate = false;
+        const a = new Computed(() => {
+            gate = true;
+            return 5;
+        });
+        assert.strictEqual(a.value, 5);
+        gate = false;
+        assert.strictEqual(a.value, 5);
+        assert.strictEqual(gate, false);
+    });
+    it('invalidate dependents', function () {
+        const a = new Ref(5);
+        const b = new Computed((value) => {
+            return value(a) + 4;
+        });
+        assert.strictEqual(b.value, 9);
+        a.value = 6;
+        assert.strictEqual(b.value, 10);
+    });
+    it('dependents up-to-date', function () {
+        const a = new Ref(5);
+        const b = new Ref(10);
+        let gate;
+        const c = new Computed((value) => {
+            gate = true;
+            return value(a) < 10 ? value(b) : 0;
+        });
+        assert.strictEqual(c.value, 10);
+        a.value = 15;
+        assert.strictEqual(c.value, 0);
+        b.value = 15;
+        gate = false;
+        assert.strictEqual(c.value, 0);
+        assert.strictEqual(gate, false);
+    });
+    it('detect circular dependency', function () {
+        // @ts-expect-error
+        const a = new Computed((value) => {
+            return value(b);
+        });
+        // @ts-expect-error
+        const b = new Computed((value) => {
+            return value(a);
+        });
+        assert.throws(() => a.value);
+    });
+    xit('detect circular deeper dependency', function () {
+        // do not support for better performance
+        assert.fail('not implemented');
+    });
+    it('throw error', function () {
+        const a = new Computed(() => {
+            throw new Error();
+        });
+        assert.throws(() => a.value);
+    });
+    it('ignore same ref value', function () {
+        let gate = 0;
+        const a = new Ref(5);
+        const b = new Computed((value) => {
+            gate++;
+            return value(a);
+        });
+        assert.strictEqual(b.value, 5);
+        a.value = 5;
+        assert.strictEqual(b.value, 5);
+        assert.strictEqual(gate, 1);
+    });
+    it('ignore same computed value', function () {
+        let gate = 0;
+        const a = new Ref(5);
+        const b = new Computed((value) => {
+            return value(a) % 2;
+        });
+        const c = new Computed((value) => {
+            gate++;
+            return value(b) + 5;
+        });
+        assert.strictEqual(c.value, 6);
+        a.value = 7;
+        assert.strictEqual(c.value, 6);
+        assert.strictEqual(gate, 1);
+    });
+});
+describe('async computed', function () {
+    it('getter', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Computed(() => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                return 5;
+            }));
+            assert.strictEqual(yield a.value, 5);
+        });
+    });
+    it('tracks async dependencies', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Ref(5);
+            const b = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                return value(a) + 5;
+            }));
+            assert.strictEqual(yield b.value, 10);
+            a.value = 6;
+            assert.strictEqual(yield b.value, 11);
+        });
+    });
+    it('get value while computing', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Computed(() => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                return 5;
+            }));
+            a.value;
+            assert.strictEqual(yield a.value, 5);
+        });
+    });
+    it('detect circular dependency', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @ts-expect-error
+            const a = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                return value(b);
+            }));
+            // @ts-expect-error
+            const b = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                return value(a);
+            }));
+            assert.rejects(() => __awaiter(this, void 0, void 0, function* () { return yield a.value; }));
+        });
+    });
+    it('dependency changed while computing', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Ref(5);
+            const b = new Computed((value) => __awaiter(this, void 0, void 0, function* () { return value(a) + 5; }));
+            b.value; // trigger compute
+            a.value = 8;
+            assert.strictEqual(yield b.value, 13);
+        });
+    });
+    it('old dependency changed while computing', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            let gate = 0;
+            const a = new Ref(5);
+            const b = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                gate++;
+                yield new Promise(resolve => setTimeout(resolve));
+                return value(a) + 2;
+            }));
+            assert.strictEqual(yield b.value, 7);
+            b.invalidate();
+            const promise = b.value;
+            a.value = 6;
+            assert.strictEqual(yield promise, 8);
+            assert.strictEqual(gate, 2);
+        });
+    });
+    it('new dependency changed while computing', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            let gate = 0;
+            const a = new Ref(5);
+            const b = new Ref(10);
+            const c = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                gate++;
+                yield new Promise(resolve => setTimeout(resolve, 50));
+                let sum = value(a);
+                yield new Promise(resolve => setTimeout(resolve, 50));
+                sum += value(b);
+                return sum;
+            }));
+            assert.strictEqual(yield c.value, 15);
+            c.invalidate();
+            const promise = c.value;
+            yield new Promise(resolve => setTimeout(resolve, 60));
+            a.value = 10;
+            assert.strictEqual(yield promise, 20);
+            assert.strictEqual(gate, 3);
+        });
+    });
+    it('fallback to primitive while computing', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Ref(5);
+            const b = new Ref(10);
+            const c = new Computed((value) => __awaiter(this, void 0, void 0, function* () {
+                if (value(a) < 10) {
+                    yield new Promise(resolve => setTimeout(resolve, 50));
+                    return value(b) + 5;
+                }
+                return 2;
+            }));
+            const promise = c.value;
+            yield new Promise(resolve => setTimeout(resolve, 20));
+            a.value = 10;
+            assert.strictEqual(yield promise, 2);
+        });
+    });
+    it('throw error', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Computed(() => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => setTimeout(resolve));
+                throw new Error();
+            }));
+            assert.rejects(() => a.value);
+        });
+    });
+    it('dispose computed', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Ref(5);
+            let gate = 0;
+            const b = new Computed(value => {
+                gate++;
+                return value(a) + 2;
+            });
+            b.value;
+            assert.strictEqual(gate, 1);
+            b.dispose();
+            b.value;
+            assert.strictEqual(gate, 2);
+        });
+    });
+});

package/lib/dependency.js

@@ -1 +1 @@
-export {};
+export {};

package/lib/dependent.js

@@ -1 +1 @@
-export {};
+export {};

package/lib/index.js

@@ -1,3 +1,3 @@
-export { default as Computed } from './computed.js';
-export { default as Ref } from './ref.js';
-export { default as Watcher } from './watcher.js';
+export { default as Computed } from './computed.js';
+export { default as Ref } from './ref.js';
+export { default as Watcher } from './watcher.js';

package/lib/ref.js

@@ -1,17 +1,19 @@
-import Tracker from "./tracker.js";
-export default class Ref extends Tracker {
-    constructor(_value) {
-        super();
-        this._value = _value;
-    }
-    set value(_value) {
-        const lastValue = this._value;
-        this._value = _value;
-        if (lastValue !== _value) {
-            this.invalidate();
-        }
-    }
-    get value() {
-        return super.value;
-    }
-}
+import Tracker from "./tracker.js";
+const defaultIsEqual = (v1, v2) => v1 === v2;
+export default class Ref extends Tracker {
+    constructor(_value, isEqual = (defaultIsEqual)) {
+        super();
+        this._value = _value;
+        this.isEqual = isEqual;
+    }
+    set value(_value) {
+        const lastValue = this._value;
+        this._value = _value;
+        if (!this.isEqual(lastValue, _value)) {
+            this.invalidate();
+        }
+    }
+    get value() {
+        return super.value;
+    }
+}

package/lib/ref.test.js

@@ -0,0 +1,21 @@
+import 'mocha';
+import assert from 'assert';
+import { Ref, Watcher } from './index.js';
+describe('ref', function () {
+    it('getter', function () {
+        const a = new Ref(5);
+        assert.strictEqual(a.value, 5);
+    });
+    it('setter', function () {
+        const a = new Ref(5);
+        a.value = 4;
+        assert.strictEqual(a.value, 4);
+    });
+    it('setter isEqual', function () {
+        const a = new Ref(5, () => true);
+        new Watcher(a, () => {
+            assert.fail();
+        }, false);
+        a.value = 4;
+    });
+});

package/lib/tracker.js

@@ -1,19 +1,19 @@
-export default class Tracker {
-    constructor() {
-        this.dependents = new Set();
-    }
-    addDependent(dependent) {
-        this.dependents.add(dependent);
-    }
-    removeDependent(dependent) {
-        this.dependents.delete(dependent);
-    }
-    invalidate() {
-        for (const dependent of [...this.dependents.keys()]) {
-            dependent.invalidate();
-        }
-    }
-    get value() {
-        return this._value;
-    }
-}
+export default class Tracker {
+    constructor() {
+        this.dependents = new Set();
+    }
+    addDependent(dependent) {
+        this.dependents.add(dependent);
+    }
+    removeDependent(dependent) {
+        this.dependents.delete(dependent);
+    }
+    invalidate() {
+        for (const dependent of [...this.dependents.keys()]) {
+            dependent.invalidate();
+        }
+    }
+    get value() {
+        return this._value;
+    }
+}

package/lib/watcher.js

@@ -1,35 +1,35 @@
-import Tracker from "./tracker.js";
-var WatchState;
-(function (WatchState) {
-    WatchState[WatchState["Uncertain"] = 0] = "Uncertain";
-    WatchState[WatchState["Valid"] = 1] = "Valid";
-})(WatchState || (WatchState = {}));
-;
-export default class Watcher extends Tracker {
-    constructor(dependency, onChange, immediate = true) {
-        super();
-        this.state = WatchState.Valid;
-        this.onChange = onChange;
-        this.dependency = dependency;
-        dependency.addDependent(this);
-        this._value = dependency.value;
-        if (immediate) {
-            onChange(this._value);
-        }
-    }
-    invalidate() {
-        this.state = WatchState.Uncertain;
-        const oldValue = this._value;
-        this._value = this.dependency.value;
-        if (this.state === WatchState.Uncertain) {
-            this.onChange(this._value, oldValue);
-            this.state = WatchState.Valid;
-        }
-    }
-    validate() {
-        this.state = WatchState.Valid;
-    }
-    dispose() {
-        this.dependency.removeDependent(this);
-    }
-}
+import Tracker from "./tracker.js";
+var WatchState;
+(function (WatchState) {
+    WatchState[WatchState["Uncertain"] = 0] = "Uncertain";
+    WatchState[WatchState["Valid"] = 1] = "Valid";
+})(WatchState || (WatchState = {}));
+;
+export default class Watcher extends Tracker {
+    constructor(dependency, onChange, immediate = true) {
+        super();
+        this.state = WatchState.Valid;
+        this.onChange = onChange;
+        this.dependency = dependency;
+        dependency.addDependent(this);
+        this._value = dependency.value;
+        if (immediate) {
+            onChange(this._value);
+        }
+    }
+    invalidate() {
+        this.state = WatchState.Uncertain;
+        const oldValue = this._value;
+        this._value = this.dependency.value;
+        if (this.state === WatchState.Uncertain) {
+            this.onChange(this._value, oldValue);
+            this.state = WatchState.Valid;
+        }
+    }
+    validate() {
+        this.state = WatchState.Valid;
+    }
+    dispose() {
+        this.dependency.removeDependent(this);
+    }
+}