@rotki/ui-library 0.15.0 → 1.0.0-beta.1

package/dist/components/tables/RuiTableHead.vue.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Represents a sortable column name for a given type.
+ * The column name must be a key of the passed data object type.
+ * @template T - The type of the data in the column.
+ */
+export type TableRowKey<T> = keyof T extends string ? keyof T : never;
+export interface BaseTableColumn<T> {
+    key: TableRowKey<T> | string;
+    sortable?: boolean;
+    direction?: 'asc' | 'desc';
+    align?: 'start' | 'center' | 'end';
+    class?: string;
+    cellClass?: string;
+    colspan?: string | number;
+    rowspan?: string | number;
+    [key: string]: any;
+}
+/**
+ * Represents a sortable table column.
+ * This is used to ensure that when using sortable with a true value,
+ * the key matches to an actual property of the object passed.
+ *
+ * @template T - The type of data in the table column.
+ */
+export interface SortableTableColumn<T> extends BaseTableColumn<T> {
+    sortable: true;
+}
+/**
+ * An interface representing a column in a table that cannot be sorted.
+ * This can be mapped to an actual property of the object or to a virtual column.
+ *
+ * @typeparam T - The type of data in the table.
+ */
+export interface NoneSortableTableColumn<T> extends BaseTableColumn<T> {
+    sortable?: false;
+}
+export type TableColumn<T> = SortableTableColumn<T> | NoneSortableTableColumn<T>;
+export interface SortColumn<T> {
+    column?: TableRowKey<T>;
+    direction: 'asc' | 'desc';
+}
+export type TableSortData<T> = SortColumn<T> | SortColumn<T>[] | undefined;
+export type TableRowKeyData<T> = TableRowKey<T> | TableRowKey<T>[] | undefined;
+export interface GroupData<T> {
+    key: string;
+    value?: Partial<T>;
+}
+export type GroupKey<T> = TableColumn<T>['key'];
+export type GroupKeys<T> = GroupKey<T> | GroupKey<T>[] | undefined;
+export interface Props<T> {
+    loading?: boolean;
+    stickyHeader?: boolean;
+    stick?: boolean;
+    selectable?: boolean;
+    disableCheckAll?: boolean;
+    noData?: boolean;
+    colspan?: number;
+    columns: TableColumn<T>[];
+    capitalizeHeaders?: boolean;
+    isAllSelected?: boolean;
+    indeterminate?: boolean;
+    dense?: boolean;
+    sortedMap: Partial<Record<TableRowKey<T>, SortColumn<T>>>;
+    sortData?: TableSortData<T>;
+    columnAttr: keyof TableColumn<T>;
+    dataId?: string;
+}
+declare const _default: <T extends object, K extends keyof T = keyof T>(__VLS_props: {
+    onSort?: ((value: {
+        key: TableRowKey<T>;
+        direction?: "desc" | "asc" | undefined;
+    }) => any) | undefined;
+    "onSelect:all"?: ((value: boolean) => any) | undefined;
+    loading?: boolean | undefined;
+    stickyHeader?: boolean | undefined;
+    stick?: boolean | undefined;
+    selectable?: boolean | undefined;
+    disableCheckAll?: boolean | undefined;
+    noData?: boolean | undefined;
+    colspan?: number | undefined;
+    columns: TableColumn<T>[];
+    capitalizeHeaders?: boolean | undefined;
+    isAllSelected?: boolean | undefined;
+    indeterminate?: boolean | undefined;
+    dense?: boolean | undefined;
+    sortedMap: Partial<Record<TableRowKey<T>, SortColumn<T>>>;
+    sortData?: TableSortData<T>;
+    columnAttr: string | number;
+    dataId?: string | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
+    attrs: any;
+    emit: {
+        (e: 'select:all', value: boolean): void;
+        (e: 'sort', value: {
+            key: TableRowKey<T>;
+            direction?: 'asc' | 'desc';
+        }): void;
+    };
+    slots: Partial<Record<`header.${string}`, (_: {
+        column: TableColumn<T>;
+    }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+        column: SortableTableColumn<T>;
+    }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+        column: NoneSortableTableColumn<T>;
+    }) => any>>;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        onSort?: ((value: {
+            key: TableRowKey<T>;
+            direction?: "desc" | "asc" | undefined;
+        }) => any) | undefined;
+        "onSelect:all"?: ((value: boolean) => any) | undefined;
+        loading?: boolean | undefined;
+        stickyHeader?: boolean | undefined;
+        stick?: boolean | undefined;
+        selectable?: boolean | undefined;
+        disableCheckAll?: boolean | undefined;
+        noData?: boolean | undefined;
+        colspan?: number | undefined;
+        columns: TableColumn<T>[];
+        capitalizeHeaders?: boolean | undefined;
+        isAllSelected?: boolean | undefined;
+        indeterminate?: boolean | undefined;
+        dense?: boolean | undefined;
+        sortedMap: Partial<Record<TableRowKey<T>, SortColumn<T>>>;
+        sortData?: TableSortData<T>;
+        columnAttr: string | number;
+        dataId?: string | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<`header.${string}`, (_: {
+        column: TableColumn<T>;
+    }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+        column: SortableTableColumn<T>;
+    }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+        column: NoneSortableTableColumn<T>;
+    }) => any>>;
+    emit: {
+        (e: 'select:all', value: boolean): void;
+        (e: 'sort', value: {
+            key: TableRowKey<T>;
+            direction?: 'asc' | 'desc';
+        }): void;
+    };
+}>) => globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            onSort?: ((value: {
+                key: TableRowKey<T>;
+                direction?: "desc" | "asc" | undefined;
+            }) => any) | undefined;
+            "onSelect:all"?: ((value: boolean) => any) | undefined;
+            loading?: boolean | undefined;
+            stickyHeader?: boolean | undefined;
+            stick?: boolean | undefined;
+            selectable?: boolean | undefined;
+            disableCheckAll?: boolean | undefined;
+            noData?: boolean | undefined;
+            colspan?: number | undefined;
+            columns: TableColumn<T>[];
+            capitalizeHeaders?: boolean | undefined;
+            isAllSelected?: boolean | undefined;
+            indeterminate?: boolean | undefined;
+            dense?: boolean | undefined;
+            sortedMap: Partial<Record<TableRowKey<T>, SortColumn<T>>>;
+            sortData?: TableSortData<T>;
+            columnAttr: string | number;
+            dataId?: string | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Partial<Record<`header.${string}`, (_: {
+            column: TableColumn<T>;
+        }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+            column: SortableTableColumn<T>;
+        }) => any>> & Partial<Record<`header.text.${string}`, (_: {
+            column: NoneSortableTableColumn<T>;
+        }) => any>>;
+        emit: {
+            (e: 'select:all', value: boolean): void;
+            (e: 'sort', value: {
+                key: TableRowKey<T>;
+                direction?: 'asc' | 'desc';
+            }): void;
+        };
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/tables/RuiTablePagination.vue.d.ts

