mobx 6.15.4 → 6.16.1

package/dist/mobx.umd.development.js

@@ -947,17 +947,44 @@
       var ann = this;
       var key = context.name,
         addInitializer = context.addInitializer;
-      addInitializer(function () {
-        var adm = asObservableObject(this)[$mobx];
+      var computedValues;
+      // 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.
+      function createComputedValue(target, adm) {
         var options = _extends({}, ann.options_, {
           get: get,
-          context: this
+          context: target
         });
         options.name || (options.name =  adm.name_ + "." + key.toString() );
-        adm.values_.set(key, new ComputedValue(options));
+        return new ComputedValue(options);
+      }
+      addInitializer(function () {
+        var _adm$lazyComputedKeys;
+        var adm = asObservableObject(this)[$mobx];
+        var target = this;
+        var observable = adm.values_.get(key);
+        if (observable instanceof ComputedValue && observable.derivation !== get) {
+          adm.values_["delete"](key);
+        }
+        ((_adm$lazyComputedKeys = adm.lazyComputedKeys_) != null ? _adm$lazyComputedKeys : adm.lazyComputedKeys_ = new Map()).set(key, function () {
+          return createComputedValue(target, adm);
+        });
       });
       return function () {
-        return this[$mobx].getObservablePropValue_(key);
+        var adm = this[$mobx];
+        var observable = adm.values_.get(key);
+        if (observable instanceof ComputedValue && observable.derivation !== get) {
+          var _computedValues;
+          var computed = (_computedValues = computedValues) == null ? void 0 : _computedValues.get(this);
+          if (!computed) {
+            var _computedValues2;
+            computed = createComputedValue(this, adm);
+            ((_computedValues2 = computedValues) != null ? _computedValues2 : computedValues = new WeakMap()).set(this, computed);
+          }
+          return computed.get();
+        }
+        return adm.getObservablePropValue_(key);
       };
     }
     function assertComputedDescriptor(adm, _ref, key, _ref2) {
@@ -995,44 +1022,37 @@
       var ann = this;
       var kind = context.kind,
         name = context.name;
-      // 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
-      var initializedObjects = new WeakSet();
-      function initializeObservable(target, value) {
-        var _ann$options_$enhance, _ann$options_;
+      if (kind !== "accessor") {
+        return;
+      }
+      // 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, value) {
+        var _adm$lazyObservableKe;
         var adm = asObservableObject(target)[$mobx];
-        var observable = new ObservableValue(value, (_ann$options_$enhance = (_ann$options_ = ann.options_) == null ? void 0 : _ann$options_.enhancer) != null ? _ann$options_$enhance : deepEnhancer,  adm.name_ + "." + name.toString() , false);
-        adm.values_.set(name, observable);
-        initializedObjects.add(target);
-      }
-      if (kind == "accessor") {
-        return {
-          get: function get() {
-            if (!initializedObjects.has(this)) {
-              initializeObservable(this, desc.get.call(this));
-            }
-            return this[$mobx].getObservablePropValue_(name);
-          },
-          set: function set(value) {
-            if (!initializedObjects.has(this)) {
-              initializeObservable(this, value);
-            }
-            return this[$mobx].setObservablePropValue_(name, value);
-          },
-          init: function init(value) {
-            if (!initializedObjects.has(this)) {
-              initializeObservable(this, value);
-            }
-            return value;
-          }
-        };
+        ((_adm$lazyObservableKe = adm.lazyObservableKeys_) != null ? _adm$lazyObservableKe : adm.lazyObservableKeys_ = new Map()).set(name, function () {
+          var _ann$options_$enhance, _ann$options_;
+          return new ObservableValue(value, (_ann$options_$enhance = (_ann$options_ = ann.options_) == null ? void 0 : _ann$options_.enhancer) != null ? _ann$options_$enhance : deepEnhancer,  adm.name_ + "." + name.toString() , false);
+        });
+        return adm;
       }
-      return;
+      return {
+        get: function get() {
+          var _this$$mobx;
+          var adm = (_this$$mobx = this[$mobx]) != null ? _this$$mobx : registerLazy(this, desc.get.call(this));
+          return adm.getObservablePropValue_(name);
+        },
+        set: function set(value) {
+          var _this$$mobx2;
+          var adm = (_this$$mobx2 = this[$mobx]) != null ? _this$$mobx2 : registerLazy(this, value);
+          return adm.setObservablePropValue_(name, value);
+        },
+        init: function init(value) {
+          registerLazy(this, value);
+          return value;
+        }
+      };
     }
     function assertObservableDescriptor(adm, _ref, key, descriptor) {
       var annotationType_ = _ref.annotationType_;
@@ -3220,13 +3240,18 @@
     }
 
     function _isComputed(value, property) {
+      var _adm$lazyComputedKeys;
       if (property === undefined) {
         return isComputedValue(value);
       }
       if (isObservableObject(value) === false) {
         return false;
       }
-      if (!value[$mobx].values_.has(property)) {
+      var adm = value[$mobx];
+      if ((_adm$lazyComputedKeys = adm.lazyComputedKeys_) != null && _adm$lazyComputedKeys.has(property)) {
+        return true;
+      }
+      if (!adm.values_.has(property)) {
         return false;
       }
       var atom = getAtom(value, property);
@@ -3254,7 +3279,9 @@
           return die("isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.");
         }
         if (isObservableObject(value)) {
-          return value[$mobx].values_.has(property);
+          var _adm$lazyComputedKeys, _adm$lazyObservableKe;
+          var adm = value[$mobx];
+          return adm.values_.has(property) || !!((_adm$lazyComputedKeys = adm.lazyComputedKeys_) != null && _adm$lazyComputedKeys.has(property)) || !!((_adm$lazyObservableKe = adm.lazyObservableKeys_) != null && _adm$lazyObservableKe.has(property));
         }
         return false;
       }
@@ -4452,6 +4479,18 @@
         }
         return this.dehanceValue_(undefined);
       };
