async-reactivity 2.0.1 → 2.0.2

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/ref.js

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

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/watcher.test.js

@@ -0,0 +1,73 @@
+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, Watcher } from './index.js';
+describe('watcher', function () {
+    it('sync', function () {
+        const a = new Ref(5);
+        new Watcher(a, (newValue, oldValue) => {
+            assert.strictEqual(oldValue, 5);
+            assert.strictEqual(newValue, 6);
+        }, false);
+        a.value = 6;
+    });
+    it('async', 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 10;
+            }));
+            const result = yield new Promise(resolve => new Watcher(a, resolve));
+            assert.strictEqual(result, 10);
+        });
+    });
+    it('sync cancel', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const a = new Ref(5);
+            const b = new Computed((value) => {
+                return value(a) % 2;
+            });
+            let gate = 0;
+            new Watcher(b, () => {
+                gate++;
+            }, false);
+            a.value = 6;
+            assert.strictEqual(gate, 1);
+            a.value = 7;
+            a.value = 9;
+            a.value = 11;
+            assert.strictEqual(gate, 2);
+        });
+    });
+    it('async sync cancel', 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* () {
+                new Promise(resolve => setTimeout(resolve));
+                return value(a) % 2;
+            }));
+            let gate = 0;
+            new Watcher(b, () => {
+                gate++;
+            }, false);
+            yield new Promise(resolve => setTimeout(resolve, 10));
+            a.value = 6;
+            yield new Promise(resolve => setTimeout(resolve, 10));
+            assert.strictEqual(gate, 1);
+            a.value = 7;
+            yield new Promise(resolve => setTimeout(resolve, 10));
+            assert.strictEqual(gate, 2);
+            a.value = 9;
+            yield new Promise(resolve => setTimeout(resolve, 10));
+            assert.strictEqual(gate, 3);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "async-reactivity",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
@@ -22,9 +22,9 @@
   "author": "Donatas Lučiūnas",
   "license": "ISC",
   "devDependencies": {
-    "@types/mocha": "^10.0.6",
-    "@types/node": "^20.10.5",
-    "mocha": "^10.2.0",
-    "typescript": "^5.3.3"
+    "@types/mocha": "^10.0.7",
+    "@types/node": "^20.14.10",
+    "mocha": "^10.6.0",
+    "typescript": "^5.5.3"
   }
 }

package/src/computed.test.ts

@@ -0,0 +1,244 @@
+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', async function () {
+        const a = new Computed(async () => {
+            await new Promise(resolve => setTimeout(resolve));
+            return 5;
+        });
+        assert.strictEqual(await a.value, 5);
+    });
+
+    it('tracks async dependencies', async function () {
+        const a = new Ref(5);
+        const b = new Computed(async (value) => {
+            await new Promise(resolve => setTimeout(resolve));
+            return value(a) + 5;
+        });
+        assert.strictEqual(await b.value, 10);
+        a.value = 6;
+        assert.strictEqual(await b.value, 11);
+    });
+
+    it('get value while computing', async function () {
+        const a = new Computed(async () => {
+            await new Promise(resolve => setTimeout(resolve));
+            return 5;
+        });
+
+        a.value;
+        assert.strictEqual(await a.value, 5);
+    });
+
+    it('detect circular dependency', async function () {
+        // @ts-expect-error
+        const a = new Computed(async (value) => {
+            await new Promise(resolve => setTimeout(resolve));
+            return value(b);
+        });
+        // @ts-expect-error
+        const b = new Computed(async (value) => {
+            await new Promise(resolve => setTimeout(resolve));
+            return value(a);
+        });
+
+        assert.rejects(async () => await a.value);
+    });
+
+    it('dependency changed while computing', async function () {
+        const a = new Ref(5);
+        const b = new Computed(async (value) => value(a) + 5);
+        b.value;            // trigger compute
+        a.value = 8;
+        assert.strictEqual(await b.value, 13);
+    });
+
+    it('old dependency changed while computing', async function () {
+        let gate = 0;
+        const a = new Ref(5);
+        const b = new Computed(async (value) => {
+            gate++;
+            await new Promise(resolve => setTimeout(resolve));
+            return value(a) + 2;
+        });
+        assert.strictEqual(await b.value, 7);
+        b.invalidate();
+        const promise = b.value;
+        a.value = 6;
+        assert.strictEqual(await promise, 8);
+        assert.strictEqual(gate, 2);
+    });
+
+    it('new dependency changed while computing', async function () {
+        let gate = 0;
+        const a = new Ref(5);
+        const b = new Ref(10);
+        const c = new Computed(async (value) => {
+            gate++;
+            await new Promise(resolve => setTimeout(resolve, 50));
+            let sum = value(a);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            sum += value(b);
+            return sum;
+        });
+        assert.strictEqual(await c.value, 15);
+        c.invalidate();
+        const promise = c.value;
+        await new Promise(resolve => setTimeout(resolve, 60));
+        a.value = 10;
+        assert.strictEqual(await promise, 20);
+        assert.strictEqual(gate, 3);
+    });
+
+    it('fallback to primitive while computing', async function () {
+        const a = new Ref(5);
+        const b = new Ref(10);
+        const c = new Computed(async (value) => {
+            if (value(a) < 10) {
+                await new Promise(resolve => setTimeout(resolve, 50));
+                return value(b) + 5;
+            }
+            return 2;
+        });
+        const promise = c.value;
+        await new Promise(resolve => setTimeout(resolve, 20));
+        a.value = 10;
+        assert.strictEqual(await promise, 2);
+    });
+
+    it('throw error', async function () {
+        const a = new Computed(async () => {
+            await new Promise(resolve => setTimeout(resolve));
+            throw new Error();
+        });
+        assert.rejects(() => a.value);
+    });
+
+    it('dispose computed', async 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/src/ref.test.ts

@@ -0,0 +1,24 @@
+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/src/ref.ts

@@ -1,17 +1,21 @@
 import Dependency from "./dependency.js";
 import Tracker from "./tracker.js";
 
+const defaultIsEqual = <T>(v1?: T, v2?: T) => v1 === v2;
+
 export default class Ref<T> extends Tracker<T> implements Dependency<T> {
+    private isEqual: (a?: T, b?: T) => boolean;
 
-    constructor(_value: T) {
+    constructor(_value: T, isEqual = defaultIsEqual<T>) {
         super();
         this._value = _value;
+        this.isEqual = isEqual;
     }
 
     public set value(_value: T) {
         const lastValue = this._value;
         this._value = _value;
-        if (lastValue !== _value) {
+        if (!this.isEqual(lastValue, _value)) {
             this.invalidate();
         }
     }