mobx 6.3.13 → 6.4.0

package/src/types/modifiers.ts

@@ -23,13 +23,23 @@ export interface IEnhancer<T> {
 
 export function deepEnhancer(v, _, name) {
     // it is an observable already, done
-    if (isObservable(v)) return v
+    if (isObservable(v)) {
+        return v
+    }
 
     // something that can be converted and mutated?
-    if (Array.isArray(v)) return observable.array(v, { name })
-    if (isPlainObject(v)) return observable.object(v, undefined, { name })
-    if (isES6Map(v)) return observable.map(v, { name })
-    if (isES6Set(v)) return observable.set(v, { name })
+    if (Array.isArray(v)) {
+        return observable.array(v, { name })
+    }
+    if (isPlainObject(v)) {
+        return observable.object(v, undefined, { name })
+    }
+    if (isES6Map(v)) {
+        return observable.map(v, { name })
+    }
+    if (isES6Set(v)) {
+        return observable.set(v, { name })
+    }
     if (typeof v === "function" && !isAction(v) && !isFlow(v)) {
         if (isGenerator(v)) {
             return flow(v)
@@ -41,18 +51,30 @@ export function deepEnhancer(v, _, name) {
 }
 
 export function shallowEnhancer(v, _, name): any {
-    if (v === undefined || v === null) return v
-    if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v) || isObservableSet(v))
+    if (v === undefined || v === null) {
+        return v
+    }
+    if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v) || isObservableSet(v)) {
         return v
-    if (Array.isArray(v)) return observable.array(v, { name, deep: false })
-    if (isPlainObject(v)) return observable.object(v, undefined, { name, deep: false })
-    if (isES6Map(v)) return observable.map(v, { name, deep: false })
-    if (isES6Set(v)) return observable.set(v, { name, deep: false })
+    }
+    if (Array.isArray(v)) {
+        return observable.array(v, { name, deep: false })
+    }
+    if (isPlainObject(v)) {
+        return observable.object(v, undefined, { name, deep: false })
+    }
+    if (isES6Map(v)) {
+        return observable.map(v, { name, deep: false })
+    }
+    if (isES6Set(v)) {
+        return observable.set(v, { name, deep: false })
+    }
 
-    if (__DEV__)
+    if (__DEV__) {
         die(
             "The shallow modifier / decorator can only used in combination with arrays, objects, maps and sets"
         )
+    }
 }
 
 export function referenceEnhancer(newValue?) {
@@ -61,8 +83,11 @@ export function referenceEnhancer(newValue?) {
 }
 
 export function refStructEnhancer(v, oldValue): any {
-    if (__DEV__ && isObservable(v))
+    if (__DEV__ && isObservable(v)) {
         die(`observable.struct should not be used with observable values`)
-    if (deepEqual(v, oldValue)) return oldValue
+    }
+    if (deepEqual(v, oldValue)) {
+        return oldValue
+    }
     return v
 }

package/src/types/observablearray.ts

@@ -84,8 +84,12 @@ export interface IArrayWillSplice<T = any> {
 const arrayTraps = {
     get(target, name) {
         const adm: ObservableArrayAdministration = target[$mobx]
-        if (name === $mobx) return adm
-        if (name === "length") return adm.getArrayLength_()
+        if (name === $mobx) {
+            return adm
+        }
+        if (name === "length") {
+            return adm.getArrayLength_()
+        }
         if (typeof name === "string" && !isNaN(name as any)) {
             return adm.get_(parseInt(name))
         }
@@ -113,7 +117,8 @@ const arrayTraps = {
 }
 
 export class ObservableArrayAdministration
-    implements IInterceptable<IArrayWillChange<any> | IArrayWillSplice<any>>, IListenable {
+    implements IInterceptable<IArrayWillChange<any> | IArrayWillSplice<any>>, IListenable
+{
     atom_: IAtom
     readonly values_: any[] = [] // this is the prop that gets proxied, so can't replace it!
     interceptors_
@@ -135,13 +140,16 @@ export class ObservableArrayAdministration
     }
 
     dehanceValue_(value: any): any {
-        if (this.dehancer !== undefined) return this.dehancer(value)
+        if (this.dehancer !== undefined) {
+            return this.dehancer(value)
+        }
         return value
     }
 
     dehanceValues_(values: any[]): any[] {
-        if (this.dehancer !== undefined && values.length > 0)
+        if (this.dehancer !== undefined && values.length > 0) {
             return values.map(this.dehancer) as any
+        }
         return values
     }
 
@@ -175,36 +183,56 @@ export class ObservableArrayAdministration
     }
 
     setArrayLength_(newLength: number) {
-        if (typeof newLength !== "number" || isNaN(newLength) || newLength < 0)
+        if (typeof newLength !== "number" || isNaN(newLength) || newLength < 0) {
             die("Out of range: " + newLength)
+        }
         let currentLength = this.values_.length
-        if (newLength === currentLength) return
-        else if (newLength > currentLength) {
+        if (newLength === currentLength) {
+            return
+        } else if (newLength > currentLength) {
             const newItems = new Array(newLength - currentLength)
-            for (let i = 0; i < newLength - currentLength; i++) newItems[i] = undefined // No Array.fill everywhere...
+            for (let i = 0; i < newLength - currentLength; i++) {
+                newItems[i] = undefined
+            } // No Array.fill everywhere...
             this.spliceWithArray_(currentLength, 0, newItems)
-        } else this.spliceWithArray_(newLength, currentLength - newLength)
+        } else {
+            this.spliceWithArray_(newLength, currentLength - newLength)
+        }
     }
 
     updateArrayLength_(oldLength: number, delta: number) {
-        if (oldLength !== this.lastKnownLength_) die(16)
+        if (oldLength !== this.lastKnownLength_) {
+            die(16)
+        }
         this.lastKnownLength_ += delta
-        if (this.legacyMode_ && delta > 0) reserveArrayBuffer(oldLength + delta + 1)
+        if (this.legacyMode_ && delta > 0) {
+            reserveArrayBuffer(oldLength + delta + 1)
+        }
     }
 
     spliceWithArray_(index: number, deleteCount?: number, newItems?: any[]): any[] {
         checkIfStateModificationsAreAllowed(this.atom_)
         const length = this.values_.length
 
-        if (index === undefined) index = 0
-        else if (index > length) index = length
-        else if (index < 0) index = Math.max(0, length + index)
+        if (index === undefined) {
+            index = 0
+        } else if (index > length) {
+            index = length
+        } else if (index < 0) {
+            index = Math.max(0, length + index)
+        }
 
-        if (arguments.length === 1) deleteCount = length - index
-        else if (deleteCount === undefined || deleteCount === null) deleteCount = 0
-        else deleteCount = Math.max(0, Math.min(deleteCount, length - index))
+        if (arguments.length === 1) {
+            deleteCount = length - index
+        } else if (deleteCount === undefined || deleteCount === null) {
+            deleteCount = 0
+        } else {
+            deleteCount = Math.max(0, Math.min(deleteCount, length - index))
+        }
 
-        if (newItems === undefined) newItems = EMPTY_ARRAY
+        if (newItems === undefined) {
+            newItems = EMPTY_ARRAY
+        }
 
         if (hasInterceptors(this)) {
             const change = interceptChange<IArrayWillSplice<any>>(this as any, {
@@ -214,7 +242,9 @@ export class ObservableArrayAdministration
                 removedCount: deleteCount,
                 added: newItems
             })
-            if (!change) return EMPTY_ARRAY
+            if (!change) {
+                return EMPTY_ARRAY
+            }
             deleteCount = change.removedCount
             newItems = change.added
         }
@@ -227,8 +257,9 @@ export class ObservableArrayAdministration
         }
         const res = this.spliceItemsIntoValues_(index, deleteCount, newItems)
 
-        if (deleteCount !== 0 || newItems.length !== 0)
+        if (deleteCount !== 0 || newItems.length !== 0) {
             this.notifyArraySplice_(index, newItems, res)
+        }
         return this.dehanceValues_(res)
     }
 
@@ -242,9 +273,12 @@ export class ObservableArrayAdministration
             let oldItems = this.values_.slice(index + deleteCount)
             // New length is the previous length + addition count - deletion count
             this.values_.length += newItems.length - deleteCount
-            for (let i = 0; i < newItems.length; i++) this.values_[index + i] = newItems[i]
-            for (let i = 0; i < oldItems.length; i++)
+            for (let i = 0; i < newItems.length; i++) {
+                this.values_[index + i] = newItems[i]
+            }
+            for (let i = 0; i < oldItems.length; i++) {
                 this.values_[index + newItems.length + i] = oldItems[i]
+            }
             return res
         }
     }
@@ -267,10 +301,16 @@ export class ObservableArrayAdministration
 
         // The reason why this is on right hand side here (and not above), is this way the uglifier will drop it, but it won't
         // cause any runtime overhead in development mode without NODE_ENV set, unless spying is enabled
-        if (__DEV__ && notifySpy) spyReportStart(change!)
+        if (__DEV__ && notifySpy) {
+            spyReportStart(change!)
+        }
         this.atom_.reportChanged()
-        if (notify) notifyListeners(this, change)
-        if (__DEV__ && notifySpy) spyReportEnd()
+        if (notify) {
+            notifyListeners(this, change)
+        }
+        if (__DEV__ && notifySpy) {
+            spyReportEnd()
+        }
     }
 
     notifyArraySplice_(index: number, added: any[], removed: any[]) {
@@ -291,11 +331,17 @@ export class ObservableArrayAdministration
                   } as const)
                 : null
 
