async-reactivity 2.0.7 → 2.0.8

package/lib/computed.js

@@ -62,20 +62,21 @@ export default class Computed extends Tracker {
         }
         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
+        const newValue = this.getter(this.trackDependency);
+        if (this.isEqual(newValue, this._value)) {
+            this.handlePromiseThen(this.lastComputeAttemptPromise, this._value);
+            this.validateDependents();
+        }
+        else if (newValue instanceof Promise) {
+            const computeAttemptPromise = newValue
                 .then(result => this.handlePromiseThen(computeAttemptPromise, result))
                 .catch(error => this.handlePromiseCatch(computeAttemptPromise, error));
             this.lastComputeAttemptPromise = computeAttemptPromise;
             this._value = this.computePromise;
         }
         else {
+            this._value = newValue;
             this.handlePromiseThen(this.lastComputeAttemptPromise, this._value);
-            if (this.isEqual(lastValue, this._value)) {
-                this.validateDependents();
-            }
         }
         return this._value;
     }

package/lib/computed.test.js

@@ -130,6 +130,15 @@ describe('computed', function () {
         assert.strictEqual(c.value, 6);
         assert.strictEqual(gate, 2);
     });
+    it('isEqual', function () {
+        const a = new Ref(1);
+        const b = new Computed((value) => {
+            return value(a);
+        }, (_newValue, oldValue) => oldValue !== undefined);
+        assert.strictEqual(b.value, 1);
+        a.value = 2;
+        assert.strictEqual(b.value, 1);
+    });
 });
 describe('async computed', function () {
     it('getter', async function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "async-reactivity",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "",
   "main": "lib/index.js",
   "types": "types/index.d.ts",

package/src/computed.test.ts

@@ -152,6 +152,18 @@ describe('computed', function () {
         assert.strictEqual(c.value, 6);
         assert.strictEqual(gate, 2);
     });
+
+    it('isEqual', function() {
+        const a = new Ref(1);
+        const b = new Computed((value) => {
+            return value(a);
+        }, (_newValue, oldValue) => oldValue !== undefined);
+
+        assert.strictEqual(b.value, 1);
+
+        a.value = 2;
+        assert.strictEqual(b.value, 1);
+    });
 });
 
 describe('async computed', function () {

package/src/computed.ts

@@ -74,19 +74,19 @@ export default class Computed<T> extends Tracker<T> implements Dependent, Depend
         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
+        const newValue: T = this.getter(this.trackDependency);
+        if (this.isEqual(newValue, this._value)) {
+            this.handlePromiseThen(this.lastComputeAttemptPromise!, this._value);
+            this.validateDependents();
+        } else if (newValue instanceof Promise) {
+            const computeAttemptPromise = newValue
                 .then(result => this.handlePromiseThen(computeAttemptPromise, result))
                 .catch(error => this.handlePromiseCatch(computeAttemptPromise, error)) as Promise<void>;
             this.lastComputeAttemptPromise = computeAttemptPromise;
             this._value = this.computePromise!;
         } else {
+            this._value = newValue;
             this.handlePromiseThen(this.lastComputeAttemptPromise!, this._value);
-            if (this.isEqual(lastValue, this._value)) {
-                this.validateDependents();
-            }
         }
         return this._value!;
     }