mobx-react 9.2.1 → 10.0.0

package/dist/mobxreact.umd.development.js

@@ -1,10 +1,28 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('mobx'), require('react'), require('mobx-react-lite')) :
     typeof define === 'function' && define.amd ? define(['exports', 'mobx', 'react', 'mobx-react-lite'], factory) :
-    (global = global || self, factory(global.mobxReact = {}, global.mobx, global.React, global.mobxReactLite));
-}(this, (function (exports, mobx, React, mobxReactLite) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.mobxReact = {}, global.mobx, global.React, global.mobxReactLite));
+})(this, (function (exports, mobx, React, mobxReactLite) { 'use strict';
 
-    var React__default = 'default' in React ? React['default'] : React;
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return n;
+    }
+
+    var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
     function shallowEqual(objA, objB) {
       //From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
@@ -14,12 +32,12 @@
       if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
         return false;
       }
-      var keysA = Object.keys(objA);
-      var keysB = Object.keys(objB);
+      const keysA = Object.keys(objA);
+      const keysB = Object.keys(objB);
       if (keysA.length !== keysB.length) {
         return false;
       }
-      for (var i = 0; i < keysA.length; i++) {
+      for (let i = 0; i < keysA.length; i++) {
         if (!Object.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
           return false;
         }
@@ -34,53 +52,24 @@
         return x !== x && y !== y;
       }
     }
-    // based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js
-    var hoistBlackList = {
-      $$typeof: 1,
-      render: 1,
-      compare: 1,
-      type: 1,
-      childContextTypes: 1,
-      contextType: 1,
-      contextTypes: 1,
-      defaultProps: 1,
-      getDefaultProps: 1,
-      getDerivedStateFromError: 1,
-      getDerivedStateFromProps: 1,
-      mixins: 1,
-      displayName: 1,
-      propTypes: 1
-    };
-    function copyStaticProperties(base, target) {
-      var protoProps = Object.getOwnPropertyNames(Object.getPrototypeOf(base));
-      Object.getOwnPropertyNames(base).forEach(function (key) {
-        if (!hoistBlackList[key] && protoProps.indexOf(key) === -1) {
-          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));
-        }
-      });
-    }
     /**
      * Utilities for patching componentWillUnmount, to make sure @disposeOnUnmount works correctly icm with user defined hooks
      * and the handler provided by mobx-react
      */
-    var mobxMixins = /*#__PURE__*/Symbol("patchMixins");
-    var mobxPatchedDefinition = /*#__PURE__*/Symbol("patchedDefinition");
+    const mobxMixins = /*#__PURE__*/Symbol("patchMixins");
+    const mobxPatchedDefinition = /*#__PURE__*/Symbol("patchedDefinition");
     function getMixins(target, methodName) {
-      var mixins = target[mobxMixins] = target[mobxMixins] || {};
-      var methodMixins = mixins[methodName] = mixins[methodName] || {};
+      const mixins = target[mobxMixins] = target[mobxMixins] || {};
+      const methodMixins = mixins[methodName] = mixins[methodName] || {};
       methodMixins.locks = methodMixins.locks || 0;
       methodMixins.methods = methodMixins.methods || [];
       return methodMixins;
     }
