@cube-dev/ui-kit 0.164.0 → 0.166.0

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

@@ -0,0 +1,58 @@
+
+import { Layout, LayoutItem } from "./types.js";
+
+//#region src/components/layout/Board/grid-core/placement.d.ts
+/**
+ * The first position at or below the preferred cell where `item` fits without
+ * overlapping any of `others` (which must themselves be overlap-free), scanning
+ * left-to-right then top-to-bottom and never past `maxRows`; if the band below
+ * is full, upward toward the top.
+ *
+ * This is the rule the board itself applies when it has to land a widget that
+ * cannot stay where it was dropped, so using it for a programmatic add is what
+ * makes the two agree.
+ *
+ * A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path
+ * applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the
+ * row limit even when the landing cell is blocked, so the downward scan cannot
+ * push it off the board. If the whole valid band is full the item is clamped to
+ * the limit — bounds win over overlap, exactly as `gridBounds` does. With an
+ * unbounded `maxRows` there is always a free slot below every existing item, so
+ * the downward scan terminates on its own.
+ *
+ * The returned item is a copy; `item` is not mutated. Its `w` is capped to
+ * `cols`, and no other dimension is changed — this never resizes to fit.
+ */
+declare function placeInFreeSlot(others: Layout, item: LayoutItem, cols: number, maxRows?: number): LayoutItem;
+/**
+ * Tile every item evenly across both axes of a `cols × rows` grid, keeping the
+ * row structure the layout already has: items are grouped into visual rows by
+ * their current `y`, `rows` is divided across those groups, and `cols` across
+ * each group's members.
+ *
+ * So three items on one line become three equal full-height columns; move one
+ * below and the top line becomes two half-width cells while the lower item
+ * spans the full width at half height. Grouping by `y` rather than reflowing
+ * from scratch is what makes the result recognisably the user's arrangement
+ * instead of an arbitrary repack.
+ *
+ * A visual row holding more items than the grid is wide is wrapped into
+ * sub-rows of at most `cols`, so nothing tiles past the right edge. That can
+ * take the result past `rows`; the caller decides whether to grow the grid or
+ * let its bounds clip.
+ *
+ * This is the one operation that deliberately GROWS items — every gesture-driven
+ * path refuses to, because growing on a move is a surprise. Here it is the whole
+ * point, which is why it is a call the app makes rather than a mode the board is
+ * in. Returns new items in the input's order; the input is not mutated.
+ */
+declare function distributeEvenly(layout: Layout, {
+  cols,
+  rows
+}: {
+  cols: number;
+  rows: number;
+}): LayoutItem[];
+//#endregion
+export { distributeEvenly, placeInFreeSlot };
+//# sourceMappingURL=placement.d.ts.map

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

