ropav 0.2.0 → 0.3.0

package/dist/useHoverDisclosure.js

@@ -1,561 +0,0 @@
-import { t as useControllableValue } from "./useControllableValue.js";
-import { t as isElement } from "./query.js";
-import { r as normalizeDelay } from "./number.js";
-import { i as isNodeWithinElement, n as isEventWithinElement, r as isEventWithinTargets } from "./events.js";
-import { t as useFloatingTargetLifecycle } from "./useFloatingTargetLifecycle.js";
-import { computed, onBeforeUnmount, onMounted, shallowRef, toValue, watch } from "vue";
-//#region src/components/floating/useHoverDisclosure.ts
-var DEFAULT_OPEN_DELAY = 0;
-var DEFAULT_CLOSE_DELAY = 0;
-var TOUCH_CLICK_EXPIRY_DELAY = 500;
-function useHoverDisclosure(options = {}) {
-	return useHoverDisclosureImplementation(options).disclosure;
-}
-function useHoverDisclosureWithExternalDismissal(options) {
-	return useHoverDisclosureImplementation(options, true);
-}
-function useHoverDisclosureImplementation(options, dismissalRouted = false) {
-	const interaction = createInteractionState();
-	const targets = createTargetState();
-	const commands = useHoverDisclosureOpenState(options, interaction, () => {
-		targets.contentElement = null;
-	});
-	const runtime = useHoverDisclosureInteractions({
-		commands,
-		dismissalRouted,
-		interaction,
-		options,
-		state: commands.state,
-		targets
-	});
-	useHoverDisclosureTargetBinding({
-		commands,
-		options,
-		runtime,
-		targets,
-		useDocumentDismissal: !dismissalRouted
-	});
-	return {
-		disclosure: {
-			isOpen: commands.isOpen,
-			isDisabled: commands.isDisabled,
-			state: commands.state,
-			triggerProps: runtime.triggerProps,
-			contentProps: runtime.contentProps,
-			open: commands.open,
-			close: commands.close,
-			toggle: commands.toggle
-		},
-		dismissalHandlers: {
-			escapeKeyDown: runtime.onDocumentKeydown,
-			pointerDownOutside: runtime.onOutsidePointerdown
-		}
-	};
-}
-function createInteractionState() {
-	return {
-		contentFocused: false,
-		contentHovered: false,
-		touchClickPending: false,
-		touchPinned: false,
-		touchPointerActive: false,
-		triggerFocused: false,
-		triggerHovered: false
-	};
-}
-function createTargetState() {
-	return {
-		contentElement: null,
-		resolvedContentTarget: shallowRef(null),
-		resolvedInteractionTarget: shallowRef(null),
-		triggerElement: null
-	};
-}
-function hasActiveInteraction(state) {
-	return state.triggerHovered || state.contentHovered || state.triggerFocused || state.contentFocused || state.touchPinned;
-}
-function hasPendingTouchInteraction(state) {
-	return state.touchPointerActive || state.touchClickPending;
-}
-function setPartInteraction(state, part, kind, active) {
-	if (part === "trigger" && kind === "hover") {
-		state.triggerHovered = active;
-		return;
-	}
-	if (part === "trigger") {
-		state.triggerFocused = active;
-		return;
-	}
-	if (kind === "hover") {
-		state.contentHovered = active;
-		return;
-	}
-	state.contentFocused = active;
-}
-function resetInteraction(state, part) {
-	if (part === "all" || part === "trigger") {
-		state.triggerFocused = false;
-		state.triggerHovered = false;
-	}
-	if (part === "all" || part === "content") {
-		state.contentFocused = false;
-		state.contentHovered = false;
-	}
-	if (part === "all") {
-		state.touchClickPending = false;
-		state.touchPinned = false;
-		state.touchPointerActive = false;
-	}
-}
-function useHoverDisclosureOpenState(options, interaction, onContentClosed) {
-	const controlledOpen = computed(() => toValue(options.open));
-	const isDisabled = computed(() => Boolean(toValue(options.disabled)));
-	let pendingChangeDetails;
-	const controllableOpen = useControllableValue({
-		modelValue: () => controlledOpen.value,
-		defaultValue: () => options.defaultOpen === true && !isDisabled.value,
-		onChange: (nextOpen) => {
-			if (pendingChangeDetails) options.onOpenChange?.(nextOpen, pendingChangeDetails);
-		}
-	});
-	const openState = controllableOpen.value;
-	const isOpen = computed(() => !isDisabled.value && openState.value);
-	const state = computed(() => isOpen.value ? "open" : "closed");
-	let requestedOpen = openState.value;
-	let openTimer;
-	let closeTimer;
-	let disposed = false;
-	function request(change) {
-		if (change.open) requestOpen(change);
-		else requestClose(change);
-	}
-	function requestOpen(change) {
-		if (change.timing === "immediate") {
-			clearTimers();
-			setOpen(true, change.reason, change.event);
-			return;
-		}
-		if (disposed || isDisabled.value) return;
-		clearCloseTimer();
-		clearOpenTimer();
-		if (requestedOpen) return;
-		const delay = normalizeDelay(toValue(options.openDelay), DEFAULT_OPEN_DELAY);
-		if (delay === 0) {
-			setOpen(true, change.reason, change.event);
-			return;
-		}
-		openTimer = setTimeout(() => {
-			openTimer = void 0;
-			if (!interaction.triggerHovered || isDisabled.value) return;
-			setOpen(true, change.reason, change.event);
-		}, delay);
-	}
-	function requestClose(change) {
-		if (change.timing === "immediate") {
-			clearTimers();
-			setOpen(false, change.reason, change.event);
-			return;
-		}
-		clearOpenTimer();
-		clearCloseTimer();
-		if (disposed || hasActiveInteraction(interaction)) return;
-		closeTimer = setTimeout(() => {
-			closeTimer = void 0;
-			if (hasActiveInteraction(interaction)) return;
-			setOpen(false, change.reason, change.event);
-		}, normalizeDelay(toValue(options.closeDelay), DEFAULT_CLOSE_DELAY));
-	}
-	function setOpen(nextOpen, reason, event) {
-		if (disposed || nextOpen && isDisabled.value || requestedOpen === nextOpen) return;
-		requestedOpen = nextOpen;
-		pendingChangeDetails = {
-			reason,
-			event
-		};
-		try {
-			controllableOpen.setValue(nextOpen);
-		} finally {
-			pendingChangeDetails = void 0;
-		}
-	}
-	function cancelScheduledClose() {
-		clearCloseTimer();
-	}
-	function isRequestedOpen() {
-		return requestedOpen;
-	}
-	function open() {
-		request({
-			open: true,
-			reason: "programmatic",
-			timing: "immediate"
-		});
-	}
-	function close() {
-		interaction.touchPinned = false;
-		request({
-			open: false,
-			reason: "programmatic",
-			timing: "immediate"
-		});
-	}
-	function toggle() {
-		if (requestedOpen || isOpen.value) close();
-		else open();
-	}
-	function clearOpenTimer() {
-		if (openTimer === void 0) return;
-		clearTimeout(openTimer);
-		openTimer = void 0;
-	}
-	function clearCloseTimer() {
-		if (closeTimer === void 0) return;
-		clearTimeout(closeTimer);
-		closeTimer = void 0;
-	}
-	function clearTimers() {
-		clearOpenTimer();
-		clearCloseTimer();
-	}
-	watch([openState, controllableOpen.isControlled], ([value]) => {
-		requestedOpen = value;
-		if (value) return;
-		resetInteraction(interaction, "content");
-		interaction.touchPinned = false;
-		onContentClosed();
-	}, { flush: "sync" });
-	watch(isDisabled, (disabled) => {
-		if (!disabled) return;
-		resetInteraction(interaction, "all");
-		request({
-			open: false,
-			reason: "disabled",
-			timing: "immediate"
-		});
-	});
-	onBeforeUnmount(() => {
-		disposed = true;
-		clearTimers();
-	});
-	return {
-		cancelScheduledClose,
-		close,
-		isDisabled,
-		isOpen,
-		isRequestedOpen,
-		open,
-		request,
-		state,
-		toggle
-	};
-}
-function useHoverDisclosureInteractions({ commands, dismissalRouted, interaction, options, state, targets }) {
-	let touchClickExpiryTimer;
-	function clearTouchClickExpiryTimer() {
-		if (touchClickExpiryTimer === void 0) return;
-		clearTimeout(touchClickExpiryTimer);
-		touchClickExpiryTimer = void 0;
-	}
-	function clearPendingTouchClick() {
-		clearTouchClickExpiryTimer();
-		interaction.touchClickPending = false;
-	}
-	function scheduleTouchClickExpiry() {
-		clearTouchClickExpiryTimer();
-		touchClickExpiryTimer = setTimeout(() => {
-			touchClickExpiryTimer = void 0;
-			interaction.touchClickPending = false;
-		}, TOUCH_CLICK_EXPIRY_DELAY);
-	}
-	function originatesInContent(event) {
-		const contentTarget = targets.resolvedContentTarget.value;
-		return contentTarget !== null && contentTarget !== targets.resolvedInteractionTarget.value && isEventWithinElement(event, contentTarget);
-	}
-	function rememberTarget(part, event) {
-		const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
-		if (part === "trigger") {
-			targets.triggerElement = currentTarget ?? targets.resolvedInteractionTarget.value ?? targets.triggerElement;
-			return;
-		}
-		targets.contentElement = currentTarget ?? targets.resolvedContentTarget.value ?? targets.contentElement;
-	}
-	function onTriggerPointerenter(event) {
-		rememberTarget("trigger", event);
-		if (event.pointerType === "touch" || commands.isDisabled.value) return;
-		setPartInteraction(interaction, "trigger", "hover", true);
-		requestOpen("hover", event, "delayed");
-	}
-	function onTriggerPointerleave(event) {
-		rememberTarget("trigger", event);
-		if (event.pointerType === "touch") return;
-		setPartInteraction(interaction, "trigger", "hover", false);
-		requestClose("hover", event, "delayed");
-	}
-	function onContentPointerenter(event) {
-		rememberTarget("content", event);
-		if (event.pointerType === "touch" || commands.isDisabled.value) return;
-		setPartInteraction(interaction, "content", "hover", true);
-		commands.cancelScheduledClose();
-	}
-	function onContentPointerleave(event) {
-		rememberTarget("content", event);
-		if (event.pointerType === "touch") return;
-		setPartInteraction(interaction, "content", "hover", false);
-		requestClose("hover", event, "delayed");
-	}
-	function onTriggerFocusin(event) {
-		rememberTarget("trigger", event);
-		if (commands.isDisabled.value || toValue(options.openOnFocus) === false || hasPendingTouchInteraction(interaction)) return;
-		setPartInteraction(interaction, "trigger", "focus", true);
-		requestOpen("focus", event, "immediate");
-	}
-	function onTriggerFocusout(event) {
-		rememberTarget("trigger", event);
-		if (!focusLeavesCurrentTarget(event)) return;
-		setPartInteraction(interaction, "trigger", "focus", false);
-		requestClose("focus", event, "delayed");
-	}
-	function onContentFocusin(event) {
-		rememberTarget("content", event);
-		if (commands.isDisabled.value) return;
-		setPartInteraction(interaction, "content", "focus", true);
-		commands.cancelScheduledClose();
-	}
-	function onContentFocusout(event) {
-		rememberTarget("content", event);
-		if (!focusLeavesCurrentTarget(event)) return;
-		setPartInteraction(interaction, "content", "focus", false);
-		requestClose("focus", event, "delayed");
-	}
-	function onTriggerPointerdown(event) {
-		if (originatesInContent(event)) return;
-		rememberTarget("trigger", event);
-		clearPendingTouchClick();
-		interaction.touchPointerActive = event.pointerType === "touch";
-	}
-	function onTriggerPointerup(event) {
-		if (originatesInContent(event)) return;
-		rememberTarget("trigger", event);
-		interaction.touchClickPending = event.pointerType === "touch" && interaction.touchPointerActive;
-		interaction.touchPointerActive = false;
-		if (interaction.touchClickPending) scheduleTouchClickExpiry();
-	}
-	function onTriggerPointercancel(event) {
-		if (originatesInContent(event)) return;
-		rememberTarget("trigger", event);
-		clearTouchClickExpiryTimer();
-		interaction.touchClickPending = false;
-		interaction.touchPointerActive = false;
-	}
-	function onTriggerClick(event) {
-		if (originatesInContent(event)) return;
-		rememberTarget("trigger", event);
-		clearTouchClickExpiryTimer();
-		if (!interaction.touchClickPending) return;
-		interaction.touchClickPending = false;
-		if (getTouchBehavior() !== "toggle" || commands.isDisabled.value) return;
-		event.preventDefault();
-		if (interaction.touchPinned || commands.isRequestedOpen()) {
-			interaction.touchPinned = false;
-			requestClose("touch", event, "immediate");
-			return;
-		}
-		interaction.touchPinned = true;
-		requestOpen("touch", event, "immediate");
-	}
-	function onContentPointerdown(event) {
-		rememberTarget("content", event);
-	}
-	function requestEscapeClose(event) {
-		if (event.key !== "Escape" || toValue(options.closeOnEscape) === false || !commands.isOpen.value) return false;
-		interaction.touchPinned = false;
-		requestClose("escape", event, "immediate");
-		return true;
-	}
-	function onKeydown(event) {
-		if (dismissalRouted || !requestEscapeClose(event)) return;
-		event.stopPropagation();
-	}
-	function onDocumentKeydown(event) {
-		requestEscapeClose(event);
-	}
-	function onOutsidePointerdown(event) {
-		if (!interaction.touchPinned) return;
-		interaction.touchPinned = false;
-		requestClose("outside", event, "immediate");
-	}
-	function onTargetDetached(part) {
-		clearPendingTouchClick();
-		if (part === "trigger") interaction.touchPointerActive = false;
-		resetInteraction(interaction, part);
-		requestClose("hover", void 0, "delayed");
-	}
-	function requestOpen(reason, event, timing) {
-		commands.request({
-			event,
-			open: true,
-			reason,
-			timing
-		});
-	}
-	function requestClose(reason, event, timing) {
-		commands.request({
-			event,
-			open: false,
-			reason,
-			timing
-		});
-	}
-	function getTouchBehavior() {
-		return toValue(options.touchBehavior) ?? "none";
-	}
-	const presentation = createInteractionPresentation(state, {
-		content: {
-			onFocusin: onContentFocusin,
-			onFocusout: onContentFocusout,
-			onKeydown,
-			onPointerdown: onContentPointerdown,
-			onPointerenter: onContentPointerenter,
-			onPointerleave: onContentPointerleave
-		},
-		trigger: {
-			onClick: onTriggerClick,
-			onFocusin: onTriggerFocusin,
-			onFocusout: onTriggerFocusout,
-			onKeydown,
-			onPointercancel: onTriggerPointercancel,
-			onPointerdown: onTriggerPointerdown,
-			onPointerenter: onTriggerPointerenter,
-			onPointerleave: onTriggerPointerleave,
-			onPointerup: onTriggerPointerup
-		}
-	});
-	watch(() => getTouchBehavior(), (behavior) => {
-		if (behavior === "toggle" || !interaction.touchPinned) return;
-		interaction.touchPinned = false;
-		requestClose("touch", void 0, "immediate");
-	});
-	onBeforeUnmount(clearTouchClickExpiryTimer);
-	return {
-		contentListeners: presentation.contentListeners,
-		contentProps: presentation.contentProps,
-		isOutsideDismissalActive: () => interaction.touchPinned,
-		onDocumentKeydown,
-		onOutsidePointerdown,
-		onTargetDetached,
-		triggerListeners: presentation.triggerListeners,
-		triggerProps: presentation.triggerProps
-	};
-}
-function createInteractionPresentation(state, handlers) {
-	const triggerProps = computed(() => ({
-		"data-state": state.value,
-		...handlers.trigger
-	}));
-	const contentProps = computed(() => ({
-		"data-state": state.value,
-		...handlers.content
-	}));
-	const triggerListeners = [
-		["pointerenter", handlers.trigger.onPointerenter],
-		["pointerleave", handlers.trigger.onPointerleave],
-		["pointerdown", handlers.trigger.onPointerdown],
-		["pointerup", handlers.trigger.onPointerup],
-		["pointercancel", handlers.trigger.onPointercancel],
-		["click", handlers.trigger.onClick],
-		["focusin", handlers.trigger.onFocusin],
-		["focusout", handlers.trigger.onFocusout],
-		["keydown", handlers.trigger.onKeydown]
-	];
-	return {
-		contentListeners: [
-			["pointerenter", handlers.content.onPointerenter],
-			["pointerleave", handlers.content.onPointerleave],
-			["pointerdown", handlers.content.onPointerdown],
-			["focusin", handlers.content.onFocusin],
-			["focusout", handlers.content.onFocusout],
-			["keydown", handlers.content.onKeydown]
-		],
-		contentProps,
-		triggerListeners,
-		triggerProps
-	};
-}
-function focusLeavesCurrentTarget(event) {
-	const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
-	return !isNodeWithinElement(event.relatedTarget, currentTarget);
-}
-function useHoverDisclosureTargetBinding({ commands, options, runtime, targets, useDocumentDismissal }) {
-	let documentListenersActive = false;
-	function setCurrentTarget(part, target) {
-		if (part === "trigger") targets.triggerElement = target;
-		else targets.contentElement = target;
-	}
-	function clearCurrentTarget(part, target) {
-		if (part === "trigger" && targets.triggerElement === target) targets.triggerElement = null;
-		if (part === "content" && targets.contentElement === target) targets.contentElement = null;
-	}
-	function connectTarget(part, target) {
-		setCurrentTarget(part, target);
-		return () => {
-			clearCurrentTarget(part, target);
-			runtime.onTargetDetached(part);
-		};
-	}
-	function onDocumentPointerdown(event) {
-		if (!runtime.isOutsideDismissalActive()) return;
-		if (isEventInsideTargets(event, targets)) return;
-		runtime.onOutsidePointerdown(event);
-	}
-	function setDocumentListeners(active) {
-		if (!useDocumentDismissal || typeof document === "undefined" || active === documentListenersActive) return;
-		documentListenersActive = active;
-		if (active) {
-			document.addEventListener("keydown", runtime.onDocumentKeydown);
-			document.addEventListener("pointerdown", onDocumentPointerdown, true);
-			return;
-		}
-		document.removeEventListener("keydown", runtime.onDocumentKeydown);
-		document.removeEventListener("pointerdown", onDocumentPointerdown, true);
-	}
-	const fallbackTarget = shallowRef(null);
-	const interactionTargetLifecycle = useFloatingTargetLifecycle({
-		target: () => toValue(options.interactionTarget),
-		fallback: fallbackTarget,
-		getTargetElement: (reference) => {
-			if (isElement(reference)) return reference;
-			return isElement(reference.contextElement) ? reference.contextElement : null;
-		}
-	});
-	const contentTargetLifecycle = useFloatingTargetLifecycle({
-		target: () => toValue(options.contentTarget),
-		fallback: fallbackTarget
-	});
-	targets.resolvedInteractionTarget = interactionTargetLifecycle.targetElement;
-	targets.resolvedContentTarget = contentTargetLifecycle.targetElement;
-	interactionTargetLifecycle.bindTarget({
-		connect: (target) => connectTarget("trigger", target),
-		listeners: runtime.triggerListeners
-	});
-	contentTargetLifecycle.bindTarget({
-		connect: (target) => connectTarget("content", target),
-		listeners: runtime.contentListeners
-	});
-	watch(commands.isOpen, setDocumentListeners, { flush: "sync" });
-	onMounted(() => {
-		setDocumentListeners(commands.isOpen.value);
-	});
-	onBeforeUnmount(() => {
-		setDocumentListeners(false);
-	});
-}
-function isEventInsideTargets(event, targets) {
-	return isEventWithinTargets(event, [
-		targets.triggerElement,
-		targets.contentElement,
-		targets.resolvedInteractionTarget.value,
-		targets.resolvedContentTarget.value
-	].filter((element) => element !== null));
-}
-//#endregion
-export { useHoverDisclosureWithExternalDismissal as n, useHoverDisclosure as t };

