react-grid-layout 0.17.1 → 0.18.3

package/build/ReactGridLayoutPropTypes.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  //
+  // Basic props
+  //
+  className: _propTypes.default.string,
+  style: _propTypes.default.object,
+  // This can be set explicitly. If it is not set, it will automatically
+  // be set to the container width. Note that resizes will *not* cause this to adjust.
+  // If you need that behavior, use WidthProvider.
+  width: _propTypes.default.number,
+  // If true, the container height swells and contracts to fit contents
+  autoSize: _propTypes.default.bool,
+  // # of cols.
+  cols: _propTypes.default.number,
+  // A selector that will not be draggable.
+  draggableCancel: _propTypes.default.string,
+  // A selector for the draggable handler
+  draggableHandle: _propTypes.default.string,
+  // Deprecated
+  verticalCompact: function verticalCompact(props
+  /*: Props*/
+  ) {
+    if (props.verticalCompact === false && process.env.NODE_ENV !== "production") {
+      console.warn( // eslint-disable-line no-console
+      "`verticalCompact` on <ReactGridLayout> is deprecated and will be removed soon. " + 'Use `compactType`: "horizontal" | "vertical" | null.');
+    }
+  },
+  // Choose vertical or hotizontal compaction
+  compactType: _propTypes.default.oneOf(["vertical", "horizontal"]),
+  // layout is an array of object with the format:
+  // {x: Number, y: Number, w: Number, h: Number, i: String}
+  layout: function layout(props
+  /*: Props*/
+  ) {
+    var layout = props.layout; // I hope you're setting the data-grid property on the grid items
+
+    if (layout === undefined) return;
+
+    require("./utils").validateLayout(layout, "layout");
+  },
+  //
+  // Grid Dimensions
+  //
+  // Margin between items [x, y] in px
+  margin: _propTypes.default.arrayOf(_propTypes.default.number),
+  // Padding inside the container [x, y] in px
+  containerPadding: _propTypes.default.arrayOf(_propTypes.default.number),
+  // Rows have a static height, but you can change this based on breakpoints if you like
+  rowHeight: _propTypes.default.number,
+  // Default Infinity, but you can specify a max here if you like.
+  // Note that this isn't fully fleshed out and won't error if you specify a layout that
+  // extends beyond the row capacity. It will, however, not allow users to drag/resize
+  // an item past the barrier. They can push items beyond the barrier, though.
+  // Intentionally not documented for this reason.
+  maxRows: _propTypes.default.number,
+  //
+  // Flags
+  //
+  isDraggable: _propTypes.default.bool,
+  isResizable: _propTypes.default.bool,
+  // If true, grid items won't change position when being dragged over.
+  preventCollision: _propTypes.default.bool,
+  // Use CSS transforms instead of top/left
+  useCSSTransforms: _propTypes.default.bool,
+  // parent layout transform scale
+  transformScale: _propTypes.default.number,
+  // If true, an external element can trigger onDrop callback with a specific grid position as a parameter
+  isDroppable: _propTypes.default.bool,
+  //
+  // Callbacks
+  //
+  // Callback so you can save the layout. Calls after each drag & resize stops.
+  onLayoutChange: _propTypes.default.func,
+  // Calls when drag starts. Callback is of the signature (layout, oldItem, newItem, placeholder, e, ?node).
+  // All callbacks below have the same signature. 'start' and 'stop' callbacks omit the 'placeholder'.
+  onDragStart: _propTypes.default.func,
+  // Calls on each drag movement.
+  onDrag: _propTypes.default.func,
+  // Calls when drag is complete.
+  onDragStop: _propTypes.default.func,
+  //Calls when resize starts.
+  onResizeStart: _propTypes.default.func,
+  // Calls when resize movement happens.
+  onResize: _propTypes.default.func,
+  // Calls when resize is complete.
+  onResizeStop: _propTypes.default.func,
+  // Calls when some element is dropped.
+  onDrop: _propTypes.default.func,
+  //
+  // Other validations
+  //
+  droppingItem: _propTypes.default.shape({
+    i: _propTypes.default.string.isRequired,
+    w: _propTypes.default.number.isRequired,
+    h: _propTypes.default.number.isRequired
+  }),
+  // Children must not have duplicate keys.
+  children: function children(props
+  /*: Props*/
+  , propName
+  /*: string*/
+  ) {
+    var children = props[propName]; // Check children keys for duplicates. Throw if found.
+
+    var keys = {};
+
+    _react.default.Children.forEach(children, function (child) {
+      if (keys[child.key]) {
+        throw new Error('Duplicate child key "' + child.key + '" found! This will cause problems in ReactGridLayout.');
+      }
+
+      keys[child.key] = true;
+    });
+  }
+};
+exports.default = _default;

