ropav 0.4.0 → 0.6.0

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,86 @@
+import DropZoneRoot from "./drop-zone-root.js";
+import DropZoneTrigger from "./drop-zone-trigger.js";
+export declare const DropZone: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        default?: (props: import("./drop-zone.types.js").DropZoneSlotProps) => unknown;
+    };
+    emit: (evt: "select", files: File[]) => void;
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        class?: string;
+        accept?: string;
+        multiple?: boolean;
+        isDisabled?: boolean;
+        ariaLabel?: string;
+        ariaLabelledby?: string;
+        ariaDescribedby?: string;
+        onSelect?: ((files: File[]) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: import("./drop-zone.types.js").DropZoneSlotProps) => unknown;
+    };
+    emit: (evt: "select", files: File[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+}) & {
+    Root: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
+        attrs: any;
+        slots: {
+            default?: (props: import("./drop-zone.types.js").DropZoneSlotProps) => unknown;
+        };
+        emit: (evt: "select", files: File[]) => void;
+    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+        props: import('vue').PublicProps & {
+            class?: string;
+            accept?: string;
+            multiple?: boolean;
+            isDisabled?: boolean;
+            ariaLabel?: string;
+            ariaLabelledby?: string;
+            ariaDescribedby?: string;
+            onSelect?: ((files: File[]) => any) | undefined;
+        } & (typeof globalThis extends {
+            __VLS_PROPS_FALLBACK: infer P;
+        } ? P : {});
+        expose: (exposed: {}) => void;
+        attrs: any;
+        slots: {
+            default?: (props: import("./drop-zone.types.js").DropZoneSlotProps) => unknown;
+        };
+        emit: (evt: "select", files: File[]) => 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;
+        } & (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 { DropZoneRoot, DropZoneTrigger };
+export type { DropZoneRootProps, 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,11 @@
+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";
+//#region src/components/drop-zone/index.ts
+var DropZone = Object.assign(drop_zone_root_default, {
+	Root: drop_zone_root_default,
+	Trigger: drop_zone_trigger_default
+});
+//#endregion
+export { DropZone, drop_zone_root_default as DropZoneRoot, drop_zone_trigger_default as DropZoneTrigger, dropZoneVariants, provideDropZoneContext, useDropZoneContext };

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

@@ -9,6 +9,7 @@ var dropdown_menu_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 	__name: "dropdown-menu",
 	props: {
 		class: {},
+		size: {},
 		selectionMode: {},
 		selectionBehavior: {},
 		selectedKeys: {},

package/dist/components/dropdown/dropdown-submenu-trigger.js

@@ -3,7 +3,7 @@ import { useSubmenuTriggerState } from "../../composables/use-overlay-trigger-st
 import { provideMenuItemPopupContext } from "../menu-item/menu-item.context.js";
 import { useMenuContext } from "../menu/menu.context.js";
 import { provideDropdownPopoverTarget, useDropdownContext } from "./dropdown.context.js";
-import { useSafelyMouseToSubmenu } from "../../composables/use-safely-mouse-to-submenu.js";
+import { useSafelyMouseToSubmenu } from "./use-safely-mouse-to-submenu.js";
 import { computed, createSlot, defineVaporComponent, onScopeDispose, shallowRef, watch } from "vue";
 var dropdown_submenu_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
 	__name: "dropdown-submenu-trigger",

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

@@ -16,7 +16,7 @@ export declare const Dropdown: ((__VLS_props: NonNullable<Awaited<typeof __VLS_s
     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 & {
-        trigger?: import("../../composables/use-menu-trigger.js").MenuTriggerType;
+        trigger?: import("./index.js").MenuTriggerType;
         isOpen?: boolean;
         defaultOpen?: boolean;
         isDisabled?: boolean;
@@ -91,6 +91,7 @@ export declare const Dropdown: ((__VLS_props: NonNullable<Awaited<typeof __VLS_s
     }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
         props: import('vue').PublicProps & {
             class?: string;
+            size?: import("@ropav/styles").MenuVariants["size"];
             selectionMode?: import("../../index.js").SelectionMode;
             selectionBehavior?: import("../../index.js").SelectionBehavior;
             selectedKeys?: "all" | Iterable<import("../../index.js").CollectionKey>;
@@ -151,7 +152,7 @@ export declare const Dropdown: ((__VLS_props: NonNullable<Awaited<typeof __VLS_s
         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 & {
-            trigger?: import("../../composables/use-menu-trigger.js").MenuTriggerType;
+            trigger?: import("./index.js").MenuTriggerType;
             isOpen?: boolean;
             defaultOpen?: boolean;
             isDisabled?: boolean;
@@ -269,5 +270,6 @@ export { DropdownMenu, DropdownPopover, DropdownRoot, DropdownSubmenuTrigger, Dr
 export type { DropdownMenuProps, DropdownPopoverProps, DropdownRootEmits, DropdownRootProps, DropdownRootProps as DropdownProps, DropdownTriggerProps, } from "./dropdown.types.js";
 export { useDropdownContext, useDropdownPopoverTarget } from "./dropdown.context.js";
 export type { DropdownContext, DropdownPopoverTarget } from "./dropdown.context.js";
+export type { MenuTriggerType } from "../../composables/use-menu-trigger.js";
 export { dropdownVariants } from "@ropav/styles";
 export type { DropdownVariants } from "@ropav/styles";

package/dist/{composables → components/dropdown}/use-safely-mouse-to-submenu.js

@@ -1,5 +1,5 @@
 import { onScopeDispose, toValue, watch } from "vue";
-//#region src/composables/use-safely-mouse-to-submenu.ts
+//#region src/components/dropdown/use-safely-mouse-to-submenu.ts
 /** How many consecutive moves away from the submenu it takes to give up on the journey. */
 var ALLOWED_INVALID_MOVEMENTS = 2;
 /** Pointer moves arrive far faster than the geometry changes. */

package/dist/components/icons/icon-overlay-arrow.js

@@ -1,6 +1,6 @@
 import { defineVaporComponent, renderEffect, setClass, template } from "vue";
 //#region src/components/icons/icon-overlay-arrow.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<svg fill=none height=12 viewBox=\"0 0 12 12\" width=12 xmlns=http://www.w3.org/2000/svg><path d=\"M0 0C5.48483 8 6.5 8 12 0Z\">", 1, 1);
+var t0 = template("<svg fill=none height=12 viewBox=\"0 0 12 12\" width=12 xmlns=http://www.w3.org/2000/svg><path d=\"M1 0V2C3.2 2 4.3 8 6 8C7.7 8 8.8 2 11 2V0Z\">", 1, 1);
 var icon_overlay_arrow_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
 	__name: "icon-overlay-arrow",
 	props: { class: {} },

package/dist/components/index.d.ts

@@ -30,6 +30,7 @@ export * from "./disclosure/index.js";
 export * from "./disclosure-group/index.js";
 export * from "./dnd/index.js";
 export * from "./drawer/index.js";
+export * from "./drop-zone/index.js";
 export * from "./dropdown/index.js";
 export * from "./empty-state/index.js";
 export * from "./error-message/index.js";
@@ -61,13 +62,17 @@ export * from "./progress-circle/index.js";
 export * from "./radio/index.js";
 export * from "./radio-group/index.js";
 export * from "./range-calendar/index.js";
+export * from "./router-provider/index.js";
 export * from "./scroll-shadow/index.js";
 export * from "./search-field/index.js";
+export * from "./segmented-control/index.js";
 export * from "./select/index.js";
 export * from "./separator/index.js";
+export * from "./sidebar/index.js";
 export * from "./skeleton/index.js";
 export * from "./slider/index.js";
 export * from "./spinner/index.js";
+export * from "./splitter/index.js";
 export * from "./surface/index.js";
 export * from "./switch/index.js";
 export * from "./switch-group/index.js";

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

@@ -8,6 +8,7 @@ export declare const Input: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
         class?: string;
         value?: string;
         variant?: import("@ropav/styles").InputVariants["variant"];
+        size?: import("@ropav/styles").InputVariants["size"];
         fullWidth?: boolean;
         placeholder?: string;
         onChange?: ((value: string) => any) | undefined;
@@ -31,6 +32,7 @@ export declare const Input: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
             class?: string;
             value?: string;
             variant?: import("@ropav/styles").InputVariants["variant"];
+            size?: import("@ropav/styles").InputVariants["size"];
             fullWidth?: boolean;
             placeholder?: string;
             onChange?: ((value: string) => any) | undefined;

package/dist/components/input/input-root.js

@@ -13,6 +13,7 @@ var input_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PUR
 		class: {},
 		value: {},
 		variant: { default: void 0 },
+		size: {},
 		fullWidth: {
 			type: Boolean,
 			default: void 0
@@ -31,9 +32,11 @@ var input_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PUR
 			control?.registerElement(element.value);
 		};
 		const resolvedVariant = computed(() => props.variant ?? textField?.variant.value);
+		const resolvedSize = computed(() => props.size ?? textField?.size.value);
 		const styles = computed(() => inputVariants({
 			class: props.class,
 			fullWidth: props.fullWidth,
+			size: resolvedSize.value,
 			variant: resolvedVariant.value
 		}));
 		const attrs = computed(() => {

package/dist/components/input/input.types.d.ts

@@ -9,6 +9,11 @@ export interface InputRootProps {
     value?: string;
     /** Visual variant. Taken from the surrounding field when unset. @default "primary" */
     variant?: InputVariants["variant"];
+    /**
+     * How tall the control stands, matching a button of the same size. Taken from the surrounding
+     * field when unset. @default "md"
+     */
+    size?: InputVariants["size"];
     /** Whether the control stretches to fill its container. */
     fullWidth?: boolean;
     /**

package/dist/components/input-group/index.d.ts

@@ -13,6 +13,7 @@ export declare const InputGroup: ((__VLS_props: NonNullable<Awaited<typeof __VLS
     props: import('vue').PublicProps & {
         class?: string;
         variant?: import("@ropav/styles").InputGroupVariants["variant"];
+        size?: import("@ropav/styles").InputGroupVariants["size"];
         fullWidth?: boolean;
         isDisabled?: boolean;
         isInvalid?: boolean;
@@ -81,6 +82,7 @@ export declare const InputGroup: ((__VLS_props: NonNullable<Awaited<typeof __VLS
         props: import('vue').PublicProps & {
             class?: string;
             variant?: import("@ropav/styles").InputGroupVariants["variant"];
+            size?: import("@ropav/styles").InputGroupVariants["size"];
             fullWidth?: boolean;
             isDisabled?: boolean;
             isInvalid?: boolean;

package/dist/components/input-group/input-group-root.js

@@ -12,6 +12,7 @@ var input_group_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*
 	props: {
 		class: {},
 		variant: { default: void 0 },
+		size: { default: void 0 },
 		fullWidth: {
 			type: Boolean,
 			default: void 0
@@ -38,10 +39,12 @@ var input_group_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*
 			element.value = next instanceof HTMLDivElement ? next : null;
 		};
 		const resolvedVariant = computed(() => props.variant ?? textField?.variant.value);
+		const resolvedSize = computed(() => props.size ?? textField?.size.value);
 		const resolvedIsDisabled = computed(() => props.isDisabled ?? control?.isDisabled.value ?? false);
 		const resolvedIsInvalid = computed(() => props.isInvalid ?? control?.isInvalid.value ?? false);
 		const slots = computed(() => inputGroupVariants({
 			fullWidth: props.fullWidth,
+			size: resolvedSize.value,
 			variant: resolvedVariant.value
 		}));
 		provideInputGroupContext({ slots });

package/dist/components/input-group/input-group.types.d.ts

@@ -3,6 +3,11 @@ export interface InputGroupRootProps {
     class?: string;
     /** Visual variant. Taken from the surrounding field when unset. @default "primary" */
     variant?: InputGroupVariants["variant"];
+    /**
+     * How tall the group stands, matching a button of the same size. Taken from the surrounding
+     * field when unset. @default "md"
+     */
+    size?: InputGroupVariants["size"];
     /** Whether the group stretches to fill its container. */
     fullWidth?: boolean;
     /**

package/dist/components/input-otp/index.d.ts

@@ -18,14 +18,14 @@ export declare const InputOTP: ((__VLS_props: NonNullable<Awaited<typeof __VLS_s
         defaultValue?: string;
         pattern?: RegExp | string;
         placeholder?: string;
-        textAlign?: import("../../index.js").InputOTPTextAlign;
+        textAlign?: import("./index.js").InputOTPTextAlign;
         inputMode?: string;
         autoComplete?: string;
         isDisabled?: boolean;
         isInvalid?: boolean;
         validationErrors?: string[];
         validationDetails?: import("../../index.js").ValidationDetails;
-        pushPasswordManagerStrategy?: import("../../index.js").PushPasswordManagerStrategy;
+        pushPasswordManagerStrategy?: import("./index.js").PushPasswordManagerStrategy;
         pasteTransformer?: (pasted: string) => string;
         name?: string;
         form?: string;
@@ -85,14 +85,14 @@ export declare const InputOTP: ((__VLS_props: NonNullable<Awaited<typeof __VLS_s
             defaultValue?: string;
             pattern?: RegExp | string;
             placeholder?: string;
-            textAlign?: import("../../index.js").InputOTPTextAlign;
+            textAlign?: import("./index.js").InputOTPTextAlign;
             inputMode?: string;
             autoComplete?: string;
             isDisabled?: boolean;
             isInvalid?: boolean;
             validationErrors?: string[];
             validationDetails?: import("../../index.js").ValidationDetails;
-            pushPasswordManagerStrategy?: import("../../index.js").PushPasswordManagerStrategy;
+            pushPasswordManagerStrategy?: import("./index.js").PushPasswordManagerStrategy;
             pasteTransformer?: (pasted: string) => string;
             name?: string;
             form?: string;
@@ -156,5 +156,7 @@ export type { InputOTPRootProps, InputOTPRootProps as InputOTPProps, InputOTPGro
 export { REGEXP_ONLY_CHARS, REGEXP_ONLY_DIGITS, REGEXP_ONLY_DIGITS_AND_CHARS, } from "../../composables/use-input-otp.js";
 export { provideInputOTPContext, useInputOTPContext } from "./input-otp.context.js";
 export type { InputOTPContext } from "./input-otp.context.js";
+export type { InputOTPTextAlign } from "../../composables/use-input-otp.js";
+export type { PushPasswordManagerStrategy } from "../../composables/use-password-manager-badge.js";
 export { inputOTPVariants } from "@ropav/styles";
 export type { InputOTPVariants } from "@ropav/styles";

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

@@ -18,6 +18,7 @@ export declare const Link: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setup
         hrefLang?: string;
         isDisabled?: boolean;
         ariaCurrent?: import("./link.types.js").LinkCurrent;
+        routerOptions?: unknown;
         ariaLabel?: string;
         ariaLabelledby?: string;
         ariaDescribedby?: string;
@@ -73,6 +74,7 @@ export declare const Link: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             hrefLang?: string;
             isDisabled?: boolean;
             ariaCurrent?: import("./link.types.js").LinkCurrent;
+            routerOptions?: unknown;
             ariaLabel?: string;
             ariaLabelledby?: string;
             ariaDescribedby?: string;