react-grid-layout 2.0.0 → 2.1.0

package/dist/{chunk-3WO4SAYB.js → chunk-FN6MIZ24.js}

@@ -1,5 +1,170 @@
 'use strict';
 
+var chunkBJFPTW5Q_js = require('./chunk-BJFPTW5Q.js');
+
+// src/core/constraints.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var gridBounds = {
+  name: "gridBounds",
+  constrainPosition(item, x, y, { cols, maxRows }) {
+    return {
+      x: clamp(x, 0, Math.max(0, cols - item.w)),
+      y: clamp(y, 0, Math.max(0, maxRows - item.h))
+    };
+  },
+  constrainSize(item, w, h, handle, { cols, maxRows }) {
+    const maxW = handle === "w" || handle === "nw" || handle === "sw" ? item.x + item.w : cols - item.x;
+    const maxH = handle === "n" || handle === "nw" || handle === "ne" ? item.y + item.h : maxRows - item.y;
+    return {
+      w: clamp(w, 1, Math.max(1, maxW)),
+      h: clamp(h, 1, Math.max(1, maxH))
+    };
+  }
+};
+var minMaxSize = {
+  name: "minMaxSize",
+  constrainSize(item, w, h) {
+    return {
+      w: clamp(w, item.minW ?? 1, item.maxW ?? Infinity),
+      h: clamp(h, item.minH ?? 1, item.maxH ?? Infinity)
+    };
+  }
+};
+var containerBounds = {
+  name: "containerBounds",
+  constrainPosition(item, x, y, { cols, maxRows, containerHeight, rowHeight, margin }) {
+    const visibleRows = containerHeight > 0 ? Math.floor((containerHeight + margin[1]) / (rowHeight + margin[1])) : maxRows;
+    return {
+      x: clamp(x, 0, Math.max(0, cols - item.w)),
+      y: clamp(y, 0, Math.max(0, visibleRows - item.h))
+    };
+  }
+};
+var boundedX = {
+  name: "boundedX",
+  constrainPosition(item, x, y, { cols }) {
+    return {
+      x: clamp(x, 0, Math.max(0, cols - item.w)),
+      y
+    };
+  }
+};
+var boundedY = {
+  name: "boundedY",
+  constrainPosition(item, x, y, { maxRows }) {
+    return {
+      x,
+      y: clamp(y, 0, Math.max(0, maxRows - item.h))
+    };
+  }
+};
+function aspectRatio(ratio) {
+  return {
+    name: `aspectRatio(${ratio})`,
+    constrainSize(_item, w, _h, _handle, context) {
+      const { cols, containerWidth, rowHeight, margin } = context;
+      const colWidth = (containerWidth - margin[0] * (cols - 1)) / cols;
+      const pixelWidth = colWidth * w + margin[0] * Math.max(0, w - 1);
+      const pixelHeight = pixelWidth / ratio;
+      const h = Math.max(
+        1,
+        Math.round((pixelHeight + margin[1]) / (rowHeight + margin[1]))
+      );
+      return { w, h };
+    }
+  };
+}
+function snapToGrid(stepX, stepY = stepX) {
+  if (stepX <= 0 || stepY <= 0) {
+    throw new Error(
+      `snapToGrid: step values must be positive (got stepX=${stepX}, stepY=${stepY})`
+    );
+  }
+  return {
+    name: `snapToGrid(${stepX}, ${stepY})`,
+    constrainPosition(_item, x, y) {
+      return {
+        x: Math.round(x / stepX) * stepX,
+        y: Math.round(y / stepY) * stepY
+      };
+    }
+  };
+}
+function minSize(minW, minH) {
+  return {
+    name: `minSize(${minW}, ${minH})`,
+    constrainSize(_item, w, h) {
+      return {
+        w: Math.max(minW, w),
+        h: Math.max(minH, h)
+      };
+    }
+  };
+}
+function maxSize(maxW, maxH) {
+  return {
+    name: `maxSize(${maxW}, ${maxH})`,
+    constrainSize(_item, w, h) {
+      return {
+        w: Math.min(maxW, w),
+        h: Math.min(maxH, h)
+      };
+    }
+  };
+}
+var defaultConstraints = [gridBounds, minMaxSize];
+function applyPositionConstraints(constraints, item, x, y, context) {
+  let result = { x, y };
+  for (const constraint of constraints) {
+    if (constraint.constrainPosition) {
+      result = constraint.constrainPosition(item, result.x, result.y, context);
+    }
+  }
+  if (item.constraints) {
+    for (const constraint of item.constraints) {
+      if (constraint.constrainPosition) {
+        result = constraint.constrainPosition(
+          item,
+          result.x,
+          result.y,
+          context
+        );
+      }
+    }
+  }
+  return result;
+}
+function applySizeConstraints(constraints, item, w, h, handle, context) {
+  let result = { w, h };
+  for (const constraint of constraints) {
+    if (constraint.constrainSize) {
+      result = constraint.constrainSize(
+        item,
+        result.w,
+        result.h,
+        handle,
+        context
+      );
+    }
+  }
+  if (item.constraints) {
+    for (const constraint of item.constraints) {
+      if (constraint.constrainSize) {
+        result = constraint.constrainSize(
+          item,
+          result.w,
+          result.h,
+          handle,
+          context
+        );
+      }
+    }
+  }
+  return result;
+}
+
 // src/core/position.ts
 function setTransform({
   top,
@@ -193,314 +358,28 @@ var defaultDropConfig = {
   defaultItem: { w: 1, h: 1 }
 };
 
-// src/core/collision.ts
-function collides(l1, l2) {
-  if (l1.i === l2.i) return false;
-  if (l1.x + l1.w <= l2.x) return false;
-  if (l1.x >= l2.x + l2.w) return false;
-  if (l1.y + l1.h <= l2.y) return false;
-  if (l1.y >= l2.y + l2.h) return false;
-  return true;
-}
-function getFirstCollision(layout, layoutItem) {
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item !== void 0 && collides(item, layoutItem)) {
-      return item;
-    }
-  }
-  return void 0;
-}
-function getAllCollisions(layout, layoutItem) {
-  return layout.filter((l) => collides(l, layoutItem));
-}
-
-// src/core/sort.ts
-function sortLayoutItems(layout, compactType) {
-  if (compactType === "horizontal") {
-    return sortLayoutItemsByColRow(layout);
-  }
-  if (compactType === "vertical") {
-    return sortLayoutItemsByRowCol(layout);
-  }
-  return [...layout];
-}
-function sortLayoutItemsByRowCol(layout) {
-  return [...layout].sort((a, b) => {
-    if (a.y !== b.y) {
-      return a.y - b.y;
-    }
-    return a.x - b.x;
-  });
-}
-function sortLayoutItemsByColRow(layout) {
-  return [...layout].sort((a, b) => {
-    if (a.x !== b.x) {
-      return a.x - b.x;
-    }
-    return a.y - b.y;
-  });
-}
-
-// src/core/layout.ts
-function bottom(layout) {
-  let max = 0;
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item !== void 0) {
-      const bottomY = item.y + item.h;
-      if (bottomY > max) max = bottomY;
-    }
-  }
-  return max;
-}
-function getLayoutItem(layout, id) {
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item !== void 0 && item.i === id) {
-      return item;
-    }
-  }
-  return void 0;
-}
-function getStatics(layout) {
-  return layout.filter((l) => l.static === true);
-}
-function cloneLayoutItem(layoutItem) {
-  return {
-    i: layoutItem.i,
-    x: layoutItem.x,
-    y: layoutItem.y,
-    w: layoutItem.w,
-    h: layoutItem.h,
-    minW: layoutItem.minW,
-    maxW: layoutItem.maxW,
-    minH: layoutItem.minH,
-    maxH: layoutItem.maxH,
-    moved: Boolean(layoutItem.moved),
-    static: Boolean(layoutItem.static),
-    isDraggable: layoutItem.isDraggable,
-    isResizable: layoutItem.isResizable,
-    resizeHandles: layoutItem.resizeHandles,
-    isBounded: layoutItem.isBounded
-  };
-}
-function cloneLayout(layout) {
-  const newLayout = new Array(layout.length);
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item !== void 0) {
-      newLayout[i] = cloneLayoutItem(item);
-    }
-  }
-  return newLayout;
-}
-function modifyLayout(layout, layoutItem) {
-  const newLayout = new Array(layout.length);
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item !== void 0) {
-      if (layoutItem.i === item.i) {
-        newLayout[i] = layoutItem;
-      } else {
-        newLayout[i] = item;
-      }
-    }
-  }
-  return newLayout;
-}
-function withLayoutItem(layout, itemKey, cb) {
-  let item = getLayoutItem(layout, itemKey);
-  if (!item) {
-    return [[...layout], null];
-  }
-  item = cb(cloneLayoutItem(item));
-  const newLayout = modifyLayout(layout, item);
-  return [newLayout, item];
-}
-function correctBounds(layout, bounds) {
-  const collidesWith = getStatics(layout);
-  for (let i = 0; i < layout.length; i++) {
-    const l = layout[i];
-    if (l === void 0) continue;
-    if (l.x + l.w > bounds.cols) {
-      l.x = bounds.cols - l.w;
-    }
-    if (l.x < 0) {
-      l.x = 0;
-      l.w = bounds.cols;
-    }
-    if (!l.static) {
-      collidesWith.push(l);
-    } else {
-      while (getFirstCollision(collidesWith, l)) {
-        l.y++;
-      }
-    }
-  }
-  return layout;
-}
-function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType, cols, allowOverlap) {
-  if (l.static && l.isDraggable !== true) {
-    return [...layout];
-  }
-  if (l.y === y && l.x === x) {
-    return [...layout];
-  }
-  const oldX = l.x;
-  const oldY = l.y;
-  if (typeof x === "number") l.x = x;
-  if (typeof y === "number") l.y = y;
-  l.moved = true;
-  let sorted = sortLayoutItems(layout, compactType);
-  const movingUp = compactType === "vertical" && typeof y === "number" ? oldY >= y : compactType === "horizontal" && typeof x === "number" ? oldX >= x : false;
-  if (movingUp) {
-    sorted = sorted.reverse();
-  }
-  const collisions = getAllCollisions(sorted, l);
-  const hasCollisions = collisions.length > 0;
-  if (hasCollisions && allowOverlap) {
-    return cloneLayout(layout);
-  }
-  if (hasCollisions && preventCollision) {
-    l.x = oldX;
-    l.y = oldY;
-    l.moved = false;
-    return layout;
-  }
-  let resultLayout = [...layout];
-  for (let i = 0; i < collisions.length; i++) {
-    const collision = collisions[i];
-    if (collision === void 0) continue;
-    if (collision.moved) continue;
-    if (collision.static) {
-      resultLayout = moveElementAwayFromCollision(
-        resultLayout,
-        collision,
-        l,
-        isUserAction,
-        compactType);
-    } else {
-      resultLayout = moveElementAwayFromCollision(
-        resultLayout,
-        l,
-        collision,
-        isUserAction,
-        compactType);
-    }
-  }
-  return resultLayout;
-}
-function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType, cols) {
-  const compactH = compactType === "horizontal";
-  const compactV = compactType === "vertical";
-  const preventCollision = collidesWith.static;
-  if (isUserAction) {
-    isUserAction = false;
-    const fakeItem = {
-      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,
-      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,
-      w: itemToMove.w,
-      h: itemToMove.h,
-      i: "-1"
-    };
-    const firstCollision = getFirstCollision(layout, fakeItem);
-    const collisionNorth = firstCollision !== void 0 && firstCollision.y + firstCollision.h > collidesWith.y;
-    const collisionWest = firstCollision !== void 0 && collidesWith.x + collidesWith.w > firstCollision.x;
-    if (!firstCollision) {
-      return moveElement(
-        layout,
-        itemToMove,
-        compactH ? fakeItem.x : void 0,
-        compactV ? fakeItem.y : void 0,
-        isUserAction,
-        preventCollision,
-        compactType);
-    }
-    if (collisionNorth && compactV) {
-      return moveElement(
-        layout,
-        itemToMove,
-        void 0,
-        itemToMove.y + 1,
-        isUserAction,
-        preventCollision,
-        compactType);
-    }
-    if (collisionNorth && compactType === null) {
-      collidesWith.y = itemToMove.y;
-      itemToMove.y = itemToMove.y + itemToMove.h;
-      return [...layout];
-    }
-    if (collisionWest && compactH) {
-      return moveElement(
-        layout,
-        collidesWith,
-        itemToMove.x,
-        void 0,
-        isUserAction,
-        preventCollision,
-        compactType);
-    }
-  }
-  const newX = compactH ? itemToMove.x + 1 : void 0;
-  const newY = compactV ? itemToMove.y + 1 : void 0;
-  if (newX === void 0 && newY === void 0) {
-    return [...layout];
-  }
-  return moveElement(
-    layout,
-    itemToMove,
-    newX,
-    newY,
-    isUserAction,
-    preventCollision,
-    compactType);
-}
-function validateLayout(layout, contextName = "Layout") {
-  const requiredProps = ["x", "y", "w", "h"];
-  if (!Array.isArray(layout)) {
-    throw new Error(`${contextName} must be an array!`);
-  }
-  for (let i = 0; i < layout.length; i++) {
-    const item = layout[i];
-    if (item === void 0) continue;
-    for (const key of requiredProps) {
-      const value = item[key];
-      if (typeof value !== "number" || Number.isNaN(value)) {
-        throw new Error(
-          `ReactGridLayout: ${contextName}[${i}].${key} must be a number! Received: ${String(value)} (${typeof value})`
-        );
-      }
-    }
-    if (item.i !== void 0 && typeof item.i !== "string") {
-      throw new Error(
-        `ReactGridLayout: ${contextName}[${i}].i must be a string! Received: ${String(item.i)} (${typeof item.i})`
-      );
-    }
-  }
-}
-
 // src/core/compact-compat.ts
 function getStatics2(layout) {
   return layout.filter((l) => l.static);
 }
 var heightWidth = { x: "w", y: "h" };
