@shakacode/recompose
Version:
A React utility belt for function components and higher-order components
1,398 lines (1,269 loc) • 49.4 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Recompose = {}, global.React));
})(this, (function (exports, React) { 'use strict';
var setStatic = function setStatic(key, value) {
return function (BaseComponent) {
/* eslint-disable no-param-reassign */
BaseComponent[key] = value;
/* eslint-enable no-param-reassign */
return BaseComponent;
};
};
var setDisplayName = function setDisplayName(displayName) {
return setStatic('displayName', displayName);
};
var getDisplayName = function getDisplayName(Component) {
if (typeof Component === 'string') {
return Component;
}
if (!Component) {
return undefined;
}
return Component.displayName || Component.name || 'Component';
};
var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
return hocName + "(" + getDisplayName(BaseComponent) + ")";
};
var mapProps = function mapProps(propsMapper) {
return function (BaseComponent) {
var MapProps = function MapProps(props) {
return /*#__PURE__*/React.createElement(BaseComponent, propsMapper(props));
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'mapProps'))(MapProps);
}
};
};
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);
}
var withProps = function withProps(input) {
var hoc = mapProps(function (props) {
return _extends({}, props, typeof input === 'function' ? input(props) : input);
});
{
return function (BaseComponent) {
return setDisplayName(wrapDisplayName(BaseComponent, 'withProps'))(hoc(BaseComponent));
};
}
};
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _inheritsLoose(t, o) {
t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
}
var pick = function pick(obj, keys) {
var result = {};
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (obj.hasOwnProperty(key)) {
result[key] = obj[key];
}
}
return result;
};
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @providesModule shallowEqual
* @typechecks
*/
/* eslint-disable no-self-compare */
var hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/
function is(x, y) {
// SameValue algorithm
if (x === y) {
// Steps 1-5, 7-10
// Steps 6.b-6.e: +0 != -0
// Added the nonzero y check to make Flow happy, but it is redundant
return x !== 0 || y !== 0 || 1 / x === 1 / y;
}
// Step 6.a: NaN == NaN
return x !== x && y !== y;
}
/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/
function shallowEqual(objA, objB) {
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;
}
// Test for A's keys different from B.
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;
}
var withPropsOnChange = function withPropsOnChange(shouldMapOrKeys, propsMapper) {
return function (BaseComponent) {
var shouldMap = typeof shouldMapOrKeys === 'function' ? shouldMapOrKeys : function (props, nextProps) {
return !shallowEqual(pick(props, shouldMapOrKeys), pick(nextProps, shouldMapOrKeys));
};
var WithPropsOnChange = /*#__PURE__*/function (_Component) {
function WithPropsOnChange() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(args)) || this;
_this.state = {
computedProps: propsMapper(_this.props),
prevProps: _this.props
};
return _this;
}
_inheritsLoose(WithPropsOnChange, _Component);
WithPropsOnChange.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
if (shouldMap(prevState.prevProps, nextProps)) {
return {
computedProps: propsMapper(nextProps),
prevProps: nextProps
};
}
return {
prevProps: nextProps
};
};
var _proto = WithPropsOnChange.prototype;
_proto.render = function render() {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, this.state.computedProps));
};
return WithPropsOnChange;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withPropsOnChange'))(WithPropsOnChange);
}
};
};
var mapValues = function mapValues(obj, func) {
var result = {};
/* eslint-disable no-restricted-syntax */
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
result[key] = func(obj[key], key);
}
}
/* eslint-enable no-restricted-syntax */
return result;
};
var withHandlers = function withHandlers(handlers) {
return function (BaseComponent) {
var WithHandlers = /*#__PURE__*/function (_Component) {
function WithHandlers() {
var _this;
for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
_args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(_args)) || this;
_this.handlers = mapValues(typeof handlers === 'function' ? handlers(_this.props) : handlers, function (createHandler) {
return function () {
var handler = createHandler(_this.props);
if (typeof handler !== 'function') {
console.error(
// eslint-disable-line no-console
'withHandlers(): Expected a map of higher-order functions. ' + 'Refer to the docs for more info.');
}
return handler.apply(void 0, arguments);
};
});
return _this;
}
_inheritsLoose(WithHandlers, _Component);
var _proto = WithHandlers.prototype;
_proto.render = function render() {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, this.handlers));
};
return WithHandlers;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withHandlers'))(WithHandlers);
}
};
};
var defaultProps = function defaultProps(defaults) {
return function (BaseComponent) {
var DefaultProps = function DefaultProps(ownerProps) {
var props = _extends({}, defaults);
Object.keys(ownerProps).forEach(function (key) {
if (ownerProps[key] !== undefined || !(key in defaults)) {
props[key] = ownerProps[key];
}
});
return /*#__PURE__*/React.createElement(BaseComponent, props);
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'defaultProps'))(DefaultProps);
}
};
};
function _objectDestructuringEmpty(t) {
if (null == t) throw new TypeError("Cannot destructure " + t);
}
var omit = function omit(obj, keys) {
var rest = _extends({}, (_objectDestructuringEmpty(obj), obj));
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (rest.hasOwnProperty(key)) {
delete rest[key];
}
}
return rest;
};
var renameProp = function renameProp(oldName, newName) {
var hoc = mapProps(function (props) {
var _extends2;
return _extends({}, omit(props, [oldName]), (_extends2 = {}, _extends2[newName] = props[oldName], _extends2));
});
{
return function (BaseComponent) {
return setDisplayName(wrapDisplayName(BaseComponent, 'renameProp'))(hoc(BaseComponent));
};
}
};
var keys = Object.keys;
var mapKeys = function mapKeys(obj, func) {
return keys(obj).reduce(function (result, key) {
var val = obj[key];
/* eslint-disable no-param-reassign */
result[func(val, key)] = val;
/* eslint-enable no-param-reassign */
return result;
}, {});
};
var renameProps = function renameProps(nameMap) {
var hoc = mapProps(function (props) {
return _extends({}, omit(props, keys(nameMap)), mapKeys(pick(props, keys(nameMap)), function (_, oldName) {
return nameMap[oldName];
}));
});
{
return function (BaseComponent) {
return setDisplayName(wrapDisplayName(BaseComponent, 'renameProps'))(hoc(BaseComponent));
};
}
};
var flattenProp = function flattenProp(propName) {
return function (BaseComponent) {
var FlattenProp = function FlattenProp(props) {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, props, props[propName]));
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'flattenProp'))(FlattenProp);
}
};
};
var withState = function withState(stateName, stateUpdaterName, initialState) {
return function (BaseComponent) {
var WithState = /*#__PURE__*/function (_Component) {
function WithState() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(args)) || this;
_this.state = {
stateValue: typeof initialState === 'function' ? initialState(_this.props) : initialState
};
_this.updateStateValue = function (updateFn, callback) {
return _this.setState(function (_ref) {
var stateValue = _ref.stateValue;
return {
stateValue: typeof updateFn === 'function' ? updateFn(stateValue) : updateFn
};
}, callback);
};
return _this;
}
_inheritsLoose(WithState, _Component);
var _proto = WithState.prototype;
_proto.render = function render() {
var _extends2;
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, (_extends2 = {}, _extends2[stateName] = this.state.stateValue, _extends2[stateUpdaterName] = this.updateStateValue, _extends2)));
};
return WithState;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withState'))(WithState);
}
};
};
var withStateHandlers = function withStateHandlers(initialState, stateUpdaters) {
return function (BaseComponent) {
var WithStateHandlers = /*#__PURE__*/function (_Component) {
function WithStateHandlers() {
var _this;
for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
_args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(_args)) || this;
_this.state = typeof initialState === 'function' ? initialState(_this.props) : initialState;
_this.stateUpdaters = mapValues(stateUpdaters, function (handler) {
return function (mayBeEvent) {
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
_this.setState(function (state, props) {
return handler(state, props).apply(void 0, [mayBeEvent].concat(args));
});
};
});
return _this;
}
_inheritsLoose(WithStateHandlers, _Component);
var _proto = WithStateHandlers.prototype;
_proto.render = function render() {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, this.state, this.stateUpdaters));
};
return WithStateHandlers;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withStateHandlers'))(WithStateHandlers);
}
};
};
var noop = function noop() {};
var withReducer = function withReducer(stateName, dispatchName, reducer, initialState) {
return function (BaseComponent) {
var WithReducer = /*#__PURE__*/function (_Component) {
function WithReducer() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(args)) || this;
_this.state = {
stateValue: _this.initializeStateValue()
};
_this.dispatch = function (action, callback) {
if (callback === void 0) {
callback = noop;
}
return _this.setState(function (_ref) {
var stateValue = _ref.stateValue;
return {
stateValue: reducer(stateValue, action)
};
}, function () {
return callback(_this.state.stateValue);
});
};
return _this;
}
_inheritsLoose(WithReducer, _Component);
var _proto = WithReducer.prototype;
_proto.initializeStateValue = function initializeStateValue() {
if (initialState !== undefined) {
return typeof initialState === 'function' ? initialState(this.props) : initialState;
}
return reducer(undefined, {
type: '@@recompose/INIT'
});
};
_proto.render = function render() {
var _extends2;
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, (_extends2 = {}, _extends2[stateName] = this.state.stateValue, _extends2[dispatchName] = this.dispatch, _extends2)));
};
return WithReducer;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withReducer'))(WithReducer);
}
};
};
var identity$1 = function identity(Component) {
return Component;
};
var branch = function branch(test, left, right) {
if (right === void 0) {
right = identity$1;
}
return function (BaseComponent) {
var leftComponent;
var rightComponent;
var Branch = function Branch(props) {
if (test(props)) {
leftComponent = leftComponent || left(BaseComponent);
return /*#__PURE__*/React.createElement(leftComponent, props);
}
rightComponent = rightComponent || right(BaseComponent);
return /*#__PURE__*/React.createElement(rightComponent, props);
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'branch'))(Branch);
}
};
};
var renderComponent = function renderComponent(Component) {
return function (_) {
var RenderComponent = function RenderComponent(props) {
return /*#__PURE__*/React.createElement(Component, props);
};
{
RenderComponent.displayName = wrapDisplayName(Component, 'renderComponent');
}
return RenderComponent;
};
};
var Nothing = /*#__PURE__*/function (_Component) {
function Nothing() {
return _Component.apply(this, arguments) || this;
}
_inheritsLoose(Nothing, _Component);
var _proto = Nothing.prototype;
_proto.render = function render() {
return null;
};
return Nothing;
}(React.Component);
var renderNothing = function renderNothing(_) {
return Nothing;
};
var shouldUpdate = function shouldUpdate(test) {
return function (BaseComponent) {
var ShouldUpdate = /*#__PURE__*/function (_Component) {
function ShouldUpdate() {
return _Component.apply(this, arguments) || this;
}
_inheritsLoose(ShouldUpdate, _Component);
var _proto = ShouldUpdate.prototype;
_proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
return test(this.props, nextProps);
};
_proto.render = function render() {
return /*#__PURE__*/React.createElement(BaseComponent, this.props);
};
return ShouldUpdate;
}(React.Component);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'shouldUpdate'))(ShouldUpdate);
}
};
};
var pure = function pure(BaseComponent) {
var hoc = shouldUpdate(function (props, nextProps) {
return !shallowEqual(props, nextProps);
});
{
return setDisplayName(wrapDisplayName(BaseComponent, 'pure'))(hoc(BaseComponent));
}
};
var onlyUpdateForKeys = function onlyUpdateForKeys(propKeys) {
var hoc = shouldUpdate(function (props, nextProps) {
return !shallowEqual(pick(nextProps, propKeys), pick(props, propKeys));
});
{
return function (BaseComponent) {
return setDisplayName(wrapDisplayName(BaseComponent, 'onlyUpdateForKeys'))(hoc(BaseComponent));
};
}
};
var onlyUpdateForPropTypes = function onlyUpdateForPropTypes(BaseComponent) {
var propTypes = BaseComponent.propTypes;
{
if (!propTypes) {
/* eslint-disable */
console.error('A component without any `propTypes` was passed to ' + '`onlyUpdateForPropTypes()`. Check the implementation of the ' + ("component with display name \"" + getDisplayName(BaseComponent) + "\"."));
/* eslint-enable */
}
}
var propKeys = Object.keys(propTypes || {});
var OnlyUpdateForPropTypes = onlyUpdateForKeys(propKeys)(BaseComponent);
{
return setDisplayName(wrapDisplayName(BaseComponent, 'onlyUpdateForPropTypes'))(OnlyUpdateForPropTypes);
}
};
var store = new Map();
var getOrCreateContext = function getOrCreateContext(key) {
var existing = store.get(key);
if (existing) return existing;
var ctx = /*#__PURE__*/React.createContext(undefined);
{
ctx.displayName = key;
}
store.set(key, ctx);
return ctx;
};
var withContext = function withContext(childContextTypes, getChildContext) {
return function (BaseComponent) {
var contextKeys = Object.keys(childContextTypes);
var WithContext = function WithContext(props) {
var contextValues = getChildContext(props);
var element = /*#__PURE__*/React.createElement(BaseComponent, props);
contextKeys.forEach(function (key) {
var Ctx = getOrCreateContext(key);
element = /*#__PURE__*/React.createElement(Ctx.Provider, {
value: contextValues[key]
}, element);
});
return element;
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'withContext'))(WithContext);
}
};
};
// Note: only the keys of contextTypes are used to select which context values
// to inject. The validator values (PropTypes) are not used for validation since
// PropTypes is deprecated and legacy context was removed in React 19.
var getContext = function getContext(contextTypes) {
return function (BaseComponent) {
var contextKeys = Object.keys(contextTypes);
// Build a chain of Consumer wrappers
var Wrapped = BaseComponent;
contextKeys.forEach(function (key) {
var Ctx = getOrCreateContext(key);
var Prev = Wrapped;
Wrapped = function Wrapped(props) {
return /*#__PURE__*/React.createElement(Ctx.Consumer, null, function (value) {
var _extends2;
return /*#__PURE__*/React.createElement(Prev, _extends({}, props, (_extends2 = {}, _extends2[key] = value, _extends2)));
});
};
});
{
return setDisplayName(wrapDisplayName(BaseComponent, 'getContext'))(Wrapped);
}
};
};
var lifecycle = function lifecycle(spec) {
return function (BaseComponent) {
if (spec.hasOwnProperty('render')) {
console.error('lifecycle() does not support the render method; its behavior is to ' + 'pass all props and state to the base component.');
}
var Lifecycle = /*#__PURE__*/function (_Component) {
function Lifecycle() {
return _Component.apply(this, arguments) || this;
}
_inheritsLoose(Lifecycle, _Component);
var _proto = Lifecycle.prototype;
_proto.render = function render() {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, this.props, this.state));
};
return Lifecycle;
}(React.Component);
Object.keys(spec).forEach(function (hook) {
return Lifecycle.prototype[hook] = spec[hook];
});
{
return setDisplayName(wrapDisplayName(BaseComponent, 'lifecycle'))(Lifecycle);
}
};
};
var isClassComponent = function isClassComponent(Component) {
return Boolean(Component && Component.prototype && typeof Component.prototype.render === 'function');
};
var toClass = function toClass(baseComponent) {
var _ToClass;
return isClassComponent(baseComponent) ? baseComponent : (_ToClass = /*#__PURE__*/function (_Component) {
function ToClass() {
return _Component.apply(this, arguments) || this;
}
_inheritsLoose(ToClass, _Component);
var _proto = ToClass.prototype;
_proto.render = function render() {
if (typeof baseComponent === 'string') {
return /*#__PURE__*/React.createElement(baseComponent, this.props);
}
return baseComponent(this.props);
};
return ToClass;
}(React.Component), _ToClass.displayName = getDisplayName(baseComponent), _ToClass.propTypes = baseComponent.propTypes, _ToClass.defaultProps = baseComponent.defaultProps, _ToClass);
};
function toRenderProps(hoc) {
var RenderPropsComponent = function RenderPropsComponent(props) {
return props.children(props);
};
return hoc(RenderPropsComponent);
}
var fromRenderProps = function fromRenderProps(RenderPropsComponent, propsMapper, renderPropName) {
if (renderPropName === void 0) {
renderPropName = 'children';
}
return function (BaseComponent) {
var FromRenderProps = function FromRenderProps(ownerProps) {
var _React$createElement;
return /*#__PURE__*/React.createElement(RenderPropsComponent, (_React$createElement = {}, _React$createElement[renderPropName] = function () {
return /*#__PURE__*/React.createElement(BaseComponent, _extends({}, ownerProps, propsMapper.apply(void 0, arguments)));
}, _React$createElement));
};
{
return setDisplayName(wrapDisplayName(BaseComponent, 'fromRenderProps'))(FromRenderProps);
}
};
};
var setPropTypes = function setPropTypes(propTypes) {
return setStatic('propTypes', propTypes);
};
var compose = function compose() {
for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
funcs[_key] = arguments[_key];
}
return funcs.reduce(function (a, b) {
return function () {
return a(b.apply(void 0, arguments));
};
}, function (arg) {
return arg;
});
};
var createSink = function createSink(callback) {
var Sink = /*#__PURE__*/function (_Component) {
function Sink() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(args)) || this;
_this.state = {};
return _this;
}
_inheritsLoose(Sink, _Component);
Sink.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps) {
callback(nextProps);
return null;
};
var _proto = Sink.prototype;
_proto.render = function render() {
return null;
};
return Sink;
}(React.Component);
return Sink;
};
var componentFromProp = function componentFromProp(propName) {
var Component = function Component(props) {
return /*#__PURE__*/React.createElement(props[propName], omit(props, [propName]));
};
Component.displayName = "componentFromProp(" + propName + ")";
return Component;
};
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) return {};
var t = {};
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
if (-1 !== e.indexOf(n)) continue;
t[n] = r[n];
}
return t;
}
var _excluded = ["children"];
var nest = function nest() {
for (var _len = arguments.length, Components = new Array(_len), _key = 0; _key < _len; _key++) {
Components[_key] = arguments[_key];
}
var Nest = function Nest(_ref) {
var children = _ref.children,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
return Components.reduceRight(function (child, C) {
return /*#__PURE__*/React.createElement(C, props, child);
}, children);
};
{
var displayNames = Components.map(getDisplayName);
Nest.displayName = "nest(" + displayNames.join(', ') + ")";
}
return Nest;
};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var reactIs = {exports: {}};
var reactIs_development = {};
/** @license React v16.13.1
* react-is.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var hasRequiredReactIs_development;
function requireReactIs_development () {
if (hasRequiredReactIs_development) return reactIs_development;
hasRequiredReactIs_development = 1;
{
(function() {
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?
var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
function isValidElementType(type) {
return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}
function typeOf(object) {
if (typeof object === 'object' && object !== null) {
var $$typeof = object.$$typeof;
switch ($$typeof) {
case REACT_ELEMENT_TYPE:
var type = object.type;
switch (type) {
case REACT_ASYNC_MODE_TYPE:
case REACT_CONCURRENT_MODE_TYPE:
case REACT_FRAGMENT_TYPE:
case REACT_PROFILER_TYPE:
case REACT_STRICT_MODE_TYPE:
case REACT_SUSPENSE_TYPE:
return type;
default:
var $$typeofType = type && type.$$typeof;
switch ($$typeofType) {
case REACT_CONTEXT_TYPE:
case REACT_FORWARD_REF_TYPE:
case REACT_LAZY_TYPE:
case REACT_MEMO_TYPE:
case REACT_PROVIDER_TYPE:
return $$typeofType;
default:
return $$typeof;
}
}
case REACT_PORTAL_TYPE:
return $$typeof;
}
}
return undefined;
} // AsyncMode is deprecated along with isAsyncMode
var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
function isAsyncMode(object) {
{
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
}
}
return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
return typeOf(object) === REACT_SUSPENSE_TYPE;
}
reactIs_development.AsyncMode = AsyncMode;
reactIs_development.ConcurrentMode = ConcurrentMode;
reactIs_development.ContextConsumer = ContextConsumer;
reactIs_development.ContextProvider = ContextProvider;
reactIs_development.Element = Element;
reactIs_development.ForwardRef = ForwardRef;
reactIs_development.Fragment = Fragment;
reactIs_development.Lazy = Lazy;
reactIs_development.Memo = Memo;
reactIs_development.Portal = Portal;
reactIs_development.Profiler = Profiler;
reactIs_development.StrictMode = StrictMode;
reactIs_development.Suspense = Suspense;
reactIs_development.isAsyncMode = isAsyncMode;
reactIs_development.isConcurrentMode = isConcurrentMode;
reactIs_development.isContextConsumer = isContextConsumer;
reactIs_development.isContextProvider = isContextProvider;
reactIs_development.isElement = isElement;
reactIs_development.isForwardRef = isForwardRef;
reactIs_development.isFragment = isFragment;
reactIs_development.isLazy = isLazy;
reactIs_development.isMemo = isMemo;
reactIs_development.isPortal = isPortal;
reactIs_development.isProfiler = isProfiler;
reactIs_development.isStrictMode = isStrictMode;
reactIs_development.isSuspense = isSuspense;
reactIs_development.isValidElementType = isValidElementType;
reactIs_development.typeOf = typeOf;
})();
}
return reactIs_development;
}
var hasRequiredReactIs;
function requireReactIs () {
if (hasRequiredReactIs) return reactIs.exports;
hasRequiredReactIs = 1;
{
reactIs.exports = requireReactIs_development();
}
return reactIs.exports;
}
var hoistNonReactStatics_cjs;
var hasRequiredHoistNonReactStatics_cjs;
function requireHoistNonReactStatics_cjs () {
if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
hasRequiredHoistNonReactStatics_cjs = 1;
var reactIs = requireReactIs();
/**
* Copyright 2015, Yahoo! Inc.
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var REACT_STATICS = {
childContextTypes: true,
contextType: true,
contextTypes: true,
defaultProps: true,
displayName: true,
getDefaultProps: true,
getDerivedStateFromError: true,
getDerivedStateFromProps: true,
mixins: true,
propTypes: true,
type: true
};
var KNOWN_STATICS = {
name: true,
length: true,
prototype: true,
caller: true,
callee: true,
arguments: true,
arity: true
};
var FORWARD_REF_STATICS = {
'$$typeof': true,
render: true,
defaultProps: true,
displayName: true,
propTypes: true
};
var MEMO_STATICS = {
'$$typeof': true,
compare: true,
defaultProps: true,
displayName: true,
propTypes: true,
type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
// React v16.11 and below
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
} // React v16.12 and above
return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}
var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
if (typeof sourceComponent !== 'string') {
// don't hoist over string (html) components
if (objectPrototype) {
var inheritedComponent = getPrototypeOf(sourceComponent);
if (inheritedComponent && inheritedComponent !== objectPrototype) {
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
}
}
var keys = getOwnPropertyNames(sourceComponent);
if (getOwnPropertySymbols) {
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
}
var targetStatics = getStatics(targetComponent);
var sourceStatics = getStatics(sourceComponent);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
// Avoid failures from read-only properties
defineProperty(targetComponent, key, descriptor);
} catch (e) {}
}
}
}
return targetComponent;
}
hoistNonReactStatics_cjs = hoistNonReactStatics;
return hoistNonReactStatics_cjs;
}
var hoistNonReactStatics_cjsExports = requireHoistNonReactStatics_cjs();
var hoistNonReactStatics = /*@__PURE__*/getDefaultExportFromCjs(hoistNonReactStatics_cjsExports);
var hoistStatics = function hoistStatics(higherOrderComponent, blacklist) {
return function (BaseComponent) {
var NewComponent = higherOrderComponent(BaseComponent);
hoistNonReactStatics(NewComponent, BaseComponent, blacklist);
return NewComponent;
};
};
var lib = {};
var hasRequiredLib;
function requireLib () {
if (hasRequiredLib) return lib;
hasRequiredLib = 1;
Object.defineProperty(lib, "__esModule", {
value: true
});
lib.createChangeEmitter = function createChangeEmitter() {
var currentListeners = [];
var nextListeners = currentListeners;
function ensureCanMutateNextListeners() {
if (nextListeners === currentListeners) {
nextListeners = currentListeners.slice();
}
}
function listen(listener) {
if (typeof listener !== 'function') {
throw new Error('Expected listener to be a function.');
}
var isSubscribed = true;
ensureCanMutateNextListeners();
nextListeners.push(listener);
return function () {
if (!isSubscribed) {
return;
}
isSubscribed = false;
ensureCanMutateNextListeners();
var index = nextListeners.indexOf(listener);
nextListeners.splice(index, 1);
};
}
function emit() {
currentListeners = nextListeners;
var listeners = currentListeners;
for (var i = 0; i < listeners.length; i++) {
listeners[i].apply(listeners, arguments);
}
}
return {
listen: listen,
emit: emit
};
};
return lib;
}
var libExports = requireLib();
function symbolObservablePonyfill(root) {
var result;
var Symbol = root.Symbol;
if (typeof Symbol === 'function') {
if (Symbol.observable) {
result = Symbol.observable;
} else {
if (typeof Symbol.for === 'function') {
// This just needs to be something that won't trample other user's Symbol.for use
// It also will guide people to the source of their issues, if this is problematic.
// META: It's a resource locator!
result = Symbol.for('https://github.com/benlesh/symbol-observable');
} else {
// Symbol.for didn't exist! The best we can do at this point is a totally
// unique symbol. Note that the string argument here is a descriptor, not
// an identifier. This symbol is unique.
result = Symbol('https://github.com/benlesh/symbol-observable');
}
try {
Symbol.observable = result;
} catch (err) {
// Do nothing. In some environments, users have frozen `Symbol` for security reasons,
// if it is frozen assigning to it will throw. In this case, we don't care, because
// they will need to use the returned value from the ponyfill.
}
}
} else {
result = '@@observable';
}
return result;
}
/* global window */
var root;
if (typeof self !== 'undefined') {
root = self;
} else if (typeof window !== 'undefined') {
root = window;
} else if (typeof global !== 'undefined') {
root = global;
} else if (typeof module !== 'undefined') {
root = module;
} else {
root = Function('return this')();
}
var result = symbolObservablePonyfill(root);
var _config = {
fromESObservable: null,
toESObservable: null
};
var configureObservable = function configureObservable(c) {
_config = c;
};
var config = {
fromESObservable: function fromESObservable(observable) {
return typeof _config.fromESObservable === 'function' ? _config.fromESObservable(observable) : observable;
},
toESObservable: function toESObservable(stream) {
return typeof _config.toESObservable === 'function' ? _config.toESObservable(stream) : stream;
}
};
var componentFromStreamWithConfig = function componentFromStreamWithConfig(config) {
return function (propsToVdom) {
return /*#__PURE__*/function (_Component) {
function ComponentFromStream() {
var _config$fromESObserva;
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Component.call.apply(_Component, [this].concat(args)) || this;
_this.state = {
vdom: null
};
_this.propsEmitter = libExports.createChangeEmitter();
// Stream of props
_this.props$ = config.fromESObservable((_config$fromESObserva = {
subscribe: function subscribe(observer) {
var unsubscribe = _this.propsEmitter.listen(function (props) {
if (props) {
observer.next(props);
} else {
observer.complete();
}
});
return {
unsubscribe: unsubscribe
};
}
}, _config$fromESObserva[result] = function () {
return this;
}, _config$fromESObserva));
// Stream of vdom
_this.vdom$ = config.toESObservable(propsToVdom(_this.props$));
return _this;
}
_inheritsLoose(ComponentFromStream, _Component);
var _proto = ComponentFromStream.prototype;
// eslint-disable-next-line camelcase
_proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {
var _this2 = this;
// Subscribe to child prop changes so we know when to re-render
this.subscription = this.vdom$.subscribe({
next: function next(vdom) {
_this2.setState({
vdom: vdom
});
}
});
this.propsEmitter.emit(this.props);
}
// eslint-disable-next-line camelcase
;
_proto.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {
// Receive new props from the owner
this.propsEmitter.emit(nextProps);
};
_proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
return nextState.vdom !== this.state.vdom;
};
_proto.componentWillUnmount = function componentWillUnmount() {
// Call without arguments to complete stream
this.propsEmitter.emit();
// Clean-up subscription before un-mounting
this.subscription.unsubscribe();
};
_proto.render = function render() {
return this.state.vdom;
};
return ComponentFromStream;
}(React.Component);
};
};
var componentFromStream = function componentFromStream(propsToVdom) {
return componentFromStreamWithConfig(config)(propsToVdom);
};
var identity = function identity(t) {
return t;
};
var mapPropsStreamWithConfig = function mapPropsStreamWithConfig(config) {
var componentFromStream = componentFromStreamWithConfig({
fromESObservable: identity,
toESObservable: identity
});
return function (transform) {
return function (BaseComponent) {
var fromESObservable = config.fromESObservable,
toESObservable = config.toESObservable;
return componentFromStream(function (props$) {
var _ref;
return _ref = {
subscribe: function subscribe(observer) {
var subscription = toESObservable(transform(fromESObservable(props$))).subscribe({
next: function next(childProps) {
return observer.next(/*#__PURE__*/React.createElement(BaseComponent, childProps));
}
});
return {
unsubscribe: function unsubscribe() {
return subscription.unsubscribe();
}
};
}
}, _ref[result] = function () {
return this;
}, _ref;
});
};
};
};
var mapPropsStream = function mapPropsStream(transform) {
var hoc = mapPropsStreamWithConfig(config)(transform);
{
return function (BaseComponent) {
return setDisplayName(wrapDisplayName(BaseComponent, 'mapPropsStream'))(hoc(BaseComponent));
};
}
};
var createEventHandlerWithConfig = function createEventHandlerWithConfig(config) {
return function () {
var _config$fromESObserva;
var emitter = libExports.createChangeEmitter();
var stream = config.fromESObservable((_config$fromESObserva = {
subscribe: function subscribe(observer) {
var unsubscribe = emitter.listen(function (value) {
return observer.next(value);
});
return {
unsubscribe: unsubscribe
};
}
}, _config$fromESObserva[result] = function () {
return this;
}, _config$fromESObserva));
return {
handler: emitter.emit,
stream: stream
};
};
};
var createEventHandler = createEventHandlerWithConfig(config);
exports.branch = branch;
exports.componentFromProp = componentFromProp;
exports.componentFromStream = componentFromStream;
exports.componentFromStreamWithConfig = componentFromStreamWithConfig;
exports.compose = compose;
exports.createEventHandler = createEventHandler;
exports.createEventHandlerWithConfig = createEventHandlerWithConfig;
exports.createSink = createSink;
exports.defaultProps = defaultProps;
exports.flattenProp = flattenProp;
exports.fromRenderProps = fromRenderProps;
exports.getContext = getContext;
exports.getDisplayName = getDisplayName;
exports.hoistStatics = hoistStatics;
exports.isClassComponent = isClassComponent;
exports.lifecycle = lifecycle;
exports.mapProps = mapProps;
exports.mapPropsStream = mapPropsStream;
exports.mapPropsStreamWithConfig = mapPropsStreamWithConfig;
exports.nest = nest;
exports.onlyUpdateForKeys = onlyUpdateForKeys;
exports.onlyUpdateForPropTypes = onlyUpdateForPropTypes;
exports.pure = pure;
exports.renameProp = renameProp;
exports.renameProps = renameProps;
exports.renderComponent = renderComponent;
exports.renderNothing = renderNothing;
exports.setDisplayName = setDisplayName;
exports.setObservableConfig = configureObservable;
exports.setPropTypes = setPropTypes;
exports.setStatic = setStatic;
exports.shallowEqual = shallowEqual;
exports.shouldUpdate = shouldUpdate;
exports.toClass = toClass;
exports.toRenderProps = toRenderProps;
exports.withContext = withContext;
exports.withHandlers = withHandlers;
exports.withProps = withProps;
exports.withPropsOnChange = withPropsOnChange;
exports.withReducer = withReducer;
exports.withState = withState;
exports.withStateHandlers = withStateHandlers;
exports.wrapDisplayName = wrapDisplayName;
}));