@proyecto-viviana/solidaria 0.3.0 → 0.4.1

package/dist/_chunk/DragManager.jsx

@@ -0,0 +1,627 @@
+import { m as isVirtualPointerEvent, p as isVirtualClick } from "./utils.jsx";
+import { a as getEventTarget, i as getActiveElement, y as nodeContains } from "./focus.jsx";
+import { o as getInteractionModality } from "./createInteractionModality.jsx";
+import { t as ariaHideOutside } from "./ariaHideOutside.jsx";
+import { t as announce } from "./announce.jsx";
+import { createSignal } from "solid-js";
+import { DIRECTORY_DRAG_TYPE } 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"
+};
+/**
+* Maps the current interaction modality onto the drag modality used for
+* announcements and descriptions. Mirrors @react-aria/dnd `mapModality`:
+* pointer collapses to virtual, and a virtual modality on a coarse pointer
+* (touch screen reader) becomes touch.
+*/
+function mapModality(modality) {
+	if (!modality) modality = "virtual";
+	if (modality === "pointer") modality = "virtual";
+	if (modality === "virtual" && typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(pointer: coarse)").matches) modality = "touch";
+	return modality;
+}
+/**
+* Returns the drag modality ('keyboard' | 'virtual' | 'touch') for the current
+* interaction. Mirrors @react-aria/dnd `getDragModality`.
+*/
+function getDragModality() {
+	return mapModality(getInteractionModality());
+}
+/**
+* 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/DragManager.ts
+/**
+* Global keyboard/virtual drag session manager.
+*
+* Faithful port of @react-aria/dnd `DragManager` (react-aria 3.50). A single
+* module-level singleton owns the active drag session: it registers drop targets
+* and drop items across every collection on the page, drives Tab/Shift+Tab
+* cycling between them, Enter-to-drop / Escape-to-cancel, and the aria-live
+* announcements — providing the accessible keyboard alternative to native
+* pointer drag and drop.
+*
+* The only framework-specific adaptation from upstream is the reactive
+* subscription: React's `useDragSession` (useState + a subscription Set) becomes
+* a module-level Solid signal exposed through `createDragSession()`. Element refs
+* (upstream `RefObject.current`) become Solid element accessors (`() => el`).
+*/
+let dropTargets = /* @__PURE__ */ new Map();
+let dropItems = /* @__PURE__ */ new Map();
+let dragSession = null;
+const [trackedDragSession, setTrackedDragSession] = createSignal(null);
+function registerDropTarget(target) {
+	dropTargets.set(target.element, target);
+	dragSession?.updateValidDropTargets();
+	return () => {
+		dropTargets.delete(target.element);
+		dragSession?.updateValidDropTargets();
+	};
+}
+function registerDropItem(item) {
+	dropItems.set(item.element, item);
+	return () => {
+		dropItems.delete(item.element);
+	};
+}
+function beginDragging(target, stringFormatter) {
+	if (dragSession) throw new Error("Cannot begin dragging while already dragging");
+	dragSession = new DragSession(target, stringFormatter);
+	setTrackedDragSession(dragSession);
+	requestAnimationFrame(() => {
+		if (dragSession) {
+			dragSession.setup();
+			if (getDragModality() === "keyboard") dragSession.next();
+		}
+	});
+}
+/** Reactive accessor for the active drag session, or null. */
+function createDragSession() {
+	return trackedDragSession;
+}
+/** @private */
+function isVirtualDragging() {
+	return !!dragSession;
+}
+function endDragging() {
+	dragSession = null;
+	setTrackedDragSession(null);
+}
+const CANCELED_EVENTS = [
+	"pointerdown",
+	"pointermove",
+	"pointerenter",
+	"pointerleave",
+	"pointerover",
+	"pointerout",
+	"pointerup",
+	"mousedown",
+	"mousemove",
+	"mouseenter",
+	"mouseleave",
+	"mouseover",
+	"mouseout",
+	"mouseup",
+	"touchstart",
+	"touchmove",
+	"touchend",
+	"focusin",
+	"focusout"
+];
+const CLICK_EVENTS = [
+	"pointerup",
+	"mouseup",
+	"touchend"
+];
+const MESSAGES = {
+	keyboard: "dragStartedKeyboard",
+	touch: "dragStartedTouch",
+	virtual: "dragStartedVirtual"
+};
+var DragSession = class {
+	dragTarget;
+	validDropTargets = [];
+	currentDropTarget = null;
+	currentDropItem = null;
+	dropOperation = null;
+	mutationObserver = null;
+	restoreAriaHidden = null;
+	stringFormatter;
+	isVirtualClick = false;
+	initialFocused;
+	constructor(target, stringFormatter) {
+		this.dragTarget = target;
+		this.stringFormatter = stringFormatter;
+		this.onKeyDown = this.onKeyDown.bind(this);
+		this.onKeyUp = this.onKeyUp.bind(this);
+		this.onFocus = this.onFocus.bind(this);
+		this.onBlur = this.onBlur.bind(this);
+		this.onClick = this.onClick.bind(this);
+		this.onPointerDown = this.onPointerDown.bind(this);
+		this.cancelEvent = this.cancelEvent.bind(this);
+		this.initialFocused = false;
+	}
+	setup() {
+		document.addEventListener("keydown", this.onKeyDown, true);
+		document.addEventListener("keyup", this.onKeyUp, true);
+		window.addEventListener("focus", this.onFocus, true);
+		window.addEventListener("blur", this.onBlur, true);
+		document.addEventListener("click", this.onClick, true);
+		document.addEventListener("pointerdown", this.onPointerDown, true);
+		for (let event of CANCELED_EVENTS) document.addEventListener(event, this.cancelEvent, true);
+		this.mutationObserver = new MutationObserver(() => this.updateValidDropTargets());
+		this.updateValidDropTargets();
+		announce(this.stringFormatter.format(MESSAGES[getDragModality()]));
+	}
+	teardown() {
+		document.removeEventListener("keydown", this.onKeyDown, true);
+		document.removeEventListener("keyup", this.onKeyUp, true);
+		window.removeEventListener("focus", this.onFocus, true);
+		window.removeEventListener("blur", this.onBlur, true);
+		document.removeEventListener("click", this.onClick, true);
+		document.removeEventListener("pointerdown", this.onPointerDown, true);
+		for (let event of CANCELED_EVENTS) document.removeEventListener(event, this.cancelEvent, true);
+		this.mutationObserver?.disconnect();
+		this.restoreAriaHidden?.();
+	}
+	onKeyDown(e) {
+		this.cancelEvent(e);
+		if (e.key === "Escape") {
+			this.cancel();
+			return;
+		}
+		if (e.key === "Tab" && !(e.metaKey || e.altKey || e.ctrlKey)) if (e.shiftKey) this.previous();
+		else this.next();
+		if (typeof this.currentDropTarget?.onKeyDown === "function") this.currentDropTarget.onKeyDown(e, this.dragTarget);
+	}
+	onKeyUp(e) {
+		this.cancelEvent(e);
+		if (e.key === "Enter") if (e.altKey || nodeContains(this.getCurrentActivateButton(), getEventTarget(e))) this.activate(this.currentDropTarget, this.currentDropItem);
+		else this.drop();
+	}
+	getCurrentActivateButton() {
+		return this.currentDropItem?.activateButtonRef?.() ?? this.currentDropTarget?.activateButtonRef?.() ?? null;
+	}
+	onFocus(e) {
+		let activateButton = this.getCurrentActivateButton();
+		let eventTarget = getEventTarget(e);
+		if (eventTarget === activateButton) {
+			this.cancelEvent(e);
+			return;
+		}
+		if (eventTarget !== this.dragTarget.element) this.cancelEvent(e);
+		if (!(eventTarget instanceof HTMLElement) || eventTarget === this.dragTarget.element) return;
+		let dropTarget = this.validDropTargets.find((target) => target.element === eventTarget) || this.validDropTargets.find((target) => nodeContains(target.element, eventTarget));
+		if (!dropTarget) {
+			if (this.currentDropTarget) this.currentDropTarget.element.focus();
+			else this.dragTarget.element.focus();
+			return;
+		}
+		let item = dropItems.get(eventTarget);
+		if (dropTarget) this.setCurrentDropTarget(dropTarget, item);
+	}
+	onBlur(e) {
+		let activateButton = this.getCurrentActivateButton();
+		if (activateButton && e.relatedTarget === activateButton) {
+			this.cancelEvent(e);
+			return;
+		}
+		if (getEventTarget(e) !== this.dragTarget.element) this.cancelEvent(e);
+		if (!e.relatedTarget || !(e.relatedTarget instanceof HTMLElement)) if (this.currentDropTarget) this.currentDropTarget.element.focus();
+		else this.dragTarget.element.focus();
+	}
+	onClick(e) {
+		this.cancelEvent(e);
+		if (isVirtualClick(e) || this.isVirtualClick) {
+			let dropElements = dropItems.values();
+			let eventTarget = getEventTarget(e);
+			let item = [...dropElements].find((item) => item.element === eventTarget || nodeContains(item.activateButtonRef?.() ?? null, eventTarget));
+			let dropTarget = this.validDropTargets.find((target) => nodeContains(target.element, eventTarget));
+			if (nodeContains(item?.activateButtonRef?.() ?? dropTarget?.activateButtonRef?.() ?? null, eventTarget) && dropTarget) {
+				this.activate(dropTarget, item);
+				return;
+			}
+			if (getEventTarget(e) === this.dragTarget.element) {
+				this.cancel();
+				return;
+			}
+			if (dropTarget) {
+				this.setCurrentDropTarget(dropTarget, item);
+				this.drop(item);
+			}
+		}
+	}
+	onPointerDown(e) {
+		this.cancelEvent(e);
+		this.isVirtualClick = isVirtualPointerEvent(e);
+	}
+	cancelEvent(e) {
+		let eventTarget = getEventTarget(e);
+		if ((e.type === "focusin" || e.type === "focusout") && (eventTarget === this.dragTarget?.element || eventTarget === this.getCurrentActivateButton())) return;
+		if (!CLICK_EVENTS.includes(e.type)) e.preventDefault();
+		e.stopPropagation();
+		e.stopImmediatePropagation();
+	}
+	updateValidDropTargets() {
+		if (!this.mutationObserver) return;
+		this.mutationObserver.disconnect();
+		if (this.restoreAriaHidden) this.restoreAriaHidden();
+		this.validDropTargets = findValidDropTargets(this.dragTarget);
+		if (this.validDropTargets.length > 0) {
+			let nearestIndex = this.findNearestDropTarget();
+			this.validDropTargets = [...this.validDropTargets.slice(nearestIndex), ...this.validDropTargets.slice(0, nearestIndex)];
+		}
+		if (this.currentDropTarget && !this.validDropTargets.includes(this.currentDropTarget)) this.setCurrentDropTarget(this.validDropTargets[0]);
+		let types = getTypes(this.dragTarget.items);
+		let validDropItems = [...dropItems.values()].filter((item) => {
+			if (typeof item.getDropOperation === "function") return item.getDropOperation(types, this.dragTarget.allowedDropOperations) !== "cancel";
+			return true;
+		});
+		let visibleDropTargets = this.validDropTargets.filter((target) => !validDropItems.some((item) => nodeContains(target.element, item.element)));
+		this.restoreAriaHidden = ariaHideOutside([
+			this.dragTarget.element,
+			...validDropItems.flatMap((item) => {
+				let button = item.activateButtonRef?.();
+				return button ? [item.element, button] : [item.element];
+			}),
+			...visibleDropTargets.flatMap((target) => {
+				let button = target.activateButtonRef?.();
+				return button ? [target.element, button] : [target.element];
+			})
+		], { shouldUseInert: true });
+		this.mutationObserver.observe(document.body, {
+			subtree: true,
+			attributes: true,
+			attributeFilter: ["aria-hidden", "inert"]
+		});
+	}
+	next() {
+		if (!this.currentDropTarget) {
+			this.setCurrentDropTarget(this.validDropTargets[0]);
+			return;
+		}
+		let index = this.validDropTargets.indexOf(this.currentDropTarget);
+		if (index < 0) {
+			this.setCurrentDropTarget(this.validDropTargets[0]);
+			return;
+		}
+		if (index === this.validDropTargets.length - 1) if (!this.dragTarget.element.closest("[aria-hidden=\"true\"], [inert]")) {
+			this.setCurrentDropTarget(null);
+			this.dragTarget.element.focus();
+		} else this.setCurrentDropTarget(this.validDropTargets[0]);
+		else this.setCurrentDropTarget(this.validDropTargets[index + 1]);
+	}
+	previous() {
+		if (!this.currentDropTarget) {
+			this.setCurrentDropTarget(this.validDropTargets[this.validDropTargets.length - 1]);
+			return;
+		}
+		let index = this.validDropTargets.indexOf(this.currentDropTarget);
+		if (index < 0) {
+			this.setCurrentDropTarget(this.validDropTargets[this.validDropTargets.length - 1]);
+			return;
+		}
+		if (index === 0) if (!this.dragTarget.element.closest("[aria-hidden=\"true\"], [inert]")) {
+			this.setCurrentDropTarget(null);
+			this.dragTarget.element.focus();
+		} else this.setCurrentDropTarget(this.validDropTargets[this.validDropTargets.length - 1]);
+		else this.setCurrentDropTarget(this.validDropTargets[index - 1]);
+	}
+	findNearestDropTarget() {
+		let dragTargetRect = this.dragTarget.element.getBoundingClientRect();
+		let minDistance = Infinity;
+		let nearest = -1;
+		for (let i = 0; i < this.validDropTargets.length; i++) {
+			let rect = this.validDropTargets[i].element.getBoundingClientRect();
+			let dx = rect.left - dragTargetRect.left;
+			let dy = rect.top - dragTargetRect.top;
+			let dist = dx * dx + dy * dy;
+			if (dist < minDistance) {
+				minDistance = dist;
+				nearest = i;
+			}
+		}
+		return nearest;
+	}
+	setCurrentDropTarget(dropTarget, item) {
+		if (dropTarget !== this.currentDropTarget) {
+			if (this.currentDropTarget && typeof this.currentDropTarget.onDropExit === "function") {
+				let rect = this.currentDropTarget.element.getBoundingClientRect();
+				this.currentDropTarget.onDropExit({
+					type: "dropexit",
+					x: rect.left + rect.width / 2,
+					y: rect.top + rect.height / 2
+				});
+			}
+			this.currentDropTarget = dropTarget;
+			if (dropTarget) {
+				if (typeof dropTarget.onDropEnter === "function") {
+					let rect = dropTarget.element.getBoundingClientRect();
+					dropTarget.onDropEnter({
+						type: "dropenter",
+						x: rect.left + rect.width / 2,
+						y: rect.top + rect.height / 2
+					}, this.dragTarget);
+				}
+				if (!item) dropTarget?.element.focus();
+			}
+		}
+		if (item != null && item !== this.currentDropItem) {
+			if (this.currentDropTarget && typeof this.currentDropTarget.onDropTargetEnter === "function") this.currentDropTarget.onDropTargetEnter(item.target);
+			item.element.focus();
+			this.currentDropItem = item;
+			if (!this.initialFocused) {
+				let label = item?.element.getAttribute("aria-label");
+				if (label) announce(label, "polite");
+				this.initialFocused = true;
+			}
+		}
+	}
+	end() {
+		this.teardown();
+		endDragging();
+		if (typeof this.dragTarget.onDragEnd === "function") {
+			let rect = (this.currentDropTarget && this.dropOperation !== "cancel" ? this.currentDropTarget : this.dragTarget).element.getBoundingClientRect();
+			this.dragTarget.onDragEnd({
+				type: "dragend",
+				x: rect.x + rect.width / 2,
+				y: rect.y + rect.height / 2,
+				dropOperation: this.dropOperation || "cancel"
+			});
+		}
+		if (this.currentDropTarget && !this.currentDropTarget.preventFocusOnDrop) getActiveElement()?.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));
+		this.setCurrentDropTarget(null);
+	}
+	cancel() {
+		this.setCurrentDropTarget(null);
+		this.end();
+		if (!this.dragTarget.element.closest("[aria-hidden=\"true\"], [inert]")) this.dragTarget.element.focus();
+		getActiveElement()?.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));
+		announce(this.stringFormatter.format("dropCanceled"));
+	}
+	drop(item) {
+		if (!this.currentDropTarget) {
+			this.cancel();
+			return;
+		}
+		if (typeof item?.getDropOperation === "function") {
+			let types = getTypes(this.dragTarget.items);
+			this.dropOperation = item.getDropOperation(types, this.dragTarget.allowedDropOperations);
+		} else if (typeof this.currentDropTarget.getDropOperation === "function") {
+			let types = getTypes(this.dragTarget.items);
+			this.dropOperation = this.currentDropTarget.getDropOperation(types, this.dragTarget.allowedDropOperations);
+		} else this.dropOperation = this.dragTarget.allowedDropOperations[0];
+		if (typeof this.currentDropTarget.onDrop === "function") {
+			let items = this.dragTarget.items.map((item) => ({
+				kind: "text",
+				types: new Set(Object.keys(item)),
+				getText: (type) => Promise.resolve(item[type])
+			}));
+			let rect = this.currentDropTarget.element.getBoundingClientRect();
+			this.currentDropTarget.onDrop({
+				type: "drop",
+				x: rect.left + rect.width / 2,
+				y: rect.top + rect.height / 2,
+				items,
+				dropOperation: this.dropOperation
+			}, item?.target ?? null);
+		}
+		this.end();
+		announce(this.stringFormatter.format("dropComplete"));
+	}
+	activate(dropTarget, dropItem) {
+		if (dropTarget && typeof dropTarget.onDropActivate === "function") {
+			let target = dropItem?.target ?? null;
+			let rect = dropTarget.element.getBoundingClientRect();
+			dropTarget.onDropActivate({
+				type: "dropactivate",
+				x: rect.left + rect.width / 2,
+				y: rect.top + rect.height / 2
+			}, target);
+		}
+	}
+};
+function findValidDropTargets(options) {
+	let types = getTypes(options.items);
+	return [...dropTargets.values()].filter((target) => {
+		if (target.element.closest("[aria-hidden=\"true\"], [inert]")) return false;
+		if (typeof target.getDropOperation === "function") return target.getDropOperation(types, options.allowedDropOperations) !== "cancel";
+		return true;
+	});
+}
+//#endregion
+export { setGlobalAllowedDropOperations as C, readFromDataTransfer as S, writeToDataTransfer as T, getGlobalDropEffect as _, registerDropTarget as a, isFileDropItem as b, DROP_OPERATION as c, DragTypesImpl as d, EFFECT_ALLOWED as f, getGlobalAllowedDropOperations as g, getDragModality as h, registerDropItem as i, DROP_OPERATION_ALLOWED as l, NATIVE_DRAG_TYPES as m, createDragSession as n, CUSTOM_DRAG_TYPE as o, GENERIC_TYPE as p, isVirtualDragging as r, DROP_EFFECT_TO_DROP_OPERATION as s, beginDragging as t, DROP_OPERATION_TO_DROP_EFFECT as u, getTypes as v, setGlobalDropEffect as w, isTextDropItem as x, isDirectoryDropItem as y };
+
+//# sourceMappingURL=DragManager.jsx.map