-        if (__DEV__ && notifySpy) spyReportStart(change!)
+        if (__DEV__ && notifySpy) {
+            spyReportStart(change!)
+        }
         this.atom_.reportChanged()
         // conform: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/observe
-        if (notify) notifyListeners(this, change)
-        if (__DEV__ && notifySpy) spyReportEnd()
+        if (notify) {
+            notifyListeners(this, change)
+        }
+        if (__DEV__ && notifySpy) {
+            spyReportEnd()
+        }
     }
 
     get_(index: number): any | undefined {
@@ -323,7 +369,9 @@ export class ObservableArrayAdministration
                     index,
                     newValue
                 })
-                if (!change) return
+                if (!change) {
+                    return
+                }
                 newValue = change.newValue
             }
             newValue = this.enhancer_(newValue, oldValue)

package/src/types/observablemap.ts

@@ -118,7 +118,9 @@ export class ObservableMap<K = any, V = any>
     }
 
     has(key: K): boolean {
-        if (!globalState.trackingDerivation) return this.has_(key)
+        if (!globalState.trackingDerivation) {
+            return this.has_(key)
+        }
 
         let entry = this.hasMap_.get(key)
         if (!entry) {
@@ -144,7 +146,9 @@ export class ObservableMap<K = any, V = any>
                 newValue: value,
                 name: key
             })