+      _proto.getOrInsert = function getOrInsert(key, value) {
+        if (!this.has(key)) {
+          this.set(key, value);
+        }
+        return this.get(key);
+      };
+      _proto.getOrInsertComputed = function getOrInsertComputed(key, callback) {
+        if (!this.has(key)) {
+          this.set(key, callback(key));
+        }
+        return this.get(key);
+      };
       _proto.dehanceValue_ = function dehanceValue_(value) {
         if (this.dehancer !== undefined) {
           return this.dehancer(value);
@@ -4985,6 +5024,8 @@
         this.isPlainObject_ = void 0;
         this.appliedAnnotations_ = void 0;
         this.pendingKeys_ = void 0;
+        this.lazyComputedKeys_ = void 0;
+        this.lazyObservableKeys_ = void 0;
         this.target_ = target_;
         this.values_ = values_;
         this.name_ = name_;
@@ -5002,10 +5043,42 @@
       }
       var _proto = ObservableObjectAdministration.prototype;
       _proto.getObservablePropValue_ = function getObservablePropValue_(key) {
-        return this.values_.get(key).get();
+        var _ref, _this$values_$get;
+        // Hot path: single map lookup. Lazy entries (rare) take the materialise branch.
+        var observable = (_ref = (_this$values_$get = this.values_.get(key)) != null ? _this$values_$get : this.materializeLazyComputed_(key)) != null ? _ref : this.materializeLazyObservable_(key);
+        return observable.get();
+      };
+      _proto.materializeLazyComputed_ = function materializeLazyComputed_(key) {
+        var _this$lazyComputedKey;
+        var factory = (_this$lazyComputedKey = this.lazyComputedKeys_) == null ? void 0 : _this$lazyComputedKey.get(key);
+        if (!factory) {
+          return undefined;
+        }
+        this.lazyComputedKeys_["delete"](key);
+        if (this.lazyComputedKeys_.size === 0) {
+          this.lazyComputedKeys_ = undefined;
+        }
+        var computed = factory();
+        this.values_.set(key, computed);
+        return computed;
+      };
+      _proto.materializeLazyObservable_ = function materializeLazyObservable_(key) {
+        var _this$lazyObservableK;
+        var factory = (_this$lazyObservableK = this.lazyObservableKeys_) == null ? void 0 : _this$lazyObservableK.get(key);
+        if (!factory) {
+          return undefined;
+        }
+        this.lazyObservableKeys_["delete"](key);
+        if (this.lazyObservableKeys_.size === 0) {
+          this.lazyObservableKeys_ = undefined;
+        }
+        var observable = factory();
+        this.values_.set(key, observable);
+        return observable;
       };
       _proto.setObservablePropValue_ = function setObservablePropValue_(key, newValue) {
-        var observable = this.values_.get(key);
+        var _ref2, _this$values_$get2;
+        var observable = (_ref2 = (_this$values_$get2 = this.values_.get(key)) != null ? _this$values_$get2 : this.materializeLazyComputed_(key)) != null ? _ref2 : this.materializeLazyObservable_(key);
         if (observable instanceof ComputedValue) {
           observable.set(newValue);
           return true;
@@ -5726,10 +5799,12 @@
           return observable;
         }
         if (isObservableObject(thing)) {
+          var _ref, _adm$values_$get;
           if (!property) {
             return die(26);
           }
-          var _observable = thing[$mobx].values_.get(property);
+          var adm = thing[$mobx];
+          var _observable = (_ref = (_adm$values_$get = adm.values_.get(property)) != null ? _adm$values_$get : adm.materializeLazyComputed_(property)) != null ? _ref : adm.materializeLazyObservable_(property);
           if (!_observable) {
             die(27, property, getDebugName(thing));
           }