mobx 6.3.4 → 6.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.3.4",
+    "version": "6.3.8",
     "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/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/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/atom.ts

@@ -17,7 +17,7 @@ import {
 export const $mobx = Symbol("mobx administration")
 
 export interface IAtom extends IObservable {
-    reportObserved()
+    reportObserved(): boolean
     reportChanged()
 }
 

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/types/observablearray.ts

@@ -175,7 +175,8 @@ export class ObservableArrayAdministration
     }
 
     setArrayLength_(newLength: number) {
-        if (typeof newLength !== "number" || isNaN(newLength) || 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) {
@@ -235,9 +236,12 @@ 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
+            // 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]