@stll/ui 0.9.1 → 0.12.0

package/dist/kanban/sortable-interactions.js

@@ -1,19 +1,64 @@
 "use client";
 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 { GripVerticalIcon } from "lucide-react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import * as React$1 from "react";
 import { createPortal } from "react-dom";
-import { DndContext, DragOverlay, KeyboardSensor, MouseSensor, TouchSensor, useSensor, useSensors } from "@dnd-kit/core";
-import { SortableContext, sortableKeyboardCoordinates, useSortable } from "@dnd-kit/sortable";
+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;
@@ -54,7 +99,9 @@ var KanbanTouchSensor = class extends TouchSensor {
 			},
 			onEnd: () => {
 				identityListeners.abort();
-				props.onEnd();
+				endWhenDropTargetSettled(props.context, () => {
+					props.onEnd();
+				});
 			}
 		});
 		this.identityListeners = identityListeners;
@@ -100,10 +147,190 @@ var KanbanTouchSensor = class extends TouchSensor {
 		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.
 *
@@ -111,9 +338,24 @@ const getTouchDocument = (event) => {
 * the sensor activation rules, keyboard navigation, auto-scroll configuration,
 * and overlay lifecycle shared by sortable board UIs.
 */
-const KanbanSortableBoard = ({ children, onDragEnd, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragCancel, overlay, overlayProps }) => {
+const KanbanSortableBoard = ({ children, onDragEnd, 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);
+	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);
@@ -126,21 +368,26 @@ const KanbanSortableBoard = ({ children, onDragEnd, collisionDetection, keyboard
 		setActiveId(null);
 		onDragCancel?.(event);
 	};
-	return /* @__PURE__ */ jsxs(DndContext, {
-		...autoScroll === void 0 ? {} : { autoScroll },
-		...accessibility === void 0 ? {} : { accessibility },
-		...collisionDetection === void 0 ? {} : { collisionDetection },
-		onDragCancel: handleDragCancel,
-		onDragEnd: handleDragEnd,
-		onDragStart: handleDragStart,
-		sensors: sensors ?? defaultSensors,
-		children: [children, overlay && typeof document !== "undefined" ? createPortal(/* @__PURE__ */ jsx(DragOverlay, {
-			...overlayProps,
-			children: overlay(activeId)
-		}), document.body) : null]
+	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 = sortableKeyboardCoordinates) => useSensors(useSensor(MouseSensor, { activationConstraint: { distance: 8 } }), useSensor(KanbanTouchSensor, { activationConstraint: KANBAN_TOUCH_ACTIVATION_CONSTRAINT }), useSensor(KeyboardSensor, { coordinateGetter: keyboardCoordinates }));
+const useKanbanSortableSensors = (keyboardCoordinates = kanbanKeyboardCoordinates) => useSensors(useSensor(KanbanMouseSensor, { activationConstraint: { distance: 8 } }), 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 },
@@ -169,22 +416,48 @@ const KanbanSortableColumns = ({ className, children, id, items, strategy, disab
 * Connect a sortable item and its separate drag handle without making the
 * item's content a touch-none activation surface.
 */
-const useKanbanSortable = ({ id, disabled }) => {
+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({
-		id,
-		...disabled === void 0 ? {} : { disabled }
+		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: sortable.setNodeRef,
+		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
-		},
-		dragHandle: {
-			attributes: sortable.attributes,
-			listeners: sortable.listeners,
-			setActivatorNodeRef: sortable.setActivatorNodeRef
 		}
 	};
 };
@@ -198,7 +471,7 @@ const KanbanDragHandle = ({ bindings, label, className, ...props }) => /* @__PUR
 	...bindings.attributes,
 	...bindings.listeners,
 	"aria-label": label,
-	className: cn("size-11 touch-none sm:size-11", className),
+	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,
@@ -206,5 +479,49 @@ const KanbanDragHandle = ({ bindings, label, className, ...props }) => /* @__PUR
 	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_MOUSE_ACTIVATION_DISTANCE, KANBAN_TOUCH_ACTIVATION_CONSTRAINT, KanbanDragHandle, KanbanSortableBoard, KanbanSortableColumns, KanbanSortableList, useKanbanSortable, useKanbanSortableSensors };
+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

@@ -0,0 +1,79 @@
+import { CollisionDetection, KeyboardCoordinateGetter, SensorContext, UniqueIdentifier } from "@dnd-kit/core";
+//#region src/kanban/sortable-interactions.logic.d.ts
+declare const KANBAN_DROP_TARGET_TYPES: {
+  readonly CELL: "kanban-cell";
+  readonly ITEM: "kanban-item";
+};
+type KanbanSortableCellPosition = {
+  column: number;
+  lane: number;
+};
+type KanbanVirtualScrollRequest = {
+  itemId: UniqueIdentifier;
+  type: "item";
+};
+type KanbanCellVirtualNavigation = {
+  type: "static";
+} | {
+  requestScroll: (request: KanbanVirtualScrollRequest) => void;
+  type: "virtual";
+};
+type KanbanCellDropData = {
+  itemIds: readonly UniqueIdentifier[];
+  navigation: KanbanCellVirtualNavigation;
+  position: KanbanSortableCellPosition;
+  type: "kanban-cell";
+};
+type KanbanKeyboardTargetState = {
+  type: "idle";
+} | {
+  targetId: UniqueIdentifier;
+  type: "pending";
+} | {
+  targetId: UniqueIdentifier;
+  type: "ready";
+};
+type KanbanItemDropData = {
+  navigation: {
+    current: KanbanKeyboardTargetState;
+  };
+  type: "kanban-item";
+};
+type NavigationCell = KanbanCellDropData & {
+  id: UniqueIdentifier;
+};
+declare const isKanbanCellDropData: (value: unknown) => value is KanbanCellDropData;
+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.
+ */
+declare const isKanbanDropSettled: ({ active, collisions, over }: Pick<SensorContext, "active" | "collisions" | "over">) => boolean;
+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.
+ */
+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;
+};
+declare const getKanbanKeyboardTarget: ({ activeId, cells, currentCellId, currentOverId, direction }: GetKeyboardTargetOptions) => UniqueIdentifier | undefined;
+/** Ordered two-dimensional navigation over item and empty-cell targets. */
+declare const kanbanKeyboardCoordinates: KeyboardCoordinateGetter;
+//#endregion
+export { KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DROP_TARGET_TYPES, KanbanCellDropData, KanbanCellVirtualNavigation, KanbanItemDropData, KanbanSortableCellPosition, KanbanVirtualScrollRequest, clearKanbanKeyboardTarget, getKanbanKeyboardTarget, getKanbanKeyboardTargetState, isKanbanCellDropData, isKanbanDropSettled, kanbanKeyboardCoordinates };