mobx 6.3.10 → 6.4.0

package/src/types/observableset.ts

@@ -96,7 +96,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     clear() {
         transaction(() => {
             untracked(() => {
-                for (const value of this.data_.values()) this.delete(value)
+                for (const value of this.data_.values()) {
+                    this.delete(value)
+                }
             })
         })
     }
@@ -120,7 +122,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                 object: this,
                 newValue: value
             })
-            if (!change) return this
+            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.
         }
@@ -141,9 +145,15 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                           newValue: value
                       }
                     : null
-            if (notifySpy && __DEV__) spyReportStart(change!)
-            if (notify) notifyListeners(this, change)
-            if (notifySpy && __DEV__) spyReportEnd()
+            if (notifySpy && __DEV__) {
+                spyReportStart(change!)
+            }
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (notifySpy && __DEV__) {
+                spyReportEnd()
+            }
         }
 
         return this
@@ -156,7 +166,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                 object: this,
                 oldValue: value
             })
-            if (!change) return false
+            if (!change) {
+                return false
+            }
         }
         if (this.has(value)) {
             const notifySpy = __DEV__ && isSpyEnabled()
@@ -172,13 +184,19 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                       }
                     : null
 
-            if (notifySpy && __DEV__) spyReportStart(change!)
+            if (notifySpy && __DEV__) {
+                spyReportStart(change!)
+            }
             transaction(() => {
                 this.atom_.reportChanged()
                 this.data_.delete(value)
             })
-            if (notify) notifyListeners(this, change)
-            if (notifySpy && __DEV__) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (notifySpy && __DEV__) {
+                spyReportEnd()
+            }
             return true
         }
         return false
@@ -243,8 +261,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
     observe_(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda {
         // ... 'fireImmediately' could also be true?
-        if (__DEV__ && fireImmediately === true)
+        if (__DEV__ && fireImmediately === true) {
             die("`observe` doesn't support fireImmediately=true in combination with sets.")
+        }
         return registerListener(this, listener)
     }
 

package/src/types/observablevalue.ts

@@ -61,7 +61,8 @@ const CREATE = "create"
 
 export class ObservableValue<T>
     extends Atom
-    implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
+    implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable
+{
     hasUnreportedChange_ = false
     interceptors_
     changeListeners_
@@ -90,7 +91,9 @@ export class ObservableValue<T>
     }
 
     private dehanceValue(value: T): T {
-        if (this.dehancer !== undefined) return this.dehancer(value)
+        if (this.dehancer !== undefined) {
+            return this.dehancer(value)
+        }
         return value
     }
 
@@ -110,7 +113,9 @@ export class ObservableValue<T>
                 })
             }
             this.setNewValue_(newValue)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
     }
 
@@ -122,7 +127,9 @@ export class ObservableValue<T>
                 type: UPDATE,
                 newValue
             })
-            if (!change) return globalState.UNCHANGED
+            if (!change) {
+                return globalState.UNCHANGED
+            }
             newValue = change.newValue
         }
         // apply modifier
@@ -154,7 +161,7 @@ export class ObservableValue<T>
     }
 
     observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda {
-        if (fireImmediately)
+        if (fireImmediately) {
             listener({
                 observableKind: "value",
                 debugObjectName: this.name_,
@@ -163,6 +170,7 @@ export class ObservableValue<T>
                 newValue: this.value_,
                 oldValue: undefined
             })
+        }
         return registerListener(this, listener)
     }
 

package/src/types/type-utils.ts

