@stll/ui 0.37.1 → 0.39.0

package/dist/kanban/sortable-interactions.logic.js

@@ -1,205 +0,0 @@
-import { closestCorners, getFirstCollision, pointerWithin } from "@dnd-kit/core";
-//#region src/kanban/sortable-interactions.logic.ts
-const KANBAN_DROP_TARGET_TYPES = {
-	CELL: "kanban-cell",
-	ITEM: "kanban-item"
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isUniqueIdentifier = (value) => typeof value === "string" || typeof value === "number";
-const isCellPosition = (value) => isRecord(value) && typeof value["column"] === "number" && typeof value["lane"] === "number" && Number.isInteger(value["column"]) && Number.isInteger(value["lane"]) && value["column"] >= 0 && value["lane"] >= 0;
-const isKanbanCellVirtualNavigation = (value) => isRecord(value) && (value["type"] === "static" || value["type"] === "virtual" && typeof value["requestScroll"] === "function");
-const isKanbanCellDropData = (value) => isRecord(value) && value["type"] === KANBAN_DROP_TARGET_TYPES.CELL && Array.isArray(value["itemIds"]) && value["itemIds"].every(isUniqueIdentifier) && isKanbanCellVirtualNavigation(value["navigation"]) && isCellPosition(value["position"]);
-const isKanbanItemDropData = (value) => {
-	if (!isRecord(value) || value["type"] !== KANBAN_DROP_TARGET_TYPES.ITEM) return false;
-	const navigation = value["navigation"];
-	const current = isRecord(navigation) ? navigation["current"] : void 0;
-	return isRecord(navigation) && isRecord(current) && (current["type"] === "idle" || (current["type"] === "ready" || current["type"] === "pending") && isUniqueIdentifier(current["targetId"]));
-};
-const getKanbanKeyboardTargetState = (value) => isKanbanItemDropData(value) ? value.navigation.current : void 0;
-/**
-* 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.
-*/
-const isKanbanDropSettled = ({ active, collisions, over }) => {
-	const target = getKanbanKeyboardTargetState(active?.data.current);
-	if (target?.type === "pending") return false;
-	if (target?.type === "ready") return over?.id === target.targetId;
-	return getFirstCollision(collisions, "id") === (over?.id ?? null);
-};
-const clearKanbanKeyboardTarget = (value) => {
-	if (isKanbanItemDropData(value) && value.navigation.current.type !== "idle") value.navigation.current = { type: "idle" };
-};
-const getSortableData = (value) => {
-	if (!isRecord(value)) return null;
-	const sortable = value["sortable"];
-	if (!isRecord(sortable) || !isUniqueIdentifier(sortable["containerId"]) || typeof sortable["index"] !== "number" || !Number.isInteger(sortable["index"]) || !Array.isArray(sortable["items"]) || !sortable["items"].every(isUniqueIdentifier)) return null;
-	return {
-		containerId: sortable["containerId"],
-		index: sortable["index"],
-		items: sortable["items"]
-	};
-};
-const isKanbanDroppable = ({ data }) => {
-	const value = data.current;
-	return isKanbanCellDropData(value) || isKanbanItemDropData(value);
-};
-/**
-* Pointer and touch input must be inside a registered board target. Once that
-* boundary is established, closest corners gives stable ranking across cells.
-*/
-const KANBAN_BOARD_COLLISION_DETECTION = (args) => {
-	const boardContainers = args.droppableContainers.filter(isKanbanDroppable);
-	if (args.pointerCoordinates === null) {
-		const activeData = args.active.data.current;
-		if (isKanbanItemDropData(activeData)) {
-			if (activeData.navigation.current.type === "pending") return [];
-			if (activeData.navigation.current.type !== "ready") return closestCorners({
-				...args,
-				droppableContainers: boardContainers
-			});
-			const { targetId } = activeData.navigation.current;
-			return boardContainers.some(({ id }) => id === targetId) ? [{ id: targetId }] : [];
-		}
-		return closestCorners({
-			...args,
-			droppableContainers: boardContainers
-		});
-	}
-	const intersections = pointerWithin({
-		...args,
-		droppableContainers: boardContainers
-	});
-	if (intersections.length === 0) return [];
-	const intersectingIds = new Set(intersections.map((intersection) => intersection.id));
-	return closestCorners({
-		...args,
-		droppableContainers: boardContainers.filter(({ id }) => intersectingIds.has(id))
-	});
-};
-const getAdjacentCell = (cells, current, direction) => {
-	let columnOffset = 0;
-	let laneOffset = 0;
-	switch (direction) {
-		case "down":
-			laneOffset = 1;
-			break;
-		case "left":
-			columnOffset = -1;
-			break;
-		case "right":
-			columnOffset = 1;
-			break;
-		case "up": laneOffset = -1;
-	}
-	return cells.find(({ position }) => position.column === current.position.column + columnOffset && position.lane === current.position.lane + laneOffset);
-};
-const getKanbanKeyboardTarget = ({ activeId, cells, currentCellId, currentOverId, direction }) => {
-	const currentCell = cells.find(({ id }) => id === currentCellId);
-	if (currentCell === void 0) return;
-	const overIndex = currentCell.itemIds.indexOf(currentOverId);
-	const activeIndex = currentCell.itemIds.indexOf(activeId);
-	const currentIndex = overIndex !== -1 ? overIndex : activeIndex;
-	if (direction === "down" && currentIndex >= 0) {
-		const nextItem = currentCell.itemIds.at(currentIndex + 1);
-		if (nextItem !== void 0) return nextItem;
-	}
-	if (direction === "up" && currentIndex > 0) return currentCell.itemIds.at(currentIndex - 1);
-	const adjacentCell = getAdjacentCell(cells, currentCell, direction);
-	if (adjacentCell === void 0) return;
-	if (adjacentCell.itemIds.length === 0) return adjacentCell.id;
-	if (direction === "down") return adjacentCell.itemIds.at(0);
-	if (direction === "up") return adjacentCell.itemIds.at(-1);
-	const targetIndex = Math.max(currentIndex, 0);
-	return adjacentCell.itemIds.at(Math.min(targetIndex, adjacentCell.itemIds.length - 1)) ?? adjacentCell.id;
-};
-const getDirection = (code) => {
-	switch (code) {
-		case "ArrowDown": return "down";
-		case "ArrowLeft": return "left";
-		case "ArrowRight": return "right";
-		case "ArrowUp": return "up";
-		default: return null;
-	}
-};
-const getCellId = (container) => {
-	const data = container.data.current;
-	if (isKanbanCellDropData(data)) return container.id;
-	if (!isKanbanItemDropData(data)) return null;
-	return getSortableData(data)?.containerId ?? null;
-};
-/** Ordered two-dimensional navigation over item and empty-cell targets. */
-const kanbanKeyboardCoordinates = (event, { active, context }) => {
-	const direction = getDirection(event.code);
-	if (direction === null) return;
-	event.preventDefault();
-	const cells = context.droppableContainers.getEnabled().filter(({ data }) => {
-		const value = data.current;
-		return isKanbanCellDropData(value);
-	}).flatMap((container) => {
-		const data = container.data.current;
-		return isKanbanCellDropData(data) ? [{
-			...data,
-			id: container.id
-		}] : [];
-	});
-	const activeData = context.active?.data.current;
-	const keyboardTarget = getKanbanKeyboardTargetState(activeData);
-	const overId = keyboardTarget?.type === "ready" ? keyboardTarget.targetId : context.over?.id ?? active;
-	const overContainer = context.droppableContainers.get(overId);
-	const activeContainer = context.droppableContainers.get(active);
-	const currentCellId = (overContainer && getCellId(overContainer)) ?? (activeContainer && getCellId(activeContainer));
-	if (currentCellId === null || currentCellId === void 0) return;
-	const targetId = getKanbanKeyboardTarget({
-		activeId: active,
-		cells,
-		currentCellId,
-		currentOverId: overId,
-		direction
-	});
-	if (targetId === void 0) return;
-	const targetNode = context.droppableContainers.get(targetId)?.node.current;
-	if (targetNode === null || targetNode === void 0) {
-		const targetCell = cells.find(({ itemIds }) => itemIds.includes(targetId));
-		if (isKanbanItemDropData(activeData) && targetCell?.navigation.type === "virtual") {
-			activeData.navigation.current = {
-				targetId,
-				type: "pending"
-			};
-			targetCell.navigation.requestScroll({
-				itemId: targetId,
-				type: "item"
-			});
-		}
-		return;
-	}
-	const targetRect = context.droppableRects.get(targetId);
-	if (targetRect === void 0) return;
-	if (isKanbanItemDropData(activeData)) activeData.navigation.current = {
-		targetId,
-		type: "ready"
-	};
-	requestAnimationFrame(() => {
-		requestAnimationFrame(() => {
-			targetNode.scrollIntoView({
-				behavior: "instant",
-				block: "nearest",
-				inline: "nearest"
-			});
-		});
-	});
-	return {
-		x: targetRect.left,
-		y: targetRect.top
-	};
-};
-//#endregion
-export { KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DROP_TARGET_TYPES, clearKanbanKeyboardTarget, getKanbanKeyboardTarget, getKanbanKeyboardTargetState, isKanbanCellDropData, isKanbanDropSettled, kanbanKeyboardCoordinates };