react-grid-layout 1.5.1 → 1.5.3

package/build/utils.js

@@ -34,7 +34,12 @@ exports.validateLayout = validateLayout;
 exports.withLayoutItem = withLayoutItem;
 var _fastEquals = require("fast-equals");
 var _react = _interopRequireDefault(require("react"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /*:: import type {
   ChildrenArray as ReactChildrenArray,
   Element as ReactElement
@@ -196,7 +201,7 @@ function cloneLayoutItem(layoutItem /*: LayoutItem*/) /*: LayoutItem*/{
  * This will catch differences in keys, order, and length.
  */
 function childrenEqual(a /*: ReactChildren*/, b /*: ReactChildren*/) /*: boolean*/{
-  return (0, _fastEquals.deepEqual)(_react.default.Children.map(a, c => c?.key), _react.default.Children.map(b, c => c?.key)) && (0, _fastEquals.deepEqual)(_react.default.Children.map(a, c => c?.props["data-grid"]), _react.default.Children.map(b, c => c?.props["data-grid"]));
+  return (0, _fastEquals.deepEqual)(_react.default.Children.map(a, c => c === null || c === void 0 ? void 0 : c.key), _react.default.Children.map(b, c => c === null || c === void 0 ? void 0 : c.key)) && (0, _fastEquals.deepEqual)(_react.default.Children.map(a, c => c === null || c === void 0 ? void 0 : c.props["data-grid"]), _react.default.Children.map(b, c => c === null || c === void 0 ? void 0 : c.props["data-grid"]));
 }
 
 /**
@@ -242,6 +247,8 @@ function collides(l1 /*: LayoutItem*/, l2 /*: LayoutItem*/) /*: boolean*/{
 function compact(layout /*: Layout*/, compactType /*: CompactType*/, cols /*: number*/, allowOverlap /*: ?boolean*/) /*: Layout*/{
   // Statics go in the compareWith array right away so items flow around them.
   const compareWith = getStatics(layout);
+  // We keep track of the bottom position.
+  let b = bottom(compareWith);
   // We go through the items by row and column.
   const sorted = sortLayoutItems(layout, compactType);
   // Holding for new items.
@@ -251,7 +258,8 @@ function compact(layout /*: Layout*/, compactType /*: CompactType*/, cols /*: nu
 
     // Don't move static elements
     if (!l.static) {
-      l = compactItem(compareWith, l, compactType, cols, sorted, allowOverlap);
+      l = compactItem(compareWith, l, compactType, cols, sorted, allowOverlap, b);
+      b = Math.max(b, l.y + l.h);
 
       // Add to comparison array. We only collide with items before this one.
       // Statics are already in this array.
@@ -302,14 +310,18 @@ function resolveCompactionCollision(layout /*: Layout*/, item /*: LayoutItem*/,
  * Modifies item.
  *
  */
-function compactItem(compareWith /*: Layout*/, l /*: LayoutItem*/, compactType /*: CompactType*/, cols /*: number*/, fullLayout /*: Layout*/, allowOverlap /*: ?boolean*/) /*: LayoutItem*/{
+function compactItem(compareWith /*: Layout*/, l /*: LayoutItem*/, compactType /*: CompactType*/, cols /*: number*/, fullLayout /*: Layout*/, allowOverlap /*: ?boolean*/, b /*: ?number*/) /*: LayoutItem*/{
   const compactV = compactType === "vertical";
   const compactH = compactType === "horizontal";
   if (compactV) {
     // Bottom 'y' possible is the bottom of the layout.
     // This allows you to do nice stuff like specify {y: Infinity}
     // This is here because the layout must be sorted in order to get the correct bottom `y`.
-    l.y = Math.min(bottom(compareWith), l.y);
+    if (typeof b === "number") {
+      l.y = Math.min(b, l.y);
+    } else {
+      l.y = Math.min(bottom(compareWith), l.y);
+    }
     // Move the element up as far as it can go without colliding.
     while (l.y > 0 && !getFirstCollision(compareWith, l)) {
       l.y--;
@@ -433,7 +445,7 @@ function moveElement(layout /*: Layout*/, l /*: LayoutItem*/, x /*: ?number*/, y
 
   // Short-circuit if nothing to do.
   if (l.y === y && l.x === x) return layout;
-  log(`Moving element ${l.i} to [${String(x)},${String(y)}] from [${l.x},${l.y}]`);
+  log("Moving element ".concat(l.i, " to [").concat(String(x), ",").concat(String(y), "] from [").concat(l.x, ",").concat(l.y, "]"));
   const oldX = l.x;
   const oldY = l.y;
 
@@ -463,7 +475,7 @@ function moveElement(layout /*: Layout*/, l /*: LayoutItem*/, x /*: ?number*/, y
     // If we are preventing collision but not allowing overlap, we need to
     // revert the position of this element so it goes to where it came from, rather
     // than the user's desired location.
-    log(`Collision prevented on ${l.i}, reverting.`);
+    log("Collision prevented on ".concat(l.i, ", reverting."));
     l.x = oldX;
     l.y = oldY;
     l.moved = false;
@@ -473,7 +485,7 @@ function moveElement(layout /*: Layout*/, l /*: LayoutItem*/, x /*: ?number*/, y
   // Move each item that collides away from this element.
   for (let i = 0, len = collisions.length; i < len; i++) {
     const collision = collisions[i];
-    log(`Resolving collision between ${l.i} at [${l.x},${l.y}] and ${collision.i} at [${collision.x},${collision.y}]`);
+    log("Resolving collision between ".concat(l.i, " at [").concat(l.x, ",").concat(l.y, "] and ").concat(collision.i, " at [").concat(collision.x, ",").concat(collision.y, "]"));
 
     // Short circuit so we can't infinite loop
     if (collision.moved) continue;
@@ -523,10 +535,10 @@ function moveElementAwayFromCollision(layout /*: Layout*/, collidesWith /*: Layo
 
     // No collision? If so, we can go up there; otherwise, we'll end up moving down as normal
     if (!firstCollision) {
-      log(`Doing reverse collision on ${itemToMove.i} up to [${fakeItem.x},${fakeItem.y}].`);
+      log("Doing reverse collision on ".concat(itemToMove.i, " up to [").concat(fakeItem.x, ",").concat(fakeItem.y, "]."));
       return moveElement(layout, itemToMove, compactH ? fakeItem.x : undefined, compactV ? fakeItem.y : undefined, isUserAction, preventCollision, compactType, cols);
     } else if (collisionNorth && compactV) {
-      return moveElement(layout, itemToMove, undefined, collidesWith.y + 1, isUserAction, preventCollision, compactType, cols);
+      return moveElement(layout, itemToMove, undefined, itemToMove.y + 1, isUserAction, preventCollision, compactType, cols);
     } else if (collisionNorth && compactType == null) {
       collidesWith.y = itemToMove.y;
       itemToMove.y = itemToMove.y + itemToMove.h;
@@ -650,10 +662,7 @@ function resizeItemInDirection(direction /*: ResizeHandleAxis*/, currentSize /*:
   const ordinalHandler = ordinalResizeHandlerMap[direction];
   // Shouldn't be possible given types; that said, don't fail hard
   if (!ordinalHandler) return newSize;
-  return ordinalHandler(currentSize, {
-    ...currentSize,
-    ...newSize
-  }, containerWidth);
+  return ordinalHandler(currentSize, _objectSpread(_objectSpread({}, currentSize), newSize), containerWidth);
 }
 function setTransform(_ref5 /*:: */) /*: Object*/{
   let {
@@ -663,15 +672,15 @@ function setTransform(_ref5 /*:: */) /*: Object*/{
     height
   } /*: Position*/ = _ref5 /*: Position*/;
   // Replace unitless items with px
-  const translate = `translate(${left}px,${top}px)`;
+  const translate = "translate(".concat(left, "px,").concat(top, "px)");
   return {
     transform: translate,
     WebkitTransform: translate,
     MozTransform: translate,
     msTransform: translate,
     OTransform: translate,
-    width: `${width}px`,
-    height: `${height}px`,
+    width: "".concat(width, "px"),
+    height: "".concat(height, "px"),
     position: "absolute"
   };
 }
@@ -683,10 +692,10 @@ function setTopLeft(_ref6 /*:: */) /*: Object*/{
     height
   } /*: Position*/ = _ref6 /*: Position*/;
   return {
-    top: `${top}px`,
-    left: `${left}px`,
-    width: `${width}px`,
-    height: `${height}px`,
+    top: "".concat(top, "px"),
+    left: "".concat(left, "px"),
+    width: "".concat(width, "px"),
+    height: "".concat(height, "px"),
     position: "absolute"
   };
 }
@@ -752,7 +761,7 @@ function synchronizeLayoutWithChildren(initialLayout /*: Layout*/, children /*:
   const layout /*: LayoutItem[]*/ = [];
   _react.default.Children.forEach(children, (child /*: ReactElement<any>*/) => {
     // Child may not exist
-    if (child?.key == null) return;
+    if ((child === null || child === void 0 ? void 0 : child.key) == null) return;
     const exists = getLayoutItem(initialLayout, String(child.key));
     const g = child.props["data-grid"];
     // Don't overwrite the layout item if it's already in the initial layout.
@@ -766,10 +775,9 @@ function synchronizeLayoutWithChildren(initialLayout /*: Layout*/, children /*:
           validateLayout([g], "ReactGridLayout.children");
         }
         // FIXME clone not really necessary here
-        layout.push(cloneLayoutItem({
-          ...g,
+        layout.push(cloneLayoutItem(_objectSpread(_objectSpread({}, g), {}, {
           i: child.key
-        }));
+        })));
       } else {
         // Nothing provided: ensure this is added to the bottom
         // FIXME clone not really necessary here
@@ -808,11 +816,11 @@ function validateLayout(layout /*: Layout*/) /*: void*/{
       const key = subProps[j];
       const value = item[key];
       if (typeof value !== "number" || Number.isNaN(value)) {
-        throw new Error(`ReactGridLayout: ${contextName}[${i}].${key} must be a number! Received: ${value} (${typeof value})`);
+        throw new Error("ReactGridLayout: ".concat(contextName, "[").concat(i, "].").concat(key, " must be a number! Received: ").concat(value, " (").concat(typeof value, ")"));
       }
     }
     if (typeof item.i !== "undefined" && typeof item.i !== "string") {
-      throw new Error(`ReactGridLayout: ${contextName}[${i}].i must be a string! Received: ${item.i} (${typeof item.i})`);
+      throw new Error("ReactGridLayout: ".concat(contextName, "[").concat(i, "].i must be a string! Received: ").concat(item.i, " (").concat(typeof item.i, ")"));
     }
   }
 }