react-grid-layout 0.18.2 → 1.1.1

package/build/ReactGridLayout.js

@@ -27,13 +27,17 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -41,15 +45,19 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 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"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
 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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 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; }
 
@@ -59,19 +67,19 @@ var isFirefox = false; // Try...catch will protect from navigator not existing (
 
 try {
   isFirefox = /firefox/i.test(navigator.userAgent);
-} catch (e) {}
-/* Ignore */
-
+} catch (e) {
+  /* Ignore */
+}
 /**
  * A reactive, fluid grid layout with draggable, resizable components.
  */
 
 
-var ReactGridLayout =
-/*#__PURE__*/
-function (_React$Component) {
+var ReactGridLayout = /*#__PURE__*/function (_React$Component) {
   _inherits(ReactGridLayout, _React$Component);
 
+  var _super = _createSuper(ReactGridLayout);
+
   // TODO publish internal ReactClass displayName transform
   // Refactored to another module to make way for preval
   function ReactGridLayout(props
@@ -85,7 +93,7 @@ function (_React$Component) {
 
     _classCallCheck(this, ReactGridLayout);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(ReactGridLayout).call(this, props, context));
+    _this = _super.call(this, props, context);
 
     _defineProperty(_assertThisInitialized(_this), "state", {
       activeDrag: null,
@@ -144,11 +152,11 @@ function (_React$Component) {
         var calculatedPosition = (0, _calculateUtils.calcXY)(positionParams, layerY, layerX, droppingItem.w, droppingItem.h);
 
         _this.setState({
-          droppingDOMNode: _react.default.createElement("div", {
+          droppingDOMNode: /*#__PURE__*/_react.default.createElement("div", {
             key: droppingItem.i
           }),
           droppingPosition: droppingPosition,
-          layout: [].concat(_toConsumableArray(layout), [_objectSpread({}, droppingItem, {
+          layout: [].concat(_toConsumableArray(layout), [_objectSpread(_objectSpread({}, droppingItem), {}, {
             x: calculatedPosition.x,
             y: calculatedPosition.y,
             static: false,
@@ -210,27 +218,15 @@ function (_React$Component) {
     ) {
       var droppingItem = _this.props.droppingItem;
       var layout = _this.state.layout;
-
-      var _ref = layout.find(function (l) {
+      var item = layout.find(function (l) {
         return l.i === droppingItem.i;
-      }) || {},
-          x = _ref.x,
-          y = _ref.y,
-          w = _ref.w,
-          h = _ref.h; // reset gragEnter counter on drop
-
+      }); // reset gragEnter counter on drop
 
       _this.dragEnterCounter = 0;
 
       _this.removeDroppingPlaceholder();
 
-      _this.props.onDrop({
-        x: x,
-        y: y,
-        w: w,
-        h: h,
-        e: e
-      });
+      _this.props.onDrop(layout, item, e);
     });
 
     (0, _utils.autoBindHandlers)(_assertThisInitialized(_this), ["onDragStart", "onDrag", "onDragStop", "onResizeStart", "onResize", "onResizeStop"]);
@@ -257,7 +253,7 @@ function (_React$Component) {
       return (// NOTE: this is almost always unequal. Therefore the only way to get better performance
         // from SCU is if the user intentionally memoizes children. If they do, and they can
         // handle changes properly, performance will increase.
-        this.props.children !== nextProps.children || !(0, _utils.fastRGLPropsEqual)(this.props, nextProps, _lodash.default) || !(0, _lodash.default)(this.state.activeDrag, nextState.activeDrag)
+        this.props.children !== nextProps.children || !(0, _utils.fastRGLPropsEqual)(this.props, nextProps, _lodash.default) || this.state.activeDrag !== nextState.activeDrag || this.state.mounted !== nextState.mounted || this.state.droppingPosition !== nextState.droppingPosition
       );
     }
   }, {
@@ -303,9 +299,9 @@ function (_React$Component) {
     /*: number*/
     , y
     /*: number*/
-    , _ref2) {
-      var e = _ref2.e,
-          node = _ref2.node;
+    , _ref) {
+      var e = _ref.e,
+          node = _ref.node;
       var layout = this.state.layout;
       var l = (0, _utils.getLayoutItem)(layout, i);
       if (!l) return;
@@ -332,9 +328,9 @@ function (_React$Component) {
     /*: number*/
     , y
     /*: number*/
-    , _ref3) {
-      var e = _ref3.e,
-          node = _ref3.node;
+    , _ref2) {
+      var e = _ref2.e,
+          node = _ref2.node;
       var oldDragItem = this.state.oldDragItem;
       var layout = this.state.layout;
       var cols = this.props.cols;
@@ -375,9 +371,9 @@ function (_React$Component) {
     /*: number*/
     , y
     /*: number*/
-    , _ref4) {
-      var e = _ref4.e,
-          node = _ref4.node;
+    , _ref3) {
+      var e = _ref3.e,
+          node = _ref3.node;
       if (!this.state.activeDrag) return;
       var oldDragItem = this.state.oldDragItem;
       var layout = this.state.layout;
@@ -422,9 +418,9 @@ function (_React$Component) {
     /*: number*/
     , h
     /*: number*/
-    , _ref5) {
-      var e = _ref5.e,
-          node = _ref5.node;
+    , _ref4) {
+      var e = _ref4.e,
+          node = _ref4.node;
       var layout = this.state.layout;
       var l = (0, _utils.getLayoutItem)(layout, i);
       if (!l) return;
@@ -442,9 +438,9 @@ function (_React$Component) {
     /*: number*/
     , h
     /*: number*/
-    , _ref6) {
-      var e = _ref6.e,
-          node = _ref6.node;
+    , _ref5) {
+      var e = _ref5.e,
+          node = _ref5.node;
       var _this$state = this.state,
           layout = _this$state.layout,
           oldResizeItem = _this$state.oldResizeItem;
@@ -460,7 +456,7 @@ function (_React$Component) {
       var hasCollisions;
 
       if (preventCollision) {
-        var collisions = (0, _utils.getAllCollisions)(layout, _objectSpread({}, l, {
+        var collisions = (0, _utils.getAllCollisions)(layout, _objectSpread(_objectSpread({}, l), {}, {
           w: w,
           h: h
         })).filter(function (layoutItem) {
@@ -511,9 +507,9 @@ function (_React$Component) {
     /*: number*/
     , h
     /*: number*/
-    , _ref7) {
-      var e = _ref7.e,
-          node = _ref7.node;
+    , _ref6) {
+      var e = _ref6.e,
+          node = _ref6.node;
       var _this$state2 = this.state,
           layout = _this$state2.layout,
           oldResizeItem = _this$state2.oldResizeItem;
@@ -553,7 +549,7 @@ function (_React$Component) {
           useCSSTransforms = _this$props5.useCSSTransforms,
           transformScale = _this$props5.transformScale; // {...this.state.activeDrag} is pretty slow, actually
 
-      return _react.default.createElement(_GridItem.default, {
+      return /*#__PURE__*/_react.default.createElement(_GridItem.default, {
         w: activeDrag.w,
         h: activeDrag.h,
         x: activeDrag.x,
@@ -568,9 +564,10 @@ function (_React$Component) {
         rowHeight: rowHeight,
         isDraggable: false,
         isResizable: false,
+        isBounded: false,
         useCSSTransforms: useCSSTransforms,
         transformScale: transformScale
-      }, _react.default.createElement("div", null));
+      }, /*#__PURE__*/_react.default.createElement("div", null));
     }
     /**
      * Given a grid item, set its style attributes & surround in a <Draggable>.
@@ -599,10 +596,12 @@ function (_React$Component) {
           maxRows = _this$props6.maxRows,
           isDraggable = _this$props6.isDraggable,
           isResizable = _this$props6.isResizable,
+          isBounded = _this$props6.isBounded,
           useCSSTransforms = _this$props6.useCSSTransforms,
           transformScale = _this$props6.transformScale,
           draggableCancel = _this$props6.draggableCancel,
-          draggableHandle = _this$props6.draggableHandle;
+          draggableHandle = _this$props6.draggableHandle,
+          resizeHandles = _this$props6.resizeHandles;
       var _this$state3 = this.state,
           mounted = _this$state3.mounted,
           droppingPosition = _this$state3.droppingPosition; // Determine user manipulations possible.
@@ -611,7 +610,10 @@ function (_React$Component) {
 
       var draggable = typeof l.isDraggable === "boolean" ? l.isDraggable : !l.static && isDraggable;
       var resizable = typeof l.isResizable === "boolean" ? l.isResizable : !l.static && isResizable;
-      return _react.default.createElement(_GridItem.default, {
+      var resizeHandlesOptions = l.resizeHandles || resizeHandles; // isBounded set on child if set on parent, and child is not explicitly false
+
+      var bounded = draggable && isBounded && l.isBounded !== false;
+      return /*#__PURE__*/_react.default.createElement(_GridItem.default, {
         containerWidth: width,
         cols: cols,
         margin: margin,
@@ -628,6 +630,7 @@ function (_React$Component) {
         onResizeStop: this.onResizeStop,
         isDraggable: draggable,
         isResizable: resizable,
+        isBounded: bounded,
         useCSSTransforms: useCSSTransforms && mounted,
         usePercentages: !mounted,
         transformScale: transformScale,
@@ -641,7 +644,8 @@ function (_React$Component) {
         maxH: l.maxH,
         maxW: l.maxW,
         static: l.static,
-        droppingPosition: isDroppingItem ? droppingPosition : undefined
+        droppingPosition: isDroppingItem ? droppingPosition : undefined,
+        resizeHandles: resizeHandlesOptions
       }, child);
     } // Called while dragging an element. Part of browser native drag/drop API.
     // Native event target might be the layout itself, or an element within the layout.
@@ -654,14 +658,16 @@ function (_React$Component) {
       var _this$props7 = this.props,
           className = _this$props7.className,
           style = _this$props7.style,
-          isDroppable = _this$props7.isDroppable;
+          isDroppable = _this$props7.isDroppable,
+          innerRef = _this$props7.innerRef;
       var mergedClassName = (0, _classnames.default)(layoutClassName, className);
 
       var mergedStyle = _objectSpread({
         height: this.containerHeight()
       }, style);
 
-      return _react.default.createElement("div", {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: innerRef,
         className: mergedClassName,
         style: mergedStyle,
         onDrop: isDroppable ? this.onDrop : _utils.noop,
@@ -735,6 +741,7 @@ _defineProperty(ReactGridLayout, "defaultProps", {
   // infinite vertical growth
   layout: [],
   margin: [10, 10],
+  isBounded: false,
   isDraggable: true,
   isResizable: true,
   isDroppable: false,
@@ -748,6 +755,7 @@ _defineProperty(ReactGridLayout, "defaultProps", {
     h: 1,
     w: 1
   },
+  resizeHandles: ["se"],
   onLayoutChange: _utils.noop,
   onDragStart: _utils.noop,
   onDrag: _utils.noop,

package/build/ReactGridLayoutPropTypes.js

@@ -69,6 +69,7 @@ var _default = {
   //
   // Flags
   //
+  isBounded: _propTypes.default.bool,
   isDraggable: _propTypes.default.bool,
   isResizable: _propTypes.default.bool,
   // If true, grid items won't change position when being dragged over.
@@ -79,6 +80,17 @@ var _default = {
   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,
+  // Defines which resize handles should be rendered (default: 'se')
+  // Allows for any combination of:
+  // 's' - South handle (bottom-center)
+  // 'w' - West handle (left-center)
+  // 'e' - East handle (right-center)
+  // 'n' - North handle (top-center)
+  // 'sw' - Southwest handle (bottom-left)
+  // 'nw' - Northwest handle (top-left)
+  // 'se' - Southeast handle (bottom-right)
+  // 'ne' - Northeast handle (top-right)
+  resizeHandles: _propTypes.default.arrayOf(_propTypes.default.oneOf(["s", "w", "e", "n", "sw", "nw", "se", "ne"])),
   //
   // Callbacks
   //
@@ -124,6 +136,8 @@ var _default = {
 
       keys[child.key] = true;
     });
-  }
+  },
+  // Optional ref for getting a reference for the wrapping div.
+  innerRef: _propTypes.default.any
 };
 exports.default = _default;

package/build/ResponsiveReactGridLayout.js

@@ -41,15 +41,19 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 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"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
 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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 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; }
 
@@ -65,11 +69,17 @@ var type = function type(obj) {
  */
 
 
-function getIndentationValue(param
-/*: { [key: string]: [number, number] } | [number, number]*/
+function getIndentationValue
+/*:: <T: ?[number, number]>*/
+(param
+/*: { [key: string]: T } | T*/
 , breakpoint
 /*: string*/
-) {
+)
+/*: T*/
+{
+  // $FlowIssue doesn't seem to understand this
+  if (param == null) return null;
   return Array.isArray(param) ? param : param[breakpoint];
 }
 /*:: type State = {
@@ -84,12 +94,13 @@ function getIndentationValue(param
 
   // Responsive config
   breakpoint?: ?Breakpoint,
-  breakpoints: { [key: Breakpoint]: number },
+  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],
+  /* prettier-ignore *-/
+  containerPadding: { [key: Breakpoint]: ?[number, number] } | ?[number, number],
 
   // Callbacks
   onBreakpointChange: (Breakpoint, cols: number) => void,
@@ -98,19 +109,17 @@ function getIndentationValue(param
     containerWidth: number,
     margin: [number, number],
     cols: number,
-    containerPadding: [number, number] | null
+    containerPadding: ?[number, number]
   ) => void
 |};*/
 
 
-var ResponsiveReactGridLayout =
-/*#__PURE__*/
-function (_React$Component) {
+var ResponsiveReactGridLayout = /*#__PURE__*/function (_React$Component) {
   _inherits(ResponsiveReactGridLayout, _React$Component);
 
-  function ResponsiveReactGridLayout() {
-    var _getPrototypeOf2;
+  var _super = _createSuper(ResponsiveReactGridLayout);
 
+  function ResponsiveReactGridLayout() {
     var _this;
 
     _classCallCheck(this, ResponsiveReactGridLayout);
@@ -119,14 +128,14 @@ function (_React$Component) {
       args[_key] = arguments[_key];
     }
 
-    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ResponsiveReactGridLayout)).call.apply(_getPrototypeOf2, [this].concat(args)));
+    _this = _super.call.apply(_super, [this].concat(args));
 
     _defineProperty(_assertThisInitialized(_this), "state", _this.generateInitialState());
 
     _defineProperty(_assertThisInitialized(_this), "onLayoutChange", function (layout
     /*: Layout*/
     ) {
-      _this.props.onLayoutChange(layout, _objectSpread({}, _this.props.layouts, _defineProperty({}, _this.state.breakpoint, layout)));
+      _this.props.onLayoutChange(layout, _objectSpread(_objectSpread({}, _this.props.layouts), {}, _defineProperty({}, _this.state.breakpoint, layout)));
     });
 
     return _this;
@@ -232,7 +241,7 @@ function (_React$Component) {
       /* eslint-enable no-unused-vars */
 
 
-      return React.createElement(_ReactGridLayout.default, _extends({}, other, {
+      return /*#__PURE__*/React.createElement(_ReactGridLayout.default, _extends({}, other, {
         margin: getIndentationValue(margin, this.state.breakpoint),
         containerPadding: getIndentationValue(containerPadding, this.state.breakpoint),
         onLayoutChange: this.onLayoutChange,
@@ -342,11 +351,11 @@ _defineProperty(ResponsiveReactGridLayout, "defaultProps", {
   layouts: {},
   margin: [10, 10],
   containerPadding: {
-    lg: [0, 0],
-    md: [0, 0],
-    sm: [0, 0],
-    xs: [0, 0],
-    xxs: [0, 0]
+    lg: null,
+    md: null,
+    sm: null,
+    xs: null,
+    xxs: null
   },
   onBreakpointChange: _utils.noop,
   onLayoutChange: _utils.noop,

package/build/calculateUtils.js

@@ -4,9 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.calcGridColWidth = calcGridColWidth;
+exports.calcGridItemWHPx = calcGridItemWHPx;
 exports.calcGridItemPosition = calcGridItemPosition;
 exports.calcXY = calcXY;
 exports.calcWH = calcWH;
+exports.clamp = clamp;
 
 /*:: import type { Position } from "./utils";*/
 
@@ -29,6 +31,22 @@ function calcGridColWidth(positionParams
       containerWidth = positionParams.containerWidth,
       cols = positionParams.cols;
   return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;
+} // This can either be called:
+// calcGridItemWHPx(w, colWidth, margin[0])
+// or
+// calcGridItemWHPx(h, rowHeight, margin[1])
+
+
+function calcGridItemWHPx(gridUnits
+/*: number*/
+, colOrRowSize
+/*: number*/
+, marginPx
+/*: number*/
+) {
+  // 0 * Infinity === NaN, which causes problems with resize contraints
+  if (!Number.isFinite(gridUnits)) return gridUnits;
+  return Math.round(colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx);
 }
 /**
  * Return position on the page given an x, y, w, h.
@@ -68,11 +86,8 @@ function calcGridItemPosition(positionParams
     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]);
+      out.width = calcGridItemWHPx(w, colWidth, margin[0]);
+      out.height = calcGridItemWHPx(h, rowHeight, margin[1]);
     } // If dragging, use the exact width and height as returned from dragging callbacks.
 
 
@@ -126,8 +141,8 @@ function calcXY(positionParams
   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);
+  x = clamp(x, 0, cols - w);
+  y = clamp(y, 0, maxRows - h);
   return {
     x: x,
     y: y
@@ -168,10 +183,21 @@ function calcWH(positionParams
   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);
+  w = clamp(w, 0, cols - x);
+  h = clamp(h, 0, maxRows - y);
   return {
     w: w,
     h: h
   };
+} // Similar to _.clamp
+
+
+function clamp(num
+/*: number*/
+, lowerBound
+/*: number*/
+, upperBound
+/*: number*/
+) {
+  return Math.max(Math.min(num, upperBound), lowerBound);
 }

package/build/components/WidthProvider.js

@@ -31,15 +31,19 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 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"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
 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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 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; }
 
@@ -64,14 +68,12 @@ function WidthProvider
 {
   var _class, _temp;
 
-  return _temp = _class =
-  /*#__PURE__*/
-  function (_React$Component) {
+  return _temp = _class = /*#__PURE__*/function (_React$Component) {
     _inherits(WidthProvider, _React$Component);
 
-    function WidthProvider() {
-      var _getPrototypeOf2;
+    var _super = _createSuper(WidthProvider);
 
+    function WidthProvider() {
       var _this;
 
       _classCallCheck(this, WidthProvider);
@@ -80,7 +82,7 @@ function WidthProvider
         args[_key] = arguments[_key];
       }
 
-      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WidthProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
+      _this = _super.call.apply(_super, [this].concat(args));
 
       _defineProperty(_assertThisInitialized(_this), "state", {
         width: 1280
@@ -126,13 +128,13 @@ function WidthProvider
             rest = _objectWithoutProperties(_this$props, ["measureBeforeMount"]);
 
         if (measureBeforeMount && !this.mounted) {
-          return React.createElement("div", {
+          return /*#__PURE__*/React.createElement("div", {
             className: this.props.className,
             style: this.props.style
           });
         }
 
-        return React.createElement(ComposedComponent, _extends({}, rest, this.state));
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, rest, this.state));
       }
     }]);
 

package/build/fastRGLPropsEqual.js

@@ -1,5 +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);
+  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.isBounded === b.isBounded && a.isDraggable === b.isDraggable && a.isResizable === b.isResizable && a.preventCollision === b.preventCollision && a.useCSSTransforms === b.useCSSTransforms && a.transformScale === b.transformScale && a.isDroppable === b.isDroppable && isEqualImpl(a.resizeHandles, b.resizeHandles) && 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) && isEqualImpl(a.innerRef, b.innerRef);
 };