ropav 0.0.6 → 0.0.8

package/dist/components/dropdown-menu/useDropdownMenuInteractions.d.ts

@@ -0,0 +1,51 @@
+import { Ref } from 'vue';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
+import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils';
+type BooleanSource = Readonly<Ref<boolean>>;
+type DisclosureControls = {
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+};
+type SubmenuControls = {
+    closeSubmenusAfter: (menuPath: ItemPath) => void;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    closeCurrentSubmenu: () => boolean;
+};
+type HoverIntentControls = {
+    clearPendingHover: () => void;
+    resetHoverIntent: () => void;
+    trackSubmenuOpen: (path: ItemPath, point?: PointerPoint) => void;
+    handleItemHover: (item: DropdownMenuItem, path: ItemPath, event: MouseEvent | undefined, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
+    handleMenuMousemove: (event: MouseEvent, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
+};
+type UseDropdownMenuInteractionsOptions = {
+    props: Readonly<DropdownMenuProps>;
+    emit: {
+        select?: (item: DropdownMenuItem) => void;
+    };
+    isDisabled: BooleanSource;
+    focusedPath: Ref<ItemPath>;
+    openSubmenuPath: Ref<ItemPath>;
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
+    moveFocus: (direction: 1 | -1) => ItemPath | undefined;
+    submenus: SubmenuControls;
+    hoverIntent: HoverIntentControls;
+    disclosure: DisclosureControls;
+    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
+};
+export declare function useDropdownMenuInteractions({ props, emit, isDisabled, focusedPath, openSubmenuPath, getItemAtPath, focusItem, moveFocus, submenus, hoverIntent, disclosure, isSubmenuOpeningLeft, }: UseDropdownMenuInteractionsOptions): {
+    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
+    selectItem: (item: DropdownMenuItem) => void;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
+    onTriggerClick: () => void;
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    onMenuMouseleave: () => void;
+};
+export {};

package/dist/components/dropdown-menu/useDropdownMenuNavigation.d.ts

@@ -0,0 +1,16 @@
+import { DropdownMenuFocusTarget, DropdownMenuItem } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type DropdownMenuItemsSource = {
+    readonly value: DropdownMenuItem[];
+};
+export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource): {
+    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    focusedIndex: import('vue').ComputedRef<number>;
+    getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
+    resetFocus: () => void;
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    moveFocus: (direction: 1 | -1) => number[] | undefined;
+};
+export {};

package/dist/components/dropdown-menu/useDropdownMenuRenderItems.d.ts

@@ -0,0 +1,25 @@
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type DropdownMenuItemsSource = {
+    readonly value: DropdownMenuItem[];
+};
+type UseDropdownMenuRenderItemsOptions = {
+    items: DropdownMenuItemsSource;
+    getItemId: (path: ItemPath) => string;
+    getSubmenuId: (path: ItemPath) => string;
+    getMenuActiveDescendant: (path: ItemPath) => string | undefined;
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
+    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
+    selectItem: (item: DropdownMenuItem) => void;
+    openSubmenu: (path: ItemPath, focus?: DropdownMenuFocusTarget) => void;
+    closeSubmenu: (path: ItemPath) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+};
+export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
+    renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemSlotProps;
+};
+export {};

package/dist/components/dropdown-menu/useDropdownSubmenus.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { DropdownMenuItem } from './types';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils';
+type UseDropdownSubmenusOptions = {
+    focusedPath: Ref<ItemPath>;
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: Exclude<SubmenuFocusTarget, false>, menuPath?: ItemPath) => boolean;
+};
+export declare function useDropdownSubmenus({ focusedPath, getItemAtPath, focusItem, }: UseDropdownSubmenusOptions): {
+    openSubmenuPath: Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    resetSubmenus: () => void;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    closeSubmenusAfter: (menuPath: ItemPath) => void;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    closeCurrentSubmenu: () => boolean;
+};
+export {};

package/dist/components/field/field.d.ts

