@stll/ui 0.38.0 → 0.40.0

package/dist/kanban/sortable-interactions.js

@@ -1,527 +0,0 @@
-"use client";
-import { GripVerticalIcon } from "../icons.js";
-import { cn } from "../lib/utils.js";
-import "../lib/overlay-layer.js";
-import { Button } from "../components/button.js";
-import { KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DROP_TARGET_TYPES, clearKanbanKeyboardTarget, getKanbanKeyboardTargetState, isKanbanDropSettled, kanbanKeyboardCoordinates } from "./sortable-interactions.logic.js";
-import { isActiveTouchChange } from "./touch-identity.js";
-import { jsx, jsxs } from "react/jsx-runtime";
-import * as React$1 from "react";
-import { createPortal } from "react-dom";
-import { AutoScrollActivator, DndContext, DragOverlay, KeyboardSensor, MouseSensor, TouchSensor, useDroppable, useSensor, useSensors } from "@dnd-kit/core";
-import { SortableContext, useSortable } from "@dnd-kit/sortable";
-//#region src/kanban/sortable-interactions.tsx
-const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
-/** Above sticky board chrome, below app-level floating surfaces. */
-const KANBAN_DRAG_OVERLAY_Z_INDEX = 75;
-const KANBAN_BOARD_AUTO_SCROLL_OPTIONS = {
-	acceleration: 10,
-	activator: AutoScrollActivator.Pointer,
-	threshold: {
-		x: .15,
-		y: .15
-	}
-};
-const KANBAN_SORTABLE_ACTIVATION_MODES = {
-	CARD: "card",
-	HANDLE: "handle",
-	ITEM: "item"
-};
-const KANBAN_TOUCH_ACTIVATION_CONSTRAINT = {
-	delay: 150,
-	tolerance: 8
-};
-const KANBAN_KEYBOARD_CODES = {
-	cancel: ["Escape"],
-	end: [
-		"Space",
-		"Enter",
-		"Tab"
-	]
-};
-const KANBAN_KEYBOARD_TARGET_RETRY_LIMIT = 60;
-/** A render commit, not a virtual scroll, so the budget stays short. */
-const KANBAN_DROP_SETTLE_FRAME_LIMIT = 10;
-/**
-* Defers a drop until dnd-kit has published the collision target it computed.
-* Every sensor ends a drag from a single input event, so without this wait the
-* drop resolves against the target published before that event.
-*/
-const endWhenDropTargetSettled = (context, end) => {
-	let framesWaited = 0;
-	const attempt = () => {
-		if (framesWaited >= KANBAN_DROP_SETTLE_FRAME_LIMIT || isKanbanDropSettled(context.current)) {
-			end();
-			return;
-		}
-		framesWaited += 1;
-		requestAnimationFrame(attempt);
-	};
-	attempt();
-};
-const hasTouchLists = (event) => "changedTouches" in event && "touches" in event;
-const getTouchIdentifier = (event) => {
-	if (!hasTouchLists(event)) return null;
-	return event.changedTouches.item(0)?.identifier ?? event.touches.item(0)?.identifier ?? null;
-};
-const getTouchIdentifiers = (touches) => {
-	const identifiers = [];
-	for (let index = 0; index < touches.length; index += 1) {
-		const identifier = touches.item(index)?.identifier;
-		if (identifier !== void 0) identifiers.push(identifier);
-	}
-	return identifiers;
-};
-/**
-* Keeps a delayed touch drag bound to the finger that activated it.
-*
-* dnd-kit's stock touch sensor attaches document-level lifecycle listeners,
-* so a second finger can otherwise move, end, or cancel the active drag. The
-* capture listeners below suppress only secondary touch changes before those
-* listeners receive them; browser scrolling remains native because no default
-* action is prevented here.
-*/
-var KanbanTouchSensor = class extends TouchSensor {
-	identityListeners;
-	ownerDocument;
-	touchIdentifier;
-	constructor(props) {
-		const identityListeners = new AbortController();
-		super({
-			...props,
-			onAbort: (active) => {
-				identityListeners.abort();
-				props.onAbort(active);
-			},
-			onCancel: () => {
-				identityListeners.abort();
-				props.onCancel();
-			},
-			onEnd: () => {
-				identityListeners.abort();
-				endWhenDropTargetSettled(props.context, () => {
-					props.onEnd();
-				});
-			}
-		});
-		this.identityListeners = identityListeners;
-		this.ownerDocument = getTouchDocument(props.event);
-		this.touchIdentifier = getTouchIdentifier(props.event);
-		this.ownerDocument.addEventListener("touchmove", this.handleTouchMove, {
-			capture: true,
-			passive: false,
-			signal: identityListeners.signal
-		});
-		this.ownerDocument.addEventListener("touchend", this.handleTouchEnd, {
-			capture: true,
-			signal: identityListeners.signal
-		});
-		this.ownerDocument.addEventListener("touchcancel", this.handleTouchCancel, {
-			capture: true,
-			signal: identityListeners.signal
-		});
-	}
-	handleTouchMove = (event) => {
-		if (this.isPrimaryTouchChange(event)) return;
-		event.stopImmediatePropagation();
-	};
-	handleTouchEnd = (event) => {
-		if (!this.isPrimaryTouchChange(event)) {
-			event.stopImmediatePropagation();
-			return;
-		}
-		this.detachIdentityListeners();
-	};
-	handleTouchCancel = (event) => {
-		if (!this.isPrimaryTouchChange(event)) {
-			event.stopImmediatePropagation();
-			return;
-		}
-		this.detachIdentityListeners();
-	};
-	isPrimaryTouchChange = (event) => isActiveTouchChange({
-		activeTouchIdentifier: this.touchIdentifier,
-		changedTouchIdentifiers: getTouchIdentifiers(event.changedTouches)
-	});
-	detachIdentityListeners = () => {
-		this.identityListeners.abort();
-	};
-};
-/** The stock mouse sensor, holding its drop until the board target settles. */
-var KanbanMouseSensor = class extends MouseSensor {
-	constructor(props) {
-		super({
-			...props,
-			onEnd: () => {
-				endWhenDropTargetSettled(props.context, () => {
-					props.onEnd();
-				});
-			}
-		});
-	}
-};
-/**
-* Applies board coordinates without the stock sensor's one-dimensional source
-* scroll clamping. The coordinate getter moves to the typed target and then
-* scrolls that virtual item into view.
-*/
-var KanbanKeyboardSensor = class {
-	static activators = KeyboardSensor.activators;
-	autoScrollEnabled = false;
-	/** Input handling, released as soon as a drag stops accepting keys. */
-	listeners = new AbortController();
-	/**
-	* The drag itself, released only once it resolves. Ending must not stop the
-	* queued retry that still has to bring a pending virtual target into view.
-	*/
-	lifetime = new AbortController();
-	props;
-	moveSequence = 0;
-	referenceCoordinates = null;
-	constructor(props) {
-		this.props = props;
-		props.onStart({
-			x: 0,
-			y: 0
-		});
-		const ownerDocument = getTouchDocument(props.event);
-		ownerDocument.addEventListener("visibilitychange", this.handleCancel, { signal: this.listeners.signal });
-		ownerDocument.defaultView?.addEventListener("resize", this.handleCancel, { signal: this.listeners.signal });
-		ownerDocument.addEventListener("keydown", this.handleKeyDown, { signal: this.listeners.signal });
-	}
-	handleCancel = () => {
-		if (this.lifetime.signal.aborted) return;
-		this.moveSequence += 1;
-		this.listeners.abort();
-		this.finish(() => {
-			this.props.onCancel();
-		});
-	};
-	finish = (resolve) => {
-		clearKanbanKeyboardTarget(this.props.context.current.active?.data.current);
-		this.lifetime.abort();
-		resolve();
-	};
-	handleKeyDown = (event) => {
-		if (event === this.props.event) return;
-		const keyboardCodes = this.props.options.keyboardCodes;
-		const cancelCodes = keyboardCodes?.cancel ?? KANBAN_KEYBOARD_CODES.cancel;
-		const endCodes = keyboardCodes?.end ?? KANBAN_KEYBOARD_CODES.end;
-		if (cancelCodes.some((code) => code === event.code)) {
-			event.preventDefault();
-			this.handleCancel();
-			return;
-		}
-		if (endCodes.some((code) => code === event.code)) {
-			event.preventDefault();
-			this.listeners.abort();
-			this.endWhenNavigationResolves(0);
-			return;
-		}
-		this.moveSequence += 1;
-		this.move(event, this.moveSequence, 0);
-	};
-	/**
-	* A pending target has asked a virtual cell to mount an offscreen row and has
-	* published nothing, so the queued move retry, not this keypress, decides
-	* where the item lands. Cancel when that retry gives up: the board never
-	* reached the row the user navigated to, and the target still published is
-	* the one they navigated away from.
-	*/
-	endWhenNavigationResolves = (framesWaited) => {
-		if (this.lifetime.signal.aborted) return;
-		const target = getKanbanKeyboardTargetState(this.props.context.current.active?.data.current);
-		if (target?.type === "pending") {
-			if (framesWaited >= KANBAN_KEYBOARD_TARGET_RETRY_LIMIT) {
-				this.finish(() => {
-					this.props.onCancel();
-				});
-				return;
-			}
-			requestAnimationFrame(() => {
-				this.endWhenNavigationResolves(framesWaited + 1);
-			});
-			return;
-		}
-		if (framesWaited > 0 && target?.type !== "ready") {
-			this.finish(() => {
-				this.props.onCancel();
-			});
-			return;
-		}
-		endWhenDropTargetSettled(this.props.context, () => {
-			const settled = isKanbanDropSettled(this.props.context.current);
-			this.finish(() => {
-				if (settled) {
-					this.props.onEnd();
-					return;
-				}
-				this.props.onCancel();
-			});
-		});
-	};
-	move = (event, sequence, retryCount) => {
-		const currentContext = this.props.context.current;
-		if (currentContext.active?.id !== this.props.active) {
-			requestAnimationFrame(() => {
-				if (this.listeners.signal.aborted || this.moveSequence !== sequence) return;
-				this.move(event, sequence, retryCount);
-			});
-			return;
-		}
-		const collisionRect = currentContext.collisionRect;
-		const currentCoordinates = collisionRect ? {
-			x: collisionRect.left,
-			y: collisionRect.top
-		} : {
-			x: 0,
-			y: 0
-		};
-		this.referenceCoordinates ??= currentCoordinates;
-		const activeData = currentContext.active.data.current;
-		const coordinates = this.props.options.coordinateGetter?.(event, {
-			active: this.props.active,
-			context: currentContext,
-			currentCoordinates
-		});
-		if (coordinates === void 0) {
-			if (getKanbanKeyboardTargetState(activeData)?.type !== "pending") return;
-			if (retryCount >= KANBAN_KEYBOARD_TARGET_RETRY_LIMIT) {
-				clearKanbanKeyboardTarget(activeData);
-				return;
-			}
-			requestAnimationFrame(() => {
-				if (this.lifetime.signal.aborted || this.moveSequence !== sequence) return;
-				this.move(event, sequence, retryCount + 1);
-			});
-			return;
-		}
-		this.props.onMove({
-			x: coordinates.x - this.referenceCoordinates.x,
-			y: coordinates.y - this.referenceCoordinates.y
-		});
-	};
-};
-const getTouchDocument = (event) => {
-	if (event.target instanceof Node && event.target.ownerDocument) return event.target.ownerDocument;
-	return document;
-};
-const KanbanInteractionReadinessContext = React$1.createContext(true);
-/**
-* Register a board-level drop target such as an empty cell or terminal lane.
-*
-* Board consumers should not need to couple their presentation code to the
-* underlying drag-and-drop library just to receive an item from a sortable
-* context.
-*/
-const useKanbanDropTarget = ({ disabled, id, itemIds, navigation, position }) => {
-	const interactionReady = React$1.useContext(KanbanInteractionReadinessContext);
-	const dropTarget = useDroppable({
-		data: {
-			itemIds,
-			navigation,
-			position,
-			type: KANBAN_DROP_TARGET_TYPES.CELL
-		},
-		disabled: !interactionReady || disabled === true,
-		id
-	});
-	return {
-		isOver: dropTarget.isOver,
-		setNodeRef: dropTarget.setNodeRef
-	};
-};
-/**
-* Input-complete drag context for sortable boards.
-*
-* The consumer owns identifiers and the result of a drop; this component owns
-* the sensor activation rules, keyboard navigation, auto-scroll configuration,
-* and overlay lifecycle shared by sortable board UIs.
-*/
-const KanbanSortableBoard = ({ children, onDragEnd, mouseActivationDistance, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragOver, onDragCancel, onInteractionReady, overlay, overlayProps }) => {
-	const [activeId, setActiveId] = React$1.useState(null);
-	const [interactionReady, setInteractionReady] = React$1.useState(false);
-	const interactionReadyNotified = React$1.useRef(false);
-	const defaultSensors = useKanbanSortableSensors(keyboardCoordinates, mouseActivationDistance);
-	React$1.useEffect(() => {
-		const frame = requestAnimationFrame(() => {
-			setInteractionReady(true);
-		});
-		return () => {
-			cancelAnimationFrame(frame);
-		};
-	}, []);
-	React$1.useEffect(() => {
-		if (!interactionReady || interactionReadyNotified.current) return;
-		interactionReadyNotified.current = true;
-		onInteractionReady?.();
-	}, [interactionReady, onInteractionReady]);
-	const handleDragStart = (event) => {
-		setActiveId(event.active.id);
-		onDragStart?.(event);
-	};
-	const handleDragEnd = (event) => {
-		setActiveId(null);
-		onDragEnd(event);
-	};
-	const handleDragCancel = (event) => {
-		setActiveId(null);
-		onDragCancel?.(event);
-	};
-	return /* @__PURE__ */ jsx(KanbanInteractionReadinessContext, {
-		value: interactionReady,
-		children: /* @__PURE__ */ jsxs(DndContext, {
-			autoScroll: autoScroll ?? KANBAN_BOARD_AUTO_SCROLL_OPTIONS,
-			...accessibility === void 0 ? {} : { accessibility },
-			collisionDetection: collisionDetection ?? KANBAN_BOARD_COLLISION_DETECTION,
-			onDragCancel: handleDragCancel,
-			onDragEnd: handleDragEnd,
-			...onDragOver === void 0 ? {} : { onDragOver },
-			onDragStart: handleDragStart,
-			sensors: sensors ?? defaultSensors,
-			children: [children, overlay && typeof document !== "undefined" ? createPortal(/* @__PURE__ */ jsx(DragOverlay, {
-				...overlayProps,
-				zIndex: overlayProps?.zIndex ?? KANBAN_DRAG_OVERLAY_Z_INDEX,
-				children: overlay(activeId)
-			}), document.body) : null]
-		})
-	});
-};
-const useKanbanSortableSensors = (keyboardCoordinates = kanbanKeyboardCoordinates, mouseActivationDistance = 8) => useSensors(useSensor(KanbanMouseSensor, { activationConstraint: { distance: mouseActivationDistance } }), useSensor(KanbanTouchSensor, { activationConstraint: KANBAN_TOUCH_ACTIVATION_CONSTRAINT }), useSensor(KanbanKeyboardSensor, { coordinateGetter: keyboardCoordinates }));
-/** A vertical card list that preserves native vertical touch scrolling. */
-const KanbanSortableList = ({ className, children, id, items, strategy, disabled, ...props }) => /* @__PURE__ */ jsx(SortableContext, {
-	...disabled === void 0 ? {} : { disabled },
-	...id === void 0 ? {} : { id },
-	items,
-	...strategy === void 0 ? {} : { strategy },
-	children: /* @__PURE__ */ jsx("div", {
-		className: cn("min-h-0 touch-auto overflow-y-auto overscroll-y-contain", className),
-		...props,
-		children
-	})
-});
-/** A horizontal column list that keeps the board pan gesture available. */
-const KanbanSortableColumns = ({ className, children, id, items, strategy, disabled, ...props }) => /* @__PURE__ */ jsx(SortableContext, {
-	...disabled === void 0 ? {} : { disabled },
-	...id === void 0 ? {} : { id },
-	items,
-	...strategy === void 0 ? {} : { strategy },
-	children: /* @__PURE__ */ jsx("div", {
-		className: cn("flex min-h-0 touch-auto overflow-x-auto overscroll-x-contain", className),
-		...props,
-		children
-	})
-});
-/**
-* Connect a sortable item and its separate drag handle without making the
-* item's content a touch-none activation surface.
-*/
-const useKanbanSortable = ({ activation, id, disabled }) => {
-	const interactionReady = React$1.useContext(KanbanInteractionReadinessContext);
-	const data = React$1.useMemo(() => ({
-		navigation: { current: { type: "idle" } },
-		type: KANBAN_DROP_TARGET_TYPES.ITEM
-	}), []);
-	const sortable = useSortable({
-		data,
-		disabled: !interactionReady || disabled === true,
-		id
-	});
-	const setNodeRef = (element) => {
-		sortable.setNodeRef(element);
-		if (activation.type === KANBAN_SORTABLE_ACTIVATION_MODES.ITEM) sortable.setActivatorNodeRef(element);
-	};
-	const bindings = {
-		attributes: sortable.attributes,
-		listeners: sortable.listeners,
-		setActivatorNodeRef: sortable.setActivatorNodeRef
-	};
-	let activator;
-	if (activation.type === KANBAN_SORTABLE_ACTIVATION_MODES.HANDLE) activator = {
-		bindings,
-		type: KANBAN_SORTABLE_ACTIVATION_MODES.HANDLE
-	};
-	else if (activation.type === KANBAN_SORTABLE_ACTIVATION_MODES.CARD) activator = {
-		bindings,
-		type: KANBAN_SORTABLE_ACTIVATION_MODES.CARD
-	};
-	else activator = {
-		attributes: sortable.attributes,
-		listeners: sortable.listeners,
-		type: KANBAN_SORTABLE_ACTIVATION_MODES.ITEM
-	};
-	return {
-		activator,
-		isDragging: sortable.isDragging,
-		setNodeRef,
-		style: {
-			touchAction: activation.type === KANBAN_SORTABLE_ACTIVATION_MODES.ITEM ? "none" : void 0,
-			transform: sortable.transform ? `translate3d(${sortable.transform.x}px, ${sortable.transform.y}px, 0)` : void 0,
-			transition: sortable.transition
-		}
-	};
-};
-/**
-* A 44px keyboard-accessible drag activator. The handle is the only board
-* surface that disables touch panning, leaving cards and scroll regions free
-* for ordinary scrolling.
-*/
-const KanbanDragHandle = ({ bindings, label, className, ...props }) => /* @__PURE__ */ jsx(Button, {
-	...props,
-	...bindings.attributes,
-	...bindings.listeners,
-	"aria-label": label,
-	className: cn("size-11 min-h-11 min-w-11 touch-none sm:size-11", className),
-	ref: (element) => bindings.setActivatorNodeRef(element),
-	size: "icon-xl",
-	tooltip: false,
-	type: "button",
-	variant: "ghost",
-	children: /* @__PURE__ */ jsx(GripVerticalIcon, { "aria-hidden": "true" })
-});
-const KANBAN_CARD_DRAG_SURFACE_INTERACTIVE_SELECTOR = "a,button,input,select,textarea,[contenteditable=true],[role=button],[data-kanban-drag-exempt]";
-const isKanbanCardDragSurfaceInteractiveTarget = (target, activator) => {
-	if (!(target instanceof Element)) return false;
-	const interactiveTarget = target.closest(KANBAN_CARD_DRAG_SURFACE_INTERACTIVE_SELECTOR);
-	return interactiveTarget !== null && interactiveTarget !== activator;
-};
-const getKanbanCardDragSurfaceAttributes = ({ "aria-describedby": _describedBy, "aria-disabled": _disabled, "aria-pressed": _pressed, "aria-roledescription": _roleDescription, role: _role, tabIndex, ...attributes }) => ({
-	...attributes,
-	tabIndex
-});
-const isKanbanCardDragSurfaceListener = (listener) => typeof listener === "function";
-const getKanbanCardDragSurfaceListeners = (listeners) => {
-	const { onKeyDown, onMouseDown, onPointerDown, onTouchStart, ...rest } = listeners;
-	const shouldActivate = (event) => !isKanbanCardDragSurfaceInteractiveTarget(event.target, event.currentTarget);
-	return {
-		...rest,
-		...!isKanbanCardDragSurfaceListener(onKeyDown) ? {} : { onKeyDown: (event) => {
-			if (shouldActivate(event)) onKeyDown(event);
-		} },
-		...!isKanbanCardDragSurfaceListener(onMouseDown) ? {} : { onMouseDown: (event) => {
-			if (shouldActivate(event)) onMouseDown(event);
-		} },
-		...!isKanbanCardDragSurfaceListener(onPointerDown) ? {} : { onPointerDown: (event) => {
-			if (shouldActivate(event)) onPointerDown(event);
-		} },
-		...!isKanbanCardDragSurfaceListener(onTouchStart) ? {} : { onTouchStart: (event) => {
-			if (shouldActivate(event)) onTouchStart(event);
-		} }
-	};
-};
-/** A whole-card drag activator that preserves descendant controls and scrolling. */
-const KanbanCardDragSurface = ({ bindings, className, ...props }) => {
-	const { listeners, setActivatorNodeRef: setCardActivatorNodeRef } = bindings;
-	const setActivatorNodeRef = React$1.useCallback((element) => {
-		setCardActivatorNodeRef(element);
-	}, [setCardActivatorNodeRef]);
-	return /* @__PURE__ */ jsx("div", {
-		...props,
-		...getKanbanCardDragSurfaceAttributes(bindings.attributes),
-		...listeners === void 0 ? {} : getKanbanCardDragSurfaceListeners(listeners),
-		className: cn("touch-auto", className),
-		ref: setActivatorNodeRef
-	});
-};
-//#endregion
-export { KANBAN_BOARD_AUTO_SCROLL_OPTIONS, KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DRAG_OVERLAY_Z_INDEX, KANBAN_MOUSE_ACTIVATION_DISTANCE, KANBAN_SORTABLE_ACTIVATION_MODES, KANBAN_TOUCH_ACTIVATION_CONSTRAINT, KanbanCardDragSurface, KanbanDragHandle, KanbanSortableBoard, KanbanSortableColumns, KanbanSortableList, kanbanKeyboardCoordinates, useKanbanDropTarget, useKanbanSortable, useKanbanSortableSensors };

