mobx 7.0.3 → 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.3",
+    "version": "7.0.5",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "type": "commonjs",

package/src/api/makeObservable.ts

@@ -19,13 +19,6 @@ import {
     recordAnnotationApplied
 } from "../internal"
 
-// Hack based on https://github.com/Microsoft/TypeScript/issues/14829#issuecomment-322267089
-// We need this, because otherwise, AdditionalKeys is going to be inferred to be any
-// set of superfluous keys. But, we rather want to get a compile error unless AdditionalKeys is
-// _explicity_ passed as generic argument
-// Fixes: https://github.com/mobxjs/mobx/issues/2325#issuecomment-691070022
-type NoInfer<T> = [T][T extends any ? 0 : never]
-
 export function makeObservable<T extends object, AdditionalKeys extends PropertyKey = never>(
     target: T,
     annotations: AnnotationsMap<T, NoInfer<AdditionalKeys>>,

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/computedvalue.ts

@@ -216,7 +216,10 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             reportObserved(this)
             if (shouldCompute(this)) {
                 let prevTrackingContext = globalState.trackingContext
-                if (this.keepAlive_ && !prevTrackingContext) {
+                if (!prevTrackingContext && (this.keepAlive_ || this.isBeingObserved)) {
+                    // An observed or keep-alive computed can be recomputed by an untracked
+                    // read, for example from inside an action. Its dependencies are still
+                    // transitively observed and must fire their lifecycle hooks
                     globalState.trackingContext = this
                 }
                 if (this.trackAndCompute()) {

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

@@ -45,7 +45,7 @@ export interface IReactionPublic {
     dispose(): void
 }
 
-export interface IReactionDisposer {
+export interface IReactionDisposer extends Disposable {
     (): void
     [$mobx]: Reaction
 }

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) {