@@ -1,4 +1,4 @@
-import { FieldControlProps, FieldProps } from './types';
+import { FieldProps } from './types';
 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<FieldProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -15,7 +15,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             invalid: true | undefined;
             labelledby: string | undefined;
             describedby: string | undefined;
-            controlProps: FieldControlProps;
+            controlProps: import('./types').FieldControlProps;
         }) => any;
     } & {
         description?: (props: {}) => any;

package/dist/components/field/useField.d.ts

@@ -0,0 +1,17 @@
+import { FieldControlProps, FieldProps } from './types';
+export declare function useField(props: Readonly<FieldProps>): {
+    controlId: import('vue').ComputedRef<string>;
+    labelId: import('vue').ComputedRef<string>;
+    descriptionId: import('vue').ComputedRef<string>;
+    messageId: import('vue').ComputedRef<string>;
+    isInvalid: import('vue').ComputedRef<boolean>;
+    messageText: import('vue').ComputedRef<string | undefined>;
+    hasLabel: import('vue').ComputedRef<boolean>;
+    hasDescription: import('vue').ComputedRef<boolean>;
+    hasMessage: import('vue').ComputedRef<boolean>;
+    controlLabelledby: import('vue').ComputedRef<string | undefined>;
+    controlDescribedby: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    controlProps: import('vue').ComputedRef<FieldControlProps>;
+    focusControl: (e: MouseEvent) => void;
+};

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

@@ -0,0 +1,8 @@
+import { InputProps } from './types';
+export declare function useInput(props: Readonly<InputProps>, emitUpdate: (value: string) => void): {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    control: import('../../composables/useControlState').ControlState;
+    rootClass: import('vue').ComputedRef<string[]>;
+    onInput: (e: Event) => void;
+    focusInput: (e: MouseEvent) => void;
+};

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

@@ -0,0 +1,2 @@
+export { default as Modal } from './modal';
+export type { ModalInitialFocus, ModalPresetSize, ModalProps, ModalRole, ModalSize, ModalSlotProps, } from './types';

package/dist/components/modal/index.js

@@ -0,0 +1,2 @@
+import { t as modal_default } from "../../modal.js";
+export { modal_default as Modal };

package/dist/components/modal/modal.d.ts

@@ -0,0 +1,42 @@
+import { ModalProps } from './types';
+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<ModalProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        footer?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: (evt: "update:open", value: boolean) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { OverlayProps } from '../overlay/types';
+export type ModalPresetSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export type ModalSize = ModalPresetSize | (string & {});
+export type ModalRole = 'dialog' | 'alertdialog';
+export type ModalInitialFocus = string | HTMLElement | Ref<HTMLElement | null | undefined>;
+export type ModalOverlayProps = Pick<OverlayProps, 'color' | 'opacity' | 'gradient' | 'blur'>;
+export interface ModalSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface ModalProps {
+    id?: string;
+    open?: boolean;
+    title?: string;
+    description?: string;
+    ariaLabel?: string;
+    closeLabel?: string;
+    role?: ModalRole;
+    size?: ModalSize;
+    initialFocus?: ModalInitialFocus | null;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    overlayProps?: ModalOverlayProps;
+    preventScroll?: boolean;
+    returnFocus?: boolean;
+    keepMounted?: boolean;
+}

package/dist/components/modal/useModal.d.ts

@@ -0,0 +1,29 @@
+import { CSSProperties } from 'vue';
+import { ModalProps, ModalRole, ModalSlotProps } from './types';
+export declare function useModal(props: Readonly<ModalProps>, emitOpenChange?: (open: boolean) => void): {
+    panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    modalId: import('vue').ComputedRef<string>;
+    titleId: import('vue').ComputedRef<string>;
+    descriptionId: import('vue').ComputedRef<string>;
+    role: import('vue').ComputedRef<ModalRole>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    shouldRender: import('vue').ComputedRef<boolean>;
+    hasHeader: import('vue').ComputedRef<boolean>;
+    hasFooter: import('vue').ComputedRef<boolean>;
+    showCloseButton: import('vue').ComputedRef<boolean | undefined>;
+    headerId: import('vue').ComputedRef<string | undefined>;
+    ariaLabelledby: import('vue').ComputedRef<string | undefined>;
+    ariaDescribedby: import('vue').ComputedRef<string | undefined>;
+    ariaLabel: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    stateClass: import('vue').ComputedRef<{
+        'rp-modal--closable': boolean | undefined;
+        'rp-modal--headerless': boolean;
+    }>;
+    slotProps: import('vue').ComputedRef<ModalSlotProps>;
+    openModal: () => void;
+    closeModal: () => void;
+    toggleModal: () => void;
+    onOverlayClick: (event: MouseEvent) => void;
+};

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

@@ -0,0 +1,2 @@
+export { default as Overlay } from './overlay';
+export type { OverlayBlur, OverlayProps, OverlayZIndex } from './types';

package/dist/components/overlay/index.js

@@ -0,0 +1,2 @@
+import { t as overlay_default } from "../../overlay.js";
+export { overlay_default as Overlay };

package/dist/components/overlay/overlay.d.ts

@@ -0,0 +1,19 @@
+import { OverlayProps } from './types';
+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<OverlayProps> & (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>>;
+};
+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/overlay/types.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'vue';
+export type OverlayZIndex = CSSProperties['zIndex'];
+export type OverlayBlur = number | string;
+export interface OverlayProps {
+    color?: string;
+    opacity?: number;
+    gradient?: string;
+    blur?: OverlayBlur;
+    zIndex?: OverlayZIndex;
+    interactive?: boolean;
+    disabled?: boolean;
+}

package/dist/components/overlay/useOverlay.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'vue';
+import { OverlayProps } from './types';
+export declare function useOverlay(props: Readonly<OverlayProps>): {
+    isRendered: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties>;
+};

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

@@ -0,0 +1,2 @@
+export { default as Popover } from './popover';
+export type { PopoverContentSlotProps, PopoverOffset, PopoverOffsetOptions, PopoverPlacement, PopoverProps, PopoverRole, PopoverSlotProps, PopoverTarget, PopoverTriggerProps, } from './types';

package/dist/components/popover/index.js

@@ -0,0 +1,2 @@
+import { t as popover_default } from "../../popover.js";
+export { popover_default as Popover };

package/dist/components/popover/popover.d.ts

@@ -0,0 +1,43 @@
+import { PopoverProps } from './types';
+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<PopoverProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            triggerProps: import('./types').PopoverTriggerProps;
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        content?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: (evt: "update:open", value: boolean) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,43 @@
+import { Ref } from 'vue';
+export type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type PopoverTarget = string | HTMLElement | Ref<HTMLElement | null | undefined>;
+export interface PopoverOffsetOptions {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+export type PopoverOffset = number | PopoverOffsetOptions;
+export type PopoverRole = 'dialog';
+export interface PopoverTriggerProps {
+    'aria-controls'?: string;
+    'aria-expanded'?: boolean;
+    'aria-haspopup'?: PopoverRole;
+    onClick: (event: MouseEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface PopoverSlotProps {
+    triggerProps: PopoverTriggerProps;
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface PopoverContentSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface PopoverProps {
+    id?: string;
+    target?: PopoverTarget | null;
+    placement?: PopoverPlacement;
+    offset?: PopoverOffset;
+    open?: boolean;
+    disabled?: boolean;
+    role?: PopoverRole;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    closeOnOutsideClick?: boolean;
+    closeOnEscape?: boolean;
+}

package/dist/components/popover/usePopover.d.ts

@@ -0,0 +1,23 @@
+import { CSSProperties } from 'vue';
+import { PopoverContentSlotProps, PopoverProps, PopoverSlotProps, PopoverTriggerProps } from './types';
+export declare function usePopover(props: Readonly<PopoverProps>, emitOpenChange?: (open: boolean) => void): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    popoverId: import('vue').ComputedRef<string>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    isVisible: import('vue').ComputedRef<boolean>;
+    isTargetMode: import('vue').ComputedRef<boolean>;
+    popoverRole: import('vue').ComputedRef<"dialog">;
+    ariaLabel: import('vue').ComputedRef<string | undefined>;
+    ariaLabelledby: import('vue').ComputedRef<string | undefined>;
+    ariaDescribedby: import('vue').ComputedRef<string | undefined>;
+    shouldRenderContent: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    triggerProps: import('vue').ComputedRef<PopoverTriggerProps>;
+    slotProps: import('vue').ComputedRef<PopoverSlotProps>;
+    contentSlotProps: import('vue').ComputedRef<PopoverContentSlotProps>;
+    openPopover: () => void;
+    closePopover: () => void;
+    togglePopover: () => void;
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+};

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

@@ -0,0 +1,6 @@
+export { default as Tabs } from './tabs';
+export { default as TabsContent } from './tabs-content';
+export { default as TabsList } from './tabs-list';
+export { default as TabsTrigger } from './tabs-trigger';
+export { useTabs, useTabsContent, useTabsList, useTabsTrigger } from './useTabs';
+export type { TabsActivationMode, TabsContentProps, TabsContentRootProps, TabsContentSlotProps, TabsListProps, TabsListRootProps, TabsListSlotProps, TabsOrientation, TabsPlacement, TabsProps, TabsRootProps, TabsSlotProps, TabsState, TabsSize, TabsTriggerAlign, TabsTriggerProps, TabsTriggerRootProps, TabsTriggerSlotProps, TabsValue, TabsVariant, UseTabsContentReturn, UseTabsListReturn, UseTabsReturn, UseTabsTriggerReturn, } from './types';

package/dist/components/tabs/index.js

@@ -0,0 +1,2 @@
+import { a as useTabs, c as useTabsTrigger, i as tabs_default, n as tabs_list_default, o as useTabsContent, r as tabs_content_default, s as useTabsList, t as tabs_trigger_default } from "../../tabs.js";
+export { tabs_default as Tabs, tabs_content_default as TabsContent, tabs_list_default as TabsList, tabs_trigger_default as TabsTrigger, useTabs, useTabsContent, useTabsList, useTabsTrigger };

package/dist/components/tabs/tabs-content.d.ts

@@ -0,0 +1,24 @@
+import { TabsContentProps } from './types';
+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<TabsContentProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: import('./types').TabsValue;
+            selected: boolean;
+        }) => any;
+    };
+    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/tabs/tabs-list.d.ts

@@ -0,0 +1,26 @@
+import { TabsListProps } from './types';
+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<TabsListProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            disabled: boolean;
+            variant: import('./types').TabsVariant;
+            orientation: import('./types').TabsOrientation;
+            placement: import('./types').TabsPlacement;
+        }) => any;
+    };
+    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/tabs/tabs-trigger.d.ts

@@ -0,0 +1,29 @@
+import { TabsTriggerProps } from './types';
+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<TabsTriggerProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: import('./types').TabsValue;
+            selected: boolean;
+            size: import('./types').TabsSize;
+            variant: import('./types').TabsVariant;
+            disabled: boolean;
+            align: import('./types').TabsTriggerAlign;
+            select: () => void;
+        }) => any;
+    };
+    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/tabs/tabs.d.ts

@@ -0,0 +1,31 @@
+import { TabsProps, TabsValue } from './types';
+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<TabsProps & {
+        "onUpdate:modelValue"?: ((value: TabsValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: TabsValue | null;
+            size: import('./types').TabsSize;
+            variant: import('./types').TabsVariant;
+            disabled: boolean;
+            placement: import('./types').TabsPlacement;
+            align: import('./types').TabsTriggerAlign;
+            select: (value: TabsValue) => void;
+        }) => any;
+    };
+    emit: (evt: "update:modelValue", value: TabsValue) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};