@volverjs/ui-vue 0.0.13 → 0.0.14

package/dist/components/common/HintSlot.d.ts

@@ -0,0 +1,57 @@
+import type { ExtractPropTypes, Ref, Slots } from 'vue';
+export type HintSlotProps = Readonly<ExtractPropTypes<{
+    hintLabel: {
+        type: StringConstructor;
+        default: '';
+        required: true;
+    };
+    modelValue: unknown;
+    valid: BooleanConstructor;
+    validLabel: (StringConstructor | ArrayConstructor)[];
+    invalid: BooleanConstructor;
+    invalidLabel: (StringConstructor | ArrayConstructor)[];
+    loading: BooleanConstructor;
+    loadingLabel: StringConstructor;
+}>>;
+/**
+ * Return a vue component (HintSlot) to render and manage hint, errors, valid, loading state and messages
+ * @param {HintSlotProps} propsOrRef vue props
+ * @param {Slots} slots vue slots
+ * @returns {Component} vue component
+ */
+export declare function HintSlotFactory(propsOrRef: HintSlotProps | Ref<HintSlotProps>, slots: Slots): {
+    hasInvalidLabelOrSlot: globalThis.ComputedRef<boolean>;
+    hasHintLabelOrSlot: globalThis.ComputedRef<boolean>;
+    hasValidLabelOrSlot: globalThis.ComputedRef<boolean>;
+    hasLoadingLabelOrSlot: globalThis.ComputedRef<boolean>;
+    hintSlotScope: globalThis.ComputedRef<{
+        modelValue: unknown;
+        valid: boolean;
+        invalid: boolean;
+        loading: boolean;
+    }>;
+    HintSlot: import("vue").DefineComponent<ExtractPropTypes<{
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        isVisible: globalThis.ComputedRef<boolean>;
+        invalidLabel: globalThis.ComputedRef<string | undefined>;
+        validLabel: globalThis.ComputedRef<string | undefined>;
+        loadingLabel: globalThis.ComputedRef<string | undefined>;
+        hintLabel: globalThis.ComputedRef<string>;
+        hasInvalidLabelOrSlot: globalThis.ComputedRef<boolean>;
+        hasValidLabelOrSlot: globalThis.ComputedRef<boolean>;
+        hasLoadingLabelOrSlot: globalThis.ComputedRef<boolean>;
+        hasHintLabelOrSlot: globalThis.ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        tag: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export default HintSlotFactory;

package/dist/components/common/VvInputClearAction.d.ts

@@ -0,0 +1,52 @@
+import type { PropType } from 'vue';
+import type { VvIconProps } from '../VvIcon';
+declare const _default: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text" | "select">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: PropType<string | VvIconProps>;
+        default: string;
+    };
+}>, {
+    hasIcon: globalThis.ComputedRef<VvIconProps | undefined>;
+    onClick: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "clear"[], "clear", import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text" | "select">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: PropType<string | VvIconProps>;
+        default: string;
+    };
+}>> & Readonly<{
+    onClear?: ((...args: any[]) => any) | undefined;
+}>, {
+    icon: string | VvIconProps;
+    label: string;
+    disabled: boolean;
+    inputType: "select" | "input-text";
+}, {}, {
+    VvIcon: import("vue").DefineComponent<VvIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VvIconProps> & Readonly<{}>, {
+        prefix: import("../VvIcon").IconPrefix | string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/common/VvInputPasswordAction.d.ts

@@ -0,0 +1,71 @@
+import type { VvIconProps } from '../VvIcon';
+declare const _default: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelShow: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelHide: {
+        type: StringConstructor;
+        default: string;
+    };
+    iconShow: {
+        type: PropType<string | VvIconProps>;
+        default: "eye-on";
+    };
+    iconHide: {
+        type: PropType<string | VvIconProps>;
+        default: "eye-off";
+    };
+}>, {
+    active: globalThis.Ref<boolean, boolean>;
+    activeIcon: globalThis.ComputedRef<string | VvIconProps>;
+    hasIcon: globalThis.ComputedRef<VvIconProps | undefined>;
+    onClick: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "toggle-password"[], "toggle-password", import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelShow: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelHide: {
+        type: StringConstructor;
+        default: string;
+    };
+    iconShow: {
+        type: PropType<string | VvIconProps>;
+        default: "eye-on";
+    };
+    iconHide: {
+        type: PropType<string | VvIconProps>;
+        default: "eye-off";
+    };
+}>> & Readonly<{
+    "onToggle-password"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    inputType: "input-text";
+    labelShow: string;
+    labelHide: string;
+    iconShow: string | VvIconProps;
+    iconHide: string | VvIconProps;
+}, {}, {
+    VvIcon: import("vue").DefineComponent<VvIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VvIconProps> & Readonly<{}>, {
+        prefix: import("../VvIcon").IconPrefix | string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/common/VvInputStepAction.d.ts

@@ -0,0 +1,50 @@
+declare const _default: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+    };
+    mode: {
+        type: StringConstructor;
+        validator: (v: string) => boolean;
+        default: string;
+    };
+}>, {
+    isUp: globalThis.ComputedRef<boolean>;
+    onClick: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("step-up" | "step-down")[], "step-up" | "step-down", import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    inputType: {
+        type: PropType<"input-text">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+    };
+    mode: {
+        type: StringConstructor;
+        validator: (v: string) => boolean;
+        default: string;
+    };
+}>> & Readonly<{
+    "onStep-up"?: ((...args: any[]) => any) | undefined;
+    "onStep-down"?: ((...args: any[]) => any) | undefined;
+}>, {
+    mode: string;
+    disabled: boolean;
+    inputType: "input-text";
+}, {}, {
+    VvIcon: import("vue").DefineComponent<import("../VvIcon/index.js").VvIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("../VvIcon/index.js").VvIconProps> & Readonly<{}>, {
+        prefix: import("../VvIcon/index.js").IconPrefix | string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/index.d.ts

@@ -0,0 +1,34 @@
+export { default as VvAccordion } from './VvAccordion/VvAccordion.vue';
+export { default as VvAccordionGroup } from './VvAccordionGroup/VvAccordionGroup.vue';
+export { default as VvAction } from './VvAction/VvAction.vue';
+export { default as VvAlert } from './VvAlert/VvAlert.vue';
+export { default as VvAlertGroup } from './VvAlertGroup/VvAlertGroup.vue';
+export { default as VvAvatar } from './VvAvatar/VvAvatar.vue';
+export { default as VvAvatarGroup } from './VvAvatarGroup/VvAvatarGroup.vue';
+export { default as VvBadge } from './VvBadge/VvBadge.vue';
+export { default as VvBreadcrumb } from './VvBreadcrumb/VvBreadcrumb.vue';
+export { default as VvButton } from './VvButton/VvButton.vue';
+export { default as VvButtonGroup } from './VvButtonGroup/VvButtonGroup.vue';
+export { default as VvCard } from './VvCard/VvCard.vue';
+export { default as VvCheckbox } from './VvCheckbox/VvCheckbox.vue';
+export { default as VvCheckboxGroup } from './VvCheckboxGroup/VvCheckboxGroup.vue';
+export { default as VvCombobox } from './VvCombobox/VvCombobox.vue';
+export { default as VvDialog } from './VvDialog/VvDialog.vue';
+export { default as VvDropdown } from './VvDropdown/VvDropdown.vue';
+export { default as VvDropdownAction } from './VvDropdown/VvDropdownAction.vue';
+export { default as VvDropdownItem } from './VvDropdown/VvDropdownItem.vue';
+export { default as VvDropdownOptgroup } from './VvDropdown/VvDropdownOptgroup.vue';
+export { default as VvDropdownOption } from './VvDropdown/VvDropdownOption.vue';
+export { default as VvIcon } from './VvIcon/VvIcon.vue';
+export { default as VvInputFile } from './VvInputFile/VvInputFile.vue';
+export { default as VvInputText } from './VvInputText/VvInputText.vue';
+export { default as VvNav } from './VvNav/VvNav.vue';
+export { default as VvNavItem } from './VvNav/VvNavItem.vue';
+export { default as VvNavSeparator } from './VvNav/VvNavSeparator.vue';
+export { default as VvProgress } from './VvProgress/VvProgress.vue';
+export { default as VvRadio } from './VvRadio/VvRadio.vue';
+export { default as VvRadioGroup } from './VvRadioGroup/VvRadioGroup.vue';
+export { default as VvSelect } from './VvSelect/VvSelect.vue';
+export { default as VvTab } from './VvTab/VvTab.vue';
+export { default as VvTextarea } from './VvTextarea/VvTextarea.vue';
+export { default as VvTooltip } from './VvTooltip/VvTooltip.vue';

package/dist/composables/alert/useAlerInject.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Injects alert group
+ */
+export declare function useInjectedAlertGroup(): import("../..").AlertGroupState;

package/dist/composables/alert/useAlert.d.ts

@@ -0,0 +1,92 @@
+import type { Alert } from '@/types/alert';
+type AlertInGroup = Alert & {
+    timestamp: number;
+    group: string;
+};
+/**
+ * @description Composable to access alert groups, alerts and functions to add, remove and get alerts by group.
+ * @example
+ *  const { groups, alerts, addAlert, removeAlert, getAlerts } = useAlert()
+ *  addAlert({
+ *      title: 'Success!',
+ *      modifiers: 'success',
+ *  })
+ *
+ *  `<vv-alert-group :items="alerts" :onClose="removeAlert" />`
+ *
+ *  @returns  {
+ *      alerts: ComputedRef<Alert[]> reactive list of alerts default group,
+ *      groups: ReactiveRef<Map<string, Map<string, Alert>>>,
+ *      addAlert: Function to add alert,
+ *      removeAlert: Function to remove alert,
+ *      getAlerts: Function to get alerts by group
+ *  } the reactive list of alerts, groups, addAlert, removeAlert and getAlerts functions
+ */
+export declare function useAlert(): {
+    groups: import("vue").Reactive<Map<string, Map<string, AlertInGroup>>>;
+    alerts: globalThis.ComputedRef<{
+        id: string | number;
+        title?: string | undefined;
+        icon?: string | {
+            name: string;
+            color?: string | undefined;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            provider?: string | undefined;
+            prefix?: (import("../../components/VvIcon").IconPrefix | string) | undefined;
+            src?: string | undefined;
+            horizontalFlip?: boolean | undefined;
+            verticalFlip?: boolean | undefined;
+            flip?: string | undefined;
+            mode?: import("@iconify/vue").IconifyRenderMode | undefined;
+            inline?: boolean | undefined;
+            rotate?: number | string | undefined;
+            onLoad?: ((icon: import("@iconify/types").IconifyIcon) => void) | undefined;
+            svg?: string | undefined;
+            modifiers?: string | string[] | undefined;
+        } | undefined;
+        content?: string | undefined;
+        footer?: string | undefined;
+        modifiers?: (import("@/types/alert").AlertModifier | import("@/types/alert").AlertModifier[]) | undefined;
+        dismissable?: boolean | undefined;
+        autoClose?: number | undefined;
+        closeLabel?: string | undefined;
+        role?: import("@/constants").AlertRole | undefined;
+        timestamp: number;
+        group: string;
+    }[]>;
+    addAlert: ({ id, group, title, icon, content, footer, modifiers, dismissable, autoClose, timestamp, }?: Partial<AlertInGroup>) => void;
+    removeAlert: (id: string | number, group?: string) => void;
+    getAlerts: (group?: string) => globalThis.ComputedRef<{
+        id: string | number;
+        title?: string | undefined;
+        icon?: string | {
+            name: string;
+            color?: string | undefined;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            provider?: string | undefined;
+            prefix?: (import("../../components/VvIcon").IconPrefix | string) | undefined;
+            src?: string | undefined;
+            horizontalFlip?: boolean | undefined;
+            verticalFlip?: boolean | undefined;
+            flip?: string | undefined;
+            mode?: import("@iconify/vue").IconifyRenderMode | undefined;
+            inline?: boolean | undefined;
+            rotate?: number | string | undefined;
+            onLoad?: ((icon: import("@iconify/types").IconifyIcon) => void) | undefined;
+            svg?: string | undefined;
+            modifiers?: string | string[] | undefined;
+        } | undefined;
+        content?: string | undefined;
+        footer?: string | undefined;
+        modifiers?: (import("@/types/alert").AlertModifier | import("@/types/alert").AlertModifier[]) | undefined;
+        dismissable?: boolean | undefined;
+        autoClose?: number | undefined;
+        closeLabel?: string | undefined;
+        role?: import("@/constants").AlertRole | undefined;
+        timestamp: number;
+        group: string;
+    }[]>;
+};
+export {};

package/dist/composables/alert/useAlertProvide.d.ts

@@ -0,0 +1,10 @@
+import type { Ref } from 'vue';
+/**
+ * Share the alert group name with all its children.
+ * @param {Ref<string | undefined>} name the alert group name
+ */
+export declare function useAlertProvideGroup({ name, }: {
+    name: Ref<string | undefined>;
+}): import("mitt").Emitter<{
+    close: string;
+}>;

package/dist/composables/dropdown/useDropdownContextmenu.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from 'vue';
+import type VvDropdown from '@/components/VvDropdown/VvDropdown.vue';
+export declare function useDropdownContextmenu(dropdownEl: Ref<typeof VvDropdown>, targetEl?: Ref<HTMLElement> | HTMLElement): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    getBoundingClientRect: () => {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    onContextmenu: (event: MouseEvent) => void;
+    onScroll: (event: HTMLElementEventMap["scroll"]) => void;
+};

package/dist/composables/dropdown/useDropdownInject.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Injects dropdown reference and the event bus
+ */
+export declare function useInjectedDropdownTrigger(): import("../../constants").DropdownTriggerState;
+/**
+ * Injects dropdown item role
+ */
+export declare function useInjectedDropdownItem(): import("../../constants").DropdownItemState;
+/**
+ * Injects dropdown action role
+ */
+export declare function useInjectedDropdownAction(): import("../../constants").DropdownActionState;

package/dist/composables/dropdown/useDropdownProvide.d.ts

@@ -0,0 +1,40 @@
+import type { Ref } from 'vue';
+import type { DropdownItemState } from '../../constants';
+import { DropdownItemRole, DropdownRole } from '../../constants';
+/**
+ * Share the dropdown reference and the event bus with all its children.
+ * @param {Ref<HTMLElement | null>} reference the dropdown reference
+ */
+export declare function useDropdownProvideTrigger({ reference, id, expanded, aria, }: {
+    reference: Ref<HTMLElement | null | undefined>;
+    id: Ref<string | number>;
+    expanded: Ref<boolean>;
+    aria: Ref<{
+        'aria-controls': string;
+        'aria-haspopup': boolean;
+        'aria-expanded': boolean;
+    }>;
+}): {
+    bus: import("mitt").Emitter<{
+        click: Event;
+        mouseover: Event;
+        mouseleave: Event;
+    }>;
+    component: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+/**
+ * Share the dropdown item role with all its children.
+ * @param {Ref<string>} role the dropdown item role
+ */
+export declare function useDropdownProvideItem({ role, ...others }: Omit<DropdownItemState, 'role'> & {
+    role: Ref<`${DropdownRole}`>;
+}): {
+    itemRole: globalThis.ComputedRef<DropdownItemRole>;
+};
+/**
+ * Share the dropdown item role with all its children.
+ * @param {Ref<string>} role the dropdown item role
+ */
+export declare function useDropdownProvideAction({ expanded, }: {
+    expanded?: Ref<boolean>;
+}): void;

package/dist/composables/dropdown/useDropdownVirtualElement.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type VvDropdown from '@/components/VvDropdown/VvDropdown.vue';
+export declare function useDropdownVirtualElement(dropdownEl: Ref<typeof VvDropdown>): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    getBoundingClientRect: () => {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    onScroll: (event: HTMLElementEventMap["scroll"]) => void;
+};

package/dist/composables/group/useGroupStateInject.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey } from 'vue';
+/**
+ * Injects a group state
+ */
+export declare function useGroupStateInject<GroupStateType>(groupKey: InjectionKey<GroupStateType>): {
+    group: GroupStateType | undefined;
+    isInGroup: globalThis.ComputedRef<boolean>;
+    getGroupOrLocalRef: <TProps extends object, TName extends keyof GroupStateType>(propName: TName, props: TProps, emit?: (event: string, ...args: unknown[]) => void) => GroupStateType[TName];
+};

package/dist/composables/group/useGroupStateProvide.d.ts

@@ -0,0 +1,6 @@
+import type { Emitter } from 'mitt';
+import type { InjectionKey, Ref } from 'vue';
+/**
+ * Share part of the state of the component with all its children.
+ */
+export declare function useGroupStateProvide<TGroupState extends Record<string, Ref<unknown> | Emitter<any>>>(key: InjectionKey<TGroupState>, groupState: TGroupState): void;

package/dist/composables/index.d.ts

@@ -0,0 +1,5 @@
+export { useAlert } from './alert/useAlert';
+export { useDropdownContextmenu } from './dropdown/useDropdownContextmenu';
+export { useDropdownVirtualElement } from './dropdown/useDropdownVirtualElement';
+export { useBlurhash } from './useBlurhash';
+export { useVirtualScroll } from './useVirtualScroll';

package/dist/composables/useBlurhash.d.ts

@@ -0,0 +1,7 @@
+declare function loadImage(src: string): Promise<CanvasImageSource>;
+export declare function useBlurhash(): {
+    encode: (file: File) => Promise<string | undefined>;
+    decode: (blurhash: string, width: number, height: number, punch?: number | undefined) => Promise<Uint8ClampedArray<ArrayBufferLike>>;
+    loadImage: typeof loadImage;
+};
+export {};

package/dist/composables/useComponentFocus.d.ts

@@ -0,0 +1,4 @@
+import type { MaybeElement, MaybeElementRef } from '@vueuse/core';
+export declare function useComponentFocus(inputTemplateRef: MaybeElementRef<MaybeElement>, emit: ((name: 'blur', ...args: any[]) => void) & ((name: 'focus', ...args: any[]) => void) & ((name: any, ...args: any[]) => void)): {
+    focused: globalThis.WritableComputedRef<boolean, boolean>;
+};

package/dist/composables/useComponentIcon.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+import type { VvIconProps } from '../components/VvIcon';
+export declare function useComponentIcon(icon?: Ref<string | VvIconProps | undefined>, iconPosition?: Ref<string | undefined>): {
+    hasIcon: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconLeft: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconRight: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconTop: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconBottom: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconBefore: globalThis.ComputedRef<VvIconProps | undefined>;
+    hasIconAfter: globalThis.ComputedRef<VvIconProps | undefined>;
+};

package/dist/composables/useDebouncedInput.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+export declare function useDebouncedInput(modelValue: Ref | undefined, emit: (event: string, value: string | number) => void, ms?: string | number, { getter, setter, }?: {
+    getter?: (value: string | number) => string | number;
+    setter?: (value: string | number) => string | number;
+}): Ref;

package/dist/composables/useDefaults.d.ts

@@ -0,0 +1,2 @@
+import type { ExtractPropTypes } from 'vue';
+export declare function useDefaults<Definition>(componentName: string, propsDefinition: Definition, props: Readonly<ExtractPropTypes<Definition>>): globalThis.ComputedRef<Readonly<ExtractPropTypes<Definition>>>;

package/dist/composables/useModifiers.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useModifiers(prefix: string, modifiers?: Ref<string | string[] | unknown | unknown[] | undefined>, others?: Ref<Record<string, boolean>>): globalThis.ComputedRef<Record<string, boolean>>;

package/dist/composables/useOptions.d.ts

@@ -0,0 +1,8 @@
+import type { Option } from '../types/generic';
+export declare function useOptions(props: any): {
+    options: globalThis.Ref<any, any>;
+    getOptionLabel: <T extends string | Option>(option: T) => string;
+    getOptionValue: <T extends string | Option>(option: T) => any;
+    isOptionDisabled: <T extends string | Option>(option: T) => boolean;
+    getOptionGrouped: <T extends string | Option>(option: T) => T[];
+};

package/dist/composables/usePersistence.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+import { StorageType } from '@/constants';
+export declare function usePersistence<T>(storageKey: Ref<string | undefined> | undefined, storageType?: Ref<`${StorageType}`> | `${StorageType}`, defaultValue?: T): Ref<T | undefined, T | undefined>;

package/dist/composables/useTextCount.d.ts

@@ -0,0 +1,10 @@
+import type { Ref } from 'vue';
+export declare function useTextCount(text: Ref<string | undefined | null> | string, options?: {
+    mode?: string | boolean;
+    upperLimit?: number;
+    lowerLimit?: number;
+}): {
+    length: globalThis.ComputedRef<number>;
+    gap: globalThis.ComputedRef<number>;
+    formatted: globalThis.ComputedRef<string | number | undefined>;
+};

package/dist/composables/useUniqueId.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useUniqueId(id?: Ref<string | number | undefined>): globalThis.ComputedRef<string>;

package/dist/composables/useVirtualScroll.d.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'vue';
+export type { ScrollToOptions } from '@tanstack/vue-virtual';
+export declare function useVirtualScroll(settings: {
+    scrollEl: HTMLElement | null | Ref<HTMLElement | null>;
+    count: number | Ref<number>;
+    estimateSize: string | number | ((index: number) => number) | Ref<string | number | ((index: number) => number)>;
+    getItemKey?: (index: number) => number | string | bigint;
+    overscan?: string | number | Ref<string | number>;
+    horizontal?: boolean | Ref<boolean>;
+}): {
+    virtualizer: Ref<import("@tanstack/vue-virtual").Virtualizer<HTMLElement, Element>, import("@tanstack/vue-virtual").Virtualizer<HTMLElement, Element>>;
+    virtualItems: globalThis.ComputedRef<import("@tanstack/vue-virtual").VirtualItem[]>;
+    virtualItemsLength: globalThis.ComputedRef<number>;
+    firstVirtualItem: globalThis.ComputedRef<import("@tanstack/vue-virtual").VirtualItem>;
+    lastVirtualItem: globalThis.ComputedRef<import("@tanstack/vue-virtual").VirtualItem>;
+    totalSize: globalThis.ComputedRef<number>;
+    startSpacer: globalThis.ComputedRef<{
+        show: boolean;
+        size: number;
+        style: {
+            width: string;
+        } | {
+            height: string;
+        };
+    }>;
+    endSpacer: globalThis.ComputedRef<{
+        show: boolean;
+        size: number;
+        style: {
+            width: string;
+        } | {
+            height: string;
+        };
+    }>;
+};

package/dist/composables/useVolver.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Injects volver
+ */
+export declare function useVolver(): import("..").Volver | undefined;