-            if (!change) return this
+            if (!change) {
+                return this
+            }
             value = change.newValue!
         }
         if (hasKey) {
@@ -163,7 +167,9 @@ export class ObservableMap<K = any, V = any>
                 object: this,
                 name: key
             })
-            if (!change) return false
+            if (!change) {
+                return false
+            }
         }
         if (this.has_(key)) {
             const notifySpy = isSpyEnabled()
@@ -180,7 +186,9 @@ export class ObservableMap<K = any, V = any>
                       }
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change! as PureSpyEvent) // TODO fix type
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change! as PureSpyEvent)
+            } // TODO fix type
             transaction(() => {
                 this.keysAtom_.reportChanged()
                 this.hasMap_.get(key)?.setNewValue_(false)
@@ -188,8 +196,12 @@ export class ObservableMap<K = any, V = any>
                 observable.setNewValue_(undefined as any)
                 this.data_.delete(key)
             })
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
             return true
         }
         return false
@@ -213,10 +225,16 @@ export class ObservableMap<K = any, V = any>
                           newValue
                       }
                     : null
-            if (__DEV__ && notifySpy) spyReportStart(change! as PureSpyEvent) // TODO fix type
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change! as PureSpyEvent)
+            } // TODO fix type
             observable.setNewValue_(newValue as V)
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
     }
 
@@ -247,13 +265,21 @@ export class ObservableMap<K = any, V = any>
                       newValue
                   }
                 : null
-        if (__DEV__ && notifySpy) spyReportStart(change! as PureSpyEvent) // TODO fix type
-        if (notify) notifyListeners(this, change)
-        if (__DEV__ && notifySpy) spyReportEnd()
+        if (__DEV__ && notifySpy) {
+            spyReportStart(change! as PureSpyEvent)
+        } // TODO fix type
+        if (notify) {
+            notifyListeners(this, change)
+        }
+        if (__DEV__ && notifySpy) {
+            spyReportEnd()
+        }
     }
 
     get(key: K): V | undefined {
-        if (this.has(key)) return this.dehanceValue_(this.data_.get(key)!.get())
+        if (this.has(key)) {
+            return this.dehanceValue_(this.data_.get(key)!.get())
+        }
         return this.dehanceValue_(undefined)
     }
 
@@ -302,24 +328,31 @@ export class ObservableMap<K = any, V = any>
     }
 
     forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?) {
-        for (const [key, value] of this) callback.call(thisArg, value, key, this)
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this)
+        }
     }
 
     /** Merge another object into this object, returns this. */