@@ -0,0 +1,153 @@
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
+import { collides } from "./collision.js";
+
+//#region src/components/layout/Board/grid-core/placement.ts
+/**
+* Placing items into a grid without dragging them there.
+*
+* A board's own gestures resolve placement through the compactor and the
+* collision resolver. An app that adds a widget programmatically — a toolbar
+* drop, a widget moved between boards by code, an "arrange these for me"
+* command — has to answer the same question with no gesture in hand, and had no
+* way to ask the engine for the answer. Left to solve it themselves, apps
+* re-implement the scan, and the same drop lands in two different cells
+* depending on whether a pointer or a code path served it.
+*
+* Original UI Kit code (not vendored from react-grid-layout).
+*/
+/**
+* The first position at or below the preferred cell where `item` fits without
+* overlapping any of `others` (which must themselves be overlap-free), scanning
+* left-to-right then top-to-bottom and never past `maxRows`; if the band below
+* is full, upward toward the top.
+*
+* This is the rule the board itself applies when it has to land a widget that
+* cannot stay where it was dropped, so using it for a programmatic add is what
+* makes the two agree.
+*
+* A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path
+* applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the
+* row limit even when the landing cell is blocked, so the downward scan cannot
+* push it off the board. If the whole valid band is full the item is clamped to
+* the limit — bounds win over overlap, exactly as `gridBounds` does. With an
+* unbounded `maxRows` there is always a free slot below every existing item, so
+* the downward scan terminates on its own.
+*
+* The returned item is a copy; `item` is not mutated. Its `w` is capped to
+* `cols`, and no other dimension is changed — this never resizes to fit.
+*/
+function placeInFreeSlot(others, item, cols, maxRows = Infinity) {
+	const w = Math.min(item.w, cols);
+	const maxY = Number.isFinite(maxRows) ? Math.max(0, maxRows - item.h) : Infinity;
+	const fits = (x, y) => !others.some((o) => collides(o, {
+		...item,
+		x,
+		y,
+		w
+	}));
+	const preferX = Math.min(Math.max(0, item.x), cols - w);
+	const startY = Math.min(Math.max(0, item.y), maxY);
+	if (fits(preferX, startY)) return {
+		...item,
+		x: preferX,
+		y: startY,
+		w
+	};
+	const scanBottom = Number.isFinite(maxRows) ? maxY : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;
+	for (let y = startY; y <= scanBottom; y++) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
+		...item,
+		x,
+		y,
+		w
+	};
+	for (let y = startY - 1; y >= 0; y--) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
+		...item,
+		x,
+		y,
+		w
+	};
+	return {
+		...item,
+		x: preferX,
+		y: startY,
+		w
+	};
+}
+/**
+* Split `total` cells across `parts` groups as evenly as possible: each group
+* gets at least one, and the first `total % parts` groups get one extra so the
+* pieces sum to `total`. With more groups than cells every group still gets one
+* and the sum overflows, which the grid's own bounds then clip — the best
+* available answer when there is less than a cell to go round.
+*/
+function splitEvenly(total, parts) {
+	if (parts <= 0) return [];
+	const base = Math.max(1, Math.floor(total / parts));
+	const remainder = base * parts >= total ? 0 : total - base * parts;
+	return Array.from({ length: parts }, (_, i) => base + (i < remainder ? 1 : 0));
+}
+/**
+* Tile every item evenly across both axes of a `cols × rows` grid, keeping the
+* row structure the layout already has: items are grouped into visual rows by
+* their current `y`, `rows` is divided across those groups, and `cols` across
+* each group's members.
+*
+* So three items on one line become three equal full-height columns; move one
+* below and the top line becomes two half-width cells while the lower item
+* spans the full width at half height. Grouping by `y` rather than reflowing
+* from scratch is what makes the result recognisably the user's arrangement
+* instead of an arbitrary repack.
+*
+* A visual row holding more items than the grid is wide is wrapped into
+* sub-rows of at most `cols`, so nothing tiles past the right edge. That can
+* take the result past `rows`; the caller decides whether to grow the grid or
+* let its bounds clip.
+*
+* This is the one operation that deliberately GROWS items — every gesture-driven
+* path refuses to, because growing on a move is a surprise. Here it is the whole
+* point, which is why it is a call the app makes rather than a mode the board is
+* in. Returns new items in the input's order; the input is not mutated.
+*/
+function distributeEvenly(layout, { cols, rows }) {
+	if (layout.length === 0) return [];
+	const gridCols = Math.max(1, cols);
+	const gridRows = Math.max(1, rows);
+	const sorted = [...layout].sort((a, b) => a.y !== b.y ? a.y - b.y : a.x - b.x);
+	const groups = [];
+	let lastY = null;
+	for (const item of sorted) {
+		if (lastY === null || item.y !== lastY) {
+			groups.push([]);
+			lastY = item.y;
+		}
+		groups[groups.length - 1].push(item);
+	}
+	const rowGroups = [];
+	for (const group of groups) if (group.length <= gridCols) rowGroups.push(group);
+	else for (let i = 0; i < group.length; i += gridCols) rowGroups.push(group.slice(i, i + gridCols));
+	const rowHeights = splitEvenly(gridRows, rowGroups.length);
+	const placed = /* @__PURE__ */ new Map();
+	let y = 0;
+	rowGroups.forEach((group, gi) => {
+		const h = rowHeights[gi];
+		const widths = splitEvenly(gridCols, group.length);
+		let x = 0;
+		group.forEach((item, ci) => {
+			const w = widths[ci];
+			placed.set(item.i, {
+				...item,
+				x,
+				y,
+				w,
+				h
+			});
+			x += w;
+		});
+		y += h;
+	});
+	return layout.map((item) => placed.get(item.i) ?? item);
+}
+
+//#endregion
+export { distributeEvenly, placeInFreeSlot };
+//# sourceMappingURL=placement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"placement.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/placement.ts"],"sourcesContent":["/**\n * Placing items into a grid without dragging them there.\n *\n * A board's own gestures resolve placement through the compactor and the\n * collision resolver. An app that adds a widget programmatically — a toolbar\n * drop, a widget moved between boards by code, an \"arrange these for me\"\n * command — has to answer the same question with no gesture in hand, and had no\n * way to ask the engine for the answer. Left to solve it themselves, apps\n * re-implement the scan, and the same drop lands in two different cells\n * depending on whether a pointer or a code path served it.\n *\n * Original UI Kit code (not vendored from react-grid-layout).\n */\n\nimport { collides } from './collision';\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * The first position at or below the preferred cell where `item` fits without\n * overlapping any of `others` (which must themselves be overlap-free), scanning\n * left-to-right then top-to-bottom and never past `maxRows`; if the band below\n * is full, upward toward the top.\n *\n * This is the rule the board itself applies when it has to land a widget that\n * cannot stay where it was dropped, so using it for a programmatic add is what\n * makes the two agree.\n *\n * A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path\n * applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the\n * row limit even when the landing cell is blocked, so the downward scan cannot\n * push it off the board. If the whole valid band is full the item is clamped to\n * the limit — bounds win over overlap, exactly as `gridBounds` does. With an\n * unbounded `maxRows` there is always a free slot below every existing item, so\n * the downward scan terminates on its own.\n *\n * The returned item is a copy; `item` is not mutated. Its `w` is capped to\n * `cols`, and no other dimension is changed — this never resizes to fit.\n */\nexport function placeInFreeSlot(\n  others: Layout,\n  item: LayoutItem,\n  cols: number,\n  maxRows = Infinity,\n): LayoutItem {\n  const w = Math.min(item.w, cols);\n  const maxY = Number.isFinite(maxRows)\n    ? Math.max(0, maxRows - item.h)\n    : Infinity;\n  const fits = (x: number, y: number) =>\n    !others.some((o) => collides(o, { ...item, x, y, w }));\n  const preferX = Math.min(Math.max(0, item.x), cols - w);\n  const startY = Math.min(Math.max(0, item.y), maxY);\n  if (fits(preferX, startY)) return { ...item, x: preferX, y: startY, w };\n  const scanBottom = Number.isFinite(maxRows)\n    ? maxY\n    : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;\n  for (let y = startY; y <= scanBottom; y++) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  // The landing row (clamped to the limit) and everything below it were full;\n  // look upward for a free slot still inside the board before giving up.\n  for (let y = startY - 1; y >= 0; y--) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  return { ...item, x: preferX, y: startY, w };\n}\n\n/**\n * Split `total` cells across `parts` groups as evenly as possible: each group\n * gets at least one, and the first `total % parts` groups get one extra so the\n * pieces sum to `total`. With more groups than cells every group still gets one\n * and the sum overflows, which the grid's own bounds then clip — the best\n * available answer when there is less than a cell to go round.\n */\nfunction splitEvenly(total: number, parts: number): number[] {\n  if (parts <= 0) return [];\n  const base = Math.max(1, Math.floor(total / parts));\n  const remainder = base * parts >= total ? 0 : total - base * parts;\n  return Array.from(\n    { length: parts },\n    (_, i) => base + (i < remainder ? 1 : 0),\n  );\n}\n\n/**\n * Tile every item evenly across both axes of a `cols × rows` grid, keeping the\n * row structure the layout already has: items are grouped into visual rows by\n * their current `y`, `rows` is divided across those groups, and `cols` across\n * each group's members.\n *\n * So three items on one line become three equal full-height columns; move one\n * below and the top line becomes two half-width cells while the lower item\n * spans the full width at half height. Grouping by `y` rather than reflowing\n * from scratch is what makes the result recognisably the user's arrangement\n * instead of an arbitrary repack.\n *\n * A visual row holding more items than the grid is wide is wrapped into\n * sub-rows of at most `cols`, so nothing tiles past the right edge. That can\n * take the result past `rows`; the caller decides whether to grow the grid or\n * let its bounds clip.\n *\n * This is the one operation that deliberately GROWS items — every gesture-driven\n * path refuses to, because growing on a move is a surprise. Here it is the whole\n * point, which is why it is a call the app makes rather than a mode the board is\n * in. Returns new items in the input's order; the input is not mutated.\n */\nexport function distributeEvenly(\n  layout: Layout,\n  { cols, rows }: { cols: number; rows: number },\n): LayoutItem[] {\n  if (layout.length === 0) return [];\n\n  const gridCols = Math.max(1, cols);\n  const gridRows = Math.max(1, rows);\n\n  const sorted = [...layout].sort((a, b) =>\n    a.y !== b.y ? a.y - b.y : a.x - b.x,\n  );\n\n  const groups: LayoutItem[][] = [];\n  let lastY: number | null = null;\n  for (const item of sorted) {\n    if (lastY === null || item.y !== lastY) {\n      groups.push([]);\n      lastY = item.y;\n    }\n    groups[groups.length - 1].push(item);\n  }\n\n  const rowGroups: LayoutItem[][] = [];\n  for (const group of groups) {\n    if (group.length <= gridCols) {\n      rowGroups.push(group);\n    } else {\n      for (let i = 0; i < group.length; i += gridCols) {\n        rowGroups.push(group.slice(i, i + gridCols));\n      }\n    }\n  }\n\n  const rowHeights = splitEvenly(gridRows, rowGroups.length);\n  const placed = new Map<string, LayoutItem>();\n  let y = 0;\n  rowGroups.forEach((group, gi) => {\n    const h = rowHeights[gi];\n    const widths = splitEvenly(gridCols, group.length);\n    let x = 0;\n    group.forEach((item, ci) => {\n      const w = widths[ci];\n      placed.set(item.i, { ...item, x, y, w, h });\n      x += w;\n    });\n    y += h;\n  });\n\n  // Emit in the caller's order, not the sort's: a layout is keyed by `i`, and\n  // reordering it would churn every consumer that diffs the array positionally.\n  return layout.map((item) => placed.get(item.i) ?? item);\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/sort.ts
 /**
 * Sort layout items based on the compaction type.

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

@@ -93,10 +93,12 @@ type CompactType = 'horizontal' | 'vertical' | 'wrap' | null;
  * - `'revert'` - snap the item back to where it was (the engine's own default).
  * - `'downscale'` - shrink the item into the free space at the cell it was
  *   dropped on, growing rightward and downward. Never upscales.
- * - `'swap'` - exchange with one widget: the dragged widget takes the cell of the
- *   widget the drop covers most, and that widget takes the cell the dragged one
- *   came from, each keeping as much of its own size as fits there. Never displaces
- *   more than that one widget. Else downscale, else revert.
+ * - `'swap'` - inside one board, exchange with one widget: the dragged widget
+ *   takes the cell of the widget the drop covers most, and that widget takes the
+ *   cell the dragged one came from, each keeping as much of its own size as fits
+ *   there. Across boards, insert only at an empty anchor and downscale without
+ *   exchanging or reflowing destination widgets; an invalid landing cancels the
+ *   transfer. Never displaces more than one widget. Else downscale, else revert.
  *
  * Only consulted where a move would otherwise be refused, so it has no effect in
  * the compacting modes (a collision pushes neighbours there) or under

package/dist/components/layout/Board/index.d.ts

@@ -1,5 +1,6 @@
 
 import { CollisionMode, Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis } from "./grid-core/types.js";
+import { distributeEvenly, placeInFreeSlot } from "./grid-core/placement.js";
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";
 import { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid } from "./grid-core/constraints.js";
 import { BoardSelectionMode } from "./use-board-selection.js";

package/dist/components/layout/Board/index.js

@@ -1,4 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
+import { distributeEvenly, placeInFreeSlot } from "./grid-core/placement.js";
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";
 import { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid } from "./grid-core/constraints.js";
 import { BoardProvider } from "./BoardProvider.js";

package/dist/components/layout/Board/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["BoardBase"],"sources":["../../../../src/components/layout/Board/index.tsx"],"sourcesContent":["import { Board as BoardBase } from './Board';\nimport { BoardProvider } from './BoardProvider';\nimport { BoardResponsive } from './BoardResponsive';\nimport { Widget } from './Widget';\n\nconst Board = Object.assign(BoardBase, {\n  Widget,\n  Provider: BoardProvider,\n  Responsive: BoardResponsive,\n});\n\nexport { Board };\nexport { BoardProvider };\nexport { BoardResponsive };\nexport { Widget as BoardWidget };\nexport { BOARD_SELECTION_CANCEL } from './Board';\n\nexport type {\n  CubeBoardProps,\n  BoardCompactType,\n  BoardGridLines,\n  BoardInteractionInfo,\n} from './Board';\nexport type { BoardSelectionMode } from './use-board-selection';\nexport type { CubeBoardResponsiveProps } from './BoardResponsive';\nexport type { CubeBoardWidgetProps, BoardResizeGripPlacement } from './Widget';\nexport type { CubeBoardProviderProps } from './BoardProvider';\nexport type { WidgetTransferInfo } from './board-context';\nexport type {\n  Breakpoints as BoardBreakpoints,\n  BreakpointCols as BoardBreakpointCols,\n  ResponsiveLayouts as BoardResponsiveLayouts,\n} from './responsive-utils';\n\nexport type {\n  Layout,\n  LayoutItem,\n  ResizeHandleAxis,\n  CollisionMode,\n  Compactor,\n  LayoutConstraint,\n  PositionParams,\n} from './grid-core';\n\nexport {\n  verticalCompactor,\n  horizontalCompactor,\n  noCompactor,\n  getCompactor,\n  gridBounds,\n  minMaxSize,\n  containerBounds,\n  boundedX,\n  boundedY,\n  aspectRatio,\n  snapToGrid,\n  minSize,\n  maxSize,\n} from './grid-core';\n"],"mappings":";;;;;;;;;AAKA,MAAM,QAAQ,OAAO,OAAOA,SAAW;CACrC;CACA,UAAU;CACV,YAAY;CACb,CAAC"}
+{"version":3,"file":"index.js","names":["BoardBase"],"sources":["../../../../src/components/layout/Board/index.tsx"],"sourcesContent":["import { Board as BoardBase } from './Board';\nimport { BoardProvider } from './BoardProvider';\nimport { BoardResponsive } from './BoardResponsive';\nimport { Widget } from './Widget';\n\nconst Board = Object.assign(BoardBase, {\n  Widget,\n  Provider: BoardProvider,\n  Responsive: BoardResponsive,\n});\n\nexport { Board };\nexport { BoardProvider };\nexport { BoardResponsive };\nexport { Widget as BoardWidget };\nexport { BOARD_SELECTION_CANCEL } from './Board';\n\nexport type {\n  CubeBoardProps,\n  BoardCompactType,\n  BoardGridLines,\n  BoardInteractionInfo,\n} from './Board';\nexport type { BoardSelectionMode } from './use-board-selection';\nexport type { CubeBoardResponsiveProps } from './BoardResponsive';\nexport type { CubeBoardWidgetProps, BoardResizeGripPlacement } from './Widget';\nexport type { CubeBoardProviderProps } from './BoardProvider';\nexport type { WidgetTransferInfo } from './board-context';\nexport type {\n  Breakpoints as BoardBreakpoints,\n  BreakpointCols as BoardBreakpointCols,\n  ResponsiveLayouts as BoardResponsiveLayouts,\n} from './responsive-utils';\n\nexport type {\n  Layout,\n  LayoutItem,\n  ResizeHandleAxis,\n  CollisionMode,\n  Compactor,\n  LayoutConstraint,\n  PositionParams,\n} from './grid-core';\n\nexport { placeInFreeSlot, distributeEvenly } from './grid-core';\n\nexport {\n  verticalCompactor,\n  horizontalCompactor,\n  noCompactor,\n  getCompactor,\n  gridBounds,\n  minMaxSize,\n  containerBounds,\n  boundedX,\n  boundedY,\n  aspectRatio,\n  snapToGrid,\n  minSize,\n  maxSize,\n} from './grid-core';\n"],"mappings":";;;;;;;;;;AAKA,MAAM,QAAQ,OAAO,OAAOA,SAAW;CACrC;CACA,UAAU;CACV,YAAY;CACb,CAAC"}

package/dist/components/layout/Board/responsive-utils.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { cloneLayout, correctBounds } from "./grid-core/layout.js";
 
 //#region src/components/layout/Board/responsive-utils.ts

package/dist/components/layout/Board/use-board-layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { cloneLayout } from "./grid-core/layout.js";
 import { useCallback, useEffect, useRef, useState } from "react";

package/dist/components/layout/Board/use-board-registry.js

@@ -1,8 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { BoardWidgetStore } from "./board-store.js";
 import { collides } from "./grid-core/collision.js";
 import { createCollisionResolver } from "./grid-core/collision-modes.js";
+import { placeInFreeSlot } from "./grid-core/placement.js";
 import { bottom, cloneLayout, getLayoutItem, moveElement } from "./grid-core/layout.js";
 import { moveElements } from "./grid-core/group-move.js";
 import { calcXYRaw } from "./grid-core/calculate.js";
@@ -77,58 +78,6 @@ function resizesAnything(before, after) {
 		return !!b && (b.w !== a.w || b.h !== a.h);
 	});
 }
-/**
-* First position at or below the preferred cell where `item` fits without
-* overlapping any of `others` (assumed overlap-free), scanning left-to-right
-* then top-to-bottom, never past `maxRows`. Last-resort placement for a legacy
-* (no-op compaction) cross-board drop that would otherwise stack widgets.
-*
-* A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path
-* applies (`clamp(y, 0, maxRows - h)`): the widget's bottom edge (`y + h`) stays
-* within the row limit even when the landing cell is blocked, so the downward
-* scan can't push it off the board. Rows are searched from the (clamped) landing
-* row down to the limit first, then upward toward the top; if the whole valid
-* band is full the widget is clamped to the limit (bounds win over overlap, as
-* `gridBounds` does). With an unbounded `maxRows` there is always a free slot
-* below every existing item, so the downward scan terminates on its own.
-*/
-function placeInFreeSlot(others, item, cols, maxRows = Infinity) {
-	const w = Math.min(item.w, cols);
-	const maxY = Number.isFinite(maxRows) ? Math.max(0, maxRows - item.h) : Infinity;
-	const fits = (x, y) => !others.some((o) => collides(o, {
-		...item,
-		x,
-		y,
-		w
-	}));
-	const preferX = Math.min(Math.max(0, item.x), cols - w);
-	const startY = Math.min(Math.max(0, item.y), maxY);
-	if (fits(preferX, startY)) return {
-		...item,
-		x: preferX,
-		y: startY,
-		w
-	};
-	const scanBottom = Number.isFinite(maxRows) ? maxY : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;
-	for (let y = startY; y <= scanBottom; y++) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
-		...item,
-		x,
-		y,
-		w
-	};
-	for (let y = startY - 1; y >= 0; y--) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
-		...item,
-		x,
-		y,
-		w
-	};
-	return {
-		...item,
-		x: preferX,
-		y: startY,
-		w
-	};
-}
 function useBoardRegistry(options) {
 	const store = useMemo(() => new BoardWidgetStore(), []);
 	const onTransferRef = useRef(options?.onWidgetTransfer);
@@ -140,6 +89,7 @@ function useBoardRegistry(options) {
 	const sourceSnapshotRef = useRef([]);
 	const targetSnapshotsRef = useRef(/* @__PURE__ */ new Map());
 	const previewRef = useRef(null);
+	const targetLandingRef = useRef(null);
 	const frozenRectsRef = useRef(/* @__PURE__ */ new Map());
 	const nestedInDraggedRef = useRef(/* @__PURE__ */ new Set());
 	const lastLandingRef = useRef(null);
@@ -254,6 +204,7 @@ function useBoardRegistry(options) {
 		affectedRef.current = new Set([boardId]);
 		sourceSnapshotRef.current = cloneLayout(entry.getLayout());
 		previewRef.current = null;
+		targetLandingRef.current = null;
 		lastLandingRef.current = {
 			x: item.x,
 			y: item.y
@@ -485,6 +436,7 @@ function useBoardRegistry(options) {
 	const previewOnTarget = useCallback((target, item, x, y) => {
 		const pp = target.getPositionParams();
 		const compactor = target.getCompactor();
+		const strictIncomingSwap = compactor.preventCollision === true && !compactor.allowOverlap && target.getCollisionMode() === "swap";
 		const carried = previewRef.current?.boardId === target.id ? previewRef.current.working : null;
 		const base = cloneLayout(carried ?? targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== item.i);
 		const prevItem = carried ? getLayoutItem(carried, item.i) : void 0;
@@ -510,19 +462,47 @@ function useBoardRegistry(options) {
 			},
 			allowExchange: false
 		}) : void 0 });
-		const compacted = [...compactor.compact(moved, pp.cols)];
-		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
+		const compacted = strictIncomingSwap ? cloneLayout(moved) : [...compactor.compact(moved, pp.cols)];
+		const landed = getLayoutItem(compacted, item.i);
+		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) {
+			if (strictIncomingSwap) {
+				const snapshot = targetSnapshotsRef.current.get(target.id);
+				if (snapshot) target.applyLayout(cloneLayout(snapshot), false);
+				target.setPlaceholders([]);
+				previewRef.current = null;
+				targetLandingRef.current = {
+					boardId: target.id,
+					valid: false
+				};
+			}
+			return;
+		}
+		if (strictIncomingSwap && (!landed || landed.x !== x || landed.y !== y)) {
+			const snapshot = targetSnapshotsRef.current.get(target.id);
+			if (snapshot) target.applyLayout(cloneLayout(snapshot), false);
+			target.setPlaceholders([]);
+			previewRef.current = null;
+			targetLandingRef.current = {
+				boardId: target.id,
+				valid: false
+			};
+			return;
+		}
 		previewRef.current = {
 			boardId: target.id,
 			working: compacted
 		};
-		const landed = getLayoutItem(compacted, item.i) ?? {
+		targetLandingRef.current = {
+			boardId: target.id,
+			valid: true
+		};
+		const previewItem = landed ?? {
 			...item,
 			x,
 			y
 		};
 		target.applyLayout(compacted.filter((l) => l.i !== item.i), false);
-		target.setPlaceholders([{ ...landed }]);
+		target.setPlaceholders([{ ...previewItem }]);
 	}, []);
 	const onDragMove = useEvent((deltaX, deltaY, pointerType) => {
 		const ds = dragStateRef.current;
@@ -567,6 +547,7 @@ function useBoardRegistry(options) {
 				if (snap) prev?.applyLayout(cloneLayout(snap), false);
 				prev?.setPlaceholders([]);
 				previewRef.current = null;
+				targetLandingRef.current = null;
 			}
 			if (isGroup) moveGroupWithinBoard(target, ds, x - ds.item.x, y - ds.item.y);
 			else moveWithinBoard(target, ds.item, x, y);
@@ -586,6 +567,7 @@ function useBoardRegistry(options) {
 			}
 			prev?.setPlaceholders([]);
 			previewRef.current = null;
+			targetLandingRef.current = null;
 			if (!targetSnapshotsRef.current.has(target.id)) targetSnapshotsRef.current.set(target.id, cloneLayout(target.getLayout()));
 		}
 		previewOnTarget(target, ds.item, x, y);
@@ -614,55 +596,63 @@ function useBoardRegistry(options) {
 				x: ds.item.x,
 				y: ds.item.y
 			};
-			if (source) {
-				const sp = source.getPositionParams();
-				const sc = source.getCompactor();
-				const remaining = source.getLayout().filter((l) => l.i !== ds.itemId);
-				source.applyLayout([...sc.compact(remaining, sp.cols)], true);
-			}
 			const tp = target.getPositionParams();
 			const tc = target.getCompactor();
+			const strictIncomingSwap = tc.preventCollision === true && !tc.allowOverlap && target.getCollisionMode() === "swap";
 			const carried = previewRef.current?.boardId === target.id && getLayoutItem(previewRef.current.working, ds.itemId) ? previewRef.current.working : null;
-			let finalLayout;
-			if (carried) finalLayout = [...tc.compact(cloneLayout(carried), tp.cols)];
-			else {
-				const newItem = tc.type === "horizontal" ? {
-					...ds.item,
-					x: Math.max(0, landing.x) - 1,
-					y: landing.y
-				} : {
-					...ds.item,
-					x: landing.x,
-					y: Math.max(0, landing.y) - 1
-				};
-				const moved = moveElement([...cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId)), newItem], newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target.getCollisionMode(), {
-					cols: tp.cols,
-					maxRows: tp.maxRows,
-					desired: {
-						w: ds.item.w,
-						h: ds.item.h
-					},
-					allowExchange: false
-				}) });
-				finalLayout = [...tc.compact(moved, tp.cols)];
-			}
-			const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId));
-			if (!tc.allowOverlap && hasNewOverlap(overlappingPairs(targetOthers), finalLayout)) finalLayout = [...targetOthers, placeInFreeSlot(targetOthers, {
-				...ds.item,
-				x: landing.x,
-				y: landing.y
-			}, tp.cols, tp.maxRows)];
-			target.applyLayout(finalLayout, true);
-			onTransferRef.current?.({
-				widgetId: ds.itemId,
-				fromBoardId: ds.sourceBoardId,
-				toBoardId: target.id,
-				item: getLayoutItem(finalLayout, ds.itemId) ?? {
+			const hasValidStrictLanding = targetLandingRef.current?.boardId === target.id && targetLandingRef.current.valid && carried != null;
+			if (strictIncomingSwap && !hasValidStrictLanding) {
+				if (source) source.applyLayout(cloneLayout(sourceSnapshotRef.current), false);
+				const targetSnapshot = targetSnapshotsRef.current.get(target.id);
+				if (targetSnapshot) target.applyLayout(cloneLayout(targetSnapshot), false);
+			} else {
+				if (source) {
+					const sp = source.getPositionParams();
+					const sc = source.getCompactor();
+					const remaining = source.getLayout().filter((l) => l.i !== ds.itemId);
+					source.applyLayout([...sc.compact(remaining, sp.cols)], true);
+				}
+				let finalLayout;
+				if (carried) finalLayout = strictIncomingSwap ? cloneLayout(carried) : [...tc.compact(cloneLayout(carried), tp.cols)];
+				else {
+					const newItem = tc.type === "horizontal" ? {
+						...ds.item,
+						x: Math.max(0, landing.x) - 1,
+						y: landing.y
+					} : {
+						...ds.item,
+						x: landing.x,
+						y: Math.max(0, landing.y) - 1
+					};
+					const moved = moveElement([...cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId)), newItem], newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target.getCollisionMode(), {
+						cols: tp.cols,
+						maxRows: tp.maxRows,
+						desired: {
+							w: ds.item.w,
+							h: ds.item.h
+						},
+						allowExchange: false
+					}) });
+					finalLayout = [...tc.compact(moved, tp.cols)];
+				}
+				const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId));
+				if (!tc.allowOverlap && hasNewOverlap(overlappingPairs(targetOthers), finalLayout)) finalLayout = [...targetOthers, placeInFreeSlot(targetOthers, {
 					...ds.item,
 					x: landing.x,
 					y: landing.y
-				}
-			});
+				}, tp.cols, tp.maxRows)];
+				target.applyLayout(finalLayout, true);
+				onTransferRef.current?.({
+					widgetId: ds.itemId,
+					fromBoardId: ds.sourceBoardId,
+					toBoardId: target.id,
+					item: getLayoutItem(finalLayout, ds.itemId) ?? {
+						...ds.item,
+						x: landing.x,
+						y: landing.y
+					}
+				});
+			}
 		}
 		const ids = new Set(affectedRef.current);
 		ids.add(ds.sourceBoardId);
@@ -674,6 +664,7 @@ function useBoardRegistry(options) {
 		frozenRectsRef.current.clear();
 		nestedInDraggedRef.current = /* @__PURE__ */ new Set();
 		previewRef.current = null;
+		targetLandingRef.current = null;
 		lastLandingRef.current = null;
 		setDragState(null);
 	});