@@ -16,23 +16,35 @@ import {
 export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
     if (typeof thing === "object" && thing !== null) {
         if (isObservableArray(thing)) {
-            if (property !== undefined) die(23)
+            if (property !== undefined) {
+                die(23)
+            }
             return (thing as any)[$mobx].atom_
         }
         if (isObservableSet(thing)) {
             return (thing as any)[$mobx]
         }
         if (isObservableMap(thing)) {
-            if (property === undefined) return thing.keysAtom_
+            if (property === undefined) {
+                return thing.keysAtom_
+            }
             const observable = thing.data_.get(property) || thing.hasMap_.get(property)
-            if (!observable) die(25, property, getDebugName(thing))
+            if (!observable) {
+                die(25, property, getDebugName(thing))
+            }
             return observable
         }
-        if (property && !thing[$mobx]) thing[property] // See #1072
+        if (property && !thing[$mobx]) {
+            thing[property]
+        } // See #1072
         if (isObservableObject(thing)) {
-            if (!property) return die(26)
+            if (!property) {
+                return die(26)
+            }
             const observable = (thing as any)[$mobx].values_.get(property)
-            if (!observable) die(27, property, getDebugName(thing))
+            if (!observable) {
+                die(27, property, getDebugName(thing))
+            }
             return observable
         }
         if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {
@@ -48,11 +60,21 @@ export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
 }
 
 export function getAdministration(thing: any, property?: string) {
-    if (!thing) die(29)
-    if (property !== undefined) return getAdministration(getAtom(thing, property))
-    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) return thing
-    if (isObservableMap(thing) || isObservableSet(thing)) return thing
-    if (thing[$mobx]) return thing[$mobx]
+    if (!thing) {
+        die(29)
+    }
+    if (property !== undefined) {
+        return getAdministration(getAtom(thing, property))
+    }
+    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {
+        return thing
+    }
+    if (isObservableMap(thing) || isObservableSet(thing)) {
+        return thing
+    }
+    if (thing[$mobx]) {
+        return thing[$mobx]
+    }
     die(24, thing)
 }
 

package/src/utils/comparer.ts

@@ -17,11 +17,11 @@ function shallowComparer(a: any, b: any): boolean {
 }
 
 function defaultComparer(a: any, b: any): boolean {
-    if (Object.is) return Object.is(a, b)
+    if (Object.is) {
+        return Object.is(a, b)
+    }
 
-    return a === b
-        ? a !== 0 || 1 / a === 1 / b
-        : a !== a && b !== b
+    return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b
 }
 
 export const comparer = {

package/src/utils/eq.ts

@@ -21,18 +21,28 @@ export function deepEqual(a: any, b: any, depth: number = -1): boolean {
 function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     // Identical objects are equal. `0 === -0`, but they aren't identical.
     // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
-    if (a === b) return a !== 0 || 1 / a === 1 / b
+    if (a === b) {
+        return a !== 0 || 1 / a === 1 / b
+    }
     // `null` or `undefined` only equal to itself (strict comparison).
-    if (a == null || b == null) return false
+    if (a == null || b == null) {
+        return false
+    }
     // `NaN`s are equivalent, but non-reflexive.
-    if (a !== a) return b !== b
+    if (a !== a) {
+        return b !== b
+    }
     // Exhaust primitive checks
     const type = typeof a
-    if (type !== "function" && type !== "object" && typeof b != "object") return false
+    if (type !== "function" && type !== "object" && typeof b != "object") {
+        return false
+    }
 
     // Compare `[[Class]]` names.
     const className = toString.call(a)
-    if (className !== toString.call(b)) return false
+    if (className !== toString.call(b)) {
+        return false
+    }
     switch (className) {
         // Strings, numbers, regular expressions, dates, and booleans are compared by value.
         case "[object RegExp]":
@@ -44,7 +54,9 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
         case "[object Number]":
             // `NaN`s are equivalent, but non-reflexive.
             // Object(NaN) is equivalent to NaN.
-            if (+a !== +a) return +b !== +b
+            if (+a !== +a) {
+                return +b !== +b
+            }
             // An `egal` comparison is performed for other numeric values.
             return +a === 0 ? 1 / +a === 1 / b : +a === +b
         case "[object Date]":
@@ -72,7 +84,9 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
 
     const areArrays = className === "[object Array]"
     if (!areArrays) {
-        if (typeof a != "object" || typeof b != "object") return false
+        if (typeof a != "object" || typeof b != "object") {
+            return false
+        }
 
         // Objects with different constructors are not equivalent, but `Object`s or `Array`s
         // from different frames are.
@@ -110,7 +124,9 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     while (length--) {
         // Linear search. Performance is inversely proportional to the number of
         // unique nested structures.
-        if (aStack[length] === a) return bStack[length] === b
+        if (aStack[length] === a) {
+            return bStack[length] === b
+        }
     }
 
     // Add the first object to the stack of traversed objects.
@@ -121,10 +137,14 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     if (areArrays) {
         // Compare array lengths to determine if a deep comparison is necessary.
         length = a.length
-        if (length !== b.length) return false
+        if (length !== b.length) {
+            return false
+        }
         // Deep compare the contents, ignoring non-numeric properties.
         while (length--) {
-            if (!eq(a[length], b[length], depth - 1, aStack, bStack)) return false
+            if (!eq(a[length], b[length], depth - 1, aStack, bStack)) {
+                return false
+            }
         }
     } else {
         // Deep compare objects.
@@ -132,11 +152,15 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
         let key
         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
+        if (Object.keys(b).length !== length) {
+            return false
+        }
         while (length--) {
             // Deep compare each member
             key = keys[length]
-            if (!(hasProp(b, key) && eq(a[key], b[key], depth - 1, aStack, bStack))) return false
+            if (!(hasProp(b, key) && eq(a[key], b[key], depth - 1, aStack, bStack))) {
+                return false
+            }
         }
     }
     // Remove the first object from the stack of traversed objects.
@@ -146,8 +170,14 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
 }
 
 function unwrap(a: any) {
-    if (isObservableArray(a)) return a.slice()
-    if (isES6Map(a) || isObservableMap(a)) return Array.from(a.entries())
-    if (isES6Set(a) || isObservableSet(a)) return Array.from(a.entries())
+    if (isObservableArray(a)) {
+        return a.slice()
+    }
+    if (isES6Map(a) || isObservableMap(a)) {
+        return Array.from(a.entries())
+    }
+    if (isES6Set(a) || isObservableSet(a)) {
+        return Array.from(a.entries())
+    }
     return a
 }

package/src/utils/utils.ts

@@ -34,7 +34,7 @@ export function warnAboutProxyRequirement(msg: string) {
     if (__DEV__ && globalState.verifyProxies) {
         die(
             "MobX is currently configured to be able to run in ES5 mode, but in ES5 MobX won't be able to " +
-            msg
+                msg
         )
     }
 }
@@ -49,13 +49,15 @@ export function getNextId() {
 export function once(func: Lambda): Lambda {
     let invoked = false
     return function () {
-        if (invoked) return
+        if (invoked) {
+            return
+        }
         invoked = true
         return (func as any).apply(this, arguments)
     }
 }
 
-export const noop = () => { }
+export const noop = () => {}
 
 export function isFunction(fn: any): fn is Function {
     return typeof fn === "function"
@@ -80,20 +82,32 @@ export function isObject(value: any): value is Object {
     return value !== null && typeof value === "object"
 }
 
-export function isPlainObject(value) {
-    if (!isObject(value)) return false
+export function isPlainObject(value: any) {
+    if (!isObject(value)) {
+        return false
+    }
     const proto = Object.getPrototypeOf(value)
-    if (proto == null) return true
-    const protoConstructor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-    return typeof protoConstructor === "function" && protoConstructor.toString() === plainObjectString
+    if (proto == null) {
+        return true
+    }
+    const protoConstructor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor
+    return (
+        typeof protoConstructor === "function" && protoConstructor.toString() === plainObjectString
+    )
 }
 
 // https://stackoverflow.com/a/37865170
 export function isGenerator(obj: any): boolean {
     const constructor = obj?.constructor
-    if (!constructor) return false
-    if ("GeneratorFunction" === constructor.name || "GeneratorFunction" === constructor.displayName)
+    if (!constructor) {
+        return false
+    }
+    if (
+        "GeneratorFunction" === constructor.name ||
+        "GeneratorFunction" === constructor.displayName
+    ) {
         return true
+    }
     return false
 }
 
@@ -126,11 +140,11 @@ export function createInstanceofPredicate<T>(
     } as any
 }
 
-export function isES6Map(thing): boolean {
+export function isES6Map(thing: any): thing is Map<any, any> {
     return thing instanceof Map
 }
 
-export function isES6Set(thing): thing is Set<any> {
+export function isES6Set(thing: any): thing is Set<any> {
     return thing instanceof Set
 }
 
@@ -139,12 +153,16 @@ const hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== "undefi
 /**
  * Returns the following: own enumerable keys and symbols.
  */
-export function getPlainObjectKeys(object) {
+export function getPlainObjectKeys(object: any) {
     const keys = Object.keys(object)
     // Not supported in IE, so there are not going to be symbol props anyway...
-    if (!hasGetOwnPropertySymbols) return keys
+    if (!hasGetOwnPropertySymbols) {
+        return keys
+    }
     const symbols = Object.getOwnPropertySymbols(object)
-    if (!symbols.length) return keys
+    if (!symbols.length) {
+        return keys
+    }
     return [...keys, ...symbols.filter(s => objectPrototype.propertyIsEnumerable.call(object, s))]
 }
 
@@ -154,16 +172,20 @@ export const ownKeys: (target: any) => Array<string | symbol> =
     typeof Reflect !== "undefined" && Reflect.ownKeys
         ? Reflect.ownKeys
         : hasGetOwnPropertySymbols
-            ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj) as any)
-            : /* istanbul ignore next */ Object.getOwnPropertyNames
+        ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj) as any)
+        : /* istanbul ignore next */ Object.getOwnPropertyNames
 
 export function stringifyKey(key: any): string {
-    if (typeof key === "string") return key
-    if (typeof key === "symbol") return key.toString()
+    if (typeof key === "string") {
+        return key
+    }
+    if (typeof key === "symbol") {
+        return key.toString()
+    }
     return new String(key).toString()
 }
 
-export function toPrimitive(value) {
+export function toPrimitive(value: any) {
     return value === null ? null : typeof value === "object" ? "" + value : value
 }