ropav 0.5.0 → 0.7.0

package/dist/components/drawer/index.d.ts

@@ -10,297 +10,8 @@ import DrawerHeader from "./drawer-header.js";
 import DrawerHeading from "./drawer-heading.js";
 import DrawerRoot from "./drawer-root.js";
 import DrawerTrigger from "./drawer-trigger.js";
-export declare const Drawer: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-    attrs: any;
-    slots: {
-        default?: () => unknown;
-    };
-    emit: ((evt: "openChange", isOpen: boolean) => void) & ((evt: "update:isOpen", isOpen: boolean) => void);
-}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-    props: import('vue').PublicProps & {
-        isOpen?: boolean;
-        defaultOpen?: boolean;
-        isDisabled?: boolean;
-        state?: import("../../index.js").OverlayTriggerState;
-        onOpenChange?: ((isOpen: boolean) => any) | undefined;
-        "onUpdate:isOpen"?: ((isOpen: boolean) => any) | undefined;
-    } & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: {}) => void;
-    attrs: any;
-    slots: {
-        default?: () => unknown;
-    };
-    emit: ((evt: "openChange", isOpen: boolean) => void) & ((evt: "update:isOpen", isOpen: boolean) => void);
-}>) => import('vue').VNode & {
-    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-}) & {
-    Backdrop: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-            variant?: import("@ropav/styles").DrawerVariants["variant"];
-            isDismissable?: boolean;
-            isKeyboardDismissDisabled?: boolean;
-            shouldCloseOnInteractOutside?: (element: Element) => boolean;
-            portalContainer?: string | HTMLElement;
-            style?: import("vue").CSSProperties | string;
-            isEntering?: boolean;
-            isExiting?: boolean;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Body: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Close: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    CloseTrigger: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {};
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {};
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Content: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-            placement?: import("./drawer.types.js").DrawerPlacement;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Dialog: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: (props: {
-                close: () => void;
-            }) => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: (props: {
-                close: () => void;
-            }) => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Footer: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Handle: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {};
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {};
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Header: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Heading: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-            level?: number;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Root: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: ((evt: "openChange", isOpen: boolean) => void) & ((evt: "update:isOpen", isOpen: boolean) => void);
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            isOpen?: boolean;
-            defaultOpen?: boolean;
-            isDisabled?: boolean;
-            state?: import("../../index.js").OverlayTriggerState;
-            onOpenChange?: ((isOpen: boolean) => any) | undefined;
-            "onUpdate:isOpen"?: ((isOpen: boolean) => any) | undefined;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: ((evt: "openChange", isOpen: boolean) => void) & ((evt: "update:isOpen", isOpen: boolean) => void);
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-    Trigger: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
-        props: import('vue').PublicProps & {
-            class?: string;
-            isDisabled?: boolean;
-        } & (typeof globalThis extends {
-            __VLS_PROPS_FALLBACK: infer P;
-        } ? P : {});
-        expose: (exposed: {}) => void;
-        attrs: any;
-        slots: {
-            default?: () => unknown;
-        };
-        emit: {};
-    }>) => import('vue').VNode & {
-        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-    };
-};
-export { DrawerBackdrop, DrawerBody, DrawerClose, DrawerCloseTrigger, DrawerContent, DrawerDialog, DrawerFooter, DrawerHandle, DrawerHeader, DrawerHeading, DrawerRoot, DrawerTrigger, };
-export type { DrawerBackdropProps, DrawerBodyProps, DrawerCloseTriggerProps, DrawerContentProps, DrawerDialogProps, DrawerDialogSlotProps, DrawerFooterProps, DrawerHandleProps, DrawerHeaderProps, DrawerHeadingProps, DrawerPlacement, DrawerRootEmits, DrawerRootProps, DrawerRootProps as DrawerProps, DrawerTriggerProps, } from "./drawer.types.js";
+export { DrawerBackdrop, DrawerBody, DrawerClose, DrawerCloseTrigger, DrawerContent, DrawerDialog, DrawerFooter, DrawerHandle, DrawerHeader, DrawerHeading, DrawerRoot as Drawer, DrawerTrigger, };
+export type { DrawerBackdropProps, DrawerBodyProps, DrawerCloseTriggerProps, DrawerContentProps, DrawerDialogProps, DrawerDialogSlotProps, DrawerFooterProps, DrawerHandleProps, DrawerHeaderProps, DrawerHeadingProps, DrawerPlacement, DrawerRootEmits as DrawerEmits, DrawerRootProps as DrawerProps, DrawerTriggerProps, } from "./drawer.types.js";
 export { useDrawerContext, useDrawerOverlayContext } from "./drawer.context.js";
 export type { DrawerContext, DrawerOverlayContext } from "./drawer.context.js";
 export { drawerVariants } from "@ropav/styles";