package/dist/useNativeChoiceTransaction.js

@@ -1,46 +0,0 @@
-import { t as useControllableValue } from "./useControllableValue.js";
-import { i as useFormControl } from "./useFormControl.js";
-import { nextTick, watchEffect } from "vue";
-//#region src/internal/composables/useNativeChoiceTransaction.ts
-function useNativeChoiceTransaction(options) {
-	const controllable = useControllableValue(options.value);
-	function syncNativeValue(value) {
-		options.adapter.syncValue(value, controllable.initialValue);
-	}
-	function restoreControlledValue() {
-		if (!controllable.isControlled.value) return;
-		queueMicrotask(() => syncNativeValue(controllable.value.value));
-	}
-	function requestValueUpdate(value) {
-		options.adapter.commitValue(value, controllable.initialValue, () => controllable.setValue(value));
-		restoreControlledValue();
-	}
-	useFormControl({
-		elements: options.adapter.controls,
-		isControlled: () => controllable.isControlled.value,
-		validationMessage: options.adapter.validationMessage,
-		readResetValue(controls) {
-			controllable.resetValue(options.adapter.readResetValue(controls, controllable.initialValue));
-			syncNativeValue(controllable.value.value);
-			options.onFormReset?.();
-		},
-		syncControlledValue() {
-			syncNativeValue(controllable.value.value);
-			options.onFormReset?.();
-		}
-	});
-	watchEffect(() => {
-		const currentValue = controllable.value.value;
-		const reconciledValue = options.adapter.reconcileValue?.(currentValue, controllable.initialValue, controllable.isControlled.value) ?? currentValue;
-		if (!controllable.isControlled.value && !Object.is(reconciledValue, currentValue)) controllable.resetValue(reconciledValue);
-		syncNativeValue(controllable.value.value);
-		nextTick(() => syncNativeValue(controllable.value.value));
-	}, { flush: "post" });
-	return {
-		isControlled: controllable.isControlled,
-		requestValueUpdate,
-		value: controllable.value
-	};
-}
-//#endregion
-export { useNativeChoiceTransaction as t };

