@dt-frames/ui 1.0.9 → 1.0.12

package/es/components/forms/src/types/form.type.d.ts

@@ -12,7 +12,7 @@ export declare type FormCallBackParams = {
     model: Recordable;
     name: string;
 };
-export declare type ComponentType = 'Input' | 'InputGroup' | 'InputPassword' | 'InputSearch' | 'InputTextArea' | 'InputNumber' | 'InputCountDown' | 'Select' | 'TreeSelect' | 'ApiTree' | 'ApiTreeSelect' | 'Radio' | 'RadioButtonGroup' | 'RadioGroup' | 'Checkbox' | 'CheckboxGroup' | 'AutoComplete' | 'Cascader' | 'DatePicker' | 'MonthPicker' | 'RangePicker' | 'WeekPicker' | 'TimePicker' | 'Switch' | 'Upload' | 'IconPicker' | 'Render' | 'Slider' | 'Rate' | 'Divider' | 'Icon';
+export declare type ComponentType = 'Input' | 'InputWithDialog' | 'InputGroup' | 'InputPassword' | 'InputSearch' | 'InputTextArea' | 'InputNumber' | 'InputCountDown' | 'Select' | 'TreeSelect' | 'ApiTree' | 'ApiTreeSelect' | 'Radio' | 'RadioButtonGroup' | 'RadioGroup' | 'Checkbox' | 'CheckboxGroup' | 'AutoComplete' | 'Cascader' | 'DatePicker' | 'MonthPicker' | 'RangePicker' | 'WeekPicker' | 'TimePicker' | 'Switch' | 'Upload' | 'IconPicker' | 'Render' | 'Slider' | 'Rate' | 'Divider' | 'Icon';
 export declare type ColEx = {
     style?: any;
     span?: number | string;
@@ -67,7 +67,7 @@ export declare type FormProps = {
     style?: Recordable;
 };
 export declare type FormSchema = {
-    name: string | string[];
+    name?: string | string[];
     changeEvent?: string;
     valueField?: string;
     label?: string | VNode;
@@ -76,7 +76,7 @@ export declare type FormSchema = {
     labelAlign?: 'left' | 'right';
     toolTip?: string | ((parms: FormCallBackParams) => string | string[]);
     toolTipProps?: ToolTipProps;
-    component: ComponentType;
+    component?: ComponentType;
     props?: ((opt: {
         schema?: FormSchema;
         formActions?: any;
@@ -90,7 +90,7 @@ export declare type FormSchema = {
     defaultValue?: any;
     span?: number;
     show?: boolean | ((parms: FormCallBackParams) => boolean);
-    render?: (parms: FormCallBackParams) => VNode | VNode[] | string;
+    render?: (parms?: FormCallBackParams) => VNode | VNode[] | string;
     renderCol?: (parms: FormCallBackParams) => VNode | VNode[] | string;
     colProps?: Partial<ColEx>;
     renderComponent?: ((parms: FormCallBackParams) => Recordable) | VNode | VNode[] | string;
@@ -102,6 +102,8 @@ export declare type FormSchema = {
     labelCol?: Partial<ColEx>;
     wrapperCol?: Partial<ColEx>;
     isAdvanced?: boolean;
+    openDialog?: (parms: Recordable) => void;
+    linkProps?: string[];
 };
 export declare type FormActionType = {
     setProps: (props: FormProps) => Promise<void>;

package/es/components/index.d.ts

@@ -8,8 +8,9 @@ import { useSource } from './source';
 import { useCurd } from './curd';
 import { export2Excel } from './excel';
 import { DtIframe } from './iframe';
-import { useDialog } from './dialog';
+import { DtUpload, DtUploadModal } from './upload';
+import { DtTree } from './tree';
 export declare function initComponents(): {
     install(app: App): void;
 };
-export { DtBaseRouter, DtIcon, DtPickIcon, DtModal, DtForm, DtTable, FormButtons, DtIframe, useForm, useTable, useSource, useCurd, useModal, useModalOut, export2Excel, useDialog };
+export { DtBaseRouter, DtIcon, DtPickIcon, DtModal, DtForm, DtTable, FormButtons, DtIframe, DtUpload, DtUploadModal, DtTree, useForm, useTable, useSource, useCurd, useModal, useModalOut, export2Excel };

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

@@ -6,13 +6,16 @@ export declare type ModalMethods = {
     redoModalHeight?: () => void;
 };
 export interface ReturnMethods extends ModalMethods {
-    openModal: <T = any>(data?: T, openOnSet?: boolean) => void;
+    openModal: (data?: {
+        data?: Recordable;
+        afterClose?: (data: Recordable) => void;
+    }, openOnSet?: boolean) => void;
     closeModal: () => void;
     getVisible?: ComputedRef<boolean>;
 }
 export interface ReturnInnerMethods extends ModalMethods {
     openModal: <T = any>(props?: boolean, data?: T, openOnSet?: boolean) => void;
-    closeModal: (rsp: Recordable) => void;
+    closeModal: (rsp?: Recordable) => void;
     changeLoading: (loading: boolean) => void;
     getVisible?: ComputedRef<boolean>;
     redoModalHeight: () => void;

package/es/components/source/src/hooks/useFetch.d.ts

@@ -1,4 +1,4 @@
-import { Recordable, ApiType } from "@dt-frames/core";
+import { ApiType } from "@dt-frames/core";
 export declare function useFetch(api: string | ApiType, baseUrl?: string): {
-    fetch: (params?: Recordable) => Promise<unknown>;
+    fetch: (params: any) => Promise<unknown>;
 };

package/es/components/source/src/hooks/useSource.d.ts

@@ -4,10 +4,10 @@ import { SourceType } from "../types/source.type";
 import { TableParamsType } from '../types/table.type';
 import { DownloadType } from '../../../table/src/types/tableHeader.type';
 export declare function useSource(opt: SourceType): {
-    api: import("../types/source.type").ApiObjType;
-    apiFul: Recordable<any>;
+    api: Recordable<any>;
+    apiPath: Recordable<any>;
     form: {
-        onSearch: (model: Recordable) => void;
+        onSearch: (model?: Recordable) => void;
         onReset: (model: Recordable) => void;
         loading: {
             [key: string]: Ref<boolean>;
@@ -25,19 +25,19 @@ export declare function useSource(opt: SourceType): {
         loading: Ref<boolean>;
     };
     curd: {
-        onAdd: (model: Recordable) => void;
+        onAdd: (model: Recordable) => Promise<void>;
         onQueryById: (id: string) => Promise<unknown>;
-        onUpdate: (model: Recordable) => void;
+        onUpdate: (model: Recordable) => Promise<void>;
         onDeletes: (ids: any) => void;
     };
     loading: {
         [key: string]: Ref<boolean>;
     };
-    onAdd: (model: Recordable) => void;
+    onAdd: (model: Recordable) => Promise<void>;
     onQueryById: (id: string) => Promise<unknown>;
     onDeletes: (ids: any) => void;
-    onUpdate: (model: Recordable) => void;
+    onUpdate: (model: Recordable) => Promise<void>;
     onTableChange: (params: TableParamsType, needSearch?: boolean) => void;
     onDownload: (excelData: DownloadType) => void;
-    onSearch: (model: Recordable) => void;
+    onSearch: (model?: Recordable) => void;
 };

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

@@ -2,6 +2,6 @@ import { Recordable } from "@dt-frames/core";
 export declare type TableParamsType = {
     pagination: any;
     showBtnLoading: boolean;
-    sort: Recordable[];
+    sort: Recordable;
     filter: any;
 };

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

@@ -387,7 +387,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
                 'onUpdate:visible': {
                     type: PropType<(val: boolean) => void>;
                 };
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "forceRender" | "arrow" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "arrow" | "forceRender" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
             $attrs: {
                 [x: string]: unknown;
             };
@@ -824,7 +824,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
                 'onUpdate:openKeys': PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:selectedKeys': PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:activeKey': PropType<(key: import("ant-design-vue/lib/_util/type").Key) => void>;
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "theme" | "multiple" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "selectable" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "multiple" | "selectable" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "theme" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
             $attrs: {
                 [x: string]: unknown;
             };

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

@@ -2,7 +2,7 @@ import { PropType } from "vue";
 import type { BtnsType, ColumnChangeParam, TableSetting } from "../types/table.type";
 declare const _default: import("vue").DefineComponent<{
     tableTools: {
-        type: PropType<TableSetting>;
+        type: PropType<boolean | TableSetting>;
     };
     toolbar: {
         type: PropType<BtnsType[]>;
@@ -14,7 +14,7 @@ declare const _default: import("vue").DefineComponent<{
     handleMethod: (e: any) => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "columns-change"[], "columns-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     tableTools: {
-        type: PropType<TableSetting>;
+        type: PropType<boolean | TableSetting>;
     };
     toolbar: {
         type: PropType<BtnsType[]>;

package/es/components/table/src/components/editable/CellComponent.d.ts

@@ -0,0 +1,14 @@
+import { Recordable } from "@dt-frames/core";
+import { FunctionalComponent, Ref } from "vue";
+export declare type EditRecordRow<T = Recordable> = Partial<{
+    onEdit: (editable: boolean, submit?: boolean) => Promise<boolean>;
+    onValid: () => Promise<boolean>;
+    editable: boolean;
+    onCancel: Function;
+    onSubmit: Function;
+    submitCbs: Function[];
+    cancelCbs: Function[];
+    validCbs: Function[];
+    editValueRefs: Recordable<Ref>;
+} & T>;
+export declare const CellComponent: FunctionalComponent;

package/es/components/table/src/components/editable/EditTableCell.d.ts

@@ -0,0 +1,88 @@
+import { Recordable } from "@dt-frames/core";
+import { PropType } from "vue";
+import { BasicColumn, LableValOptions } from "../../types/table.type";
+declare const _default: import("vue").DefineComponent<{
+    value: {
+        type: PropType<string | number | boolean | Recordable<any>>;
+        default: string;
+    };
+    record: {
+        type: PropType<Partial<{
+            onEdit: (editable: boolean, submit?: boolean) => Promise<boolean>;
+            onValid: () => Promise<boolean>;
+            editable: boolean;
+            onCancel: Function;
+            onSubmit: Function;
+            submitCbs: Function[];
+            cancelCbs: Function[];
+            validCbs: Function[];
+            editValueRefs: Recordable<import("vue").Ref<any>>;
+        } & Recordable<any>>>;
+    };
+    column: {
+        type: PropType<BasicColumn>;
+        default: () => BasicColumn;
+    };
+    index: NumberConstructor;
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: PropType<string | number | boolean | Recordable<any>>;
+            default: string;
+        };
+        record: {
+            type: PropType<Partial<{
+                onEdit: (editable: boolean, submit?: boolean) => Promise<boolean>;
+                onValid: () => Promise<boolean>;
+                editable: boolean;
+                onCancel: Function;
+                onSubmit: Function;
+                submitCbs: Function[];
+                cancelCbs: Function[];
+                validCbs: Function[];
+                editValueRefs: Recordable<import("vue").Ref<any>>;
+            } & Recordable<any>>>;
+        };
+        column: {
+            type: PropType<BasicColumn>;
+            default: () => BasicColumn;
+        };
+        index: NumberConstructor;
+    }>> & {
+        [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
+    }>>;
+    getComponentProps: import("vue").ComputedRef<any>;
+    getRuleVisible: import("vue").ComputedRef<boolean>;
+    editRule: boolean | ((text: string, record: Recordable<any>) => Promise<string>);
+    ruleMessage: import("vue").Ref<string>;
+    getWrapperClass: import("vue").ComputedRef<string>;
+    handleChange: (e: any) => Promise<void>;
+    handleOptionsChange: (options: LableValOptions) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<string | number | boolean | Recordable<any>>;
+        default: string;
+    };
+    record: {
+        type: PropType<Partial<{
+            onEdit: (editable: boolean, submit?: boolean) => Promise<boolean>;
+            onValid: () => Promise<boolean>;
+            editable: boolean;
+            onCancel: Function;
+            onSubmit: Function;
+            submitCbs: Function[];
+            cancelCbs: Function[];
+            validCbs: Function[];
+            editValueRefs: Recordable<import("vue").Ref<any>>;
+        } & Recordable<any>>>;
+    };
+    column: {
+        type: PropType<BasicColumn>;
+        default: () => BasicColumn;
+    };
+    index: NumberConstructor;
+}>>, {
+    value: string;
+    column: BasicColumn;
+}>;
+export default _default;

package/es/components/table/src/components/editable/componentMap.d.ts

@@ -0,0 +1,4 @@
+import { Component } from 'vue';
+import { ComponentType } from '../../types/table.type';
+declare const componentMap: Map<ComponentType, Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+export { componentMap };

package/es/components/table/src/components/editable/index.d.ts

@@ -0,0 +1,9 @@
+import { BasicColumn } from "../../types/table.type";
+declare function renderEditCell(column: BasicColumn): ({ text: value, record, index }: {
+    text: any;
+    record: any;
+    index: any;
+}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export { renderEditCell };

package/es/components/table/src/components/setting/Download.d.ts

@@ -330,7 +330,7 @@ declare const _sfc_main: import("vue").DefineComponent<{}, {
                 'onUpdate:visible': {
                     type: import("vue").PropType<(val: boolean) => void>;
                 };
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "forceRender" | "arrow" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "arrow" | "forceRender" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
             $attrs: {
                 [x: string]: unknown;
             };
@@ -767,7 +767,7 @@ declare const _sfc_main: import("vue").DefineComponent<{}, {
                 'onUpdate:openKeys': import("vue").PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:selectedKeys': import("vue").PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:activeKey': import("vue").PropType<(key: import("ant-design-vue/lib/_util/type").Key) => void>;
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "theme" | "multiple" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "selectable" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "multiple" | "selectable" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "theme" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
             $attrs: {
                 [x: string]: unknown;
             };

package/es/components/table/src/components/setting/Size.d.ts

@@ -331,7 +331,7 @@ declare const _sfc_main: import("vue").DefineComponent<{}, {
                 'onUpdate:visible': {
                     type: import("vue").PropType<(val: boolean) => void>;
                 };
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "forceRender" | "arrow" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "overlayStyle" | "disabled" | "arrow" | "forceRender" | "minOverlayWidthMatchTrigger" | "destroyPopupOnHide">;
             $attrs: {
                 [x: string]: unknown;
             };
@@ -768,7 +768,7 @@ declare const _sfc_main: import("vue").DefineComponent<{}, {
                 'onUpdate:openKeys': import("vue").PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:selectedKeys': import("vue").PropType<(keys: import("ant-design-vue/lib/_util/type").Key[]) => void>;
                 'onUpdate:activeKey': import("vue").PropType<(key: import("ant-design-vue/lib/_util/type").Key) => void>;
-            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "theme" | "multiple" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "selectable" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "mode" | "multiple" | "selectable" | "inlineCollapsed" | "disabledOverflow" | "forceSubMenuRender" | "theme" | "inlineIndent" | "subMenuOpenDelay" | "subMenuCloseDelay" | "triggerSubMenuAction">;
             $attrs: {
                 [x: string]: unknown;
             };

package/es/components/table/src/hooks/useCustomRow.d.ts

@@ -0,0 +1,19 @@
+import { Recordable } from "@dt-frames/core";
+import { ComputedRef } from "vue";
+import { BasicTableProps } from "../types/table.type";
+interface Options {
+    setSelectedRowKeys: (keys: string[]) => void;
+    getSelectRowKeys: () => string[];
+    clearSelectedRowKeys: () => void;
+    emit: any;
+}
+export declare function useCustomRow(propsRef: ComputedRef<BasicTableProps>, { setSelectedRowKeys, getSelectRowKeys, clearSelectedRowKeys, emit }: Options): {
+    customRow: (record: Recordable, index: number) => {
+        onClick: (e: any) => void;
+        onDblclick: (event: Event) => void;
+        onContextmenu: (event: Event) => void;
+        onMouseenter: (event: Event) => void;
+        onMouseleave: (event: Event) => void;
+    };
+};
+export {};

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

@@ -7,9 +7,13 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
     tableSetting: {
-        type: import("vue").PropType<import("./types/table.type").TableSetting>;
+        type: import("vue").PropType<boolean | import("./types/table.type").TableSetting>;
         default: () => {};
     };
+    clickToRowSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     striped: {
         type: BooleanConstructor;
         default: boolean;
@@ -264,12 +268,20 @@ declare const _default: import("vue").DefineComponent<{
         rowKey: string;
         columns: import("./types/table.type").BasicColumn[];
         tableLayout: string;
+        customRow: (record: Recordable<any>, index: number) => {
+            onClick: (e: any) => void;
+            onDblclick: (event: Event) => void;
+            onContextmenu: (event: Event) => void;
+            onMouseenter: (event: Event) => void;
+            onMouseleave: (event: Event) => void;
+        };
         size: SizeType;
         bordered: boolean;
-        customRow: (record: any, index: any) => void;
+        onDownload: Function;
         childrenColumnName: string;
         clickRowSelect: boolean;
         tableSetting: {};
+        clickToRowSelect: boolean;
         striped: boolean;
         canColDrag: boolean;
         resizable: boolean;
@@ -279,7 +291,6 @@ declare const _default: import("vue").DefineComponent<{
         templates: {};
         ellipsis: boolean;
         onTableChange: Function;
-        onDownload: Function;
         showIndexColumn: boolean;
         indexColumnProps: import("./types/table.type").BasicColumn[];
         isTreeTable: boolean;
@@ -352,15 +363,19 @@ declare const _default: import("vue").DefineComponent<{
     }>>, filters: Partial<Recordable<string[]>>, sorter: import("./types/table.type").SorterResult) => any;
     getSelectRows: () => Recordable<any>[];
     handleResizeColumn: (w: any, col: any) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("register" | "columns-change" | "selection-change")[], "register" | "columns-change" | "selection-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("register" | "columns-change" | "selection-change" | "row-click" | "row-dbClick" | "row-contextmenu" | "row-mouseenter" | "row-mouseleave" | "expanded-rows-change" | "edit-change")[], "register" | "columns-change" | "selection-change" | "row-click" | "row-dbClick" | "row-contextmenu" | "row-mouseenter" | "row-mouseleave" | "expanded-rows-change" | "edit-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
     clickRowSelect: {
         type: BooleanConstructor;
         default: boolean;
     };
     tableSetting: {
-        type: import("vue").PropType<import("./types/table.type").TableSetting>;
+        type: import("vue").PropType<boolean | import("./types/table.type").TableSetting>;
         default: () => {};
     };
+    clickToRowSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     striped: {
         type: BooleanConstructor;
         default: boolean;
@@ -548,10 +563,18 @@ declare const _default: import("vue").DefineComponent<{
     onRegister?: (...args: any[]) => any;
     "onColumns-change"?: (...args: any[]) => any;
     "onSelection-change"?: (...args: any[]) => any;
+    "onRow-click"?: (...args: any[]) => any;
+    "onRow-dbClick"?: (...args: any[]) => any;
+    "onRow-contextmenu"?: (...args: any[]) => any;
+    "onRow-mouseenter"?: (...args: any[]) => any;
+    "onRow-mouseleave"?: (...args: any[]) => any;
+    "onExpanded-rows-change"?: (...args: any[]) => any;
+    "onEdit-change"?: (...args: any[]) => any;
 }, {
     size: SizeType;
     loading: boolean;
     bordered: boolean;
+    onDownload: Function;
     columns: import("./types/table.type").BasicColumn[];
     scroll: {};
     rowKey: string;
@@ -562,6 +585,7 @@ declare const _default: import("vue").DefineComponent<{
     rowSelection: any;
     clickRowSelect: boolean;
     tableSetting: {};
+    clickToRowSelect: boolean;
     striped: boolean;
     canColDrag: boolean;
     resizable: boolean;
@@ -572,7 +596,6 @@ declare const _default: import("vue").DefineComponent<{
     templates: {};
     ellipsis: boolean;
     onTableChange: Function;
-    onDownload: Function;
     showIndexColumn: boolean;
     indexColumnProps: import("./types/table.type").BasicColumn[];
     isTreeTable: boolean;

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

@@ -10,9 +10,13 @@ export declare const TableProps: {
         default: boolean;
     };
     tableSetting: {
-        type: PropType<TableSetting>;
+        type: PropType<boolean | TableSetting>;
         default: () => {};
     };
+    clickToRowSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     striped: {
         type: BooleanConstructor;
         default: boolean;

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

@@ -64,6 +64,12 @@ export declare type ActionType = {
     fixed?: 'left' | 'right' | 'auto';
     btns?: BtnsType[];
 };
+export declare type ComponentType = 'Input' | 'InputNumber' | 'Select' | 'TreeSelect' | 'Checkbox' | 'Switch' | 'DatePicker' | 'TimePicker';
+export declare type LableValOptions = {
+    label: string;
+    value: any;
+    [key: string]: string | number | boolean;
+}[];
 export interface BasicColumn extends ColumnProps {
     children?: BasicColumn[];
     defaultHidden?: boolean;
@@ -72,6 +78,15 @@ export interface BasicColumn extends ColumnProps {
     render?: CellFormat;
     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>);
     showIndexColumn?: boolean;
     expand?: boolean;
 }
@@ -86,4 +101,5 @@ export declare type TableActionType = {
     setCacheColumnsByField?: (dataIndex: string | undefined, value: BasicColumn) => void;
     getSelectRows: () => void;
     getSelectRowKeys: () => void;
+    emit?: any;
 };

package/es/components/tree/index.d.ts

@@ -0,0 +1,2 @@
+import DtTree from "./src/index";
+export { DtTree };

package/es/components/tree/src/hooks/useTree.d.ts

@@ -0,0 +1,14 @@
+import { TreeDataItem } from "ant-design-vue/lib/tree";
+import { ComputedRef, Ref } from "vue";
+import { FieldNames, InsertNodeParams, TreeItem, KeyType } from "../type/tree";
+export declare function useTree(treeDataRef: Ref<TreeDataItem[]>, getFieldNames: ComputedRef<FieldNames>): {
+    getAllKeys: (list?: TreeDataItem[]) => KeyType[];
+    getEnabledKeys: (list?: TreeDataItem[]) => KeyType[];
+    getChildrenKeys: (nodeKey: string | number, list?: TreeDataItem[]) => KeyType[];
+    updateNodeByKey: (key: string, node: TreeDataItem, list?: TreeDataItem[]) => void;
+    filterByLevel: (level?: number, list?: TreeDataItem[], currentLevel?: number) => string[] | number[];
+    insertNodeByKey: ({ parentKey, node, push }: InsertNodeParams) => void;
+    insertNodesByKey: ({ parentKey, list, push }: InsertNodeParams) => void;
+    deleteNodeByKey: (key: string, list?: TreeDataItem[]) => void;
+    getSelectedNode: (key: KeyType, list?: TreeItem[], selectedNode?: TreeItem | null) => TreeItem;
+};

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

@@ -0,0 +1,101 @@
+import { Recordable } from "@dt-frames/core";
+import { PropType } from "vue";
+import { CheckKeys, ContextMenuItem, FieldNames, TreeActionItem, TreeItem } from "./type/tree";
+export declare const BasicProps: {
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkStrictly: BooleanConstructor;
+    expandedKeys: {
+        type: PropType<KeyType[]>;
+        default: () => any[];
+    };
+    selectedKeys: {
+        type: PropType<KeyType[]>;
+        default: () => any[];
+    };
+    checkedKeys: {
+        type: PropType<CheckKeys>;
+        default: () => any[];
+    };
+    fieldNames: {
+        type: PropType<FieldNames>;
+    };
+    beforeRightClick: {
+        type: PropType<(...arg: any) => ContextMenuItem[]>;
+        default: any;
+    };
+    rightMenuList: {
+        type: PropType<ContextMenuItem[]>;
+    };
+    renderIcon: {
+        type: PropType<(params: Recordable) => string>;
+    };
+    highlight: {
+        type: PropType<String | Boolean>;
+        default: boolean;
+    };
+    actionList: {
+        type: PropType<TreeActionItem[]>;
+        default: () => any[];
+    };
+    clickRowToExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterFn: {
+        type: PropType<(searchValue: any, node: TreeItem, fieldNames: FieldNames) => boolean>;
+        default: any;
+    };
+    checkable: BooleanConstructor;
+    expandOnSearch: BooleanConstructor;
+    checkOnSearch: BooleanConstructor;
+    selectedOnSearch: BooleanConstructor;
+    treeData: {
+        type: PropType<import("ant-design-vue/lib/tree").DataNode[]>;
+    };
+    value: {
+        type: PropType<KeyType[] | CheckKeys>;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: BooleanConstructor;
+    search: BooleanConstructor;
+};
+export declare const searchProps: {
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    search: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchText: {
+        type: StringConstructor;
+        default: string;
+    };
+    checkAll: {
+        type: FunctionConstructor;
+        default: any;
+    };
+    expandAll: {
+        type: FunctionConstructor;
+        default: any;
+    };
+};