@volverjs/ui-vue 0.0.13 → 0.0.14

package/dist/Volver.d.ts

@@ -0,0 +1,121 @@
+import type { IconifyIcon, IconifyJSON, PartialIconifyAPIConfig } from '@iconify/vue';
+import type { Component, Directive, Plugin, Ref } from 'vue';
+export declare function useDefaultProps(component: Component, defaults?: Record<string, unknown>, name?: string): Component;
+export type DefaultOptions = Record<string, Record<string, unknown>>;
+export type VolverExperimentalFeatures = {
+    /**
+     * Force suggestions in `VvInputText` and `VvTextarea` component
+     */
+    forceInputSuggestions?: boolean;
+};
+export type VolverOptions = {
+    /**
+     * If true set "fetchOptions" with credentials: 'include'
+     */
+    fetchWithCredentials?: boolean;
+    /**
+     * Optional fetch params
+     */
+    fetchOptions?: RequestInit;
+    /**
+     * Array of iconify collections that will be added during plugin install
+     * @see https://docs.iconify.design/types/iconify-json.html
+     */
+    iconsCollections?: IconifyJSON[];
+    /**
+     * Set true inside nuxt
+     */
+    nuxt?: boolean;
+    /**
+     * Default iconify provider
+     * @see https://docs.iconify.design/icon-components/vue/add-collection.html
+     * @default 'vv'
+     */
+    iconsProvider?: string;
+    /**
+     * Components to install
+     */
+    components?: Record<string, Component>;
+    /**
+     * Alias to install
+     */
+    aliases?: Record<string, Component>;
+    /**
+     * Directives to install
+     */
+    directives?: Record<string, Directive>;
+    /**
+     * Default props for components
+     */
+    defaults?: DefaultOptions;
+    /**
+     * Experimental features
+     */
+    experimentalFeatures?: VolverExperimentalFeatures;
+};
+export interface VolverInterface {
+    /**
+     * @param {string} src Icon source path (url)
+     * @param {RequestInit} options
+     * @returns {Promise<string | undefined>} String SVG if exist
+     */
+    fetchIcon: (src: string, options?: RequestInit) => Promise<string | undefined>;
+    /**
+     * Add iconify collection to library
+     * @see https://docs.iconify.design/icon-components/vue/add-collection.html
+     * @param {IconifyJSON} collection
+     * @param {string} providerName Optional provider name
+     */
+    addCollection: (collection: IconifyJSON, providerName?: string) => boolean;
+    /**
+     * Add icon to collection
+     * @see https://docs.iconify.design/icon-components/vue/add-icon.html
+     * @param {string} name
+     * @param {IconifyIcon} data
+     * @returns {boolean} true on success, false if something is wrong with data
+     */
+    addIcon: (name: string, data: IconifyIcon) => boolean;
+    /**
+     * Add custom config for icons provider
+     * @param {string} provider
+     * @param {PartialIconifyAPIConfig} customConfig
+     * @returns {boolean} true on success, false if something is wrong with data
+     */
+    addIconsAPIProvider: (provider: string, customConfig: PartialIconifyAPIConfig) => boolean;
+    /**
+     * Current provider
+     */
+    iconsProvider: string;
+    /**
+     * Array of installed iconify collections
+     * @see https://docs.iconify.design/types/iconify-json.html
+     */
+    iconsCollections: IconifyJSON[];
+    /**
+     * Set true inside nuxt
+     */
+    nuxt: boolean;
+    /**
+     * Components defaults options
+     */
+    defaults: Ref<DefaultOptions>;
+}
+export declare class Volver implements VolverInterface {
+    private _fetchOptions;
+    private _iconsCollections;
+    private _iconsProvider;
+    private _nuxt;
+    private _experimentalFeatures;
+    defaults: Ref<DefaultOptions>;
+    constructor({ fetchWithCredentials, fetchOptions, iconsProvider, nuxt, iconsCollections, defaults, experimentalFeatures, }?: VolverOptions);
+    get nuxt(): boolean;
+    get iconsProvider(): string;
+    get iconsCollections(): IconifyJSON[];
+    get experimentalFeatures(): VolverExperimentalFeatures;
+    addCollection(collection: IconifyJSON, providerName?: string): boolean;
+    addIcon(name: string, data: IconifyIcon): boolean;
+    addIconsAPIProvider(provider: string, customConfig: PartialIconifyAPIConfig): boolean;
+    fetchIcon(src: string, options?: RequestInit): Promise<string | undefined>;
+}
+declare const VolverPlugin: Plugin;
+export default VolverPlugin;

package/dist/components/VvAccordion/VvAccordion.vue.d.ts

