@cube-dev/ui-kit 0.0.0-canary-4c90a81 → 0.0.0-canary-c26fe9d

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

@@ -0,0 +1,35 @@
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | 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.0.0-canary-c26fe9d | 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.0.0-canary-c26fe9d | 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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"}

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

@@ -0,0 +1,176 @@
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | Cube Dev Team */
+import { getAllCollisions, getFirstCollision } from "./collision.js";
+import { sortLayoutItems } from "./sort.js";
+
+//#region src/components/layout/Board/grid-core/layout.ts
+/**
+* Core layout manipulation utilities.
+*
+* Vendored from react-grid-layout v2 (`src/core/layout.ts`).
+* See ./NOTICE.md for attribution and license.
+*
+* These functions create, modify, and query grid layouts. Most functions treat
+* layouts as immutable and return new arrays/objects, but a few mutate items in
+* place for performance (documented per function).
+*/
+/**
+* Get the bottom-most Y coordinate of the layout (max of y + h).
+*/
+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;
+}
+/** Get a layout item by its ID. */
+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;
+	}
+}
+/** Get all static items from the layout. */
+function getStatics(layout) {
+	return layout.filter((l) => l.static === true);
+}
+/** Clone a layout item (shallow copy, boolean flags normalized). */
+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,
+		constraints: layoutItem.constraints,
+		isBounded: layoutItem.isBounded
+	};
+}
+/** Clone an entire layout. */
+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;
+}
+/** Replace a layout item in a layout (matched by `i`). Other items untouched. */
+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;
+}
+/**
+* Ensure all layout items fit within the grid bounds.
+*
+* **IMPORTANT**: mutates the layout items in place for performance. Clone the
+* layout first (e.g. with `cloneLayout()`) if you need immutability.
+*/
+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;
+}
+/**
+* Move a layout element to a new position.
+*
+* Handles collision detection and cascading movements. Does not compact the
+* layout - call the compactor separately.
+*
+* **Note**: mutates the `l` parameter directly for performance.
+*/
+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);
+	if (compactType === "vertical" && typeof y === "number" ? oldY >= y : compactType === "horizontal" && typeof x === "number" ? oldX >= x : false) 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, cols);
+		else resultLayout = moveElementAwayFromCollision(resultLayout, l, collision, isUserAction, compactType, cols);
+	}
+	return resultLayout;
+}
+/**
+* Move an item away from a collision. Attempts to move up/left first if there's
+* room, otherwise moves it down/right.
+*/
+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, cols);
+		if (collisionNorth && compactV) return moveElement(layout, itemToMove, void 0, itemToMove.y + 1, isUserAction, preventCollision, compactType, cols);
+		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, cols);
+	}
+	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, cols);
+}
+
+//#endregion
+export { bottom, cloneLayout, cloneLayoutItem, correctBounds, getLayoutItem, getStatics, modifyLayout, moveElement };
+//# sourceMappingURL=layout.js.map