ropav 0.1.6 → 0.1.8

package/dist/useHoverDisclosure.js

@@ -0,0 +1,561 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,86 @@
+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 };