-function resolveCompactionCollision(layout, item, moveToCoord, axis) {
+function resolveCompactionCollision(layout, item, moveToCoord, axis, hasStatics) {
   const sizeProp = heightWidth[axis];
   item[axis] += 1;
   const itemIndex = layout.findIndex((l) => l.i === item.i);
+  const layoutHasStatics = hasStatics ?? getStatics2(layout).length > 0;
   for (let i = itemIndex + 1; i < layout.length; i++) {
     const otherItem = layout[i];
     if (otherItem === void 0) continue;
     if (otherItem.static) continue;
-    if (otherItem.y > item.y + item.h) break;
-    if (collides(item, otherItem)) {
+    if (!layoutHasStatics && otherItem.y > item.y + item.h) break;
+    if (chunkBJFPTW5Q_js.collides(item, otherItem)) {
       resolveCompactionCollision(
         layout,
         otherItem,
         moveToCoord + item[sizeProp],
-        axis
+        axis,
+        layoutHasStatics
       );
     }
   }
@@ -513,18 +392,18 @@ function compactItemInternal(compareWith, l, compactType, cols, fullLayout, allo
     if (typeof b === "number") {
       l.y = Math.min(b, l.y);
     } else {
-      l.y = Math.min(bottom(compareWith), l.y);
+      l.y = Math.min(chunkBJFPTW5Q_js.bottom(compareWith), l.y);
     }
-    while (l.y > 0 && !getFirstCollision(compareWith, l)) {
+    while (l.y > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
       l.y--;
     }
   } else if (compactH) {
-    while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+    while (l.x > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
       l.x--;
     }
   }
   let collision;
-  while ((collision = getFirstCollision(compareWith, l)) !== void 0 && !(compactType === null && allowOverlap)) {
+  while ((collision = chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) !== void 0 && !(compactType === null && allowOverlap)) {
     if (compactH) {
       resolveCompactionCollision(fullLayout, l, collision.x + collision.w, "x");
     } else {
@@ -533,7 +412,7 @@ function compactItemInternal(compareWith, l, compactType, cols, fullLayout, allo
     if (compactH && l.x + l.w > cols) {
       l.x = cols - l.w;
       l.y++;
-      while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+      while (l.x > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
         l.x--;
       }
     }
@@ -544,13 +423,13 @@ function compactItemInternal(compareWith, l, compactType, cols, fullLayout, allo
 }
 function compact(layout, compactType, cols, allowOverlap) {
   const compareWith = getStatics2(layout);
-  let b = bottom(compareWith);
-  const sorted = sortLayoutItems(layout, compactType);
+  let b = chunkBJFPTW5Q_js.bottom(compareWith);
+  const sorted = chunkBJFPTW5Q_js.sortLayoutItems(layout, compactType);
   const out = new Array(layout.length);
   for (let i = 0; i < sorted.length; i++) {
     const sortedItem = sorted[i];
     if (sortedItem === void 0) continue;
-    let l = cloneLayoutItem(sortedItem);
+    let l = chunkBJFPTW5Q_js.cloneLayoutItem(sortedItem);
     if (!l.static) {
       l = compactItemInternal(
         compareWith,
@@ -573,7 +452,7 @@ function compact(layout, compactType, cols, allowOverlap) {
 function compactItem(compareWith, l, compactType, cols, fullLayout, allowOverlap, maxY) {
   return compactItemInternal(
     compareWith,
-    cloneLayoutItem(l),
+    chunkBJFPTW5Q_js.cloneLayoutItem(l),
     compactType,
     cols,
     fullLayout,
@@ -583,21 +462,23 @@ function compactItem(compareWith, l, compactType, cols, fullLayout, allowOverlap
 }
 
 // src/core/compactors.ts
-function resolveCompactionCollision2(layout, item, moveToCoord, axis) {
+function resolveCompactionCollision2(layout, item, moveToCoord, axis, hasStatics) {
   const sizeProp = axis === "x" ? "w" : "h";
   item[axis] += 1;
   const itemIndex = layout.findIndex((l) => l.i === item.i);
+  const layoutHasStatics = hasStatics ?? chunkBJFPTW5Q_js.getStatics(layout).length > 0;
   for (let i = itemIndex + 1; i < layout.length; i++) {
     const otherItem = layout[i];
     if (otherItem === void 0) continue;
     if (otherItem.static) continue;
-    if (otherItem.y > item.y + item.h) break;
-    if (collides(item, otherItem)) {
+    if (!layoutHasStatics && otherItem.y > item.y + item.h) break;
+    if (chunkBJFPTW5Q_js.collides(item, otherItem)) {
       resolveCompactionCollision2(
         layout,
         otherItem,
         moveToCoord + item[sizeProp],
-        axis
+        axis,
+        layoutHasStatics
       );
     }
   }
@@ -605,27 +486,27 @@ function resolveCompactionCollision2(layout, item, moveToCoord, axis) {
 }
 function compactItemVertical(compareWith, l, fullLayout, maxY) {
   l.y = Math.min(maxY, l.y);
-  while (l.y > 0 && !getFirstCollision(compareWith, l)) {
+  while (l.y > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
     l.y--;
   }
   let collision;
-  while ((collision = getFirstCollision(compareWith, l)) !== void 0) {
+  while ((collision = chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) !== void 0) {
     resolveCompactionCollision2(fullLayout, l, collision.y + collision.h, "y");
   }
   l.y = Math.max(l.y, 0);
   return l;
 }
 function compactItemHorizontal(compareWith, l, cols, fullLayout) {
-  while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+  while (l.x > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
     l.x--;
   }
   let collision;
-  while ((collision = getFirstCollision(compareWith, l)) !== void 0) {
+  while ((collision = chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) !== void 0) {
     resolveCompactionCollision2(fullLayout, l, collision.x + collision.w, "x");
     if (l.x + l.w > cols) {
       l.x = cols - l.w;
       l.y++;
-      while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+      while (l.x > 0 && !chunkBJFPTW5Q_js.getFirstCollision(compareWith, l)) {
         l.x--;
       }
     }
@@ -637,14 +518,14 @@ var verticalCompactor = {
   type: "vertical",
   allowOverlap: false,
   compact(layout, _cols) {
-    const compareWith = getStatics(layout);
-    let maxY = bottom(compareWith);
-    const sorted = sortLayoutItemsByRowCol(layout);
+    const compareWith = chunkBJFPTW5Q_js.getStatics(layout);
+    let maxY = chunkBJFPTW5Q_js.bottom(compareWith);
+    const sorted = chunkBJFPTW5Q_js.sortLayoutItemsByRowCol(layout);
     const out = new Array(layout.length);
     for (let i = 0; i < sorted.length; i++) {
       const sortedItem = sorted[i];
       if (sortedItem === void 0) continue;
-      let l = cloneLayoutItem(sortedItem);
+      let l = chunkBJFPTW5Q_js.cloneLayoutItem(sortedItem);
       if (!l.static) {
         l = compactItemVertical(compareWith, l, sorted, maxY);
         maxY = Math.max(maxY, l.y + l.h);
@@ -657,7 +538,7 @@ var verticalCompactor = {
     return out;
   },
   onMove(layout, item, x, y, _cols) {
-    const newLayout = cloneLayout(layout);
+    const newLayout = chunkBJFPTW5Q_js.cloneLayout(layout);
     const movedItem = newLayout.find((l) => l.i === item.i);
     if (movedItem) {
       movedItem.x = x;
@@ -671,13 +552,13 @@ var horizontalCompactor = {
   type: "horizontal",
   allowOverlap: false,
   compact(layout, cols) {
-    const compareWith = getStatics(layout);
-    const sorted = sortLayoutItemsByColRow(layout);
+    const compareWith = chunkBJFPTW5Q_js.getStatics(layout);
+    const sorted = chunkBJFPTW5Q_js.sortLayoutItemsByColRow(layout);
     const out = new Array(layout.length);
     for (let i = 0; i < sorted.length; i++) {
       const sortedItem = sorted[i];
       if (sortedItem === void 0) continue;
-      let l = cloneLayoutItem(sortedItem);
+      let l = chunkBJFPTW5Q_js.cloneLayoutItem(sortedItem);
       if (!l.static) {
         l = compactItemHorizontal(compareWith, l, cols, sorted);
         compareWith.push(l);
@@ -689,7 +570,7 @@ var horizontalCompactor = {
     return out;
   },
   onMove(layout, item, x, y, _cols) {
-    const newLayout = cloneLayout(layout);
+    const newLayout = chunkBJFPTW5Q_js.cloneLayout(layout);
     const movedItem = newLayout.find((l) => l.i === item.i);
     if (movedItem) {
       movedItem.x = x;
@@ -703,10 +584,10 @@ var noCompactor = {
   type: null,
   allowOverlap: false,
   compact(layout, _cols) {
-    return cloneLayout(layout);
+    return chunkBJFPTW5Q_js.cloneLayout(layout);
   },
   onMove(layout, item, x, y, _cols) {
-    const newLayout = cloneLayout(layout);
+    const newLayout = chunkBJFPTW5Q_js.cloneLayout(layout);
     const movedItem = newLayout.find((l) => l.i === item.i);
     if (movedItem) {
       movedItem.x = x;
@@ -720,14 +601,14 @@ var verticalOverlapCompactor = {
   ...verticalCompactor,
   allowOverlap: true,
   compact(layout, _cols) {
-    return cloneLayout(layout);
+    return chunkBJFPTW5Q_js.cloneLayout(layout);
   }
 };
 var horizontalOverlapCompactor = {
   ...horizontalCompactor,
   allowOverlap: true,
   compact(layout, _cols) {
-    return cloneLayout(layout);
+    return chunkBJFPTW5Q_js.cloneLayout(layout);
   }
 };
 function getCompactor(compactType, allowOverlap = false, preventCollision = false) {
@@ -781,7 +662,7 @@ function getColsFromBreakpoint(breakpoint, cols) {
 function findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBreakpoint, cols, compactType) {
   const existingLayout = layouts[breakpoint];
   if (existingLayout) {
-    return cloneLayout(existingLayout);
+    return chunkBJFPTW5Q_js.cloneLayout(existingLayout);
   }
   let layout = layouts[lastBreakpoint];
   const breakpointsSorted = sortBreakpoints(breakpoints);
@@ -797,8 +678,8 @@ function findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBr
       break;
     }
   }
-  const clonedLayout = cloneLayout(layout || []);
-  return compact(correctBounds(clonedLayout, { cols }), compactType, cols);
+  const clonedLayout = chunkBJFPTW5Q_js.cloneLayout(layout || []);
+  return compact(chunkBJFPTW5Q_js.correctBounds(clonedLayout, { cols }), compactType, cols);
 }
 function getIndentationValue(value, breakpoint) {
   if (Array.isArray(value)) {
@@ -820,49 +701,44 @@ function getIndentationValue(value, breakpoint) {
 }
 
 exports.absoluteStrategy = absoluteStrategy;
-exports.bottom = bottom;
-exports.cloneLayout = cloneLayout;
-exports.cloneLayoutItem = cloneLayoutItem;
-exports.collides = collides;
+exports.applyPositionConstraints = applyPositionConstraints;
+exports.applySizeConstraints = applySizeConstraints;
+exports.aspectRatio = aspectRatio;
+exports.boundedX = boundedX;
+exports.boundedY = boundedY;
 exports.compact = compact;
 exports.compactItem = compactItem;
 exports.compactItemHorizontal = compactItemHorizontal;
 exports.compactItemVertical = compactItemVertical;
-exports.correctBounds = correctBounds;
+exports.containerBounds = containerBounds;
 exports.createScaledStrategy = createScaledStrategy;
+exports.defaultConstraints = defaultConstraints;
 exports.defaultDragConfig = defaultDragConfig;
 exports.defaultDropConfig = defaultDropConfig;
 exports.defaultGridConfig = defaultGridConfig;
 exports.defaultPositionStrategy = defaultPositionStrategy;
 exports.defaultResizeConfig = defaultResizeConfig;
 exports.findOrGenerateResponsiveLayout = findOrGenerateResponsiveLayout;
-exports.getAllCollisions = getAllCollisions;
 exports.getBreakpointFromWidth = getBreakpointFromWidth;
 exports.getColsFromBreakpoint = getColsFromBreakpoint;
 exports.getCompactor = getCompactor;
-exports.getFirstCollision = getFirstCollision;
 exports.getIndentationValue = getIndentationValue;
-exports.getLayoutItem = getLayoutItem;
-exports.getStatics = getStatics;
+exports.gridBounds = gridBounds;
 exports.horizontalCompactor = horizontalCompactor;
 exports.horizontalOverlapCompactor = horizontalOverlapCompactor;
-exports.modifyLayout = modifyLayout;
-exports.moveElement = moveElement;
-exports.moveElementAwayFromCollision = moveElementAwayFromCollision;
+exports.maxSize = maxSize;
+exports.minMaxSize = minMaxSize;
+exports.minSize = minSize;
 exports.noCompactor = noCompactor;
 exports.perc = perc;
 exports.resizeItemInDirection = resizeItemInDirection;
 exports.resolveCompactionCollision = resolveCompactionCollision2;
 exports.setTopLeft = setTopLeft;
 exports.setTransform = setTransform;
+exports.snapToGrid = snapToGrid;
 exports.sortBreakpoints = sortBreakpoints;
-exports.sortLayoutItems = sortLayoutItems;
-exports.sortLayoutItemsByColRow = sortLayoutItemsByColRow;
-exports.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;
 exports.transformStrategy = transformStrategy;
-exports.validateLayout = validateLayout;
 exports.verticalCompactor = verticalCompactor;
 exports.verticalOverlapCompactor = verticalOverlapCompactor;
-exports.withLayoutItem = withLayoutItem;
-//# sourceMappingURL=chunk-3WO4SAYB.js.map
-//# sourceMappingURL=chunk-3WO4SAYB.js.map
+//# sourceMappingURL=chunk-FN6MIZ24.js.map
+//# sourceMappingURL=chunk-FN6MIZ24.js.map