mobx 6.3.3 → 6.3.7

package/dist/types/observablemap.d.ts

@@ -48,7 +48,6 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     has(key: K): boolean;
     set(key: K, value: V): this;
     delete(key: K): boolean;
-    private updateHasMapEntry_;
     private updateValue_;
     private addValue_;
     get(key: K): V | undefined;

package/package.json

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

package/src/api/autorun.ts

@@ -86,8 +86,8 @@ export function autorun(
     return reaction.getDisposer_()
 }
 
-export type IReactionOptions<T> = IAutorunOptions & {
-    fireImmediately?: boolean
+export type IReactionOptions<T, FireImmediately extends boolean> = IAutorunOptions & {
+    fireImmediately?: FireImmediately
     equals?: IEqualsComparer<T>
 }
 
@@ -101,10 +101,14 @@ function createSchedulerFromOptions(opts: IAutorunOptions) {
         : run
 }
 
-export function reaction<T>(
+export function reaction<T, FireImmediately extends boolean = false>(
     expression: (r: IReactionPublic) => T,
-    effect: (arg: T, prev: T, r: IReactionPublic) => void,
-    opts: IReactionOptions<T> = EMPTY_OBJECT
+    effect: (
+        arg: T,
+        prev: FireImmediately extends true ? T | undefined : T,
+        r: IReactionPublic
+    ) => void,
+    opts: IReactionOptions<T, FireImmediately> = EMPTY_OBJECT
 ): IReactionDisposer {
     if (__DEV__) {
         if (!isFunction(expression) || !isFunction(effect))
@@ -122,7 +126,7 @@ export function reaction<T>(
     let firstTime = true
     let isScheduled = false
     let value: T
-    let oldValue: T = undefined as any // only an issue with fireImmediately
+    let oldValue: T | undefined
 
     const equals: IEqualsComparer<T> = (opts as any).compareStructural
         ? comparer.structural
@@ -152,8 +156,11 @@ export function reaction<T>(
             oldValue = value
             value = nextValue
         })
-        if (firstTime && opts.fireImmediately!) effectAction(value, oldValue, r)
-        else if (!firstTime && changed) effectAction(value, oldValue, r)
+
+        // This casting is nesessary as TS cannot infer proper type in current funciton implementation
+        type OldValue = FireImmediately extends true ? T | undefined : T
+        if (firstTime && opts.fireImmediately!) effectAction(value, oldValue as OldValue, r)
+        else if (!firstTime && changed) effectAction(value, oldValue as OldValue, r)
         firstTime = false
     }
 

package/src/api/extendobservable.ts

@@ -27,7 +27,7 @@ export function extendObservable<A extends Object, B extends Object>(
         if (isObservableMap(target))
             die("'extendObservable' should not be used on maps, use map.merge instead")
         if (!isPlainObject(properties))
-            die(`'extendObservabe' only accepts plain objects as second argument`)
+            die(`'extendObservable' only accepts plain objects as second argument`)
         if (isObservable(properties) || isObservable(annotations))
             die(`Extending an object with another observable (object) is not supported`)
     }

package/src/api/intercept.ts

@@ -24,15 +24,15 @@ export function intercept<T>(
     handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>
 ): Lambda
 export function intercept<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     handler: IInterceptor<IMapWillChange<K, V>>
 ): Lambda
 export function intercept<V>(
-    observableMap: ObservableSet<V>,
+    observableSet: ObservableSet<V> | Set<V>,
     handler: IInterceptor<ISetWillChange<V>>
 ): Lambda
 export function intercept<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     property: K,
     handler: IInterceptor<IValueWillChange<V>>
 ): Lambda
@@ -40,7 +40,7 @@ export function intercept(object: object, handler: IInterceptor<IObjectWillChang
 export function intercept<T extends object, K extends keyof T>(
     object: T,
     property: K,
-    handler: IInterceptor<IValueWillChange<any>>
+    handler: IInterceptor<IValueWillChange<T[K]>>
 ): Lambda
 export function intercept(thing, propOrHandler?, handler?): Lambda {
     if (isFunction(handler)) return interceptProperty(thing, propOrHandler, handler)

package/src/api/iscomputed.ts

@@ -1,13 +1,13 @@
 import { $mobx, getAtom, isComputedValue, isObservableObject, die, isStringish } from "../internal"
 
 export function _isComputed(value, property?: PropertyKey): boolean {
-    if (property !== undefined) {
-        if (isObservableObject(value) === false) return false
-        if (!value[$mobx].values_.has(property)) return false
-        const atom = getAtom(value, property)
-        return isComputedValue(atom)
+    if (property === undefined) {
+        return isComputedValue(value)
     }
-    return isComputedValue(value)
+    if (isObservableObject(value) === false) return false
+    if (!value[$mobx].values_.has(property)) return false
+    const atom = getAtom(value, property)
+    return isComputedValue(atom)
 }
 
 export function isComputed(value: any): boolean {

package/src/api/makeObservable.ts

@@ -12,7 +12,8 @@ import {
     die,
     ownKeys,
     extendObservable,
-    addHiddenProp
+    addHiddenProp,
+    storedAnnotationsSymbol
 } from "../internal"
 
 // Hack based on https://github.com/Microsoft/TypeScript/issues/14829#issuecomment-322267089
@@ -30,6 +31,11 @@ export function makeObservable<T extends object, AdditionalKeys extends Property
     const adm: ObservableObjectAdministration = asObservableObject(target, options)[$mobx]
     startBatch()
     try {
+        if (__DEV__ && annotations && target[storedAnnotationsSymbol]) {
+            die(
+                `makeObservable second arg must be nullish when using decorators. Mixing @decorator syntax with annotations is not supported.`
+            )
+        }
         // Default to decorators
         annotations ??= collectStoredAnnotations(target)
 

package/src/api/observe.ts

@@ -25,17 +25,18 @@ export function observe<T>(
     fireImmediately?: boolean
 ): Lambda
 export function observe<V>(
-    observableMap: ObservableSet<V>,
+    // ObservableSet/ObservableMap are required despite they implement Set/Map: https://github.com/mobxjs/mobx/pull/3180#discussion_r746542929
+    observableSet: ObservableSet<V> | Set<V>,
     listener: (change: ISetDidChange<V>) => void,
     fireImmediately?: boolean
 ): Lambda
 export function observe<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     listener: (change: IMapDidChange<K, V>) => void,
     fireImmediately?: boolean
 ): Lambda
 export function observe<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     property: K,
     listener: (change: IValueDidChange<V>) => void,
     fireImmediately?: boolean

package/src/api/when.ts

@@ -72,7 +72,7 @@ function whenPromise(
         let disposer = _when(predicate, resolve, { ...opts, onError: reject })
         cancel = () => {
             disposer()
-            reject("WHEN_CANCELLED")
+            reject(new Error("WHEN_CANCELLED"))
         }
     })
     ;(res as any).cancel = cancel

package/src/core/computedvalue.ts

@@ -204,17 +204,6 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             /* see #1208 */ this.dependenciesState_ === IDerivationState_.NOT_TRACKING_
         const newValue = this.computeValue_(true)
 
-        if (__DEV__ && isSpyEnabled()) {
-            spyReport({
-                observableKind: "computed",
-                debugObjectName: this.name_,
-                object: this.scope_,
-                type: "update",
-                oldValue: this.value_,
-                newValue
-            } as IComputedDidChange)
-        }
-
         const changed =
             wasSuspended ||
             isCaughtException(oldValue) ||
@@ -223,6 +212,17 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
 
         if (changed) {
             this.value_ = newValue
+
+            if (__DEV__ && isSpyEnabled()) {
+                spyReport({
+                    observableKind: "computed",
+                    debugObjectName: this.name_,
+                    object: this.scope_,
+                    type: "update",
+                    oldValue,
+                    newValue
+                } as IComputedDidChange)
+            }
         }
 
         return changed

package/src/core/globalstate.ts

@@ -162,6 +162,8 @@ export let globalState: MobXGlobals = (function () {
         canMergeGlobalState = false
 
     if (!canMergeGlobalState) {
+        // Because this is a IIFE we need to let isolateCalled a chance to change
+        // so we run it after the event loop completed at least 1 iteration
         setTimeout(() => {
             if (!isolateCalled) {
                 die(35)

package/src/core/observable.ts

@@ -268,6 +268,6 @@ function printDepTree(tree: IDependencyTree, lines: string[], depth: number) {
         lines.push("(and many more)")
         return
     }
-    lines.push(`${new Array(depth).join("\t")}${tree.name}`) // MWE: not the fastest, but the easiest way :)
+    lines.push(`${"\t".repeat(depth - 1)}${tree.name}`)
     if (tree.dependencies) tree.dependencies.forEach(child => printDepTree(child, lines, depth + 1))
 }

package/src/types/actionannotation.ts

@@ -67,7 +67,7 @@ function assertActionDescriptor(
     if (__DEV__ && !isFunction(value)) {
         die(
             `Cannot apply '${annotationType_}' to '${adm.name_}.${key.toString()}':` +
-                `\n'${annotationType_}' can only be used on properties with a function value.`
+            `\n'${annotationType_}' can only be used on properties with a function value.`
         )
     }
 }
@@ -89,7 +89,9 @@ export function createActionDescriptor(
         value: createAction(
             annotation.options_?.name ?? key.toString(),
             value,
-            annotation.options_?.autoAction ?? false
+            annotation.options_?.autoAction ?? false,
+            // https://github.com/mobxjs/mobx/discussions/3140
+            annotation.options_?.bound ? (adm.proxy_ ?? adm.target_) : undefined,
         ),
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass

package/src/types/observablearray.ts

@@ -175,7 +175,7 @@ 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) {

package/src/types/observablemap.ts

@@ -178,7 +178,7 @@ export class ObservableMap<K = any, V = any>
             if (__DEV__ && notifySpy) spyReportStart(change!)
             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)
@@ -190,13 +190,6 @@ export class ObservableMap<K = any, V = any>
         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
@@ -233,7 +226,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()