@proyecto-viviana/solidaria 0.2.8 → 0.4.0

package/dist/_chunk/dnd.js

@@ -0,0 +1,1304 @@
+import { createEffect, createMemo, onCleanup } from "solid-js";
+import { DIRECTORY_DRAG_TYPE, createDragState, createDropState } from "@proyecto-viviana/solid-stately";
+//#region src/dnd/utils.ts
+const NATIVE_DRAG_TYPES = new Set([
+	"text/plain",
+	"text/uri-list",
+	"text/html"
+]);
+const CUSTOM_DRAG_TYPE = "application/vnd.solidaria.items+json";
+const GENERIC_TYPE = "application/octet-stream";
+let DROP_OPERATION = /* @__PURE__ */ function(DROP_OPERATION) {
+	DROP_OPERATION[DROP_OPERATION["none"] = 0] = "none";
+	DROP_OPERATION[DROP_OPERATION["cancel"] = 0] = "cancel";
+	DROP_OPERATION[DROP_OPERATION["move"] = 1] = "move";
+	DROP_OPERATION[DROP_OPERATION["copy"] = 2] = "copy";
+	DROP_OPERATION[DROP_OPERATION["link"] = 4] = "link";
+	DROP_OPERATION[DROP_OPERATION["all"] = 7] = "all";
+	return DROP_OPERATION;
+}({});
+const DROP_OPERATION_ALLOWED = {
+	none: 0,
+	copy: 2,
+	copyLink: 6,
+	copyMove: 3,
+	link: 4,
+	linkMove: 5,
+	move: 1,
+	all: 7,
+	uninitialized: 7
+};
+const EFFECT_ALLOWED = {
+	[0]: "none",
+	[1]: "move",
+	[2]: "copy",
+	[3]: "copyMove",
+	[4]: "link",
+	[5]: "linkMove",
+	[6]: "copyLink",
+	[7]: "all"
+};
+const DROP_EFFECT_TO_DROP_OPERATION = {
+	none: "cancel",
+	link: "link",
+	copy: "copy",
+	move: "move"
+};
+const DROP_OPERATION_TO_DROP_EFFECT = {
+	cancel: "none",
+	link: "link",
+	copy: "copy",
+	move: "move"
+};
+/**
+* Get the types present in drag items.
+*/
+function getTypes(items) {
+	const types = /* @__PURE__ */ new Set();
+	for (const item of items) for (const type of Object.keys(item)) types.add(type);
+	return types;
+}
+/**
+* Write drag items to a DataTransfer object.
+*/
+function writeToDataTransfer(dataTransfer, items) {
+	const groupedByType = /* @__PURE__ */ new Map();
+	let needsCustomData = false;
+	const customData = [];
+	for (const item of items) {
+		const types = Object.keys(item);
+		if (types.length > 1) needsCustomData = true;
+		const dataByType = {};
+		for (const type of types) {
+			let typeItems = groupedByType.get(type);
+			if (!typeItems) {
+				typeItems = [];
+				groupedByType.set(type, typeItems);
+			} else needsCustomData = true;
+			const data = item[type];
+			dataByType[type] = data;
+			typeItems.push(data);
+		}
+		customData.push(dataByType);
+	}
+	for (const [type, typeItems] of groupedByType) if (NATIVE_DRAG_TYPES.has(type)) {
+		const data = typeItems.join("\n");
+		dataTransfer.items.add(data, type);
+	} else dataTransfer.items.add(typeItems[0], type);
+	if (needsCustomData) {
+		const data = JSON.stringify(customData);
+		dataTransfer.items.add(data, CUSTOM_DRAG_TYPE);
+	}
+}
+/**
+* Read drop items from a DataTransfer object.
+*/
+function readFromDataTransfer(dataTransfer) {
+	const items = [];
+	if (!dataTransfer) return items;
+	let hasCustomType = false;
+	if (dataTransfer.types.includes("application/vnd.solidaria.items+json")) try {
+		const data = dataTransfer.getData(CUSTOM_DRAG_TYPE);
+		const parsed = JSON.parse(data);
+		for (const item of parsed) items.push({
+			kind: "text",
+			types: new Set(Object.keys(item)),
+			getText: (type) => Promise.resolve(item[type])
+		});
+		hasCustomType = true;
+	} catch {}
+	if (!hasCustomType) {
+		const stringItems = /* @__PURE__ */ new Map();
+		for (const item of dataTransfer.items) if (item.kind === "string") {
+			const type = item.type || "application/octet-stream";
+			stringItems.set(type, dataTransfer.getData(item.type));
+		} else if (item.kind === "file") {
+			const file = item.getAsFile();
+			if (file) items.push(createFileItem(file));
+		}
+		if (stringItems.size > 0) items.push({
+			kind: "text",
+			types: new Set(stringItems.keys()),
+			getText: (type) => Promise.resolve(stringItems.get(type) ?? "")
+		});
+	}
+	return items;
+}
+/**
+* Create a FileDropItem from a File object.
+*/
+function createFileItem(file) {
+	return {
+		kind: "file",
+		type: file.type || "application/octet-stream",
+		name: file.name,
+		getText: () => file.text(),
+		getFile: () => Promise.resolve(file)
+	};
+}
+/**
+* DragTypes implementation for checking drag types.
+*/
+var DragTypesImpl = class {
+	types;
+	includesUnknownTypes;
+	constructor(dataTransfer) {
+		this.types = /* @__PURE__ */ new Set();
+		let hasFiles = false;
+		for (const item of dataTransfer.items) if (item.type !== "application/vnd.solidaria.items+json") {
+			if (item.kind === "file") hasFiles = true;
+			if (item.type) this.types.add(item.type);
+			else this.types.add(GENERIC_TYPE);
+		}
+		this.includesUnknownTypes = !hasFiles && dataTransfer.types.includes("Files");
+	}
+	has(type) {
+		if (Array.isArray(type)) return type.some((t) => this.has(t));
+		if (this.includesUnknownTypes || type === DIRECTORY_DRAG_TYPE && this.types.has("application/octet-stream") || type === "*/*") return true;
+		if (typeof type === "string") {
+			if (type.endsWith("/*")) {
+				for (const key of this.types) if (key.startsWith(type.slice(0, -2))) return true;
+				return false;
+			}
+			return this.types.has(type);
+		}
+		return false;
+	}
+};
+/**
+* Check if a drop item is a text item.
+*/
+function isTextDropItem(dropItem) {
+	return dropItem.kind === "text";
+}
+/**
+* Check if a drop item is a file item.
+*/
+function isFileDropItem(dropItem) {
+	return dropItem.kind === "file";
+}
+/**
+* Check if a drop item is a directory item.
+*/
+function isDirectoryDropItem(dropItem) {
+	return dropItem.kind === "directory";
+}
+let globalDropEffect;
+let globalAllowedDropOperations = 0;
+function setGlobalDropEffect(effect) {
+	globalDropEffect = effect;
+}
+function getGlobalDropEffect() {
+	return globalDropEffect;
+}
+function setGlobalAllowedDropOperations(ops) {
+	globalAllowedDropOperations = ops;
+}
+function getGlobalAllowedDropOperations() {
+	return globalAllowedDropOperations;
+}
+//#endregion
+//#region src/dnd/createDraggableCollection.ts
+/**
+* createDraggableCollection - ARIA hook for draggable collection items.
+*
+* Provides accessibility support for dragging items from a collection
+* component like ListBox, GridList, or Table.
+*/
+let globalDraggingCollectionRef = null;
+let globalDraggingKeys = /* @__PURE__ */ new Set();
+let globalDraggingTypes = /* @__PURE__ */ new Set();
+function setGlobalDraggingCollectionRef(ref) {
+	globalDraggingCollectionRef = ref;
+}
+function getGlobalDraggingCollectionRef() {
+	return globalDraggingCollectionRef;
+}
+function setGlobalDraggingKeys(keys) {
+	globalDraggingKeys = new Set(keys);
+}
+function getGlobalDraggingKeys() {
+	return new Set(globalDraggingKeys);
+}
+function setGlobalDraggingTypes(types) {
+	globalDraggingTypes = new Set(types);
+}
+function getGlobalDraggingTypes() {
+	return new Set(globalDraggingTypes);
+}
+/**
+* Creates ARIA support for a draggable collection.
+*
+* @param _options - Collection options
+* @param state - Draggable collection state
+* @returns Draggable collection ARIA result
+*/
+function createDraggableCollection(options, state) {
+	const ref = createMemo(() => options.ref());
+	createEffect(() => {
+		const currentRef = ref();
+		if (state.draggingKeys.size > 0) {
+			if (globalDraggingCollectionRef !== currentRef) setGlobalDraggingCollectionRef(currentRef);
+			setGlobalDraggingKeys(state.draggingKeys);
+			setGlobalDraggingTypes(getTypes(state.getItems(state.draggingKeys)));
+			return;
+		}
+		if (globalDraggingCollectionRef === currentRef) {
+			setGlobalDraggingCollectionRef(null);
+			setGlobalDraggingKeys(/* @__PURE__ */ new Set());
+			setGlobalDraggingTypes(/* @__PURE__ */ new Set());
+		}
+	});
+	onCleanup(() => {
+		if (globalDraggingCollectionRef === ref()) {
+			setGlobalDraggingCollectionRef(null);
+			setGlobalDraggingKeys(/* @__PURE__ */ new Set());
+			setGlobalDraggingTypes(/* @__PURE__ */ new Set());
+		}
+	});
+	return { state };
+}
+//#endregion
+//#region src/dnd/createDrag.ts
+/**
+* createDrag - ARIA hook for drag operations.
+*
+* Provides accessibility props for draggable elements with support for
+* mouse, touch, and keyboard interactions.
+*/
+/**
+* Creates ARIA props for a draggable element.
+*
+* @param props - Accessor returning drag options
+* @returns Drag ARIA props and state
+*/
+function createDrag(props) {
+	const getProps = createMemo(() => props());
+	const state = createDragState(() => ({
+		getItems: getProps().getItems,
+		getAllowedDropOperations: getProps().getAllowedDropOperations,
+		onDragStart: getProps().onDragStart,
+		onDragMove: getProps().onDragMove,
+		onDragEnd: getProps().onDragEnd,
+		isDisabled: getProps().isDisabled,
+		hasDragButton: getProps().hasDragButton,
+		preview: getProps().preview
+	}));
+	let lastX = 0;
+	let lastY = 0;
+	const onDragStart = (e) => {
+		if (e.defaultPrevented) return;
+		e.stopPropagation();
+		const p = getProps();
+		state.startDrag(e.clientX, e.clientY);
+		const items = state.getItems();
+		setGlobalDraggingTypes(getTypes(items));
+		e.dataTransfer?.clearData?.();
+		if (e.dataTransfer) writeToDataTransfer(e.dataTransfer, items);
+		let allowed = 7;
+		const allowedOps = state.getAllowedDropOperations();
+		if (allowedOps.length > 0) {
+			allowed = 0;
+			for (const op of allowedOps) allowed |= DROP_OPERATION[op] || 0;
+		}
+		setGlobalAllowedDropOperations(allowed);
+		const effectAllowed = EFFECT_ALLOWED[allowed] || "none";
+		if (e.dataTransfer) e.dataTransfer.effectAllowed = effectAllowed === "cancel" ? "none" : effectAllowed;
+		if (typeof p.preview?.current === "function" && e.dataTransfer) p.preview.current(items, (node, userX, userY) => {
+			if (!node || !e.dataTransfer) return;
+			const size = node.getBoundingClientRect();
+			const rect = e.currentTarget.getBoundingClientRect();
+			let defaultX = e.clientX - rect.x;
+			let defaultY = e.clientY - rect.y;
+			if (defaultX > size.width || defaultY > size.height) {
+				defaultX = size.width / 2;
+				defaultY = size.height / 2;
+			}
+			let offsetX = typeof userX === "number" ? userX : defaultX;
+			let offsetY = typeof userY === "number" ? userY : defaultY;
+			offsetX = Math.max(0, Math.min(offsetX, size.width));
+			offsetY = Math.max(0, Math.min(offsetY, size.height));
+			e.dataTransfer.setDragImage(node, offsetX, offsetY);
+		});
+		lastX = e.clientX;
+		lastY = e.clientY;
+	};
+	const onDrag = (e) => {
+		e.stopPropagation();
+		if (e.clientX === lastX && e.clientY === lastY) return;
+		state.moveDrag(e.clientX, e.clientY);
+		lastX = e.clientX;
+		lastY = e.clientY;
+	};
+	const onDragEnd = (e) => {
+		e.stopPropagation();
+		let dropEffect = e.dataTransfer?.dropEffect ?? "none";
+		if (getGlobalDropEffect()) dropEffect = getGlobalDropEffect();
+		const dropOperation = DROP_EFFECT_TO_DROP_OPERATION[dropEffect];
+		state.endDrag(e.clientX, e.clientY, dropOperation);
+		setGlobalAllowedDropOperations(0);
+		setGlobalDraggingTypes(/* @__PURE__ */ new Set());
+		setGlobalDropEffect(void 0);
+	};
+	const onKeyDown = (e) => {
+		if (e.key === "Enter" && e.target === e.currentTarget) {
+			e.preventDefault();
+			e.stopPropagation();
+		}
+	};
+	const onKeyUp = (e) => {
+		if (e.key === "Enter" && e.target === e.currentTarget) {
+			e.preventDefault();
+			e.stopPropagation();
+			const rect = e.target.getBoundingClientRect();
+			state.startDrag(rect.x + rect.width / 2, rect.y + rect.height / 2);
+			setGlobalDraggingTypes(getTypes(state.getItems()));
+			let allowed = 7;
+			const allowedOps = state.getAllowedDropOperations();
+			if (allowedOps.length > 0) {
+				allowed = 0;
+				for (const op of allowedOps) allowed |= DROP_OPERATION[op] || 0;
+			}
+			setGlobalAllowedDropOperations(allowed);
+		}
+	};
+	const dragProps = createMemo(() => {
+		const p = getProps();
+		if (p.isDisabled) return { draggable: false };
+		const baseProps = {
+			draggable: true,
+			onDragStart,
+			onDrag,
+			onDragEnd
+		};
+		if (!p.hasDragButton) {
+			baseProps.onKeyDown = onKeyDown;
+			baseProps.onKeyUp = onKeyUp;
+		}
+		return baseProps;
+	});
+	const dragButtonProps = createMemo(() => {
+		if (getProps().isDisabled) return { disabled: true };
+		return {
+			type: "button",
+			"aria-label": "Drag",
+			onKeyDown,
+			onKeyUp
+		};
+	});
+	return {
+		get dragProps() {
+			return dragProps();
+		},
+		get dragButtonProps() {
+			return dragButtonProps();
+		},
+		get isDragging() {
+			return state.isDragging;
+		}
+	};
+}
+//#endregion
+//#region src/dnd/createDrop.ts
+/**
+* createDrop - ARIA hook for drop operations.
+*
+* Provides accessibility props for drop target elements with support for
+* mouse, touch, and keyboard interactions.
+*/
+const DROP_ACTIVATE_TIMEOUT = 800;
+/**
+* Creates ARIA props for a drop target element.
+*
+* @param props - Accessor returning drop options
+* @returns Drop ARIA props and state
+*/
+function createDrop(props) {
+	const getProps = createMemo(() => props());
+	const state = createDropState(() => ({
+		getDropOperation: getProps().getDropOperation,
+		onDropEnter: getProps().onDropEnter,
+		onDropMove: getProps().onDropMove,
+		onDropActivate: getProps().onDropActivate,
+		onDropExit: getProps().onDropExit,
+		onDrop: getProps().onDrop,
+		hasDropButton: getProps().hasDropButton,
+		isDisabled: getProps().isDisabled
+	}));
+	let x = 0;
+	let y = 0;
+	let dragOverElements = /* @__PURE__ */ new Set();
+	let dropEffect = "none";
+	let allowedOperations = 7;
+	let dropActivateTimer;
+	const fireDropEnter = (e) => {
+		const rect = e.currentTarget.getBoundingClientRect();
+		state.enterTarget(e.clientX - rect.x, e.clientY - rect.y);
+	};
+	const fireDropExit = (e) => {
+		const rect = e.currentTarget.getBoundingClientRect();
+		state.exitTarget(e.clientX - rect.x, e.clientY - rect.y);
+	};
+	const getAllowedOperations = (e) => {
+		let allowed = DROP_OPERATION_ALLOWED[e.dataTransfer?.effectAllowed ?? "none"] ?? 0;
+		const globalAllowed = getGlobalAllowedDropOperations();
+		if (globalAllowed) allowed &= globalAllowed;
+		let modifierAllowed = 0;
+		if (typeof navigator !== "undefined" && /mac/i.test(navigator.platform)) {
+			if (e.altKey) modifierAllowed |= 2;
+			if (e.ctrlKey) modifierAllowed |= 4;
+			if (e.metaKey) modifierAllowed |= 1;
+		} else {
+			if (e.altKey) modifierAllowed |= 4;
+			if (e.shiftKey) modifierAllowed |= 1;
+			if (e.ctrlKey) modifierAllowed |= 2;
+		}
+		if (modifierAllowed) return allowed & modifierAllowed;
+		return allowed;
+	};
+	const allowedOperationsToArray = (ops) => {
+		const result = [];
+		if (ops & 1) result.push("move");
+		if (ops & 2) result.push("copy");
+		if (ops & 4) result.push("link");
+		return result;
+	};
+	const getDropOperationForAllowed = (allowed, operation) => {
+		return allowed & DROP_OPERATION[operation] ? operation : "cancel";
+	};
+	const onDragEnter = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		dragOverElements.add(e.target);
+		if (dragOverElements.size > 1) return;
+		const p = getProps();
+		const allowedOpsBits = getAllowedOperations(e);
+		const allowedOps = allowedOperationsToArray(allowedOpsBits);
+		let dropOp = allowedOps[0] ?? "cancel";
+		if (typeof p.getDropOperation === "function" && e.dataTransfer) {
+			const types = new DragTypesImpl(e.dataTransfer);
+			dropOp = getDropOperationForAllowed(allowedOpsBits, p.getDropOperation(types, allowedOps));
+		}
+		if (typeof p.getDropOperationForPoint === "function" && e.dataTransfer) {
+			const types = new DragTypesImpl(e.dataTransfer);
+			const rect = e.currentTarget.getBoundingClientRect();
+			dropOp = getDropOperationForAllowed(allowedOpsBits, p.getDropOperationForPoint(types, allowedOps, e.clientX - rect.x, e.clientY - rect.y));
+		}
+		x = e.clientX;
+		y = e.clientY;
+		allowedOperations = allowedOpsBits;
+		dropEffect = DROP_OPERATION_TO_DROP_EFFECT[dropOp] || "none";
+		if (e.dataTransfer) e.dataTransfer.dropEffect = dropEffect;
+		if (dropOp !== "cancel") fireDropEnter(e);
+	};
+	const onDragOver = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		const allowedOpsBits = getAllowedOperations(e);
+		if (e.clientX === x && e.clientY === y && allowedOpsBits === allowedOperations) {
+			if (e.dataTransfer) e.dataTransfer.dropEffect = dropEffect;
+			return;
+		}
+		x = e.clientX;
+		y = e.clientY;
+		const prevDropEffect = dropEffect;
+		const p = getProps();
+		if (allowedOpsBits !== allowedOperations) {
+			const allowedOps = allowedOperationsToArray(allowedOpsBits);
+			let dropOp = allowedOps[0] ?? "cancel";
+			if (typeof p.getDropOperation === "function" && e.dataTransfer) {
+				const types = new DragTypesImpl(e.dataTransfer);
+				dropOp = getDropOperationForAllowed(allowedOpsBits, p.getDropOperation(types, allowedOps));
+			}
+			dropEffect = DROP_OPERATION_TO_DROP_EFFECT[dropOp] || "none";
+		}
+		if (typeof p.getDropOperationForPoint === "function" && e.dataTransfer) {
+			const types = new DragTypesImpl(e.dataTransfer);
+			const rect = e.currentTarget.getBoundingClientRect();
+			dropEffect = DROP_OPERATION_TO_DROP_EFFECT[getDropOperationForAllowed(allowedOpsBits, p.getDropOperationForPoint(types, allowedOperationsToArray(allowedOpsBits), x - rect.x, y - rect.y))] || "none";
+		}
+		allowedOperations = allowedOpsBits;
+		if (e.dataTransfer) e.dataTransfer.dropEffect = dropEffect;
+		if (dropEffect === "none" && prevDropEffect !== "none") fireDropExit(e);
+		else if (dropEffect !== "none" && prevDropEffect === "none") fireDropEnter(e);
+		if (dropEffect !== "none") {
+			const rect = e.currentTarget.getBoundingClientRect();
+			state.moveInTarget(x - rect.x, y - rect.y);
+		}
+		clearTimeout(dropActivateTimer);
+		if (typeof p.onDropActivate === "function" && dropEffect !== "none") {
+			const rect = e.currentTarget.getBoundingClientRect();
+			const activateX = x - rect.x;
+			const activateY = y - rect.y;
+			dropActivateTimer = setTimeout(() => {
+				state.activateTarget(activateX, activateY);
+			}, DROP_ACTIVATE_TIMEOUT);
+		}
+	};
+	const onDragLeave = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		dragOverElements.delete(e.target);
+		for (const element of dragOverElements) if (!e.currentTarget || !e.currentTarget.contains(element)) dragOverElements.delete(element);
+		if (dragOverElements.size > 0) return;
+		if (dropEffect !== "none") fireDropExit(e);
+		clearTimeout(dropActivateTimer);
+	};
+	const onDropHandler = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		setGlobalDropEffect(dropEffect);
+		if (typeof getProps().onDrop === "function" && e.dataTransfer) {
+			const items = readFromDataTransfer(e.dataTransfer);
+			const dropOperation = DROP_EFFECT_TO_DROP_OPERATION[dropEffect];
+			const rect = e.currentTarget.getBoundingClientRect();
+			state.drop(e.clientX - rect.x, e.clientY - rect.y, items, dropOperation);
+		}
+		dragOverElements.clear();
+		fireDropExit(e);
+		clearTimeout(dropActivateTimer);
+	};
+	const dropProps = createMemo(() => {
+		if (getProps().isDisabled) return {};
+		return {
+			onDragEnter,
+			onDragOver,
+			onDragLeave,
+			onDrop: onDropHandler
+		};
+	});
+	const dropButtonProps = createMemo(() => {
+		if (getProps().isDisabled) return { disabled: true };
+		return {
+			type: "button",
+			"aria-label": "Drop"
+		};
+	});
+	return {
+		get dropProps() {
+			return dropProps();
+		},
+		get isDropTarget() {
+			return state.isDropTarget;
+		},
+		get dropButtonProps() {
+			return dropButtonProps();
+		}
+	};
+}
+//#endregion
+//#region src/dnd/createDroppableCollection.ts
+/**
+* createDroppableCollection - ARIA hook for droppable collection targets.
+*
+* Provides accessibility support for dropping items into a collection
+* component like ListBox, GridList, or Table.
+*/
+let globalDropCollectionRef = null;
+function setGlobalDropCollectionRef(ref) {
+	globalDropCollectionRef = ref;
+}
+function getGlobalDropCollectionRef() {
+	return globalDropCollectionRef;
+}
+function getDropItemTypes(item) {
+	if (item.kind === "file") return new Set([item.type]);
+	if (item.kind === "text") return new Set(item.types);
+	return new Set([DIRECTORY_DRAG_TYPE]);
+}
+/**
+* Creates ARIA support for a droppable collection.
+*
+* @param options - Collection options accessor
+* @param state - Droppable collection state
+* @returns Droppable collection ARIA result
+*/
+function createDroppableCollection(options, state) {
+	const getOptions = createMemo(() => options());
+	let nextTarget = null;
+	let currentDropOperation = null;
+	const isInternalDropOperation = () => {
+		const ref = getOptions().ref();
+		const draggingRef = getGlobalDraggingCollectionRef();
+		return ref !== null && draggingRef === ref;
+	};
+	const getDropOperationForTarget = (target, types, allowedOperations) => {
+		return state.getDropOperation(target, types, allowedOperations);
+	};
+	const drop = createDrop(() => ({
+		isDisabled: getOptions().isDisabled,
+		getDropOperationForPoint: (types, allowedOperations, x, y) => {
+			const opts = getOptions();
+			const isValidDropTarget = (target) => getDropOperationForTarget(target, types, allowedOperations) !== "cancel";
+			const target = opts.dropTargetDelegate.getDropTargetFromPoint(x, y, isValidDropTarget);
+			if (!target) {
+				currentDropOperation = "cancel";
+				nextTarget = null;
+				return "cancel";
+			}
+			currentDropOperation = getDropOperationForTarget(target, types, allowedOperations);
+			if (currentDropOperation === "cancel") {
+				const rootTarget = { type: "root" };
+				const rootOp = getDropOperationForTarget(rootTarget, types, allowedOperations);
+				if (rootOp !== "cancel") {
+					nextTarget = rootTarget;
+					currentDropOperation = rootOp;
+					return currentDropOperation;
+				}
+			}
+			const ref = opts.ref();
+			if (target && currentDropOperation !== "cancel" && ref !== globalDropCollectionRef) setGlobalDropCollectionRef(ref);
+			nextTarget = currentDropOperation === "cancel" ? null : target;
+			return currentDropOperation;
+		},
+		onDropEnter: () => {
+			if (nextTarget) state.setTarget(nextTarget);
+		},
+		onDropMove: () => {
+			if (nextTarget) state.setTarget(nextTarget);
+		},
+		onDropExit: () => {
+			setGlobalDropCollectionRef(null);
+			state.setTarget(null);
+		},
+		onDropActivate: (e) => {
+			const opts = getOptions();
+			if (state.target?.type === "item" && state.target.dropPosition === "on" && typeof opts.onDropActivate === "function") opts.onDropActivate({
+				target: state.target,
+				x: e.x,
+				y: e.y
+			});
+		},
+		onDrop: (e) => {
+			const opts = getOptions();
+			setGlobalDropCollectionRef(opts.ref());
+			if (state.target) {
+				const target = state.target;
+				const previousCollection = opts.collection;
+				const previousSelectedKeys = normalizeSelection(opts.selectedKeys);
+				opts.onDrop?.({
+					items: e.items,
+					target,
+					dropOperation: e.dropOperation,
+					x: e.x,
+					y: e.y
+				});
+				Promise.resolve(handleDrop(e.items, target, e.dropOperation)).then(() => {
+					queueMicrotask(() => {
+						updateFocusAfterDrop(getOptions(), previousCollection, previousSelectedKeys, target);
+					});
+				});
+			}
+		}
+	}));
+	const handleDrop = async (items, target, dropOperation) => {
+		const opts = getOptions();
+		const isInternal = isInternalDropOperation();
+		let filteredItems = items;
+		const acceptedTypes = opts.acceptedDragTypes;
+		if (acceptedTypes && acceptedTypes !== "all") filteredItems = items.filter((item) => {
+			const itemTypes = getDropItemTypes(item);
+			return acceptedTypes.some((type) => itemTypes.has(type));
+		});
+		if (filteredItems.length === 0) return;
+		if (target.type === "root" && opts.onRootDrop) await opts.onRootDrop({
+			items: filteredItems,
+			dropOperation
+		});
+		if (target.type === "item") {
+			if (target.dropPosition === "on" && opts.onItemDrop) await opts.onItemDrop({
+				items: filteredItems,
+				target,
+				dropOperation,
+				isInternal
+			});
+			if (opts.onMove && isInternal) {
+				const draggingKeys = getGlobalDraggingKeys();
+				await opts.onMove({
+					keys: draggingKeys,
+					target,
+					dropOperation
+				});
+			}
+			if (target.dropPosition !== "on") {
+				if (!isInternal && opts.onInsert) await opts.onInsert({
+					items: filteredItems,
+					target,
+					dropOperation
+				});
+				if (isInternal && opts.onReorder) {
+					const draggingKeys = getGlobalDraggingKeys();
+					await opts.onReorder({
+						keys: draggingKeys,
+						target,
+						dropOperation
+					});
+				}
+			}
+		}
+	};
+	onCleanup(() => {
+		const ref = getOptions().ref();
+		if (globalDropCollectionRef === ref) setGlobalDropCollectionRef(null);
+	});
+	const collectionProps = createMemo(() => {
+		const baseDropProps = drop.dropProps;
+		const onKeyDownBase = baseDropProps.onKeyDown;
+		const onKeyDown = (e) => {
+			onKeyDownBase?.(e);
+			const opts = getOptions();
+			if (opts.isDisabled) return;
+			const resolveDirection = () => {
+				const refEl = opts.ref();
+				if (refEl && typeof window !== "undefined" && typeof window.getComputedStyle === "function") {
+					if (window.getComputedStyle(refEl).direction === "rtl") return "rtl";
+				}
+				return typeof document !== "undefined" && document.dir === "rtl" ? "rtl" : "ltr";
+			};
+			const isRtl = resolveDirection() === "rtl";
+			const forwardHorizontalKey = isRtl ? "ArrowLeft" : "ArrowRight";
+			const backwardHorizontalKey = isRtl ? "ArrowRight" : "ArrowLeft";
+			const callUserOnKeyDown = () => opts.onKeyDown?.(e);
+			const getKeyboardAllowedOperations = () => {
+				const allowedBits = getGlobalAllowedDropOperations();
+				if (!allowedBits) return [
+					"copy",
+					"move",
+					"link"
+				];
+				const allowed = [];
+				if (allowedBits & 2) allowed.push("copy");
+				if (allowedBits & 1) allowed.push("move");
+				if (allowedBits & 4) allowed.push("link");
+				return allowed.length > 0 ? allowed : [
+					"copy",
+					"move",
+					"link"
+				];
+			};
+			const getKeyboardDragTypes = () => {
+				const draggingTypes = getGlobalDraggingTypes();
+				if (draggingTypes.size === 0) return { has: () => true };
+				return { has: (type) => typeof type === "string" && draggingTypes.has(type) };
+			};
+			const isValidDropTarget = (target) => state.getDropOperation(target, getKeyboardDragTypes(), getKeyboardAllowedOperations()) !== "cancel";
+			const targetsEqual = (a, b) => {
+				if (a.type !== b.type) return false;
+				if (a.type === "root" && b.type === "root") return true;
+				if (a.type !== "item" || b.type !== "item") return false;
+				return a.key === b.key && a.dropPosition === b.dropPosition;
+			};
+			const findNextValidTarget = (start, getNext) => {
+				let current = start;
+				let seenRoot = 0;
+				let safety = 0;
+				while (safety < 256) {
+					safety += 1;
+					const next = getNext(current);
+					if (!next) return null;
+					if (current && targetsEqual(current, next)) return isValidDropTarget(next) ? next : null;
+					current = next;
+					if (next.type === "root") {
+						seenRoot += 1;
+						if (seenRoot >= 2) return isValidDropTarget(next) ? next : null;
+					}
+					if (isValidDropTarget(next)) return next;
+				}
+				return null;
+			};
+			const resolveTargetForKey = (key, direction) => {
+				if (key == null) return null;
+				const onTarget = {
+					type: "item",
+					key,
+					dropPosition: "on"
+				};
+				if (isValidDropTarget(onTarget)) return onTarget;
+				const insertionOrder = direction === "next" ? ["before", "after"] : ["after", "before"];
+				for (const position of insertionOrder) {
+					const insertionTarget = {
+						type: "item",
+						key,
+						dropPosition: position
+					};
+					if (isValidDropTarget(insertionTarget)) return insertionTarget;
+				}
+				return null;
+			};
+			const resolveBoundaryTargetForDirection = (key, direction) => {
+				if (key == null) return null;
+				const boundaryOrder = direction === "next" ? [
+					"before",
+					"on",
+					"after"
+				] : [
+					"after",
+					"on",
+					"before"
+				];
+				for (const position of boundaryOrder) {
+					const candidate = {
+						type: "item",
+						key,
+						dropPosition: position
+					};
+					if (isValidDropTarget(candidate)) return candidate;
+				}
+				return null;
+			};
+			const resolveFallbackKeyboardTarget = (keyName, currentTarget = state.target) => {
+				const keyboardDelegate = opts.keyboardDelegate;
+				if (!keyboardDelegate) return null;
+				const currentKey = currentTarget?.type === "item" ? currentTarget.key : null;
+				const keyForDirection = (direction, getter) => {
+					if (currentKey == null) return resolveBoundaryTargetForDirection((direction === "next" ? keyboardDelegate.getFirstKey?.() : keyboardDelegate.getLastKey?.()) ?? null, direction);
+					if (!getter) return null;
+					let nextKey = getter(currentKey);
+					let safety = 0;
+					while (nextKey != null && safety < 256) {
+						const resolvedTarget = resolveTargetForKey(nextKey, direction);
+						if (resolvedTarget) return resolvedTarget;
+						const candidate = getter(nextKey);
+						if (candidate === nextKey) break;
+						nextKey = candidate;
+						safety += 1;
+					}
+					return null;
+				};
+				if (keyName === "ArrowDown") return keyForDirection("next", keyboardDelegate.getKeyBelow);
+				if (keyName === "ArrowUp") return keyForDirection("previous", keyboardDelegate.getKeyAbove);
+				if (keyName === forwardHorizontalKey) return keyForDirection("next", isRtl ? keyboardDelegate.getKeyLeftOf : keyboardDelegate.getKeyRightOf);
+				if (keyName === backwardHorizontalKey) return keyForDirection("previous", isRtl ? keyboardDelegate.getKeyRightOf : keyboardDelegate.getKeyLeftOf);
+				if (keyName === "Home") return resolveBoundaryTargetForDirection(keyboardDelegate.getFirstKey?.() ?? null, "next");
+				if (keyName === "End") return resolveBoundaryTargetForDirection(keyboardDelegate.getLastKey?.() ?? null, "previous");
+				if (keyName === "PageDown") {
+					if (currentKey != null && keyboardDelegate.getKeyPageBelow) return resolveTargetForKey(keyboardDelegate.getKeyPageBelow(currentKey), "next");
+					return keyForDirection("next", keyboardDelegate.getKeyBelow);
+				}
+				if (keyName === "PageUp") {
+					if (currentKey != null && keyboardDelegate.getKeyPageAbove) return resolveTargetForKey(keyboardDelegate.getKeyPageAbove(currentKey), "previous");
+					return keyForDirection("previous", keyboardDelegate.getKeyAbove);
+				}
+				return null;
+			};
+			const resolvePageTargetForState = (direction, currentTarget) => {
+				const keyboardDelegate = opts.keyboardDelegate;
+				if (!keyboardDelegate) return null;
+				if (direction === "next") {
+					let targetKey = keyboardDelegate.getFirstKey?.() ?? null;
+					let dropPosition = "after";
+					if (currentTarget.type === "item") {
+						targetKey = currentTarget.key;
+						dropPosition = currentTarget.dropPosition;
+					}
+					let nextKey = targetKey != null ? keyboardDelegate.getKeyPageBelow?.(targetKey) ?? null : null;
+					if (nextKey == null || currentTarget.type === "item" && currentTarget.key === keyboardDelegate.getLastKey?.()) {
+						nextKey = keyboardDelegate.getLastKey?.() ?? null;
+						dropPosition = "after";
+					}
+					if (nextKey == null) return null;
+					return {
+						type: "item",
+						key: nextKey,
+						dropPosition
+					};
+				}
+				if (currentTarget.type === "item") {
+					if (currentTarget.key === keyboardDelegate.getFirstKey?.()) return { type: "root" };
+					let nextKey = keyboardDelegate.getKeyPageAbove?.(currentTarget.key) ?? null;
+					let dropPosition = currentTarget.dropPosition;
+					if (nextKey == null) {
+						nextKey = keyboardDelegate.getFirstKey?.() ?? null;
+						dropPosition = "before";
+					}
+					if (nextKey == null) return null;
+					return {
+						type: "item",
+						key: nextKey,
+						dropPosition
+					};
+				}
+				return currentTarget.type === "root" ? currentTarget : null;
+			};
+			if (e.key === "PageDown" || e.key === "PageUp") {
+				if (e.key === "PageDown" && !opts.keyboardDelegate?.getKeyPageBelow || e.key === "PageUp" && !opts.keyboardDelegate?.getKeyPageAbove) {
+					callUserOnKeyDown();
+					return;
+				}
+				const direction = e.key === "PageDown" ? "next" : "previous";
+				const pageNavigation = opts.dropTargetDelegate.getKeyboardPageNavigationTarget;
+				const stepNavigation = opts.dropTargetDelegate.getKeyboardNavigationTarget;
+				const resolveStepTarget = (target, navDirection) => stepNavigation?.(target, navDirection, isValidDropTarget) ?? resolveFallbackKeyboardTarget(navDirection === "next" ? "ArrowDown" : "ArrowUp", target) ?? resolveFallbackKeyboardTarget(navDirection === "next" ? "Home" : "End", target) ?? null;
+				let nextTarget = null;
+				if (!state.target) nextTarget = findNextValidTarget(null, (target) => resolveStepTarget(target, direction));
+				else {
+					const pageTarget = pageNavigation?.(state.target, direction, isValidDropTarget) ?? resolvePageTargetForState(direction, state.target) ?? null;
+					if (pageTarget && isValidDropTarget(pageTarget)) nextTarget = pageTarget;
+					else {
+						const startTarget = pageTarget ?? state.target;
+						nextTarget = findNextValidTarget(startTarget, (target) => resolveStepTarget(target, direction)) ?? findNextValidTarget(startTarget, (target) => resolveStepTarget(target, direction === "next" ? "previous" : "next"));
+					}
+				}
+				if (nextTarget) {
+					e.preventDefault();
+					state.setTarget(nextTarget);
+				}
+				callUserOnKeyDown();
+				return;
+			}
+			if ((e.key === "ArrowDown" || e.key === "ArrowUp" || e.key === "ArrowRight" || e.key === "ArrowLeft" || e.key === "Home" || e.key === "End") && opts.dropTargetDelegate.getKeyboardNavigationTarget) {
+				if (e.key === "ArrowDown" && !opts.keyboardDelegate?.getKeyBelow || e.key === "ArrowUp" && !opts.keyboardDelegate?.getKeyAbove || e.key === "ArrowLeft" && !opts.keyboardDelegate?.getKeyLeftOf || e.key === "ArrowRight" && !opts.keyboardDelegate?.getKeyRightOf || e.key === "Home" && !opts.keyboardDelegate?.getFirstKey || e.key === "End" && !opts.keyboardDelegate?.getLastKey) {
+					callUserOnKeyDown();
+					return;
+				}
+				const direction = e.key === "ArrowDown" || e.key === forwardHorizontalKey || e.key === "Home" ? "next" : "previous";
+				const nextTarget = findNextValidTarget(e.key === "Home" || e.key === "End" ? null : state.target, (target) => opts.dropTargetDelegate.getKeyboardNavigationTarget?.(target, direction, isValidDropTarget) ?? resolveFallbackKeyboardTarget(e.key, target));
+				if (nextTarget) {
+					e.preventDefault();
+					state.setTarget(nextTarget);
+				}
+				callUserOnKeyDown();
+				return;
+			}
+			if (e.key === "ArrowDown" || e.key === "ArrowUp" || e.key === "ArrowRight" || e.key === "ArrowLeft" || e.key === "Home" || e.key === "End") {
+				if (e.key === "ArrowDown" && !opts.keyboardDelegate?.getKeyBelow || e.key === "ArrowUp" && !opts.keyboardDelegate?.getKeyAbove || e.key === "ArrowLeft" && !opts.keyboardDelegate?.getKeyLeftOf || e.key === "ArrowRight" && !opts.keyboardDelegate?.getKeyRightOf || e.key === "Home" && !opts.keyboardDelegate?.getFirstKey || e.key === "End" && !opts.keyboardDelegate?.getLastKey) {
+					callUserOnKeyDown();
+					return;
+				}
+				const nextTarget = findNextValidTarget(e.key === "Home" || e.key === "End" ? null : state.target, (target) => resolveFallbackKeyboardTarget(e.key, target));
+				if (nextTarget) {
+					e.preventDefault();
+					state.setTarget(nextTarget);
+				}
+				callUserOnKeyDown();
+				return;
+			}
+			if (e.key === "Enter" && state.target) {
+				e.preventDefault();
+				state.activateTarget(0, 0);
+				callUserOnKeyDown();
+				return;
+			}
+			if (e.key === "Escape" && state.target) {
+				e.preventDefault();
+				state.exitTarget(0, 0);
+				callUserOnKeyDown();
+				return;
+			}
+			callUserOnKeyDown();
+		};
+		return {
+			...baseDropProps,
+			onKeyDown
+		};
+	});
+	return { get collectionProps() {
+		return collectionProps();
+	} };
+}
+function normalizeSelection(selection) {
+	if (selection == null) return null;
+	if (selection === "all") return "all";
+	return new Set(selection);
+}
+function selectionEquals(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a === "all" || b === "all") return false;
+	if (a.size !== b.size) return false;
+	for (const key of a) if (!b.has(key)) return false;
+	return true;
+}
+function getNewItemKeys(collection, previousCollection) {
+	const keys = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node.type === "item" && !previousCollection.getItem(node.key)) keys.add(node.key);
+		for (const child of node.childNodes ?? []) visit(child);
+	};
+	for (const node of collection) visit(node);
+	return keys;
+}
+function updateFocusAfterDrop(opts, previousCollection, previousSelectedKeys, target) {
+	const collection = opts.collection;
+	if (!collection || !previousCollection) return;
+	const newKeys = getNewItemKeys(collection, previousCollection);
+	if (newKeys.size === 0) return;
+	const currentSelectedKeys = normalizeSelection(opts.selectedKeys);
+	if (opts.setSelectedKeys && previousSelectedKeys && selectionEquals(previousSelectedKeys, currentSelectedKeys)) opts.setSelectedKeys(newKeys);
+	const first = newKeys.values().next().value;
+	if (first == null) return;
+	let focusKey = first;
+	const item = collection.getItem(first);
+	const parent = item?.parentKey != null ? collection.getItem(item.parentKey) : null;
+	const isDroppedOnCollapsedParent = target.type === "item" && target.dropPosition === "on" && item?.parentKey != null && parent?.isExpanded !== true;
+	if (item && (item.type === "cell" || item.type === "rowheader" || isDroppedOnCollapsedParent)) focusKey = item.parentKey ?? first;
+	opts.setFocusedKey?.(focusKey);
+	queueMicrotask(() => {
+		(opts.ref()?.querySelector("[role=\"row\"][tabindex=\"0\"]"))?.focus();
+	});
+}
+//#endregion
+//#region src/dnd/createDraggableItem.ts
+/**
+* createDraggableItem - ARIA hook for draggable items within a collection.
+*
+* Provides accessibility props for items that can be dragged from a collection.
+*/
+/**
+* Creates ARIA props for a draggable item within a collection.
+*
+* @param options - Accessor returning item options
+* @param state - Draggable collection state
+* @returns Draggable item ARIA props
+*/
+function createDraggableItem(options, state) {
+	const getOptions = createMemo(() => options());
+	let lastX = 0;
+	let lastY = 0;
+	const isDragging = createMemo(() => {
+		const key = getOptions().key;
+		return state.draggingKeys.has(key);
+	});
+	const getKeysForDrag = () => {
+		const { key } = getOptions();
+		return new Set([key]);
+	};
+	const onDragStart = (e) => {
+		if (e.defaultPrevented) return;
+		e.stopPropagation();
+		const opts = getOptions();
+		if (opts.isDisabled || state.isDisabled) return;
+		const keys = getKeysForDrag();
+		state.startDrag(keys, e.clientX, e.clientY);
+		const items = state.getItems(keys);
+		setGlobalDraggingTypes(getTypes(items));
+		e.dataTransfer?.clearData?.();
+		if (e.dataTransfer) writeToDataTransfer(e.dataTransfer, items);
+		let allowed = 7;
+		const allowedOps = state.getAllowedDropOperations();
+		if (allowedOps.length > 0) {
+			allowed = 0;
+			for (const op of allowedOps) allowed |= DROP_OPERATION[op] || 0;
+		}
+		setGlobalAllowedDropOperations(allowed);
+		const effectAllowed = EFFECT_ALLOWED[allowed] || "none";
+		if (e.dataTransfer) e.dataTransfer.effectAllowed = effectAllowed === "cancel" ? "none" : effectAllowed;
+		const preview = opts.preview ?? state.preview;
+		if (typeof preview?.current === "function" && e.dataTransfer) preview.current(items, (node, userX, userY) => {
+			if (!node || !e.dataTransfer) return;
+			const size = node.getBoundingClientRect();
+			const rect = e.currentTarget.getBoundingClientRect();
+			let defaultX = e.clientX - rect.x;
+			let defaultY = e.clientY - rect.y;
+			if (defaultX > size.width || defaultY > size.height) {
+				defaultX = size.width / 2;
+				defaultY = size.height / 2;
+			}
+			let offsetX = typeof userX === "number" ? userX : defaultX;
+			let offsetY = typeof userY === "number" ? userY : defaultY;
+			offsetX = Math.max(0, Math.min(offsetX, size.width));
+			offsetY = Math.max(0, Math.min(offsetY, size.height));
+			e.dataTransfer.setDragImage(node, offsetX, offsetY);
+		});
+		lastX = e.clientX;
+		lastY = e.clientY;
+	};
+	const onDrag = (e) => {
+		e.stopPropagation();
+		if (e.clientX === lastX && e.clientY === lastY) return;
+		state.moveDrag(e.clientX, e.clientY);
+		lastX = e.clientX;
+		lastY = e.clientY;
+	};
+	const onDragEnd = (e) => {
+		e.stopPropagation();
+		let dropEffect = e.dataTransfer?.dropEffect ?? "none";
+		if (getGlobalDropEffect()) dropEffect = getGlobalDropEffect();
+		const dropOperation = DROP_EFFECT_TO_DROP_OPERATION[dropEffect];
+		state.endDrag(e.clientX, e.clientY, dropOperation, false);
+		setGlobalAllowedDropOperations(0);
+		setGlobalDraggingTypes(/* @__PURE__ */ new Set());
+		setGlobalDropEffect(void 0);
+	};
+	const onKeyDown = (e) => {
+		if (e.key === "Enter" && e.target === e.currentTarget) {
+			e.preventDefault();
+			e.stopPropagation();
+		}
+	};
+	const onKeyUp = (e) => {
+		if (e.key === "Enter" && e.target === e.currentTarget) {
+			e.preventDefault();
+			e.stopPropagation();
+			if (getOptions().isDisabled || state.isDisabled) return;
+			const keys = getKeysForDrag();
+			const rect = e.target.getBoundingClientRect();
+			state.startDrag(keys, rect.x + rect.width / 2, rect.y + rect.height / 2);
+			setGlobalDraggingTypes(getTypes(state.getItems(keys)));
+			let allowed = 7;
+			const allowedOps = state.getAllowedDropOperations();
+			if (allowedOps.length > 0) {
+				allowed = 0;
+				for (const op of allowedOps) allowed |= DROP_OPERATION[op] || 0;
+			}
+			setGlobalAllowedDropOperations(allowed);
+		}
+	};
+	const dragProps = createMemo(() => {
+		const opts = getOptions();
+		if (opts.isDisabled || state.isDisabled) return { draggable: false };
+		const baseProps = {
+			draggable: true,
+			onDragStart,
+			onDrag,
+			onDragEnd
+		};
+		if (!opts.hasDragButton) {
+			baseProps.onKeyDown = onKeyDown;
+			baseProps.onKeyUp = onKeyUp;
+		}
+		return baseProps;
+	});
+	const dragButtonProps = createMemo(() => {
+		if (getOptions().isDisabled || state.isDisabled) return { disabled: true };
+		return {
+			type: "button",
+			"aria-label": "Drag",
+			onKeyDown,
+			onKeyUp
+		};
+	});
+	return {
+		get dragProps() {
+			return dragProps();
+		},
+		get dragButtonProps() {
+			return dragButtonProps();
+		},
+		get isDragging() {
+			return isDragging();
+		}
+	};
+}
+//#endregion
+//#region src/dnd/createDroppableItem.ts
+/**
+* createDroppableItem - ARIA hook for droppable items within a collection.
+*
+* Provides accessibility props for items that can receive drops.
+*/
+/**
+* Creates ARIA props for a droppable item within a collection.
+*
+* @param options - Accessor returning item options
+* @param state - Droppable collection state
+* @returns Droppable item ARIA props
+*/
+function createDroppableItem(options, state) {
+	const getOptions = createMemo(() => options());
+	const isDropTarget = createMemo(() => {
+		const { key } = getOptions();
+		const target = state.target;
+		return target?.type === "item" && target.key === key;
+	});
+	const getTarget = (dropPosition) => {
+		const { key } = getOptions();
+		return {
+			type: "item",
+			key,
+			dropPosition
+		};
+	};
+	const getDropOperation = (e, target) => {
+		if (!e.dataTransfer) return "cancel";
+		const types = new DragTypesImpl(e.dataTransfer);
+		let allowedBits = DROP_OPERATION_ALLOWED[e.dataTransfer.effectAllowed] || 7;
+		const globalAllowed = getGlobalAllowedDropOperations();
+		if (globalAllowed) allowedBits &= globalAllowed;
+		const allowedOperations = [];
+		if (allowedBits & 1) allowedOperations.push("move");
+		if (allowedBits & 2) allowedOperations.push("copy");
+		if (allowedBits & 4) allowedOperations.push("link");
+		return state.getDropOperation(target, types, allowedOperations);
+	};
+	let dropActivateTimer;
+	const DROP_ACTIVATE_TIMEOUT = 800;
+	const onDragEnter = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		if (getOptions().isDisabled) return;
+		const rect = e.currentTarget.getBoundingClientRect();
+		e.clientX - rect.x;
+		const y = e.clientY - rect.y;
+		const height = rect.height;
+		let dropPosition;
+		if (y < height * .25) dropPosition = "before";
+		else if (y > height * .75) dropPosition = "after";
+		else dropPosition = "on";
+		const target = getTarget(dropPosition);
+		const operation = getDropOperation(e, target);
+		if (operation !== "cancel") {
+			state.setTarget(target);
+			e.dataTransfer.dropEffect = DROP_OPERATION_TO_DROP_EFFECT[operation];
+		}
+	};
+	const onDragOver = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		if (getOptions().isDisabled) return;
+		const rect = e.currentTarget.getBoundingClientRect();
+		const x = e.clientX - rect.x;
+		const y = e.clientY - rect.y;
+		const height = rect.height;
+		let dropPosition;
+		if (y < height * .25) dropPosition = "before";
+		else if (y > height * .75) dropPosition = "after";
+		else dropPosition = "on";
+		const target = getTarget(dropPosition);
+		const operation = getDropOperation(e, target);
+		if (operation !== "cancel") {
+			state.setTarget(target);
+			e.dataTransfer.dropEffect = DROP_OPERATION_TO_DROP_EFFECT[operation];
+			clearTimeout(dropActivateTimer);
+			if (dropPosition === "on") dropActivateTimer = setTimeout(() => {
+				state.activateTarget(x, y);
+			}, DROP_ACTIVATE_TIMEOUT);
+		} else e.dataTransfer.dropEffect = "none";
+	};
+	const onDragLeave = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		clearTimeout(dropActivateTimer);
+		const relatedTarget = e.relatedTarget;
+		const currentTarget = e.currentTarget;
+		if (!relatedTarget || !currentTarget.contains(relatedTarget)) {
+			const { key } = getOptions();
+			if (state.target?.type === "item" && state.target.key === key) {}
+		}
+	};
+	const onDrop = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		clearTimeout(dropActivateTimer);
+	};
+	const dropProps = createMemo(() => {
+		if (getOptions().isDisabled) return {};
+		return {
+			onDragEnter,
+			onDragOver,
+			onDragLeave,
+			onDrop
+		};
+	});
+	return {
+		get dropProps() {
+			return dropProps();
+		},
+		get isDropTarget() {
+			return isDropTarget();
+		}
+	};
+}
+//#endregion
+export { readFromDataTransfer as A, NATIVE_DRAG_TYPES as C, isDirectoryDropItem as D, getTypes as E, setGlobalDropEffect as M, writeToDataTransfer as N, isFileDropItem as O, GENERIC_TYPE as S, getGlobalDropEffect as T, DROP_OPERATION as _, setGlobalDropCollectionRef as a, DragTypesImpl as b, createDraggableCollection as c, getGlobalDraggingTypes as d, setGlobalDraggingCollectionRef as f, DROP_EFFECT_TO_DROP_OPERATION as g, CUSTOM_DRAG_TYPE as h, getGlobalDropCollectionRef as i, setGlobalAllowedDropOperations as j, isTextDropItem as k, getGlobalDraggingCollectionRef as l, setGlobalDraggingTypes as m, createDraggableItem as n, createDrop as o, setGlobalDraggingKeys as p, createDroppableCollection as r, createDrag as s, createDroppableItem as t, getGlobalDraggingKeys as u, DROP_OPERATION_ALLOWED as v, getGlobalAllowedDropOperations as w, EFFECT_ALLOWED as x, DROP_OPERATION_TO_DROP_EFFECT as y };
+
+//# sourceMappingURL=dnd.js.map