3h1-ui 2.5.0 → 2.7.0

package/es/index.js

@@ -1,6 +1,6 @@
 import { h, nextTick, createVNode, defineComponent, ref, computed, unref, watchEffect, watch, resolveComponent, openBlock, createBlock, mergeProps, withCtx, createElementBlock, Fragment, renderList, createTextVNode, toDisplayString, createSlots, renderSlot, normalizeProps, guardReactiveProps, createElementVNode, onMounted, normalizeClass, createCommentVNode, normalizeStyle, Transition, toHandlers, useSlots, withDirectives, vShow, getCurrentInstance, inject, onUnmounted, provide, onBeforeUnmount, resolveDynamicComponent, reactive, toRef, toRefs, TransitionGroup, getCurrentScope, onScopeDispose, readonly, isVNode, shallowReactive, toRaw, shallowRef, withKeys, withModifiers, render as render$1, resolveDirective, isRef, useAttrs as useAttrs$2 } from "vue";
 import { Radio, Select, Tree, TreeSelect, Cascader, Transfer, Input, Tooltip, Skeleton, Popover, Pagination, Empty, Button as Button$1, Table as Table$1, Form, FormItem, DatePicker, InputNumber, AutoComplete, Switch, Checkbox, Slider, Rate, TimePicker, Divider, Col, Popconfirm, Modal as Modal$2, Row, Dropdown, Menu, MenuItem, MenuDivider, Spin, PageHeader, Image, Badge, Tag, FormItemRest, Drawer, Space, Upload, Avatar } from "ant-design-vue";
-import { propTypes, isFunction as isFunction$4, isString as isString$3, isArray as isArray$3, getSlot as getSlot$1, addClass as addClass$1, removeClass as removeClass$1, getPopupContainer as getPopupContainer$1, triggerWindowResize, off, on, addResizeListener, removeResizeListener, isNumber as isNumber$2, isBoolean, isNull, extendSlots as extendSlots$1, withInstall as withInstall$1, isObject as isObject$3, dateUtil, isNullOrUnDef, isDef as isDef$1, error as error$1, deepMerge as deepMerge$1, getDynamicProps, buildProps, createBEM, forEach as forEach$1, isClient as isClient$1, filter, treeToList, eachTree, isEmpty, isServer, formatToDate, isMap as isMap$2, buildUUID, findNodeAll, getViewportOffset, warn as warn$1, isNullAndUnDef, dataURLtoBlob } from "@shy-plugins/utils";
+import { propTypes, isFunction as isFunction$4, isString as isString$3, isArray as isArray$3, getSlot as getSlot$1, addClass as addClass$1, removeClass as removeClass$1, getPopupContainer as getPopupContainer$1, triggerWindowResize, off, on, addResizeListener, removeResizeListener, isNumber as isNumber$2, isBoolean, isNull, extendSlots as extendSlots$1, withInstall as withInstall$2, isObject as isObject$3, dateUtil, isNullOrUnDef, isDef as isDef$1, error as error$1, deepMerge as deepMerge$1, getDynamicProps, buildProps, createBEM, forEach as forEach$1, isClient as isClient$1, filter, treeToList, eachTree, isEmpty, isServer, formatToDate, isMap as isMap$2, buildUUID, findNodeAll, getViewportOffset, warn as warn$1, isNullAndUnDef, dataURLtoBlob } from "@shy-plugins/utils";
 import { useAttrs as useAttrs$1, useRuleFormItem, useTimeoutFn as useTimeoutFn$2, useScrollTo as useScrollTo$1, useIntersectionObserver, useCopyToClipboard, useMessage, usePagination as usePagination$2, createContext as createContext$1, useContext as useContext$2, useBreakpoint, useI18n as useI18n$1, useContentHeight, useDesign as useDesign$1, useWindowSizeFn as useWindowSizeFn$1, onMountedOrActivated, useEventListener as useEventListener$1 } from "@shy-plugins/use";
 import { zxcvbn } from "@zxcvbn-ts/core";
 import Iconify from "@purge-icons/generated";
@@ -7902,7 +7902,7 @@ const _sfc_main$J = defineComponent({
     };
   }
 });
-const Button = withInstall$1(_sfc_main$K);
+const Button = withInstall$2(_sfc_main$K);
 const key$3 = Symbol();
 function createFormContext(context) {
   return createContext$1(context, key$3);
@@ -7967,7 +7967,10 @@ const _sfc_main$I = defineComponent({
         {
           text: "查询"
         },
-        props2.submitButtonOptions
+        {
+          ...props2.submitButtonOptions,
+          loading: false
+        }
       );
     });
     const getPreIcon = computed(() => {
@@ -7992,7 +7995,6 @@ const _sfc_main$I = defineComponent({
 });
 function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_BasicButton = resolveComponent("BasicButton");
-  const _component_SearchOutlined = resolveComponent("SearchOutlined");
   const _component_Button = resolveComponent("Button");
   const _component_FormItem = resolveComponent("FormItem");
   return _ctx.showActionButtonGroup ? (openBlock(), createElementBlock("div", {
@@ -8006,10 +8008,7 @@ function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
           key: 0,
           type: "default",
           class: "mr-2"
-        }, _ctx.getResetBtnOptions, {
-          onClick: _ctx.resetAction,
-          preIcon: "ant-design:sync-outlined"
-        }), {
+        }, _ctx.getResetBtnOptions, { onClick: _ctx.resetAction }), {
           default: withCtx(() => [
             createTextVNode(toDisplayString(_ctx.getResetBtnOptions.text), 1)
           ]),
@@ -8021,11 +8020,8 @@ function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
           type: "primary",
           class: "mr-2"
         }, { ..._ctx.getSubmitBtnOptions }, { onClick: _ctx.submitAction }), {
-          icon: withCtx(() => [
-            createVNode(_component_SearchOutlined, { style: { "line-height": "14px", "transform": "translateY(3px)", "font-size": "14px", "box-sizing": "border-box" } })
-          ]),
           default: withCtx(() => [
-            createTextVNode(" " + toDisplayString(_ctx.getSubmitBtnOptions.text), 1)
+            createTextVNode(toDisplayString(_ctx.getSubmitBtnOptions.text), 1)
           ]),
           _: 1
         }, 16, ["onClick"])) : createCommentVNode("", true),
