@dt-frames/ui 2.0.0 → 2.0.2

package/es/components/table/src/props.d.ts

@@ -0,0 +1,244 @@
+import { Recordable } from "@dt-frames/core";
+import { TableRowSelection } from "ant-design-vue/lib/table/interface";
+import { PropType } from "vue";
+import { TableActionType } from "./types/actions.type";
+import { DownloadType } from "./types/header.type";
+import { BasicColumn, ButtonType, TableRowAction, TableSetting } from "./types/table.type";
+export declare const DEFAULT_SORT_FN: (sortInfo: any) => Recordable;
+export declare const TableProps: {
+    clickToSelectRow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tableSetting: {
+        type: PropType<boolean | TableSetting>;
+        default: () => {};
+    };
+    striped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canColDrag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearSelectOnPageChange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resizable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minWidth: {
+        type: NumberConstructor;
+    };
+    maxWidth: {
+        type: NumberConstructor;
+    };
+    virtual: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sortFn: {
+        type: FunctionConstructor;
+        default: (sortInfo: any) => Recordable;
+    };
+    defSort: {
+        type: PropType<Recordable<any>>;
+        default: any;
+    };
+    filterFn: {
+        type: PropType<(data: Partial<Recordable<string[]>>) => any>;
+        default: (data: Partial<Recordable<string[]>>) => Partial<Recordable<string[]>>;
+    };
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    columnCode: {
+        type: StringConstructor;
+        default: string;
+    };
+    columns: {
+        type: PropType<BasicColumn[]>;
+        default: () => any[];
+    };
+    slotsTemplate: {
+        type: PropType<Recordable<any>>;
+        default: {};
+    };
+    showIndexColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCheckboxColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandMethodIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ellipsis: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dataSource: {
+        type: PropType<Recordable<any>[]>;
+        default: any;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagination: {
+        type: PropType<Boolean | Partial<import("vue").ExtractPropTypes<{
+            total: NumberConstructor;
+            defaultCurrent: NumberConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            current: NumberConstructor;
+            defaultPageSize: NumberConstructor;
+            pageSize: NumberConstructor;
+            hideOnSinglePage: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            showSizeChanger: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            pageSizeOptions: PropType<(string | number)[]>;
+            buildOptionText: PropType<(opt: {
+                value: any;
+            }) => any>;
+            showQuickJumper: {
+                type: PropType<boolean | {
+                    goButton?: any;
+                }>;
+                default: boolean | {
+                    goButton?: any;
+                };
+            };
+            showTotal: PropType<(total: number, range: [number, number]) => any>;
+            size: PropType<"default" | "small">;
+            simple: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            locale: ObjectConstructor;
+            prefixCls: StringConstructor;
+            selectPrefixCls: StringConstructor;
+            totalBoundaryShowSizeChanger: NumberConstructor;
+            selectComponentClass: StringConstructor;
+            itemRender: PropType<(opt: {
+                page: number;
+                type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
+                originalElement: any;
+            }) => any>;
+            role: StringConstructor;
+            responsive: BooleanConstructor;
+            showLessItems: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            onChange: PropType<(page: number, pageSize: number) => void>;
+            onShowSizeChange: PropType<(current: number, size: number) => void>;
+            'onUpdate:current': PropType<(current: number) => void>;
+            'onUpdate:pageSize': PropType<(size: number) => void>;
+        }>>>;
+        default: {
+            pageSize: number;
+            current: number;
+        };
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowClassName: {
+        type: PropType<(record: any, index: number) => string>;
+    };
+    scroll: {
+        type: PropType<{
+            x?: number | true;
+            y?: number;
+        }>;
+        default: {};
+    };
+    onTableChange: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    onDownload: {
+        type: FunctionConstructor;
+        default: (excelData: DownloadType) => void;
+    };
+    rowSelection: {
+        type: PropType<TableRowSelection<any>>;
+        default: {
+            type: string;
+            fixed: boolean;
+        };
+    };
+    customRow: {
+        type: PropType<(record: any, index: any) => void>;
+        default: () => void;
+    };
+    childrenColumnName: {
+        type: StringConstructor;
+        default: string;
+    };
+    indexColumnProps: {
+        type: PropType<BasicColumn[]>;
+        default: () => any[];
+    };
+    isTreeTable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    operations: {
+        type: PropType<TableRowAction | ButtonType[]>;
+    };
+    toolbar: {
+        type: PropType<ButtonType[]>;
+    };
+    registerInstance: {
+        type: PropType<(instance: TableActionType) => void>;
+    };
+    onAdd: {
+        type: PropType<(params: Recordable) => void>;
+        default: (params: Recordable) => void;
+    };
+    onUpdate: {
+        type: PropType<(params: {
+            row: Recordable;
+            index: number;
+        }) => void>;
+        default: (params: {
+            row: Recordable;
+            index: number;
+        }) => void;
+    };
+    onDelete: {
+        type: PropType<(params: {
+            row: Recordable;
+            index: number;
+        }) => void>;
+        default: (params: {
+            row: Recordable;
+            index: number;
+        }) => void;
+    };
+    onDeletes: {
+        type: PropType<(params: Recordable) => void>;
+        default: (params: Recordable) => void;
+    };
+};

package/es/components/table/src/types/actions.type.d.ts

@@ -0,0 +1,22 @@
+import { Recordable } from "@dt-frames/core";
+import { Key, TableRowSelection } from "ant-design-vue/es/table/interface";
+import { PaginationProps } from "ant-design-vue/es/pagination";
+import { SetColumnsParams } from "./header.type";
+import { BasicColumn, BasicTableProps } from "./table.type";
+export declare type TableActionType = {
+    setProps: (props: Partial<BasicTableProps>) => void;
+    setLoading: (loading: boolean) => void;
+    clearSelectedRowKeys: () => void;
+    getSelectRows: () => Recordable[];
+    getSelectedRowKeys: () => Key[];
+    setSelectedRowKeys: (keys: Key[]) => void;
+    getRowSelection: () => TableRowSelection<Recordable>;
+    getColumns: (opt?: SetColumnsParams) => BasicColumn[];
+    setColumns: (columns: BasicColumn[] | string[]) => void;
+    setColumnsByDataIndex: (dataIndex: string | undefined, schema: BasicColumn) => void;
+    getCacheColumns: () => BasicColumn[];
+    findTableDataRecord: (rowKey: Key) => Recordable;
+    updateTableDataRecord: (rowKey: string | number, record: Recordable) => Recordable | undefined;
+    getPagination: () => PaginationProps | boolean;
+    emits?: any;
+};

package/es/components/table/src/types/header.type.d.ts

@@ -0,0 +1,23 @@
+import { Recordable } from "@dt-frames/core";
+import { BasicColumn } from "./table.type";
+export declare type DownloadType = {
+    type: 'current' | 'select' | 'all';
+    columns?: BasicColumn[];
+    rows?: Recordable<any>[];
+};
+export declare type SetColumnsParams = {
+    ignoreIndex?: boolean;
+    ignoreAction?: boolean;
+    sort?: boolean;
+};
+export declare type ColumnStateType = {
+    checkAll: boolean;
+    isInit?: boolean;
+    checkedList: string[];
+    defaultCheckList: string[];
+};
+export declare type ColumnOptionsType = {
+    label: string;
+    value: string;
+    fixed?: boolean | 'left' | 'right';
+};

package/es/components/table/src/types/table.type.d.ts

@@ -0,0 +1,92 @@
+import { DictType, Recordable } from "@dt-frames/core";
+import { ColumnProps, TableProps as ATableProps } from "ant-design-vue/es/table";
+import { ComputedRef, ExtractPropTypes, VNode } from "vue";
+import { TableProps } from "../props";
+export declare type ButtonFlag = 'OK' | 'CANCEL' | 'ADD' | 'DEL' | 'DELS' | 'UPDATE';
+export declare type TableSetting = {
+    download?: boolean;
+    onlyFrontDownload?: boolean;
+    onlyBackDowonload?: boolean;
+    setting?: boolean;
+    fullscreen?: boolean;
+};
+export declare type CellFormat = ((record: Recordable, index: Number, text: string) => any) | {
+    dict: DictType;
+} | {
+    struc: string;
+} | {
+    number: string;
+} | {
+    date: string;
+} | {
+    percent: string;
+} | {
+    [key: string]: Recordable;
+} | VNode | JSX.Element;
+export declare type ComponentType = 'Input' | 'InputNumber' | 'Select' | 'TreeSelect' | 'Checkbox' | 'Switch' | 'DatePicker' | 'TimePicker';
+export interface BasicColumn extends ColumnProps<Recordable> {
+    t?: string;
+    children?: BasicColumn[];
+    defaultHidden?: boolean;
+    show?: boolean | ((column: Recordable) => boolean);
+    flag?: 'INDEX' | 'DEFAULT' | 'CHECKBOX' | 'RADIO' | 'ACTION';
+    render?: CellFormat;
+    slot?: string;
+    edit?: boolean;
+    editRow?: boolean;
+    editable?: boolean;
+    editComponent?: ComponentType;
+    editComponentProps?: ((opt: {
+        text: string | number | boolean | Recordable;
+        record: Recordable;
+        column: BasicColumn;
+        index: number;
+    }) => Recordable) | Recordable;
+    editRule?: boolean | ((text: string, record: Recordable) => Promise<string>);
+}
+export declare type ButtonType = {
+    t?: string;
+    name?: string;
+    icon?: string;
+    auth?: string;
+    color?: string;
+    class?: string;
+    type?: 'primary' | 'ghost' | 'dashed' | 'link' | 'text' | 'default';
+    size?: 'large' | 'middle' | 'small';
+    loading?: boolean;
+    disabled?: boolean;
+    show?: boolean | ((row?: Recordable) => boolean) | ComputedRef<boolean>;
+    preIcon?: string;
+    postIcon?: string;
+    flag?: ButtonFlag;
+    onClick?: (data?: {
+        row: Recordable;
+        index: number;
+    }) => void;
+};
+export declare type TableRowAction = {
+    title?: string;
+    width?: number | string;
+    expand?: boolean;
+    fixed?: 'left' | 'right' | 'auto';
+    btns?: ButtonType[];
+};
+export declare type ColumnChangeParam = {
+    dataIndex: string;
+    fixed: boolean | 'left' | 'right' | undefined;
+    visible: boolean;
+};
+export declare type BasicTableProps = ATableProps & ExtractPropTypes<typeof TableProps> & {
+    onColumnsChange?: (data: ColumnChangeParam[]) => void;
+};
+export declare type SorterResult = {
+    column: ColumnProps;
+    order: 'ascend' | 'descend';
+    field: string;
+    columnKey: string;
+};
+export declare type LableValOptions = {
+    label: string;
+    value: any;
+    [key: string]: string | number | boolean;
+}[];

package/es/directives/icon.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveBinding } from "vue";
+export declare const iconMounted: (el: Element, binding: DirectiveBinding<any>, props: any) => void;

package/es/directives/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+import { authMounted } from './permission';
+import { iconMounted } from './icon';
+export declare function initDirectives(): {
+    install(app: App): void;
+};
+export { authMounted, iconMounted };