mobx 6.1.8 → 6.9.0

package/src/types/modifiers.ts

@@ -9,7 +9,12 @@ import {
     isObservableObject,
     isPlainObject,
     observable,
-    die
+    die,
+    isAction,
+    autoAction,
+    flow,
+    isFlow,
+    isGenerator
 } from "../internal"
 
 export interface IEnhancer<T> {
@@ -18,30 +23,58 @@ 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)
+        } else {
+            return autoAction(name, v)
+        }
+    }
     return v
 }
 
 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?) {
@@ -50,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/observableannotation.ts

@@ -1,12 +1,9 @@
 import {
     ObservableObjectAdministration,
-    getDescriptor,
     deepEnhancer,
     die,
     Annotation,
-    recordAnnotationApplied,
-    objectPrototype,
-    storedAnnotationsSymbol
+    MakeResult
 } from "../internal"
 
 export function createObservableAnnotation(name: string, options?: object): Annotation {
@@ -18,36 +15,12 @@ export function createObservableAnnotation(name: string, options?: object): Anno
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let source = adm.target_
-    // Copy props from proto as well, see test:
-    // "decorate should work with Object.create"
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            assertObservableDescriptor(adm, this, key, descriptor)
-            const definePropertyOutcome = adm.defineObservableProperty_(
-                key,
-                descriptor.value,
-                this.options_?.enhancer ?? deepEnhancer
-            )
-            if (!definePropertyOutcome) {
-                // Intercepted
-                return
-            }
-            recordAnnotationApplied(adm, this, key)
-            return
-        }
-        source = Object.getPrototypeOf(source)
-    }
-    if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
-        // Throw on missing key, except for decorators:
-        // Decorator annotations are collected from whole prototype chain.
-        // When called from super() some props may not exist yet.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
-    }
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor
+): MakeResult {
+    return this.extend_(adm, key, descriptor, false) === null ? MakeResult.Cancel : MakeResult.Break
 }
 
 function extend_(

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,35 +183,56 @@ export class ObservableArrayAdministration
     }
 
     setArrayLength_(newLength: number) {
-        if (typeof newLength !== "number" || newLength < 0) die("Out of range: " + newLength)
+        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, {
@@ -213,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
         }
@@ -226,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)
     }
 
@@ -235,12 +267,18 @@ export class ObservableArrayAdministration
         if (newItems.length < MAX_SPLICE_SIZE) {
             return this.values_.splice(index, deleteCount, ...newItems)
         } else {
+            // The items removed by the splice
             const res = this.values_.slice(index, index + deleteCount)
+            // The items that that should remain at the end of the array
             let oldItems = this.values_.slice(index + deleteCount)
-            this.values_.length = index + 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++)
+            // 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++) {
                 this.values_[index + newItems.length + i] = oldItems[i]
+            }
             return res
         }
     }
@@ -263,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[]) {
@@ -287,27 +331,38 @@ 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 {
-        if (index < this.values_.length) {
-            this.atom_.reportObserved()
-            return this.dehanceValue_(this.values_[index])
-        }
-        console.warn(
-            __DEV__
-                ? `[mobx] Out of bounds read: ${index}`
-                : `[mobx.array] Attempt to read an array index (${index}) that is out of bounds (${this.values_.length}). Please check length first. Out of bound indices will not be tracked by MobX`
-        )
+        if (this.legacyMode_ && index >= this.values_.length) {
+            console.warn(
+                __DEV__
+                    ? `[mobx.array] Attempt to read an array index (${index}) that is out of bounds (${this.values_.length}). Please check length first. Out of bound indices will not be tracked by MobX`
+                    : `[mobx] Out of bounds read: ${index}`
+            )
+            return undefined
+        }
+        this.atom_.reportObserved()
+        return this.dehanceValue_(this.values_[index])
     }
 
     set_(index: number, newValue: any) {
         const values = this.values_
+        if (this.legacyMode_ && index > values.length) {
+            // out of bounds
+            die(17, index, values.length)
+        }
         if (index < values.length) {
             // update at index in range
             checkIfStateModificationsAreAllowed(this.atom_)
@@ -319,7 +374,9 @@ export class ObservableArrayAdministration
                     index,
                     newValue
                 })
-                if (!change) return
+                if (!change) {
+                    return
+                }
                 newValue = change.newValue
             }
             newValue = this.enhancer_(newValue, oldValue)
