ropav 0.10.0 → 0.11.1

package/dist/components/autocomplete/autocomplete-filter.d.ts

@@ -1,5 +1,5 @@
 import type { AutocompleteFilterProps, AutocompleteFilterSlotProps } from "./autocomplete.types.js";
-declare const __VLS_export: <T>(__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<{
+declare const __VLS_export: <T = any>(__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<AutocompleteFilterProps<T> & {
         onInputChange?: ((value: string) => any) | undefined;
         "onUpdate:inputValue"?: ((value: string) => any) | undefined;

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

@@ -1,4 +1,5 @@
 import { provideAvatarContext } from "./avatar.context.js";
+import { useAvatarGroupContext } from "../avatar-group/avatar-group.context.js";
 import { computed, createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, shallowRef, template } from "vue";
 import { avatarVariants } from "@ropav/styles";
 //#region src/components/avatar/avatar-root.vue?vue&type=script&setup=true&vapor=true&lang.ts
@@ -13,9 +14,11 @@ var avatar_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PU
 	},
 	setup(__props) {
 		const props = __props;
+		const group = useAvatarGroupContext();
+		const resolvedSize = computed(() => props.size ?? group?.size.value);
 		const slots = computed(() => avatarVariants({
 			color: props.color,
-			size: props.size,
+			size: resolvedSize.value,
 			variant: props.variant
 		}));
 		const imageStatus = shallowRef("idle");

package/dist/components/avatar-group/avatar-group-overflow.d.ts

@@ -0,0 +1,21 @@
+import type { AvatarGroupOverflowProps } from "./avatar-group.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<AvatarGroupOverflowProps> & (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/avatar-group/avatar-group-overflow.js

@@ -0,0 +1,42 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import avatar_fallback_default from "../avatar/avatar-fallback.js";
+import { useAvatarGroupContext } from "./avatar-group.context.js";
+import avatar_root_default from "../avatar/avatar-root.js";
+import { computed, createComponent, createIf, createSlot, defineVaporComponent, extend, renderEffect, setText, template, toDisplayString, unref, useSlots } from "vue";
+//#region src/components/avatar-group/avatar-group-overflow.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template(" ");
+var avatar_group_overflow_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "avatar-group-overflow",
+	props: {
+		class: {},
+		count: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const callerSlots = useSlots();
+		/**
+		* Whether the caller wrote a slot at all, read off its presence and never by running it. A
+		* default written as `<slot>` fallback content drops the slots of anything nested inside it on
+		* the first render from a VDOM host, so both paths are kept apart instead.
+		*/
+		const hasSlot = computed(() => Boolean(callerSlots["default"]));
+		const context = useAvatarGroupContext();
+		const overflowClass = computed(() => composeSlotClassName(context?.slots.value.overflow, props.class));
+		return createComponent(unref(avatar_root_default), {
+			class: () => overflowClass.value,
+			"data-slot": "avatar-group-overflow"
+		}, () => {
+			return createComponent(unref(avatar_fallback_default), null, extend(() => {
+				return createIf(() => hasSlot.value, () => {
+					return createSlot("default", null, null, 4);
+				}, () => createIf(() => props.count !== void 0, () => {
+					const n5 = t0();
+					renderEffect(() => setText(n5, "+" + toDisplayString(props.count)));
+					return n5;
+				}, null, 129), 389);
+			}, { _: 1 }));
+		}, true);
+	}
+});
+//#endregion
+export { avatar_group_overflow_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/avatar-group/avatar-group-root.d.ts

@@ -0,0 +1,21 @@
+import type { AvatarGroupRootProps } from "./avatar-group.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<AvatarGroupRootProps> & (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/avatar-group/avatar-group-root.js

@@ -0,0 +1,35 @@
+import { provideAvatarGroupContext } from "./avatar-group.context.js";
+import { computed, createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template } from "vue";
+import { avatarGroupVariants } from "@ropav/styles";
+//#region src/components/avatar-group/avatar-group-root.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=avatar-group>", 1);
+var avatar_group_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "avatar-group-root",
+	props: {
+		class: {},
+		front: {},
+		orientation: {},
+		overlap: {},
+		size: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = computed(() => avatarGroupVariants({
+			front: props.front,
+			orientation: props.orientation,
+			overlap: props.overlap,
+			size: props.size
+		}));
+		provideAvatarGroupContext({
+			size: computed(() => props.size),
+			slots
+		});
+		const n1 = t0();
+		renderEffect(() => setClass(n1, slots.value.base({ class: props.class })));
+		setInsertionState(n1);
+		createSlot();
+		return n1;
+	}
+});
+//#endregion
+export { avatar_group_root_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/avatar-group/avatar-group.context.d.ts

@@ -0,0 +1,12 @@
+import type { avatarGroupVariants, AvatarVariants } from "@ropav/styles";
+import type { ComputedRef } from "vue";
+export interface AvatarGroupContext {
+    slots: ComputedRef<ReturnType<typeof avatarGroupVariants>>;
+    /** Size for every avatar in the group, which each avatar may still override. */
+    size: ComputedRef<AvatarVariants["size"]>;
+}
+/**
+ * Loose on purpose: an Avatar reads this context but is perfectly usable on its own, so the
+ * absence of a group is a normal state rather than an error.
+ */
+export declare const useAvatarGroupContext: () => AvatarGroupContext | null, provideAvatarGroupContext: (value: AvatarGroupContext | null) => AvatarGroupContext | null;

package/dist/components/avatar-group/avatar-group.context.js

@@ -0,0 +1,13 @@
+import { createContext } from "../../utils/create-context.js";
+//#region src/components/avatar-group/avatar-group.context.ts
+/**
+* Loose on purpose: an Avatar reads this context but is perfectly usable on its own, so the
+* absence of a group is a normal state rather than an error.
+*/
+var [useAvatarGroupContext, provideAvatarGroupContext] = createContext({
+	defaultValue: null,
+	name: "AvatarGroupContext",
+	strict: false
+});
+//#endregion
+export { provideAvatarGroupContext, useAvatarGroupContext };

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

@@ -0,0 +1,26 @@
+import type { AvatarGroupVariants, AvatarVariants } from "@ropav/styles";
+export interface AvatarGroupRootProps {
+    class?: string;
+    /**
+     * Which avatar is in front. `"last"` is the order the document paints in already, so it costs
+     * no stacking rule; `"first"` reverses it. @default "last"
+     */
+    front?: AvatarGroupVariants["front"];
+    /** Axis the avatars are laid out along. @default "horizontal" */
+    orientation?: AvatarGroupVariants["orientation"];
+    /**
+     * How far each avatar tucks under its neighbour, as a share of one avatar. `"none"` spaces them
+     * out instead, and drops the ring with it. @default "md"
+     */
+    overlap?: AvatarGroupVariants["overlap"];
+    /** Size for every avatar in the group. Each avatar can still set its own. @default "md" */
+    size?: AvatarVariants["size"];
+}
+export interface AvatarGroupOverflowProps {
+    class?: string;
+    /**
+     * How many avatars are not shown, rendered as `+count`. Write the slot instead where the count
+     * needs words around it.
+     */
+    count?: number;
+}

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

@@ -0,0 +1,8 @@
+import AvatarGroupOverflow from "./avatar-group-overflow.js";
+import AvatarGroupRoot from "./avatar-group-root.js";
+export { AvatarGroupRoot as AvatarGroup, AvatarGroupOverflow };
+export type { AvatarGroupRootProps as AvatarGroupProps, AvatarGroupOverflowProps, } from "./avatar-group.types.js";
+export { useAvatarGroupContext } from "./avatar-group.context.js";
+export type { AvatarGroupContext } from "./avatar-group.context.js";
+export { avatarGroupVariants } from "@ropav/styles";
+export type { AvatarGroupVariants } from "@ropav/styles";

package/dist/components/avatar-group/index.js

@@ -0,0 +1,5 @@
+import { useAvatarGroupContext } from "./avatar-group.context.js";
+import avatar_group_overflow_default from "./avatar-group-overflow.js";
+import avatar_group_root_default from "./avatar-group-root.js";
+import { avatarGroupVariants } from "@ropav/styles";
+export { avatar_group_root_default as AvatarGroup, avatar_group_overflow_default as AvatarGroupOverflow, avatarGroupVariants, useAvatarGroupContext };

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

@@ -48,7 +48,7 @@ var button_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PU
 			focusResponder?.registerElement(next);
 		};
 		const resolvedFullWidth = computed(() => props.fullWidth ?? group?.fullWidth.value);
-		const resolvedIsDisabled = computed(() => props.isDisabled ?? group?.isDisabled.value ?? fieldset?.isDisabled.value);
+		const resolvedIsDisabled = computed(() => props.isDisabled ?? responder?.isDisabled?.value ?? group?.isDisabled.value ?? fieldset?.isDisabled.value);
 		const resolvedSize = computed(() => props.size ?? group?.size.value);
 		const resolvedVariant = computed(() => props.variant ?? group?.variant.value);
 		const styles = computed(() => buttonVariants({

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

@@ -1,12 +1,17 @@
 import { dataAttr } from "../../utils/assertion.js";
+import { useInteractionStates } from "../../composables/use-interaction-states.js";
 import { composePressResponder, usePressResponder } from "../../composables/press-responder.js";
-import { createSlot, defineVaporComponent, on, renderEffect, setDynamicProps, setInsertionState, setTemplateRefBinding, template, unref } from "vue";
+import { computed, createSlot, defineVaporComponent, on, renderEffect, setDynamicProps, setInsertionState, setTemplateRefBinding, template, unref } from "vue";
 //#region src/components/dropdown/dropdown-trigger.vue?vue&type=script&setup=true&vapor=true&lang.ts
 var t0 = template("<button>", 1);
 var dropdown_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
 	__name: "dropdown-trigger",
 	props: {
 		class: {},
+		isDisabled: {
+			type: Boolean,
+			default: void 0
+		},
 		type: { default: "button" }
 	},
 	setup(__props) {
@@ -15,23 +20,39 @@ var dropdown_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default = /*
 		const setElement = (element) => {
 			responder?.registerElement(element ?? null);
 		};
-		const press = composePressResponder(responder);
+		const resolvedIsDisabled = computed(() => props.isDisabled ?? responder?.isDisabled?.value);
+		const { isFocusVisible, isFocused, isHovered, isPressed, onBlur, onFocus, onPointerdown, onPointerenter, onPointerleave } = useInteractionStates({ isDisabled: () => resolvedIsDisabled.value });
+		const tabindex = computed(() => resolvedIsDisabled.value ? void 0 : 0);
+		const press = composePressResponder(responder, {
+			onPointerdown,
+			onPointerenter,
+			onPointerleave
+		});
 		const n1 = t0();
 		renderEffect(() => {
 			const _props = props;
+			const _dataAttr = unref(dataAttr);
+			const _resolvedIsDisabled = resolvedIsDisabled.value;
 			const _responder = unref(responder);
 			setDynamicProps(n1, [{
 				class: ["rp-dropdown__trigger", _props.class],
-				"data-pressed": unref(dataAttr)(_responder?.isPressed.value),
+				"data-disabled": _dataAttr(_resolvedIsDisabled),
+				"data-focus-visible": _dataAttr(unref(isFocusVisible)),
+				"data-focused": _dataAttr(unref(isFocused)),
+				"data-hovered": _dataAttr(unref(isHovered)),
+				"data-pressed": _dataAttr(unref(isPressed) || _responder?.isPressed.value),
 				"data-slot": "dropdown-trigger",
-				tabindex: "0",
+				disabled: _resolvedIsDisabled || void 0,
+				tabindex: tabindex.value,
 				type: _props.type
 			}, _responder?.attrs.value]);
 		});
 		setInsertionState(n1);
 		createSlot();
+		on(n1, "blur", (e) => unref(onBlur)(e));
 		on(n1, "click", (e) => unref(press).onClick(e));
 		on(n1, "dragstart", (e) => unref(press).onDragstart(e));
+		on(n1, "focus", (e) => unref(onFocus)(e));
 		on(n1, "keydown", (e) => unref(press).onKeydown(e));
 		on(n1, "mousedown", (e) => unref(press).onMousedown(e));
 		on(n1, "pointerdown", (e) => unref(press).onPointerdown(e));

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

@@ -15,6 +15,8 @@ export interface DropdownRootEmits {
 }
 export interface DropdownTriggerProps {
     class?: string;
+    /** Disables the trigger. Falls back to the state the dropdown root supplies. */
+    isDisabled?: boolean;
     /** Native button type. @default "button" */
     type?: "button" | "reset" | "submit";
 }

package/dist/components/index.d.ts

@@ -3,6 +3,7 @@ export * from "./alert/index.js";
 export * from "./alert-dialog/index.js";
 export * from "./autocomplete/index.js";
 export * from "./avatar/index.js";
+export * from "./avatar-group/index.js";
 export * from "./badge/index.js";
 export * from "./breadcrumbs/index.js";
 export * from "./button/index.js";

package/dist/components/list-box-item/list-box-item-root.js

@@ -54,7 +54,10 @@ var list_box_item_root_vue_vue_type_script_setup_true_vapor_true_lang_default =
 		const isSelected = computed(() => selection.isSelected(itemKey.value));
 		const isDisabled = computed(() => selection.isDisabled(itemKey.value));
 		const selectionMode = computed(() => selection.selectionMode.value);
-		const fieldIds = useFieldIds({ slots: ["description"] });
+		const fieldIds = useFieldIds({
+			labelElementType: "span",
+			slots: ["description"]
+		});
 		provideFieldIdsContext(fieldIds.context);
 		provideListBoxItemContext({
 			isSelected,

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

@@ -1,7 +1,7 @@
 import { useOverlayArrowContext } from "./overlay.context.js";
 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><!><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 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(--rp-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;

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

@@ -231,7 +231,7 @@ export interface SidebarItemTooltipProps {
     /**
      * How long the pointer has to rest on the item before the tooltip opens.
      *
-     * Left to the theme's `--tooltip-delay` by default, the same as every other tooltip. A rail is a
+     * Left to the theme's `--rp-tooltip-delay` by default, the same as every other tooltip. A rail is a
      * good reason to want this shorter — the label is the only way to read the item, not a hint
      * beside one — but that is a decision about the whole product's tooltips, not about this part.
      */

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

@@ -11,7 +11,7 @@ var skeleton_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 	},
 	setup(__props) {
 		const props = __props;
-		const resolvedAnimationType = useCssVariable("--skeleton-animation", { override: () => props.animationType });
+		const resolvedAnimationType = useCssVariable("--rp-skeleton-animation", { override: () => props.animationType });
 		const styles = computed(() => skeletonVariants({ animationType: resolvedAnimationType.value }).base({ class: props.class }));
 		const n1 = t0();
 		renderEffect(() => setClass(n1, styles.value));

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

@@ -1,6 +1,6 @@
 import type { SkeletonVariants } from "@ropav/styles";
 export interface SkeletonRootProps {
     class?: string;
-    /** Animation type. Falls back to the theme's `--skeleton-animation` value. */
+    /** Animation type. Falls back to the theme's `--rp-skeleton-animation` value. */
     animationType?: SkeletonVariants["animationType"];
 }

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

@@ -3,6 +3,7 @@ import { useInteractionStates } from "../../composables/use-interaction-states.j
 import { setFormValue } from "../../utils/form-value.js";
 import { useTextFieldControlContext } from "../../composables/use-text-field.js";
 import { useTextFieldContext } from "../textfield/textfield.context.js";
+import { useTextareaAutosize } from "../../composables/use-textarea-autosize.js";
 import { computed, createTemplateRefSetter, defineVaporComponent, on, renderEffect, setDynamicProps, shallowRef, template, unref, watch } from "vue";
 import { textAreaVariants } from "@ropav/styles";
 //#region src/components/textarea/textarea-root.vue?vue&type=script&setup=true&vapor=true&lang.ts
@@ -18,6 +19,13 @@ var textarea_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 			type: Boolean,
 			default: void 0
 		},
+		autosize: {
+			type: Boolean,
+			default: void 0
+		},
+		minRows: { default: void 0 },
+		maxRows: { default: void 0 },
+		resize: { default: void 0 },
 		placeholder: {}
 	},
 	emits: ["change", "update:value"],
@@ -33,9 +41,11 @@ var textarea_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 		};
 		const resolvedVariant = computed(() => props.variant ?? textField?.variant.value);
 		const resolvedSize = computed(() => props.size ?? textField?.size.value);
+		const resolvedResize = computed(() => props.autosize ? "none" : props.resize);
 		const styles = computed(() => textAreaVariants({
 			class: props.class,
 			fullWidth: props.fullWidth,
+			resize: resolvedResize.value,
 			size: resolvedSize.value,
 			variant: resolvedVariant.value
 		}));
@@ -43,15 +53,24 @@ var textarea_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 			const merged = { ...control?.attrs.value };
 			if (props.placeholder !== void 0) merged["placeholder"] = props.placeholder;
 			if (props.value !== void 0) merged["value"] = props.value;
+			if (props.autosize && props.minRows !== void 0) merged["rows"] = props.minRows;
 			return merged;
 		});
 		const interaction = useInteractionStates({ isDisabled: () => control?.isDisabled.value });
 		const inputCount = shallowRef(0);
+		const { sync: syncAutosize } = useTextareaAutosize({
+			content: () => control?.attrs.value["value"],
+			element,
+			enabled: () => props.autosize,
+			maxRows: () => props.maxRows,
+			minRows: () => props.minRows
+		});
 		const onInput = (event) => {
 			control?.handlers.onInput(event);
 			const next = event.currentTarget.value;
 			emit("change", next);
 			emit("update:value", next);
+			syncAutosize({ fromInput: true });
 			if (props.value !== void 0) inputCount.value++;
 		};
 		/**
@@ -66,6 +85,7 @@ var textarea_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__
 		], ([el, pinned]) => {
 			if (pinned === void 0) return;
 			setFormValue(el, pinned);
+			syncAutosize();
 		}, {
 			flush: "post",
 			immediate: true

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

@@ -16,6 +16,27 @@ export interface TextAreaRootProps {
     size?: TextAreaVariants["size"];
     /** Whether the control stretches to fill its container. */
     fullWidth?: boolean;
+    /**
+     * Whether the control grows with its content. `minRows` and `maxRows` only apply when this
+     * is set. Native resize is forced off while it is, so the drag handle cannot fight the
+     * measured height. @default false
+     */
+    autosize?: boolean;
+    /**
+     * Minimum visible rows while `autosize` is set. Ignored otherwise. Written through to the
+     * native `rows` attribute so the first paint is already that tall.
+     */
+    minRows?: number;
+    /**
+     * Maximum visible rows while `autosize` is set. Ignored otherwise. Absent, the control grows
+     * without a cap.
+     */
+    maxRows?: number;
+    /**
+     * Whether the pointer can drag the edge. `none` by default; `vertical` or `both` opt in.
+     * Ignored while `autosize` is set. @default "none"
+     */
+    resize?: TextAreaVariants["resize"];
     /**
      * Placeholder shown while the control is empty. Declared so it can also be set here rather
      * than only on the field; every other native attribute arrives by attribute fallthrough.

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

@@ -39,8 +39,8 @@ var tooltip_root_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__P
 		* changes one declaration instead of every call site. A prop still wins, and the built-in defaults
 		* are the floor when the property is not declared at all.
 		*/
-		const cssDelay = useCssVariable("--tooltip-delay");
-		const cssCloseDelay = useCssVariable("--tooltip-close-delay");
+		const cssDelay = useCssVariable("--rp-tooltip-delay");
+		const cssCloseDelay = useCssVariable("--rp-tooltip-close-delay");
 		const state = useTooltipTriggerState({
 			closeDelay: () => props.closeDelay ?? parseCssTime(cssCloseDelay.value),
 			defaultOpen: props.defaultOpen,

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

@@ -6,13 +6,13 @@ export interface TooltipRootProps {
     /**
      * How long the pointer has to rest on the trigger before the tooltip opens.
      *
-     * @default the `--tooltip-delay` custom property, or 1500
+     * @default the `--rp-tooltip-delay` custom property, or 1500
      */
     delay?: number;
     /**
      * How long the tooltip stays after the pointer leaves.
      *
-     * @default the `--tooltip-close-delay` custom property, or 500
+     * @default the `--rp-tooltip-close-delay` custom property, or 500
      */
     closeDelay?: number;
     /** Opens on hover and on keyboard focus, or on focus alone. @default "hover" */

package/dist/composables/press-responder.d.ts

@@ -9,6 +9,12 @@ export interface PressResponder {
     attrs: ComputedRef<Record<string, unknown>>;
     /** Listeners the pressable chains ahead of its own, through {@link composePressResponder}. */
     handlers: ComputedRef<UsePressHandlers>;
+    /**
+     * Whether the pressable should be disabled regardless of its own state. Holds `undefined` when
+     * nothing above has an opinion, which is what lets a pressable resolving this against its own
+     * group or fieldset tell "enabled" apart from "unstated".
+     */
+    isDisabled?: ComputedRef<boolean | undefined>;
     /** Whether the pressable should look pressed regardless of its own state. */
     isPressed: ComputedRef<boolean>;
     /** Reports the pressable's element, which is what the responder acts on and positions against. */

package/dist/composables/use-css-variable.d.ts

@@ -14,7 +14,7 @@ export interface UseCssVariableOptions {
  *
  * @example
  * ```ts
- * const delay = computed(() => parseCssTime(useCssVariable("--tooltip-delay").value));
+ * const delay = computed(() => parseCssTime(useCssVariable("--rp-tooltip-delay").value));
  * ```
  */
 export declare const useCssVariable: (name: MaybeRefOrGetter<string>, options?: UseCssVariableOptions) => ComputedRef<string | undefined>;

package/dist/composables/use-css-variable.js

@@ -16,7 +16,7 @@ var cache = /* @__PURE__ */ new Map();
 *
 * @example
 * ```ts
-* const delay = computed(() => parseCssTime(useCssVariable("--tooltip-delay").value));
+* const delay = computed(() => parseCssTime(useCssVariable("--rp-tooltip-delay").value));
 * ```
 */
 var useCssVariable = (name, options = {}) => {

package/dist/composables/use-menu-trigger.js

@@ -102,6 +102,7 @@ var useMenuTrigger = (options, state) => {
 				}
 			};
 		}),
+		isDisabled: computed(() => toValue(options.isDisabled)),
 		isPressed: press.isPressed,
 		registerElement: (next) => {
 			element.value = next;

package/dist/composables/use-textarea-autosize.d.ts

@@ -0,0 +1,55 @@
+import type { MaybeRefOrGetter } from "vue";
+export interface UseTextareaAutosizeOptions {
+    element: MaybeRefOrGetter<HTMLTextAreaElement | null | undefined>;
+    /** When false, inline height and overflow are cleared and the native `rows` height is used. */
+    enabled: MaybeRefOrGetter<boolean | undefined>;
+    /** Floor, in rows. Ignored when `enabled` is false. */
+    minRows: MaybeRefOrGetter<number | undefined>;
+    /** Ceiling, in rows. Absent, the control grows without a cap. Ignored when `enabled` is false. */
+    maxRows: MaybeRefOrGetter<number | undefined>;
+    /**
+     * Text held somewhere the element cannot be read from. Reading `element.value` is not
+     * reactive, so a caller that does not already remeasure when its own text moves passes
+     * the value it holds here.
+     */
+    content?: MaybeRefOrGetter<unknown>;
+}
+export interface UseTextareaAutosizeSyncOptions {
+    /**
+     * From `input` only. A caret at the end then keeps the last line's padding in view.
+     * Layout remeasures omit this so a scroll the user made is not stolen.
+     */
+    fromInput?: boolean;
+}
+export interface UseTextareaAutosizeReturn {
+    /** Measure now. Needed from `input`, where the DOM already holds the next text. */
+    sync: (options?: UseTextareaAutosizeSyncOptions) => void;
+}
+/**
+ * Keep a textarea as tall as its content, optionally between `minRows` and `maxRows`.
+ *
+ * The caller has to invoke {@link UseTextareaAutosizeReturn.sync} from `input`: reading
+ * `element.value` inside a getter is not a reactive dependency, and waiting for a post-flush
+ * watch would size against the previous stroke. `minRows`, `maxRows` and {@link
+ * UseTextareaAutosizeOptions.content} go through a post-flush watch instead.
+ *
+ * Observers attach only while autosize is on. Native `resize` writes inline `width` and
+ * `height` as the pointer drags; an observer that stayed attached with autosize off would
+ * `clear` that height on every width change and fight the handle.
+ *
+ * Writing `style.height` is itself a size change, so the observer has to discriminate width
+ * or it would loop. That makes the seed load-bearing: it is read from the same content box
+ * `contentRect` reports, because a seed off by the border makes the first delivery look like
+ * a width change, and skipping that first delivery instead loses a real one — `sync` after
+ * `observe` can make a scrollbar appear, and the callback reporting the narrower width is
+ * the only notice of it.
+ *
+ * An inline height also hides height-only metric changes from the observer — a webfont that
+ * lands after first paint, or `.rp-textarea`'s `@media (width >= 40rem)` type/padding switch
+ * on a fixed-width control. Those go through `document.fonts` and `window` `resize`. Used
+ * metrics that do not move the box (`--rp-leading`, Firefox text-only zoom) never notify at
+ * all, which is why every field settles with `overflow-y: auto` — a stale height then
+ * scrolls rather than clips. A leftover clip on a field no cap clamped is the observer
+ * backstop for same-width box changes such as padding, which do notify.
+ */
+export declare const useTextareaAutosize: (options: UseTextareaAutosizeOptions) => UseTextareaAutosizeReturn;