mobx 6.15.3 → 6.16.0

package/dist/types/observablemap.d.ts

@@ -53,6 +53,8 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     private updateValue_;
     private addValue_;
     get(key: K): V | undefined;
+    getOrInsert(key: K, value: V): V;
+    getOrInsertComputed(key: K, callback: (key: K) => V): V;
     private dehanceValue_;
     keys(): MapIterator<K>;
     values(): MapIterator<V>;

package/dist/types/observableobject.d.ts

@@ -27,7 +27,7 @@ export type IObjectWillChange<T = any> = {
 };
 export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
     target_: any;
-    values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>;
+    values_: Map<PropertyKey, ComputedValue<any> | ObservableValue<any>>;
     name_: string;
     defaultAnnotation_: Annotation;
     keysAtom_: IAtom;
@@ -37,8 +37,12 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     isPlainObject_: boolean;
     appliedAnnotations_?: object;
     private pendingKeys_;
-    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>> | undefined, name_: string, defaultAnnotation_?: Annotation);
+    lazyComputedKeys_: undefined | Map<PropertyKey, () => ComputedValue<any>>;
+    lazyObservableKeys_: undefined | Map<PropertyKey, () => ObservableValue<any>>;
+    constructor(target_: any, values_: Map<PropertyKey, ComputedValue<any> | ObservableValue<any>> | undefined, name_: string, defaultAnnotation_?: Annotation);
     getObservablePropValue_(key: PropertyKey): any;
+    materializeLazyComputed_(key: PropertyKey): ComputedValue<any> | undefined;
+    materializeLazyObservable_(key: PropertyKey): ObservableValue<any> | undefined;
     setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
     get_(key: PropertyKey): any;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.15.3",
+    "version": "6.16.0",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",
@@ -68,13 +68,14 @@
         "perf": "scripts/perf.sh",
         "perf-legacy": "node --expose-gc ./__tests__/perf/index.js legacy",
         "perf-proxy": "node --expose-gc ./__tests__/perf/index.js proxy",
-        "test:performance": "yarn perf proxy && yarn perf legacy",
-        "test:mixed-versions": "yarn test --testRegex mixed-versions",
+        "perf-decorator": "tsc -p ./__tests__/perf/tsconfig.decorator.json && node --expose-gc ./__tests__/perf/compiled/lazy-computed-decorator.js && node --expose-gc ./__tests__/perf/compiled/lazy-observable-decorator.js",
+        "test:performance": "npm run perf -- proxy && npm run perf -- legacy && npm run perf-decorator",
+        "test:mixed-versions": "npm test -- --testRegex mixed-versions",
         "test:types": "tsc --noEmit",
         "test:flow": "flow check",
-        "test:coverage": "yarn test -i --coverage",
-        "test:size": "yarn import-size --report . observable computed autorun action",
-        "test:check": "yarn test:types",
+        "test:coverage": "npm test -- -i --coverage",
+        "test:size": "import-size --report . observable computed autorun action",
+        "test:check": "npm run test:types",
         "prepublishOnly": "node ./scripts/prepublish.js && npm run build -- --target publish"
     }
 }

package/src/api/iscomputed.ts

@@ -7,7 +7,11 @@ export function _isComputed(value, property?: PropertyKey): boolean {
     if (isObservableObject(value) === false) {
         return false
     }
-    if (!value[$mobx].values_.has(property)) {
+    const adm = value[$mobx]
+    if (adm.lazyComputedKeys_?.has(property)) {
+        return true
+    }
+    if (!adm.values_.has(property)) {
         return false
     }
     const atom = getAtom(value, property)

package/src/api/isobservable.ts

@@ -21,7 +21,12 @@ function _isObservable(value, property?: PropertyKey): boolean {
             )
         }
         if (isObservableObject(value)) {
-            return value[$mobx].values_.has(property)
+            const adm = value[$mobx]
+            return (
+                adm.values_.has(property) ||
+                !!adm.lazyComputedKeys_?.has(property) ||
+                !!adm.lazyObservableKeys_?.has(property)
+            )
         }
         return false
     }

