ropav 0.4.0 → 0.5.0

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

@@ -1,21 +1,73 @@
 import { useOverlayArrowContext } from "./overlay.context.js";
-import { computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, setStyle, setTemplateRefBinding, template } from "vue";
+import { child, computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, setStyle, setTemplateRefBinding, shallowRef, template, watch } from "vue";
 //#region src/components/overlay/overlay-arrow.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<div>", 1);
+var t0 = template("<div><!><svg aria-hidden=true focusable=false height=0 style=\"position: absolute\" width=0><filter id=ropav-overlay-edge color-interpolation-filters=sRGB height=200% width=200% x=-50% y=-50%><feFlood result=line style=\"flood-color: var(--overlay-edge-line, transparent)\"></feFlood><feComposite in=line in2=SourceAlpha operator=out result=outside></feComposite><feGaussianBlur in=outside result=soft stdDeviation=0.5></feGaussianBlur><feComposite in=soft in2=SourceAlpha operator=in result=glow></feComposite><feMerge><feMergeNode in=SourceGraphic></feMergeNode><feMergeNode in=glow>", 1);
+var SKIRT = 2;
+/** Half the mouth's width: the shape's mouth spans the middle 10 of its 12 unit box. */
+var HALF_MOUTH = 5;
+/**
+* How much deeper than the skirt the arrow sits, where the overlay's edge is curved.
+*
+* The mouth is straight, and it normally lies exactly on the overlay's edge, whose flat run its
+* ends meet tangentially. Near a corner the edge has curved away from that line — entirely, when
+* a large radius has clamped a short overlay toward a pill — and the mouth's ends would hang past
+* the curve as two bare horns. The recession under each end follows from the radius the overlay
+* actually renders, and the whole arrow is pulled in that far, plus a little for antialiasing.
+*/
 var overlay_arrow_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
 	__name: "overlay-arrow",
 	props: { class: {} },
 	setup(__props) {
 		const props = __props;
 		const arrow = useOverlayArrowContext();
+		const element = shallowRef(null);
 		const setElement = (next) => {
-			arrow?.registerElement(next ?? null);
+			element.value = next ?? null;
+			arrow?.registerElement(element.value);
 		};
 		const placement = computed(() => arrow?.placement.value ?? null);
+		/** The straight run the shape carries above its mouth, buried inside the overlay. */
+		const burial = shallowRef(0);
+		const measureBurial = () => {
+			const own = element.value;
+			const side = placement.value;
+			const isHorizontal = side === "top" || side === "bottom";
+			const centre = Number.parseFloat(arrow?.style.value[isHorizontal ? "left" : "top"] ?? "");
+			const overlay = own?.offsetParent;
+			if (!own || !side || !Number.isFinite(centre) || !(overlay instanceof HTMLElement)) return 0;
+			const width = overlay.offsetWidth;
+			const height = overlay.offsetHeight;
+			const edge = isHorizontal ? width : height;
+			const declared = getComputedStyle(overlay).borderTopLeftRadius;
+			const radius = Math.min(declared.includes("%") ? Math.min(width, height) : Number.parseFloat(declared) || 0, width / 2, height / 2);
+			if (radius <= 0) return 0;
+			const recessionAt = (position) => {
+				const intoCorner = Math.max(radius - position, position - (edge - radius), 0);
+				if (intoCorner <= 0) return 0;
+				const reach = Math.min(intoCorner, radius);
+				return radius - Math.sqrt(radius * radius - reach * reach);
+			};
+			const deepest = Math.max(recessionAt(centre - HALF_MOUTH), recessionAt(centre + HALF_MOUTH));
+			return deepest > 0 ? Math.min(deepest + .5, 4) : 0;
+		};
+		watch([
+			element,
+			placement,
+			() => arrow?.style.value
+		], () => {
+			burial.value = measureBurial();
+		}, {
+			flush: "post",
+			immediate: true
+		});
 		/**
 		* Pinned to the edge the overlay is placed against, and centred on the offset the positioner
 		* worked out.
 		*
+		* Pulled back into the overlay by the skirt, so the shape overlaps the body it grows out of
+		* rather than touching it: shapes that merely touch each antialias the shared row at fractional
+		* device pixel ratios, and the page bleeds through the seam.
+		*
 		* The offset names the arrow's centre, so it is pulled back by half its own size on the cross
 		* axis — done with a transform rather than arithmetic because only the stylesheet knows how big
 		* the arrow is.
@@ -25,20 +77,21 @@ var overlay_arrow_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 			return {
 				position: "absolute",
 				transform: side === "top" || side === "bottom" ? "translateX(-50%)" : "translateY(-50%)",
-				...side ? { [side]: "100%" } : {},
+				...side ? { [side]: `calc(100% - ${SKIRT + burial.value}px)` } : {},
 				...arrow?.style.value ?? {}
 			};
 		});
-		const n1 = t0();
+		const n2 = t0();
+		const n1 = child(n2);
 		renderEffect(() => {
-			setClass(n1, props.class);
-			setAttr(n1, "data-placement", placement.value ?? void 0);
-			setStyle(n1, style.value);
+			setClass(n2, props.class);
+			setAttr(n2, "data-placement", placement.value ?? void 0);
+			setStyle(n2, style.value);
 		});
-		setInsertionState(n1);
+		setInsertionState(n2, n1);
 		createSlot();
-		setTemplateRefBinding(n1, () => setElement);
-		return n1;
+		setTemplateRefBinding(n2, () => setElement);
+		return n2;
 	}
 });
 //#endregion

package/dist/components/radio/radio-content.js

@@ -21,7 +21,7 @@ var radio_content_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 		const setInputEl = (element) => {
 			inputEl.value = element instanceof HTMLInputElement ? element : null;
 		};
-		useFormReset(inputEl, state.defaultSelectedValue, state.setSelectedValue);
+		useFormReset(inputEl, state.defaultSelectedValue, state.setSelectedValue, form);
 		watch([inputEl, isSelected], ([input, selected]) => setFormChecked(input, selected), {
 			flush: "post",
 			immediate: true

package/dist/components/range-calendar/index.d.ts

@@ -13,7 +13,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
     slots: {
         default?: (props: import("./range-calendar.types.js").RangeCalendarRootSlotProps) => unknown;
     };
-    emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("../../index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
+    emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("./index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
 }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & {
         class?: string;
@@ -22,15 +22,15 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         ariaLabelledby?: string;
         ariaDescribedby?: string;
         ariaDetails?: string;
-        value?: import("../../index.js").DateRange | null;
-        defaultValue?: import("../../index.js").DateRange | null;
+        value?: import("./index.js").DateRange | null;
+        defaultValue?: import("./index.js").DateRange | null;
         focusedValue?: import("@internationalized/date").DateValue | null;
         defaultFocusedValue?: import("@internationalized/date").DateValue | null;
         minValue?: import("@internationalized/date").DateValue | null;
         maxValue?: import("@internationalized/date").DateValue | null;
         isDateUnavailable?: (date: import("@internationalized/date").DateValue, anchorDate: import("@internationalized/date").CalendarDate | null) => boolean;
         allowsNonContiguousRanges?: boolean;
-        commitBehavior?: import("../../index.js").RangeCalendarCommitBehavior;
+        commitBehavior?: import("./index.js").RangeCalendarCommitBehavior;
         isDisabled?: boolean;
         isReadOnly?: boolean;
         isInvalid?: boolean;
@@ -43,7 +43,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         isYearPickerOpen?: boolean;
         defaultYearPickerOpen?: boolean;
         "onUpdate:focusedValue"?: ((value: import("@internationalized/date").CalendarDate) => any) | undefined;
-        "onUpdate:value"?: ((value: import("../../index.js").DateRange | null) => any) | undefined;
+        "onUpdate:value"?: ((value: import("./index.js").DateRange | null) => any) | undefined;
         "onUpdate:yearPickerOpen"?: ((isOpen: boolean) => any) | undefined;
     } & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -53,7 +53,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
     slots: {
         default?: (props: import("./range-calendar.types.js").RangeCalendarRootSlotProps) => unknown;
     };
-    emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("../../index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
+    emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("./index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 }) & {
@@ -215,7 +215,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         props: import('vue').PublicProps & {
             class?: string;
             offset?: import("@internationalized/date").DateDuration;
-            format?: import("../../index.js").CalendarHeadingFormatOptions;
+            format?: import("./index.js").CalendarHeadingFormatOptions;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
         } ? P : {});
@@ -253,7 +253,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         slots: {
             default?: (props: import("./range-calendar.types.js").RangeCalendarRootSlotProps) => unknown;
         };
-        emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("../../index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
+        emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("./index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
     }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
         props: import('vue').PublicProps & {
             class?: string;
@@ -262,15 +262,15 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
             ariaLabelledby?: string;
             ariaDescribedby?: string;
             ariaDetails?: string;
-            value?: import("../../index.js").DateRange | null;
-            defaultValue?: import("../../index.js").DateRange | null;
+            value?: import("./index.js").DateRange | null;
+            defaultValue?: import("./index.js").DateRange | null;
             focusedValue?: import("@internationalized/date").DateValue | null;
             defaultFocusedValue?: import("@internationalized/date").DateValue | null;
             minValue?: import("@internationalized/date").DateValue | null;
             maxValue?: import("@internationalized/date").DateValue | null;
             isDateUnavailable?: (date: import("@internationalized/date").DateValue, anchorDate: import("@internationalized/date").CalendarDate | null) => boolean;
             allowsNonContiguousRanges?: boolean;
-            commitBehavior?: import("../../index.js").RangeCalendarCommitBehavior;
+            commitBehavior?: import("./index.js").RangeCalendarCommitBehavior;
             isDisabled?: boolean;
             isReadOnly?: boolean;
             isInvalid?: boolean;
@@ -283,7 +283,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
             isYearPickerOpen?: boolean;
             defaultYearPickerOpen?: boolean;
             "onUpdate:focusedValue"?: ((value: import("@internationalized/date").CalendarDate) => any) | undefined;
-            "onUpdate:value"?: ((value: import("../../index.js").DateRange | null) => any) | undefined;
+            "onUpdate:value"?: ((value: import("./index.js").DateRange | null) => any) | undefined;
             "onUpdate:yearPickerOpen"?: ((isOpen: boolean) => any) | undefined;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
@@ -293,7 +293,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         slots: {
             default?: (props: import("./range-calendar.types.js").RangeCalendarRootSlotProps) => unknown;
         };
-        emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("../../index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
+        emit: ((evt: "update:focusedValue", value: import("@internationalized/date").CalendarDate) => void) & ((evt: "update:value", value: import("./index.js").DateRange | null) => void) & ((evt: "update:yearPickerOpen", isOpen: boolean) => void);
     }>) => import('vue').VNode & {
         __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
     };
@@ -330,7 +330,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         props: import('vue').PublicProps & {
             class?: string;
             visibleYears?: number;
-            format?: import("../../index.js").CalendarYearPickerFormatOptions;
+            format?: import("../index.js").CalendarYearPickerFormatOptions;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
         } ? P : {});
@@ -395,7 +395,7 @@ export declare const RangeCalendar: ((__VLS_props: NonNullable<Awaited<typeof __
         props: import('vue').PublicProps & {
             class?: string;
             offset?: import("@internationalized/date").DateDuration;
-            format?: import("../../index.js").CalendarHeadingFormatOptions;
+            format?: import("./index.js").CalendarHeadingFormatOptions;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
         } ? P : {});
@@ -434,5 +434,8 @@ export { RangeCalendarCell, RangeCalendarCellIndicator, RangeCalendarGrid, Range
 export type { RangeCalendarCellIndicatorProps, RangeCalendarCellProps, RangeCalendarCellSlotProps, RangeCalendarGridBodyProps, RangeCalendarGridBodySlotProps, RangeCalendarGridHeaderProps, RangeCalendarGridHeaderSlotProps, RangeCalendarGridProps, RangeCalendarHeaderCellProps, RangeCalendarHeaderProps, RangeCalendarHeadingProps, RangeCalendarNavButtonProps, RangeCalendarRootProps, RangeCalendarRootProps as RangeCalendarProps, RangeCalendarRootSlotProps, } from "./range-calendar.types.js";
 export { provideRangeCalendarContext, provideRangeCalendarOwnerContext, useRangeCalendarContext, useRangeCalendarOwnerContext, } from "./range-calendar.context.js";
 export type { RangeCalendarContext, RangeCalendarOwnedProps, RangeCalendarOwnerContext, } from "./range-calendar.context.js";
+export type { AnyCalendarState, DateRange } from "../../composables/use-calendar.js";
+export type { CalendarHeadingFormatOptions } from "../../composables/use-calendar-heading.js";
+export type { RangeCalendarCommitBehavior } from "../../composables/use-range-calendar.js";
 export { rangeCalendarVariants } from "@ropav/styles";
 export type { RangeCalendarVariants } from "@ropav/styles";

package/dist/components/router-provider/index.d.ts

@@ -0,0 +1,5 @@
+import RouterProviderRoot from "./router-provider.js";
+export { RouterProviderRoot, RouterProviderRoot as RouterProvider };
+export type { RouterProviderRootProps, RouterProviderRootProps as RouterProviderProps, } from "./router-provider.types.js";
+export { useRouterContext } from "./router-provider.context.js";
+export type { RouterContext } from "./router-provider.context.js";

package/dist/components/router-provider/index.js

@@ -0,0 +1,3 @@
+import { useRouterContext } from "./router-provider.context.js";
+import router_provider_default from "./router-provider.js";
+export { router_provider_default as RouterProvider, router_provider_default as RouterProviderRoot, useRouterContext };

package/dist/components/router-provider/router-provider.context.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The application's router, reduced to the three questions a link has to ask it.
+ *
+ * Ported from React Aria's `packages/react-aria/src/utils/RouterProvider.tsx`
+ * (react-aria 3.51.0), minus its `isNative` branch — this package has no native target.
+ *
+ * `resolveHref` is React's `useHref` renamed: in Vue a `use*` name promises a composable that
+ * may only be called during `setup()`, and this one is a plain function called from a `computed`.
+ */
+export interface RouterContext {
+    /**
+     * Hands a same-origin, unmodified activation to the application's router.
+     *
+     * Receives the href as the link declared it, not as the anchor renders it — `resolveHref` is
+     * for the DOM, and a router wants back the path it was given.
+     */
+    navigate: (href: string, options?: unknown) => void;
+    /**
+     * Whether this href addresses the route showing now.
+     *
+     * The matching rule lives entirely here, in the application's own predicate: exact against
+     * prefix, trailing slashes and query handling all differ per route and per link, and a library
+     * that guessed would be wrong for half of them.
+     */
+    isCurrent: (href: string) => boolean;
+    /**
+     * Turns an app-relative href into the URL the anchor should carry, for a router mounted under
+     * a base path or running in hash mode. The rendered href is what a middle-click opens and what
+     * "copy link address" yields, so it has to be the real one.
+     */
+    resolveHref: (href: string) => string;
+}
+/**
+ * The router an ancestor has supplied, or `null` when nobody has and the browser's own navigation
+ * is what should happen.
+ *
+ * Loose, because most of the tree runs without a router — a documentation page, a test, an app
+ * that never routes — and following the href is the right answer there, not an error.
+ */
+export declare const useRouterContext: () => RouterContext | null, provideRouterContext: (value: RouterContext | null) => RouterContext | null;

package/dist/components/router-provider/router-provider.context.js

@@ -0,0 +1,16 @@
+import { createContext } from "../../utils/create-context.js";
+//#region src/components/router-provider/router-provider.context.ts
+/**
+* The router an ancestor has supplied, or `null` when nobody has and the browser's own navigation
+* is what should happen.
+*
+* Loose, because most of the tree runs without a router — a documentation page, a test, an app
+* that never routes — and following the href is the right answer there, not an error.
+*/
+var [useRouterContext, provideRouterContext] = createContext({
+	defaultValue: null,
+	name: "RouterContext",
+	strict: false
+});
+//#endregion
+export { provideRouterContext, useRouterContext };

package/dist/components/router-provider/router-provider.d.ts

@@ -0,0 +1,21 @@
+import type { RouterProviderRootProps } from "./router-provider.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<RouterProviderRootProps> & (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/router-provider/router-provider.js

@@ -0,0 +1,22 @@
+import { provideRouterContext } from "./router-provider.context.js";
+import { createSlot, defineVaporComponent } from "vue";
+//#region src/components/router-provider/router-provider.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var router_provider_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "router-provider",
+	props: {
+		navigate: { type: Function },
+		isCurrent: { type: Function },
+		resolveHref: { type: Function }
+	},
+	setup(__props) {
+		const props = __props;
+		provideRouterContext({
+			isCurrent: (href) => props.isCurrent?.(href) ?? false,
+			navigate: (href, options) => props.navigate(href, options),
+			resolveHref: (href) => props.resolveHref?.(href) ?? href
+		});
+		return createSlot();
+	}
+});
+//#endregion
+export { router_provider_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/router-provider/router-provider.types.d.ts

@@ -0,0 +1,23 @@
+export interface RouterProviderRootProps {
+    /**
+     * Performs a client-side navigation to `href`. In a vue-router application this is
+     * `(href, options) => router.push({path: href, ...options})`.
+     *
+     * Receives the href as the link declared it, so a router gets back the path it was given
+     * rather than the one `resolveHref` produced for the DOM.
+     */
+    navigate: (href: string, options?: unknown) => void;
+    /**
+     * Whether an href addresses the route showing now, for links that ask with `aria-current="auto"`.
+     *
+     * The matching rule is yours: `(href) => route.path === href` for an exact match,
+     * `(href) => route.path.startsWith(href)` for a section. Omitted, no link resolves as current.
+     */
+    isCurrent?: (href: string) => boolean;
+    /**
+     * Rewrites an app-relative href into the URL the anchor should carry, for a router mounted
+     * under a base path or running in hash mode — `(href) => router.resolve(href).href`.
+     * Omitted, the href renders as written.
+     */
+    resolveHref?: (href: string) => string;
+}

package/dist/components/scroll-shadow/use-scroll-shadow.js

@@ -77,10 +77,34 @@ var useScrollShadow = (options) => {
 		checkOverflow();
 		current.addEventListener("scroll", checkOverflow, { passive: true });
 		const observer = typeof ResizeObserver === "undefined" ? void 0 : new ResizeObserver(checkOverflow);
-		observer?.observe(current);
+		/**
+		* The container **and** everything directly inside it.
+		*
+		* Watching the container alone sees only half of what makes a region scrollable: the other
+		* half is the content growing while the region keeps its size, which is what an accordion or
+		* a disclosure opening inside one does. Nothing scrolls and nothing resizes, so a check that
+		* waits for either turns up only once the reader scrolls — by which point the shadow has
+		* stopped being the hint it exists to be.
+		*
+		* Direct children are enough. In normal flow nothing can grow the scrollable area without
+		* growing one of them, so watching deeper would cost an entry per row and report the same
+		* thing.
+		*/
+		const observe = () => {
+			observer?.disconnect();
+			observer?.observe(current);
+			for (const child of Array.from(current.children)) observer?.observe(child);
+		};
+		observe();
+		const mutations = typeof MutationObserver === "undefined" ? void 0 : new MutationObserver(() => {
+			observe();
+			checkOverflow();
+		});
+		mutations?.observe(current, { childList: true });
 		onCleanup(() => {
 			current.removeEventListener("scroll", checkOverflow);
 			observer?.disconnect();
+			mutations?.disconnect();
 			cancelPendingFrame();
 			previous = null;
 		});

package/dist/components/search-field/index.d.ts

@@ -13,6 +13,7 @@ export declare const SearchField: ((__VLS_props: NonNullable<Awaited<typeof __VL
     props: import('vue').PublicProps & {
         class?: string;
         variant?: import("@ropav/styles").SearchFieldVariants["variant"];
+        size?: import("@ropav/styles").SearchFieldVariants["size"];
         fullWidth?: boolean;
         value?: string;
         defaultValue?: string;
@@ -129,6 +130,7 @@ export declare const SearchField: ((__VLS_props: NonNullable<Awaited<typeof __VL
         props: import('vue').PublicProps & {
             class?: string;
             variant?: import("@ropav/styles").SearchFieldVariants["variant"];
+            size?: import("@ropav/styles").SearchFieldVariants["size"];
             fullWidth?: boolean;
             value?: string;
             defaultValue?: string;

package/dist/components/search-field/search-field-root.js

@@ -5,7 +5,7 @@ import { useAutocompleteInputContext } from "../../composables/use-autocomplete.
 import { provideFieldErrorContext } from "../field-error/field-error.context.js";
 import { provideTextFieldControlContext } from "../../composables/use-text-field.js";
 import { provideSearchFieldContext } from "./search-field.context.js";
-import { useSearchField } from "../../composables/use-search-field.js";
+import { useSearchField } from "./use-search-field.js";
 import { computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, template, unref, watch } from "vue";
 import { searchFieldVariants } from "@ropav/styles";
 //#region src/components/search-field/search-field-root.vue?vue&type=script&setup=true&vapor=true&lang.ts
@@ -15,6 +15,7 @@ var search_field_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /
 	props: {
 		class: {},
 		variant: { default: void 0 },
+		size: {},
 		fullWidth: {
 			type: Boolean,
 			default: void 0
@@ -128,6 +129,7 @@ var search_field_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /
 		});
 		const slots = computed(() => searchFieldVariants({
 			fullWidth: props.fullWidth,
+			size: props.size,
 			variant: props.variant
 		}));
 		provideFieldIdsContext(field.fieldIds);

package/dist/components/search-field/search-field.types.d.ts

@@ -4,6 +4,8 @@ export interface SearchFieldRootProps {
     class?: string;
     /** Visual variant. @default "primary" */
     variant?: SearchFieldVariants["variant"];
+    /** How tall the field stands, matching a button of the same size. @default "md" */
+    size?: SearchFieldVariants["size"];
     /** Whether the field stretches to fill its container. */
     fullWidth?: boolean;
     /** Text in the field. Makes it controlled. */

package/dist/{composables → components/search-field}/use-search-field.d.ts

@@ -1,5 +1,5 @@
-import type { PressResponder } from "./press-responder.js";
-import type { UseTextFieldOptions, UseTextFieldReturn } from "./use-text-field.js";
+import type { PressResponder } from "../../composables/press-responder.js";
+import type { UseTextFieldOptions, UseTextFieldReturn } from "../../composables/use-text-field.js";
 import type { ComputedRef, MaybeRefOrGetter } from "vue";
 export interface UseSearchFieldOptions extends Omit<UseTextFieldOptions, "type"> {
     /** Kind of control the browser should offer. @default "search" */

package/dist/{composables → components/search-field}/use-search-field.js

@@ -1,7 +1,7 @@
-import { usePress } from "./use-press.js";
-import { useTextField } from "./use-text-field.js";
+import { usePress } from "../../composables/use-press.js";
+import { useTextField } from "../../composables/use-text-field.js";
 import { computed, toValue } from "vue";
-//#region src/composables/use-search-field.ts
+//#region src/components/search-field/use-search-field.ts
 /**
 * Behaviour and accessibility for a search field, ported from React Aria's
 * `packages/react-aria/src/searchfield/useSearchField.ts` (react-aria 3.51.0).

package/dist/components/segmented-control/index.d.ts

@@ -0,0 +1,134 @@
+import SegmentedControlIndicator from "./segmented-control-indicator.js";
+import SegmentedControlItem from "./segmented-control-item.js";
+import SegmentedControlRoot from "./segmented-control-root.js";
+import SegmentedControlSeparator from "./segmented-control-separator.js";
+export declare const SegmentedControl: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        default?: (props: import("./segmented-control.types.js").SegmentedControlRootSlotProps) => unknown;
+    };
+    emit: ((evt: "selectionChange", key: import("../../index.js").CollectionKey) => void) & ((evt: "update:selectedKey", key: import("../../index.js").CollectionKey) => void);
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        class?: string;
+        size?: import("@ropav/styles").SegmentedControlVariants["size"];
+        fullWidth?: boolean;
+        selectedKey?: import("../../index.js").CollectionKey;
+        defaultSelectedKey?: import("../../index.js").CollectionKey;
+        disabledKeys?: import("../../index.js").CollectionKey[];
+        isDisabled?: boolean;
+        ariaLabel?: string;
+        ariaLabelledby?: string;
+        ariaDescribedby?: string;
+        onSelectionChange?: (((key: import("../../index.js").CollectionKey) => void) & ((key: import("../../index.js").CollectionKey) => any)) | undefined;
+        "onUpdate:selectedKey"?: ((key: import("../../index.js").CollectionKey) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: import("./segmented-control.types.js").SegmentedControlRootSlotProps) => unknown;
+    };
+    emit: ((evt: "selectionChange", key: import("../../index.js").CollectionKey) => void) & ((evt: "update:selectedKey", key: import("../../index.js").CollectionKey) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+}) & {
+    Indicator: (__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>>;
+    };
+    Item: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: {
+        attrs: any;
+        slots: {
+            default?: (props: import("./segmented-control.types.js").SegmentedControlItemSlotProps) => unknown;
+        };
+        emit: {};
+    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+        props: import('vue').PublicProps & {
+            class?: string;
+            id: import("../../index.js").CollectionKey;
+            isDisabled?: boolean;
+            textValue?: string;
+            ariaLabel?: string;
+        } & (typeof globalThis extends {
+            __VLS_PROPS_FALLBACK: infer P;
+        } ? P : {});
+        expose: (exposed: {}) => void;
+        attrs: any;
+        slots: {
+            default?: (props: import("./segmented-control.types.js").SegmentedControlItemSlotProps) => 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?: (props: import("./segmented-control.types.js").SegmentedControlRootSlotProps) => unknown;
+        };
+        emit: ((evt: "selectionChange", key: import("../../index.js").CollectionKey) => void) & ((evt: "update:selectedKey", key: import("../../index.js").CollectionKey) => void);
+    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+        props: import('vue').PublicProps & {
+            class?: string;
+            size?: import("@ropav/styles").SegmentedControlVariants["size"];
+            fullWidth?: boolean;
+            selectedKey?: import("../../index.js").CollectionKey;
+            defaultSelectedKey?: import("../../index.js").CollectionKey;
+            disabledKeys?: import("../../index.js").CollectionKey[];
+            isDisabled?: boolean;
+            ariaLabel?: string;
+            ariaLabelledby?: string;
+            ariaDescribedby?: string;
+            onSelectionChange?: (((key: import("../../index.js").CollectionKey) => void) & ((key: import("../../index.js").CollectionKey) => any)) | undefined;
+            "onUpdate:selectedKey"?: ((key: import("../../index.js").CollectionKey) => any) | undefined;
+        } & (typeof globalThis extends {
+            __VLS_PROPS_FALLBACK: infer P;
+        } ? P : {});
+        expose: (exposed: {}) => void;
+        attrs: any;
+        slots: {
+            default?: (props: import("./segmented-control.types.js").SegmentedControlRootSlotProps) => unknown;
+        };
+        emit: ((evt: "selectionChange", key: import("../../index.js").CollectionKey) => void) & ((evt: "update:selectedKey", key: import("../../index.js").CollectionKey) => void);
+    }>) => import('vue').VNode & {
+        __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+    };
+    Separator: (__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>>;
+    };
+};
+export { SegmentedControlRoot, SegmentedControlItem, SegmentedControlIndicator, SegmentedControlSeparator, };
+export type { SegmentedControlRootProps, SegmentedControlRootProps as SegmentedControlProps, SegmentedControlRootSlotProps, SegmentedControlItemProps, SegmentedControlItemSlotProps, SegmentedControlIndicatorProps, SegmentedControlSeparatorProps, SegmentedControlOrientation, } from "./segmented-control.types.js";
+export { useSegmentedControlContext, useSegmentedControlItemContext, } from "./segmented-control.context.js";
+export type { SegmentedControlContext, SegmentedControlItemContext, } from "./segmented-control.context.js";
+export { segmentedControlVariants } from "@ropav/styles";
+export type { SegmentedControlVariants } from "@ropav/styles";