package/dist/useNativeFileSelection.js

@@ -1,86 +0,0 @@
-import { t as useControllableValue } from "./useControllableValue.js";
-import { i as useFormControl } from "./useFormControl.js";
-import { computed, nextTick, ref, watchEffect } from "vue";
-//#region src/utils/dom/files.ts
-function normalizeSelectedFiles(files, multiple) {
-	const selectedFiles = Array.from(files);
-	return multiple ? selectedFiles : selectedFiles.slice(0, 1);
-}
-function haveSameFiles(fileList, files) {
-	if (!fileList || fileList.length !== files.length) return false;
-	return files.every((file, index) => fileList.item(index) === file);
-}
-function replaceInputFiles(input, files) {
-	if (haveSameFiles(input.files, files)) return true;
-	if (files.length === 0) {
-		input.value = "";
-		return true;
-	}
-	const DataTransferConstructor = input.ownerDocument.defaultView?.DataTransfer;
-	if (!DataTransferConstructor) return false;
-	const transfer = new DataTransferConstructor();
-	for (const file of files) transfer.items.add(file);
-	try {
-		input.files = transfer.files;
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/internal/composables/useNativeFileSelection.ts
-function useNativeFileSelection(options) {
-	const inputRef = ref(null);
-	const controllable = useControllableValue({
-		modelValue: options.modelValue,
-		defaultValue: () => [],
-		onChange: options.onChange
-	});
-	const files = computed(() => normalizeSelectedFiles(controllable.value.value, options.multiple()));
-	function syncNativeFiles(nextFiles = files.value) {
-		const input = inputRef.value;
-		if (input) replaceInputFiles(input, nextFiles);
-	}
-	function settleSelection(outcome) {
-		if (outcome.status === "accepted") {
-			const nextFiles = normalizeSelectedFiles(outcome.files, options.multiple());
-			syncNativeFiles(nextFiles);
-			controllable.setValue(nextFiles);
-		} else syncNativeFiles();
-		nextTick(() => syncNativeFiles());
-	}
-	function clear() {
-		settleSelection({
-			status: "accepted",
-			files: []
-		});
-	}
-	function focus(focusOptions) {
-		inputRef.value?.focus(focusOptions);
-	}
-	function open() {
-		if (options.disabled()) return;
-		inputRef.value?.click();
-	}
-	watchEffect(() => syncNativeFiles(files.value), { flush: "post" });
-	useFormControl({
-		elements: () => [inputRef.value],
-		isControlled: () => controllable.isControlled.value,
-		validationMessage: options.validationMessage,
-		readResetValue() {
-			controllable.resetValue([]);
-			settleSelection({ status: "rejected" });
-		},
-		syncControlledValue: () => settleSelection({ status: "rejected" })
-	});
-	return {
-		inputRef,
-		files,
-		settleSelection,
-		clear,
-		focus,
-		open
-	};
-}
-//#endregion
-export { useNativeFileSelection as t };