-    function wrapper(realMethod, mixins) {
-      var _this = this;
-      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-        args[_key - 2] = arguments[_key];
-      }
+    function wrapper(realMethod, mixins, ...args) {
       // locks are used to ensure that mixins are invoked only once per invocation, even on recursive calls
       mixins.locks++;
       try {
-        var retVal;
+        let retVal;
         if (realMethod !== undefined && realMethod !== null) {
           retVal = realMethod.apply(this, args);
         }
@@ -88,57 +77,60 @@
       } finally {
         mixins.locks--;
         if (mixins.locks === 0) {
-          mixins.methods.forEach(function (mx) {
-            mx.apply(_this, args);
+          mixins.methods.forEach(mx => {
+            mx.apply(this, args);
           });
         }
       }
     }
     function wrapFunction(realMethod, mixins) {
-      var fn = function fn() {
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          args[_key2] = arguments[_key2];
-        }
-        wrapper.call.apply(wrapper, [this, realMethod, mixins].concat(args));
+      const fn = function fn(...args) {
+        wrapper.call(this, realMethod, mixins, ...args);
       };
       return fn;
     }
     function patch(target, methodName, mixinMethod) {
-      var mixins = getMixins(target, methodName);
+      const mixins = getMixins(target, methodName);
       if (mixins.methods.indexOf(mixinMethod) < 0) {
         mixins.methods.push(mixinMethod);
       }
-      var oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);
+      const oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);
       if (oldDefinition && oldDefinition[mobxPatchedDefinition]) {
         // already patched definition, do not repatch
         return;
       }
-      var originalMethod = target[methodName];
-      var newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);
+      const originalMethod = target[methodName];
+      const newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);
       Object.defineProperty(target, methodName, newDefinition);
     }
     function createDefinition(target, methodName, enumerable, mixins, originalMethod) {
-      var _ref;
-      var wrappedFunc = wrapFunction(originalMethod, mixins);
-      return _ref = {}, _ref[mobxPatchedDefinition] = true, _ref.get = function get() {
-        return wrappedFunc;
-      }, _ref.set = function set(value) {
-        if (this === target) {
-          wrappedFunc = wrapFunction(value, mixins);
-        } else {
-          // when it is an instance of the prototype/a child prototype patch that particular case again separately
-          // since we need to store separate values depending on wether it is the actual instance, the prototype, etc
-          // e.g. the method for super might not be the same as the method for the prototype which might be not the same
-          // as the method for the instance
-          var newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
-          Object.defineProperty(this, methodName, newDefinition);
-        }
-      }, _ref.configurable = true, _ref.enumerable = enumerable, _ref;
+      let wrappedFunc = wrapFunction(originalMethod, mixins);
+      return {
+        // @ts-ignore
+        [mobxPatchedDefinition]: true,
+        get: function () {
+          return wrappedFunc;
+        },
+        set: function (value) {
+          if (this === target) {
+            wrappedFunc = wrapFunction(value, mixins);
+          } else {
+            // when it is an instance of the prototype/a child prototype patch that particular case again separately
+            // since we need to store separate values depending on wether it is the actual instance, the prototype, etc
+            // e.g. the method for super might not be the same as the method for the prototype which might be not the same
+            // as the method for the instance
+            const newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
+            Object.defineProperty(this, methodName, newDefinition);
+          }
+        },
+        configurable: true,
+        enumerable: enumerable
+      };
     }
 
