@cube-dev/ui-kit 0.143.0 → 0.144.0

package/dist/components/layout/Board/grid-core/calculate.js

@@ -0,0 +1,90 @@
+/** @license MIT | @cube-dev/ui-kit v0.144.0 | Cube Dev Team */
+//#region src/components/layout/Board/grid-core/calculate.ts
+/** Calculate the width of a single grid column in pixels. */
+function calcGridColWidth(positionParams) {
+	const { margin, containerPadding, containerWidth, cols } = positionParams;
+	return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;
+}
+/**
+* Calculate the pixel size for a grid unit dimension (width or height).
+*/
+function calcGridItemWHPx(gridUnits, colOrRowSize, marginPx) {
+	if (!Number.isFinite(gridUnits)) return gridUnits;
+	return Math.round(colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx);
+}
+/**
+* Calculate pixel position for a grid item. Returns left, top, width, height.
+*/
+function calcGridItemPosition(positionParams, x, y, w, h, dragPosition, resizePosition) {
+	const { margin, containerPadding, rowHeight } = positionParams;
+	const colWidth = calcGridColWidth(positionParams);
+	let width;
+	let height;
+	let top;
+	let left;
+	if (resizePosition) {
+		width = Math.round(resizePosition.width);
+		height = Math.round(resizePosition.height);
+	} else {
+		width = calcGridItemWHPx(w, colWidth, margin[0]);
+		height = calcGridItemWHPx(h, rowHeight, margin[1]);
+	}
+	if (dragPosition) {
+		top = Math.round(dragPosition.top);
+		left = Math.round(dragPosition.left);
+	} else if (resizePosition) {
+		top = Math.round(resizePosition.top);
+		left = Math.round(resizePosition.left);
+	} else {
+		top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);
+		left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);
+	}
+	if (!dragPosition && !resizePosition) {
+		if (Number.isFinite(w)) {
+			const actualMarginRight = Math.round((colWidth + margin[0]) * (x + w) + containerPadding[0]) - left - width;
+			if (actualMarginRight !== margin[0]) width += actualMarginRight - margin[0];
+		}
+		if (Number.isFinite(h)) {
+			const actualMarginBottom = Math.round((rowHeight + margin[1]) * (y + h) + containerPadding[1]) - top - height;
+			if (actualMarginBottom !== margin[1]) height += actualMarginBottom - margin[1];
+		}
+	}
+	return {
+		top,
+		left,
+		width,
+		height
+	};
+}
+/** Translate pixel coordinates to grid units without clamping. */
+function calcXYRaw(positionParams, top, left) {
+	const { margin, containerPadding, rowHeight } = positionParams;
+	const colWidth = calcGridColWidth(positionParams);
+	return {
+		x: Math.round((left - containerPadding[0]) / (colWidth + margin[0])),
+		y: Math.round((top - containerPadding[1]) / (rowHeight + margin[1]))
+	};
+}
+/** Calculate grid units from pixel dimensions (clamped by handle direction). */
+function calcWH(positionParams, width, height, x, y, handle) {
+	const { margin, maxRows, cols, rowHeight } = positionParams;
+	const colWidth = calcGridColWidth(positionParams);
+	const w = Math.round((width + margin[0]) / (colWidth + margin[0]));
+	const h = Math.round((height + margin[1]) / (rowHeight + margin[1]));
+	let _w = clamp(w, 0, cols - x);
+	let _h = clamp(h, 0, maxRows - y);
+	if (handle === "sw" || handle === "w" || handle === "nw") _w = clamp(w, 0, cols);
+	if (handle === "nw" || handle === "n" || handle === "ne") _h = clamp(h, 0, maxRows);
+	return {
+		w: _w,
+		h: _h
+	};
+}
+/** Clamp a number between bounds. */
+function clamp(num, lowerBound, upperBound) {
+	return Math.max(Math.min(num, upperBound), lowerBound);
+}
+
+//#endregion
+export { calcGridColWidth, calcGridItemPosition, calcWH, calcXYRaw, clamp };
+//# sourceMappingURL=calculate.js.map

