mobx-react 6.1.1 → 6.1.5

package/dist/mobx-react.rn.module.js

@@ -1,2 +1,705 @@
-import{unstable_batchedUpdates as r}from"react-native";import{isUsingStaticRendering as e,observer as t,Observer as n}from"mobx-react-lite";export{Observer,useAsObservableSource,useLocalStore,isUsingStaticRendering,useStaticRendering}from"mobx-react-lite";import o,{PureComponent as i,Component as a,forwardRef as c,Children as s,createContext as u,createElement as f}from"react";import{createAtom as p,_allowStateChanges as l,Reaction as d,$mobx as y,isObservableArray as h,isObservableObject as b,isObservableMap as v,untracked as m,observable as O,configure as g}from"mobx";var w=0,j={};function x(r){return j[r]||(j[r]=function(r){if("function"==typeof Symbol)return Symbol(r);var e="__$mobx-react "+r+" ("+w+")";return w++,e}(r)),j[r]}function P(r,e){if(E(r,e))return!0;if("object"!=typeof r||null===r||"object"!=typeof e||null===e)return!1;var t=Object.keys(r),n=Object.keys(e);if(t.length!==n.length)return!1;for(var o=0;o<t.length;o++)if(!hasOwnProperty.call(e,t[o])||!E(r[t[o]],e[t[o]]))return!1;return!0}function E(r,e){return r===e?0!==r||1/r==1/e:r!=r&&e!=e}var R={$$typeof:1,render:1,compare:1,type:1,childContextTypes:1,contextType:1,contextTypes:1,defaultProps:1,getDefaultProps:1,getDerivedStateFromError:1,getDerivedStateFromProps:1,mixins:1,propTypes:1};function _(r,e,t){Object.hasOwnProperty.call(r,e)?r[e]=t:Object.defineProperty(r,e,{enumerable:!1,configurable:!0,writable:!0,value:t})}var k=x("patchMixins"),A=x("patchedDefinition");function S(r,e){for(var t=this,n=[],o=arguments.length-2;o-- >0;)n[o]=arguments[o+2];e.locks++;try{var i;return null!=r&&(i=r.apply(this,n)),i}finally{e.locks--,0===e.locks&&e.methods.forEach(function(r){r.apply(t,n)})}}function C(r,e){return function(){for(var t=[],n=arguments.length;n--;)t[n]=arguments[n];S.call.apply(S,[this,r,e].concat(t))}}function U(r,e,t){var n=function(r,e){var t=r[k]=r[k]||{},n=t[e]=t[e]||{};return n.locks=n.locks||0,n.methods=n.methods||[],n}(r,e);n.methods.indexOf(t)<0&&n.methods.push(t);var o=Object.getOwnPropertyDescriptor(r,e);if(!o||!o[A]){var i=function r(e,t,n,o,i){var a,c=C(i,o);return(a={})[A]=!0,a.get=function(){return c},a.set=function(i){if(this===e)c=C(i,o);else{var a=r(this,t,n,o,i);Object.defineProperty(this,t,a)}},a.configurable=!0,a.enumerable=n,a}(r,e,o?o.enumerable:void 0,n,r[e]);Object.defineProperty(r,e,i)}}var T=y||"$mobx",M=x("isUnmounted"),D=x("skipRender"),N=x("isForcingUpdate");function $(r,t){return e()&&console.warn("[mobx-react] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side."),this.state!==t||!P(this.props,r)}function I(r,e){var t=x("reactProp_"+e+"_valueHolder"),n=x("reactProp_"+e+"_atomHolder");function o(){return this[n]||_(this,n,p("reactive "+e)),this[n]}Object.defineProperty(r,e,{configurable:!0,enumerable:!0,get:function(){return o.call(this).reportObserved(),this[t]},set:function(r){this[N]||P(this[t],r)?_(this,t,r):(_(this,t,r),_(this,D,!0),o.call(this).reportChanged(),_(this,D,!1))}})}var F="function"==typeof c&&c(function(r,e){}).$$typeof;function W(r){if(!0===r.isMobxInjector&&console.warn("Mobx observer: You are trying to use 'observer' on a component that already has 'inject'. Please apply 'observer' before applying 'inject'"),F&&r.$$typeof===F){var s=r.render;if("function"!=typeof s)throw new Error("render property of ForwardRef was not a function");return c(function(){var r=arguments;return o.createElement(n,null,function(){return s.apply(void 0,r)})})}return"function"!=typeof r||r.prototype&&r.prototype.render||r.isReactClass||a.isPrototypeOf(r)?function(r){var t=r.prototype;if(t.componentWillReact)throw new Error("The componentWillReact life-cycle event is no longer supported");if(r.__proto__!==i)if(t.shouldComponentUpdate){if(t.shouldComponentUpdate!==$)throw new Error("It is not allowed to use shouldComponentUpdate in observer based components.")}else t.shouldComponentUpdate=$;I(t,"props"),I(t,"state");var n=t.render;return t.render=function(){return function(r){var t=this;if(!0===e())return r.call(this);_(this,D,!1),_(this,N,!1);var n=this.displayName||this.name||this.constructor&&(this.constructor.displayName||this.constructor.name)||"<component>",o=r.bind(this),i=!1,c=new d(n+".render()",function(){if(!i&&(i=!0,!0!==t[M])){var r=!0;try{_(t,N,!0),t[D]||a.prototype.forceUpdate.call(t),r=!1}finally{_(t,N,!1),r&&c.dispose()}}});function s(){i=!1;var r=void 0,e=void 0;if(c.track(function(){try{e=l(!1,o)}catch(e){r=e}}),r)throw r;return e}return c.reactComponent=this,s[T]=c,this.render=s,s.call(this)}.call(this,n)},U(t,"componentWillUnmount",function(){!0!==e()&&(this.render[T]&&this.render[T].dispose(),this[M]=!0)}),r}(r):t(r)}var q={children:!0,key:!0,ref:!0},L=u({}),H=function(r){function e(e,t){r.call(this,e,t),this.state=Object.assign({},t,X(e))}return r&&(e.__proto__=r),(e.prototype=Object.create(r&&r.prototype)).constructor=e,e.prototype.render=function(){return f(L.Provider,{value:this.state},s.only(this.props.children))},e.getDerivedStateFromProps=function(r,e){if("production"!==process.env.NODE_ENV&&!P(e,Object.assign({},e,X(r))))throw new Error("MobX Provider: The set of provided stores has changed. Please avoid changing stores as the change might not propagate to all children");return e},e}(a);function X(r){var e={};if(!r)return e;for(var t in r)V(t)&&(e[t]=r[t]);return e}function V(r){return!q[r]&&"suppressChangedStoreWarning"!==r}function Y(r,e,t,n){var i=function(r,e){var t=r.displayName||r.name||r.constructor&&r.constructor.name||"Component";return e?"inject-with-"+e+"("+t+")":"inject("+t+")"}(e,t),c=function(t){function n(){t.apply(this,arguments)}return t&&(n.__proto__=t),(n.prototype=Object.create(t&&t.prototype)).constructor=n,n.prototype.render=function(){var t=this.props,n=t.forwardRef,o=function(r,e){var t={};for(var n in r)Object.prototype.hasOwnProperty.call(r,n)&&-1===e.indexOf(n)&&(t[n]=r[n]);return t}(t,["forwardRef"]);return Object.assign(o,r(this.context||{},o)||{}),n&&!function(r){return!(r.prototype&&r.prototype.render)}(e)&&(o.ref=this.props.forwardRef),f(e,o)},n}(a);c.contextType=L,n&&(c=W(c)),c.isMobxInjector=!0;var s,u,p,l=o.forwardRef(function(r,e){return o.createElement(c,Object.assign({},r,{forwardRef:e}))});return s=e,u=l,p=Object.getOwnPropertyNames(Object.getPrototypeOf(s)),Object.getOwnPropertyNames(s).forEach(function(r){R[r]||-1!==p.indexOf(r)||Object.defineProperty(u,r,Object.getOwnPropertyDescriptor(s,r))}),l.wrappedComponent=e,l.displayName=i,l}function z(){for(var r,e=[],t=arguments.length;t--;)e[t]=arguments[t];return"function"==typeof arguments[0]?(r=arguments[0],function(e){return Y(r,e,r.name,!0)}):function(r){return Y(function(r){return function(e,t){return r.forEach(function(r){if(!(r in t)){if(!(r in e))throw new Error("MobX injector: Store '"+r+"' is not available! Make sure it is provided by some Provider");t[r]=e[r]}}),t}}(e),r,e.join("-"),!1)}}H.contextType=L;var B=x("disposeOnUnmountProto"),G=x("disposeOnUnmountInst");function J(){var r=this;(this[B]||[]).concat(this[G]||[]).forEach(function(e){var t="string"==typeof e?r[e]:e;null!=t&&(Array.isArray(t)?t.map(function(r){return r()}):t())})}function K(r,e){if(Array.isArray(e))return e.map(function(e){return K(r,e)});var t=Object.getPrototypeOf(r).constructor||Object.getPrototypeOf(r.constructor),n=Object.getPrototypeOf(r.constructor);if(t!==a&&t!==i&&n!==a&&n!==i)throw new Error("[mobx-react] disposeOnUnmount only supports direct subclasses of React.Component or React.PureComponent.");if("string"!=typeof e&&"function"!=typeof e&&!Array.isArray(e))throw new Error("[mobx-react] disposeOnUnmount only works if the parameter is either a property key or a function.");var o=!!r[B]||!!r[G];return("string"==typeof e?r[B]||(r[B]=[]):r[G]||(r[G]=[])).push(e),o||U(r,"componentWillUnmount",J),"string"!=typeof e?e:void 0}function Q(r){function e(e,t,n,o,i,a){for(var c=[],s=arguments.length-6;s-- >0;)c[s]=arguments[s+6];return m(function(){return o=o||"<<anonymous>>",a=a||n,null==t[n]?e?new Error("The "+i+" `"+a+"` is marked as required in `"+o+"`, but its value is `"+(null===t[n]?"null":"undefined")+"`."):null:r.apply(void 0,[t,n,o,i,a].concat(c))})}var t=e.bind(null,!1);return t.isRequired=e.bind(null,!0),t}function Z(r){var e=typeof r;return Array.isArray(r)?"array":r instanceof RegExp?"object":function(r,e){return"symbol"===r||"Symbol"===e["@@toStringTag"]||"function"==typeof Symbol&&e instanceof Symbol}(e,r)?"symbol":e}function rr(r,e){return Q(function(t,n,o,i,a){return m(function(){if(r&&Z(t[n])===e.toLowerCase())return null;var i;switch(e){case"Array":i=h;break;case"Object":i=b;break;case"Map":i=v;break;default:throw new Error("Unexpected mobxType: "+e)}var c=t[n];if(!i(c)){var s=function(r){var e=Z(r);if("object"===e){if(r instanceof Date)return"date";if(r instanceof RegExp)return"regexp"}return e}(c),u=r?" or javascript `"+e.toLowerCase()+"`":"";return new Error("Invalid prop `"+a+"` of type `"+s+"` supplied to `"+o+"`, expected `mobx.Observable"+e+"`"+u+".")}return null})})}function er(r,e){return Q(function(t,n,o,i,a){for(var c=[],s=arguments.length-5;s-- >0;)c[s]=arguments[s+5];return m(function(){if("function"!=typeof e)return new Error("Property `"+a+"` of component `"+o+"` has invalid PropType notation.");var s=rr(r,"Array")(t,n,o);if(s instanceof Error)return s;for(var u=t[n],f=0;f<u.length;f++)if((s=e.apply(void 0,[u,f,o,i,a+"["+f+"]"].concat(c)))instanceof Error)return s;return null})})}var tr={observableArray:rr(!1,"Array"),observableArrayOf:er.bind(null,!1),observableMap:rr(!1,"Map"),observableObject:rr(!1,"Object"),arrayOrObservableArray:rr(!0,"Array"),arrayOrObservableArrayOf:er.bind(null,!0),objectOrObservableObject:rr(!0,"Object")};if(!a)throw new Error("mobx-react requires React to be available");if(!O)throw new Error("mobx-react requires mobx to be available");"function"==typeof r&&g({reactionScheduler:r});export{W as observer,H as Provider,L as MobXProviderContext,z as inject,K as disposeOnUnmount,tr as PropTypes};
+import { unstable_batchedUpdates } from 'react-native';
+import { isUsingStaticRendering, observer, Observer } from 'mobx-react-lite';
+export { Observer, useObserver, useAsObservableSource, useLocalStore, isUsingStaticRendering, useStaticRendering } from 'mobx-react-lite';
+import React__default, { PureComponent, Component, forwardRef, memo, createElement } from 'react';
+import { createAtom, _allowStateChanges, Reaction, $mobx, isObservableArray, isObservableObject, isObservableMap, untracked, observable, configure } from 'mobx';
+
+var symbolId = 0;
+
+function createSymbol(name) {
+  if (typeof Symbol === "function") {
+    return Symbol(name);
+  }
+
+  var symbol = "__$mobx-react " + name + " (" + symbolId + ")";
+  symbolId++;
+  return symbol;
+}
+
+var createdSymbols = {};
+function newSymbol(name) {
+  if (!createdSymbols[name]) {
+    createdSymbols[name] = createSymbol(name);
+  }
+
+  return createdSymbols[name];
+}
+function shallowEqual(objA, objB) {
+  //From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
+  if (is(objA, objB)) { return true; }
+
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) { return false; }
+
+  for (var i = 0; i < keysA.length; i++) {
+    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function is(x, y) {
+  // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    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,
+  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));
+    }
+  });
+}
+/**
+ * Helper to set `prop` to `this` as non-enumerable (hidden prop)
+ * @param target
+ * @param prop
+ * @param value
+ */
+
+function setHiddenProp(target, prop, value) {
+  if (!Object.hasOwnProperty.call(target, prop)) {
+    Object.defineProperty(target, prop, {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: value
+    });
+  } else {
+    target[prop] = value;
+  }
+}
+/**
+ * Utilities for patching componentWillUnmount, to make sure @disposeOnUnmount works correctly icm with user defined hooks
+ * and the handler provided by mobx-react
+ */
+
+var mobxMixins = newSymbol("patchMixins");
+var mobxPatchedDefinition = newSymbol("patchedDefinition");
+
+function getMixins(target, methodName) {
+  var mixins = target[mobxMixins] = target[mobxMixins] || {};
+  var methodMixins = mixins[methodName] = mixins[methodName] || {};
+  methodMixins.locks = methodMixins.locks || 0;
+  methodMixins.methods = methodMixins.methods || [];
+  return methodMixins;
+}
+
+function wrapper(realMethod, mixins) {
+  var this$1 = this;
+  var args = [], len = arguments.length - 2;
+  while ( len-- > 0 ) args[ len ] = arguments[ len + 2 ];
+
+  // locks are used to ensure that mixins are invoked only once per invocation, even on recursive calls
+  mixins.locks++;
+
+  try {
+    var retVal;
+
+    if (realMethod !== undefined && realMethod !== null) {
+      retVal = realMethod.apply(this, args);
+    }
+
+    return retVal;
+  } finally {
+    mixins.locks--;
+
+    if (mixins.locks === 0) {
+      mixins.methods.forEach(function (mx) {
+        mx.apply(this$1, args);
+      });
+    }
+  }
+}
+
+function wrapFunction(realMethod, mixins) {
+  var fn = function () {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
+
+    wrapper.call.apply(wrapper, [ this, realMethod, mixins ].concat( args ));
+  };
+
+  return fn;
+}
+
+function patch(target, methodName, mixinMethod) {
+  var mixins = getMixins(target, methodName);
+
+  if (mixins.methods.indexOf(mixinMethod) < 0) {
+    mixins.methods.push(mixinMethod);
+  }
+
+  var 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);
+  Object.defineProperty(target, methodName, newDefinition);
+}
+
+function createDefinition(target, methodName, enumerable, mixins, originalMethod) {
+  var obj;
+
+  var wrappedFunc = wrapFunction(originalMethod, mixins);
+  return ( obj = {}, obj[mobxPatchedDefinition] = true, obj.get = function () {
+      return wrappedFunc;
+    }, obj.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
+        var newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
+        Object.defineProperty(this, methodName, newDefinition);
+      }
+    }, obj.configurable = true, obj.enumerable = enumerable, obj );
+}
+
+var mobxAdminProperty = $mobx || "$mobx";
+var mobxIsUnmounted = newSymbol("isUnmounted");
+var skipRenderKey = newSymbol("skipRender");
+var isForcingUpdateKey = newSymbol("isForcingUpdate");
+function makeClassComponentObserver(componentClass) {
+  var target = componentClass.prototype;
+  if (target.componentWillReact) { throw new Error("The componentWillReact life-cycle event is no longer supported"); }
+
+  if (componentClass.__proto__ !== PureComponent) {
+    if (!target.shouldComponentUpdate) { target.shouldComponentUpdate = observerSCU; }else if (target.shouldComponentUpdate !== observerSCU) // n.b. unequal check, instead of existence check, as @observer might be on superclass as well
+      { throw new Error("It is not allowed to use shouldComponentUpdate in observer based components."); }
+  } // this.props and this.state are made observable, just to make sure @computed fields that
+  // are defined inside the component, and which rely on state or props, re-compute if state or props change
+  // (otherwise the computed wouldn't update and become stale on props change, since props are not observable)
+  // However, this solution is not without it's own problems: https://github.com/mobxjs/mobx-react/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3Aobservable-props-or-not+
+
+
+  makeObservableProp(target, "props");
+  makeObservableProp(target, "state");
+  var baseRender = target.render;
+
+  target.render = function () {
+    return makeComponentReactive.call(this, baseRender);
+  };
+
+  patch(target, "componentWillUnmount", function () {
+    if (isUsingStaticRendering() === true) { return; }
+
+    if (this.render[mobxAdminProperty]) {
+      this.render[mobxAdminProperty].dispose();
+    } else if (process.env.NODE_ENV !== "production") {
+      var displayName = getDisplayName(this);
+      console.warn(("The render function for an observer component (" + displayName + ") was modified after MobX attached. This is not supported, since the new function can't be triggered by MobX."));
+    }
+
+    this[mobxIsUnmounted] = true;
+  });
+  return componentClass;
+} // Generates a friendly name for debugging
+
+function getDisplayName(comp) {
+  return comp.displayName || comp.name || comp.constructor && (comp.constructor.displayName || comp.constructor.name) || "<component>";
+}
+
+function makeComponentReactive(render) {
+  var this$1 = this;
+
+  if (isUsingStaticRendering() === true) { return render.call(this); }
+  /**
+   * If props are shallowly modified, react will render anyway,
+   * so atom.reportChanged() should not result in yet another re-render
+   */
+
+  setHiddenProp(this, skipRenderKey, false);
+  /**
+   * forceUpdate will re-assign this.props. We don't want that to cause a loop,
+   * so detect these changes
+   */
+
+  setHiddenProp(this, isForcingUpdateKey, false);
+  var initialName = getDisplayName(this);
+  var baseRender = render.bind(this);
+  var isRenderingPending = false;
+  var reaction = new Reaction((initialName + ".render()"), function () {
+    if (!isRenderingPending) {
+      // N.B. Getting here *before mounting* means that a component constructor has side effects (see the relevant test in misc.js)
+      // This unidiomatic React usage but React will correctly warn about this so we continue as usual
+      // See #85 / Pull #44
+      isRenderingPending = true;
+
+      if (this$1[mobxIsUnmounted] !== true) {
+        var hasError = true;
+
+        try {
+          setHiddenProp(this$1, isForcingUpdateKey, true);
+          if (!this$1[skipRenderKey]) { Component.prototype.forceUpdate.call(this$1); }
+          hasError = false;
+        } finally {
+          setHiddenProp(this$1, isForcingUpdateKey, false);
+          if (hasError) { reaction.dispose(); }
+        }
+      }
+    }
+  });
+  reaction.reactComponent = this;
+  reactiveRender[mobxAdminProperty] = reaction;
+  this.render = reactiveRender;
+
+  function reactiveRender() {
+    isRenderingPending = false;
+    var exception = undefined;
+    var rendering = undefined;
+    reaction.track(function () {
+      try {
+        rendering = _allowStateChanges(false, baseRender);
+      } catch (e) {
+        exception = e;
+      }
+    });
+
+    if (exception) {
+      throw exception;
+    }
+
+    return rendering;
+  }
+
+  return reactiveRender.call(this);
+}
+
+function observerSCU(nextProps, nextState) {
+  if (isUsingStaticRendering()) {
+    console.warn("[mobx-react] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side.");
+  } // update on any state changes (as is the default)
+
+
+  if (this.state !== nextState) {
+    return true;
+  } // update if props are shallowly not equal, inspired by PureRenderMixin
+  // we could return just 'false' here, and avoid the `skipRender` checks etc
+  // however, it is nicer if lifecycle events are triggered like usually,
+  // so we return true here if props are shallowly modified.
+
+
+  return !shallowEqual(this.props, nextProps);
+}
+
+function makeObservableProp(target, propName) {
+  var valueHolderKey = newSymbol(("reactProp_" + propName + "_valueHolder"));
+  var atomHolderKey = newSymbol(("reactProp_" + propName + "_atomHolder"));
+
+  function getAtom() {
+    if (!this[atomHolderKey]) {
+      setHiddenProp(this, atomHolderKey, createAtom("reactive " + propName));
+    }
+
+    return this[atomHolderKey];
+  }
+
+  Object.defineProperty(target, propName, {
+    configurable: true,
+    enumerable: true,
+    get: function () {
+      getAtom.call(this).reportObserved();
+      return this[valueHolderKey];
+    },
+    set: function set(v) {
+      if (!this[isForcingUpdateKey] && !shallowEqual(this[valueHolderKey], v)) {
+        setHiddenProp(this, valueHolderKey, v);
+        setHiddenProp(this, skipRenderKey, true);
+        getAtom.call(this).reportChanged();
+        setHiddenProp(this, skipRenderKey, false);
+      } else {
+        setHiddenProp(this, valueHolderKey, v);
+      }
+    }
+  });
+}
+
+/* eslint-disable react/display-name */
+var hasSymbol = typeof Symbol === "function" && Symbol.for; // Using react-is had some issues (and operates on elements, not on types), see #608 / #609
+
+var ReactForwardRefSymbol = hasSymbol ? Symbol.for("react.forward_ref") : typeof forwardRef === "function" && forwardRef(function () {})["$$typeof"];
+var ReactMemoSymbol = hasSymbol ? Symbol.for("react.memo") : typeof memo === "function" && memo(function () {})["$$typeof"];
+/**
+ * Observer function / decorator
+ */
+
+function observer$1(componentClass) {
+  if (componentClass.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 (ReactMemoSymbol && componentClass["$$typeof"] === ReactMemoSymbol) {
+    throw new Error("Mobx observer: You are trying to use 'observer' on function component wrapped to either another observer or 'React.memo'. The observer already applies 'React.memo' for you.");
+  } // Unwrap forward refs into `<Observer>` component
+  // we need to unwrap the render, because it is the inner render that needs to be tracked,
+  // not the ForwardRef HoC
+
+
+  if (ReactForwardRefSymbol && componentClass["$$typeof"] === ReactForwardRefSymbol) {
+    var baseRender = componentClass.render;
+    if (typeof baseRender !== "function") { throw new Error("render property of ForwardRef was not a function"); }
+    return forwardRef(function ObserverForwardRef() {
+      var arguments$1 = arguments;
+
+      return React__default.createElement( Observer, null, function () { return baseRender.apply(undefined, arguments$1); } );
+    });
+  } // Function component
+
+
+  if (typeof componentClass === "function" && (!componentClass.prototype || !componentClass.prototype.render) && !componentClass.isReactClass && !Object.prototype.isPrototypeOf.call(Component, componentClass)) {
+    return observer(componentClass);
+  }
+
+  return makeClassComponentObserver(componentClass);
+}
+
+/* eslint-disable react/prop-types */
+function objectWithoutProperties (obj, exclude) { var target = {}; for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k]; return target; }
+var MobXProviderContext = React__default.createContext({});
+function Provider(ref) {
+  var children = ref.children;
+  var rest = objectWithoutProperties( ref, ["children"] );
+  var stores = rest;
+
+  var parentValue = React__default.useContext(MobXProviderContext);
+  var value = React__default.useRef(Object.assign({}, parentValue,
+    stores)).current;
+
+  if (process && typeof process.env !== "undefined" && process.env.NODE_ENV !== "production") {
+    var newValue = Object.assign({}, 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 = Object.assign({}, props);
+    var context = React__default.useContext(MobXProviderContext);
+    Object.assign(newProps, grabStoresFn(context || {}, newProps) || {});
+
+    if (ref) {
+      newProps.ref = ref;
+    }
+
+    return createElement(component, newProps);
+  });
+  if (makeReactive) { Injector = observer$1(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(
+/* fn(stores, nextProps) or ...storeNames */) {
+  var storeNames = [], len = arguments.length;
+  while ( len-- ) storeNames[ len ] = arguments[ len ];
+
+  var grabStoresFn;
+
+  if (typeof arguments[0] === "function") {
+    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 protoStoreKey = newSymbol("disposeOnUnmountProto");
+var instStoreKey = newSymbol("disposeOnUnmountInst");
+
+function runDisposersOnWillUnmount() {
+  var this$1 = this;
+  (this[protoStoreKey] || []).concat( (this[instStoreKey] || [])).forEach(function (propKeyOrFunction) {
+    var prop = typeof propKeyOrFunction === "string" ? this$1[propKeyOrFunction] : propKeyOrFunction;
+
+    if (prop !== undefined && prop !== null) {
+      if (Array.isArray(prop)) { prop.map(function (f) { return f(); }); }else { prop(); }
+    }
+  });
+}
+
+function disposeOnUnmount(target, propertyKeyOrFunction) {
+  if (Array.isArray(propertyKeyOrFunction)) {
+    return propertyKeyOrFunction.map(function (fn) { return disposeOnUnmount(target, fn); });
+  }
+
+  var c = Object.getPrototypeOf(target).constructor || Object.getPrototypeOf(target.constructor);
+  var c2 = Object.getPrototypeOf(target.constructor);
+
+  if (!(c === Component || c === PureComponent || c2 === Component || c2 === 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;
+  }
+}
+
+function createChainableTypeChecker(validate) {
+  function checkType(isRequired, props, propName, componentName, location, propFullName) {
+    var rest = [], len = arguments.length - 6;
+    while ( len-- > 0 ) rest[ len ] = arguments[ len + 6 ];
+
+    return 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 {
+        return validate.apply(void 0, [ props, propName, componentName, location, propFullName ].concat( rest ));
+      }
+    });
+  }
+
+  var chainedCheckType = checkType.bind(null, false);
+  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 untracked(function () {
+      if (allowNativeType) {
+        if (getPropType(props[propName]) === mobxType.toLowerCase()) { return null; }
+      }
+
+      var mobxChecker;
+
+      switch (mobxType) {
+        case "Array":
+          mobxChecker = isObservableArray;
+          break;
+
+        case "Object":
+          mobxChecker = isObservableObject;
+          break;
+
+        case "Map":
+          mobxChecker = 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) {
+    var rest = [], len = arguments.length - 5;
+    while ( len-- > 0 ) rest[ len ] = arguments[ len + 5 ];
+
+    return untracked(function () {
+      if (typeof typeChecker !== "function") {
+        return new Error("Property `" + propFullName + "` of component `" + componentName + "` has " + "invalid PropType notation.");
+      }
+
+      var error = createObservableTypeCheckerCreator(allowNativeType, "Array")(props, propName, componentName);
+      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 = createObservableTypeCheckerCreator(false, "Array");
+var observableArrayOf = createObservableArrayOfTypeChecker.bind(null, false);
+var observableMap = createObservableTypeCheckerCreator(false, "Map");
+var observableObject = createObservableTypeCheckerCreator(false, "Object");
+var arrayOrObservableArray = createObservableTypeCheckerCreator(true, "Array");
+var arrayOrObservableArrayOf = createObservableArrayOfTypeChecker.bind(null, true);
+var objectOrObservableObject = createObservableTypeCheckerCreator(true, "Object");
+var PropTypes = {
+  observableArray: observableArray,
+  observableArrayOf: observableArrayOf,
+  observableMap: observableMap,
+  observableObject: observableObject,
+  arrayOrObservableArray: arrayOrObservableArray,
+  arrayOrObservableArrayOf: arrayOrObservableArrayOf,
+  objectOrObservableObject: objectOrObservableObject
+};
+
+if (!Component) { throw new Error("mobx-react requires React to be available"); }
+if (!observable) { throw new Error("mobx-react requires mobx to be available"); }
+if (typeof unstable_batchedUpdates === "function") { configure({
+  reactionScheduler: unstable_batchedUpdates
+}); }
+
+export { observer$1 as observer, Provider, MobXProviderContext, inject, disposeOnUnmount, PropTypes };
 //# sourceMappingURL=mobx-react.module.js.map