mobx 6.13.5 → 6.13.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # mobx
 
+## 6.13.7
+
+### Patch Changes
+
+-   [`54e3f71ca02f09b3107290f18d8484b70a6e2f0b`](https://github.com/mobxjs/mobx/commit/54e3f71ca02f09b3107290f18d8484b70a6e2f0b) [#4528](https://github.com/mobxjs/mobx/pull/4528) Thanks [@k-g-a](https://github.com/k-g-a)! - Fix observable.set not respecting the new value from interceptors
+
+## 6.13.6
+
+### Patch Changes
+
+-   [`bca3841347f4fba50ad910e1c4176c56ba0173d1`](https://github.com/mobxjs/mobx/commit/bca3841347f4fba50ad910e1c4176c56ba0173d1) [#3993](https://github.com/mobxjs/mobx/pull/3993) Thanks [@tonyraoul](https://github.com/tonyraoul)! - Improve observableset memory footprint and performance
+
 ## 6.13.5
 
 ### Patch Changes

package/dist/mobx.cjs.development.js

@@ -4682,8 +4682,8 @@ var ObservableSet = /*#__PURE__*/function () {
       if (!change) {
         return this;
       }
-      // ideally, value = change.value would be done here, so that values can be
-      // changed by interceptor. Same applies for other Set and Map api's.
+      // implemented reassignment same as it's done for ObservableMap
+      value = change.newValue;
     }
     if (!this.has(value)) {
       transaction(function () {
@@ -4755,19 +4755,18 @@ var ObservableSet = /*#__PURE__*/function () {
     return this.data_.has(this.dehanceValue_(value));
   };
   _proto.entries = function entries() {
-    var nextIndex = 0;
-    var keys = Array.from(this.keys());
-    var values = Array.from(this.values());
+    var values = this.values();
     return makeIterableForSet({
       next: function next() {
-        var index = nextIndex;
-        nextIndex += 1;
-        return index < values.length ? {
-          value: [keys[index], values[index]],
-          done: false
+        var _values$next = values.next(),
+          value = _values$next.value,
+          done = _values$next.done;
+        return !done ? {
+          value: [value, value],
+          done: done
         } : {
           value: undefined,
-          done: true
+          done: done
         };
       }
     });
@@ -4778,16 +4777,18 @@ var ObservableSet = /*#__PURE__*/function () {
   _proto.values = function values() {
     this.atom_.reportObserved();
     var self = this;
-    var nextIndex = 0;
-    var observableValues = Array.from(this.data_.values());
+    var values = this.data_.values();
     return makeIterableForSet({
       next: function next() {
-        return nextIndex < observableValues.length ? {
-          value: self.dehanceValue_(observableValues[nextIndex++]),
-          done: false
+        var _values$next2 = values.next(),
+          value = _values$next2.value,
+          done = _values$next2.done;
+        return !done ? {
+          value: self.dehanceValue_(value),
+          done: done
         } : {
           value: undefined,
-          done: true
+          done: done
         };
       }
     });
@@ -5737,6 +5738,8 @@ function deepEqual(a, b, depth) {
   return eq(a, b, depth);
 }
 // Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289
+// Modified: "Deep compare objects" part to iterate over keys in forward order instead of reverse order.
+//
 // Internal recursive comparison function for `isEqual`.
 function eq(a, b, depth, aStack, bStack) {
   // Identical objects are equal. `0 === -0`, but they aren't identical.
@@ -5849,15 +5852,14 @@ function eq(a, b, depth, aStack, bStack) {
   } else {
     // Deep compare objects.
     var keys = Object.keys(a);
-    var key;
-    length = keys.length;
+    var _length = keys.length;
     // Ensure that both objects contain the same number of properties before comparing deep equality.
-    if (Object.keys(b).length !== length) {
+    if (Object.keys(b).length !== _length) {
       return false;
     }
-    while (length--) {
+    for (var i = 0; i < _length; i++) {
       // Deep compare each member
-      key = keys[length];
+      var key = keys[i];
       if (!(hasProp(b, key) && eq(a[key], b[key], depth - 1, aStack, bStack))) {
         return false;
       }