mobx 7.0.4 → 7.0.5

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.5",
     "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/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) {