@cube-dev/ui-kit 0.0.0-canary-c325dcb → 0.0.0-canary-162cdb3

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

@@ -1,700 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c325dcb | 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";
-import { applyPositionConstraints } from "./grid-core/constraints.js";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-
-//#region src/components/layout/Board/use-board-registry.ts
-/**
-* The dragged widget's center in viewport coordinates.
-*
-* This is the anchor the drop-target hit-test uses to pick which board a drag is
-* over, so a board (including an empty one) opens as soon as the widget's center
-* enters it rather than only once its whole top-left corner is inside.
-*
-* The landing itself stays anchored to the grabbed top-left (`rect.left/top` in
-* `computeLanding`): that point is this center offset by the widget's own fixed
-* pixel size, so the resolved landing cell keeps corresponding to where the
-* floating overlay clone is drawn (see `WidgetHost`) and the placeholder keeps
-* tracking the ghost. The only unavoidable divergence is while the widget
-* physically overhangs a board edge - a placeholder cannot render outside row 0
-* / column 0 - which is the accepted tradeoff for opening on the center.
-*/
-function rectCenter(rect) {
-	return {
-		x: rect.left + rect.width / 2,
-		y: rect.top + rect.height / 2
-	};
-}
-/**
-* Canonical key for the unordered pair `{id1, id2}`. Widget ids are unrestricted
-* strings, so a naive `` `${id1}|${id2}` `` join is ambiguous - an id containing
-* the delimiter lets two different pairs collide (e.g. `{"a|b","c"}` and
-* `{"a","b|c"}` both yield `"a|b|c"`). `JSON.stringify` of the sorted tuple
-* quotes and escapes each id, so distinct pairs always produce distinct keys.
-*/
-function pairKey(id1, id2) {
-	return id1 < id2 ? JSON.stringify([id1, id2]) : JSON.stringify([id2, id1]);
-}
-/**
-* Keys of every overlapping pair in the layout (see `pairKey`), so two layouts'
-* overlap sets can be compared to tell which overlaps a move *introduced* versus
-* which already existed.
-*/
-function overlappingPairs(layout) {
-	const pairs = /* @__PURE__ */ new Set();
-	for (let i = 0; i < layout.length; i++) for (let j = i + 1; j < layout.length; j++) {
-		const a = layout[i];
-		const b = layout[j];
-		if (collides(a, b)) pairs.add(pairKey(a.i, b.i));
-	}
-	return pairs;
-}
-/**
-* Whether `after` contains an overlapping pair that `before` did not. Used to
-* reject only moves that *create* a new stack. A board may already hold
-* overlapping widgets - a `compact={null}` layout is never gap-compacted, and an
-* app can supply overlapping items directly (or toggle `allowOverlap` off after
-* stacking) - and those pre-existing overlaps must not freeze every subsequent
-* move by making a whole-layout collision check always true.
-*/
-function hasNewOverlap(before, after) {
-	const afterPairs = overlappingPairs(after);
-	for (const key of afterPairs) if (!before.has(key)) return true;
-	return false;
-}
-/**
-* Where a cross-board arrival ends up when the destination refuses the very first
-* cell it was offered.
-*
-* `moveElement` answers a refused placement by restoring the item to where it
-* came from. Every frame after the first has a real cell to go back to - the one
-* the previous frame settled on - so the preview simply holds there, which is
-* what keeps the placeholder from jumping about as the pointer sweeps across an
-* occupied widget. The *first* frame on a board has no such cell: its origin is
-* the synthetic seed one row above (or column left of) the anchor, which sits off
-* the board entirely whenever the anchor is in row 0 or column 0. Holding that
-* would preview - and commit - a widget outside the grid.
-*
-* So only that first frame relocates, to the nearest cell that can hold the
-* widget. The destination's own widgets are the fixed `others`: an arrival is
-* placed around them and never displaces one.
-*
-* A refusal is read off `origin` - the seed itself - rather than off the
-* requested cell, because a resolver is allowed to place the widget somewhere
-* other than the exact cell asked for (downscaling into room the anchor clamp hid
-* from the pointer does exactly that). Only an item sitting back on its origin was
-* actually refused; anything else is a resolution and stands.
-*/
-function landIncoming(layout, others, itemId, origin, landing, cols, maxRows) {
-	const placed = getLayoutItem(layout, itemId);
-	if (!placed || placed.x !== origin.x || placed.y !== origin.y) return layout;
-	const landed = placeInFreeSlot(others, {
-		...placed,
-		...landing
-	}, cols, maxRows);
-	return layout.map((l) => l.i === itemId ? {
-		...l,
-		...landed
-	} : l);
-}
-/**
-* Whether any item in `after` has a different size than it had in `before`.
-*/
-function resizesAnything(before, after) {
-	return after.some((a) => {
-		const b = before.find((it) => it.i === a.i);
-		return !!b && (b.w !== a.w || b.h !== a.h);
-	});
-}
-function useBoardRegistry(options) {
-	const store = useMemo(() => new BoardWidgetStore(), []);
-	const onTransferRef = useRef(options?.onWidgetTransfer);
-	onTransferRef.current = options?.onWidgetTransfer;
-	const overlayRef = useRef(null);
-	const boardsRef = useRef(/* @__PURE__ */ new Map());
-	const dragStateRef = useRef(null);
-	const affectedRef = useRef(/* @__PURE__ */ new Set());
-	const sourceSnapshotRef = useRef([]);
-	const targetSnapshotsRef = useRef(/* @__PURE__ */ new Map());
-	const previewRef = useRef(null);
-	const frozenRectsRef = useRef(/* @__PURE__ */ new Map());
-	const nestedInDraggedRef = useRef(/* @__PURE__ */ new Set());
-	const lastLandingRef = useRef(null);
-	const pointerPosRef = useRef(null);
-	const [dragState, setDragStateInternal] = useState(null);
-	const setDragState = useCallback((next) => {
-		dragStateRef.current = next;
-		setDragStateInternal(next);
-	}, []);
-	const getDragState = useCallback(() => dragStateRef.current, []);
-	const trackPointer = useCallback((e) => {
-		pointerPosRef.current = {
-			x: e.clientX,
-			y: e.clientY
-		};
-	}, []);
-	useEffect(() => () => window.removeEventListener("pointermove", trackPointer, true), [trackPointer]);
-	const registerBoard = useCallback((entry) => {
-		boardsRef.current.set(entry.id, entry);
-		return () => {
-			if (boardsRef.current.get(entry.id) === entry) boardsRef.current.delete(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_0.getContentRect();
-		if (live && live.width > 0 && live.height > 0) {
-			frozenRectsRef.current.set(entry_0.id, live);
-			return live;
-		}
-		return frozen ?? live;
-	}, []);
-	/** True when board `outer` DOM-contains board `inner` (outer is an ancestor). */
-	const isAncestorBoard = useCallback((outer, inner) => {
-		const outerNode = outer.getContentNode();
-		const innerNode = inner.getContentNode();
-		return !!outerNode && !!innerNode && outerNode.contains(innerNode);
-	}, []);
-	/**
-	* Viewport rect of the widget host a nested board lives in, or null for a
-	* top-level board. Lets a drag stay anchored to a nested board while the anchor
-	* 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_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_0) => {
-		let best = null;
-		let bestArea = Infinity;
-		const overlay = overlayRef.current;
-		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_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_2;
-				}
-			}
-		});
-		return best;
-	}, [getBoardRect]);
-	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_3.getContentNode();
-			const idSet = new Set(itemIds);
-			contentNode?.querySelectorAll("[data-board-widget-id]").forEach((el) => {
-				const id = el.dataset.boardWidgetId;
-				if (!id || !idSet.has(id)) return;
-				if (id !== itemId) memberNodes.push(el);
-				const r = el.getBoundingClientRect();
-				memberRects.set(id, {
-					left: r.left,
-					top: r.top,
-					width: r.width,
-					height: r.height
-				});
-			});
-		}
-		const nested = /* @__PURE__ */ new Set();
-		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_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_0;
-		affectedRef.current = new Set([boardId]);
-		sourceSnapshotRef.current = cloneLayout(entry_3.getLayout());
-		previewRef.current = null;
-		lastLandingRef.current = {
-			x: item.x,
-			y: item.y
-		};
-		pointerPosRef.current = null;
-		if (pointerType !== "keyboard") window.addEventListener("pointermove", trackPointer, true);
-		const draggedItem = {
-			...item,
-			constraints: item.constraints ?? store.get(itemId)?.constraints
-		};
-		const items = itemIds.map((id_0) => id_0 === itemId ? draggedItem : getLayoutItem(layoutAtStart, id_0)).filter((it) => it !== void 0);
-		setDragState({
-			sourceBoardId: boardId,
-			currentBoardId: boardId,
-			itemId,
-			item: draggedItem,
-			itemIds,
-			items,
-			rect: rect_1,
-			startRect: rect_1,
-			memberRects,
-			pointerType,
-			nestedBoardIds: nested
-		});
-		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_0, rect_2) => {
-		const pp = target.getPositionParams();
-		const contentRect = getBoardRect(target);
-		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,
-			containerHeight: target.getContainerHeight(),
-			rowHeight: pp.rowHeight,
-			margin: pp.margin,
-			layout: target.getLayout()
-		});
-	}, [getBoardRect]);
-	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_1.i) ? startLayout : layout;
-		const working = getLayoutItem(base, item_1.i) ? cloneLayout(base) : [...cloneLayout(base), {
-			...item_1,
-			x,
-			y
-		}];
-		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_0.w,
-				h: target_0.h
-			}
-		}) });
-		const compacted = [...compactor.compact(moved, pp_0.cols)];
-		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
-		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.
-	*
-	* Unlike the single-widget path, each frame is recomputed from the drag-start
-	* snapshot rather than from the previous frame. A rigid group at an absolute
-	* delta is a pure function of that delta, so dragging back retraces the
-	* arrangement exactly, pushed neighbours never accumulate, and there is no
-	* hysteresis. The single path's frame-to-frame continuity exists to stop
-	* `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_5, ds, dx, dy) => {
-		const pp_1 = entry_5.getPositionParams();
-		const result = moveElements(sourceSnapshotRef.current, new Set(ds.itemIds), dx, dy, {
-			compactor: entry_5.getCompactor(),
-			cols: pp_1.cols,
-			maxRows: entry_5.getMaxRows()
-		});
-		if (!result.moved) return;
-		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
-	* starts from the live grid coordinates rather than DOM geometry and scans
-	* farther in the requested direction when the adjacent slot cannot produce a
-	* valid move.
-	*/
-	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_6.getMaxRows();
-		const resolveCollision = compactor_0.preventCollision ? createCollisionResolver(entry_6.getCollisionMode(), {
-			cols: pp_2.cols,
-			maxRows,
-			desired: {
-				w: live_1.w,
-				h: live_1.h
-			}
-		}) : void 0;
-		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_0);
-		for (let distance = 1; distance <= attempts; distance++) {
-			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_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_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_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
-			};
-			return;
-		}
-	}, []);
-	/**
-	* Keyboard equivalent of `moveGroupWithinBoard`: scan outward for the nearest
-	* whole-group delta that resolves cleanly.
-	*
-	* Constraints are resolved through the **grabbed** widget only, and the delta
-	* it yields is applied to the rest. `applyPositionConstraints` returns an
-	* absolute position, so running it per member would shear the group apart
-	* under `snapToGrid` or any app constraint — and the grabbed widget is the one
-	* the user is aiming with.
-	*
-	* 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_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_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_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_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_0.x,
-				y: landed_0.y
-			};
-			return;
-		}
-	}, []);
-	/**
-	* Live cross-board reflow preview. Pushes the target board's *other* widgets
-	* aside to make room for the incoming item, without ever adding the dragged
-	* item's host to the target (it stays visualized as a placeholder + overlay
-	* clone, and its gesture host remains mounted in the source board).
-	*
-	* Continuity: the working layout (including the incoming item) is carried
-	* across frames via `previewRef`, so a small pointer movement moves the item
-	* one step and reflows the neighbours incrementally - identical to an in-board
-	* drag. Recomputing from the clean snapshot every frame instead lets
-	* `moveElement`/compaction sink the item to the bottom of an occupied column
-	* (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_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_3.w,
-			h: item_3.h
-		} : compactor_2.type === "horizontal" ? {
-			...item_3,
-			x: Math.max(0, x_0) - 1,
-			y: y_0
-		} : {
-			...item_3,
-			x: x_0,
-			y: Math.max(0, y_0) - 1
-		};
-		const working_1 = [...base_0, dragged];
-		const origin = {
-			x: dragged.x,
-			y: dragged.y
-		};
-		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_3.w,
-				h: item_3.h
-			},
-			allowExchange: false
-		}) : void 0 });
-		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_2.id,
-			working: compacted_1
-		};
-		const previewItem = landed_1 ?? {
-			...item_3,
-			x: x_0,
-			y: y_0
-		};
-		target_2.applyLayout(compacted_1.filter((l_7) => l_7.i !== item_3.i), false);
-		target_2.setPlaceholders([{ ...previewItem }]);
-	}, []);
-	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_1, deltaX_1, deltaY_1);
-			else moveWithKeyboard(source, ds_1.item, deltaX_1, deltaY_1);
-			return;
-		}
-		const newRect = {
-			...ds_1.rect,
-			left: ds_1.rect.left + deltaX_1,
-			top: ds_1.rect.top + deltaY_1
-		};
-		const source_0 = boardsRef.current.get(ds_1.sourceBoardId);
-		const anchor = rectCenter(newRect);
-		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_3 = source_0;
-		}
-		if (!target_3) {
-			setDragState({
-				...ds_1,
-				rect: newRect
-			});
-			return;
-		}
-		const { x: x_1, y: y_1 } = computeLanding(target_3, ds_1.item, newRect);
-		lastLandingRef.current = {
-			x: x_1,
-			y: y_1
-		};
-		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_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_1,
-				currentBoardId: ds_1.sourceBoardId,
-				rect: newRect
-			});
-			return;
-		}
-		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_0 = targetSnapshotsRef.current.get(ds_1.currentBoardId);
-				if (snap_0) prev_0?.applyLayout(cloneLayout(snap_0), false);
-			}
-			prev_0?.setPlaceholders([]);
-			previewRef.current = null;
-			if (!targetSnapshotsRef.current.has(target_3.id)) targetSnapshotsRef.current.set(target_3.id, cloneLayout(target_3.getLayout()));
-		}
-		previewOnTarget(target_3, ds_1.item, x_1, y_1);
-		affectedRef.current.add(target_3.id);
-		setDragState({
-			...ds_1,
-			currentBoardId: target_3.id,
-			rect: newRect
-		});
-	});
-	const onDragEnd = useEvent(() => {
-		window.removeEventListener("pointermove", trackPointer, true);
-		pointerPosRef.current = null;
-		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_2.item.x,
-				y: ds_2.item.y
-			};
-			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_0) finalLayout = [...tc.compact(cloneLayout(carried_0), tp.cols)];
-			else {
-				const newItem = tc.type === "horizontal" ? {
-					...ds_2.item,
-					x: Math.max(0, landing.x) - 1,
-					y: landing.y
-				} : {
-					...ds_2.item,
-					x: landing.x,
-					y: Math.max(0, landing.y) - 1
-				};
-				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_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_2.item.w,
-						h: ds_2.item.h
-					},
-					allowExchange: false
-				}) });
-				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_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_2.item,
-				x: landing.x,
-				y: landing.y
-			}, tp.cols, tp.maxRows)];
-			target_4.applyLayout(finalLayout, true, "transfer");
-			onTransferRef.current?.({
-				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_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();
-		frozenRectsRef.current.clear();
-		nestedInDraggedRef.current = /* @__PURE__ */ new Set();
-		previewRef.current = null;
-		lastLandingRef.current = null;
-		setDragState(null);
-	});
-	return useMemo(() => ({
-		store,
-		overlayRef,
-		registerBoard,
-		onDragStart,
-		onDragMove,
-		onDragEnd,
-		dragState,
-		getDragState
-	}), [
-		store,
-		registerBoard,
-		onDragStart,
-		onDragMove,
-		onDragEnd,
-		dragState,
-		getDragState
-	]);
-}
-
-//#endregion
-export { useBoardRegistry };
-//# sourceMappingURL=use-board-registry.js.map