react-grid-layout 0.16.4 → 0.17.1

package/build/components/WidthProvider.js

@@ -1,94 +1,137 @@
 "use strict";
 
-exports.__esModule = true;
-
-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; };
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = WidthProvider;
 
-var _react = require("react");
+var _react = _interopRequireDefault(require("react"));
 
-var _react2 = _interopRequireDefault(_react);
+var _propTypes = _interopRequireDefault(require("prop-types"));
 
-var _propTypes = require("prop-types");
+var _reactDom = _interopRequireDefault(require("react-dom"));
 
-var _propTypes2 = _interopRequireDefault(_propTypes);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _reactDom = require("react-dom");
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-var _reactDom2 = _interopRequireDefault(_reactDom);
+function _extends() { _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; }; return _extends.apply(this, arguments); }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 
-function _objectWithoutProperties(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; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function _possibleConstructorReturn(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; }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-function _inherits(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; }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 /*
  * A simple HOC that provides facility for listening to container resizes.
  */
-function WidthProvider(ComposedComponent) {
-  var _class, _temp2;
-
-  return _temp2 = _class = function (_React$Component) {
+function WidthProvider
+/*:: <
+  Props,
+  ComposedProps: { ...Props, ...WPProps }
+>*/
+(ComposedComponent
+/*: ReactComponentType<Props>*/
+)
+/*: ReactComponentType<ComposedProps>*/
+{
+  var _class, _temp;
+
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_React$Component) {
     _inherits(WidthProvider, _React$Component);
 
     function WidthProvider() {
-      var _temp, _this, _ret;
+      var _getPrototypeOf2;
+
+      var _this;
 
       _classCallCheck(this, WidthProvider);
 
-      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
 
-      return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
+      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WidthProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+      _defineProperty(_assertThisInitialized(_this), "state", {
         width: 1280
-      }, _this.mounted = false, _this.onWindowResize = function () {
-        if (!_this.mounted) return;
-        // eslint-disable-next-line
-        var node = _reactDom2.default.findDOMNode(_this); // Flow casts this to Text | Element
-        if (node instanceof HTMLElement) _this.setState({ width: node.offsetWidth });
-      }, _temp), _possibleConstructorReturn(_this, _ret);
-    }
+      });
 
-    WidthProvider.prototype.componentDidMount = function componentDidMount() {
-      this.mounted = true;
+      _defineProperty(_assertThisInitialized(_this), "mounted", false);
 
-      window.addEventListener("resize", this.onWindowResize);
-      // Call to properly set the breakpoint and resize the elements.
-      // Note that if you're doing a full-width element, this can get a little wonky if a scrollbar
-      // appears because of the grid. In that case, fire your own resize event, or set `overflow: scroll` on your body.
-      this.onWindowResize();
-    };
+      _defineProperty(_assertThisInitialized(_this), "onWindowResize", function () {
+        if (!_this.mounted) return; // eslint-disable-next-line react/no-find-dom-node
 
-    WidthProvider.prototype.componentWillUnmount = function componentWillUnmount() {
-      this.mounted = false;
-      window.removeEventListener("resize", this.onWindowResize);
-    };
+        var node = _reactDom.default.findDOMNode(_assertThisInitialized(_this)); // Flow casts this to Text | Element
 
-    WidthProvider.prototype.render = function render() {
-      var _props = this.props,
-          measureBeforeMount = _props.measureBeforeMount,
-          rest = _objectWithoutProperties(_props, ["measureBeforeMount"]);
 
-      if (measureBeforeMount && !this.mounted) {
-        return _react2.default.createElement("div", { className: this.props.className, style: this.props.style });
-      }
+        if (node instanceof HTMLElement) _this.setState({
+          width: node.offsetWidth
+        });
+      });
+
+      return _this;
+    }
+
+    _createClass(WidthProvider, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.mounted = true;
+        window.addEventListener("resize", this.onWindowResize); // Call to properly set the breakpoint and resize the elements.
+        // Note that if you're doing a full-width element, this can get a little wonky if a scrollbar
+        // appears because of the grid. In that case, fire your own resize event, or set `overflow: scroll` on your body.
 
-      return _react2.default.createElement(ComposedComponent, _extends({}, rest, this.state));
-    };
+        this.onWindowResize();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.mounted = false;
+        window.removeEventListener("resize", this.onWindowResize);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            measureBeforeMount = _this$props.measureBeforeMount,
+            rest = _objectWithoutProperties(_this$props, ["measureBeforeMount"]);
+
+        if (measureBeforeMount && !this.mounted) {
+          return _react.default.createElement("div", {
+            className: this.props.className,
+            style: this.props.style
+          });
+        }
+
+        return _react.default.createElement(ComposedComponent, _extends({}, rest, this.state));
+      }
+    }]);
 
     return WidthProvider;