package/dist/kanban/sortable-interactions.logic.d.ts

@@ -1,78 +0,0 @@
-import { CollisionDetection, KeyboardCoordinateGetter, SensorContext, UniqueIdentifier } from "@dnd-kit/core";
-//#region src/kanban/sortable-interactions.logic.d.ts
-export declare const KANBAN_DROP_TARGET_TYPES: {
-  readonly CELL: "kanban-cell";
-  readonly ITEM: "kanban-item";
-};
-export type KanbanSortableCellPosition = {
-  column: number;
-  lane: number;
-};
-export type KanbanVirtualScrollRequest = {
-  itemId: UniqueIdentifier;
-  type: "item";
-};
-export type KanbanCellVirtualNavigation = {
-  type: "static";
-} | {
-  requestScroll: (request: KanbanVirtualScrollRequest) => void;
-  type: "virtual";
-};
-export type KanbanCellDropData = {
-  itemIds: readonly UniqueIdentifier[];
-  navigation: KanbanCellVirtualNavigation;
-  position: KanbanSortableCellPosition;
-  type: "kanban-cell";
-};
-type KanbanKeyboardTargetState = {
-  type: "idle";
-} | {
-  targetId: UniqueIdentifier;
-  type: "pending";
-} | {
-  targetId: UniqueIdentifier;
-  type: "ready";
-};
-export type KanbanItemDropData = {
-  navigation: {
-    current: KanbanKeyboardTargetState;
-  };
-  type: "kanban-item";
-};
-type NavigationCell = KanbanCellDropData & {
-  id: UniqueIdentifier;
-};
-export declare const isKanbanCellDropData: (value: unknown) => value is KanbanCellDropData;
-export declare const getKanbanKeyboardTargetState: (value: unknown) => KanbanKeyboardTargetState | undefined;
-/**
- * dnd-kit computes collisions while rendering but publishes the resulting drop
- * target to its sensor context a render later, and resolves a drop from that
- * published value. A drag that ends before the two agree, which every input
- * can do because a single move produces a single render, drops the item on the
- * previously published target.
- *
- * Keyboard navigation names its target outright, so it is compared directly: a
- * pending target is still waiting for a virtual cell to mount an offscreen row
- * and has produced no collision at all, and a ready one is only settled once it
- * is the published target. Until then both the collisions and the published
- * target still describe where the board was before the user navigated away.
- */
-export declare const isKanbanDropSettled: ({ active, collisions, over }: Pick<SensorContext, "active" | "collisions" | "over">) => boolean;
-export declare const clearKanbanKeyboardTarget: (value: unknown) => void;
-/**
- * Pointer and touch input must be inside a registered board target. Once that
- * boundary is established, closest corners gives stable ranking across cells.
- */
-export declare const KANBAN_BOARD_COLLISION_DETECTION: CollisionDetection;
-type NavigationDirection = "down" | "left" | "right" | "up";
-type GetKeyboardTargetOptions = {
-  activeId: UniqueIdentifier;
-  cells: readonly NavigationCell[];
-  currentCellId: UniqueIdentifier;
-  currentOverId: UniqueIdentifier;
-  direction: NavigationDirection;
-};
-export declare const getKanbanKeyboardTarget: ({ activeId, cells, currentCellId, currentOverId, direction }: GetKeyboardTargetOptions) => UniqueIdentifier | undefined;
-/** Ordered two-dimensional navigation over item and empty-cell targets. */
-export declare const kanbanKeyboardCoordinates: KeyboardCoordinateGetter;
-//#endregion