@manyducks.co/dolla 0.76.0 → 0.77.1

package/lib/index.js

@@ -502,96 +502,80 @@ function computed(...args) {
     throw new Error(`Must pass at least one value before the callback function.`);
   }
   const readables = args;
-  if (readables.length === 1) {
-    const readable2 = readables[0];
-    return {
-      get: () => {
-        const computed2 = compute(readable2.get());
-        if (isReadable(computed2)) {
-          return computed2.get();
-        } else {
-          return computed2;
-        }
-      },
-      [OBSERVE]: (callback) => {
-        let lastComputedValue = UNOBSERVED;
-        return readable2[OBSERVE]((currentValue) => {
-          const computedValue = compute(currentValue);
-          if (isReadable(computedValue)) {
-            lastComputedValue = computedValue;
-            return computedValue[OBSERVE]((current) => {
-              callback(current);
-            });
-          }
-          if (!deepEqual(computedValue, lastComputedValue)) {
-            callback(computedValue);
-            lastComputedValue = computedValue;
-          }
-        });
-      }
-    };
-  } else {
-    let updateValue2 = function() {
-      const computedValue = compute(...observedValues);
-      if (!deepEqual(computedValue, latestComputedValue)) {
-        latestComputedValue = computedValue;
-        for (const callback of observers) {
-          callback(computedValue);
-        }
+  const observers = [];
+  let stopCallbacks = [];
+  let isObserving = false;
+  let observedValues = [];
+  let valuesChanged = [];
+  let latestComputedValue = UNOBSERVED;
+  function updateValue() {
+    if (!valuesChanged.some((x) => x)) {
+      return;
+    }
+    const computedValue = compute(...observedValues);
+    if (!deepEqual(computedValue, latestComputedValue)) {
+      latestComputedValue = computedValue;
+      for (const callback of observers) {
+        callback(computedValue);
       }
-    }, startObserving2 = function() {
-      if (isObserving)
-        return;
-      for (let i = 0; i < readables.length; i++) {
-        const readable2 = readables[i];
-        stopCallbacks.push(
-          observe(readable2, (value) => {
+    }
+    for (let i = 0; i < observedValues.length; i++) {
+      valuesChanged[i] = false;
+    }
+  }
+  function startObserving() {
+    if (isObserving)
+      return;
+    for (let i = 0; i < readables.length; i++) {
+      const readable2 = readables[i];
+      stopCallbacks.push(
+        observe(readable2, (value) => {
+          if (!deepEqual(observedValues[i], value)) {
             observedValues[i] = value;
+            valuesChanged[i] = true;
             if (isObserving) {
-              updateValue2();
+              updateValue();
             }
-          })
-        );
+          }
+        })
+      );
+    }
+    observedValues = readables.map((x) => x.get());
+    for (let i = 0; i < observedValues.length; i++) {
+      valuesChanged[i] = true;
+    }
+    isObserving = true;
+    updateValue();
+  }
+  function stopObserving() {
+    isObserving = false;
+    for (const callback of stopCallbacks) {
+      callback();
+    }
+    stopCallbacks = [];
+  }
+  return {
+    get: () => {
+      if (isObserving) {
+        return latestComputedValue;
+      } else {
+        return compute(...readables.map((x) => x.get()));
       }
-      observedValues = readables.map((x) => x.get());
-      isObserving = true;
-      updateValue2();
-    }, stopObserving2 = function() {
-      isObserving = false;
-      for (const callback of stopCallbacks) {
-        callback();
+    },
+    [OBSERVE]: (callback) => {
+      if (!isObserving) {
+        startObserving();
       }
-      stopCallbacks = [];
-    };
-    var updateValue = updateValue2, startObserving = startObserving2, stopObserving = stopObserving2;
-    const observers = [];
-    let stopCallbacks = [];
-    let isObserving = false;
-    let observedValues = [];
-    let latestComputedValue = UNOBSERVED;
-    return {
-      get: () => {
-        if (isObserving) {
-          return latestComputedValue;
-        } else {
-          return compute(...readables.map((x) => x.get()));
+      callback(latestComputedValue);
+      observers.push(callback);
+      return function stop() {
+        observers.splice(observers.indexOf(callback), 1);
+        if (observers.length === 0) {
+          stopObserving();
         }
-      },
-      [OBSERVE]: (callback) => {
-        if (!isObserving) {
-          startObserving2();
-        }
-        callback(latestComputedValue);
-        observers.push(callback);
-        return function stop() {
-          observers.splice(observers.indexOf(callback), 1);
-          if (observers.length === 0) {
-            stopObserving2();
-          }
-        };
-      }
-    };
-  }
+      };
+    }
+  };
 }
 function writable(value) {
   if (isWritable(value)) {