louis-xiv/umd/louis-xiv.js

React state as a component

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('react-dom')) :
  typeof define === 'function' && define.amd ? define(['react', 'react-dom'], factory) :
  (global.LouisXIV = factory(global.React,global.ReactDOM));
}(this, (function (react,ReactDOM) { 'use strict';

  ReactDOM = ReactDOM && ReactDOM.hasOwnProperty('default') ? ReactDOM['default'] : ReactDOM;

  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 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 State = function (_Component) {
    inherits(State, _Component);

    function State() {
      var _temp, _this, _ret;

      classCallCheck(this, State);

      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 = _extends({}, _this.props.init), _temp), possibleConstructorReturn(_this, _ret);
    }

    State.prototype.render = function render() {
      var _this2 = this;

      var setState = function setState(s, se) {
        return _this2.setState(s, se);
      };
      var deferredSetState = function deferredSetState(s, se) {
        return ReactDOM.unstable_deferredUpdates(function () {
          return _this2.setState(s, se);
        });
      };

      var state = this.props.map ? this.props.map(this.state, setState, deferredSetState) : this.state;

      return this.props.children(state, setState, deferredSetState);
    };

    return State;
  }(react.Component);

  return State;

})));