mobx 6.15.4 → 6.16.0

package/dist/mobx.esm.development.js

@@ -941,14 +941,21 @@ function decorate_20223_$3(get, context) {
   var ann = this;
   var key = context.name,
     addInitializer = context.addInitializer;
+  // 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 () {
+    var _adm$lazyComputedKeys;
     var adm = asObservableObject(this)[$mobx];
-    var options = _extends({}, ann.options_, {
-      get: get,
-      context: this
+    var target = this;
+    ((_adm$lazyComputedKeys = adm.lazyComputedKeys_) != null ? _adm$lazyComputedKeys : adm.lazyComputedKeys_ = new Map()).set(key, function () {
+      var options = _extends({}, ann.options_, {
+        get: get,
+        context: target
+      });
+      options.name || (options.name =  adm.name_ + "." + key.toString() );
+      return new ComputedValue(options);
     });
-    options.name || (options.name =  adm.name_ + "." + key.toString() );
-    adm.values_.set(key, new ComputedValue(options));
   });
   return function () {
     return this[$mobx].getObservablePropValue_(key);
@@ -989,44 +996,37 @@ function decorate_20223_$4(desc, context) {
   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_;
@@ -3214,13 +3214,18 @@ function interceptProperty(thing, property, handler) {
 }
 
 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);
@@ -3248,7 +3253,9 @@ function _isObservable(value, property) {
       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;
   }
@@ -4446,6 +4453,18 @@ var ObservableMap = /*#__PURE__*/function () {
     }
     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);
@@ -4979,6 +4998,8 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     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_;
@@ -4996,10 +5017,42 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
   }
   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;
@@ -5720,10 +5773,12 @@ function getAtom(thing, property) {
       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));
       }