@cube-dev/ui-kit 0.181.0 → 0.183.0

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.181.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.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";
@@ -147,12 +147,12 @@ function useBoardRegistry(options) {
 			if (boardsRef.current.get(entry.id) === entry) boardsRef.current.delete(entry.id);
 		};
 	}, []);
-	const getBoardRect = useCallback((entry) => {
-		const frozen = frozenRectsRef.current.get(entry.id);
+	const getBoardRect = useCallback((entry_0) => {
+		const frozen = frozenRectsRef.current.get(entry_0.id);
 		if (frozen && frozen.width > 0 && frozen.height > 0) return frozen;
-		const live = entry.getContentRect();
+		const live = entry_0.getContentRect();
 		if (live && live.width > 0 && live.height > 0) {
-			frozenRectsRef.current.set(entry.id, live);
+			frozenRectsRef.current.set(entry_0.id, live);
 			return live;
 		}
 		return frozen ?? live;
@@ -169,46 +169,46 @@ function useBoardRegistry(options) {
 	* is still within its container widget (e.g. over a Tabs header sitting above
 	* the board), so an ancestor board does not reflow prematurely.
 	*/
-	const getBoardContainerRect = useCallback((entry) => {
-		return (entry.getContentNode()?.parentElement?.closest("[data-board-widget-host]"))?.getBoundingClientRect() ?? null;
+	const getBoardContainerRect = useCallback((entry_1) => {
+		return (entry_1.getContentNode()?.parentElement?.closest("[data-board-widget-host]"))?.getBoundingClientRect() ?? null;
 	}, []);
 	/** Whether a point falls within a rect (inclusive of edges). */
 	const pointInRect = useCallback((point, rect) => point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom, []);
 	/** Find the most-nested droppable board whose content rect contains a point. */
-	const hitTest = useCallback((point) => {
+	const hitTest = useCallback((point_0) => {
 		let best = null;
 		let bestArea = Infinity;
 		const overlay = overlayRef.current;
-		boardsRef.current.forEach((entry) => {
-			if (!entry.isDroppable()) return;
-			if (nestedInDraggedRef.current.has(entry.id)) return;
-			if (overlay && overlay.contains(entry.getContentNode())) return;
-			const liveRect = entry.getContentRect();
+		boardsRef.current.forEach((entry_2) => {
+			if (!entry_2.isDroppable()) return;
+			if (nestedInDraggedRef.current.has(entry_2.id)) return;
+			if (overlay && overlay.contains(entry_2.getContentNode())) return;
+			const liveRect = entry_2.getContentRect();
 			if (!liveRect || liveRect.width === 0 || liveRect.height === 0) return;
-			const rect = getBoardRect(entry);
-			if (!rect) return;
-			if (point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom) {
-				const area = rect.width * rect.height;
+			const rect_0 = getBoardRect(entry_2);
+			if (!rect_0) return;
+			if (point_0.x >= rect_0.left && point_0.x <= rect_0.right && point_0.y >= rect_0.top && point_0.y <= rect_0.bottom) {
+				const area = rect_0.width * rect_0.height;
 				if (area < bestArea) {
 					bestArea = area;
-					best = entry;
+					best = entry_2;
 				}
 			}
 		});
 		return best;
 	}, [getBoardRect]);
-	const onDragStart = useEvent((boardId, itemId, rect, pointerType, widgetNode) => {
-		const entry = boardsRef.current.get(boardId);
-		const layoutAtStart = entry?.getLayout() ?? [];
-		const item = entry ? getLayoutItem(layoutAtStart, itemId) : void 0;
-		if (!entry || !item) return;
-		const selected = entry.getSelectedKeys();
-		const memberIds = selected && selected.has(itemId) ? layoutAtStart.filter((l) => l.i !== itemId && selected.has(l.i) && (!l.static || l.isDraggable === true)).map((l) => l.i) : [];
+	const onDragStart = useEvent((boardId, itemId, rect_1, pointerType, widgetNode) => {
+		const entry_3 = boardsRef.current.get(boardId);
+		const layoutAtStart = entry_3?.getLayout() ?? [];
+		const item = entry_3 ? getLayoutItem(layoutAtStart, itemId) : void 0;
+		if (!entry_3 || !item) return;
+		const selected = entry_3.getSelectedKeys();
+		const memberIds = selected && selected.has(itemId) ? layoutAtStart.filter((l) => l.i !== itemId && selected.has(l.i) && (!l.static || l.isDraggable === true)).map((l_0) => l_0.i) : [];
 		const itemIds = [itemId, ...memberIds];
 		const memberNodes = widgetNode ? [widgetNode] : [];
 		const memberRects = /* @__PURE__ */ new Map();
 		if (memberIds.length > 0) {
-			const contentNode = entry.getContentNode();
+			const contentNode = entry_3.getContentNode();
 			const idSet = new Set(itemIds);
 			contentNode?.querySelectorAll("[data-board-widget-id]").forEach((el) => {
 				const id = el.dataset.boardWidgetId;
@@ -224,19 +224,19 @@ function useBoardRegistry(options) {
 			});
 		}
 		const nested = /* @__PURE__ */ new Set();
-		if (memberNodes.length > 0) boardsRef.current.forEach((e) => {
-			const node = e.getContentNode();
-			if (node && memberNodes.some((host) => host.contains(node))) nested.add(e.id);
+		if (memberNodes.length > 0) boardsRef.current.forEach((e_0) => {
+			const node = e_0.getContentNode();
+			if (node && memberNodes.some((host_0) => host_0.contains(node))) nested.add(e_0.id);
 		});
 		nestedInDraggedRef.current = nested;
-		const frozen = /* @__PURE__ */ new Map();
-		boardsRef.current.forEach((e) => {
-			const r = e.getContentRect();
-			if (r) frozen.set(e.id, r);
+		const frozen_0 = /* @__PURE__ */ new Map();
+		boardsRef.current.forEach((e_1) => {
+			const r_0 = e_1.getContentRect();
+			if (r_0) frozen_0.set(e_1.id, r_0);
 		});
-		frozenRectsRef.current = frozen;
+		frozenRectsRef.current = frozen_0;
 		affectedRef.current = new Set([boardId]);
-		sourceSnapshotRef.current = cloneLayout(entry.getLayout());
+		sourceSnapshotRef.current = cloneLayout(entry_3.getLayout());
 		previewRef.current = null;
 		lastLandingRef.current = {
 			x: item.x,
@@ -248,7 +248,7 @@ function useBoardRegistry(options) {
 			...item,
 			constraints: item.constraints ?? store.get(itemId)?.constraints
 		};
-		const items = itemIds.map((id) => id === itemId ? draggedItem : getLayoutItem(layoutAtStart, id)).filter((it) => it !== void 0);
+		const items = itemIds.map((id_0) => id_0 === itemId ? draggedItem : getLayoutItem(layoutAtStart, id_0)).filter((it) => it !== void 0);
 		setDragState({
 			sourceBoardId: boardId,
 			currentBoardId: boardId,
@@ -256,21 +256,21 @@ function useBoardRegistry(options) {
 			item: draggedItem,
 			itemIds,
 			items,
-			rect,
-			startRect: rect,
+			rect: rect_1,
+			startRect: rect_1,
 			memberRects,
 			pointerType,
 			nestedBoardIds: nested
 		});
-		entry.setPlaceholders(items.map((it) => ({ ...it })));
+		entry_3.setPlaceholders(items.map((it_0) => ({ ...it_0 })));
 	});
 	/** Compute the constrained landing position of an item on a target board. */
-	const computeLanding = useCallback((target, item, rect) => {
+	const computeLanding = useCallback((target, item_0, rect_2) => {
 		const pp = target.getPositionParams();
 		const contentRect = getBoardRect(target);
-		const localLeft = rect.left - (contentRect?.left ?? 0);
-		const raw = calcXYRaw(pp, rect.top - (contentRect?.top ?? 0), localLeft);
-		return applyPositionConstraints(target.getConstraints(), item, raw.x, raw.y, {
+		const localLeft = rect_2.left - (contentRect?.left ?? 0);
+		const raw = calcXYRaw(pp, rect_2.top - (contentRect?.top ?? 0), localLeft);
+		return applyPositionConstraints(target.getConstraints(), item_0, raw.x, raw.y, {
 			cols: pp.cols,
 			maxRows: target.getMaxRows(),
 			containerWidth: pp.containerWidth,
@@ -280,32 +280,32 @@ function useBoardRegistry(options) {
 			layout: target.getLayout()
 		});
 	}, [getBoardRect]);
-	const moveWithinBoard = useCallback((entry, item, x, y) => {
-		const pp = entry.getPositionParams();
-		const compactor = entry.getCompactor();
-		const layout = entry.getLayout();
-		const collisionMode = compactor.preventCollision ? entry.getCollisionMode() : "revert";
+	const moveWithinBoard = useCallback((entry_4, item_1, x, y) => {
+		const pp_0 = entry_4.getPositionParams();
+		const compactor = entry_4.getCompactor();
+		const layout = entry_4.getLayout();
+		const collisionMode = compactor.preventCollision ? entry_4.getCollisionMode() : "revert";
 		const startLayout = sourceSnapshotRef.current;
-		const base = collisionMode !== "revert" && getLayoutItem(startLayout, item.i) ? startLayout : layout;
-		const working = getLayoutItem(base, item.i) ? cloneLayout(base) : [...cloneLayout(base), {
-			...item,
+		const base = collisionMode !== "revert" && getLayoutItem(startLayout, item_1.i) ? startLayout : layout;
+		const working = getLayoutItem(base, item_1.i) ? cloneLayout(base) : [...cloneLayout(base), {
+			...item_1,
 			x,
 			y
 		}];
-		const target = getLayoutItem(working, item.i);
-		if (!target) return;
-		const moved = moveElement(working, target, x, y, true, compactor.preventCollision, compactor.type, pp.cols, compactor.allowOverlap, { resolveCollision: createCollisionResolver(collisionMode, {
-			cols: pp.cols,
-			maxRows: entry.getMaxRows(),
+		const target_0 = getLayoutItem(working, item_1.i);
+		if (!target_0) return;
+		const moved = moveElement(working, target_0, x, y, true, compactor.preventCollision, compactor.type, pp_0.cols, compactor.allowOverlap, { resolveCollision: createCollisionResolver(collisionMode, {
+			cols: pp_0.cols,
+			maxRows: entry_4.getMaxRows(),
 			desired: {
-				w: target.w,
-				h: target.h
+				w: target_0.w,
+				h: target_0.h
 			}
 		}) });
-		const compacted = [...compactor.compact(moved, pp.cols)];
+		const compacted = [...compactor.compact(moved, pp_0.cols)];
 		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
-		entry.applyLayout(compacted, false);
-		entry.setPlaceholders([getLayoutItem(compacted, item.i)].filter((it) => it !== void 0));
+		entry_4.applyLayout(compacted, false);
+		entry_4.setPlaceholders([getLayoutItem(compacted, item_1.i)].filter((it_1) => it_1 !== void 0));
 	}, []);
 	/**
 	* Move the whole selection rigidly to an absolute delta.
@@ -318,16 +318,16 @@ function useBoardRegistry(options) {
 	* `moveElement` sinking a no-op placement to the bottom of a column;
 	* `moveElements` places the group explicitly, so that does not apply here.
 	*/
-	const moveGroupWithinBoard = useCallback((entry, ds, dx, dy) => {
-		const pp = entry.getPositionParams();
+	const moveGroupWithinBoard = useCallback((entry_5, ds, dx, dy) => {
+		const pp_1 = entry_5.getPositionParams();
 		const result = moveElements(sourceSnapshotRef.current, new Set(ds.itemIds), dx, dy, {
-			compactor: entry.getCompactor(),
-			cols: pp.cols,
-			maxRows: entry.getMaxRows()
+			compactor: entry_5.getCompactor(),
+			cols: pp_1.cols,
+			maxRows: entry_5.getMaxRows()
 		});
 		if (!result.moved) return;
-		entry.applyLayout(result.layout, false);
-		entry.setPlaceholders(ds.itemIds.map((id) => getLayoutItem(result.layout, id)).filter((it) => it !== void 0));
+		entry_5.applyLayout(result.layout, false);
+		entry_5.setPlaceholders(ds.itemIds.map((id_1) => getLayoutItem(result.layout, id_1)).filter((it_2) => it_2 !== void 0));
 	}, []);
 	/**
 	* Move a widget by one logical keyboard step. Unlike pointer movement, this
@@ -335,55 +335,55 @@ function useBoardRegistry(options) {
 	* farther in the requested direction when the adjacent slot cannot produce a
 	* valid move.
 	*/
-	const moveWithKeyboard = useCallback((entry, item, deltaX, deltaY) => {
-		const pp = entry.getPositionParams();
-		const compactor = entry.getCompactor();
-		const layout = entry.getLayout();
-		const live = getLayoutItem(layout, item.i);
-		if (!live) return;
+	const moveWithKeyboard = useCallback((entry_6, item_2, deltaX, deltaY) => {
+		const pp_2 = entry_6.getPositionParams();
+		const compactor_0 = entry_6.getCompactor();
+		const layout_0 = entry_6.getLayout();
+		const live_1 = getLayoutItem(layout_0, item_2.i);
+		if (!live_1) return;
 		const directionX = Math.sign(deltaX);
 		const directionY = Math.sign(deltaY);
 		if (directionX === 0 && directionY === 0) return;
-		const maxRows = entry.getMaxRows();
-		const resolveCollision = compactor.preventCollision ? createCollisionResolver(entry.getCollisionMode(), {
-			cols: pp.cols,
+		const maxRows = entry_6.getMaxRows();
+		const resolveCollision = compactor_0.preventCollision ? createCollisionResolver(entry_6.getCollisionMode(), {
+			cols: pp_2.cols,
 			maxRows,
 			desired: {
-				w: live.w,
-				h: live.h
+				w: live_1.w,
+				h: live_1.h
 			}
 		}) : void 0;
-		const attempts = directionX < 0 ? live.x : directionX > 0 ? Math.max(0, pp.cols - live.w - live.x) : directionY < 0 ? live.y : Number.isFinite(maxRows) ? Math.max(0, maxRows - live.h - live.y) : Math.max(1, bottom(layout) - live.y);
+		const attempts = directionX < 0 ? live_1.x : directionX > 0 ? Math.max(0, pp_2.cols - live_1.w - live_1.x) : directionY < 0 ? live_1.y : Number.isFinite(maxRows) ? Math.max(0, maxRows - live_1.h - live_1.y) : Math.max(1, bottom(layout_0) - live_1.y);
 		const seen = /* @__PURE__ */ new Set();
-		const beforePairs = overlappingPairs(layout);
+		const beforePairs = overlappingPairs(layout_0);
 		for (let distance = 1; distance <= attempts; distance++) {
-			const rawX = live.x + directionX * distance;
-			const rawY = live.y + directionY * distance;
-			const candidate = applyPositionConstraints(entry.getConstraints(), item, rawX, rawY, {
-				cols: pp.cols,
+			const rawX = live_1.x + directionX * distance;
+			const rawY = live_1.y + directionY * distance;
+			const candidate = applyPositionConstraints(entry_6.getConstraints(), item_2, rawX, rawY, {
+				cols: pp_2.cols,
 				maxRows,
-				containerWidth: pp.containerWidth,
-				containerHeight: entry.getContainerHeight(),
-				rowHeight: pp.rowHeight,
-				margin: pp.margin,
-				layout
+				containerWidth: pp_2.containerWidth,
+				containerHeight: entry_6.getContainerHeight(),
+				rowHeight: pp_2.rowHeight,
+				margin: pp_2.margin,
+				layout: layout_0
 			});
 			const candidateKey = `${candidate.x}:${candidate.y}`;
 			if (seen.has(candidateKey)) continue;
 			seen.add(candidateKey);
-			if (directionX !== 0 && (Math.sign(candidate.x - live.x) !== directionX || candidate.y !== live.y) || directionY !== 0 && (Math.sign(candidate.y - live.y) !== directionY || candidate.x !== live.x)) continue;
-			const working = cloneLayout(layout);
-			const target = getLayoutItem(working, item.i);
-			if (!target) return;
-			const moved = moveElement(working, target, candidate.x, candidate.y, true, compactor.preventCollision, compactor.type, pp.cols, compactor.allowOverlap, { resolveCollision });
-			const compacted = [...compactor.compact(moved, pp.cols)];
-			const landed = getLayoutItem(compacted, item.i);
+			if (directionX !== 0 && (Math.sign(candidate.x - live_1.x) !== directionX || candidate.y !== live_1.y) || directionY !== 0 && (Math.sign(candidate.y - live_1.y) !== directionY || candidate.x !== live_1.x)) continue;
+			const working_0 = cloneLayout(layout_0);
+			const target_1 = getLayoutItem(working_0, item_2.i);
+			if (!target_1) return;
+			const moved_0 = moveElement(working_0, target_1, candidate.x, candidate.y, true, compactor_0.preventCollision, compactor_0.type, pp_2.cols, compactor_0.allowOverlap, { resolveCollision });
+			const compacted_0 = [...compactor_0.compact(moved_0, pp_2.cols)];
+			const landed = getLayoutItem(compacted_0, item_2.i);
 			if (!landed) continue;
-			const advanced = directionX !== 0 ? Math.sign(landed.x - live.x) === directionX && landed.y === live.y : Math.sign(landed.y - live.y) === directionY && landed.x === live.x;
-			const overlaps = !compactor.allowOverlap && hasNewOverlap(beforePairs, compacted);
-			if (!advanced || overlaps || resizesAnything(layout, compacted)) continue;
-			entry.applyLayout(compacted, false);
-			entry.setPlaceholders([landed]);
+			const advanced = directionX !== 0 ? Math.sign(landed.x - live_1.x) === directionX && landed.y === live_1.y : Math.sign(landed.y - live_1.y) === directionY && landed.x === live_1.x;
+			const overlaps = !compactor_0.allowOverlap && hasNewOverlap(beforePairs, compacted_0);
+			if (!advanced || overlaps || resizesAnything(layout_0, compacted_0)) continue;
+			entry_6.applyLayout(compacted_0, false);
+			entry_6.setPlaceholders([landed]);
 			lastLandingRef.current = {
 				x: landed.x,
 				y: landed.y
@@ -404,50 +404,50 @@ function useBoardRegistry(options) {
 	* Unlike the pointer path this steps from the live layout, not the drag-start
 	* snapshot, because keyboard moves accumulate one cell at a time.
 	*/
-	const moveGroupWithKeyboard = useCallback((entry, ds, deltaX, deltaY) => {
-		const pp = entry.getPositionParams();
-		const compactor = entry.getCompactor();
-		const layout = entry.getLayout();
-		const live = getLayoutItem(layout, ds.itemId);
-		if (!live) return;
-		const directionX = Math.sign(deltaX);
-		const directionY = Math.sign(deltaY);
-		if (directionX === 0 && directionY === 0) return;
-		const maxRows = entry.getMaxRows();
-		const ids = new Set(ds.itemIds);
-		const members = layout.filter((l) => ids.has(l.i));
+	const moveGroupWithKeyboard = useCallback((entry_7, ds_0, deltaX_0, deltaY_0) => {
+		const pp_3 = entry_7.getPositionParams();
+		const compactor_1 = entry_7.getCompactor();
+		const layout_1 = entry_7.getLayout();
+		const live_2 = getLayoutItem(layout_1, ds_0.itemId);
+		if (!live_2) return;
+		const directionX_0 = Math.sign(deltaX_0);
+		const directionY_0 = Math.sign(deltaY_0);
+		if (directionX_0 === 0 && directionY_0 === 0) return;
+		const maxRows_0 = entry_7.getMaxRows();
+		const ids = new Set(ds_0.itemIds);
+		const members = layout_1.filter((l_1) => ids.has(l_1.i));
 		if (members.length === 0) return;
-		const attempts = directionX < 0 ? Math.min(...members.map((l) => l.x)) : directionX > 0 ? Math.min(...members.map((l) => pp.cols - l.w - l.x)) : directionY < 0 ? Math.min(...members.map((l) => l.y)) : Number.isFinite(maxRows) ? Math.min(...members.map((l) => maxRows - l.h - l.y)) : Math.max(1, bottom(layout) - live.y);
-		const seen = /* @__PURE__ */ new Set();
-		const beforePairs = overlappingPairs(layout);
-		for (let distance = 1; distance <= Math.max(0, attempts); distance++) {
-			const candidate = applyPositionConstraints(entry.getConstraints(), ds.item, live.x + directionX * distance, live.y + directionY * distance, {
-				cols: pp.cols,
-				maxRows,
-				containerWidth: pp.containerWidth,
-				containerHeight: entry.getContainerHeight(),
-				rowHeight: pp.rowHeight,
-				margin: pp.margin,
-				layout
+		const attempts_0 = directionX_0 < 0 ? Math.min(...members.map((l_2) => l_2.x)) : directionX_0 > 0 ? Math.min(...members.map((l_3) => pp_3.cols - l_3.w - l_3.x)) : directionY_0 < 0 ? Math.min(...members.map((l_4) => l_4.y)) : Number.isFinite(maxRows_0) ? Math.min(...members.map((l_5) => maxRows_0 - l_5.h - l_5.y)) : Math.max(1, bottom(layout_1) - live_2.y);
+		const seen_0 = /* @__PURE__ */ new Set();
+		const beforePairs_0 = overlappingPairs(layout_1);
+		for (let distance_0 = 1; distance_0 <= Math.max(0, attempts_0); distance_0++) {
+			const candidate_0 = applyPositionConstraints(entry_7.getConstraints(), ds_0.item, live_2.x + directionX_0 * distance_0, live_2.y + directionY_0 * distance_0, {
+				cols: pp_3.cols,
+				maxRows: maxRows_0,
+				containerWidth: pp_3.containerWidth,
+				containerHeight: entry_7.getContainerHeight(),
+				rowHeight: pp_3.rowHeight,
+				margin: pp_3.margin,
+				layout: layout_1
 			});
-			const candidateKey = `${candidate.x}:${candidate.y}`;
-			if (seen.has(candidateKey)) continue;
-			seen.add(candidateKey);
-			if (directionX !== 0 && (Math.sign(candidate.x - live.x) !== directionX || candidate.y !== live.y) || directionY !== 0 && (Math.sign(candidate.y - live.y) !== directionY || candidate.x !== live.x)) continue;
-			const result = moveElements(layout, ids, candidate.x - live.x, candidate.y - live.y, {
-				compactor,
-				cols: pp.cols,
-				maxRows
+			const candidateKey_0 = `${candidate_0.x}:${candidate_0.y}`;
+			if (seen_0.has(candidateKey_0)) continue;
+			seen_0.add(candidateKey_0);
+			if (directionX_0 !== 0 && (Math.sign(candidate_0.x - live_2.x) !== directionX_0 || candidate_0.y !== live_2.y) || directionY_0 !== 0 && (Math.sign(candidate_0.y - live_2.y) !== directionY_0 || candidate_0.x !== live_2.x)) continue;
+			const result_0 = moveElements(layout_1, ids, candidate_0.x - live_2.x, candidate_0.y - live_2.y, {
+				compactor: compactor_1,
+				cols: pp_3.cols,
+				maxRows: maxRows_0
 			});
-			if (!result.moved) continue;
-			const landed = getLayoutItem(result.layout, ds.itemId);
-			if (!landed) continue;
-			if (!(directionX !== 0 ? Math.sign(landed.x - live.x) === directionX && landed.y === live.y : Math.sign(landed.y - live.y) === directionY && landed.x === live.x) || !compactor.allowOverlap && hasNewOverlap(beforePairs, result.layout)) continue;
-			entry.applyLayout(result.layout, false);
-			entry.setPlaceholders(ds.itemIds.map((id) => getLayoutItem(result.layout, id)).filter((it) => it !== void 0));
+			if (!result_0.moved) continue;
+			const landed_0 = getLayoutItem(result_0.layout, ds_0.itemId);
+			if (!landed_0) continue;
+			if (!(directionX_0 !== 0 ? Math.sign(landed_0.x - live_2.x) === directionX_0 && landed_0.y === live_2.y : Math.sign(landed_0.y - live_2.y) === directionY_0 && landed_0.x === live_2.x) || !compactor_1.allowOverlap && hasNewOverlap(beforePairs_0, result_0.layout)) continue;
+			entry_7.applyLayout(result_0.layout, false);
+			entry_7.setPlaceholders(ds_0.itemIds.map((id_2) => getLayoutItem(result_0.layout, id_2)).filter((it_3) => it_3 !== void 0));
 			lastLandingRef.current = {
-				x: landed.x,
-				y: landed.y
+				x: landed_0.x,
+				y: landed_0.y
 			};
 			return;
 		}
@@ -466,206 +466,206 @@ function useBoardRegistry(options) {
 	* (the "pushed too far below" bug). On (re-)entry the working layout is seeded
 	* from a *clone* of the snapshot so the stored snapshot is never mutated.
 	*/
-	const previewOnTarget = useCallback((target, item, x, y) => {
-		const pp = target.getPositionParams();
-		const compactor = target.getCompactor();
-		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;
-		const dragged = prevItem ? prevItem.x === x && prevItem.y === y ? { ...prevItem } : {
+	const previewOnTarget = useCallback((target_2, item_3, x_0, y_0) => {
+		const pp_4 = target_2.getPositionParams();
+		const compactor_2 = target_2.getCompactor();
+		const carried = previewRef.current?.boardId === target_2.id ? previewRef.current.working : null;
+		const base_0 = cloneLayout(carried ?? targetSnapshotsRef.current.get(target_2.id) ?? target_2.getLayout()).filter((l_6) => l_6.i !== item_3.i);
+		const prevItem = carried ? getLayoutItem(carried, item_3.i) : void 0;
+		const dragged = prevItem ? prevItem.x === x_0 && prevItem.y === y_0 ? { ...prevItem } : {
 			...prevItem,
-			w: item.w,
-			h: item.h
-		} : compactor.type === "horizontal" ? {
-			...item,
-			x: Math.max(0, x) - 1,
-			y
+			w: item_3.w,
+			h: item_3.h
+		} : compactor_2.type === "horizontal" ? {
+			...item_3,
+			x: Math.max(0, x_0) - 1,
+			y: y_0
 		} : {
-			...item,
-			x,
-			y: Math.max(0, y) - 1
+			...item_3,
+			x: x_0,
+			y: Math.max(0, y_0) - 1
 		};
-		const working = [...base, dragged];
+		const working_1 = [...base_0, dragged];
 		const origin = {
 			x: dragged.x,
 			y: dragged.y
 		};
-		const moved = moveElement(working, dragged, x, y, true, compactor.preventCollision, compactor.type, pp.cols, compactor.allowOverlap, { resolveCollision: compactor.preventCollision ? createCollisionResolver(target.getCollisionMode(), {
-			cols: pp.cols,
-			maxRows: target.getMaxRows(),
+		const moved_1 = moveElement(working_1, dragged, x_0, y_0, true, compactor_2.preventCollision, compactor_2.type, pp_4.cols, compactor_2.allowOverlap, { resolveCollision: compactor_2.preventCollision ? createCollisionResolver(target_2.getCollisionMode(), {
+			cols: pp_4.cols,
+			maxRows: target_2.getMaxRows(),
 			desired: {
-				w: item.w,
-				h: item.h
+				w: item_3.w,
+				h: item_3.h
 			},
 			allowExchange: false
 		}) : void 0 });
-		const compacted = [...compactor.compact(prevItem ? moved : landIncoming(moved, base, item.i, origin, {
-			x,
-			y
-		}, pp.cols, target.getMaxRows()), pp.cols)];
-		const landed = getLayoutItem(compacted, item.i);
-		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
+		const compacted_1 = [...compactor_2.compact(prevItem ? moved_1 : landIncoming(moved_1, base_0, item_3.i, origin, {
+			x: x_0,
+			y: y_0
+		}, pp_4.cols, target_2.getMaxRows()), pp_4.cols)];
+		const landed_1 = getLayoutItem(compacted_1, item_3.i);
+		if (!compactor_2.allowOverlap && hasNewOverlap(overlappingPairs(base_0), compacted_1)) return;
 		previewRef.current = {
-			boardId: target.id,
-			working: compacted
+			boardId: target_2.id,
+			working: compacted_1
 		};
-		const previewItem = landed ?? {
-			...item,
-			x,
-			y
+		const previewItem = landed_1 ?? {
+			...item_3,
+			x: x_0,
+			y: y_0
 		};
-		target.applyLayout(compacted.filter((l) => l.i !== item.i), false);
-		target.setPlaceholders([{ ...previewItem }]);
+		target_2.applyLayout(compacted_1.filter((l_7) => l_7.i !== item_3.i), false);
+		target_2.setPlaceholders([{ ...previewItem }]);
 	}, []);
-	const onDragMove = useEvent((deltaX, deltaY, pointerType) => {
-		const ds = dragStateRef.current;
-		if (!ds) return;
-		const isGroup = ds.itemIds.length > 1;
-		if (pointerType === "keyboard") {
-			const source = boardsRef.current.get(ds.sourceBoardId);
+	const onDragMove = useEvent((deltaX_1, deltaY_1, pointerType_0) => {
+		const ds_1 = dragStateRef.current;
+		if (!ds_1) return;
+		const isGroup = ds_1.itemIds.length > 1;
+		if (pointerType_0 === "keyboard") {
+			const source = boardsRef.current.get(ds_1.sourceBoardId);
 			if (!source) return;
-			if (isGroup) moveGroupWithKeyboard(source, ds, deltaX, deltaY);
-			else moveWithKeyboard(source, ds.item, deltaX, deltaY);
+			if (isGroup) moveGroupWithKeyboard(source, ds_1, deltaX_1, deltaY_1);
+			else moveWithKeyboard(source, ds_1.item, deltaX_1, deltaY_1);
 			return;
 		}
 		const newRect = {
-			...ds.rect,
-			left: ds.rect.left + deltaX,
-			top: ds.rect.top + deltaY
+			...ds_1.rect,
+			left: ds_1.rect.left + deltaX_1,
+			top: ds_1.rect.top + deltaY_1
 		};
-		const source = boardsRef.current.get(ds.sourceBoardId);
+		const source_0 = boardsRef.current.get(ds_1.sourceBoardId);
 		const anchor = rectCenter(newRect);
-		let target = isGroup ? source : hitTest(anchor) ?? source ?? null;
-		if (target && source && target.id !== source.id && isAncestorBoard(target, source)) {
-			const containerRect = getBoardContainerRect(source);
+		let target_3 = isGroup ? source_0 : hitTest(anchor) ?? source_0 ?? null;
+		if (target_3 && source_0 && target_3.id !== source_0.id && isAncestorBoard(target_3, source_0)) {
+			const containerRect = getBoardContainerRect(source_0);
 			const gatePoint = pointerPosRef.current ?? anchor;
-			if (containerRect && pointInRect(gatePoint, containerRect)) target = source;
+			if (containerRect && pointInRect(gatePoint, containerRect)) target_3 = source_0;
 		}
-		if (!target) {
+		if (!target_3) {
 			setDragState({
-				...ds,
+				...ds_1,
 				rect: newRect
 			});
 			return;
 		}
-		const { x, y } = computeLanding(target, ds.item, newRect);
+		const { x: x_1, y: y_1 } = computeLanding(target_3, ds_1.item, newRect);
 		lastLandingRef.current = {
-			x,
-			y
+			x: x_1,
+			y: y_1
 		};
-		if (target.id === ds.sourceBoardId) {
-			if (ds.currentBoardId !== ds.sourceBoardId) {
-				const prev = boardsRef.current.get(ds.currentBoardId);
-				const snap = targetSnapshotsRef.current.get(ds.currentBoardId);
+		if (target_3.id === ds_1.sourceBoardId) {
+			if (ds_1.currentBoardId !== ds_1.sourceBoardId) {
+				const prev = boardsRef.current.get(ds_1.currentBoardId);
+				const snap = targetSnapshotsRef.current.get(ds_1.currentBoardId);
 				if (snap) prev?.applyLayout(cloneLayout(snap), false);
 				prev?.setPlaceholders([]);
 				previewRef.current = null;
 			}
-			if (isGroup) moveGroupWithinBoard(target, ds, x - ds.item.x, y - ds.item.y);
-			else moveWithinBoard(target, ds.item, x, y);
+			if (isGroup) moveGroupWithinBoard(target_3, ds_1, x_1 - ds_1.item.x, y_1 - ds_1.item.y);
+			else moveWithinBoard(target_3, ds_1.item, x_1, y_1);
 			setDragState({
-				...ds,
-				currentBoardId: ds.sourceBoardId,
+				...ds_1,
+				currentBoardId: ds_1.sourceBoardId,
 				rect: newRect
 			});
 			return;
 		}
-		if (ds.currentBoardId !== target.id) {
-			const prev = boardsRef.current.get(ds.currentBoardId);
-			if (ds.currentBoardId === ds.sourceBoardId) prev?.applyLayout(cloneLayout(sourceSnapshotRef.current), false);
+		if (ds_1.currentBoardId !== target_3.id) {
+			const prev_0 = boardsRef.current.get(ds_1.currentBoardId);
+			if (ds_1.currentBoardId === ds_1.sourceBoardId) prev_0?.applyLayout(cloneLayout(sourceSnapshotRef.current), false);
 			else {
-				const snap = targetSnapshotsRef.current.get(ds.currentBoardId);
-				if (snap) prev?.applyLayout(cloneLayout(snap), false);
+				const snap_0 = targetSnapshotsRef.current.get(ds_1.currentBoardId);
+				if (snap_0) prev_0?.applyLayout(cloneLayout(snap_0), false);
 			}
-			prev?.setPlaceholders([]);
+			prev_0?.setPlaceholders([]);
 			previewRef.current = null;
-			if (!targetSnapshotsRef.current.has(target.id)) targetSnapshotsRef.current.set(target.id, cloneLayout(target.getLayout()));
+			if (!targetSnapshotsRef.current.has(target_3.id)) targetSnapshotsRef.current.set(target_3.id, cloneLayout(target_3.getLayout()));
 		}
-		previewOnTarget(target, ds.item, x, y);
-		affectedRef.current.add(target.id);
+		previewOnTarget(target_3, ds_1.item, x_1, y_1);
+		affectedRef.current.add(target_3.id);
 		setDragState({
-			...ds,
-			currentBoardId: target.id,
+			...ds_1,
+			currentBoardId: target_3.id,
 			rect: newRect
 		});
 	});
 	const onDragEnd = useEvent(() => {
 		window.removeEventListener("pointermove", trackPointer, true);
 		pointerPosRef.current = null;
-		const ds = dragStateRef.current;
-		if (!ds) return;
-		const source = boardsRef.current.get(ds.sourceBoardId);
-		const target = boardsRef.current.get(ds.currentBoardId);
-		if (!target || target.id === ds.sourceBoardId) {
-			if (source) {
-				const sp = source.getPositionParams();
-				const sc = source.getCompactor();
-				source.applyLayout([...sc.compact(source.getLayout(), sp.cols)], true, "drag");
+		const ds_2 = dragStateRef.current;
+		if (!ds_2) return;
+		const source_1 = boardsRef.current.get(ds_2.sourceBoardId);
+		const target_4 = boardsRef.current.get(ds_2.currentBoardId);
+		if (!target_4 || target_4.id === ds_2.sourceBoardId) {
+			if (source_1) {
+				const sp = source_1.getPositionParams();
+				const sc = source_1.getCompactor();
+				source_1.applyLayout([...sc.compact(source_1.getLayout(), sp.cols)], true, "drag");
 			}
 		} else {
 			const landing = lastLandingRef.current ?? {
-				x: ds.item.x,
-				y: ds.item.y
+				x: ds_2.item.x,
+				y: ds_2.item.y
 			};
-			const tp = target.getPositionParams();
-			const tc = target.getCompactor();
-			const carried = previewRef.current?.boardId === target.id && getLayoutItem(previewRef.current.working, ds.itemId) ? previewRef.current.working : null;
-			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, "transfer");
+			const tp = target_4.getPositionParams();
+			const tc = target_4.getCompactor();
+			const carried_0 = previewRef.current?.boardId === target_4.id && getLayoutItem(previewRef.current.working, ds_2.itemId) ? previewRef.current.working : null;
+			if (source_1) {
+				const sp_0 = source_1.getPositionParams();
+				const sc_0 = source_1.getCompactor();
+				const remaining = source_1.getLayout().filter((l_8) => l_8.i !== ds_2.itemId);
+				source_1.applyLayout([...sc_0.compact(remaining, sp_0.cols)], true, "transfer");
 			}
 			let finalLayout;
-			if (carried) finalLayout = [...tc.compact(cloneLayout(carried), tp.cols)];
+			if (carried_0) finalLayout = [...tc.compact(cloneLayout(carried_0), tp.cols)];
 			else {
 				const newItem = tc.type === "horizontal" ? {
-					...ds.item,
+					...ds_2.item,
 					x: Math.max(0, landing.x) - 1,
 					y: landing.y
 				} : {
-					...ds.item,
+					...ds_2.item,
 					x: landing.x,
 					y: Math.max(0, landing.y) - 1
 				};
-				const base = [...cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId)), newItem];
+				const base_1 = [...cloneLayout((targetSnapshotsRef.current.get(target_4.id) ?? target_4.getLayout()).filter((l_9) => l_9.i !== ds_2.itemId)), newItem];
 				const seed = {
 					x: newItem.x,
 					y: newItem.y
 				};
-				const moved = moveElement(base, newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target.getCollisionMode(), {
+				const moved_2 = moveElement(base_1, newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target_4.getCollisionMode(), {
 					cols: tp.cols,
 					maxRows: tp.maxRows,
 					desired: {
-						w: ds.item.w,
-						h: ds.item.h
+						w: ds_2.item.w,
+						h: ds_2.item.h
 					},
 					allowExchange: false
 				}) });
-				finalLayout = [...tc.compact(landIncoming(moved, base.filter((l) => l.i !== ds.itemId), ds.itemId, seed, landing, tp.cols, tp.maxRows), tp.cols)];
+				finalLayout = [...tc.compact(landIncoming(moved_2, base_1.filter((l_10) => l_10.i !== ds_2.itemId), ds_2.itemId, seed, landing, tp.cols, tp.maxRows), tp.cols)];
 			}
-			const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId));
+			const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target_4.id) ?? target_4.getLayout()).filter((l_11) => l_11.i !== ds_2.itemId));
 			if (!tc.allowOverlap && hasNewOverlap(overlappingPairs(targetOthers), finalLayout)) finalLayout = [...targetOthers, placeInFreeSlot(targetOthers, {
-				...ds.item,
+				...ds_2.item,
 				x: landing.x,
 				y: landing.y
 			}, tp.cols, tp.maxRows)];
-			target.applyLayout(finalLayout, true, "transfer");
+			target_4.applyLayout(finalLayout, true, "transfer");
 			onTransferRef.current?.({
-				widgetId: ds.itemId,
-				fromBoardId: ds.sourceBoardId,
-				toBoardId: target.id,
-				item: getLayoutItem(finalLayout, ds.itemId) ?? {
-					...ds.item,
+				widgetId: ds_2.itemId,
+				fromBoardId: ds_2.sourceBoardId,
+				toBoardId: target_4.id,
+				item: getLayoutItem(finalLayout, ds_2.itemId) ?? {
+					...ds_2.item,
 					x: landing.x,
 					y: landing.y
 				}
 			});
 		}
-		const ids = new Set(affectedRef.current);
-		ids.add(ds.sourceBoardId);
-		ids.add(ds.currentBoardId);
-		ids.forEach((id) => boardsRef.current.get(id)?.setPlaceholders([]));
+		const ids_0 = new Set(affectedRef.current);
+		ids_0.add(ds_2.sourceBoardId);
+		ids_0.add(ds_2.currentBoardId);
+		ids_0.forEach((id_3) => boardsRef.current.get(id_3)?.setPlaceholders([]));
 		affectedRef.current.clear();
 		sourceSnapshotRef.current = [];
 		targetSnapshotsRef.current.clear();