package/dist/components/layout/Board/grid-core/calculate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/calculate.ts"],"sourcesContent":["/**\n * Grid calculation utilities.\n *\n * Vendored from react-grid-layout v2 (`src/core/calculate.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * These functions convert between grid units and pixel positions.\n */\n\nimport type { Position, ResizeHandleAxis } from './types';\n\n/** Parameters needed for position calculations. */\nexport interface PositionParams {\n  readonly margin: readonly [number, number];\n  readonly containerPadding: readonly [number, number];\n  readonly containerWidth: number;\n  readonly cols: number;\n  readonly rowHeight: number;\n  readonly maxRows: number;\n}\n\n// ============================================================================\n// Grid Column/Row Calculations\n// ============================================================================\n\n/** Calculate the width of a single grid column in pixels. */\nexport function calcGridColWidth(positionParams: PositionParams): number {\n  const { margin, containerPadding, containerWidth, cols } = positionParams;\n  return (\n    (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols\n  );\n}\n\n/**\n * Calculate the pixel size for a grid unit dimension (width or height).\n */\nexport function calcGridItemWHPx(\n  gridUnits: number,\n  colOrRowSize: number,\n  marginPx: number,\n): number {\n  // 0 * Infinity === NaN, which causes problems with resize constraints\n  if (!Number.isFinite(gridUnits)) return gridUnits;\n  return Math.round(\n    colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx,\n  );\n}\n\n// ============================================================================\n// Position Calculations\n// ============================================================================\n\n/**\n * Calculate pixel position for a grid item. Returns left, top, width, height.\n */\nexport function calcGridItemPosition(\n  positionParams: PositionParams,\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n  dragPosition?: { top: number; left: number } | null,\n  resizePosition?: {\n    top: number;\n    left: number;\n    height: number;\n    width: number;\n  } | null,\n): Position {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let width: number;\n  let height: number;\n  let top: number;\n  let left: number;\n\n  // If resizing, use the exact width and height from resize callbacks\n  if (resizePosition) {\n    width = Math.round(resizePosition.width);\n    height = Math.round(resizePosition.height);\n  } else {\n    width = calcGridItemWHPx(w, colWidth, margin[0]);\n    height = calcGridItemWHPx(h, rowHeight, margin[1]);\n  }\n\n  // If dragging, use the exact left/top from drag callbacks\n  if (dragPosition) {\n    top = Math.round(dragPosition.top);\n    left = Math.round(dragPosition.left);\n  } else if (resizePosition) {\n    top = Math.round(resizePosition.top);\n    left = Math.round(resizePosition.left);\n  } else {\n    top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);\n    left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);\n  }\n\n  // When not dragging or resizing, fix margin inconsistencies caused by\n  // rounding by comparing where the next sibling would start.\n  if (!dragPosition && !resizePosition) {\n    if (Number.isFinite(w)) {\n      const siblingLeft = Math.round(\n        (colWidth + margin[0]) * (x + w) + containerPadding[0],\n      );\n      const actualMarginRight = siblingLeft - left - width;\n      if (actualMarginRight !== margin[0]) {\n        width += actualMarginRight - margin[0];\n      }\n    }\n\n    if (Number.isFinite(h)) {\n      const siblingTop = Math.round(\n        (rowHeight + margin[1]) * (y + h) + containerPadding[1],\n      );\n      const actualMarginBottom = siblingTop - top - height;\n      if (actualMarginBottom !== margin[1]) {\n        height += actualMarginBottom - margin[1];\n      }\n    }\n  }\n\n  return { top, left, width, height };\n}\n\n/** Translate pixel coordinates to grid units (clamped). */\nexport function calcXY(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n  w: number,\n  h: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, cols, rowHeight, maxRows } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  let y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  x = clamp(x, 0, cols - w);\n  y = clamp(y, 0, maxRows - h);\n\n  return { x, y };\n}\n\n/** Translate pixel coordinates to grid units without clamping. */\nexport function calcXYRaw(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  const y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  return { x, y };\n}\n\n/** Calculate grid units from pixel dimensions (clamped by handle direction). */\nexport function calcWH(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n  x: number,\n  y: number,\n  handle: ResizeHandleAxis,\n): { w: number; h: number } {\n  const { margin, maxRows, cols, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.round((width + margin[0]) / (colWidth + margin[0]));\n  const h = Math.round((height + margin[1]) / (rowHeight + margin[1]));\n\n  let _w = clamp(w, 0, cols - x);\n  let _h = clamp(h, 0, maxRows - y);\n\n  // West handles can resize to full width\n  if (handle === 'sw' || handle === 'w' || handle === 'nw') {\n    _w = clamp(w, 0, cols);\n  }\n\n  // North handles can resize to full height\n  if (handle === 'nw' || handle === 'n' || handle === 'ne') {\n    _h = clamp(h, 0, maxRows);\n  }\n\n  return { w: _w, h: _h };\n}\n\n/** Calculate grid units from pixel dimensions without clamping (min 1). */\nexport function calcWHRaw(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n): { w: number; h: number } {\n  const { margin, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.max(\n    1,\n    Math.round((width + margin[0]) / (colWidth + margin[0])),\n  );\n  const h = Math.max(\n    1,\n    Math.round((height + margin[1]) / (rowHeight + margin[1])),\n  );\n\n  return { w, h };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/** Clamp a number between bounds. */\nexport function clamp(\n  num: number,\n  lowerBound: number,\n  upperBound: number,\n): number {\n  return Math.max(Math.min(num, upperBound), lowerBound);\n}\n"],"mappings":"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"}

