1278 lines
37 KiB
JavaScript
1278 lines
37 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
|
|
typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
|
|
(factory((global.Recompose = global.Recompose || {}),global.React));
|
|
}(this, (function (exports,React) { 'use strict';
|
|
|
|
var React__default = 'default' in React ? React['default'] : React;
|
|
|
|
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$$1) {
|
|
if (typeof Component$$1 === 'string') {
|
|
return Component$$1;
|
|
}
|
|
|
|
if (!Component$$1) {
|
|
return undefined;
|
|
}
|
|
|
|
return Component$$1.displayName || Component$$1.name || 'Component';
|
|
};
|
|
|
|
var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
|
|
return hocName + '(' + getDisplayName(BaseComponent) + ')';
|
|
};
|
|
|
|
var mapProps = function mapProps(propsMapper) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var MapProps = function MapProps(props) {
|
|
return factory(propsMapper(props));
|
|
};
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'mapProps'))(MapProps);
|
|
}
|
|
return MapProps;
|
|
};
|
|
};
|
|
|
|
var classCallCheck = function (instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _extends = Object.assign || function (target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
|
|
|
|
var inherits = function (subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var objectWithoutProperties = function (obj, keys) {
|
|
var target = {};
|
|
|
|
for (var i in obj) {
|
|
if (keys.indexOf(i) >= 0) continue;
|
|
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
|
|
target[i] = obj[i];
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
var possibleConstructorReturn = function (self, call) {
|
|
if (!self) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
|
};
|
|
|
|
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));
|
|
};
|
|
}
|
|
return hoc;
|
|
};
|
|
|
|
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.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*
|
|
* @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;
|
|
} else {
|
|
// 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$1(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 shallowEqual_1 = shallowEqual$1;
|
|
|
|
var withPropsOnChange = function withPropsOnChange(shouldMapOrKeys, propsMapper) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var shouldMap = typeof shouldMapOrKeys === 'function' ? shouldMapOrKeys : function (props, nextProps) {
|
|
return !shallowEqual_1(pick(props, shouldMapOrKeys), pick(nextProps, shouldMapOrKeys));
|
|
};
|
|
|
|
var WithPropsOnChange = function (_Component) {
|
|
inherits(WithPropsOnChange, _Component);
|
|
|
|
function WithPropsOnChange() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithPropsOnChange);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.computedProps = propsMapper(_this.props), _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithPropsOnChange.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
|
|
if (shouldMap(this.props, nextProps)) {
|
|
this.computedProps = propsMapper(nextProps);
|
|
}
|
|
};
|
|
|
|
WithPropsOnChange.prototype.render = function render() {
|
|
return factory(_extends({}, this.props, this.computedProps));
|
|
};
|
|
|
|
return WithPropsOnChange;
|
|
}(React.Component);
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withPropsOnChange'))(WithPropsOnChange);
|
|
}
|
|
return 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;
|
|
};
|
|
|
|
/* eslint-disable no-console */
|
|
var withHandlers = function withHandlers(handlers) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var WithHandlers = function (_Component) {
|
|
inherits(WithHandlers, _Component);
|
|
|
|
function WithHandlers() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithHandlers);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithHandlers.prototype.componentWillReceiveProps = function componentWillReceiveProps() {
|
|
this.cachedHandlers = {};
|
|
};
|
|
|
|
WithHandlers.prototype.render = function render() {
|
|
return factory(_extends({}, this.props, this.handlers));
|
|
};
|
|
|
|
return WithHandlers;
|
|
}(React.Component);
|
|
|
|
var _initialiseProps = function _initialiseProps() {
|
|
var _this2 = this;
|
|
|
|
this.cachedHandlers = {};
|
|
this.handlers = mapValues(typeof handlers === 'function' ? handlers(this.props) : handlers, function (createHandler, handlerName) {
|
|
return function () {
|
|
var cachedHandler = _this2.cachedHandlers[handlerName];
|
|
if (cachedHandler) {
|
|
return cachedHandler.apply(undefined, arguments);
|
|
}
|
|
|
|
var handler = createHandler(_this2.props);
|
|
_this2.cachedHandlers[handlerName] = handler;
|
|
|
|
if ("development" !== 'production' && 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(undefined, arguments);
|
|
};
|
|
});
|
|
};
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withHandlers'))(WithHandlers);
|
|
}
|
|
return WithHandlers;
|
|
};
|
|
};
|
|
|
|
var defaultProps = function defaultProps(props) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var DefaultProps = function DefaultProps(ownerProps) {
|
|
return factory(ownerProps);
|
|
};
|
|
DefaultProps.defaultProps = props;
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'defaultProps'))(DefaultProps);
|
|
}
|
|
return DefaultProps;
|
|
};
|
|
};
|
|
|
|
var omit = function omit(obj, keys) {
|
|
var rest = objectWithoutProperties(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 _babelHelpers$extends;
|
|
|
|
return _extends({}, omit(props, [oldName]), (_babelHelpers$extends = {}, _babelHelpers$extends[newName] = props[oldName], _babelHelpers$extends));
|
|
});
|
|
{
|
|
return function (BaseComponent) {
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'renameProp'))(hoc(BaseComponent));
|
|
};
|
|
}
|
|
return hoc;
|
|
};
|
|
|
|
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));
|
|
};
|
|
}
|
|
return hoc;
|
|
};
|
|
|
|
var flattenProp = function flattenProp(propName) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var FlattenProp = function FlattenProp(props) {
|
|
return factory(_extends({}, props, props[propName]));
|
|
};
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'flattenProp'))(FlattenProp);
|
|
}
|
|
return FlattenProp;
|
|
};
|
|
};
|
|
|
|
var withState = function withState(stateName, stateUpdaterName, initialState) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var WithState = function (_Component) {
|
|
inherits(WithState, _Component);
|
|
|
|
function WithState() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithState);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(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);
|
|
}, _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithState.prototype.render = function render() {
|
|
var _babelHelpers$extends;
|
|
|
|
return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[stateUpdaterName] = this.updateStateValue, _babelHelpers$extends)));
|
|
};
|
|
|
|
return WithState;
|
|
}(React.Component);
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withState'))(WithState);
|
|
}
|
|
return WithState;
|
|
};
|
|
};
|
|
|
|
var withStateHandlers = function withStateHandlers(initialState, stateUpdaters) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var WithStateHandlers = function (_Component) {
|
|
inherits(WithStateHandlers, _Component);
|
|
|
|
function WithStateHandlers() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithStateHandlers);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithStateHandlers.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
|
|
var propsChanged = nextProps !== this.props;
|
|
// the idea is to skip render if stateUpdater handler return undefined
|
|
// this allows to create no state update handlers with access to state and props
|
|
var stateChanged = !shallowEqual_1(nextState, this.state);
|
|
return propsChanged || stateChanged;
|
|
};
|
|
|
|
WithStateHandlers.prototype.render = function render() {
|
|
return factory(_extends({}, this.props, this.state, this.stateUpdaters));
|
|
};
|
|
|
|
return WithStateHandlers;
|
|
}(React.Component);
|
|
|
|
var _initialiseProps = function _initialiseProps() {
|
|
var _this2 = 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 = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
|
|
// Having that functional form of setState can be called async
|
|
// we need to persist SyntheticEvent
|
|
if (mayBeEvent && typeof mayBeEvent.persist === 'function') {
|
|
mayBeEvent.persist();
|
|
}
|
|
|
|
_this2.setState(function (state, props) {
|
|
return handler(state, props).apply(undefined, [mayBeEvent].concat(args));
|
|
});
|
|
};
|
|
});
|
|
};
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withStateHandlers'))(WithStateHandlers);
|
|
}
|
|
return WithStateHandlers;
|
|
};
|
|
};
|
|
|
|
var withReducer = function withReducer(stateName, dispatchName, reducer, initialState) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var WithReducer = function (_Component) {
|
|
inherits(WithReducer, _Component);
|
|
|
|
function WithReducer() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithReducer);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {
|
|
stateValue: _this.initializeStateValue()
|
|
}, _this.dispatch = function (action) {
|
|
return _this.setState(function (_ref) {
|
|
var stateValue = _ref.stateValue;
|
|
return {
|
|
stateValue: reducer(stateValue, action)
|
|
};
|
|
});
|
|
}, _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithReducer.prototype.initializeStateValue = function initializeStateValue() {
|
|
if (initialState !== undefined) {
|
|
return typeof initialState === 'function' ? initialState(this.props) : initialState;
|
|
}
|
|
return reducer(undefined, { type: '@@recompose/INIT' });
|
|
};
|
|
|
|
WithReducer.prototype.render = function render() {
|
|
var _babelHelpers$extends;
|
|
|
|
return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[dispatchName] = this.dispatch, _babelHelpers$extends)));
|
|
};
|
|
|
|
return WithReducer;
|
|
}(React.Component);
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withReducer'))(WithReducer);
|
|
}
|
|
return WithReducer;
|
|
};
|
|
};
|
|
|
|
var identity = function identity(Component$$1) {
|
|
return Component$$1;
|
|
};
|
|
|
|
var branch = function branch(test, left) {
|
|
var right = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;
|
|
return function (BaseComponent) {
|
|
var leftFactory = void 0;
|
|
var rightFactory = void 0;
|
|
var Branch = function Branch(props) {
|
|
if (test(props)) {
|
|
leftFactory = leftFactory || React.createFactory(left(BaseComponent));
|
|
return leftFactory(props);
|
|
}
|
|
rightFactory = rightFactory || React.createFactory(right(BaseComponent));
|
|
return rightFactory(props);
|
|
};
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'branch'))(Branch);
|
|
}
|
|
return Branch;
|
|
};
|
|
};
|
|
|
|
var renderComponent = function renderComponent(Component$$1) {
|
|
return function (_) {
|
|
var factory = React.createFactory(Component$$1);
|
|
var RenderComponent = function RenderComponent(props) {
|
|
return factory(props);
|
|
};
|
|
{
|
|
RenderComponent.displayName = wrapDisplayName(Component$$1, 'renderComponent');
|
|
}
|
|
return RenderComponent;
|
|
};
|
|
};
|
|
|
|
var Nothing = function (_Component) {
|
|
inherits(Nothing, _Component);
|
|
|
|
function Nothing() {
|
|
classCallCheck(this, Nothing);
|
|
return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
|
}
|
|
|
|
Nothing.prototype.render = function render() {
|
|
return null;
|
|
};
|
|
|
|
return Nothing;
|
|
}(React.Component);
|
|
|
|
var renderNothing = function renderNothing(_) {
|
|
return Nothing;
|
|
};
|
|
|
|
var shouldUpdate = function shouldUpdate(test) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var ShouldUpdate = function (_Component) {
|
|
inherits(ShouldUpdate, _Component);
|
|
|
|
function ShouldUpdate() {
|
|
classCallCheck(this, ShouldUpdate);
|
|
return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
|
}
|
|
|
|
ShouldUpdate.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
|
|
return test(this.props, nextProps);
|
|
};
|
|
|
|
ShouldUpdate.prototype.render = function render() {
|
|
return factory(this.props);
|
|
};
|
|
|
|
return ShouldUpdate;
|
|
}(React.Component);
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'shouldUpdate'))(ShouldUpdate);
|
|
}
|
|
return ShouldUpdate;
|
|
};
|
|
};
|
|
|
|
var pure = function pure(BaseComponent) {
|
|
var hoc = shouldUpdate(function (props, nextProps) {
|
|
return !shallowEqual_1(props, nextProps);
|
|
});
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'pure'))(hoc(BaseComponent));
|
|
}
|
|
|
|
return hoc(BaseComponent);
|
|
};
|
|
|
|
var onlyUpdateForKeys = function onlyUpdateForKeys(propKeys) {
|
|
var hoc = shouldUpdate(function (props, nextProps) {
|
|
return !shallowEqual_1(pick(nextProps, propKeys), pick(props, propKeys));
|
|
});
|
|
|
|
{
|
|
return function (BaseComponent) {
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'onlyUpdateForKeys'))(hoc(BaseComponent));
|
|
};
|
|
}
|
|
return hoc;
|
|
};
|
|
|
|
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);
|
|
}
|
|
return OnlyUpdateForPropTypes;
|
|
};
|
|
|
|
var withContext = function withContext(childContextTypes, getChildContext) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
var WithContext = function (_Component) {
|
|
inherits(WithContext, _Component);
|
|
|
|
function WithContext() {
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, WithContext);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.getChildContext = function () {
|
|
return getChildContext(_this.props);
|
|
}, _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
WithContext.prototype.render = function render() {
|
|
return factory(this.props);
|
|
};
|
|
|
|
return WithContext;
|
|
}(React.Component);
|
|
|
|
WithContext.childContextTypes = childContextTypes;
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'withContext'))(WithContext);
|
|
}
|
|
return WithContext;
|
|
};
|
|
};
|
|
|
|
var getContext = function getContext(contextTypes) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var GetContext = function GetContext(ownerProps, context) {
|
|
return factory(_extends({}, ownerProps, context));
|
|
};
|
|
|
|
GetContext.contextTypes = contextTypes;
|
|
|
|
{
|
|
return setDisplayName(wrapDisplayName(BaseComponent, 'getContext'))(GetContext);
|
|
}
|
|
return GetContext;
|
|
};
|
|
};
|
|
|
|
/* eslint-disable no-console */
|
|
var lifecycle = function lifecycle(spec) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
|
|
if ("development" !== 'production' && 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 = function (_Component) {
|
|
inherits(Lifecycle, _Component);
|
|
|
|
function Lifecycle() {
|
|
classCallCheck(this, Lifecycle);
|
|
return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
|
}
|
|
|
|
Lifecycle.prototype.render = function render() {
|
|
return factory(_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);
|
|
}
|
|
return Lifecycle;
|
|
};
|
|
};
|
|
|
|
var isClassComponent = function isClassComponent(Component$$1) {
|
|
return Boolean(Component$$1 && Component$$1.prototype && typeof Component$$1.prototype.render === 'function');
|
|
};
|
|
|
|
var toClass = function toClass(baseComponent) {
|
|
if (isClassComponent(baseComponent)) {
|
|
return baseComponent;
|
|
}
|
|
|
|
var ToClass = function (_Component) {
|
|
inherits(ToClass, _Component);
|
|
|
|
function ToClass() {
|
|
classCallCheck(this, ToClass);
|
|
return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
|
}
|
|
|
|
ToClass.prototype.render = function render() {
|
|
if (typeof baseComponent === 'string') {
|
|
return React__default.createElement(baseComponent, this.props);
|
|
}
|
|
return baseComponent(this.props, this.context);
|
|
};
|
|
|
|
return ToClass;
|
|
}(React.Component);
|
|
|
|
ToClass.displayName = getDisplayName(baseComponent);
|
|
ToClass.propTypes = baseComponent.propTypes;
|
|
ToClass.contextTypes = baseComponent.contextTypes;
|
|
ToClass.defaultProps = baseComponent.defaultProps;
|
|
|
|
return ToClass;
|
|
};
|
|
|
|
var setPropTypes = function setPropTypes(propTypes) {
|
|
return setStatic('propTypes', propTypes);
|
|
};
|
|
|
|
function compose() {
|
|
for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
|
|
funcs[_key] = arguments[_key];
|
|
}
|
|
|
|
if (funcs.length === 0) {
|
|
return function (arg) {
|
|
return arg;
|
|
};
|
|
}
|
|
|
|
if (funcs.length === 1) {
|
|
return funcs[0];
|
|
}
|
|
|
|
return funcs.reduce(function (a, b) {
|
|
return function () {
|
|
return a(b.apply(undefined, arguments));
|
|
};
|
|
});
|
|
}
|
|
|
|
var createSink = function createSink(callback) {
|
|
return function (_Component) {
|
|
inherits(Sink, _Component);
|
|
|
|
function Sink() {
|
|
classCallCheck(this, Sink);
|
|
return possibleConstructorReturn(this, _Component.apply(this, arguments));
|
|
}
|
|
|
|
Sink.prototype.componentWillMount = function componentWillMount() {
|
|
callback(this.props);
|
|
};
|
|
|
|
Sink.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
|
|
callback(nextProps);
|
|
};
|
|
|
|
Sink.prototype.render = function render() {
|
|
return null;
|
|
};
|
|
|
|
return Sink;
|
|
}(React.Component);
|
|
};
|
|
|
|
var componentFromProp = function componentFromProp(propName) {
|
|
var Component$$1 = function Component$$1(props) {
|
|
return React.createElement(props[propName], omit(props, [propName]));
|
|
};
|
|
Component$$1.displayName = 'componentFromProp(' + propName + ')';
|
|
return Component$$1;
|
|
};
|
|
|
|
var nest = function nest() {
|
|
for (var _len = arguments.length, Components = Array(_len), _key = 0; _key < _len; _key++) {
|
|
Components[_key] = arguments[_key];
|
|
}
|
|
|
|
var factories = Components.map(React.createFactory);
|
|
var Nest = function Nest(_ref) {
|
|
var props = objectWithoutProperties(_ref, []),
|
|
children = _ref.children;
|
|
return factories.reduceRight(function (child, factory) {
|
|
return factory(props, child);
|
|
}, children);
|
|
};
|
|
|
|
{
|
|
var displayNames = Components.map(getDisplayName);
|
|
Nest.displayName = 'nest(' + displayNames.join(', ') + ')';
|
|
}
|
|
|
|
return Nest;
|
|
};
|
|
|
|
/**
|
|
* Copyright 2015, Yahoo! Inc.
|
|
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
|
|
*/
|
|
var REACT_STATICS = {
|
|
childContextTypes: true,
|
|
contextTypes: true,
|
|
defaultProps: true,
|
|
displayName: true,
|
|
getDefaultProps: true,
|
|
mixins: true,
|
|
propTypes: true,
|
|
type: true
|
|
};
|
|
|
|
var KNOWN_STATICS = {
|
|
name: true,
|
|
length: true,
|
|
prototype: true,
|
|
caller: true,
|
|
arguments: true,
|
|
arity: true
|
|
};
|
|
|
|
var isGetOwnPropertySymbolsAvailable = typeof Object.getOwnPropertySymbols === 'function';
|
|
|
|
var index = function hoistNonReactStatics(targetComponent, sourceComponent, customStatics) {
|
|
if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components
|
|
var keys = Object.getOwnPropertyNames(sourceComponent);
|
|
|
|
/* istanbul ignore else */
|
|
if (isGetOwnPropertySymbolsAvailable) {
|
|
keys = keys.concat(Object.getOwnPropertySymbols(sourceComponent));
|
|
}
|
|
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
if (!REACT_STATICS[keys[i]] && !KNOWN_STATICS[keys[i]] && (!customStatics || !customStatics[keys[i]])) {
|
|
try {
|
|
targetComponent[keys[i]] = sourceComponent[keys[i]];
|
|
} catch (error) {
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return targetComponent;
|
|
};
|
|
|
|
var hoistStatics = function hoistStatics(higherOrderComponent) {
|
|
return function (BaseComponent) {
|
|
var NewComponent = higherOrderComponent(BaseComponent);
|
|
index(NewComponent, BaseComponent);
|
|
return NewComponent;
|
|
};
|
|
};
|
|
|
|
function createCommonjsModule(fn, module) {
|
|
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
|
}
|
|
|
|
var index$1 = createCommonjsModule(function (module, exports) {
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var createChangeEmitter = exports.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
|
|
};
|
|
};
|
|
});
|
|
|
|
var index_1 = index$1.createChangeEmitter;
|
|
|
|
function symbolObservablePonyfill(root) {
|
|
var result;
|
|
var Symbol = root.Symbol;
|
|
|
|
if (typeof Symbol === 'function') {
|
|
if (Symbol.observable) {
|
|
result = Symbol.observable;
|
|
} else {
|
|
result = Symbol('observable');
|
|
Symbol.observable = result;
|
|
}
|
|
} 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$$1) {
|
|
return function (propsToVdom) {
|
|
return function (_Component) {
|
|
inherits(ComponentFromStream, _Component);
|
|
|
|
function ComponentFromStream() {
|
|
var _config$fromESObserva;
|
|
|
|
var _temp, _this, _ret;
|
|
|
|
classCallCheck(this, ComponentFromStream);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { vdom: null }, _this.propsEmitter = index_1(), _this.props$ = config$$1.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)), _this.vdom$ = config$$1.toESObservable(propsToVdom(_this.props$)), _temp), possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
// Stream of props
|
|
|
|
|
|
// Stream of vdom
|
|
|
|
|
|
ComponentFromStream.prototype.componentWillMount = function 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);
|
|
};
|
|
|
|
ComponentFromStream.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
|
|
// Receive new props from the owner
|
|
this.propsEmitter.emit(nextProps);
|
|
};
|
|
|
|
ComponentFromStream.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
|
|
return nextState.vdom !== this.state.vdom;
|
|
};
|
|
|
|
ComponentFromStream.prototype.componentWillUnmount = function componentWillUnmount() {
|
|
// Call without arguments to complete stream
|
|
this.propsEmitter.emit();
|
|
|
|
// Clean-up subscription before un-mounting
|
|
this.subscription.unsubscribe();
|
|
};
|
|
|
|
ComponentFromStream.prototype.render = function render() {
|
|
return this.state.vdom;
|
|
};
|
|
|
|
return ComponentFromStream;
|
|
}(React.Component);
|
|
};
|
|
};
|
|
|
|
var componentFromStream = function componentFromStream(propsToVdom) {
|
|
return componentFromStreamWithConfig(config)(propsToVdom);
|
|
};
|
|
|
|
var identity$1 = function identity(t) {
|
|
return t;
|
|
};
|
|
|
|
var mapPropsStreamWithConfig = function mapPropsStreamWithConfig(config$$1) {
|
|
var componentFromStream = componentFromStreamWithConfig({
|
|
fromESObservable: identity$1,
|
|
toESObservable: identity$1
|
|
});
|
|
return function (transform) {
|
|
return function (BaseComponent) {
|
|
var factory = React.createFactory(BaseComponent);
|
|
var fromESObservable = config$$1.fromESObservable,
|
|
toESObservable = config$$1.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(factory(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));
|
|
};
|
|
}
|
|
return hoc;
|
|
};
|
|
|
|
var createEventHandlerWithConfig = function createEventHandlerWithConfig(config$$1) {
|
|
return function () {
|
|
var _config$fromESObserva;
|
|
|
|
var emitter = index_1();
|
|
var stream = config$$1.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);
|
|
|
|
// Higher-order component helpers
|
|
|
|
exports.mapProps = mapProps;
|
|
exports.withProps = withProps;
|
|
exports.withPropsOnChange = withPropsOnChange;
|
|
exports.withHandlers = withHandlers;
|
|
exports.defaultProps = defaultProps;
|
|
exports.renameProp = renameProp;
|
|
exports.renameProps = renameProps;
|
|
exports.flattenProp = flattenProp;
|
|
exports.withState = withState;
|
|
exports.withStateHandlers = withStateHandlers;
|
|
exports.withReducer = withReducer;
|
|
exports.branch = branch;
|
|
exports.renderComponent = renderComponent;
|
|
exports.renderNothing = renderNothing;
|
|
exports.shouldUpdate = shouldUpdate;
|
|
exports.pure = pure;
|
|
exports.onlyUpdateForKeys = onlyUpdateForKeys;
|
|
exports.onlyUpdateForPropTypes = onlyUpdateForPropTypes;
|
|
exports.withContext = withContext;
|
|
exports.getContext = getContext;
|
|
exports.lifecycle = lifecycle;
|
|
exports.toClass = toClass;
|
|
exports.setStatic = setStatic;
|
|
exports.setPropTypes = setPropTypes;
|
|
exports.setDisplayName = setDisplayName;
|
|
exports.compose = compose;
|
|
exports.getDisplayName = getDisplayName;
|
|
exports.wrapDisplayName = wrapDisplayName;
|
|
exports.shallowEqual = shallowEqual_1;
|
|
exports.isClassComponent = isClassComponent;
|
|
exports.createSink = createSink;
|
|
exports.componentFromProp = componentFromProp;
|
|
exports.nest = nest;
|
|
exports.hoistStatics = hoistStatics;
|
|
exports.componentFromStream = componentFromStream;
|
|
exports.componentFromStreamWithConfig = componentFromStreamWithConfig;
|
|
exports.mapPropsStream = mapPropsStream;
|
|
exports.mapPropsStreamWithConfig = mapPropsStreamWithConfig;
|
|
exports.createEventHandler = createEventHandler;
|
|
exports.createEventHandlerWithConfig = createEventHandlerWithConfig;
|
|
exports.setObservableConfig = configureObservable;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|