package/build/ResponsiveReactGridLayout.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _react = _interopRequireDefault(require("react"));
+var React = _interopRequireWildcard(require("react"));
 
 var _propTypes = _interopRequireDefault(require("prop-types"));
 
@@ -19,7 +19,11 @@ var _ReactGridLayout = _interopRequireDefault(require("./ReactGridLayout"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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); }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
 
 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); }
 
@@ -29,7 +33,7 @@ function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) r
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -75,14 +79,14 @@ function getIndentationValue(param
   layouts?: { [key: string]: Layout }
 };*/
 
-/*:: type Props<Breakpoint: string = string> = {
-  ...$Exact<RGLProps>,
+/*:: type Props<Breakpoint: string = string> = {|
+  ...React.ElementConfig<typeof ReactGridLayout>,
 
   // Responsive config
-  breakpoint: Breakpoint,
-  breakpoints: { [key: Breakpoint]: number },
+  breakpoint?: ?Breakpoint,
+  breakpoints: Breakpoints<Breakpoint>,
   cols: { [key: Breakpoint]: number },
-  layouts: { [key: Breakpoint]: Layout },
+  layouts: ResponsiveLayout<Breakpoint>,
   width: number,
   margin: { [key: Breakpoint]: [number, number] } | [number, number],
   containerPadding: { [key: Breakpoint]: [number, number] } | [number, number],
@@ -96,7 +100,7 @@ function getIndentationValue(param
     cols: number,
     containerPadding: [number, number] | null
   ) => void
-};*/
+|};*/
 
 
 var ResponsiveReactGridLayout =
@@ -158,7 +162,7 @@ function (_React$Component) {
     ) {
       // Allow parent to set width or breakpoint directly.
       if (this.props.width != prevProps.width || this.props.breakpoint !== prevProps.breakpoint || !(0, _lodash.default)(this.props.breakpoints, prevProps.breakpoints) || !(0, _lodash.default)(this.props.cols, prevProps.cols)) {
-        this.onWidthChange(this.props);
+        this.onWidthChange(prevProps);
       }
     } // wrap layouts so we do not need to pass layouts to child
 