@@ -0,0 +1,47 @@
+export interface TablePaginationData {
+    page: number;
+    total: number;
+    limit: number;
+    limits?: number[];
+}
+export interface Props {
+    modelValue: TablePaginationData;
+    dense?: boolean;
+    disablePerPage?: boolean;
+    loading?: boolean;
+}
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    dense: boolean;
+    loading: boolean;
+    disablePerPage: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (value: TablePaginationData) => void;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    dense: boolean;
+    loading: boolean;
+    disablePerPage: boolean;
+}>>> & {
+    "onUpdate:model-value"?: ((value: TablePaginationData) => any) | undefined;
+}, {
+    loading: boolean;
+    dense: boolean;
+    disablePerPage: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/tabs/tab/RuiTab.vue.d.ts

@@ -0,0 +1,90 @@
+import type { ContextColorsType } from '../../../consts/colors';
+export interface Props {
+    color?: ContextColorsType;
+    disabled?: boolean;
+    grow?: boolean;
+    tabValue?: number | string;
+    active?: boolean;
+    link?: boolean;
+    target?: string;
+    to?: string;
+    exact?: boolean;
+    exactPath?: boolean;
+    vertical?: boolean;
+    align?: 'start' | 'center' | 'end';
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    color: undefined;
+    disabled: boolean;
+    grow: boolean;
+    tabValue: string;
+    active: boolean;
+    link: boolean;
+    to: string;
+    target: string;
+    exact: boolean;
+    exactPath: boolean;
+    vertical: boolean;
+    align: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (tabValue: string | number) => void;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    color: undefined;
+    disabled: boolean;
+    grow: boolean;
+    tabValue: string;
+    active: boolean;
+    link: boolean;
+    to: string;
+    target: string;
+    exact: boolean;
+    exactPath: boolean;
+    vertical: boolean;
+    align: string;
+}>>> & {
+    onClick?: ((tabValue: string | number) => any) | undefined;
+}, {
+    active: boolean;
+    vertical: boolean;
+    link: boolean;
+    color: "primary" | "secondary" | "error" | "warning" | "info" | "success";
+    disabled: boolean;
+    target: string;
+    exact: boolean;
+    to: string;
+    align: "center" | "end" | "start";
+    grow: boolean;
+    tabValue: string | number;
+    exactPath: boolean;
+}, {}>, Readonly<{
+    default?: ((props?: object | undefined) => any) | undefined;
+    prepend?: ((props?: object | undefined) => any) | undefined;
+    append?: ((props?: object | undefined) => any) | undefined;
+}> & {
+    default?: ((props?: object | undefined) => any) | undefined;
+    prepend?: ((props?: object | undefined) => any) | undefined;
+    append?: ((props?: object | undefined) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/tabs/tab-item/RuiTabItem.vue.d.ts

@@ -0,0 +1,48 @@
+export interface Props {
+    active?: boolean;
+    value?: number | string;
+    eager?: boolean;
+    reverse?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    value: undefined;
+    eager: boolean;
+    active: boolean;
+    reverse: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    value: undefined;
+    eager: boolean;
+    active: boolean;
+    reverse: boolean;
+}>>>, {
+    reverse: boolean;
+    active: boolean;
+    value: string | number;
+    eager: boolean;
+}, {}>, {
+    default?(_: {}): any;
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/tabs/tab-items/RuiTabItems.vue.d.ts

@@ -0,0 +1,28 @@
+export interface Props {
+    modelValue?: number | string;
+}
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    modelValue: undefined;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    modelValue: undefined;
+}>>>, {
+    modelValue: string | number;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/tabs/tabs/RuiTabs.vue.d.ts

@@ -0,0 +1,53 @@
+import type { ContextColorsType } from '../../../consts/colors';
+export interface Props {
+    color?: ContextColorsType;
+    vertical?: boolean;
+    disabled?: boolean;
+    grow?: boolean;
+    modelValue?: number | string;
+    align?: 'start' | 'center' | 'end';
+}
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    color: undefined;
+    vertical: boolean;
+    disabled: boolean;
+    grow: boolean;
+    modelValue: undefined;
+    align: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (modelValue: string | number) => void;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    color: undefined;
+    vertical: boolean;
+    disabled: boolean;
+    grow: boolean;
+    modelValue: undefined;
+    align: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((modelValue: string | number) => any) | undefined;
+}, {
+    vertical: boolean;
+    color: "primary" | "secondary" | "error" | "warning" | "info" | "success";
+    disabled: boolean;
+    modelValue: string | number;
+    align: "center" | "end" | "start";
+    grow: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/composables/dropdown-menu.d.ts

@@ -2,29 +2,41 @@ import type { Ref } from 'vue';
 export interface DropdownOptions<T, K extends keyof T = keyof T> {
     options: Ref<T[]>;
     dense?: Ref<boolean>;
-    value: Ref<T | undefined>;
+    value: Ref<T | T[] | undefined>;
     menuRef: Ref<HTMLElement>;
     keyAttr?: K;
-    textAttr?: keyof T;
+    textAttr?: keyof T | ((item: T) => string);
     appendWidth?: number;
     prependWidth?: number;
     itemHeight?: number;
     overscan?: number;
+    autoSelectFirst?: boolean;
+    autoFocus?: boolean;
+    setValue?: (val: T) => void;
+    hideSelected?: boolean;
 }
-export declare function useDropdownMenu<T extends object | string, K extends keyof T>({ appendWidth, dense, itemHeight, keyAttr, menuRef, options, overscan, prependWidth, textAttr, value, }: DropdownOptions<T, K>): {
+export declare function useDropdownMenu<T extends object | string, K extends keyof T>({ appendWidth, autoFocus, autoSelectFirst, dense, hideSelected, itemHeight, keyAttr, menuRef, options: allOptions, overscan, prependWidth, setValue, textAttr, value, }: DropdownOptions<T, K>): {
+    applyHighlighted: () => void;
     containerProps: {
         ref: Ref<HTMLElement | null>;
         onScroll: () => void;
         style: import("vue").StyleValue;
     };
     getIdentifier: (item: T) => T[K] | T;
-    getText: (item: T) => T[keyof T] | T;
+    getText: (item: T) => string | undefined;
+    highlightedIndex: Ref<number>;
     isActiveItem: (item: T) => boolean;
     isOpen: Ref<boolean>;
+    itemIndexInValue: (item: T) => number;
     menuWidth: globalThis.ComputedRef<string>;
-    renderedData: globalThis.ComputedRef<T[]>;
+    moveHighlight: (up: boolean) => void;
+    optionsWithSelectedHidden: globalThis.ComputedRef<T[]>;
+    renderedData: globalThis.ComputedRef<{
+        index: number;
+        item: T;
+    }[]>;
     toggle: (state?: boolean) => void;
-    valueKey: globalThis.ComputedRef<T | T[K] | undefined>;
+    valueKey: globalThis.ComputedRef<any[] | T | T[K] | undefined>;
     wrapperProps: globalThis.ComputedRef<{
         style: {
             width: string;

package/dist/composables/index.es.js

@@ -1,5 +1,5 @@
-import { u as s, a } from "../index-x2urm9HD.js";
-import { u } from "../breakpoint-CRvqq4aP.js";
+import { u as s, a } from "../index-NNlkUY_M.js";
+import { u } from "../breakpoint-OTAceaTK.js";
 export {
   u as useBreakpoint,
   s as useIcons,

package/dist/composables/popper.d.ts

@@ -18,7 +18,9 @@ export declare const DEFAULT_POPPER_OPTIONS: PopperOptions;
 export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>> | undefined) => Instance;
 export declare function usePopper(options: Ref<PopperOptions>, disabled?: Ref<boolean>, openDelay?: Ref<number>, closeDelay?: Ref<number>, virtualReference?: Ref<Element | VirtualElement>): {
     instance: Ref<Instance | null>;
+    leavePending: Ref<boolean>;
     onClose: () => void;
+    onLeavePending: () => void;
     onOpen: () => void;
     onPopperLeave: () => void;
     open: Ref<boolean>;

package/dist/composables/theme.d.ts

@@ -3,4 +3,4 @@ import { type ThemeContent } from '../types/theme';
  * Theme manager
  * @returns {ThemeContent}
  */
-export declare function useRotkiTheme(): ThemeContent;
+export declare const useRotkiTheme: () => ThemeContent;

package/dist/consts/typography.d.ts

@@ -1,5 +1,4 @@
-declare const typographyClasses: {
+export declare const typographyClasses: {
     className: string;
     name: string;
 }[];
-export default typographyClasses;