-    var administrationSymbol = /*#__PURE__*/Symbol("ObserverAdministration");
-    var isMobXReactObserverSymbol = /*#__PURE__*/Symbol("isMobXReactObserver");
-    var observablePropDescriptors;
+    const administrationSymbol = /*#__PURE__*/Symbol("ObserverAdministration");
+    const isMobXReactObserverSymbol = /*#__PURE__*/Symbol("isMobXReactObserver");
+    let observablePropDescriptors;
     {
       observablePropDescriptors = {
         props: /*#__PURE__*/createObservablePropDescriptor("props"),
@@ -163,10 +155,12 @@
       };
     }
     function makeClassComponentObserver(componentClass) {
-      var prototype = componentClass.prototype;
+      const {
+        prototype
+      } = componentClass;
       if (componentClass[isMobXReactObserverSymbol]) {
-        var displayName = getDisplayName(componentClass);
-        throw new Error("The provided component class (" + displayName + ") has already been declared as an observer component.");
+        const displayName = getDisplayName(componentClass);
+        throw new Error(`The provided component class (${displayName}) has already been declared as an observer component.`);
       } else {
         componentClass[isMobXReactObserverSymbol] = true;
       }
@@ -184,10 +178,10 @@
       {
         Object.defineProperties(prototype, observablePropDescriptors);
       }
-      var originalRender = prototype.render;
+      const originalRender = prototype.render;
       if (typeof originalRender !== "function") {
-        var _displayName = getDisplayName(componentClass);
-        throw new Error("[mobx-react] class component (" + _displayName + ") is missing `render` method." + "\n`observer` requires `render` being a function defined on prototype." + "\n`render = () => {}` or `render = function() {}` is not supported.");
+        const displayName = getDisplayName(componentClass);
+        throw new Error(`[mobx-react] class component (${displayName}) is missing \`render\` method.` + `\n\`observer\` requires \`render\` being a function defined on prototype.` + `\n\`render = () => {}\` or \`render = function() {}\` is not supported.`);
       }
       prototype.render = function () {
         Object.defineProperty(this, "render", {
@@ -198,12 +192,11 @@
         });
         return this.render();
       };
-      var originalComponentDidMount = prototype.componentDidMount;
+      const originalComponentDidMount = prototype.componentDidMount;
       prototype.componentDidMount = function () {
-        var _this = this;
-        if ( this.componentDidMount !== Object.getPrototypeOf(this).componentDidMount) {
-          var _displayName2 = getDisplayName(componentClass);
-          throw new Error("[mobx-react] `observer(" + _displayName2 + ").componentDidMount` must be defined on prototype." + "\n`componentDidMount = () => {}` or `componentDidMount = function() {}` is not supported.");
+        if (this.componentDidMount !== Object.getPrototypeOf(this).componentDidMount) {
+          const displayName = getDisplayName(componentClass);
+          throw new Error(`[mobx-react] \`observer(${displayName}).componentDidMount\` must be defined on prototype.` + `\n\`componentDidMount = () => {}\` or \`componentDidMount = function() {}\` is not supported.`);
         }
         // `componentDidMount` may not be called at all. React can abandon the instance after `render`.
         // That's why we use finalization registry to dispose reaction created during render.
@@ -216,7 +209,7 @@
         // Therefore we don't have to worry about external (observable) state being updated before mount (no state version checking).
         //
         // Things may change: "In the future, React will provide a feature that lets components preserve state between unmounts"
-        var admin = getAdministration(this);
+        const admin = getAdministration(this);
         admin.mounted = true;
         // Component instance committed, prevent reaction disposal.
         mobxReactLite._observerFinalizationRegistry.unregister(this);
@@ -224,9 +217,7 @@
         // therefore `this` could NOT be garbage collected before mount,
         // preventing reaction disposal by FinalizationRegistry and leading to memory leak.
         // As an alternative we could have `admin.instanceRef = new WeakRef(this)`, but lets avoid it if possible.
-        admin.forceUpdate = function () {
-          return _this.forceUpdate();
-        };
+        admin.forceUpdate = () => this.forceUpdate();
         if (!admin.reaction || admin.reactionInvalidatedBeforeMount) {
           // Missing reaction:
           // 1. Instance was unmounted (reaction disposed) and immediately remounted without running render #3395.
@@ -246,7 +237,7 @@
         if (mobxReactLite.isUsingStaticRendering()) {
           return;
         }
-        var admin = getAdministration(this);
+        const admin = getAdministration(this);
         (_admin$reaction = admin.reaction) == null || _admin$reaction.dispose();
         admin.reaction = null;
         admin.forceUpdate = null;
@@ -260,8 +251,8 @@
       return componentClass.displayName || componentClass.name || "<component>";
     }
     function createReactiveRender(originalRender) {
-      var boundOriginalRender = originalRender.bind(this);
-      var admin = getAdministration(this);
+      const boundOriginalRender = originalRender.bind(this);
+      const admin = getAdministration(this);
       function reactiveRender() {
         if (!admin.reaction) {
           // Create reaction lazily to support re-mounting #3395
@@ -272,9 +263,9 @@
             mobxReactLite._observerFinalizationRegistry.register(this, admin, this);
           }
         }
-        var error = undefined;
-        var renderResult = undefined;
-        admin.reaction.track(function () {
+        let error = undefined;
+        let renderResult = undefined;
+        admin.reaction.track(() => {
           try {
             // TODO@major
             // Optimization: replace with _allowStateChangesStart/End (not available in mobx@6.0.0)
@@ -291,7 +282,7 @@
       return reactiveRender;
     }
     function createReaction(admin) {
-      return new mobx.Reaction(admin.name + ".render()", function () {
+      return new mobx.Reaction(`${admin.name}.render()`, () => {
         if (!admin.mounted) {
           // This is neccessary to avoid react warning about calling forceUpdate on component that isn't mounted yet.
           // This happens when component is abandoned after render - our reaction is already created and reacts to changes.
@@ -327,15 +318,17 @@
       return {
         configurable: true,
         enumerable: true,
-        get: function get() {
-          var admin = getAdministration(this);
-          var derivation = mobx._getGlobalState().trackingDerivation;
+        get() {
+          const admin = getAdministration(this);
+          const derivation = mobx._getGlobalState().trackingDerivation;
           if (derivation && derivation !== admin.reaction) {
-            throw new Error("[mobx-react] Cannot read \"" + admin.name + "." + key + "\" in a reactive context, as it isn't observable.\n                    Please use component lifecycle method to copy the value into a local observable first.\n                    See https://github.com/mobxjs/mobx/blob/main/packages/mobx-react/README.md#note-on-using-props-and-state-in-derivations");
+            throw new Error(`[mobx-react] Cannot read "${admin.name}.${key}" in a reactive context, as it isn't observable.
+                    Please use component lifecycle method to copy the value into a local observable first.
+                    See https://github.com/mobxjs/mobx/blob/main/packages/mobx-react/README.md#note-on-using-props-and-state-in-derivations`);
           }
           return admin[key];
         },
-        set: function set(value) {
+        set(value) {
           getAdministration(this)[key] = value;
         }
       };
@@ -345,10 +338,7 @@
       if (context && context.kind !== "class") {
         throw new Error("The @observer decorator can be used on classes only");
       }
-      if (component["isMobxInjector"] === true) {
-        console.warn("Mobx observer: You are trying to use `observer` on a component that already has `inject`. Please apply `observer` before applying `inject`");
-      }
-      if (Object.prototype.isPrototypeOf.call(React.Component, component) || Object.prototype.isPrototypeOf.call(React.PureComponent, component)) {
+      if (Object.prototype.isPrototypeOf.call(React__namespace.Component, component) || Object.prototype.isPrototypeOf.call(React__namespace.PureComponent, component)) {
         // Class component
         return makeClassComponentObserver(component);
       } else {
@@ -357,308 +347,6 @@
       }
     }
 
-    function _extends() {
-      return _extends = Object.assign ? Object.assign.bind() : function (n) {
-        for (var e = 1; e < arguments.length; e++) {
-          var t = arguments[e];
-          for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-        }
-        return n;
-      }, _extends.apply(null, arguments);
-    }
-    function _objectWithoutPropertiesLoose(r, e) {
-      if (null == r) return {};
-      var t = {};
-      for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-        if (e.indexOf(n) >= 0) continue;
-        t[n] = r[n];
-      }
-      return t;
-    }
-
-    var _excluded = ["children"];
-    var MobXProviderContext = /*#__PURE__*/React__default.createContext({});
-    function Provider(props) {
-      var children = props.children,
-        stores = _objectWithoutPropertiesLoose(props, _excluded);
-      var parentValue = React__default.useContext(MobXProviderContext);
-      var mutableProviderRef = React__default.useRef(_extends({}, parentValue, stores));
-      var value = mutableProviderRef.current;
-      {
-        var newValue = _extends({}, value, stores); // spread in previous state for the context based stores
-        if (!shallowEqual(value, newValue)) {
-          throw new Error("MobX Provider: The set of provided stores has changed. See: https://github.com/mobxjs/mobx-react#the-set-of-provided-stores-has-changed-error.");
-        }
-      }
-      return React__default.createElement(MobXProviderContext.Provider, {
-        value: value
-      }, children);
-    }
-    Provider.displayName = "MobXProvider";
-
-    /**
-     * Store Injection
-     */
-    function createStoreInjector(grabStoresFn, component, injectNames, makeReactive) {
-      // Support forward refs
-      var Injector = React__default.forwardRef(function (props, ref) {
-        var newProps = _extends({}, props);
-        var context = React__default.useContext(MobXProviderContext);
-        Object.assign(newProps, grabStoresFn(context || {}, newProps) || {});
-        if (ref) {
-          newProps.ref = ref;
-        }
-        return React__default.createElement(component, newProps);
-      });
-      if (makeReactive) Injector = observer(Injector);
-      Injector["isMobxInjector"] = true; // assigned late to suppress observer warning
-      // Static fields from component should be visible on the generated Injector
-      copyStaticProperties(component, Injector);
-      Injector["wrappedComponent"] = component;
-      Injector.displayName = getInjectName(component, injectNames);
-      return Injector;
-    }
-    function getInjectName(component, injectNames) {
-      var displayName;
-      var componentName = component.displayName || component.name || component.constructor && component.constructor.name || "Component";
-      if (injectNames) displayName = "inject-with-" + injectNames + "(" + componentName + ")";else displayName = "inject(" + componentName + ")";
-      return displayName;
-    }
-    function grabStoresByName(storeNames) {
-      return function (baseStores, nextProps) {
-        storeNames.forEach(function (storeName) {
-          if (storeName in nextProps // prefer props over stores
-          ) return;
-          if (!(storeName in baseStores)) throw new Error("MobX injector: Store '" + storeName + "' is not available! Make sure it is provided by some Provider");
-          nextProps[storeName] = baseStores[storeName];
-        });
-        return nextProps;
-      };
-    }
-    /**
-     * higher order component that injects stores to a child.
-     * takes either a varargs list of strings, which are stores read from the context,
-     * or a function that manually maps the available stores from the context to props:
-     * storesToProps(mobxStores, props, context) => newProps
-     */
-    function inject() {
-      for (var _len = arguments.length, storeNames = new Array(_len), _key = 0; _key < _len; _key++) {
-        storeNames[_key] = arguments[_key];
-      }
-      if (typeof arguments[0] === "function") {
-        var grabStoresFn = arguments[0];
-        return function (componentClass) {
-          return createStoreInjector(grabStoresFn, componentClass, grabStoresFn.name, true);
-        };
-      } else {
-        return function (componentClass) {
-          return createStoreInjector(grabStoresByName(storeNames), componentClass, storeNames.join("-"), false);
-        };
-      }
-    }
-
-    var reactMajorVersion = /*#__PURE__*/Number.parseInt( /*#__PURE__*/React__default.version.split(".")[0]);
-    var warnedAboutDisposeOnUnmountDeprecated = false;
-    var protoStoreKey = /*#__PURE__*/Symbol("disposeOnUnmountProto");
-    var instStoreKey = /*#__PURE__*/Symbol("disposeOnUnmountInst");
-    function runDisposersOnWillUnmount() {
-      var _this = this;
-      [].concat(this[protoStoreKey] || [], this[instStoreKey] || []).forEach(function (propKeyOrFunction) {
-        var prop = typeof propKeyOrFunction === "string" ? _this[propKeyOrFunction] : propKeyOrFunction;
-        if (prop !== undefined && prop !== null) {
-          if (Array.isArray(prop)) prop.map(function (f) {
-            return f();
-          });else prop();
-        }
-      });
-    }
-    /**
-     * @deprecated `disposeOnUnmount` is not compatible with React 18 and higher.
-     */
-    function disposeOnUnmount(target, propertyKeyOrFunction) {
-      if (Array.isArray(propertyKeyOrFunction)) {
-        return propertyKeyOrFunction.map(function (fn) {
-          return disposeOnUnmount(target, fn);
-        });
-      }
-      if (!warnedAboutDisposeOnUnmountDeprecated) {
-        if (reactMajorVersion >= 18) {
-          console.error("[mobx-react] disposeOnUnmount is not compatible with React 18 and higher. Don't use it.");
-        } else {
-          console.warn("[mobx-react] disposeOnUnmount is deprecated. It won't work correctly with React 18 and higher.");
-        }
-        warnedAboutDisposeOnUnmountDeprecated = true;
-      }
-      var c = Object.getPrototypeOf(target).constructor;
-      var c2 = Object.getPrototypeOf(target.constructor);
-      // Special case for react-hot-loader
-      var c3 = Object.getPrototypeOf(Object.getPrototypeOf(target));
-      if (!(c === React__default.Component || c === React__default.PureComponent || c2 === React__default.Component || c2 === React__default.PureComponent || c3 === React__default.Component || c3 === React__default.PureComponent)) {
-        throw new Error("[mobx-react] disposeOnUnmount only supports direct subclasses of React.Component or React.PureComponent.");
-      }
-      if (typeof propertyKeyOrFunction !== "string" && typeof propertyKeyOrFunction !== "function" && !Array.isArray(propertyKeyOrFunction)) {
-        throw new Error("[mobx-react] disposeOnUnmount only works if the parameter is either a property key or a function.");
-      }
-      // decorator's target is the prototype, so it doesn't have any instance properties like props
-      var isDecorator = typeof propertyKeyOrFunction === "string";
-      // add property key / function we want run (disposed) to the store
-      var componentWasAlreadyModified = !!target[protoStoreKey] || !!target[instStoreKey];
-      var store = isDecorator ?
-      // decorators are added to the prototype store
-      target[protoStoreKey] || (target[protoStoreKey] = []) :
-      // functions are added to the instance store
-      target[instStoreKey] || (target[instStoreKey] = []);
-      store.push(propertyKeyOrFunction);
-      // tweak the component class componentWillUnmount if not done already
-      if (!componentWasAlreadyModified) {
-        patch(target, "componentWillUnmount", runDisposersOnWillUnmount);
-      }
-      // return the disposer as is if invoked as a non decorator
-      if (typeof propertyKeyOrFunction !== "string") {
-        return propertyKeyOrFunction;
-      }
-    }
-
-    // Copied from React.PropTypes
-    function createChainableTypeChecker(validator) {
-      function checkType(isRequired, props, propName, componentName, location, propFullName) {
-        for (var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
-          rest[_key - 6] = arguments[_key];
-        }
-        return mobx.untracked(function () {
-          componentName = componentName || "<<anonymous>>";
-          propFullName = propFullName || propName;
-          if (props[propName] == null) {
-            if (isRequired) {
-              var actual = props[propName] === null ? "null" : "undefined";
-              return new Error("The " + location + " `" + propFullName + "` is marked as required " + "in `" + componentName + "`, but its value is `" + actual + "`.");
-            }
-            return null;
-          } else {
-            // @ts-ignore rest arg is necessary for some React internals - fails tests otherwise
-            return validator.apply(void 0, [props, propName, componentName, location, propFullName].concat(rest));
-          }
-        });
-      }
-      var chainedCheckType = checkType.bind(null, false);
-      // Add isRequired to satisfy Requirable
-      chainedCheckType.isRequired = checkType.bind(null, true);
-      return chainedCheckType;
-    }
-    // Copied from React.PropTypes
-    function isSymbol(propType, propValue) {
-      // Native Symbol.
-      if (propType === "symbol") {
-        return true;
-      }
-      // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
-      if (propValue["@@toStringTag"] === "Symbol") {
-        return true;
-      }
-      // Fallback for non-spec compliant Symbols which are polyfilled.
-      if (typeof Symbol === "function" && propValue instanceof Symbol) {
-        return true;
-      }
-      return false;
-    }
-    // Copied from React.PropTypes
-    function getPropType(propValue) {
-      var propType = typeof propValue;
-      if (Array.isArray(propValue)) {
-        return "array";
-      }
-      if (propValue instanceof RegExp) {
-        // Old webkits (at least until Android 4.0) return 'function' rather than
-        // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
-        // passes PropTypes.object.
-        return "object";
-      }
-      if (isSymbol(propType, propValue)) {
-        return "symbol";
-      }
-      return propType;
-    }
-    // This handles more types than `getPropType`. Only used for error messages.
-    // Copied from React.PropTypes
-    function getPreciseType(propValue) {
-      var propType = getPropType(propValue);
-      if (propType === "object") {
-        if (propValue instanceof Date) {
-          return "date";
-        } else if (propValue instanceof RegExp) {
-          return "regexp";
-        }
-      }
-      return propType;
-    }
-    function createObservableTypeCheckerCreator(allowNativeType, mobxType) {
-      return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
-        return mobx.untracked(function () {
-          if (allowNativeType) {
-            if (getPropType(props[propName]) === mobxType.toLowerCase()) return null;
-          }
-          var mobxChecker;
-          switch (mobxType) {
-            case "Array":
-              mobxChecker = mobx.isObservableArray;
-              break;
-            case "Object":
-              mobxChecker = mobx.isObservableObject;
-              break;
-            case "Map":
-              mobxChecker = mobx.isObservableMap;
-              break;
-            default:
-              throw new Error("Unexpected mobxType: " + mobxType);
-          }
-          var propValue = props[propName];
-          if (!mobxChecker(propValue)) {
-            var preciseType = getPreciseType(propValue);
-            var nativeTypeExpectationMessage = allowNativeType ? " or javascript `" + mobxType.toLowerCase() + "`" : "";
-            return new Error("Invalid prop `" + propFullName + "` of type `" + preciseType + "` supplied to" + " `" + componentName + "`, expected `mobx.Observable" + mobxType + "`" + nativeTypeExpectationMessage + ".");
-          }
-          return null;
-        });
-      });
-    }
-    function createObservableArrayOfTypeChecker(allowNativeType, typeChecker) {
-      return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
-        for (var _len2 = arguments.length, rest = new Array(_len2 > 5 ? _len2 - 5 : 0), _key2 = 5; _key2 < _len2; _key2++) {
-          rest[_key2 - 5] = arguments[_key2];
-        }
-        return mobx.untracked(function () {
-          if (typeof typeChecker !== "function") {
-            return new Error("Property `" + propFullName + "` of component `" + componentName + "` has " + "invalid PropType notation.");
-          } else {
-            var error = createObservableTypeCheckerCreator(allowNativeType, "Array")(props, propName, componentName, location, propFullName);
-            if (error instanceof Error) return error;
-            var propValue = props[propName];
-            for (var i = 0; i < propValue.length; i++) {
-              error = typeChecker.apply(void 0, [propValue, i, componentName, location, propFullName + "[" + i + "]"].concat(rest));
-              if (error instanceof Error) return error;
-            }
-            return null;
-          }
-        });
-      });
-    }
-    var observableArray = /*#__PURE__*/createObservableTypeCheckerCreator(false, "Array");
-    var observableArrayOf = /*#__PURE__*/createObservableArrayOfTypeChecker.bind(null, false);
-    var observableMap = /*#__PURE__*/createObservableTypeCheckerCreator(false, "Map");
-    var observableObject = /*#__PURE__*/createObservableTypeCheckerCreator(false, "Object");
-    var arrayOrObservableArray = /*#__PURE__*/createObservableTypeCheckerCreator(true, "Array");
-    var arrayOrObservableArrayOf = /*#__PURE__*/createObservableArrayOfTypeChecker.bind(null, true);
-    var objectOrObservableObject = /*#__PURE__*/createObservableTypeCheckerCreator(true, "Object");
-    var PropTypes = {
-      observableArray: observableArray,
-      observableArrayOf: observableArrayOf,
-      observableMap: observableMap,
-      observableObject: observableObject,
-      arrayOrObservableArray: arrayOrObservableArray,
-      arrayOrObservableArrayOf: arrayOrObservableArrayOf,
-      objectOrObservableObject: objectOrObservableObject
-    };
-
     if (!React.Component) {
       throw new Error("mobx-react requires React to be available");
     }
@@ -668,66 +356,31 @@
 
     Object.defineProperty(exports, 'Observer', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.Observer;
-        }
+        get: function () { return mobxReactLite.Observer; }
     });
-    Object.defineProperty(exports, 'enableStaticRendering', {
+    Object.defineProperty(exports, '_observerFinalizationRegistry', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.enableStaticRendering;
-        }
+        get: function () { return mobxReactLite._observerFinalizationRegistry; }
     });
-    Object.defineProperty(exports, 'isUsingStaticRendering', {
+    Object.defineProperty(exports, 'clearTimers', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.isUsingStaticRendering;
-        }
+        get: function () { return mobxReactLite.clearTimers; }
     });
-    Object.defineProperty(exports, 'observerBatching', {
+    Object.defineProperty(exports, 'enableStaticRendering', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.observerBatching;
-        }
+        get: function () { return mobxReactLite.enableStaticRendering; }
     });
-    Object.defineProperty(exports, 'useAsObservableSource', {
+    Object.defineProperty(exports, 'isUsingStaticRendering', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.useAsObservableSource;
-        }
+        get: function () { return mobxReactLite.isUsingStaticRendering; }
     });
     Object.defineProperty(exports, 'useLocalObservable', {
         enumerable: true,
-        get: function () {
-            return mobxReactLite.useLocalObservable;
-        }
-    });
-    Object.defineProperty(exports, 'useLocalStore', {
-        enumerable: true,
-        get: function () {
-            return mobxReactLite.useLocalStore;
-        }
-    });
-    Object.defineProperty(exports, 'useObserver', {
-        enumerable: true,
-        get: function () {
-            return mobxReactLite.useObserver;
-        }
-    });
-    Object.defineProperty(exports, 'useStaticRendering', {
-        enumerable: true,
-        get: function () {
-            return mobxReactLite.useStaticRendering;
-        }
+        get: function () { return mobxReactLite.useLocalObservable; }
     });
-    exports.MobXProviderContext = MobXProviderContext;
-    exports.PropTypes = PropTypes;
-    exports.Provider = Provider;
-    exports.disposeOnUnmount = disposeOnUnmount;
-    exports.inject = inject;
     exports.observer = observer;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=mobxreact.umd.development.js.map