@@ -169,30 +173,34 @@ function (_React$Component) {
      * When the width changes work through breakpoints and reset state with the new width & breakpoint.
      * Width changes are necessary to figure out the widget widths.
      */
-    value: function onWidthChange(nextProps
+    value: function onWidthChange(prevProps
     /*: Props<*>*/
     ) {
-      var breakpoints = nextProps.breakpoints,
-          cols = nextProps.cols,
-          layouts = nextProps.layouts,
-          compactType = nextProps.compactType;
-      var newBreakpoint = nextProps.breakpoint || (0, _responsiveUtils.getBreakpointFromWidth)(nextProps.breakpoints, nextProps.width);
+      var _this$props2 = this.props,
+          breakpoints = _this$props2.breakpoints,
+          cols = _this$props2.cols,
+          layouts = _this$props2.layouts,
+          compactType = _this$props2.compactType;
+      var newBreakpoint = this.props.breakpoint || (0, _responsiveUtils.getBreakpointFromWidth)(this.props.breakpoints, this.props.width);
       var lastBreakpoint = this.state.breakpoint;
       var newCols
       /*: number*/
-      = (0, _responsiveUtils.getColsFromBreakpoint)(newBreakpoint, cols); // Breakpoint change
+      = (0, _responsiveUtils.getColsFromBreakpoint)(newBreakpoint, cols);
 
-      if (lastBreakpoint !== newBreakpoint || this.props.breakpoints !== breakpoints || this.props.cols !== cols) {
+      var newLayouts = _objectSpread({}, layouts); // Breakpoint change
+
+
+      if (lastBreakpoint !== newBreakpoint || prevProps.breakpoints !== breakpoints || prevProps.cols !== cols) {
         // Preserve the current layout if the current breakpoint is not present in the next layouts.
-        if (!(lastBreakpoint in layouts)) layouts[lastBreakpoint] = (0, _utils.cloneLayout)(this.state.layout); // Find or generate a new layout.
+        if (!(lastBreakpoint in newLayouts)) newLayouts[lastBreakpoint] = (0, _utils.cloneLayout)(this.state.layout); // Find or generate a new layout.
 
-        var layout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(layouts, breakpoints, newBreakpoint, lastBreakpoint, newCols, compactType); // This adds missing items.
+        var layout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(newLayouts, breakpoints, newBreakpoint, lastBreakpoint, newCols, compactType); // This adds missing items.
 
-        layout = (0, _utils.synchronizeLayoutWithChildren)(layout, nextProps.children, newCols, compactType); // Store the new layout.
+        layout = (0, _utils.synchronizeLayoutWithChildren)(layout, this.props.children, newCols, compactType); // Store the new layout.
 
-        layouts[newBreakpoint] = layout; // callbacks
+        newLayouts[newBreakpoint] = layout; // callbacks
 
-        this.props.onLayoutChange(layout, layouts);
+        this.props.onLayoutChange(layout, newLayouts);
         this.props.onBreakpointChange(newBreakpoint, newCols);
         this.setState({
           breakpoint: newBreakpoint,
@@ -201,30 +209,30 @@ function (_React$Component) {
         });
       }
 
-      var margin = getIndentationValue(nextProps.margin, newBreakpoint);
-      var containerPadding = getIndentationValue(nextProps.containerPadding, newBreakpoint); //call onWidthChange on every change of width, not only on breakpoint changes
+      var margin = getIndentationValue(this.props.margin, newBreakpoint);
+      var containerPadding = getIndentationValue(this.props.containerPadding, newBreakpoint); //call onWidthChange on every change of width, not only on breakpoint changes
 
-      this.props.onWidthChange(nextProps.width, margin, newCols, containerPadding);
+      this.props.onWidthChange(this.props.width, margin, newCols, containerPadding);
     }
   }, {
     key: "render",
     value: function render() {
       /* eslint-disable no-unused-vars */
-      var _this$props2 = this.props,
-          breakpoint = _this$props2.breakpoint,
-          breakpoints = _this$props2.breakpoints,
-          cols = _this$props2.cols,
-          layouts = _this$props2.layouts,
-          margin = _this$props2.margin,
-          containerPadding = _this$props2.containerPadding,
-          onBreakpointChange = _this$props2.onBreakpointChange,
-          onLayoutChange = _this$props2.onLayoutChange,
-          onWidthChange = _this$props2.onWidthChange,
-          other = _objectWithoutProperties(_this$props2, ["breakpoint", "breakpoints", "cols", "layouts", "margin", "containerPadding", "onBreakpointChange", "onLayoutChange", "onWidthChange"]);
+      var _this$props3 = this.props,
+          breakpoint = _this$props3.breakpoint,
+          breakpoints = _this$props3.breakpoints,
+          cols = _this$props3.cols,
+          layouts = _this$props3.layouts,
+          margin = _this$props3.margin,
+          containerPadding = _this$props3.containerPadding,
+          onBreakpointChange = _this$props3.onBreakpointChange,
+          onLayoutChange = _this$props3.onLayoutChange,
+          onWidthChange = _this$props3.onWidthChange,
+          other = _objectWithoutProperties(_this$props3, ["breakpoint", "breakpoints", "cols", "layouts", "margin", "containerPadding", "onBreakpointChange", "onLayoutChange", "onWidthChange"]);
       /* eslint-enable no-unused-vars */
 
 
-      return _react.default.createElement(_ReactGridLayout.default, _extends({}, other, {
+      return React.createElement(_ReactGridLayout.default, _extends({}, other, {
         margin: getIndentationValue(margin, this.state.breakpoint),
         containerPadding: getIndentationValue(containerPadding, this.state.breakpoint),
         onLayoutChange: this.onLayoutChange,
@@ -257,7 +265,7 @@ function (_React$Component) {
   }]);
 
   return ResponsiveReactGridLayout;
-}(_react.default.Component);
+}(React.Component);
 
 exports.default = ResponsiveReactGridLayout;
 
@@ -334,11 +342,11 @@ _defineProperty(ResponsiveReactGridLayout, "defaultProps", {
   layouts: {},
   margin: [10, 10],
   containerPadding: {
-    lg: null,
-    md: null,
-    sm: null,
-    xs: null,
-    xxs: null
+    lg: [0, 0],
+    md: [0, 0],
+    sm: [0, 0],
+    xs: [0, 0],
+    xxs: [0, 0]
   },
   onBreakpointChange: _utils.noop,
   onLayoutChange: _utils.noop,

package/build/calculateUtils.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcGridColWidth = calcGridColWidth;
+exports.calcGridItemPosition = calcGridItemPosition;
+exports.calcXY = calcXY;
+exports.calcWH = calcWH;
+
+/*:: import type { Position } from "./utils";*/
+
+/*:: export type PositionParams = {
+  margin: [number, number],
+  containerPadding: [number, number],
+  containerWidth: number,
+  cols: number,
+  rowHeight: number,
+  maxRows: number
+};*/
+// Helper for generating column width
+function calcGridColWidth(positionParams
+/*: PositionParams*/
+)
+/*: number*/
+{
+  var margin = positionParams.margin,
+      containerPadding = positionParams.containerPadding,
+      containerWidth = positionParams.containerWidth,
+      cols = positionParams.cols;
+  return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;
+}
+/**
+ * Return position on the page given an x, y, w, h.
+ * left, top, width, height are all in pixels.
+ * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calculations.
+ * @param  {Number}  x                      X coordinate in grid units.
+ * @param  {Number}  y                      Y coordinate in grid units.
+ * @param  {Number}  w                      W coordinate in grid units.
+ * @param  {Number}  h                      H coordinate in grid units.
+ * @return {Position}                       Object containing coords.
+ */
+
+
+function calcGridItemPosition(positionParams
+/*: PositionParams*/
+, x
+/*: number*/
+, y
+/*: number*/
+, w
+/*: number*/
+, h
+/*: number*/
+, state
+/*: ?Object*/
+)
+/*: Position*/
+{
+  var margin = positionParams.margin,
+      containerPadding = positionParams.containerPadding,
+      rowHeight = positionParams.rowHeight;
+  var colWidth = calcGridColWidth(positionParams);
+  var out = {}; // If resizing, use the exact width and height as returned from resizing callbacks.
+
+  if (state && state.resizing) {
+    out.width = Math.round(state.resizing.width);
+    out.height = Math.round(state.resizing.height);
+  } // Otherwise, calculate from grid units.
+  else {
+      // 0 * Infinity === NaN, which causes problems with resize constraints;
+      // Fix this if it occurs.
+      // Note we do it here rather than later because Math.round(Infinity) causes deopt
+      out.width = w === Infinity ? w : Math.round(colWidth * w + Math.max(0, w - 1) * margin[0]);
+      out.height = h === Infinity ? h : Math.round(rowHeight * h + Math.max(0, h - 1) * margin[1]);
+    } // If dragging, use the exact width and height as returned from dragging callbacks.
+
+
+  if (state && state.dragging) {
+    out.top = Math.round(state.dragging.top);
+    out.left = Math.round(state.dragging.left);
+  } // Otherwise, calculate from grid units.
+  else {
+      out.top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);
+      out.left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);
+    }
+
+  return out;
+}
+/**
+ * Translate x and y coordinates from pixels to grid units.
+ * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calculations.
+ * @param  {Number} top                     Top position (relative to parent) in pixels.
+ * @param  {Number} left                    Left position (relative to parent) in pixels.
+ * @param  {Number} w                       W coordinate in grid units.
+ * @param  {Number} h                       H coordinate in grid units.
+ * @return {Object}                         x and y in grid units.
+ */
+
+
+function calcXY(positionParams
+/*: PositionParams*/
+, top
+/*: number*/
+, left
+/*: number*/
+, w
+/*: number*/
+, h
+/*: number*/
+)
+/*: { x: number, y: number }*/
+{
+  var margin = positionParams.margin,
+      cols = positionParams.cols,
+      rowHeight = positionParams.rowHeight,
+      maxRows = positionParams.maxRows;
+  var colWidth = calcGridColWidth(positionParams); // left = colWidth * x + margin * (x + 1)
+  // l = cx + m(x+1)
+  // l = cx + mx + m
+  // l - m = cx + mx
+  // l - m = x(c + m)
+  // (l - m) / (c + m) = x
+  // x = (left - margin) / (coldWidth + margin)
+
+  var x = Math.round((left - margin[0]) / (colWidth + margin[0]));
+  var y = Math.round((top - margin[1]) / (rowHeight + margin[1])); // Capping
+
+  x = Math.max(Math.min(x, cols - w), 0);
+  y = Math.max(Math.min(y, maxRows - h), 0);
+  return {
+    x: x,
+    y: y
+  };
+}
+/**
+ * Given a height and width in pixel values, calculate grid units.
+ * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calcluations.
+ * @param  {Number} height                  Height in pixels.
+ * @param  {Number} width                   Width in pixels.
+ * @param  {Number} x                       X coordinate in grid units.
+ * @param  {Number} y                       Y coordinate in grid units.
+ * @return {Object}                         w, h as grid units.
+ */
+
+
+function calcWH(positionParams
+/*: PositionParams*/
+, width
+/*: number*/
+, height
+/*: number*/
+, x
+/*: number*/
+, y
+/*: number*/
+)
+/*: { w: number, h: number }*/
+{
+  var margin = positionParams.margin,
+      maxRows = positionParams.maxRows,
+      cols = positionParams.cols,
+      rowHeight = positionParams.rowHeight;
+  var colWidth = calcGridColWidth(positionParams); // width = colWidth * w - (margin * (w - 1))
+  // ...
+  // w = (width + margin) / (colWidth + margin)
+
+  var w = Math.round((width + margin[0]) / (colWidth + margin[0]));
+  var h = Math.round((height + margin[1]) / (rowHeight + margin[1])); // Capping
+
+  w = Math.max(Math.min(w, cols - x), 0);
+  h = Math.max(Math.min(h, maxRows - y), 0);
+  return {
+    w: w,
+    h: h
+  };
+}

package/build/components/WidthProvider.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = WidthProvider;
 
-var _react = _interopRequireDefault(require("react"));
+var React = _interopRequireWildcard(require("react"));
 
 var _propTypes = _interopRequireDefault(require("prop-types"));
 
@@ -13,7 +13,11 @@ var _reactDom = _interopRequireDefault(require("react-dom"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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); }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
 
 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); }
 
@@ -41,16 +45,22 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 /*
  * A simple HOC that provides facility for listening to container resizes.
+ *
+ * The Flow type is pretty janky here. I can't just spread `WPProps` into this returned object - I wish I could - but it triggers
+ * a flow bug of some sort that causes it to stop typechecking.
  */
 function WidthProvider
-/*:: <
-  Props,
-  ComposedProps: { ...Props, ...WPProps }
->*/
+/*:: <Config>*/
 (ComposedComponent
-/*: ReactComponentType<Props>*/
+/*: React.AbstractComponent<Config>*/
 )
-/*: ReactComponentType<ComposedProps>*/
+/*: React.AbstractComponent<{|
+  ...Config,
+  measureBeforeMount?: boolean,
+  className?: string,
+  style?: Object,
+  width?: number
+|}>*/
 {
   var _class, _temp;
 
@@ -116,18 +126,18 @@ function WidthProvider
             rest = _objectWithoutProperties(_this$props, ["measureBeforeMount"]);
 
         if (measureBeforeMount && !this.mounted) {
-          return _react.default.createElement("div", {
+          return React.createElement("div", {
             className: this.props.className,
             style: this.props.style
           });
         }
 
-        return _react.default.createElement(ComposedComponent, _extends({}, rest, this.state));
+        return React.createElement(ComposedComponent, _extends({}, rest, this.state));
       }
     }]);
 
     return WidthProvider;
-  }(_react.default.Component), _defineProperty(_class, "defaultProps", {
+  }(React.Component), _defineProperty(_class, "defaultProps", {
     measureBeforeMount: false
   }), _defineProperty(_class, "propTypes", {
     // If true, will not render children until mounted. Useful for getting the exact width before

package/build/fastRGLPropsEqual.js

@@ -0,0 +1,5 @@
+// this file was prevaled
+module.exports = function fastRGLPropsEqual(a, b, isEqualImpl) {
+  if (a === b) return true;
+  return a.className === b.className && isEqualImpl(a.style, b.style) && a.width === b.width && a.autoSize === b.autoSize && a.cols === b.cols && a.draggableCancel === b.draggableCancel && a.draggableHandle === b.draggableHandle && isEqualImpl(a.verticalCompact, b.verticalCompact) && isEqualImpl(a.compactType, b.compactType) && isEqualImpl(a.layout, b.layout) && isEqualImpl(a.margin, b.margin) && isEqualImpl(a.containerPadding, b.containerPadding) && a.rowHeight === b.rowHeight && a.maxRows === b.maxRows && a.isDraggable === b.isDraggable && a.isResizable === b.isResizable && a.preventCollision === b.preventCollision && a.useCSSTransforms === b.useCSSTransforms && a.transformScale === b.transformScale && a.isDroppable === b.isDroppable && a.onLayoutChange === b.onLayoutChange && a.onDragStart === b.onDragStart && a.onDrag === b.onDrag && a.onDragStop === b.onDragStop && a.onResizeStart === b.onResizeStart && a.onResize === b.onResize && a.onResizeStop === b.onResizeStop && a.onDrop === b.onDrop && isEqualImpl(a.droppingItem, b.droppingItem);
+};

package/build/responsiveUtils.js

@@ -18,7 +18,7 @@ var _utils = require("./utils");
  * @return {String}       Highest breakpoint that is less than width.
  */
 function getBreakpointFromWidth(breakpoints
-/*: Breakpoints*/
+/*: Breakpoints<Breakpoint>*/
 , width
 /*: number*/
 )
@@ -45,7 +45,7 @@ function getBreakpointFromWidth(breakpoints
 function getColsFromBreakpoint(breakpoint
 /*: Breakpoint*/
 , cols
-/*: Breakpoints*/
+/*: Breakpoints<Breakpoint>*/
 )
 /*: number*/
 {
@@ -72,9 +72,9 @@ function getColsFromBreakpoint(breakpoint
 
 
 function findOrGenerateResponsiveLayout(layouts
-/*: ResponsiveLayout*/
+/*: ResponsiveLayout<Breakpoint>*/
 , breakpoints
-/*: Breakpoints*/
+/*: Breakpoints<Breakpoint>*/
 , breakpoint
 /*: Breakpoint*/
 , lastBreakpoint
@@ -118,7 +118,7 @@ function findOrGenerateResponsiveLayout(layouts
 
 
 function sortBreakpoints(breakpoints
-/*: Breakpoints*/
+/*: Breakpoints<Breakpoint>*/
 )
 /*: Array<Breakpoint>*/
 {