-  }(_react2.default.Component), _class.defaultProps = {
+  }(_react.default.Component), _defineProperty(_class, "defaultProps", {
     measureBeforeMount: false
-  }, _class.propTypes = {
+  }), _defineProperty(_class, "propTypes", {
     // If true, will not render children until mounted. Useful for getting the exact width before
     // rendering, to prevent any unsightly resizing.
-    measureBeforeMount: _propTypes2.default.bool
-  }, _temp2;
+    measureBeforeMount: _propTypes.default.bool
+  }), _temp;
 }

package/build/responsiveUtils.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.getBreakpointFromWidth = getBreakpointFromWidth;
 exports.getColsFromBreakpoint = getColsFromBreakpoint;
 exports.findOrGenerateResponsiveLayout = findOrGenerateResponsiveLayout;
@@ -15,16 +17,23 @@ var _utils = require("./utils");
  * @param  {Number} width Screen width.
  * @return {String}       Highest breakpoint that is less than width.
  */
-function getBreakpointFromWidth(breakpoints, width) {
+function getBreakpointFromWidth(breakpoints
+/*: Breakpoints*/
+, width
+/*: number*/
+)
+/*: Breakpoint*/
+{
   var sorted = sortBreakpoints(breakpoints);
   var matching = sorted[0];
+
   for (var i = 1, len = sorted.length; i < len; i++) {
     var breakpointName = sorted[i];
     if (width > breakpoints[breakpointName]) matching = breakpointName;
   }
+
   return matching;
 }
-
 /**
  * Given a breakpoint, get the # of cols set for it.
  * @param  {String} breakpoint Breakpoint name.
@@ -33,13 +42,19 @@ function getBreakpointFromWidth(breakpoints, width) {
  */
 
 
-function getColsFromBreakpoint(breakpoint, cols) {
+function getColsFromBreakpoint(breakpoint
+/*: Breakpoint*/
+, cols
+/*: Breakpoints*/
+)
+/*: number*/
+{
   if (!cols[breakpoint]) {
     throw new Error("ResponsiveReactGridLayout: `cols` entry for breakpoint " + breakpoint + " is missing!");
   }
+
   return cols[breakpoint];
 }
-
 /**
  * Given existing layouts and a new breakpoint, find or generate a new layout.
  *
@@ -54,24 +69,45 @@ function getColsFromBreakpoint(breakpoint, cols) {
  *   vertically.
  * @return {Array}             New layout.
  */
-function findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBreakpoint, cols, compactType) {
+
+
+function findOrGenerateResponsiveLayout(layouts
+/*: ResponsiveLayout*/
+, breakpoints
+/*: Breakpoints*/
+, breakpoint
+/*: Breakpoint*/
+, lastBreakpoint
+/*: Breakpoint*/
+, cols
+/*: number*/
+, compactType
+/*: CompactType*/
+)
+/*: Layout*/
+{
   // If it already exists, just return it.
-  if (layouts[breakpoint]) return (0, _utils.cloneLayout)(layouts[breakpoint]);
-  // Find or generate the next layout
+  if (layouts[breakpoint]) return (0, _utils.cloneLayout)(layouts[breakpoint]); // Find or generate the next layout
+
   var layout = layouts[lastBreakpoint];
   var breakpointsSorted = sortBreakpoints(breakpoints);
   var breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));
+
   for (var i = 0, len = breakpointsAbove.length; i < len; i++) {
     var b = breakpointsAbove[i];
+
     if (layouts[b]) {
       layout = layouts[b];
       break;
     }
   }
+
   layout = (0, _utils.cloneLayout)(layout || []); // clone layout so we don't modify existing items
-  return (0, _utils.compact)((0, _utils.correctBounds)(layout, { cols: cols }), compactType, cols);
-}
 
+  return (0, _utils.compact)((0, _utils.correctBounds)(layout, {
+    cols: cols
+  }), compactType, cols);
+}
 /**
  * Given breakpoints, return an array of breakpoints sorted by width. This is usually
  * e.g. ['xxs', 'xs', 'sm', ...]
@@ -79,8 +115,16 @@ function findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBr
  * @param  {Object} breakpoints Key/value pair of breakpoint names to widths.
  * @return {Array}              Sorted breakpoints.
  */
-function sortBreakpoints(breakpoints) {
-  var keys = Object.keys(breakpoints);
+
+
+function sortBreakpoints(breakpoints
+/*: Breakpoints*/
+)
+/*: Array<Breakpoint>*/
+{
+  var keys
+  /*: Array<string>*/
+  = Object.keys(breakpoints);
   return keys.sort(function (a, b) {
     return breakpoints[a] - breakpoints[b];
   });