{"version":3,"sources":["node_modules\\react\\lib\\ReactBaseClasses.js"],"names":["_prodInvariant","require","_assign","ReactNoopUpdateQueue","canDefineProperty","emptyObject","invariant","lowPriorityWarning","ReactComponent","props","context","updater","refs","prototype","isReactComponent","setState","partialState","callback","process","env","NODE_ENV","enqueueSetState","enqueueCallback","forceUpdate","enqueueForceUpdate","deprecatedAPIs","isMounted","replaceState","defineDeprecationWarning","methodName","info","Object","defineProperty","get","undefined","fnName","hasOwnProperty","ReactPureComponent","ComponentDummy","constructor","isPureReactComponent","module","exports","Component","PureComponent"],"mappings":"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","file":"ReactBaseClasses.js","sourceRoot":"D:/Work/Office/react-native-on-web/cli/tmpl/project","sourcesContent":["/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n    _assign = require('object-assign');\n\nvar ReactNoopUpdateQueue = require('./ReactNoopUpdateQueue');\n\nvar canDefineProperty = require('./canDefineProperty');\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar invariant = require('fbjs/lib/invariant');\nvar lowPriorityWarning = require('./lowPriorityWarning');\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactComponent(props, context, updater) {\n  this.props = props;\n  this.context = context;\n  this.refs = emptyObject;\n  // We initialize the default updater but the real one gets injected by the\n  // renderer.\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nReactComponent.prototype.isReactComponent = {};\n\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together.  You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n *        produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\nReactComponent.prototype.setState = function (partialState, callback) {\n  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;\n  this.updater.enqueueSetState(this, partialState);\n  if (callback) {\n    this.updater.enqueueCallback(this, callback, 'setState');\n  }\n};\n\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\nReactComponent.prototype.forceUpdate = function (callback) {\n  this.updater.enqueueForceUpdate(this);\n  if (callback) {\n    this.updater.enqueueCallback(this, callback, 'forceUpdate');\n  }\n};\n\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\nif (process.env.NODE_ENV !== 'production') {\n  var deprecatedAPIs = {\n    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\n    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\n  };\n  var defineDeprecationWarning = function (methodName, info) {\n    if (canDefineProperty) {\n      Object.defineProperty(ReactComponent.prototype, methodName, {\n        get: function () {\n          lowPriorityWarning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\n          return undefined;\n        }\n      });\n    }\n  };\n  for (var fnName in deprecatedAPIs) {\n    if (deprecatedAPIs.hasOwnProperty(fnName)) {\n      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n    }\n  }\n}\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactPureComponent(props, context, updater) {\n  // Duplicated from ReactComponent.\n  this.props = props;\n  this.context = context;\n  this.refs = emptyObject;\n  // We initialize the default updater but the real one gets injected by the\n  // renderer.\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nfunction ComponentDummy() {}\nComponentDummy.prototype = ReactComponent.prototype;\nReactPureComponent.prototype = new ComponentDummy();\nReactPureComponent.prototype.constructor = ReactPureComponent;\n// Avoid an extra prototype jump for these methods.\n_assign(ReactPureComponent.prototype, ReactComponent.prototype);\nReactPureComponent.prototype.isPureReactComponent = true;\n\nmodule.exports = {\n  Component: ReactComponent,\n  PureComponent: ReactPureComponent\n};"]}