package/dist/components/drawer/index.js

@@ -12,20 +12,4 @@ import drawer_heading_default from "./drawer-heading.js";
 import drawer_root_default from "./drawer-root.js";
 import drawer_trigger_default from "./drawer-trigger.js";
 import { drawerVariants } from "@ropav/styles";
-//#region src/components/drawer/index.ts
-var Drawer = Object.assign(drawer_root_default, {
-	Backdrop: drawer_backdrop_default,
-	Body: drawer_body_default,
-	Close: drawer_close_default,
-	CloseTrigger: drawer_close_trigger_default,
-	Content: drawer_content_default,
-	Dialog: drawer_dialog_default,
-	Footer: drawer_footer_default,
-	Handle: drawer_handle_default,
-	Header: drawer_header_default,
-	Heading: drawer_heading_default,
-	Root: drawer_root_default,
-	Trigger: drawer_trigger_default
-});
-//#endregion
-export { Drawer, drawer_backdrop_default as DrawerBackdrop, drawer_body_default as DrawerBody, drawer_close_default as DrawerClose, drawer_close_trigger_default as DrawerCloseTrigger, drawer_content_default as DrawerContent, drawer_dialog_default as DrawerDialog, drawer_footer_default as DrawerFooter, drawer_handle_default as DrawerHandle, drawer_header_default as DrawerHeader, drawer_heading_default as DrawerHeading, drawer_root_default as DrawerRoot, drawer_trigger_default as DrawerTrigger, drawerVariants, useDrawerContext, useDrawerOverlayContext };
+export { drawer_root_default as Drawer, drawer_backdrop_default as DrawerBackdrop, drawer_body_default as DrawerBody, drawer_close_default as DrawerClose, drawer_close_trigger_default as DrawerCloseTrigger, drawer_content_default as DrawerContent, drawer_dialog_default as DrawerDialog, drawer_footer_default as DrawerFooter, drawer_handle_default as DrawerHandle, drawer_header_default as DrawerHeader, drawer_heading_default as DrawerHeading, drawer_trigger_default as DrawerTrigger, drawerVariants, useDrawerContext, useDrawerOverlayContext };

package/dist/components/drop-zone/drop-zone-root.d.ts

