mobx 6.13.5 → 6.13.7

package/dist/types/observableset.d.ts

@@ -13,15 +13,17 @@ export type ISetDidChange<T = any> = {
     type: "delete";
     oldValue: T;
 };
-export type ISetWillChange<T = any> = {
+export type ISetWillDeleteChange<T = any> = {
     type: "delete";
     object: ObservableSet<T>;
     oldValue: T;
-} | {
+};
+export type ISetWillAddChange<T = any> = {
     type: "add";
     object: ObservableSet<T>;
     newValue: T;
 };
+export type ISetWillChange<T = any> = ISetWillDeleteChange<T> | ISetWillAddChange<T>;
 export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
     name_: string;
     [$mobx]: {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.13.5",
+    "version": "6.13.7",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/types/observableset.ts

@@ -51,17 +51,20 @@ export type ISetDidChange<T = any> =
           oldValue: T
       }
 
+export type ISetWillDeleteChange<T = any> = {
+    type: "delete"
+    object: ObservableSet<T>
+    oldValue: T
+};
+export type ISetWillAddChange<T = any> = {
+    type: "add"
+    object: ObservableSet<T>
+    newValue: T
+};
+
 export type ISetWillChange<T = any> =
-    | {
-          type: "delete"
-          object: ObservableSet<T>
-          oldValue: T
-      }
-    | {
-          type: "add"
-          object: ObservableSet<T>
-          newValue: T
-      }
+    | ISetWillDeleteChange<T>
+    | ISetWillAddChange<T>
 
 export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
     [$mobx] = ObservableSetMarker
@@ -120,7 +123,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     add(value: T) {
         checkIfStateModificationsAreAllowed(this.atom_)
         if (hasInterceptors(this)) {
-            const change = interceptChange<ISetWillChange<T>>(this, {
+            const change = interceptChange<ISetWillAddChange<T>>(this, {
                 type: ADD,
                 object: this,
                 newValue: value
@@ -128,8 +131,10 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
             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(() => {
@@ -164,7 +169,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
 
     delete(value: T) {
         if (hasInterceptors(this)) {
-            const change = interceptChange<ISetWillChange<T>>(this, {
+            const change = interceptChange<ISetWillDeleteChange<T>>(this, {
                 type: DELETE,
                 object: this,
                 oldValue: value
@@ -211,16 +216,11 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
 
     entries() {
-        let nextIndex = 0
-        const keys = Array.from(this.keys())
-        const values = Array.from(this.values())
+        const values = this.values()
         return makeIterableForSet<[T, T]>({
             next() {
-                const index = nextIndex
-                nextIndex += 1
-                return index < values.length
-                    ? { value: [keys[index], values[index]], done: false }
-                    : { value: undefined, done: true }
+                const { value, done } = values.next()
+                return !done ? { value: [value, value], done } : { value: undefined, done }
             }
         })
     }
@@ -232,13 +232,13 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     values(): SetIterator<T> {
         this.atom_.reportObserved()
         const self = this
-        let nextIndex = 0
-        const observableValues = Array.from(this.data_.values())
+        const values = this.data_.values()
         return makeIterableForSet({
             next() {
-                return nextIndex < observableValues.length
-                    ? { value: self.dehanceValue_(observableValues[nextIndex++]), done: false }
-                    : { value: undefined, done: true }
+                const { value, done } = values.next()
+                return !done
+                    ? { value: self.dehanceValue_(value), done }
+                    : { value: undefined, done }
             }
         })
     }

package/src/utils/eq.ts

@@ -17,6 +17,8 @@ export function deepEqual(a: any, b: any, depth: number = -1): boolean {
 }
 
 // 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: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     // Identical objects are equal. `0 === -0`, but they aren't identical.
@@ -149,15 +151,14 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     } else {
         // Deep compare objects.
         const keys = Object.keys(a)
-        let key
-        length = keys.length
+        const length = keys.length
         // Ensure that both objects contain the same number of properties before comparing deep equality.
         if (Object.keys(b).length !== length) {
             return false
         }
-        while (length--) {
+        for (let i = 0; i < length; i++) {
             // Deep compare each member
-            key = keys[length]
+            const key = keys[i]
             if (!(hasProp(b, key) && eq(a[key], b[key], depth - 1, aStack, bStack))) {
                 return false
             }