-    merge(other: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V> {
+    merge(other?: IObservableMapInitialValues<K, V>): ObservableMap<K, V> {
         if (isObservableMap(other)) {
             other = new Map(other)
         }
         transaction(() => {
-            if (isPlainObject(other))
+            if (isPlainObject(other)) {
                 getPlainObjectKeys(other).forEach((key: any) =>
-                    this.set(key as any as K, other[key])
+                    this.set(key as K, (other as IKeyValueMap)[key])
                 )
-            else if (Array.isArray(other)) other.forEach(([key, value]) => this.set(key, value))
-            else if (isES6Map(other)) {
-                if (other.constructor !== Map) die(19, other)
+            } else if (Array.isArray(other)) {
+                other.forEach(([key, value]) => this.set(key, value))
+            } else if (isES6Map(other)) {
+                if (other.constructor !== Map) {
+                    die(19, other)
+                }
                 other.forEach((value, key) => this.set(key, value))
-            } else if (other !== null && other !== undefined) die(20, other)
+            } else if (other !== null && other !== undefined) {
+                die(20, other)
+            }
         })
         return this
     }
@@ -327,12 +360,14 @@ export class ObservableMap<K = any, V = any>
     clear() {
         transaction(() => {
             untracked(() => {
-                for (const key of this.keys()) this.delete(key)
+                for (const key of this.keys()) {
+                    this.delete(key)
+                }
             })
         })
     }
 
-    replace(values: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V> {
+    replace(values: IObservableMapInitialValues<K, V>): ObservableMap<K, V> {
         // Implementation requirements:
         // - respect ordering of replacement map
         // - allow interceptors to run and potentially prevent individual operations
@@ -433,8 +468,9 @@ export class ObservableMap<K = any, V = any>
      * for callback details
      */
     observe_(listener: (changes: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda {
-        if (__DEV__ && fireImmediately === true)
+        if (__DEV__ && fireImmediately === true) {
             die("`observe` doesn't support fireImmediately=true in combination with maps.")
+        }
         return registerListener(this, listener)
     }
 

package/src/types/observableobject.ts

@@ -136,7 +136,9 @@ export class ObservableObjectAdministration
                 name: key,
                 newValue
             })
-            if (!change) return null
+            if (!change) {
+                return null
+            }
             newValue = (change as any).newValue
         }
         newValue = (observable as any).prepareNewValue_(newValue)
@@ -158,10 +160,16 @@ export class ObservableObjectAdministration
                       }
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change!)
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change!)
+            }
             ;(observable as ObservableValue<any>).setNewValue_(newValue)
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
         return true
     }
@@ -256,8 +264,12 @@ export class ObservableObjectAdministration
             const descriptor = getDescriptor(source, key)
             if (descriptor) {
                 const outcome = annotation.make_(this, key, descriptor, source)
-                if (outcome === MakeResult.Cancel) return
-                if (outcome === MakeResult.Break) break
+                if (outcome === MakeResult.Cancel) {
+                    return
+                }
+                if (outcome === MakeResult.Break) {
+                    break
+                }
             }
             source = Object.getPrototypeOf(source)
         }
@@ -320,7 +332,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: descriptor.value
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
                 const { newValue } = change as any
                 if (descriptor.value !== newValue) {
                     descriptor = {
@@ -372,7 +386,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: value
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
                 value = (change as any).newValue
             }
 
@@ -434,7 +450,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: undefined
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
             }
             options.name ||= __DEV__ ? `${this.name_}.${key.toString()}` : "ObservableObject.key"
             options.context = this.proxy_ || this.target_
@@ -485,7 +503,9 @@ export class ObservableObjectAdministration
                 type: REMOVE
             })
             // Cancelled
-            if (!change) return null
+            if (!change) {
+                return null
+            }
         }
 
         // Delete
@@ -539,9 +559,15 @@ export class ObservableObjectAdministration
                     oldValue: value,
                     name: key
                 }
-                if (__DEV__ && notifySpy) spyReportStart(change!)
-                if (notify) notifyListeners(this, change)
-                if (__DEV__ && notifySpy) spyReportEnd()
+                if (__DEV__ && notifySpy) {
+                    spyReportStart(change!)
+                }
+                if (notify) {
+                    notifyListeners(this, change)
+                }
+                if (__DEV__ && notifySpy) {
+                    spyReportEnd()
+                }
             }
         } finally {
             endBatch()
@@ -555,8 +581,9 @@ export class ObservableObjectAdministration
      * for callback details
      */
     observe_(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda {
-        if (__DEV__ && fireImmediately === true)
+        if (__DEV__ && fireImmediately === true) {
             die("`observe` doesn't support the fire immediately property for observable objects.")
+        }
         return registerListener(this, callback)
     }
 
@@ -580,9 +607,15 @@ export class ObservableObjectAdministration
                       } as const)
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change!)
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change!)
+            }
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
 
         this.pendingKeys_?.get(key)?.set(true)
@@ -631,8 +664,9 @@ export function asObservableObject(
         return target
     }
 
-    if (__DEV__ && !Object.isExtensible(target))
+    if (__DEV__ && !Object.isExtensible(target)) {
         die("Cannot make the designated object observable; it is not extensible")
+    }
 
     const name =
         options?.name ??

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)
     }