package/dist/components/layout/Board/grid-core/collision.js

@@ -0,0 +1,35 @@
+/** @license MIT | @cube-dev/ui-kit v0.144.0 | Cube Dev Team */
+//#region src/components/layout/Board/grid-core/collision.ts
+/**
+* Check if two layout items collide (overlap).
+*
+* Two items collide if their bounding boxes overlap and they are not the same
+* item.
+*/
+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;
+}
+/**
+* Find the first item in the layout that collides with the given item.
+*/
+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;
+	}
+}
+/**
+* Find all items in the layout that collide with the given item.
+*/
+function getAllCollisions(layout, layoutItem) {
+	return layout.filter((l) => collides(l, layoutItem));
+}
+
+//#endregion
+export { collides, getAllCollisions, getFirstCollision };
+//# sourceMappingURL=collision.js.map

package/dist/components/layout/Board/grid-core/collision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/collision.ts"],"sourcesContent":["/**\n * Collision detection utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/collision.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * Check if two layout items collide (overlap).\n *\n * Two items collide if their bounding boxes overlap and they are not the same\n * item.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  // Same element - can't collide with itself\n  if (l1.i === l2.i) return false;\n\n  // Check if bounding boxes don't overlap (any gap means no collision)\n  if (l1.x + l1.w <= l2.x) return false; // l1 is completely left of l2\n  if (l1.x >= l2.x + l2.w) return false; // l1 is completely right of l2\n  if (l1.y + l1.h <= l2.y) return false; // l1 is completely above l2\n  if (l1.y >= l2.y + l2.h) return false; // l1 is completely below l2\n\n  // Bounding boxes overlap\n  return true;\n}\n\n/**\n * Find the first item in the layout that collides with the given item.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && collides(item, layoutItem)) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Find all items in the layout that collide with the given item.\n */\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => collides(l, layoutItem));\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,SAAS,IAAgB,IAAyB;AAEhE,KAAI,GAAG,MAAM,GAAG,EAAG,QAAO;AAG1B,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAGhC,QAAO;;;;;AAMT,SAAgB,kBACd,QACA,YACwB;AACxB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,UAAa,SAAS,MAAM,WAAW,CAClD,QAAO;;;;;;AASb,SAAgB,iBACd,QACA,YACc;AACd,QAAO,OAAO,QAAQ,MAAuB,SAAS,GAAG,WAAW,CAAC"}

package/dist/components/layout/Board/grid-core/compactors.d.ts

@@ -0,0 +1,23 @@
+
+import { CompactType, Compactor } from "./types.js";
+
+//#region src/components/layout/Board/grid-core/compactors.d.ts
+/**
+ * Vertical compactor - moves items up to fill gaps. Default compaction mode.
+ */
+declare const verticalCompactor: Compactor;
+/**
+ * Horizontal compactor - moves items left to fill gaps.
+ */
+declare const horizontalCompactor: Compactor;
+/**
+ * No compaction - items stay where placed (free-form layouts).
+ */
+declare const noCompactor: Compactor;
+/**
+ * Get a compactor by type (convenience for the string-based compactType API).
+ */
+declare function getCompactor(compactType: CompactType, allowOverlap?: boolean, preventCollision?: boolean): Compactor;
+//#endregion
+export { getCompactor, horizontalCompactor, noCompactor, verticalCompactor };
+//# sourceMappingURL=compactors.d.ts.map

package/dist/components/layout/Board/grid-core/compactors.js