@@ -0,0 +1,68 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    name: StringConstructor;
+    title: StringConstructor;
+    content: StringConstructor;
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disabled: BooleanConstructor;
+    not: BooleanConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+}>, {
+    /** Whether the accordion is expanded */
+    isExpanded: globalThis.Ref<boolean, boolean>;
+    /** Expand the accordion */
+    expand: () => void;
+    /** Collapse the accordion */
+    collapse: () => void;
+    /** Expand accordions in the same group */
+    groupExpand: (name?: string | string[]) => void;
+    /** Collapse accordions in the same group */
+    groupCollapse: (name?: string | string[]) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    name: StringConstructor;
+    title: StringConstructor;
+    content: StringConstructor;
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disabled: BooleanConstructor;
+    not: BooleanConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    modelValue: boolean;
+    modifiers: string | string[];
+    disabled: boolean;
+    not: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    summary?: (props: {
+        isExpanded: boolean;
+        expand: () => void;
+        collapse: () => void;
+        groupExpand: (name?: string | string[]) => void;
+        groupCollapse: (name?: string | string[]) => void;
+    }) => any;
+} & {
+    default?: (props: {
+        isExpanded: boolean;
+        expand: () => void;
+        collapse: () => void;
+        groupExpand: (name?: string | string[]) => void;
+        groupCollapse: (name?: string | string[]) => void;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,47 @@
+import type { ExtractPropTypes } from 'vue';
+import type { AccordionGroupState } from '../../types/group';
+export declare const VvAccordionProps: {
+    /**
+     * Accordion name
+     */
+    name: StringConstructor;
+    /**
+     * Header title
+     */
+    title: StringConstructor;
+    /**
+     * Content text
+     */
+    content: StringConstructor;
+    /**
+     * (Optional) Defines if item is open. Event "update:modelValue" is emitted on accordion header click
+     */
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     * If true, the accordion will be disabled
+     */
+    disabled: BooleanConstructor;
+    /**
+     * If true, the accordion will be opened by default
+     */
+    not: BooleanConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+};
+export declare const VvAccordionEvents: string[];
+export type VvAccordionPropsTypes = ExtractPropTypes<typeof VvAccordionProps>;
+/**
+ * Merges local and group props
+ */
+export declare function useGroupProps(props: VvAccordionPropsTypes): {
+    isInGroup: globalThis.ComputedRef<boolean>;
+    group: AccordionGroupState | undefined;
+    modifiers: globalThis.ComputedRef<string[]>;
+    disabled: globalThis.ComputedRef<boolean>;
+    bus: import("mitt").Emitter<import("../..").AccordionGroupBusEvents> | undefined;
+};

package/dist/components/VvAccordionGroup/VvAccordionGroup.vue.d.ts

@@ -0,0 +1,98 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string | string[] | undefined>;
+        default: undefined;
+    };
+    items: {
+        type: PropType<import(".").VvAccordionGroupItem[]>;
+        default: () => never[];
+    };
+    collapse: BooleanConstructor;
+    itemModifiers: {
+        type: PropType<string | string[]>;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+    not: BooleanConstructor;
+    storageType: {
+        type: PropType<`${import("../../constants").StorageType}`>;
+        default: import("../../constants").StorageType;
+        validator: (value: import("../../constants").StorageType) => boolean;
+    };
+    storageKey: StringConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+}>, {
+    /** Expanded accordions names */
+    expandedAccordions: globalThis.WritableComputedRef<Set<string>, Set<string>>;
+    /** Expand accordion by name, expand all if no name is provided */
+    expand: (name?: string | string[]) => void;
+    /** Collapse accordion by name, collapse all if no name is provided */
+    collapse: (name?: string | string[]) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string | string[] | undefined>;
+        default: undefined;
+    };
+    items: {
+        type: PropType<import(".").VvAccordionGroupItem[]>;
+        default: () => never[];
+    };
+    collapse: BooleanConstructor;
+    itemModifiers: {
+        type: PropType<string | string[]>;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+    not: BooleanConstructor;
+    storageType: {
+        type: PropType<`${import("../../constants").StorageType}`>;
+        default: import("../../constants").StorageType;
+        validator: (value: import("../../constants").StorageType) => boolean;
+    };
+    storageKey: StringConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    modelValue: string | string[] | undefined;
+    collapse: boolean;
+    modifiers: string | string[];
+    disabled: boolean;
+    not: boolean;
+    items: import(".").VvAccordionGroupItem[];
+    itemModifiers: string | string[];
+    storageType: "local" | "session";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    [x: `summary::${string}`]: ((props: {
+        isExpanded: boolean;
+        expand: () => void;
+        collapse: () => void;
+        groupExpand: (name?: string | string[]) => void;
+        groupCollapse: (name?: string | string[]) => void;
+    }) => any) | undefined;
+} & {
+    [x: `content::${string}`]: ((props: {
+        isExpanded: boolean;
+        expand: () => void;
+        collapse: () => void;
+        groupExpand: (name?: string | string[]) => void;
+        groupCollapse: (name?: string | string[]) => void;
+    }) => any) | undefined;
+} & {
+    default?: (props: {
+        expandedAccordions: Set<string>;
+        expand: (name?: string | string[]) => void;
+        collapse: (name?: string | string[]) => void;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,54 @@
+export interface VvAccordionGroupItem {
+    title: string;
+    content: string;
+    name?: string;
+    disabled?: boolean;
+    modifiers?: string | string[];
+}
+export declare const VvAccordionGroupProps: {
+    /**
+     * VModel
+     */
+    modelValue: {
+        type: PropType<string | string[] | undefined>;
+        default: undefined;
+    };
+    /**
+     * Accordion items
+     * @type VvAccordionGroupItem
+     */
+    items: {
+        type: PropType<VvAccordionGroupItem[]>;
+        default: () => never[];
+    };
+    /**
+     * If true, accordion items stay open when another item is opened
+     */
+    collapse: BooleanConstructor;
+    /**
+     * String or String[] of css classes (modifiers) that will be concatenated to prefix 'vv-accordion--'
+     */
+    itemModifiers: {
+        type: PropType<string | string[]>;
+        default: string;
+    };
+    /**
+     * If true, the accordion items will be disabled
+     */
+    disabled: BooleanConstructor;
+    /**
+     * If true, the accordion items will be opened by default
+     */
+    not: BooleanConstructor;
+    storageType: {
+        type: PropType<`${import("../../constants").StorageType}`>;
+        default: import("../../constants").StorageType;
+        validator: (value: import("../../constants").StorageType) => boolean;
+    };
+    storageKey: StringConstructor;
+    modifiers: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+};
+export declare const VvAccordionGroupEvents: string[];

package/dist/components/VvAction/VvAction.vue.d.ts

@@ -0,0 +1,110 @@
+import { ActionTag } from '../../constants';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    type: {
+        type: PropType<`${import("../../constants").ButtonType}`>;
+        default: import("../../constants").ButtonType;
+        validator: (value: import("../../constants").ButtonType) => boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultTag: {
+        type: StringConstructor;
+        default: ActionTag;
+    };
+    to: {
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+    href: StringConstructor;
+    target: StringConstructor;
+    rel: {
+        type: StringConstructor;
+        default: string;
+    };
+    current: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pressed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    /** Reference to the root element */
+    $el: globalThis.Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    type: {
+        type: PropType<`${import("../../constants").ButtonType}`>;
+        default: import("../../constants").ButtonType;
+        validator: (value: import("../../constants").ButtonType) => boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultTag: {
+        type: StringConstructor;
+        default: ActionTag;
+    };
+    to: {
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+    href: StringConstructor;
+    target: StringConstructor;
+    rel: {
+        type: StringConstructor;
+        default: string;
+    };
+    current: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pressed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    label: string | number;
+    disabled: boolean;
+    type: "button" | "submit" | "reset";
+    ariaLabel: string;
+    defaultTag: string;
+    rel: string;
+    current: boolean;
+    active: boolean;
+    pressed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,45 @@
+export declare const VvActionEvents: string[];
+export declare const VvActionProps: {
+    type: {
+        type: PropType<`${import("../../constants").ButtonType}`>;
+        default: import("../../constants").ButtonType;
+        validator: (value: import("../../constants").ButtonType) => boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultTag: {
+        type: StringConstructor;
+        default: import("../../constants").ActionTag;
+    };
+    to: {
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+    href: StringConstructor;
+    target: StringConstructor;
+    rel: {
+        type: StringConstructor;
+        default: string;
+    };
+    current: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pressed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};

package/dist/components/VvAlert/VvAlert.vue.d.ts

@@ -0,0 +1,124 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+    modifiers: {
+        type: PropType<import("../..").AlertModifier | import("../..").AlertModifier[]>;
+        default: undefined;
+    };
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoClose: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    content: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    footer: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    role: {
+        type: PropType<`${import("../../constants").AlertRole}`>;
+        default: import("../../constants").AlertRole;
+    };
+    icon: {
+        type: PropType<string | import("../VvIcon").VvIconProps>;
+        default: undefined;
+    };
+    iconPosition: {
+        type: PropType<`${import("../../constants").Position}`>;
+        default: import("../../constants").Position;
+        validation: (value: import("../../constants").Position) => boolean;
+    };
+    id: (NumberConstructor | StringConstructor)[];
+}>, {
+    /** Close the alert */
+    close: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    modifiers: {
+        type: PropType<import("../..").AlertModifier | import("../..").AlertModifier[]>;
+        default: undefined;
+    };
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoClose: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    content: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    footer: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    role: {
+        type: PropType<`${import("../../constants").AlertRole}`>;
+        default: import("../../constants").AlertRole;
+    };
+    icon: {
+        type: PropType<string | import("../VvIcon").VvIconProps>;
+        default: undefined;
+    };
+    iconPosition: {
+        type: PropType<`${import("../../constants").Position}`>;
+        default: import("../../constants").Position;
+        validation: (value: import("../../constants").Position) => boolean;
+    };
+    id: (NumberConstructor | StringConstructor)[];
+}>> & Readonly<{}>, {
+    title: string;
+    icon: string | import("../VvIcon").VvIconProps;
+    content: string;
+    footer: string;
+    modifiers: string | string[];
+    dismissable: boolean;
+    autoClose: number;
+    closeLabel: string;
+    role: "alert" | "alertdialog";
+    iconPosition: "before" | "after";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    header?: (props: {}) => any;
+} & {
+    'title::before'?: (props: {}) => any;
+} & {
+    title?: (props: {}) => any;
+} & {
+    'title::after'?: (props: {}) => any;
+} & {
+    close?: (props: {
+        close: () => void;
+    }) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};