@@ -9840,7 +9836,7 @@ const useModalInner = (callbackFn) => {
     }
   ];
 };
-const BasicModal = withInstall$1(basicModal);
+const BasicModal = withInstall$2(basicModal);
 const basicProps$4 = {
   model: {
     type: Object,
@@ -10249,7 +10245,7 @@ function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) {
             class: normalizeClass(_ctx.getToggleClass),
             onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleToggleAdvanced && _ctx.handleToggleAdvanced(...args))
           }, [
-            createVNode(_component_DownOutlined, { style: { fontSize: "10px", color: "#919191 " } })
+            createVNode(_component_DownOutlined, { style: { fontSize: "10px", color: "#AED0FA " } })
           ], 2)
         ], 2)) : createCommentVNode("", true)
       ];
@@ -11851,9 +11847,12 @@ const FETCH_SETTING = fetchSetting;
 const DEFAULT_SIZE = defaultSize;
 const DEFAULT_SORT_FN = defaultSortFn;
 const DEFAULT_FILTER_FN = defaultFilterFn;
-const DEFAULT_ALIGN = "center";
+let DEFAULT_ALIGN = "left";
 const INDEX_COLUMN_FLAG = "INDEX";
 const ACTION_COLUMN_FLAG = "ACTION";
+const setConstConfig = (config) => {
+  DEFAULT_ALIGN = config.align;
+};
 function itemRender({
   page,
   type,
@@ -14393,6 +14392,7 @@ function useTableForm(propsRef, slots, fetch, getLoading) {
     const { submitButtonOptions } = formConfig || {};
     return {
       showAdvancedButton: true,
+      rowProps: { gutter: 20 },
       ...formConfig,
       submitButtonOptions: {
         loading: unref(getLoading),
@@ -14425,7 +14425,7 @@ function useTableForm(propsRef, slots, fetch, getLoading) {
     handleSearchInfoChange
   };
 }
-const basicProps$3 = {
+const basicProps$3 = reactive({
   clickToRowSelect: { type: Boolean, default: true },
   isTreeTable: Boolean,
   tableSetting: propTypes.shape({}),
@@ -14552,6 +14552,11 @@ const basicProps$3 = {
     type: String,
     default: DEFAULT_SIZE
   }
+});
+const basicPropChange = (options) => {
+  Object.keys(options).forEach((name) => {
+    basicProps$3[name] = options[name];
+  });
 };
 const _sfc_main$i = defineComponent({
   components: {
@@ -15010,7 +15015,11 @@ const _sfc_main$g = defineComponent({
     },
     divider: propTypes.bool.def(true),
     outside: propTypes.bool,
-    stopButtonPropagation: propTypes.bool.def(false)
+    stopButtonPropagation: propTypes.bool.def(false),
+    showCount: {
+      type: Number,
+      default: () => 2
+    }
   },
   setup(props2) {
     const { prefixCls: prefixCls2 } = useDesign$1("basic-table-action");
@@ -15030,8 +15039,8 @@ const _sfc_main$g = defineComponent({
       return isIfShow2;
     }
     const getActions = computed(() => {
-      return (toRaw(props2.actions) || []).filter((action) => {
-        return isIfShow(action);
+      return (toRaw(props2.actions) || []).filter((action, index2) => {
+        return isIfShow(action) && index2 < props2.showCount;
       }).map((action) => {
         const { popConfirm } = action;
         return {
@@ -15047,8 +15056,8 @@ const _sfc_main$g = defineComponent({
       });
     });
     const getDropdownList = computed(() => {
-      const list = (toRaw(props2.dropDownActions) || []).filter((action) => {
-        return isIfShow(action);
+      const list = (toRaw(props2.actions) || []).filter((action, index2) => {
+        return isIfShow(action) && index2 >= props2.showCount;
       });
       return list.map((action, index2) => {
         const { label, popConfirm } = action;
@@ -15151,7 +15160,7 @@ function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
         })) : createCommentVNode("", true)
       ], 64);
     }), 128)),
-    _ctx.dropDownActions && _ctx.getDropdownList.length > 0 ? (openBlock(), createBlock(_component_Dropdown, {
+    _ctx.getDropdownList.length > 0 ? (openBlock(), createBlock(_component_Dropdown, {
       key: 0,
       trigger: ["hover"],
       dropMenuList: _ctx.getDropdownList,
@@ -15435,6 +15444,16 @@ function useTable(tableProps) {
   };
   return [register, methods2];
 }
+const withInstall$1 = (component) => {
+  const comp = component;
+  comp.install = (app, options = {}, config = {}) => {
+    basicPropChange(options);
+    setConstConfig(config);
+    app.component("BasicTable", component);
+  };
+  return component;
+};
+withInstall$1(BasicTable);
 const _sfc_main$d = /* @__PURE__ */ defineComponent({
   __name: "Table",
   setup(__props, { expose }) {
@@ -19909,7 +19928,6 @@ const useTableData = (getProps, { setPage, params }) => {
     var _a2;
     if ((_a2 = getProps.value) == null ? void 0 : _a2.api) {
       const res = await getProps.value.api(params.value);
-      console.log("1", getProps.value.transDataAfterReload(res));
       setTableData(getProps.value.transDataAfterReload(res));
       setPage({ total: (res == null ? void 0 : res.total) || 0 });
     }
@@ -20067,7 +20085,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const innerProps = ref({});
     const getProps = computed(() => {
       const tempProps = { ...props2, ...innerProps.value };
-      console.log("1", props2);
       if (tempProps.isCompatible) {
         tempProps.columns.forEach((column) => {
           column.field = column.dataIndex;
@@ -20089,13 +20106,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         ...getProps.value
       };
     });
-    watchEffect(() => {
-      getBindValues.value;
-      console.log(
-        "🚀 ~ file: TablePlus.vue:263 ~ watchEffect ~ getBindValues:",
-        getBindValues.value
-      );
-    });
     const getColumns = computed(() => {
       return getProps.value.columns.map((item) => {
         return { ...basicColumn, ...item };
@@ -20173,6 +20183,18 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const setTreeExpand = (rows, checked) => {
       return toRaw(tableRef.value.setTreeExpand(rows, checked));
     };
+    const getVxeTableRef = () => {
+      return tableRef.value;
+    };
+    const setSelectRowByKeys = (keys2, checked) => {
+      tableRef.value.getTableData();
+      const rows = [];
+      keys2.forEach((key2) => {
+        const row = tableRef.value.getRowById(key2);
+        rows.push(row);
+      });
+      tableRef.value.setCheckboxRow(rows, checked);
+    };
     const tableAction = {
       reload,
       setTableData,
@@ -20184,7 +20206,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       getTreeExpandRecords,
       setAllTreeExpand,
       clearTreeExpand,
-      setTreeExpand
+      setTreeExpand,
+      getVxeTableRef,
+      setSelectRowByKeys
     };
     emits("register", tableAction, formActions);
     return (_ctx, _cache) => {
@@ -20366,7 +20390,9 @@ function useTablePlus(tableProps) {
     getTreeExpandRecords: () => getTableInstance().getTreeExpandRecords(),
     setAllTreeExpand: () => getTableInstance().setAllTreeExpand(),
     clearTreeExpand: () => getTableInstance().clearTreeExpand(),
-    setTreeExpand: (rows, checked) => getTableInstance().setTreeExpand(rows, checked)
+    setTreeExpand: (rows, checked) => getTableInstance().setTreeExpand(rows, checked),
+    getVxeTableRef: () => getTableInstance().getVxeTableRef(),
+    setSelectRowByKeys: (keys2, checked) => getTableInstance().setSelectRowByKeys(keys2, checked)
   };
   return [register, methods2];
 }

package/es/style.css

@@ -25064,9 +25064,9 @@ span.iconify {
   align-items: center;
   width: 32px;
   height: 12px;
-  border: 1px solid #f0f0f0;
-  border-radius: 6px;
-  transition: all 0.2s;
+  border: 1px solid #aed0fa;
+  border-radius: 0;
+  transition: all 0.1;
   cursor: pointer;
 }
 .shy-basic-form-toggle-icon.expend {

package/es/ui/src/Table/index.d.ts

@@ -1,4 +1,4 @@
-export { default as BasicTable } from './src/BasicTable.vue';
+import BasicTable from './src/BasicTable.vue';
 export { default as TableAction } from './src/components/TableAction.vue';
 export { default as EditTableHeaderIcon } from './src/components/EditTableHeaderIcon.vue';
 export { default as TableImg } from './src/components/TableImg.vue';
@@ -9,3 +9,4 @@ export * from './src/types/tableAction';
 export { useTable } from './src/hooks/useTable';
 export type { FormSchema, FormProps } from '../form';
 export type { EditRecordRow } from './src/components/editable';
+export { BasicTable };

package/es/ui/src/Table/src/const.d.ts

@@ -17,6 +17,7 @@ export declare const DEFAULT_SORT_FN: (sortInfo: SorterResult) => {
     order?: undefined;
 };
 export declare const DEFAULT_FILTER_FN: (data: Partial<Recordable<string[]>>) => Partial<Recordable<string[]>>;
-export declare const DEFAULT_ALIGN = "center";
+export declare let DEFAULT_ALIGN: string;
 export declare const INDEX_COLUMN_FLAG = "INDEX";
 export declare const ACTION_COLUMN_FLAG = "ACTION";
+export declare const setConstConfig: (config: any) => void;

package/es/ui/src/Table/src/props.d.ts

@@ -1,4 +1,3 @@
-import type { PropType } from 'vue';
 import type { PaginationProps } from './types/pagination';
 import type { BasicColumn, FetchSetting, TableSetting, SorterResult, TableCustomRecord, TableRowSelection, SizeType } from './types/table';
 import type { FormProps } from '../../Form';
@@ -8,10 +7,140 @@ export declare const basicProps: {
         default: boolean;
     };
     isTreeTable: BooleanConstructor;
-    tableSetting: import("vue-types").VueTypeShape<TableSetting>;
+    tableSetting: {
+        readonly loose: {
+            readonly loose: any;
+            readonly _vueTypes_isLoose: true;
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+            readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting & {
+                [key: string]: any;
+            }>>) => import("vue-types").VueTypeLooseShape<TableSetting> & {
+                default: () => Partial<TableSetting> & {
+                    [key: string]: any;
+                };
+            };
+            readonly isRequired: {
+                readonly loose: any;
+                readonly _vueTypes_isLoose: true;
+                _vueTypes_name: string;
+                type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+                readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting & {
+                    [key: string]: any;
+                }>>) => import("vue-types").VueTypeLooseShape<TableSetting> & {
+                    required: true;
+                } & {
+                    default: () => Partial<TableSetting> & {
+                        [key: string]: any;
+                    };
+                };
+                readonly isRequired: any;
+                required: true;
+                default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+                    redo?: boolean;
+                    size?: boolean;
+                    setting?: boolean;
+                    fullScreen?: boolean;
+                };
+                validator?: (value: TableSetting) => boolean;
+            };
+            required?: boolean;
+            default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+                redo?: boolean;
+                size?: boolean;
+                setting?: boolean;
+                fullScreen?: boolean;
+            };
+            validator?: (value: TableSetting) => boolean;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+        readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting>>) => import("vue-types").VueTypeShape<TableSetting> & {
+            default: () => Partial<TableSetting>;
+        };
+        readonly isRequired: {
+            readonly loose: {
+                readonly loose: any;
+                readonly _vueTypes_isLoose: true;
+                _vueTypes_name: string;
+                type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+                readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting & {
+                    [key: string]: any;
+                }>>) => import("vue-types").VueTypeLooseShape<TableSetting> & {
+                    default: () => Partial<TableSetting> & {
+                        [key: string]: any;
+                    };
+                };
+                readonly isRequired: {
+                    readonly loose: any;
+                    readonly _vueTypes_isLoose: true;
+                    _vueTypes_name: string;
+                    type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+                    readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting & {
+                        [key: string]: any;
+                    }>>) => import("vue-types").VueTypeLooseShape<TableSetting> & {
+                        required: true;
+                    } & {
+                        default: () => Partial<TableSetting> & {
+                            [key: string]: any;
+                        };
+                    };
+                    readonly isRequired: any;
+                    required: true;
+                    default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+                        redo?: boolean;
+                        size?: boolean;
+                        setting?: boolean;
+                        fullScreen?: boolean;
+                    };
+                    validator?: (value: TableSetting) => boolean;
+                };
+                required?: boolean;
+                default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+                    redo?: boolean;
+                    size?: boolean;
+                    setting?: boolean;
+                    fullScreen?: boolean;
+                };
+                validator?: (value: TableSetting) => boolean;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<TableSetting> | import("vue-types/dist/types").Prop<TableSetting>[];
+            readonly def: (def?: import("vue-types/dist/types").DefaultFactory<Partial<TableSetting>>) => import("vue-types").VueTypeShape<TableSetting> & {
+                required: true;
+            } & {
+                default: () => Partial<TableSetting>;
+            };
+            readonly isRequired: any;
+            required: true;
+            default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+                redo?: boolean;
+                size?: boolean;
+                setting?: boolean;
+                fullScreen?: boolean;
+            };
+            validator?: (value: TableSetting) => boolean;
+        };
+        required?: boolean;
+        default?: object | (() => TableSetting) | ((props: Record<string, unknown>) => TableSetting) | {
+            redo?: boolean;
+            size?: boolean;
+            setting?: boolean;
+            fullScreen?: boolean;
+        };
+        validator?: (value: TableSetting) => boolean;
+    };
     inset: BooleanConstructor;
     sortFn: {
-        type: PropType<(sortInfo: SorterResult) => any>;
+        type: ((new (...args: any[]) => (sortInfo: SorterResult) => any) | (() => (sortInfo: SorterResult) => any) | {
+            (): (sortInfo: SorterResult) => any;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (sortInfo: SorterResult) => any) | (() => (sortInfo: SorterResult) => any) | {
+            (): (sortInfo: SorterResult) => any;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: (sortInfo: SorterResult) => {
             field: string;
             order: import("./types/table").SortOrder;
@@ -21,7 +150,15 @@ export declare const basicProps: {
         };
     };
     filterFn: {
-        type: PropType<(data: Partial<Recordable<string[]>>) => any>;
+        type: ((new (...args: any[]) => (data: Partial<Recordable<string[]>>) => any) | (() => (data: Partial<Recordable<string[]>>) => any) | {
+            (): (data: Partial<Recordable<string[]>>) => any;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (data: Partial<Recordable<string[]>>) => any) | (() => (data: Partial<Recordable<string[]>>) => any) | {
+            (): (data: Partial<Recordable<string[]>>) => any;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: (data: Partial<Recordable<string[]>>) => Partial<Recordable<string[]>>;
     };
     showTableSetting: {
@@ -38,40 +175,118 @@ export declare const basicProps: {
     };
     showSummary: BooleanConstructor;
     summaryFunc: {
-        type: PropType<(...arg: any[]) => any[]>;
+        type: ((new (...args: any[]) => (...arg: any[]) => any[]) | (() => (...arg: any[]) => any[]) | {
+            (): (...arg: any[]) => any[];
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (...arg: any[]) => any[]) | (() => (...arg: any[]) => any[]) | {
+            (): (...arg: any[]) => any[];
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: any;
     };
     summaryData: {
-        type: PropType<Recordable<any>[]>;
+        type: ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[])) | ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[]))[];
         default: any;
     };
-    indentSize: import("vue-types").VueTypeValidableDef<number> & {
-        default: number;
-    } & {
-        default: number;
+    indentSize: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        } & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+        readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+            readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                required: true;
+            };
+            readonly isRequired: any;
+            required: true;
+            default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+            validator?: (value: number) => boolean;
+        };
+        required?: boolean;
+        default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+        validator?: (value: number) => boolean;
     };
     canColDrag: {
         type: BooleanConstructor;
         default: boolean;
     };
     api: {
-        type: PropType<(...arg: any[]) => Promise<any>>;
+        type: ((new (...args: any[]) => (...arg: any[]) => Promise<any>) | (() => (...arg: any[]) => Promise<any>) | {
+            (): (...arg: any[]) => Promise<any>;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (...arg: any[]) => Promise<any>) | (() => (...arg: any[]) => Promise<any>) | {
+            (): (...arg: any[]) => Promise<any>;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: any;
     };
     beforeFetch: {
-        type: PropType<Fn<any, any>>;
+        type: ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: any;
     };
     afterFetch: {
-        type: PropType<Fn<any, any>>;
+        type: ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: any;
     };
     handleSearchInfoFn: {
-        type: PropType<Fn<any, any>>;
+        type: ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => Fn<any, any>) | (() => Fn<any, any>) | {
+            (): Fn<any, any>;
+            new (): any;
+            readonly prototype: any;
+        })[];
         default: any;
     };
     fetchSetting: {
-        type: PropType<FetchSetting>;
+        type: ((new (...args: any[]) => FetchSetting) | (() => FetchSetting)) | ((new (...args: any[]) => FetchSetting) | (() => FetchSetting))[];
         default: () => {
             pageField: string;
             sizeField: string;
@@ -88,20 +303,50 @@ export declare const basicProps: {
         default: boolean;
     };
     searchInfo: {
-        type: PropType<Recordable<any>>;
+        type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
         default: any;
     };
     defSort: {
-        type: PropType<Recordable<any>>;
+        type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
         default: any;
     };
-    useSearchForm: import("vue-types").VueTypeValidableDef<boolean>;
+    useSearchForm: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+        readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+            readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                default: boolean;
+            };
+            readonly isRequired: any;
+            required: true;
+            default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+            validator?: (value: boolean) => boolean;
+        };
+        required?: boolean;
+        default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+        validator?: (value: boolean) => boolean;
+    };
     formConfig: {
-        type: PropType<Partial<FormProps>>;
+        type: ((new (...args: any[]) => Partial<FormProps>) | (() => Partial<FormProps>)) | ((new (...args: any[]) => Partial<FormProps>) | (() => Partial<FormProps>))[];
         default: any;
     };
     columns: {
-        type: PropType<BasicColumn[]>;
+        type: ((new (...args: any[]) => BasicColumn[]) | (() => BasicColumn[])) | ((new (...args: any[]) => BasicColumn[]) | (() => BasicColumn[]))[];
         default: () => any[];
     };
     showIndexColumn: {
@@ -109,11 +354,11 @@ export declare const basicProps: {
         default: boolean;
     };
     indexColumnProps: {
-        type: PropType<BasicColumn>;
+        type: ((new (...args: any[]) => BasicColumn) | (() => BasicColumn)) | ((new (...args: any[]) => BasicColumn) | (() => BasicColumn))[];
         default: any;
     };
     actionColumn: {
-        type: PropType<BasicColumn>;
+        type: ((new (...args: any[]) => BasicColumn) | (() => BasicColumn)) | ((new (...args: any[]) => BasicColumn) | (() => BasicColumn))[];
         default: any;
     };
     ellipsis: {
@@ -128,62 +373,279 @@ export declare const basicProps: {
         type: BooleanConstructor;
         default: boolean;
     };
-    clearSelectOnPageChange: import("vue-types").VueTypeValidableDef<boolean>;
-    resizeHeightOffset: import("vue-types").VueTypeValidableDef<number> & {
-        default: number;
-    } & {
-        default: number;
+    clearSelectOnPageChange: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+        readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+            readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                default: boolean;
+            };
+            readonly isRequired: any;
+            required: true;
+            default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+            validator?: (value: boolean) => boolean;
+        };
+        required?: boolean;
+        default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+        validator?: (value: boolean) => boolean;
+    };
+    resizeHeightOffset: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        } & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+        readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+            readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                required: true;
+            };
+            readonly isRequired: any;
+            required: true;
+            default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+            validator?: (value: number) => boolean;
+        };
+        required?: boolean;
+        default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+        validator?: (value: number) => boolean;
     };
     rowSelection: {
-        type: PropType<TableRowSelection<any>>;
+        type: ((new (...args: any[]) => TableRowSelection<any>) | (() => TableRowSelection<any>)) | ((new (...args: any[]) => TableRowSelection<any>) | (() => TableRowSelection<any>))[];
         default: any;
     };
     title: {
-        type: PropType<string | ((data: Recordable) => string)>;
+        type: ((new (...args: any[]) => string | ((data: Recordable) => string)) | (() => string | ((data: Recordable) => string))) | ((new (...args: any[]) => string | ((data: Recordable) => string)) | (() => string | ((data: Recordable) => string)))[];
         default: any;
     };
     titleHelpMessage: {
-        type: PropType<string | string[]>;
+        type: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
     };
-    maxHeight: import("vue-types").VueTypeValidableDef<number> & {
-        default: number;
+    maxHeight: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+        readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<number> | import("vue-types/dist/types").Prop<number>[];
+            readonly def: (def?: number) => import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                required: true;
+            } & {
+                default: number;
+            };
+            readonly isRequired: any;
+            required: true;
+            default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+            validator?: (value: number) => boolean;
+        };
+        required?: boolean;
+        default: number | ((() => number) & number) | (((props: Record<string, unknown>) => number) & number);
+        validator?: (value: number) => boolean;
     };
     dataSource: {
-        type: PropType<Recordable<any>[]>;
+        type: ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[])) | ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[]))[];
         default: any;
     };
     rowKey: {
-        type: PropType<string | ((record: Recordable) => string)>;
+        type: ((new (...args: any[]) => string | ((record: Recordable) => string)) | (() => string | ((record: Recordable) => string))) | ((new (...args: any[]) => string | ((record: Recordable) => string)) | (() => string | ((record: Recordable) => string)))[];
         default: string;
     };
-    bordered: import("vue-types").VueTypeValidableDef<boolean> & {
-        default: boolean;
+    bordered: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+        readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+            readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                required: true;
+            };
+            readonly isRequired: any;
+            required: true;
+            default: (boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean)) & boolean;
+            validator?: (value: boolean) => boolean;
+        };
+        required?: boolean;
+        default: (boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean)) & boolean;
+        validator?: (value: boolean) => boolean;
     };
     pagination: {
-        type: PropType<boolean | PaginationProps>;
+        type: ((new (...args: any[]) => boolean | PaginationProps) | (() => boolean | PaginationProps)) | ((new (...args: any[]) => boolean | PaginationProps) | (() => boolean | PaginationProps))[];
         default: any;
     };
-    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: {
+        readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        _vueTypes_name: string;
+        type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+        readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly isRequired: {
+            readonly validate: (fn: import("vue-types/dist/types").ValidatorFunction<unknown>) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            _vueTypes_name: string;
+            type?: import("vue-types/dist/types").Prop<boolean> | import("vue-types/dist/types").Prop<boolean>[];
+            readonly def: (def?: boolean) => import("vue-types").VueTypeValidableDef<boolean> & {
+                required: true;
+            } & {
+                default: boolean;
+            };
+            readonly isRequired: any;
+            required: true;
+            default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+            validator?: (value: boolean) => boolean;
+        };
+        required?: boolean;
+        default?: boolean | object | (() => boolean) | ((props: Record<string, unknown>) => boolean);
+        validator?: (value: boolean) => boolean;
+    };
     rowClassName: {
-        type: PropType<(record: TableCustomRecord<any>, index: number) => string>;
+        type: ((new (...args: any[]) => (record: TableCustomRecord<any>, index: number) => string) | (() => (record: TableCustomRecord<any>, index: number) => string) | {
+            (): (record: TableCustomRecord<any>, index: number) => string;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (record: TableCustomRecord<any>, index: number) => string) | (() => (record: TableCustomRecord<any>, index: number) => string) | {
+            (): (record: TableCustomRecord<any>, index: number) => string;
+            new (): any;
+            readonly prototype: any;
+        })[];
     };
     scroll: {
-        type: PropType<{
+        type: ((new (...args: any[]) => {
+            x: number | true;
+            y: number;
+        }) | (() => {
+            x: number | true;
+            y: number;
+        })) | ((new (...args: any[]) => {
             x: number | true;
             y: number;
-        }>;
+        }) | (() => {
+            x: number | true;
+            y: number;
+        }))[];
         default: any;
     };
     beforeEditSubmit: {
-        type: PropType<(data: {
+        type: ((new (...args: any[]) => (data: {
+            record: Recordable;
+            index: number;
+            key: string | number;
+            value: any;
+        }) => Promise<any>) | (() => (data: {
+            record: Recordable;
+            index: number;
+            key: string | number;
+            value: any;
+        }) => Promise<any>) | {
+            (): (data: {
+                record: Recordable;
+                index: number;
+                key: string | number;
+                value: any;
+            }) => Promise<any>;
+            new (): any;
+            readonly prototype: any;
+        }) | ((new (...args: any[]) => (data: {
+            record: Recordable;
+            index: number;
+            key: string | number;
+            value: any;
+        }) => Promise<any>) | (() => (data: {
             record: Recordable;
             index: number;
             key: string | number;
             value: any;
-        }) => Promise<any>>;
+        }) => Promise<any>) | {
+            (): (data: {
+                record: Recordable;
+                index: number;
+                key: string | number;
+                value: any;
+            }) => Promise<any>;
+            new (): any;
+            readonly prototype: any;
+        })[];
     };
     size: {
-        type: PropType<SizeType>;
+        type: ((new (...args: any[]) => "small" | "default" | "middle" | "large") | (() => SizeType)) | ((new (...args: any[]) => "small" | "default" | "middle" | "large") | (() => SizeType))[];
         default: string;
     };
 };
+export declare const basicPropChange: (options: any) => void;

package/es/ui/src/Table/src/types/table.d.ts

@@ -111,6 +111,8 @@ export interface TableActionType {
     setAllTreeExpand?: any;
     clearTreeExpand?: any;
     setTreeExpand?: any;
+    getVxeTableRef: any;
+    setSelectRowByKeys?: any;
 }
 export interface FetchSetting {
     pageField: string;

package/es/ui/src/TablePlus/TablePlus.vue.d.ts

@@ -145,6 +145,8 @@ declare const _sfc_main: import("vue").DefineComponent<{
     setAllTreeExpand: () => any;
     clearTreeExpand: () => any;
     setTreeExpand: (rows: any, checked: any) => any;
+    getVxeTableRef: () => any;
+    setSelectRowByKeys: (keys: any, checked: any) => void;
     tableAction: {
         reload: () => Promise<void>;
         setTableData: (data: any) => void;
@@ -157,6 +159,8 @@ declare const _sfc_main: import("vue").DefineComponent<{
         setAllTreeExpand: () => any;
         clearTreeExpand: () => any;
         setTreeExpand: (rows: any, checked: any) => any;
+        getVxeTableRef: () => any;
+        setSelectRowByKeys: (keys: any, checked: any) => void;
     };
     readonly BasicForm: 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>, {}>;
     readonly VxeTable: import("vxe-table").VXEComponent<import("vxe-table").VxeTableProps<any>, import("vxe-table").VxeTableEventProps>;
@@ -464,7 +468,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
             default: any;
         };
     }, {
-        emit: (event: "updateStatusEdit" | "edit-ensure" | "edit-cancel", ...args: any[]) => void;
+        emit: (event: "edit-cancel" | "updateStatusEdit" | "edit-ensure", ...args: any[]) => void;
         props: any;
         getActions: import("vue").ComputedRef<{
             label: string;
@@ -472,14 +476,14 @@ declare const _sfc_main: import("vue").DefineComponent<{
             ifShow: boolean;
         }[]>;
         TableAction: 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>, {}>;
-    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updateStatusEdit" | "edit-ensure" | "edit-cancel")[], "updateStatusEdit" | "edit-ensure" | "edit-cancel", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("edit-cancel" | "updateStatusEdit" | "edit-ensure")[], "edit-cancel" | "updateStatusEdit" | "edit-ensure", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
         row: {
             default: any;
         };
     }>> & {
+        "onEdit-cancel"?: (...args: any[]) => any;
         onUpdateStatusEdit?: (...args: any[]) => any;
         "onEdit-ensure"?: (...args: any[]) => any;
-        "onEdit-cancel"?: (...args: any[]) => any;
     }, {
         row: any;
     }>;
@@ -591,9 +595,11 @@ declare const _sfc_main: import("vue").DefineComponent<{
 }, {
     columns: unknown[];
     api: any;
+    searchInfo: any;
+    formConfig: any;
+    actionColumn: any;
     isShowSeq: boolean;
     isCompatible: boolean;
-    actionColumn: any;
     isShowSearch: boolean;
     isShowRowSelection: boolean;
     isShowAction: boolean;
@@ -602,8 +608,6 @@ declare const _sfc_main: import("vue").DefineComponent<{
     isShowToolbar: boolean;
     isImmediate: boolean;
     configRowSelection: any;
-    formConfig: any;
-    searchInfo: any;
     transSearchInfoBeforeReload: any;
     isUseEdit: boolean;
     transDataAfterReload: any;

package/es/ui/src/TablePlus/components/ButtonGroupEdit.vue.d.ts

@@ -3,7 +3,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
         default: any;
     };
 }, {
-    emit: (event: "updateStatusEdit" | "edit-ensure" | "edit-cancel", ...args: any[]) => void;
+    emit: (event: "edit-cancel" | "updateStatusEdit" | "edit-ensure", ...args: any[]) => void;
     props: any;
     getActions: import("vue").ComputedRef<{
         label: string;
@@ -11,14 +11,14 @@ declare const _sfc_main: import("vue").DefineComponent<{
         ifShow: boolean;
     }[]>;
     TableAction: 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>, {}>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updateStatusEdit" | "edit-ensure" | "edit-cancel")[], "updateStatusEdit" | "edit-ensure" | "edit-cancel", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("edit-cancel" | "updateStatusEdit" | "edit-ensure")[], "edit-cancel" | "updateStatusEdit" | "edit-ensure", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     row: {
         default: any;
     };
 }>> & {
+    "onEdit-cancel"?: (...args: any[]) => any;
     onUpdateStatusEdit?: (...args: any[]) => any;
     "onEdit-ensure"?: (...args: any[]) => any;
-    "onEdit-cancel"?: (...args: any[]) => any;
 }, {
     row: any;
 }>;

package/es/ui/src/Tree/src/BasicTree.vue.d.ts

@@ -71,6 +71,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
     loading: import("@shy-plugins/utils").BuildPropType<BooleanConstructor, unknown, unknown>;
     helpMessage: import("@shy-plugins/utils").BuildPropType<PropType<string | string[]>, unknown, unknown>;
     selectedKeys: KeyType[];
+    filterFn: (searchValue: any, node: TreeItem, fieldNames: FieldNames) => boolean;
     fieldNames: undefined;
     searchValue: string;
     treeData: import("ant-design-vue/es/tree").DataNode[];
@@ -85,7 +86,6 @@ declare const _sfc_main: import("vue").DefineComponent<{
     checkedKeys: CheckKeys;
     beforeRightClick: (...arg: any) => import("./types/tree").ContextMenuOptions | import("./types/tree").ContextMenuItem[];
     rightMenuList: import("./types/tree").ContextMenuItem[];
-    filterFn: (searchValue: any, node: TreeItem, fieldNames: FieldNames) => boolean;
     highlight: import("@shy-plugins/utils").BuildPropType<PropType<String | Boolean>, unknown, unknown>;
     expandOnSearch: boolean;
     checkOnSearch: boolean;

package/lib/index.js

@@ -7969,7 +7969,10 @@ const _sfc_main$I = vue.defineComponent({
         {
           text: "查询"
         },
-        props2.submitButtonOptions
+        {
+          ...props2.submitButtonOptions,
+          loading: false
+        }
       );
     });
     const getPreIcon = vue.computed(() => {
@@ -7994,7 +7997,6 @@ const _sfc_main$I = vue.defineComponent({
 });
 function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_BasicButton = vue.resolveComponent("BasicButton");
-  const _component_SearchOutlined = vue.resolveComponent("SearchOutlined");
   const _component_Button = vue.resolveComponent("Button");
   const _component_FormItem = vue.resolveComponent("FormItem");
   return _ctx.showActionButtonGroup ? (vue.openBlock(), vue.createElementBlock("div", {
@@ -8008,10 +8010,7 @@ function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
           key: 0,
           type: "default",
           class: "mr-2"
-        }, _ctx.getResetBtnOptions, {
-          onClick: _ctx.resetAction,
-          preIcon: "ant-design:sync-outlined"
-        }), {
+        }, _ctx.getResetBtnOptions, { onClick: _ctx.resetAction }), {
           default: vue.withCtx(() => [
             vue.createTextVNode(vue.toDisplayString(_ctx.getResetBtnOptions.text), 1)
           ]),
@@ -8023,11 +8022,8 @@ function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
           type: "primary",
           class: "mr-2"
         }, { ..._ctx.getSubmitBtnOptions }, { onClick: _ctx.submitAction }), {
-          icon: vue.withCtx(() => [
-            vue.createVNode(_component_SearchOutlined, { style: { "line-height": "14px", "transform": "translateY(3px)", "font-size": "14px", "box-sizing": "border-box" } })
-          ]),
           default: vue.withCtx(() => [
-            vue.createTextVNode(" " + vue.toDisplayString(_ctx.getSubmitBtnOptions.text), 1)
+            vue.createTextVNode(vue.toDisplayString(_ctx.getSubmitBtnOptions.text), 1)
           ]),
           _: 1
         }, 16, ["onClick"])) : vue.createCommentVNode("", true),
@@ -10251,7 +10247,7 @@ function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) {
             class: vue.normalizeClass(_ctx.getToggleClass),
             onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleToggleAdvanced && _ctx.handleToggleAdvanced(...args))
           }, [
-            vue.createVNode(_component_DownOutlined, { style: { fontSize: "10px", color: "#919191 " } })
+            vue.createVNode(_component_DownOutlined, { style: { fontSize: "10px", color: "#AED0FA " } })
           ], 2)
         ], 2)) : vue.createCommentVNode("", true)
       ];