@@ -0,0 +1,166 @@
+/** @license MIT | @cube-dev/ui-kit v0.144.0 | Cube Dev Team */
+import { collides, getFirstCollision } from "./collision.js";
+import { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from "./sort.js";
+import { bottom, cloneLayout, cloneLayoutItem, getStatics } from "./layout.js";
+
+//#region src/components/layout/Board/grid-core/compactors.ts
+/**
+* Compactor implementations.
+*
+* Vendored from react-grid-layout v2 (`src/core/compactors.ts`).
+* See ./NOTICE.md for attribution and license.
+*
+* Compactors are pluggable strategies for removing gaps between grid items.
+*/
+/**
+* Resolve a compaction collision by moving items.
+*
+* Before moving an item to a position, checks if that movement would cause
+* collisions and recursively moves those items first.
+*/
+function resolveCompactionCollision(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 (!layoutHasStatics && otherItem.y > item.y + item.h) break;
+		if (collides(item, otherItem)) resolveCompactionCollision(layout, otherItem, moveToCoord + item[sizeProp], axis, layoutHasStatics);
+	}
+	item[axis] = moveToCoord;
+}
+/** Compact a single item vertically (move up). Mutates `l`. */
+function compactItemVertical(compareWith, l, fullLayout, maxY) {
+	l.x = Math.max(l.x, 0);
+	l.y = Math.max(l.y, 0);
+	l.y = Math.min(maxY, l.y);
+	while (l.y > 0 && !getFirstCollision(compareWith, l)) l.y--;
+	let collision;
+	while ((collision = getFirstCollision(compareWith, l)) !== void 0) resolveCompactionCollision(fullLayout, l, collision.y + collision.h, "y");
+	l.y = Math.max(l.y, 0);
+	return l;
+}
+/** Compact a single item horizontally (move left). Mutates `l`. */
+function compactItemHorizontal(compareWith, l, cols, fullLayout) {
+	l.x = Math.max(l.x, 0);
+	l.y = Math.max(l.y, 0);
+	while (l.x > 0 && !getFirstCollision(compareWith, l)) l.x--;
+	let collision;
+	while ((collision = getFirstCollision(compareWith, l)) !== void 0) {
+		resolveCompactionCollision(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)) l.x--;
+		}
+	}
+	l.x = Math.max(l.x, 0);
+	return l;
+}
+/**
+* Vertical compactor - moves items up to fill gaps. Default compaction mode.
+*/
+const verticalCompactor = {
+	type: "vertical",
+	allowOverlap: false,
+	compact(layout, _cols) {
+		const compareWith = getStatics(layout);
+		let maxY = bottom(compareWith);
+		const sorted = 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);
+			if (!l.static) {
+				l = compactItemVertical(compareWith, l, sorted, maxY);
+				maxY = Math.max(maxY, l.y + l.h);
+				compareWith.push(l);
+			}
+			const originalIndex = layout.indexOf(sortedItem);
+			out[originalIndex] = l;
+			l.moved = false;
+		}
+		return out;
+	}
+};
+/**
+* Horizontal compactor - moves items left to fill gaps.
+*/
+const horizontalCompactor = {
+	type: "horizontal",
+	allowOverlap: false,
+	compact(layout, cols) {
+		const compareWith = getStatics(layout);
+		const sorted = 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);
+			if (!l.static) {
+				l = compactItemHorizontal(compareWith, l, cols, sorted);
+				compareWith.push(l);
+			}
+			const originalIndex = layout.indexOf(sortedItem);
+			out[originalIndex] = l;
+			l.moved = false;
+		}
+		return out;
+	}
+};
+/**
+* No compaction - items stay where placed (free-form layouts).
+*/
+const noCompactor = {
+	type: null,
+	allowOverlap: false,
+	compact(layout, _cols) {
+		return cloneLayout(layout);
+	}
+};
+/** Vertical compactor that allows overlapping items. */
+const verticalOverlapCompactor = {
+	...verticalCompactor,
+	allowOverlap: true,
+	compact(layout, _cols) {
+		return cloneLayout(layout);
+	}
+};
+/** Horizontal compactor that allows overlapping items. */
+const horizontalOverlapCompactor = {
+	...horizontalCompactor,
+	allowOverlap: true,
+	compact(layout, _cols) {
+		return cloneLayout(layout);
+	}
+};
+/** No compaction, with overlapping allowed. */
+const noOverlapCompactor = {
+	...noCompactor,
+	allowOverlap: true
+};
+/**
+* Get a compactor by type (convenience for the string-based compactType API).
+*/
+function getCompactor(compactType, allowOverlap = false, preventCollision = false) {
+	let baseCompactor;
+	if (allowOverlap) if (compactType === "vertical") baseCompactor = verticalOverlapCompactor;
+	else if (compactType === "horizontal") baseCompactor = horizontalOverlapCompactor;
+	else baseCompactor = noOverlapCompactor;
+	else if (compactType === "vertical") baseCompactor = verticalCompactor;
+	else if (compactType === "horizontal") baseCompactor = horizontalCompactor;
+	else baseCompactor = noCompactor;
+	if (preventCollision) return {
+		...baseCompactor,
+		preventCollision
+	};
+	return baseCompactor;
+}
+
+//#endregion
+export { getCompactor, horizontalCompactor, noCompactor, verticalCompactor };
+//# sourceMappingURL=compactors.js.map

