mobx 7.0.4 → 7.0.6

package/dist/types/autoannotation.d.ts

@@ -1,3 +1,4 @@
-import { Annotation } from "../internal";
+import { Annotation, CreateObservableOptions } from "../internal";
 export declare const autoAnnotation: Annotation;
 export declare function createAutoAnnotation(options?: object): Annotation;
+export declare function getAutoAnnotation(options: CreateObservableOptions): Annotation;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "7.0.4",
+    "version": "7.0.6",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "type": "commonjs",

package/src/api/observable.ts

@@ -26,7 +26,7 @@ import {
     AnnotationsMap,
     assign,
     createObservableAnnotation,
-    createAutoAnnotation,
+    getAutoAnnotation,
     initObservable,
     decorateObservable20223_
 } from "../internal"
@@ -87,7 +87,7 @@ export function getEnhancerFromOptions(options: CreateObservableOptions): IEnhan
 export function getAnnotationFromOptions(
     options?: CreateObservableOptions
 ): Annotation | undefined {
-    return options ? options.defaultDecorator ?? createAutoAnnotation(options) : undefined
+    return options ? options.defaultDecorator ?? getAutoAnnotation(options) : undefined
 }
 
 export function getEnhancerFromAnnotation(annotation?: Annotation): IEnhancer<any> {

package/src/core/observable.ts

@@ -117,34 +117,42 @@ export function endBatch() {
         // the nested call instead of recursing; the outer loop re-reads list.length on
         // every iteration, so it picks up anything the nested dispose() pushes onto the
         // same pendingUnobservations array.
-        if (!globalState.isRunningUnobservations) {
-            globalState.isRunningUnobservations = true
-            try {
-                const list = globalState.pendingUnobservations
-                for (let i = 0; i < list.length; i++) {
-                    const observable = list[i]
-                    observable.isPendingUnobservation = false
-                    if (!observable.observers_ || observable.observers_.size === 0) {
-                        if (observable.isBeingObserved) {
-                            // if this observable had reactive observers, trigger the hooks
-                            observable.isBeingObserved = false
-                            observable.onBUO()
-                        }
-                        if (observable instanceof ComputedValue) {
-                            // computed values are automatically teared down when the last observer leaves
-                            // this process happens recursively, this computed might be the last observabe of another, etc..
-                            observable.suspend_()
-                        }
-                    }
+        if (!globalState.isRunningUnobservations && globalState.pendingUnobservations.length > 0) {
+            runPendingUnobservations()
+        }
+    }
+}
+
+// Only called when there is something to unobserve, so the common endBatch() skips the
+// try/finally and the pendingUnobservations reallocation entirely
+function runPendingUnobservations() {
+    globalState.isRunningUnobservations = true
+    try {
+        const list = globalState.pendingUnobservations
+        for (let i = 0; i < list.length; i++) {
+            const observable = list[i]
+            observable.isPendingUnobservation = false
+            if (!observable.observers_ || observable.observers_.size === 0) {
+                // release the empty Set so unobserved atoms don't keep paying for it
+                observable.observers_ = null
+                if (observable.isBeingObserved) {
+                    // if this observable had reactive observers, trigger the hooks
+                    observable.isBeingObserved = false
+                    observable.onBUO()
+                }
+                if (observable instanceof ComputedValue) {
+                    // computed values are automatically teared down when the last observer leaves
+                    // this process happens recursively, this computed might be the last observabe of another, etc..
+                    observable.suspend_()
                 }
-                globalState.pendingUnobservations = []
-            } finally {
-                // Always release the guard, even if an onBUO handler (user code) threw,
-                // otherwise every future endBatch() would see isRunningUnobservations
-                // stuck true and silently stop draining pendingUnobservations forever.
-                globalState.isRunningUnobservations = false
             }
         }
+        globalState.pendingUnobservations = []
+    } finally {
+        // Always release the guard, even if an onBUO handler (user code) threw,
+        // otherwise every future endBatch() would see isRunningUnobservations
+        // stuck true and silently stop draining pendingUnobservations forever.
+        globalState.isRunningUnobservations = false
     }
 }
 

package/src/core/reaction.ts

@@ -66,6 +66,7 @@ export class Reaction implements IDerivation, IReactionPublic {
     unboundDepsCount_ = 0
 
     private flags_ = 0b00000
+    private removeAbortListener_: Lambda | undefined = undefined
 
     constructor(
         public name_: string = __DEV__ ? "Reaction@" + getNextId() : "Reaction",
@@ -221,6 +222,8 @@ export class Reaction implements IDerivation, IReactionPublic {
     dispose() {
         if (!this.isDisposed) {
             this.isDisposed = true
+            // also covers self-disposal (`r.dispose()`, `when`), which bypasses the disposer
+            this.removeAbortListener_?.()
             if (!this.isRunning) {
                 // if disposed while running, clean up later. Maybe not optimal, but rare case
                 startBatch()
@@ -231,11 +234,11 @@ export class Reaction implements IDerivation, IReactionPublic {
     }
 
     getDisposer_(abortSignal?: GenericAbortSignal): IReactionDisposer {
-        const dispose = (() => {
-            this.dispose()
-            abortSignal?.removeEventListener?.("abort", dispose)
-        }) as IReactionDisposer
-        abortSignal?.addEventListener?.("abort", dispose)
+        const dispose = (() => this.dispose()) as IReactionDisposer
+        if (abortSignal?.addEventListener && !this.isDisposed) {
+            abortSignal.addEventListener("abort", dispose)
+            this.removeAbortListener_ = () => abortSignal.removeEventListener?.("abort", dispose)
+        }
         dispose[$mobx] = this
 
         if ("dispose" in Symbol && typeof Symbol.dispose === "symbol") {

package/src/types/autoannotation.ts

@@ -13,7 +13,8 @@ import {
     autoActionBound,
     isGenerator,
     MakeResult,
-    isAction
+    isAction,
+    CreateObservableOptions
 } from "../internal"
 
 const AUTO = "true"
@@ -29,6 +30,17 @@ export function createAutoAnnotation(options?: object): Annotation {
     }
 }
 
+// The auto annotation only depends on `deep` and `autoBind`, so share one instance per combination
+// instead of allocating one for every object created with options
+const autoAnnotations: Annotation[] = [autoAnnotation]
+
+export function getAutoAnnotation(options: CreateObservableOptions): Annotation {
+    const deep = options.deep !== false
+    const autoBind = !!options.autoBind
+    const idx = (deep ? 0 : 1) | (autoBind ? 2 : 0)
+    return (autoAnnotations[idx] ??= createAutoAnnotation({ deep, autoBind }))
+}
+
 function make_(
     adm: ObservableObjectAdministration,
     key: PropertyKey,

package/src/types/intercept-utils.ts

@@ -14,8 +14,13 @@ export function registerInterceptor<T>(
     interceptable: IInterceptable<T>,
     handler: IInterceptor<T>
 ): Lambda {
-    const interceptors = interceptable.interceptors_ || (interceptable.interceptors_ = [])
-    interceptors.push(handler)
+    let interceptors = interceptable.interceptors_
+    if (interceptors) {
+        interceptors.push(handler)
+    } else {
+        // Allocate at the exact size: pushing onto an empty array over-allocates its backing store
+        interceptors = interceptable.interceptors_ = [handler]
+    }
     return once(() => {
         const idx = interceptors.indexOf(handler)
         if (idx !== -1) {

package/src/types/listen-utils.ts

@@ -9,8 +9,13 @@ export function hasListeners(listenable: IListenable) {
 }
 
 export function registerListener(listenable: IListenable, handler: Function): Lambda {
-    const listeners = listenable.changeListeners_ || (listenable.changeListeners_ = [])
-    listeners.push(handler)
+    let listeners = listenable.changeListeners_
+    if (listeners) {
+        listeners.push(handler)
+    } else {
+        // Allocate at the exact size: pushing onto an empty array over-allocates its backing store
+        listeners = listenable.changeListeners_ = [handler]
+    }
     return once(() => {
         const idx = listeners.indexOf(handler)
         if (idx !== -1) {

package/src/types/observablearray.ts

@@ -95,8 +95,7 @@ const arrayTraps = {
         const adm: ObservableArrayAdministration = target[$mobx]
         if (name === "length") {
             adm.setArrayLength_(value)
-        }
-        if (typeof name === "symbol" || isNaN(name)) {
+        } else if (typeof name === "symbol" || isNaN(name)) {
             target[name] = value
         } else {
             // numeric string
@@ -151,7 +150,7 @@ export class ObservableArrayAdministration
     }
 
     setArrayLength_(newLength: number) {
-        if (typeof newLength !== "number" || isNaN(newLength) || newLength < 0) {
+        if (!Number.isInteger(newLength) || newLength < 0) {
             die(40, newLength)
         }
         let currentLength = this.values_.length

package/src/types/observableset.ts

@@ -127,7 +127,8 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
         }
         if (!this.has(value)) {
             transaction(() => {
-                this.data_.add(this.enhancer_(value, undefined))
+                value = this.enhancer_(value, undefined) // report the stored value, like map and array
+                this.data_.add(value)
                 this.atom_.reportChanged()
             })
             const notifySpy = __DEV__ && isSpyEnabled()

package/src/types/observablevalue.ts

@@ -79,7 +79,7 @@ export class ObservableValue<T>
                 object: this,
                 observableKind: "value",
                 debugObjectName: this.name_,
-                newValue: "" + this.value_?.toString()
+                newValue: this.value_
             })
         }
     }