package/src/types/computedannotation.ts

@@ -54,17 +54,23 @@ function decorate_20223_(this: Annotation, get, context: ClassGetterDecoratorCon
     const ann = this
     const { name: key, addInitializer } = context
 
+    // Defer ComputedValue creation until first access — avoids allocating
+    // ComputedValues for getters that are never read on a given instance.
+    // The factory is materialised by ObservableObjectAdministration on demand.
     addInitializer(function () {
         const adm: ObservableObjectAdministration = asObservableObject(this)[$mobx]
-        const options = {
-            ...ann.options_,
-            get,
-            context: this
-        }
-        options.name ||= __DEV__
-            ? `${adm.name_}.${key.toString()}`
-            : `ObservableObject.${key.toString()}`
-        adm.values_.set(key, new ComputedValue(options))
+        const target = this
+        ;(adm.lazyComputedKeys_ ??= new Map()).set(key, () => {
+            const options = {
+                ...ann.options_,
+                get,
+                context: target
+            }
+            options.name ||= __DEV__
+                ? `${adm.name_}.${key.toString()}`
+                : `ObservableObject.${key.toString()}`
+            return new ComputedValue(options)
+        })
     })
 
     return function () {

package/src/types/observableannotation.ts

@@ -64,51 +64,45 @@ function decorate_20223_(
     const ann = this
     const { kind, name } = context
 
-    // The laziness here is not ideal... It's a workaround to how 2022.3 Decorators are implemented:
-    //   `addInitializer` callbacks are executed _before_ any accessors are defined (instead of the ideal-for-us right after each).
-    //   This means that, if we were to do our stuff in an `addInitializer`, we'd attempt to read a private slot
-    //   before it has been initialized. The runtime doesn't like that and throws a `Cannot read private member
-    //   from an object whose class did not declare it` error.
-    // TODO: it seems that this will not be required anymore in the final version of the spec
-    // See TODO: link
-    const initializedObjects = new WeakSet()
+    if (kind !== "accessor") {
+        return
+    }
 
-    function initializeObservable(target, value) {
+    // Defer ObservableValue construction until first access. The factory is
+    // materialised by ObservableObjectAdministration on demand, so unused
+    // fields on wide classes never pay the per-instance allocation cost.
+    function registerLazy(target: any, value: any): ObservableObjectAdministration {
         const adm: ObservableObjectAdministration = asObservableObject(target)[$mobx]
-        const observable = new ObservableValue(
-            value,
-            ann.options_?.enhancer ?? deepEnhancer,
-            __DEV__ ? `${adm.name_}.${name.toString()}` : `ObservableObject.${name.toString()}`,
-            false
+        ;(adm.lazyObservableKeys_ ??= new Map()).set(
+            name,
+            () =>
+                new ObservableValue(
+                    value,
+                    ann.options_?.enhancer ?? deepEnhancer,
+                    __DEV__
+                        ? `${adm.name_}.${name.toString()}`
+                        : `ObservableObject.${name.toString()}`,
+                    false
+                )
         )
-        adm.values_.set(name, observable)
-        initializedObjects.add(target)
+        return adm
     }
 
-    if (kind == "accessor") {
-        return {
-            get() {
-                if (!initializedObjects.has(this)) {
-                    initializeObservable(this, desc.get.call(this))
-                }
-                return this[$mobx].getObservablePropValue_(name)
-            },
-            set(value) {
-                if (!initializedObjects.has(this)) {
-                    initializeObservable(this, value)
-                }
-                return this[$mobx].setObservablePropValue_(name, value)
-            },
-            init(value) {
-                if (!initializedObjects.has(this)) {
-                    initializeObservable(this, value)
-                }
-                return value
-            }
+    return {
+        get() {
+            const adm: ObservableObjectAdministration =
+                this[$mobx] ?? registerLazy(this, desc.get.call(this))
+            return adm.getObservablePropValue_(name)
+        },
+        set(value) {
+            const adm: ObservableObjectAdministration = this[$mobx] ?? registerLazy(this, value)
+            return adm.setObservablePropValue_(name, value)
+        },
+        init(value) {
+            registerLazy(this, value)
+            return value
         }
     }
-
-    return
 }
 
 function assertObservableDescriptor(

package/src/types/observablemap.ts

@@ -289,6 +289,20 @@ export class ObservableMap<K = any, V = any>
         return this.dehanceValue_(undefined)
     }
 
+    getOrInsert(key: K, value: V): V {
+        if (!this.has(key)) {
+            this.set(key, value)
+        }
+        return this.get(key)!
+    }
+
+    getOrInsertComputed(key: K, callback: (key: K) => V): V {
+        if (!this.has(key)) {
+            this.set(key, callback(key))
+        }
+        return this.get(key)!
+    }
+
     private dehanceValue_<X extends V | undefined>(value: X): X {
         if (this.dehancer !== undefined) {
             return this.dehancer(value)

package/src/types/observableobject.ts

@@ -98,6 +98,8 @@ export class ObservableObjectAdministration
     isPlainObject_: boolean
     appliedAnnotations_?: object
     private pendingKeys_: undefined | Map<PropertyKey, ObservableValue<boolean>>
+    lazyComputedKeys_: undefined | Map<PropertyKey, () => ComputedValue<any>>
+    lazyObservableKeys_: undefined | Map<PropertyKey, () => ObservableValue<any>>
 
     constructor(
         public target_: any,
@@ -119,11 +121,47 @@ export class ObservableObjectAdministration
     }
 
     getObservablePropValue_(key: PropertyKey): any {
-        return this.values_.get(key)!.get()
+        // Hot path: single map lookup. Lazy entries (rare) take the materialise branch.
+        const observable =
+            this.values_.get(key) ??
+            this.materializeLazyComputed_(key) ??
+            this.materializeLazyObservable_(key)
+        return observable!.get()
+    }
+
+    materializeLazyComputed_(key: PropertyKey): ComputedValue<any> | undefined {
+        const factory = this.lazyComputedKeys_?.get(key)
+        if (!factory) {
+            return undefined
+        }
+        this.lazyComputedKeys_!.delete(key)
+        if (this.lazyComputedKeys_!.size === 0) {
+            this.lazyComputedKeys_ = undefined
+        }
+        const computed = factory()
+        this.values_.set(key, computed)
+        return computed
+    }
+
+    materializeLazyObservable_(key: PropertyKey): ObservableValue<any> | undefined {
+        const factory = this.lazyObservableKeys_?.get(key)
+        if (!factory) {
+            return undefined
+        }
+        this.lazyObservableKeys_!.delete(key)
+        if (this.lazyObservableKeys_!.size === 0) {
+            this.lazyObservableKeys_ = undefined
+        }
+        const observable = factory()
+        this.values_.set(key, observable)
+        return observable
     }
 
     setObservablePropValue_(key: PropertyKey, newValue): boolean | null {
-        const observable = this.values_.get(key)
+        const observable =
+            this.values_.get(key) ??
+            this.materializeLazyComputed_(key) ??
+            this.materializeLazyObservable_(key)
         if (observable instanceof ComputedValue) {
             observable.set(newValue)
             return true

package/src/types/type-utils.ts

@@ -47,7 +47,11 @@ export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
             if (!property) {
                 return die(26)
             }
-            const observable = (thing as any)[$mobx].values_.get(property)
+            const adm = (thing as any)[$mobx]
+            const observable =
+                adm.values_.get(property) ??
+                adm.materializeLazyComputed_(property) ??
+                adm.materializeLazyObservable_(property)
             if (!observable) {
                 die(27, property, getDebugName(thing))
             }

package/src/utils/iterable.ts

@@ -1,7 +1,8 @@
 import { getGlobal } from "../internal"
 
 // safely get iterator prototype if available
-const maybeIteratorPrototype = getGlobal().Iterator?.prototype || {}
+const global = getGlobal()
+const maybeIteratorPrototype = global.Iterator?.prototype || {}
 
 export function makeIterable<T, TReturn = unknown>(
     iterator: Iterator<T>