package/dist/components/layout/Board/grid-core/compactors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactors.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/compactors.ts"],"sourcesContent":["/**\n * Compactor implementations.\n *\n * Vendored from react-grid-layout v2 (`src/core/compactors.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Compactors are pluggable strategies for removing gaps between grid items.\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type {\n  Compactor,\n  CompactType,\n  Layout,\n  LayoutItem,\n  Mutable,\n} from './types';\n\n// ============================================================================\n// Helpers for Custom Compactors\n// ============================================================================\n\n/**\n * Resolve a compaction collision by moving items.\n *\n * Before moving an item to a position, checks if that movement would cause\n * collisions and recursively moves those items first.\n */\nexport function resolveCompactionCollision(\n  layout: Layout,\n  item: LayoutItem,\n  moveToCoord: number,\n  axis: 'x' | 'y',\n  hasStatics?: boolean,\n): void {\n  const sizeProp = axis === 'x' ? 'w' : 'h';\n\n  // Temporarily increment position to check for collisions\n  (item as Mutable<LayoutItem>)[axis] += 1;\n\n  const itemIndex = layout.findIndex((l) => l.i === item.i);\n\n  const layoutHasStatics = hasStatics ?? getStatics(layout).length > 0;\n\n  for (let i = itemIndex + 1; i < layout.length; i++) {\n    const otherItem = layout[i];\n    if (otherItem === undefined) continue;\n    if (otherItem.static) continue;\n    // Optimization: break early if past this element, but only if no statics\n    // are present. Static items can be scattered throughout the layout.\n    if (!layoutHasStatics && otherItem.y > item.y + item.h) break;\n\n    if (collides(item, otherItem)) {\n      resolveCompactionCollision(\n        layout,\n        otherItem,\n        moveToCoord + item[sizeProp],\n        axis,\n        layoutHasStatics,\n      );\n    }\n  }\n\n  (item as Mutable<LayoutItem>)[axis] = moveToCoord;\n}\n\n/** Compact a single item vertically (move up). Mutates `l`. */\nexport function compactItemVertical(\n  compareWith: Layout,\n  l: LayoutItem,\n  fullLayout: Layout,\n  maxY: number,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Limit Y to the current bottom\n  (l as Mutable<LayoutItem>).y = Math.min(maxY, l.y);\n\n  // Move up as far as possible\n  while (l.y > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).y--;\n  }\n\n  // Resolve collisions by moving down\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.y + collision.h, 'y');\n  }\n\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n  return l;\n}\n\n/** Compact a single item horizontally (move left). Mutates `l`. */\nexport function compactItemHorizontal(\n  compareWith: Layout,\n  l: LayoutItem,\n  cols: number,\n  fullLayout: Layout,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Move left as far as possible\n  while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).x--;\n  }\n\n  // Resolve collisions\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.x + collision.w, 'x');\n\n    // Horizontal overflow: wrap to next row\n    if (l.x + l.w > cols) {\n      (l as Mutable<LayoutItem>).x = cols - l.w;\n      (l as Mutable<LayoutItem>).y++;\n\n      while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n        (l as Mutable<LayoutItem>).x--;\n      }\n    }\n  }\n\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  return l;\n}\n\n// ============================================================================\n// Vertical Compactor\n// ============================================================================\n\n/**\n * Vertical compactor - moves items up to fill gaps. Default compaction mode.\n */\nexport const verticalCompactor: Compactor = {\n  type: 'vertical',\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    const compareWith = getStatics(layout);\n    let maxY = bottom(compareWith);\n    const sorted = sortLayoutItemsByRowCol(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemVertical(compareWith, l, sorted, maxY);\n        maxY = Math.max(maxY, l.y + l.h);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// Horizontal Compactor\n// ============================================================================\n\n/**\n * Horizontal compactor - moves items left to fill gaps.\n */\nexport const horizontalCompactor: Compactor = {\n  type: 'horizontal',\n  allowOverlap: false,\n\n  compact(layout: Layout, cols: number): Layout {\n    const compareWith = getStatics(layout);\n    const sorted = sortLayoutItemsByColRow(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemHorizontal(compareWith, l, cols, sorted);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// No Compaction\n// ============================================================================\n\n/**\n * No compaction - items stay where placed (free-form layouts).\n */\nexport const noCompactor: Compactor = {\n  type: null,\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n// ============================================================================\n// Overlap-Allowing Variants\n// ============================================================================\n\n/** Vertical compactor that allows overlapping items. */\nexport const verticalOverlapCompactor: Compactor = {\n  ...verticalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** Horizontal compactor that allows overlapping items. */\nexport const horizontalOverlapCompactor: Compactor = {\n  ...horizontalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** No compaction, with overlapping allowed. */\nexport const noOverlapCompactor: Compactor = {\n  ...noCompactor,\n  allowOverlap: true,\n};\n\n// ============================================================================\n// Factory Function\n// ============================================================================\n\n/**\n * Get a compactor by type (convenience for the string-based compactType API).\n */\nexport function getCompactor(\n  compactType: CompactType,\n  allowOverlap: boolean = false,\n  preventCollision: boolean = false,\n): Compactor {\n  let baseCompactor: Compactor;\n\n  if (allowOverlap) {\n    if (compactType === 'vertical') baseCompactor = verticalOverlapCompactor;\n    else if (compactType === 'horizontal')\n      baseCompactor = horizontalOverlapCompactor;\n    else baseCompactor = noOverlapCompactor;\n  } else {\n    if (compactType === 'vertical') baseCompactor = verticalCompactor;\n    else if (compactType === 'horizontal') baseCompactor = horizontalCompactor;\n    // For 'wrap' and null, use noCompactor\n    else baseCompactor = noCompactor;\n  }\n\n  if (preventCollision) {\n    return { ...baseCompactor, preventCollision };\n  }\n  return baseCompactor;\n}\n"],"mappings":"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"}

package/dist/components/layout/Board/grid-core/constraints.d.ts

@@ -0,0 +1,35 @@
+
+import { LayoutConstraint } from "./types.js";
+
+//#region src/components/layout/Board/grid-core/constraints.d.ts
+/**
+ * Grid boundary constraint. Ensures items stay within the grid bounds. This is
+ * the default position constraint.
+ */
+declare const gridBounds: LayoutConstraint;
+/**
+ * Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.
+ */
+declare const minMaxSize: LayoutConstraint;
+/**
+ * Container bounds constraint. Constrains items to stay within the visible
+ * container (a replacement for the legacy `isBounded` prop).
+ */
+declare const containerBounds: LayoutConstraint;
+/** Bounded X constraint. Only constrains horizontal position. */
+declare const boundedX: LayoutConstraint;
+/** Bounded Y constraint. Only constrains vertical position. */
+declare const boundedY: LayoutConstraint;
+/**
+ * Create an aspect ratio constraint (maintains width-to-height ratio in pixels).
+ */
+declare function aspectRatio(ratio: number): LayoutConstraint;
+/** Create a snap-to-grid constraint. */
+declare function snapToGrid(stepX: number, stepY?: number): LayoutConstraint;
+/** Create a minimum size constraint (grid-wide). */
+declare function minSize(minW: number, minH: number): LayoutConstraint;
+/** Create a maximum size constraint (grid-wide). */
+declare function maxSize(maxW: number, maxH: number): LayoutConstraint;
+//#endregion
+export { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid };
+//# sourceMappingURL=constraints.d.ts.map

package/dist/components/layout/Board/grid-core/constraints.js

@@ -0,0 +1,155 @@
+/** @license MIT | @cube-dev/ui-kit v0.144.0 | Cube Dev Team */
+//#region src/components/layout/Board/grid-core/constraints.ts
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+/**
+* Grid boundary constraint. Ensures items stay within the grid bounds. This is
+* the default position constraint.
+*/
+const 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))
+		};
+	}
+};
+/**
+* Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.
+*/
+const 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)
+		};
+	}
+};
+/**
+* Container bounds constraint. Constrains items to stay within the visible
+* container (a replacement for the legacy `isBounded` prop).
+*/
+const 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))
+		};
+	}
+};
+/** Bounded X constraint. Only constrains horizontal position. */
+const boundedX = {
+	name: "boundedX",
+	constrainPosition(item, x, y, { cols }) {
+		return {
+			x: clamp(x, 0, Math.max(0, cols - item.w)),
+			y
+		};
+	}
+};
+/** Bounded Y constraint. Only constrains vertical position. */
+const boundedY = {
+	name: "boundedY",
+	constrainPosition(item, x, y, { maxRows }) {
+		return {
+			x,
+			y: clamp(y, 0, Math.max(0, maxRows - item.h))
+		};
+	}
+};
+/**
+* Create an aspect ratio constraint (maintains width-to-height ratio in pixels).
+*/
+function aspectRatio(ratio) {
+	return {
+		name: `aspectRatio(${ratio})`,
+		constrainSize(_item, w, _h, _handle, context) {
+			const { cols, containerWidth, rowHeight, margin } = context;
+			const pixelHeight = ((containerWidth - margin[0] * (cols - 1)) / cols * w + margin[0] * Math.max(0, w - 1)) / ratio;
+			return {
+				w,
+				h: Math.max(1, Math.round((pixelHeight + margin[1]) / (rowHeight + margin[1])))
+			};
+		}
+	};
+}
+/** Create a snap-to-grid constraint. */
+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
+			};
+		}
+	};
+}
+/** Create a minimum size constraint (grid-wide). */
+function minSize(minW, minH) {
+	return {
+		name: `minSize(${minW}, ${minH})`,
+		constrainSize(_item, w, h) {
+			return {
+				w: Math.max(minW, w),
+				h: Math.max(minH, h)
+			};
+		}
+	};
+}
+/** Create a maximum size constraint (grid-wide). */
+function maxSize(maxW, maxH) {
+	return {
+		name: `maxSize(${maxW}, ${maxH})`,
+		constrainSize(_item, w, h) {
+			return {
+				w: Math.min(maxW, w),
+				h: Math.min(maxH, h)
+			};
+		}
+	};
+}
+/** Default constraints applied when none are specified. */
+const defaultConstraints = [gridBounds, minMaxSize];
+/** Apply position constraints to a proposed position. */
+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;
+}
+/** Apply size constraints to a proposed size. */
+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;
+}
+
+//#endregion
+export { applyPositionConstraints, applySizeConstraints, aspectRatio, boundedX, boundedY, containerBounds, defaultConstraints, gridBounds, maxSize, minMaxSize, minSize, snapToGrid };
+//# sourceMappingURL=constraints.js.map

