@livestorm/ui-vue 3.0.0 → 4.0.0

package/dist/types/src/components/UiTable/UiTableActionsCell.vue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Host for trailing row actions. Place it as the last cell of a row, under a
+ * UiTableActionsHeaderCell. The overlay variants reveal the actions over the
+ * preceding cells on row hover or keyboard focus; the menu variant renders a
+ * persistent trigger instead. Without content it renders an empty cell, for
+ * rows that have no actions.
+ */
+export interface UiTableActionsCellProps {
+    /**
+     * `default` masks the cells behind the actions with a row-state backdrop,
+     * for bare buttons per the Figma spec. `floating` drops the backdrop for
+     * self-contained content that brings its own surface, like a UiActionBar.
+     * `menu` tucks the actions behind an always-visible trigger button that
+     * opens them in a popover on click — no hover needed, so it also works
+     * on touch devices.
+     * @default 'default'
+     */
+    variant?: 'default' | 'floating' | 'menu';
+    /**
+     * Accessible label of the menu trigger. Defaults to the built-in
+     * "More actions" label.
+     */
+    menuLabel?: string;
+    /**
+     * Keeps the overlay actions shown without row hover or focus, e.g. while
+     * a menu they opened is open.
+     * @default false
+     */
+    revealed?: boolean;
+}
+declare var __VLS_27: {}, __VLS_29: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_27) => any;
+} & {
+    default?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<UiTableActionsCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UiTableActionsCellProps> & Readonly<{}>, {
+    variant: "default" | "floating" | "menu";
+    menuLabel: string;
+    revealed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiTable/UiTableActionsHeaderCell.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/UiTable/UiTableBody.vue.d.ts

@@ -1,8 +1,18 @@
+export interface UiTableBodyProps {
+    /**
+     * Starts the zebra on the first row, so a body that follows another body
+     * with an odd number of rows keeps the stripes alternating.
+     * @default false
+     */
+    zebraOffset?: boolean;
+}
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<UiTableBodyProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UiTableBodyProps> & Readonly<{}>, {
+    zebraOffset: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiTable/UiTableCell.vue.d.ts

@@ -1,8 +1,23 @@
+export interface UiTableCellProps {
+    /**
+     * Renders an en dash (–), the convention for missing values.
+     * @default false
+     */
+    empty?: boolean;
+    /**
+     * Content alignment. Textual data stays left-aligned; reserve `right` for numeric data.
+     * @default 'left'
+     */
+    align?: 'left' | 'right';
+}
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<UiTableCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UiTableCellProps> & Readonly<{}>, {
+    align: "left" | "right";
+    empty: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiTable/UiTableHeaderCell.vue.d.ts

@@ -1,8 +1,37 @@
-declare var __VLS_1: {};
+export type UiTableSortDirection = 'asc' | 'desc' | 'none';
+export interface UiTableHeaderCellProps {
+    /**
+     * Renders the sort affordance and makes the header interactive.
+     * Sorting itself stays in the consumer: listen to `sort` and update `sort-direction`.
+     * @default false
+     */
+    sortable?: boolean;
+    /**
+     * Current sort direction, controlled by the consumer.
+     * @default 'none'
+     */
+    sortDirection?: UiTableSortDirection;
+    /**
+     * Content alignment. Textual data stays left-aligned; reserve `right` for numeric data.
+     * @default 'left'
+     */
+    align?: 'left' | 'right';
+}
+declare var __VLS_1: {}, __VLS_3: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<UiTableHeaderCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    sort: () => any;
+}, string, import("vue").PublicProps, Readonly<UiTableHeaderCellProps> & Readonly<{
+    onSort?: (() => any) | undefined;
+}>, {
+    align: "left" | "right";
+    sortable: boolean;
+    sortDirection: UiTableSortDirection;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiTable/UiTableRow.vue.d.ts

@@ -1,11 +1,41 @@
 export interface UiTableRowProps {
-    isEven?: boolean;
+    /**
+     * Marks the row as selected.
+     * @default false
+     */
+    selected?: boolean;
+    /**
+     * Makes the row interactive: hover feedback, pointer cursor and keyboard focus.
+     * @default false
+     */
+    clickable?: boolean;
+    /**
+     * The row hosts a link stretched over it: positions the row for the link
+     * and gives it the hover and focus tone.
+     * @default false
+     */
+    linked?: boolean;
+    /**
+     * Takes part in the table zebra. Turn it off for a row that is not a data
+     * row, such as an overlay over the rows: it is neither striped nor counted.
+     * @default true
+     */
+    zebra?: boolean;
 }
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<UiTableRowProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UiTableRowProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<UiTableRowProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent | KeyboardEvent) => any;
+}, string, import("vue").PublicProps, Readonly<UiTableRowProps> & Readonly<{
+    onClick?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    zebra: boolean;
+    clickable: boolean;
+    linked: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiTable/context.d.ts

@@ -0,0 +1,3 @@
+import type { InjectionKey, Ref } from 'vue';
+export type UiTableSize = 'md' | 'lg';
+export declare const UI_TABLE_SIZE_KEY: InjectionKey<Ref<UiTableSize>>;

package/dist/types/src/components/UiTable/index.d.ts

@@ -1,6 +1,10 @@
 export { default as UiTable } from './UiTable.vue';
 export { default as UiTableHeader } from './UiTableHeader.vue';
 export { default as UiTableHeaderCell } from './UiTableHeaderCell.vue';
+export { default as UiTableActionsHeaderCell } from './UiTableActionsHeaderCell.vue';
 export { default as UiTableBody } from './UiTableBody.vue';
 export { default as UiTableRow } from './UiTableRow.vue';
 export { default as UiTableCell } from './UiTableCell.vue';
+export { default as UiTableActionsCell } from './UiTableActionsCell.vue';
+export type { UiTableSize } from './context';
+export type { UiTableSortDirection } from './UiTableHeaderCell.vue';

package/dist/types/src/components/UiTabs/UiTabs.vue.d.ts

@@ -17,6 +17,8 @@ export interface UiTabsProps {
     modelValue: string;
     /** Size of the tabs */
     size?: 'sm' | 'md';
+    /** Horizontal alignment of the tabs inside the component */
+    align?: 'start' | 'center';
 }
 type __VLS_Slots = {
     badge?(props: {
@@ -29,6 +31,7 @@ declare const __VLS_base: import("vue").DefineComponent<UiTabsProps, {}, {}, {},
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
     size: "sm" | "md";
+    align: "start" | "center";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/src/components/UiTag/UiTag.types.d.ts

@@ -0,0 +1,25 @@
+export type UiTagSize = 'xxs' | 'xs' | 'sm' | 'md';
+export type UiTagColor = 'primary' | 'neutral' | 'danger' | 'warning' | 'success' | 'neutral-invert';
+export type UiTagVariant = 'light' | 'strong';
+export interface UiTagProps {
+    /**
+     * Size of the tag
+     */
+    size?: UiTagSize;
+    /**
+     * Color variant of the tag
+     */
+    color?: UiTagColor;
+    /**
+     * Variant of the tag
+     */
+    variant?: UiTagVariant;
+    /**
+     * Label text for the tag
+     */
+    label?: string;
+    /**
+     * Whether to show hover effects
+     */
+    withHoverEffect?: boolean;
+}

package/dist/types/src/components/UiTag/UiTag.vue.d.ts

@@ -1,36 +1,15 @@
-interface Props {
-    /**
-     * Size of the tag
-     */
-    size?: 'xxs' | 'xs' | 'sm' | 'md';
-    /**
-     * Color variant of the tag
-     */
-    color?: 'primary' | 'neutral' | 'danger' | 'warning' | 'success' | 'neutral-invert';
-    /**
-     * Variant of the tag
-     */
-    variant?: 'light' | 'strong';
-    /**
-     * Label text for the tag
-     */
-    label?: string;
-    /**
-     * Whether to show hover effects
-     */
-    withHoverEffect?: boolean;
-}
+import type { UiTagProps } from './UiTag.types';
 declare var __VLS_1: {}, __VLS_3: {};
 type __VLS_Slots = {} & {
     'left-icon'?: (props: typeof __VLS_1) => any;
 } & {
     default?: (props: typeof __VLS_3) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
-    size: "xxs" | "xs" | "sm" | "md";
+declare const __VLS_base: import("vue").DefineComponent<UiTagProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UiTagProps> & Readonly<{}>, {
+    size: import("./UiTag.types").UiTagSize;
     label: string;
-    variant: "light" | "strong";
-    color: "primary" | "neutral" | "danger" | "warning" | "success" | "neutral-invert";
+    variant: import("./UiTag.types").UiTagVariant;
+    color: import("./UiTag.types").UiTagColor;
     withHoverEffect: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/src/components/UiTag/index.d.ts

@@ -1 +1,2 @@
-export { default } from "./UiTag.vue";
+export { default } from './UiTag.vue';
+export type { UiTagColor, UiTagProps, UiTagSize, UiTagVariant } from './UiTag.types';

package/dist/types/src/components/UiTextField/UiTextField.vue.d.ts

@@ -4,6 +4,10 @@ interface UiTextFieldProps {
     modelValue?: string;
     placeholder?: string;
     disabled?: boolean;
+    /**
+     * The value can be selected and copied but not edited
+     */
+    readonly?: boolean;
     loading?: boolean;
     error?: boolean;
     label?: string;
@@ -31,17 +35,17 @@ declare const __VLS_base: import("vue").DefineComponent<UiTextFieldProps, {
     insertAtCursor: (text: string) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     clear: () => any;
+    keydown: (event: KeyboardEvent) => any;
     "update:modelValue": (value: string) => any;
-    blur: (event: FocusEvent) => any;
     focus: (event: FocusEvent) => any;
-    keydown: (event: KeyboardEvent) => any;
+    blur: (event: FocusEvent) => any;
     keyup: (event: KeyboardEvent) => any;
 }, string, import("vue").PublicProps, Readonly<UiTextFieldProps> & Readonly<{
     onClear?: (() => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onBlur?: ((event: FocusEvent) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
     onKeyup?: ((event: KeyboardEvent) => any) | undefined;
 }>, {
     size: TextFieldSize;
@@ -52,8 +56,9 @@ declare const __VLS_base: import("vue").DefineComponent<UiTextFieldProps, {
     error: boolean;
     loading: boolean;
     modelValue: string;
-    clearable: boolean;
     ariaDescribedby: string;
+    readonly: boolean;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/src/components/UiTooltip/UiTooltipProvider.vue.d.ts

@@ -5,6 +5,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {
     delayDuration: number;
+    disableClosingTrigger: boolean;
     skipDelayDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/src/components/UiTooltip/UiTooltipTrigger.vue.d.ts

@@ -1,7 +1,7 @@
 import type { TooltipTriggerProps } from 'reka-ui';
-declare var __VLS_8: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/src/composables/storedThemingApplies.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Does stored theming output apply?
+ *
+ * The theme picker (and its playground) is the only writer of deliberate
+ * theming choices: the stored modes in `themeAndMode` and the seed token map
+ * in `customThemeTokens`. A stored value alone is not a choice signal —
+ * `useStorage` persists the light/light defaults for every visitor — so
+ * stored theming is consumed only where the picker exists, and every surface
+ * ships its own defaults otherwise (the dashboard light/light, the room
+ * dark shell over light content).
+ *
+ * This is the single place that rule lives. `ls-internal-theming` itself
+ * gates the picker's visibility; it does not gate any rendering path.
+ * When a real user-facing theming choice ships (workspace setting, OS
+ * follow), its mechanism replaces this predicate.
+ */
+export declare function storedThemingApplies(): boolean;

package/dist/types/src/composables/useButtonStyles.d.ts

@@ -15,6 +15,7 @@ export declare function useButtonStyles(options: UseButtonStylesOptions): {
     bgClass: import("vue").ComputedRef<string>;
     textClass: import("vue").ComputedRef<string>;
     borderClasses: import("vue").ComputedRef<string[]>;
+    decorationClass: import("vue").ComputedRef<"" | "[text-decoration-line:var(--control-link-decoration)] underline-offset-3">;
     overlayClasses: import("vue").ComputedRef<string[]>;
     beforeHoverOverlayClass: import("vue").ComputedRef<string>;
 };

package/dist/types/src/composables/useChoiceboxSurface.d.ts

@@ -0,0 +1,11 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { ChoiceControl } from '../components/UiChoice/types';
+interface ChoiceboxState {
+    control: ChoiceControl;
+    selected: boolean;
+    disabled: boolean;
+    error?: boolean;
+}
+/** Border, fill, radius and focus ring of a UiChoice choicebox */
+export declare function useChoiceboxSurface(state: MaybeRefOrGetter<ChoiceboxState>): ComputedRef<string[]>;
+export {};

package/dist/types/src/composables/useContentMode.d.ts

@@ -5,21 +5,19 @@ import { type Ref } from 'vue';
  * behaviour `UiPage` gives its page content, without pulling in the full page
  * layout (and its `<main>`).
  *
- * The content historically forces light mode. That pin is only lifted when the
- * internal theming tooling is enabled, so the stored content mode can apply;
- * everyone else stays light regardless of what localStorage may hold.
+ * Content ships light. The stored content mode applies where the picker
+ * exists (see storedThemingApplies); everyone else gets the shipped default
+ * regardless of what localStorage may hold.
  *
- * The flag is read in onMounted, not at setup: setup also runs during SSR (no
- * localStorage), and server + client-hydration markup must be identical — the
- * pin lifts right after mount for the internal tooling instead.
+ * The predicate is read in onMounted, not at setup: setup also runs during
+ * SSR (no localStorage), and server + client-hydration markup must be
+ * identical — stored modes take over right after mount instead.
  *
  * @param element  Template ref of the content element to watch.
  * @param selector Unique key for the watch registry — one per logical surface
  *                 (e.g. `[data-name="ui-page-content"]`).
- * @returns `contentMode`, to bind to the element's `data-colors-semantic`, and
- *          `isInternalThemingEnabled` for any mode-dependent styling.
+ * @returns `contentMode`, to bind to the element's `data-colors-semantic`.
  */
 export declare function useContentMode(element: Ref<HTMLElement | undefined>, selector: string): {
     contentMode: import("vue").ComputedRef<"light" | "dark">;
-    isInternalThemingEnabled: Ref<boolean, boolean>;
 };

package/dist/types/src/composables/useControlModes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Applies the accessibility look on the app root: `data-accessibility="on"`.
+ * The control tokens read this attribute.
+ */
+export declare function applyControlModes({ accessibility }: {
+    accessibility: boolean;
+}, root?: HTMLElement): void;

package/dist/types/src/composables/useControlShape.d.ts

@@ -0,0 +1,24 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+export type FieldSize = 'sm' | 'md' | 'lg' | 'xl';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg';
+interface FieldShape {
+    height: string;
+    radius: string;
+    chevron: string;
+}
+interface ControlShapes {
+    field: {
+        size: FieldSize;
+        shape: FieldShape;
+    };
+    button: {
+        size: ButtonSize;
+        shape: {
+            height: string;
+            square: string;
+            radius: string;
+        };
+    };
+}
+export declare function useControlShape<K extends keyof ControlShapes>(kind: K, size: MaybeRefOrGetter<ControlShapes[K]['size']>): ComputedRef<ControlShapes[K]['shape']>;
+export {};

package/dist/types/src/composables/useFieldFocusEvents.d.ts

@@ -0,0 +1,12 @@
+export declare function useFieldFocusEvents(emit: {
+    (event: 'focus', payload: FocusEvent): void;
+    (event: 'blur', payload: FocusEvent): void;
+    (event: 'keydown', payload: KeyboardEvent): void;
+    (event: 'keyup', payload: KeyboardEvent): void;
+}): {
+    isFocused: import("vue").Ref<boolean, boolean>;
+    handleFocus: (event: FocusEvent) => void;
+    handleBlur: (event: FocusEvent) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    handleKeyup: (event: KeyboardEvent) => void;
+};

package/dist/types/src/composables/useIconSize.d.ts

@@ -9,3 +9,5 @@ export declare const ICON_SIZES: {
 export type IconSizeName = keyof typeof ICON_SIZES;
 /** Reactive icon size class for a control's `size`. */
 export declare function useIconSize(size: MaybeRefOrGetter<IconSizeName>): import("vue").ComputedRef<"size-3" | "size-4" | "size-5" | "size-6" | "size-7">;
+/** Reactive trailing icon size class for a control's `size`. */
+export declare function useTrailingIconSize(size: MaybeRefOrGetter<IconSizeName>): import("vue").ComputedRef<"size-4" | "size-5" | "size-6" | "size-2.5" | "size-3.5">;

package/dist/types/src/composables/usePullGesture.d.ts

@@ -0,0 +1,42 @@
+import { type MaybeRefOrGetter } from 'vue';
+interface UsePullGestureOptions {
+    /**
+     * Pointer travel (px, ascending) at which each stage is reached. An empty
+     * list disables the gesture.
+     */
+    stages: MaybeRefOrGetter<number[]>;
+    /**
+     * Travel (px) up to which the element tracks the pointer 1:1; resistance
+     * builds beyond it. Defaults to the last stage.
+     */
+    resistFrom?: MaybeRefOrGetter<number | undefined>;
+    /**
+     * Visible travel the pulled element tends toward once resisting. Defaults to
+     * five times the last stage.
+     */
+    maxOffset?: MaybeRefOrGetter<number | undefined>;
+    /** Called on release when at least one stage was reached. */
+    onRelease?: (stage: number) => void;
+}
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Pull gesture in any direction with staged thresholds: the element follows
+ * the pointer through the stages and resists beyond the last one. Bind the
+ * returned pointer handlers to the pulled element and apply `offset` as its
+ * translation; on release the state snaps back to rest.
+ */
+export declare function usePullGesture(options: UsePullGestureOptions): {
+    enabled: import("vue").ComputedRef<boolean>;
+    isPulling: import("vue").Ref<boolean, boolean>;
+    stage: import("vue").ComputedRef<number>;
+    offset: import("vue").ComputedRef<Point>;
+    onPointerDown: (event: PointerEvent) => void;
+    onPointerMove: (event: PointerEvent) => void;
+    onPointerUp: (event: PointerEvent) => void;
+    onPointerCancel: (event: PointerEvent) => void;
+    consumeDrag: () => boolean;
+};
+export {};

package/dist/types/src/composables/useThemeAndModes.d.ts

@@ -11,6 +11,10 @@ export default function useThemeAndModes({ themeOverride, modeOverride, contentM
         element: HTMLElement;
         modeOverride?: (typeof MODE_OPTIONS)[number];
     }) => void;
+    removeElementToWatch: (listType: "mode" | "content", { selector, element }: {
+        selector: string;
+        element: HTMLElement;
+    }) => void;
     updateContentMode: typeof updateContentMode;
     updateTheme: typeof updateTheme;
     updateMode: typeof updateMode;