@@ -328,12 +385,16 @@ export class ObservableArrayAdministration
                 values[index] = newValue
                 this.notifyArrayChildUpdate_(index, newValue, oldValue)
             }
-        } else if (index === values.length) {
-            // add a new item
-            this.spliceWithArray_(index, 0, [newValue])
         } else {
-            // out of bounds
-            die(17, index, values.length)
+            // For out of bound index, we don't create an actual sparse array,
+            // but rather fill the holes with undefined (same as setArrayLength_).
+            // This could be considered a bug.
+            const newItems = new Array(index + 1 - values.length)
+            for (let i = 0; i < newItems.length - 1; i++) {
+                newItems[i] = undefined
+            } // No Array.fill everywhere...
+            newItems[newItems.length - 1] = newValue
+            this.spliceWithArray_(values.length, 0, newItems)
         }
     }
 }

package/src/types/observablemap.ts

@@ -33,7 +33,9 @@ import {
     die,
     isFunction,
     UPDATE,
-    IAtom
+    IAtom,
+    PureSpyEvent,
+    allowStateChanges
 } from "../internal"
 
 export interface IKeyValueMap<V = any> {
@@ -41,7 +43,9 @@ export interface IKeyValueMap<V = any> {
 }
 
 export type IMapEntry<K = any, V = any> = [K, V]
+export type IReadonlyMapEntry<K = any, V = any> = readonly [K, V]
 export type IMapEntries<K = any, V = any> = IMapEntry<K, V>[]
+export type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[]
 
 export type IMapDidChange<K = any, V = any> = { observableKind: "map"; debugObjectName: string } & (
     | {
@@ -79,6 +83,7 @@ export const DELETE = "delete"
 
 export type IObservableMapInitialValues<K = any, V = any> =
     | IMapEntries<K, V>
+    | IReadonlyMapEntries<K, V>
     | IKeyValueMap<V>
     | Map<K, V>
 
@@ -105,7 +110,9 @@ export class ObservableMap<K = any, V = any>
         this.keysAtom_ = createAtom(__DEV__ ? `${this.name_}.keys()` : "ObservableMap.keys()")
         this.data_ = new Map()
         this.hasMap_ = new Map()
-        this.merge(initialData)
+        allowStateChanges(true, () => {
+            this.merge(initialData)
+        })
     }
 
     private has_(key: K): boolean {
@@ -113,7 +120,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) {
@@ -139,7 +148,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) {
@@ -158,7 +169,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()
@@ -175,28 +188,27 @@ export class ObservableMap<K = any, V = any>
                       }
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change!)
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change! as PureSpyEvent)
+            } // TODO fix type
             transaction(() => {
                 this.keysAtom_.reportChanged()
-                this.updateHasMapEntry_(key, false)
+                this.hasMap_.get(key)?.setNewValue_(false)
                 const observable = this.data_.get(key)!
                 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
     }
 
-    private updateHasMapEntry_(key: K, value: boolean) {
-        let entry = this.hasMap_.get(key)
-        if (entry) {
-            entry.setNewValue_(value)
-        }
-    }
-
     private updateValue_(key: K, newValue: V | undefined) {
         const observable = this.data_.get(key)!
         newValue = (observable as any).prepareNewValue_(newValue) as V
@@ -215,10 +227,16 @@ export class ObservableMap<K = any, V = any>
                           newValue
                       }
                     : null
-            if (__DEV__ && notifySpy) spyReportStart(change!)
+            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()
+            }
         }
     }
 
@@ -233,7 +251,7 @@ export class ObservableMap<K = any, V = any>
             )
             this.data_.set(key, observable)
             newValue = (observable as any).value_ // value might have been changed
-            this.updateHasMapEntry_(key, true)
+            this.hasMap_.get(key)?.setNewValue_(true)
             this.keysAtom_.reportChanged()
         })
         const notifySpy = isSpyEnabled()
@@ -249,13 +267,21 @@ export class ObservableMap<K = any, V = any>
                       newValue
                   }
                 : null
-        if (__DEV__ && notifySpy) spyReportStart(change!)
-        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)
     }
 
@@ -304,24 +330,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
     }
@@ -329,12 +362,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
@@ -435,8 +470,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)
     }