package/dist/components/layout/Board/grid-core/constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/constraints.ts"],"sourcesContent":["/**\n * Pluggable layout constraints.\n *\n * Vendored from react-grid-layout v2 (`src/core/constraints.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Constraints control position and size limits during drag/resize operations.\n */\n\nimport type {\n  ConstraintContext,\n  LayoutConstraint,\n  LayoutItem,\n  ResizeHandleAxis,\n} from './types';\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\n// ============================================================================\n// Built-in Constraints\n// ============================================================================\n\n/**\n * Grid boundary constraint. Ensures items stay within the grid bounds. This is\n * the default position constraint.\n */\nexport const gridBounds: LayoutConstraint = {\n  name: 'gridBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n    handle: ResizeHandleAxis,\n    { cols, maxRows }: ConstraintContext,\n  ): { w: number; h: number } {\n    const maxW =\n      handle === 'w' || handle === 'nw' || handle === 'sw'\n        ? item.x + item.w\n        : cols - item.x;\n\n    const maxH =\n      handle === 'n' || handle === 'nw' || handle === 'ne'\n        ? item.y + item.h\n        : maxRows - item.y;\n\n    return {\n      w: clamp(w, 1, Math.max(1, maxW)),\n      h: clamp(h, 1, Math.max(1, maxH)),\n    };\n  },\n};\n\n/**\n * Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.\n */\nexport const minMaxSize: LayoutConstraint = {\n  name: 'minMaxSize',\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n  ): { w: number; h: number } {\n    return {\n      w: clamp(w, item.minW ?? 1, item.maxW ?? Infinity),\n      h: clamp(h, item.minH ?? 1, item.maxH ?? Infinity),\n    };\n  },\n};\n\n/**\n * Container bounds constraint. Constrains items to stay within the visible\n * container (a replacement for the legacy `isBounded` prop).\n */\nexport const containerBounds: LayoutConstraint = {\n  name: 'containerBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows, containerHeight, rowHeight, margin }: ConstraintContext,\n  ): { x: number; y: number } {\n    const visibleRows =\n      containerHeight > 0\n        ? Math.floor((containerHeight + margin[1]) / (rowHeight + margin[1]))\n        : maxRows;\n\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, visibleRows - item.h)),\n    };\n  },\n};\n\n/** Bounded X constraint. Only constrains horizontal position. */\nexport const boundedX: LayoutConstraint = {\n  name: 'boundedX',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y,\n    };\n  },\n};\n\n/** Bounded Y constraint. Only constrains vertical position. */\nexport const boundedY: LayoutConstraint = {\n  name: 'boundedY',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x,\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n};\n\n// ============================================================================\n// Constraint Factories\n// ============================================================================\n\n/**\n * Create an aspect ratio constraint (maintains width-to-height ratio in pixels).\n */\nexport function aspectRatio(ratio: number): LayoutConstraint {\n  return {\n    name: `aspectRatio(${ratio})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      _h: number,\n      _handle: ResizeHandleAxis,\n      context: ConstraintContext,\n    ): { w: number; h: number } {\n      const { cols, containerWidth, rowHeight, margin } = context;\n      const colWidth = (containerWidth - margin[0] * (cols - 1)) / cols;\n      const pixelWidth = colWidth * w + margin[0] * Math.max(0, w - 1);\n      const pixelHeight = pixelWidth / ratio;\n      const h = Math.max(\n        1,\n        Math.round((pixelHeight + margin[1]) / (rowHeight + margin[1])),\n      );\n\n      return { w, h };\n    },\n  };\n}\n\n/** Create a snap-to-grid constraint. */\nexport function snapToGrid(\n  stepX: number,\n  stepY: number = stepX,\n): LayoutConstraint {\n  if (stepX <= 0 || stepY <= 0) {\n    throw new Error(\n      `snapToGrid: step values must be positive (got stepX=${stepX}, stepY=${stepY})`,\n    );\n  }\n\n  return {\n    name: `snapToGrid(${stepX}, ${stepY})`,\n\n    constrainPosition(\n      _item: LayoutItem,\n      x: number,\n      y: number,\n    ): { x: number; y: number } {\n      return {\n        x: Math.round(x / stepX) * stepX,\n        y: Math.round(y / stepY) * stepY,\n      };\n    },\n  };\n}\n\n/** Create a minimum size constraint (grid-wide). */\nexport function minSize(minW: number, minH: number): LayoutConstraint {\n  return {\n    name: `minSize(${minW}, ${minH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.max(minW, w),\n        h: Math.max(minH, h),\n      };\n    },\n  };\n}\n\n/** Create a maximum size constraint (grid-wide). */\nexport function maxSize(maxW: number, maxH: number): LayoutConstraint {\n  return {\n    name: `maxSize(${maxW}, ${maxH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.min(maxW, w),\n        h: Math.min(maxH, h),\n      };\n    },\n  };\n}\n\n// ============================================================================\n// Default Constraints\n// ============================================================================\n\n/** Default constraints applied when none are specified. */\nexport const defaultConstraints: LayoutConstraint[] = [gridBounds, minMaxSize];\n\n// ============================================================================\n// Constraint Application Functions\n// ============================================================================\n\n/** Apply position constraints to a proposed position. */\nexport function applyPositionConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  x: number,\n  y: number,\n  context: ConstraintContext,\n): { x: number; y: number } {\n  let result = { x, y };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainPosition) {\n      result = constraint.constrainPosition(item, result.x, result.y, context);\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainPosition) {\n        result = constraint.constrainPosition(\n          item,\n          result.x,\n          result.y,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n\n/** Apply size constraints to a proposed size. */\nexport function applySizeConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  w: number,\n  h: number,\n  handle: ResizeHandleAxis,\n  context: ConstraintContext,\n): { w: number; h: number } {\n  let result = { w, h };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainSize) {\n      result = constraint.constrainSize(\n        item,\n        result.w,\n        result.h,\n        handle,\n        context,\n      );\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainSize) {\n        result = constraint.constrainSize(\n          item,\n          result.w,\n          result.h,\n          handle,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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"}