mobx 6.15.3 → 6.16.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # mobx
 
+## 6.16.0
+
+### Minor Changes
+
+-   [`6b3fb0ee725c0521bbaf7ba901a30261472a0e71`](https://github.com/mobxjs/mobx/commit/6b3fb0ee725c0521bbaf7ba901a30261472a0e71) [#4639](https://github.com/mobxjs/mobx/pull/4639) Thanks [@ashishkr96](https://github.com/ashishkr96)! - feat(mobx): make the 2022.3 `@computed` decorator lazy. `ComputedValue` is now created on first read of the decorated getter rather than eagerly during instance construction, avoiding wasted allocations for getters that are never used. On a 50k-instance × 10-getter class with one read per instance this cuts construction heap by ~50% and construction time by ~25%; the steady-state read path is unchanged. Closes #4616.
+
+-   [`f0c68749428fd4d3bba48e9685e44fd1ddbbee76`](https://github.com/mobxjs/mobx/commit/f0c68749428fd4d3bba48e9685e44fd1ddbbee76) [#4658](https://github.com/mobxjs/mobx/pull/4658) Thanks [@ashishkr96](https://github.com/ashishkr96)! - feat(mobx): make the 2022.3 `@observable accessor` decorator lazy. `ObservableValue` is now created on first read/write/observe of the decorated accessor rather than eagerly during instance construction, avoiding wasted allocations for fields that are never touched. On a 50k-instance × 10-field class with sparse access (1 of 10 fields read per instance), this cuts construction heap by ~82% and construction time by ~86% versus the eager path. Follow-up to #4639.
+
+### Patch Changes
+
+-   [`7eb54418b16fb9b415c04c5b8e05779790dd74ed`](https://github.com/mobxjs/mobx/commit/7eb54418b16fb9b415c04c5b8e05779790dd74ed) [#4659](https://github.com/mobxjs/mobx/pull/4659) Thanks [@kubk](https://github.com/kubk)! - Fix regression from #4639 where isComputedProp returned false for lazy @computed properties before first read
+
+-   [`c22b4b705447a4ccdce93473255f4beb170613f3`](https://github.com/mobxjs/mobx/commit/c22b4b705447a4ccdce93473255f4beb170613f3) [#4657](https://github.com/mobxjs/mobx/pull/4657) Thanks [@kubk](https://github.com/kubk)! - Add `getOrInsert` and `getOrInsertComputed` to `ObservableMap` for compatibility with ESNext `Map` typings.
+
+## 6.15.4
+
+### Patch Changes
+
+-   [`105c985c71308e439bfeed118fb1ba1eac06824e`](https://github.com/mobxjs/mobx/commit/105c985c71308e439bfeed118fb1ba1eac06824e) [#4650](https://github.com/mobxjs/mobx/pull/4650) Thanks [@kubk](https://github.com/kubk)! - Avoid Rolldown invalid PURE annotation warnings from Babel-generated optional chaining output.
+
 ## 6.15.3
 
 ### Patch Changes

package/dist/mobx.cjs.development.js

@@ -945,14 +945,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);
@@ -993,44 +1000,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_;
@@ -3218,13 +3218,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);
@@ -3252,7 +3257,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;
   }
@@ -4450,6 +4457,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);
@@ -4983,6 +5002,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_;
@@ -5000,10 +5021,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;
@@ -5724,10 +5777,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));
       }
@@ -5948,9 +6003,10 @@ function unwrap(a) {
   return a;
 }
 
-var _getGlobal$Iterator;
+var _global$Iterator;
 // safely get iterator prototype if available
-var maybeIteratorPrototype = ((_getGlobal$Iterator = /*#__PURE__*/getGlobal().Iterator) == null ? void 0 : _getGlobal$Iterator.prototype) || {};
+var global$1 = /*#__PURE__*/getGlobal();
+var maybeIteratorPrototype = ((_global$Iterator = global$1.Iterator) == null ? void 0 : _global$Iterator.prototype) || {};
 function makeIterable(iterator) {
   iterator[Symbol.iterator] = getSelf;
   return Object.assign(Object.create(maybeIteratorPrototype), iterator);