vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/table/src/table-types.d.ts

@@ -0,0 +1,135 @@
+import type { PropType, ExtractPropTypes, ComponentInternalInstance, InjectionKey, Ref, ComputedRef, CSSProperties, ToRefs } from 'vue';
+import { TableStore } from './store/store-types';
+export declare type TableSize = 'sm' | 'md' | 'lg';
+export declare type BorderType = '' | 'bordered' | 'borderless';
+export declare type RowKeyType = string | ((v: Record<string, unknown>, index?: number | undefined) => string);
+export declare type SpanMethod = (data: {
+    row: unknown;
+    column: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}) => number[] | {
+    rowspan: number;
+    colspan: number;
+};
+export declare const tableProps: {
+    data: {
+        type: PropType<Record<string, unknown>[]>;
+        default: never[];
+    };
+    striped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxWidth: {
+        type: StringConstructor;
+    };
+    maxHeight: {
+        type: StringConstructor;
+    };
+    tableWidth: {
+        type: StringConstructor;
+    };
+    tableHeight: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<TableSize>;
+        validator(value: string): boolean;
+        default: string;
+    };
+    rowHoveredHighlight: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fixHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tableLayout: {
+        type: PropType<"fixed" | "auto">;
+        default: string;
+        validator(v: string): boolean;
+    };
+    showLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    headerBg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    spanMethod: {
+        type: PropType<SpanMethod>;
+    };
+    borderType: {
+        type: PropType<BorderType>;
+        default: string;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowKey: {
+        type: (StringConstructor | (new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | ((new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | {
+            (): (v: Record<string, unknown>, index?: number | undefined) => string;
+            new (): any;
+            readonly prototype: any;
+        })[])[];
+        default: string;
+    };
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandRowKeys: {
+        type: PropType<string[]>;
+    };
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type TableProps = ExtractPropTypes<typeof tableProps>;
+export declare type DefaultRow = TableProps['data'][number];
+export interface ITable<T = DefaultRow> extends ComponentInternalInstance {
+    store: TableStore<T>;
+    props: TableProps;
+    tableId: string;
+    hiddenColumns: Ref<HTMLElement | null>;
+    tableRef: Ref<HTMLElement>;
+    updateColumnWidth: () => void;
+}
+export interface TableMethods<T = Record<string, unknown>> {
+    getCheckedRows(): T[];
+}
+export declare const TABLE_TOKEN: InjectionKey<ITable>;
+export interface UseTable {
+    classes: ComputedRef<Record<string, boolean>>;
+    styles: ComputedRef<CSSProperties>;
+}
+export declare type UseFixedColumn = ToRefs<{
+    stickyClass: ComputedRef<Record<string, boolean>>;
+    stickyStyle: ComputedRef<CSSProperties>;
+}>;
+export interface UseTableLayout {
+    tableWidth: Ref;
+    updateColumnWidth: () => void;
+}
+export declare type ITableInstanceAndDefaultRow = ComponentInternalInstance & ITable<DefaultRow>;

package/types/table/src/table.d.ts

@@ -0,0 +1,3 @@
+import './table.scss';
+declare const _default: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
+export default _default;

package/types/table/src/utils.d.ts

@@ -0,0 +1,9 @@
+import { DefaultRow, ITable, RowKeyType } from './table-types';
+export declare function formatWidth(width: number | string): number | string;
+export declare function getRowIdentity(row: DefaultRow, rowKey: RowKeyType, index?: number): string;
+export declare function getRowKeysMap(data: DefaultRow[], rowKey: RowKeyType): Record<string, {
+    row: DefaultRow;
+    index: number;
+}>;
+export declare function toggleRowExpandStatus(rowsArr: DefaultRow[], row: DefaultRow, status?: boolean): boolean;
+export declare function toggleRowVisible(expand: boolean, table: ITable<DefaultRow>, key: string): void;

package/types/tabs/__tests__/tabs.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/tabs/index.d.ts

@@ -0,0 +1,12 @@
+import type { App } from 'vue';
+import Tabs from './src/tabs';
+import Tab from './src/components/tab/tab';
+export * from './src/tabs-types';
+export { Tabs, Tab };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/tabs/src/components/tab/tab-types.d.ts

@@ -0,0 +1,25 @@
+import { ExtractPropTypes, PropType, Slots } from 'vue';
+export declare const tabProps: {
+    readonly title: {
+        readonly type: PropType<string | number>;
+        readonly default: null;
+    };
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export declare type TabProps = ExtractPropTypes<typeof tabProps>;
+export interface TabContext {
+    uid: number | undefined;
+    slots: Slots;
+    props: TabProps;
+}

package/types/tabs/src/components/tab/tab.d.ts

@@ -0,0 +1,42 @@
+import './tab.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly title: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}, () => JSX.Element | null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly title: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>>, {
+    readonly id: string;
+    readonly title: string | number;
+    readonly disabled: boolean;
+    readonly closeable: boolean;
+}>;
+export default _default;

package/types/tabs/src/components/tab-nav/composables/use-tab-nav-event.d.ts

@@ -0,0 +1,3 @@
+import type { SetupContext } from 'vue';
+import type { UseTabNavEvent } from '../tab-nav-types';
+export declare function useTabNavEvent(ctx: SetupContext): UseTabNavEvent;

package/types/tabs/src/components/tab-nav/composables/use-tab-nav-function.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef, EmitsOptions, SetupContext, ShallowRef } from 'vue';
+import { TabsProps, TabsData } from '../../../tabs-types';
+import { OffSetData, UseTabNavFunction } from '../tab-nav-types';
+export declare function useTabNavFunction(props: TabsProps, tabs: TabsData | undefined, tabsList: ComputedRef, data: OffSetData, ctx: SetupContext<EmitsOptions>, tabsEle: ShallowRef<HTMLUListElement | undefined>): UseTabNavFunction;

package/types/tabs/src/components/tab-nav/composables/use-tab-nav-render.d.ts

@@ -0,0 +1,3 @@
+import { TabsProps } from '../../../tabs-types';
+import { OffSetData, UseTabNavRender } from '../tab-nav-types';
+export declare function useTabNavRender(props: TabsProps, data: OffSetData): UseTabNavRender;

package/types/tabs/src/components/tab-nav/tab-nav-types.d.ts

@@ -0,0 +1,26 @@
+import type { ComputedRef, StyleValue } from 'vue';
+import type { TabsStateData } from '../../tabs-types';
+export interface UseTabNavRender {
+    ulClasses: ComputedRef<Record<string, boolean>>;
+    aClasses: ComputedRef<Record<string, boolean>>;
+    customStyle: StyleValue;
+    sliderAnimationStyle: ComputedRef<Record<string, string | undefined>>;
+}
+export interface OffSetData {
+    offsetLeft: number;
+    offsetWidth: number;
+    offsetTop: number;
+    offsetHeight: number;
+    id: null;
+}
+export interface UseTabNavFunction {
+    update: () => void;
+    activeClick: (item: TabsStateData, tabEl?: Element) => void;
+    beforeMount: () => void;
+    mounted: () => void;
+    tabCanClose: (item: TabsStateData) => boolean;
+}
+export interface UseTabNavEvent {
+    onTabRemove: (item: TabsStateData, ev: MouseEvent) => void;
+    onTabAdd: () => void;
+}

package/types/tabs/src/components/tab-nav/tab-nav.d.ts

@@ -0,0 +1,96 @@
+import './tab-nav.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly type: {
+        readonly type: () => import("../../tabs-types").ITabsType;
+        readonly default: "tabs";
+    };
+    readonly showContent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly reactivable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly customWidth: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly cssClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly beforeChange: {
+        readonly type: import("vue").PropType<(id: import("../../tabs-types").Active) => boolean>;
+        readonly default: null;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly addable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly tabPosition: {
+        readonly type: () => import("../../tabs-types").ITabPositionType;
+        readonly default: "top";
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "active-tab-change" | "tab-remove" | "tab-change" | "tab-add", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly type: {
+        readonly type: () => import("../../tabs-types").ITabsType;
+        readonly default: "tabs";
+    };
+    readonly showContent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly reactivable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly customWidth: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly cssClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly beforeChange: {
+        readonly type: import("vue").PropType<(id: import("../../tabs-types").Active) => boolean>;
+        readonly default: null;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly addable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly tabPosition: {
+        readonly type: () => import("../../tabs-types").ITabPositionType;
+        readonly default: "top";
+    };
+}>>, {
+    readonly type: import("../../tabs-types").ITabsType;
+    readonly cssClass: string;
+    readonly closeable: boolean;
+    readonly modelValue: string | number;
+    readonly beforeChange: (id: import("../../tabs-types").Active) => boolean;
+    readonly showContent: boolean;
+    readonly reactivable: boolean;
+    readonly customWidth: string;
+    readonly addable: boolean;
+    readonly tabPosition: import("../../tabs-types").ITabPositionType;
+}>;
+export default _default;

package/types/tabs/src/tabs-types.d.ts

@@ -0,0 +1,72 @@
+import type { ComputedRef, ExtractPropTypes, PropType, Ref } from 'vue';
+import type { TabContext } from './components/tab/tab-types';
+export declare type Active = string | number | null;
+export declare type ITabsType = 'tabs' | 'pills' | 'options' | 'wrapped' | 'slider';
+export declare type ITabPositionType = 'top' | 'right' | 'bottom' | 'left';
+export declare type TabsStateData = TabContext & {
+    tabId?: string;
+    tabsEle?: Ref<Document>;
+};
+export interface TabsState {
+    data: Record<number, TabContext>;
+    showContent: boolean;
+    active: string | number;
+}
+export interface TabsData {
+    state: TabsState;
+    addTab(ctx: TabContext): void;
+    deleteTab(id: number | undefined): void;
+}
+export declare const tabsProps: {
+    readonly modelValue: {
+        readonly type: PropType<string | number>;
+        readonly default: null;
+    };
+    readonly type: {
+        readonly type: () => ITabsType;
+        readonly default: "tabs";
+    };
+    readonly showContent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly reactivable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly customWidth: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly cssClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly beforeChange: {
+        readonly type: PropType<(id: Active) => boolean>;
+        readonly default: null;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly addable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly tabPosition: {
+        readonly type: () => ITabPositionType;
+        readonly default: "top";
+    };
+};
+export declare type TabsProps = ExtractPropTypes<typeof tabsProps>;
+export interface UseTabsEvent {
+    onUpdateModelValue: (value: string | number) => void;
+    onActiveTabChange: (value: string) => void;
+    onTabRemove: (item: TabsStateData, ev: MouseEvent) => void;
+    onTabAdd: () => void;
+    onTabChange: (id: string | undefined, type: string) => void;
+}
+export interface UseTabsRender {
+    tabsClasses: ComputedRef<Record<string, boolean>>;
+}

package/types/tabs/src/tabs.d.ts

@@ -0,0 +1,95 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly type: {
+        readonly type: () => import("./tabs-types").ITabsType;
+        readonly default: "tabs";
+    };
+    readonly showContent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly reactivable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly customWidth: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly cssClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly beforeChange: {
+        readonly type: import("vue").PropType<(id: import("./tabs-types").Active) => boolean>;
+        readonly default: null;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly addable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly tabPosition: {
+        readonly type: () => import("./tabs-types").ITabPositionType;
+        readonly default: "top";
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "update:modelValue" | "active-tab-change" | "tab-remove" | "tab-change" | "tab-add", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: null;
+    };
+    readonly type: {
+        readonly type: () => import("./tabs-types").ITabsType;
+        readonly default: "tabs";
+    };
+    readonly showContent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly reactivable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly customWidth: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly cssClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly beforeChange: {
+        readonly type: import("vue").PropType<(id: import("./tabs-types").Active) => boolean>;
+        readonly default: null;
+    };
+    readonly closeable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly addable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly tabPosition: {
+        readonly type: () => import("./tabs-types").ITabPositionType;
+        readonly default: "top";
+    };
+}>>, {
+    readonly type: import("./tabs-types").ITabsType;
+    readonly cssClass: string;
+    readonly closeable: boolean;
+    readonly modelValue: string | number;
+    readonly beforeChange: (id: import("./tabs-types").Active) => boolean;
+    readonly showContent: boolean;
+    readonly reactivable: boolean;
+    readonly customWidth: string;
+    readonly addable: boolean;
+    readonly tabPosition: import("./tabs-types").ITabPositionType;
+}>;
+export default _default;

package/types/tabs/src/use-tabs.d.ts

@@ -0,0 +1,4 @@
+import type { SetupContext } from 'vue';
+import type { UseTabsEvent, TabsProps, UseTabsRender } from './tabs-types';
+export declare function useTabsEvent(ctx: SetupContext): UseTabsEvent;
+export declare function useTabsRender(props: TabsProps): UseTabsRender;

package/types/tag/__tests__/tag.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/tag/index.d.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vue';
+import Tag from './src/tag';
+export * from './src/tag-types';
+export { Tag };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/tag/src/composables/index.d.ts

@@ -0,0 +1,3 @@
+import useClass from './use-class';
+import useColor from './use-color';
+export { useClass, useColor };

package/types/tag/src/composables/use-class.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef } from 'vue';
+import { TagProps } from '../tag-types';
+export default function (props: TagProps): ComputedRef<string>;

package/types/tag/src/composables/use-color.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef } from 'vue';
+import { TagProps } from '../tag-types';
+export default function (props: TagProps): ComputedRef<string>;

package/types/tag/src/tag-types.d.ts

@@ -0,0 +1,30 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+export declare type TagType = 'primary' | 'success' | 'warning' | 'danger';
+export declare type SizeType = 'lg' | 'md' | 'sm';
+export declare const tagProps: {
+    readonly type: {
+        readonly type: PropType<TagType>;
+        readonly default: "";
+    };
+    readonly color: {
+        readonly type: PropType<string>;
+        readonly default: "";
+    };
+    readonly titleContent: {
+        readonly type: PropType<string>;
+        readonly default: "";
+    };
+    readonly checked: {
+        readonly type: PropType<boolean>;
+        readonly default: false;
+    };
+    readonly deletable: {
+        readonly type: PropType<boolean>;
+        readonly default: false;
+    };
+    readonly size: {
+        readonly type: PropType<SizeType>;
+        readonly default: "md";
+    };
+};
+export declare type TagProps = ExtractPropTypes<typeof tagProps>;

package/types/tag/src/tag.d.ts

@@ -0,0 +1,64 @@
+import './tag.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./tag-types").TagType>;
+        readonly default: "";
+    };
+    readonly color: {
+        readonly type: import("vue").PropType<string>;
+        readonly default: "";
+    };
+    readonly titleContent: {
+        readonly type: import("vue").PropType<string>;
+        readonly default: "";
+    };
+    readonly checked: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: false;
+    };
+    readonly deletable: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: false;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./tag-types").SizeType>;
+        readonly default: "md";
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "tagDelete" | "checkedChange")[], "click" | "tagDelete" | "checkedChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./tag-types").TagType>;
+        readonly default: "";
+    };
+    readonly color: {
+        readonly type: import("vue").PropType<string>;
+        readonly default: "";
+    };
+    readonly titleContent: {
+        readonly type: import("vue").PropType<string>;
+        readonly default: "";
+    };
+    readonly checked: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: false;
+    };
+    readonly deletable: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly default: false;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./tag-types").SizeType>;
+        readonly default: "md";
+    };
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+    onTagDelete?: ((...args: any[]) => any) | undefined;
+    onCheckedChange?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly type: import("./tag-types").TagType;
+    readonly color: string;
+    readonly size: import("./tag-types").SizeType;
+    readonly checked: boolean;
+    readonly titleContent: string;
+    readonly deletable: boolean;
+}>;
+export default _default;