@@ -11853,9 +11849,12 @@ const FETCH_SETTING = fetchSetting;
 const DEFAULT_SIZE = defaultSize;
 const DEFAULT_SORT_FN = defaultSortFn;
 const DEFAULT_FILTER_FN = defaultFilterFn;
-const DEFAULT_ALIGN = "center";
+let DEFAULT_ALIGN = "left";
 const INDEX_COLUMN_FLAG = "INDEX";
 const ACTION_COLUMN_FLAG = "ACTION";
+const setConstConfig = (config) => {
+  DEFAULT_ALIGN = config.align;
+};
 function itemRender({
   page,
   type,
@@ -14395,6 +14394,7 @@ function useTableForm(propsRef, slots, fetch, getLoading) {
     const { submitButtonOptions } = formConfig || {};
     return {
       showAdvancedButton: true,
+      rowProps: { gutter: 20 },
       ...formConfig,
       submitButtonOptions: {
         loading: vue.unref(getLoading),
@@ -14427,7 +14427,7 @@ function useTableForm(propsRef, slots, fetch, getLoading) {
     handleSearchInfoChange
   };
 }
-const basicProps$3 = {
+const basicProps$3 = vue.reactive({
   clickToRowSelect: { type: Boolean, default: true },
   isTreeTable: Boolean,
   tableSetting: utils.propTypes.shape({}),
@@ -14554,6 +14554,11 @@ const basicProps$3 = {
     type: String,
     default: DEFAULT_SIZE
   }
+});
+const basicPropChange = (options) => {
+  Object.keys(options).forEach((name) => {
+    basicProps$3[name] = options[name];
+  });
 };
 const _sfc_main$i = vue.defineComponent({
   components: {
@@ -15012,7 +15017,11 @@ const _sfc_main$g = vue.defineComponent({
     },
     divider: utils.propTypes.bool.def(true),
     outside: utils.propTypes.bool,
-    stopButtonPropagation: utils.propTypes.bool.def(false)
+    stopButtonPropagation: utils.propTypes.bool.def(false),
+    showCount: {
+      type: Number,
+      default: () => 2
+    }
   },
   setup(props2) {
     const { prefixCls: prefixCls2 } = use.useDesign("basic-table-action");
@@ -15032,8 +15041,8 @@ const _sfc_main$g = vue.defineComponent({
       return isIfShow2;
     }
     const getActions = vue.computed(() => {
-      return (vue.toRaw(props2.actions) || []).filter((action) => {
-        return isIfShow(action);
+      return (vue.toRaw(props2.actions) || []).filter((action, index2) => {
+        return isIfShow(action) && index2 < props2.showCount;
       }).map((action) => {
         const { popConfirm } = action;
         return {
@@ -15049,8 +15058,8 @@ const _sfc_main$g = vue.defineComponent({
       });
     });
     const getDropdownList = vue.computed(() => {
-      const list = (vue.toRaw(props2.dropDownActions) || []).filter((action) => {
-        return isIfShow(action);
+      const list = (vue.toRaw(props2.actions) || []).filter((action, index2) => {
+        return isIfShow(action) && index2 >= props2.showCount;
       });
       return list.map((action, index2) => {
         const { label, popConfirm } = action;
@@ -15153,7 +15162,7 @@ function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
         })) : vue.createCommentVNode("", true)
       ], 64);
     }), 128)),
-    _ctx.dropDownActions && _ctx.getDropdownList.length > 0 ? (vue.openBlock(), vue.createBlock(_component_Dropdown, {
+    _ctx.getDropdownList.length > 0 ? (vue.openBlock(), vue.createBlock(_component_Dropdown, {
       key: 0,
       trigger: ["hover"],
       dropMenuList: _ctx.getDropdownList,
@@ -15437,6 +15446,16 @@ function useTable(tableProps) {
   };
   return [register, methods2];
 }
+const withInstall$1 = (component) => {
+  const comp = component;
+  comp.install = (app, options = {}, config = {}) => {
+    basicPropChange(options);
+    setConstConfig(config);
+    app.component("BasicTable", component);
+  };
+  return component;
+};
+withInstall$1(BasicTable);
 const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
   __name: "Table",
   setup(__props, { expose }) {
@@ -19911,7 +19930,6 @@ const useTableData = (getProps, { setPage, params }) => {
     var _a2;
     if ((_a2 = getProps.value) == null ? void 0 : _a2.api) {
       const res = await getProps.value.api(params.value);
-      console.log("1", getProps.value.transDataAfterReload(res));
       setTableData(getProps.value.transDataAfterReload(res));
       setPage({ total: (res == null ? void 0 : res.total) || 0 });
     }
@@ -20069,7 +20087,6 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const innerProps = vue.ref({});
     const getProps = vue.computed(() => {
       const tempProps = { ...props2, ...innerProps.value };
-      console.log("1", props2);
       if (tempProps.isCompatible) {
         tempProps.columns.forEach((column) => {
           column.field = column.dataIndex;
@@ -20091,13 +20108,6 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         ...getProps.value
       };
     });
-    vue.watchEffect(() => {
-      getBindValues.value;
-      console.log(
-        "🚀 ~ file: TablePlus.vue:263 ~ watchEffect ~ getBindValues:",
-        getBindValues.value
-      );
-    });
     const getColumns = vue.computed(() => {
       return getProps.value.columns.map((item) => {
         return { ...basicColumn, ...item };
@@ -20175,6 +20185,18 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const setTreeExpand = (rows, checked) => {
       return vue.toRaw(tableRef.value.setTreeExpand(rows, checked));
     };
+    const getVxeTableRef = () => {
+      return tableRef.value;
+    };
+    const setSelectRowByKeys = (keys2, checked) => {
+      tableRef.value.getTableData();
+      const rows = [];
+      keys2.forEach((key2) => {
+        const row = tableRef.value.getRowById(key2);
+        rows.push(row);
+      });
+      tableRef.value.setCheckboxRow(rows, checked);
+    };
     const tableAction = {
       reload,
       setTableData,
@@ -20186,7 +20208,9 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       getTreeExpandRecords,
       setAllTreeExpand,
       clearTreeExpand,
-      setTreeExpand
+      setTreeExpand,
+      getVxeTableRef,
+      setSelectRowByKeys
     };
     emits("register", tableAction, formActions);
     return (_ctx, _cache) => {
@@ -20368,7 +20392,9 @@ function useTablePlus(tableProps) {
     getTreeExpandRecords: () => getTableInstance().getTreeExpandRecords(),
     setAllTreeExpand: () => getTableInstance().setAllTreeExpand(),
     clearTreeExpand: () => getTableInstance().clearTreeExpand(),
-    setTreeExpand: (rows, checked) => getTableInstance().setTreeExpand(rows, checked)
+    setTreeExpand: (rows, checked) => getTableInstance().setTreeExpand(rows, checked),
+    getVxeTableRef: () => getTableInstance().getVxeTableRef(),
+    setSelectRowByKeys: (keys2, checked) => getTableInstance().setSelectRowByKeys(keys2, checked)
   };
   return [register, methods2];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3h1-ui",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "",
   "main": "lib/index.js",
   "module": "es/index.js",