@@ -0,0 +1,23 @@
+import type { DropZoneRootProps, DropZoneSlotProps } from "./drop-zone.types.js";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<DropZoneRootProps & {
+        onSelect?: ((files: File[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: DropZoneSlotProps) => unknown;
+    };
+    emit: (evt: "select", files: File[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/drop-zone/drop-zone-root.js

@@ -0,0 +1,153 @@
+import { dataAttr } from "../../utils/assertion.js";
+import { useFocusWithin, useInteractionStates } from "../../composables/use-interaction-states.js";
+import { visuallyHiddenStyle } from "../../utils/visually-hidden.js";
+import { isVirtualDragging } from "../../composables/drag-manager.js";
+import { useDrop } from "../../composables/use-drop.js";
+import { isDirectoryDropItem, isFileDropItem } from "../../utils/dnd-types.js";
+import { isDragRefused, isFileAccepted, parseAccept } from "./drop-zone.accept.js";
+import { provideDropZoneContext } from "./drop-zone.context.js";
+import { child, computed, createSlot, createTemplateRefSetter, defineVaporComponent, on, renderEffect, setAttr, setClass, setInsertionState, setProp, setStyle, setTemplateRefBinding, shallowRef, template, unref } from "vue";
+import { dropZoneVariants } from "@ropav/styles";
+//#region src/components/drop-zone/drop-zone-root.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=drop-zone><span><input type=file></span>", 1);
+var drop_zone_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "drop-zone-root",
+	props: {
+		class: {},
+		accept: {},
+		multiple: { type: Boolean },
+		isDisabled: { type: Boolean },
+		ariaLabel: {},
+		ariaLabelledby: {},
+		ariaDescribedby: {}
+	},
+	emits: ["select"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootEl = shallowRef(null);
+		const inputEl = shallowRef(null);
+		const setRootEl = (element) => {
+			rootEl.value = element instanceof HTMLElement ? element : null;
+		};
+		const setInputEl = (element) => {
+			inputEl.value = element instanceof HTMLInputElement ? element : null;
+		};
+		const acceptTokens = computed(() => parseAccept(props.accept));
+		/** Refused drags are still entered, so the zone can say no rather than ignore the pointer. */
+		const isRefusing = shallowRef(false);
+		const interaction = useInteractionStates({ isDisabled: () => props.isDisabled });
+		const focusWithin = useFocusWithin({ isDisabled: () => props.isDisabled });
+		/**
+		* Flattens a drop into plain files, walking any directory that came with it.
+		*
+		* `for await` covers both the array a drop arrives as and the async iterable a directory hands
+		* back, so one function serves both levels.
+		*/
+		const collectFiles = async (items) => {
+			const files = [];
+			for await (const item of items) if (isFileDropItem(item)) files.push(await item.getFile());
+			else if (isDirectoryDropItem(item)) files.push(...await collectFiles(item.getEntries()));
+			return files;
+		};
+		/**
+		* What the zone hands on, out of what arrived.
+		*
+		* Filtering rather than reporting: the browser already filters the picker half silently from
+		* the same `accept`, and enforces `multiple` there on its own, so the drop half matches that
+		* instead of inventing an error channel this component has no way to show.
+		*/
+		const takeable = (files) => {
+			const accepted = files.filter((file) => isFileAccepted(file, acceptTokens.value));
+			return props.multiple ? accepted : accepted.slice(0, 1);
+		};
+		const announce = (files) => {
+			if (files.length > 0) emit("select", files);
+		};
+		const drop = useDrop({
+			getDropOperation: (types) => {
+				isRefusing.value = isDragRefused(types, acceptTokens.value);
+				return "copy";
+			},
+			hasDropButton: true,
+			isDisabled: () => props.isDisabled,
+			onDrop: (event) => {
+				if (isRefusing.value) return;
+				collectFiles(event.items).then((files) => announce(takeable(files)));
+			},
+			onDropExit: () => {
+				isRefusing.value = false;
+			},
+			ref: rootEl
+		});
+		const status = computed(() => {
+			if (!drop.isDropTarget.value) return "idle";
+			return isRefusing.value ? "reject" : "accept";
+		});
+		const open = () => {
+			if (props.isDisabled) return;
+			inputEl.value?.click();
+		};
+		const onClick = (event) => {
+			if (event.target === inputEl.value) return;
+			if (isVirtualDragging()) return;
+			open();
+		};
+		const onInputChange = (event) => {
+			const input = event.target;
+			announce(takeable(Array.from(input.files ?? [])));
+			input.value = "";
+		};
+		/** The drag instructions, plus whatever help text the caller wired up. */
+		const describedBy = computed(() => {
+			const ids = [drop.dropButtonAttrs.value["aria-describedby"], props.ariaDescribedby].filter(Boolean);
+			return ids.length > 0 ? ids.join(" ") : void 0;
+		});
+		const styles = computed(() => dropZoneVariants());
+		provideDropZoneContext({ slots: styles });
+		const _setTemplateRef = createTemplateRefSetter();
+		const n3 = t0();
+		const n1 = child(n3);
+		const n0 = child(n1);
+		on(n0, "change", onInputChange);
+		renderEffect(() => {
+			const _props = props;
+			const _dataAttr = unref(dataAttr);
+			setClass(n3, styles.value.base({ class: _props.class }));
+			setAttr(n3, "data-disabled", _dataAttr(_props.isDisabled));
+			setAttr(n3, "data-drop-target", _dataAttr(unref(drop).isDropTarget.value));
+			setAttr(n3, "data-focus-visible", _dataAttr(unref(focusWithin).isFocusVisible.value));
+			setAttr(n3, "data-hovered", _dataAttr(unref(interaction).isHovered.value));
+			setAttr(n3, "data-status", status.value);
+			setStyle(n1, unref(visuallyHiddenStyle));
+			setProp(n0, "accept", _props.accept);
+			setAttr(n0, "aria-describedby", describedBy.value);
+			setAttr(n0, "aria-label", _props.ariaLabel);
+			setAttr(n0, "aria-labelledby", _props.ariaLabelledby);
+			setProp(n0, "disabled", _props.isDisabled || void 0);
+			setProp(n0, "multiple", _props.multiple || void 0);
+			_setTemplateRef(n0, setInputEl);
+		});
+		setInsertionState(n3, 1);
+		createSlot("default", {
+			isDisabled: () => Boolean(props.isDisabled),
+			isDropTarget: () => unref(drop).isDropTarget.value,
+			open: () => open,
+			status: () => status.value
+		});
+		on(n3, "click", onClick);
+		on(n3, "dragenter", (e) => unref(drop).handlers.onDragenter(e));
+		on(n3, "dragleave", (e) => unref(drop).handlers.onDragleave(e));
+		on(n3, "dragover", (e) => unref(drop).handlers.onDragover(e));
+		on(n3, "drop", (e) => unref(drop).handlers.onDrop(e));
+		on(n3, "focusin", (e) => unref(focusWithin).onFocusin(e));
+		on(n3, "focusout", (e) => unref(focusWithin).onFocusout(e));
+		on(n3, "pointerenter", (e) => unref(interaction).onPointerenter(e));
+		on(n3, "pointerleave", (e) => unref(interaction).onPointerleave(e));
+		setProp(n3, "tabindex", -1);
+		setTemplateRefBinding(n3, () => setRootEl);
+		return n3;
+	}
+});
+//#endregion
+export { drop_zone_root_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/drop-zone/drop-zone-trigger.d.ts

@@ -0,0 +1,21 @@
+import type { DropZoneTriggerProps } from "./drop-zone.types.js";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<DropZoneTriggerProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/drop-zone/drop-zone-trigger.js

@@ -0,0 +1,20 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useDropZoneContext } from "./drop-zone.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/drop-zone/drop-zone-trigger.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span data-slot=drop-zone-trigger>", 1);
+var drop_zone_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "drop-zone-trigger",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots } = useDropZoneContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).trigger, props.class)));
+		setInsertionState(n1);
+		createSlot();
+		return n1;
+	}
+});
+//#endregion
+export { drop_zone_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/drop-zone/drop-zone.accept.d.ts

@@ -0,0 +1,19 @@
+import type { DragTypes } from "../../utils/dnd-types.js";
+/** The tokens of an `accept` list, lowercased, with the empties dropped. */
+export declare const parseAccept: (accept: string | undefined) => string[];
+/** Whether one file satisfies an `accept` list. An empty list accepts everything. */
+export declare const isFileAccepted: (file: File, tokens: string[]) => boolean;
+/**
+ * Whether a drag still in flight should be refused.
+ *
+ * A drag advertises mime types and nothing else — never a file name, and never how many files
+ * it carries. So the answer is only ever "certainly not takeable"; everything unprovable is
+ * left to the drop, which filters what it emits. Three cases are unprovable:
+ *
+ * - an `.ext` token, which needs a file name;
+ * - {@link GENERIC_TYPE}, which is what a file with no known mime type reports — and also what
+ *   a directory reports, since the two are indistinguishable until the drop;
+ * - a transfer whose types are hidden, which `DragTypes` already answers `true` to for
+ *   everything (Safari reports no items at all while dragging files).
+ */
+export declare const isDragRefused: (types: DragTypes, tokens: string[]) => boolean;

package/dist/components/drop-zone/drop-zone.accept.js

@@ -0,0 +1,28 @@
+import "../../utils/dnd-constants.js";
+//#region src/components/drop-zone/drop-zone.accept.ts
+/** The tokens of an `accept` list, lowercased, with the empties dropped. */
+var parseAccept = (accept) => accept?.split(",").map((token) => token.trim().toLowerCase()).filter(Boolean) ?? [];
+var matchesMimeToken = (type, token) => token.endsWith("/*") ? type.startsWith(token.slice(0, -1)) : type === token;
+/** Whether one file satisfies an `accept` list. An empty list accepts everything. */
+var isFileAccepted = (file, tokens) => tokens.length === 0 || tokens.some((token) => token.startsWith(".") ? file.name.toLowerCase().endsWith(token) : matchesMimeToken(file.type.toLowerCase(), token));
+/**
+* Whether a drag still in flight should be refused.
+*
+* A drag advertises mime types and nothing else — never a file name, and never how many files
+* it carries. So the answer is only ever "certainly not takeable"; everything unprovable is
+* left to the drop, which filters what it emits. Three cases are unprovable:
+*
+* - an `.ext` token, which needs a file name;
+* - {@link GENERIC_TYPE}, which is what a file with no known mime type reports — and also what
+*   a directory reports, since the two are indistinguishable until the drop;
+* - a transfer whose types are hidden, which `DragTypes` already answers `true` to for
+*   everything (Safari reports no items at all while dragging files).
+*/
+var isDragRefused = (types, tokens) => {
+	if (tokens.length === 0) return false;
+	if (tokens.some((token) => token.startsWith("."))) return false;
+	if (types.has("application/octet-stream")) return false;
+	return !tokens.some((token) => types.has(token));
+};
+//#endregion
+export { isDragRefused, isFileAccepted, parseAccept };

package/dist/components/drop-zone/drop-zone.context.d.ts

@@ -0,0 +1,6 @@
+import type { dropZoneVariants } from "@ropav/styles";
+import type { ComputedRef } from "vue";
+export interface DropZoneContext {
+    slots: ComputedRef<ReturnType<typeof dropZoneVariants>>;
+}
+export declare const useDropZoneContext: () => DropZoneContext, provideDropZoneContext: (value: DropZoneContext) => DropZoneContext;

package/dist/components/drop-zone/drop-zone.context.js

@@ -0,0 +1,5 @@
+import { createContext } from "../../utils/create-context.js";
+//#region src/components/drop-zone/drop-zone.context.ts
+var [useDropZoneContext, provideDropZoneContext] = createContext({ name: "DropZoneContext" });
+//#endregion
+export { provideDropZoneContext, useDropZoneContext };

package/dist/components/drop-zone/drop-zone.types.d.ts

@@ -0,0 +1,30 @@
+/** What the zone makes of the drag currently over it. */
+export type DropZoneStatus = "accept" | "idle" | "reject";
+export interface DropZoneRootProps {
+    class?: string;
+    /**
+     * Which files to take, spelled the way the native `accept` attribute spells it: a comma
+     * separated list of mime types, `type/*` wildcards and `.ext` suffixes.
+     *
+     * It filters the picker, judges a drag while it is still moving, and filters what a drop
+     * emits. A drag is only refused where the refusal is certain — see `drop-zone-root.vue`.
+     */
+    accept?: string;
+    /** Whether more than one file may arrive at once. */
+    multiple?: boolean;
+    isDisabled?: boolean;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+}
+export interface DropZoneSlotProps {
+    status: DropZoneStatus;
+    /** Whether a drag the zone would take is over it. */
+    isDropTarget: boolean;
+    isDisabled: boolean;
+    /** Opens the file picker, as clicking the zone does. */
+    open: () => void;
+}
+export interface DropZoneTriggerProps {
+    class?: string;
+}

package/dist/components/drop-zone/index.d.ts

@@ -0,0 +1,8 @@
+import DropZoneRoot from "./drop-zone-root.js";
+import DropZoneTrigger from "./drop-zone-trigger.js";
+export { DropZoneRoot as DropZone, DropZoneTrigger };
+export type { DropZoneRootProps as DropZoneProps, DropZoneSlotProps, DropZoneStatus, DropZoneTriggerProps, } from "./drop-zone.types.js";
+export { useDropZoneContext, provideDropZoneContext } from "./drop-zone.context.js";
+export type { DropZoneContext } from "./drop-zone.context.js";
+export { dropZoneVariants } from "@ropav/styles";
+export type { DropZoneVariants } from "@ropav/styles";

package/dist/components/drop-zone/index.js

@@ -0,0 +1,5 @@
+import { provideDropZoneContext, useDropZoneContext } from "./drop-zone.context.js";
+import drop_zone_root_default from "./drop-zone-root.js";
+import drop_zone_trigger_default from "./drop-zone-trigger.js";
+import { dropZoneVariants } from "@ropav/styles";
+export { drop_zone_root_default as DropZone, drop_zone_trigger_default as DropZoneTrigger, dropZoneVariants, provideDropZoneContext, useDropZoneContext };

package/dist/components/dropdown/dropdown-popover.js

@@ -47,8 +47,8 @@ var dropdown_popover_vue_vue_type_script_setup_true_vapor_true_lang_default = /*
 			"should-flip": () => props.shouldFlip,
 			"slot-contexts": () => unref(contexts)
 		}, extend(() => {
-			return createSlot("default", null, null, 36);
-		}, { _: 8 }), true);
+			return createSlot("default", null, null, 4);
+		}, { _: 1 }), true);
 	}
 });
 //#endregion