react-grid-layout 2.0.0 → 2.1.1

package/dist/{chunk-4HNUMWQK.mjs → chunk-FLITZMQC.mjs}

@@ -1,3 +1,168 @@
+import { bottom, sortLayoutItems, cloneLayoutItem, getStatics, collides, getFirstCollision, cloneLayout, sortLayoutItemsByRowCol, sortLayoutItemsByColRow, correctBounds } from './chunk-AWM66AWF.mjs';
+
+// 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,
@@ -191,314 +356,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 (!layoutHasStatics && otherItem.y > item.y + item.h) break;
     if (collides(item, otherItem)) {
       resolveCompactionCollision(
         layout,
         otherItem,
         moveToCoord + item[sizeProp],
-        axis
+        axis,
+        layoutHasStatics
       );
     }
   }
@@ -507,22 +386,24 @@ function resolveCompactionCollision(layout, item, moveToCoord, axis) {
 function compactItemInternal(compareWith, l, compactType, cols, fullLayout, allowOverlap, b) {
   const compactV = compactType === "vertical";
   const compactH = compactType === "horizontal";
-  if (compactV) {
-    if (typeof b === "number") {
-      l.y = Math.min(b, l.y);
-    } else {
-      l.y = Math.min(bottom(compareWith), l.y);
-    }
-    while (l.y > 0 && !getFirstCollision(compareWith, l)) {
-      l.y--;
-    }
-  } else if (compactH) {
-    while (l.x > 0 && !getFirstCollision(compareWith, l)) {
-      l.x--;
+  if (!allowOverlap) {
+    if (compactV) {
+      if (typeof b === "number") {
+        l.y = Math.min(b, l.y);
+      } else {
+        l.y = Math.min(bottom(compareWith), l.y);
+      }
+      while (l.y > 0 && !getFirstCollision(compareWith, l)) {
+        l.y--;
+      }
+    } else if (compactH) {
+      while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+        l.x--;
+      }
     }
   }
   let collision;
-  while ((collision = getFirstCollision(compareWith, l)) !== void 0 && !(compactType === null && allowOverlap)) {
+  while ((collision = getFirstCollision(compareWith, l)) !== void 0 && !allowOverlap) {
     if (compactH) {
       resolveCompactionCollision(fullLayout, l, collision.x + collision.w, "x");
     } else {
@@ -581,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 ?? 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 (!layoutHasStatics && otherItem.y > item.y + item.h) break;
     if (collides(item, otherItem)) {
       resolveCompactionCollision2(
         layout,
         otherItem,
         moveToCoord + item[sizeProp],
-        axis
+        axis,
+        layoutHasStatics
       );
     }
   }
@@ -728,13 +611,17 @@ var horizontalOverlapCompactor = {
     return cloneLayout(layout);
   }
 };
+var noOverlapCompactor = {
+  ...noCompactor,
+  allowOverlap: true
+};
 function getCompactor(compactType, allowOverlap = false, preventCollision = false) {
   let baseCompactor;
   if (allowOverlap) {
     if (compactType === "vertical") baseCompactor = verticalOverlapCompactor;
     else if (compactType === "horizontal")
       baseCompactor = horizontalOverlapCompactor;
-    else baseCompactor = noCompactor;
+    else baseCompactor = noOverlapCompactor;
   } else {
     if (compactType === "vertical") baseCompactor = verticalCompactor;
     else if (compactType === "horizontal") baseCompactor = horizontalCompactor;
@@ -817,6 +704,6 @@ function getIndentationValue(value, breakpoint) {
   return [10, 10];
 }
 
-export { absoluteStrategy, bottom, cloneLayout, cloneLayoutItem, collides, compact, compactItem, compactItemHorizontal, compactItemVertical, correctBounds, createScaledStrategy, defaultDragConfig, defaultDropConfig, defaultGridConfig, defaultPositionStrategy, defaultResizeConfig, findOrGenerateResponsiveLayout, getAllCollisions, getBreakpointFromWidth, getColsFromBreakpoint, getCompactor, getFirstCollision, getIndentationValue, getLayoutItem, getStatics, horizontalCompactor, horizontalOverlapCompactor, modifyLayout, moveElement, moveElementAwayFromCollision, noCompactor, perc, resizeItemInDirection, resolveCompactionCollision2 as resolveCompactionCollision, setTopLeft, setTransform, sortBreakpoints, sortLayoutItems, sortLayoutItemsByColRow, sortLayoutItemsByRowCol, transformStrategy, validateLayout, verticalCompactor, verticalOverlapCompactor, withLayoutItem };
-//# sourceMappingURL=chunk-4HNUMWQK.mjs.map
-//# sourceMappingURL=chunk-4HNUMWQK.mjs.map
+export { absoluteStrategy, applyPositionConstraints, applySizeConstraints, aspectRatio, boundedX, boundedY, compact, compactItem, compactItemHorizontal, compactItemVertical, containerBounds, createScaledStrategy, defaultConstraints, defaultDragConfig, defaultDropConfig, defaultGridConfig, defaultPositionStrategy, defaultResizeConfig, findOrGenerateResponsiveLayout, getBreakpointFromWidth, getColsFromBreakpoint, getCompactor, getIndentationValue, gridBounds, horizontalCompactor, horizontalOverlapCompactor, maxSize, minMaxSize, minSize, noCompactor, noOverlapCompactor, perc, resizeItemInDirection, resolveCompactionCollision2 as resolveCompactionCollision, setTopLeft, setTransform, snapToGrid, sortBreakpoints, transformStrategy, verticalCompactor, verticalOverlapCompactor };
+//# sourceMappingURL=chunk-FLITZMQC.mjs.map
+//# sourceMappingURL=chunk-FLITZMQC.mjs.map