vxe-table 4.13.40 → 4.13.41

package/es/table/src/cell.js

@@ -367,20 +367,6 @@ export const Cell = {
         const { field, slots, editRender, cellRender, rowGroupNode, aggFunc } = column;
         const renderOpts = editRender || cellRender;
         const defaultSlot = slots ? slots.default : null;
-        if (defaultSlot) {
-            return renderCellBaseVNs(params, $table.callSlot(defaultSlot, params));
-        }
-        if (renderOpts) {
-            const compConf = renderer.get(renderOpts.name);
-            if (compConf) {
-                const rtCell = compConf.renderTableCell || compConf.renderCell;
-                const rtDefault = compConf.renderTableDefault || compConf.renderDefault;
-                const renderFn = editRender ? rtCell : rtDefault;
-                if (renderFn) {
-                    return renderCellBaseVNs(params, getSlotVNs(renderFn(renderOpts, Object.assign({ $type: editRender ? 'edit' : 'cell' }, params))));
-                }
-            }
-        }
         let cellValue = '';
         if (isRowGroupStatus && field && row.isAggregate) {
             const aggRow = row;
@@ -429,6 +415,20 @@ export const Cell = {
             }
         }
         else {
+            if (defaultSlot) {
+                return renderCellBaseVNs(params, $table.callSlot(defaultSlot, params));
+            }
+            if (renderOpts) {
+                const compConf = renderer.get(renderOpts.name);
+                if (compConf) {
+                    const rtCell = compConf.renderTableCell || compConf.renderCell;
+                    const rtDefault = compConf.renderTableDefault || compConf.renderDefault;
+                    const renderFn = editRender ? rtCell : rtDefault;
+                    if (renderFn) {
+                        return renderCellBaseVNs(params, getSlotVNs(renderFn(renderOpts, Object.assign({ $type: editRender ? 'edit' : 'cell' }, params))));
+                    }
+                }
+            }
             cellValue = $table.getCellLabel(row, column);
         }
         const cellPlaceholder = editRender ? editRender.placeholder : '';

package/es/toolbar/src/toolbar.js

@@ -10,11 +10,17 @@ export default defineVxeComponent({
     props: {
         loading: Boolean,
         refresh: [Boolean, Object],
+        refreshOptions: Object,
         import: [Boolean, Object],
+        importOptions: Object,
         export: [Boolean, Object],
+        exportOptions: Object,
         print: [Boolean, Object],
+        printOptions: Object,
         zoom: [Boolean, Object],
+        zoomOptions: Object,
         custom: [Boolean, Object],
+        customOptions: Object,
         buttons: {
             type: Array,
             default: () => getConfig().toolbar.buttons
@@ -66,22 +72,22 @@ export default defineVxeComponent({
         let toolbarMethods = {};
         const $xeGrid = inject('$xeGrid', null);
         const computeRefreshOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.refresh, true), props.refresh);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.refresh, true), props.refreshOptions, props.refresh);
         });
         const computeImportOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.import, true), props.import);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.import, true), props.importOptions, props.import);
         });
         const computeExportOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.export, true), props.export);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.export, true), props.exportOptions, props.export);
         });
         const computePrintOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.print, true), props.print);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.print, true), props.printOptions, props.print);
         });
         const computeZoomOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.zoom, true), props.zoom);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.zoom, true), props.zoomOptions, props.zoom);
         });
         const computeCustomOpts = computed(() => {
-            return Object.assign({}, XEUtils.clone(getConfig().toolbar.custom, true), props.custom);
+            return Object.assign({}, XEUtils.clone(getConfig().toolbar.custom, true), props.customOptions, props.custom);
         });
         const computeTableCustomOpts = computed(() => {
             const { connectTable } = internalData;
@@ -163,56 +169,20 @@ export default defineVxeComponent({
             if ($xeGrid) {
                 $xeGrid.triggerZoomEvent($event);
             }
-        };
-        const btnEvent = (evnt, item) => {
-            const { connectTable } = internalData;
-            const $table = connectTable;
-            const { code } = item;
-            if (code) {
-                if ($xeGrid) {
-                    $xeGrid.triggerToolbarBtnEvent(item, evnt);
-                }
-                else {
-                    const gCommandOpts = commands.get(code);
-                    const params = { code, button: item, $table: $table, $grid: $xeGrid, $event: evnt };
-                    if (gCommandOpts) {
-                        const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
-                        if (tCommandMethod) {
-                            tCommandMethod(params);
-                        }
-                        else {
-                            errLog('vxe.error.notCommands', [code]);
-                        }
-                    }
-                    $xeToolbar.dispatchEvent('button-click', params, evnt);
-                }
+            else {
+                warnLog('vxe.error.notProp', ['zoom']);
             }
         };
-        const tolEvent = (evnt, item) => {
-            const { connectTable } = internalData;
-            const $table = connectTable;
-            const { code } = item;
-            if (code) {
-                if ($xeGrid) {
-                    $xeGrid.triggerToolbarTolEvent(item, evnt);
-                }
-                else {
-                    const gCommandOpts = commands.get(code);
-                    const params = { code, button: null, tool: item, $table: $table, $grid: $xeGrid, $event: evnt };
-                    if (gCommandOpts) {
-                        const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
-                        if (tCommandMethod) {
-                            tCommandMethod(params);
-                        }
-                        else {
-                            errLog('vxe.error.notCommands', [code]);
-                        }
-                    }
-                    $xeToolbar.dispatchEvent('tool-click', params, evnt);
+        const importEvent = () => {
+            if (checkTable()) {
+                const { connectTable } = internalData;
+                const $table = connectTable;
+                if ($table) {
+                    $table.importData();
                 }
             }
         };
-        const importEvent = () => {
+        const openImportEvent = () => {
             if (checkTable()) {
                 const { connectTable } = internalData;
                 const $table = connectTable;
@@ -222,6 +192,15 @@ export default defineVxeComponent({
             }
         };
         const exportEvent = () => {
+            if (checkTable()) {
+                const { connectTable } = internalData;
+                const $table = connectTable;
+                if ($table) {
+                    $table.exportData();
+                }
+            }
+        };
+        const openExportEvent = () => {
             if (checkTable()) {
                 const { connectTable } = internalData;
                 const $table = connectTable;
@@ -231,6 +210,15 @@ export default defineVxeComponent({
             }
         };
         const printEvent = () => {
+            if (checkTable()) {
+                const { connectTable } = internalData;
+                const $table = connectTable;
+                if ($table) {
+                    $table.print();
+                }
+            }
+        };
+        const openPrintEvent = () => {
             if (checkTable()) {
                 const { connectTable } = internalData;
                 const $table = connectTable;
@@ -239,6 +227,94 @@ export default defineVxeComponent({
                 }
             }
         };
+        const handleDefaultCodeEvent = (eventParams, item, cb) => {
+            switch (item.code) {
+                case 'print':
+                    printEvent();
+                    break;
+                case 'open_print':
+                    openPrintEvent();
+                    break;
+                case 'custom':
+                    handleClickSettingEvent(eventParams);
+                    break;
+                case 'export':
+                    exportEvent();
+                    break;
+                case 'open_export':
+                    openExportEvent();
+                    break;
+                case 'import':
+                    importEvent();
+                    break;
+                case 'open_import':
+                    openImportEvent();
+                    break;
+                case 'zoom':
+                    zoomEvent(eventParams);
+                    break;
+                case 'refresh':
+                    refreshEvent(eventParams);
+                    break;
+                default:
+                    cb();
+                    break;
+            }
+        };
+        const btnEvent = (eventParams, item) => {
+            const { $event } = eventParams;
+            const { connectTable } = internalData;
+            const $table = connectTable;
+            const { code } = item;
+            if (code) {
+                handleDefaultCodeEvent(eventParams, item, () => {
+                    if ($xeGrid) {
+                        $xeGrid.triggerToolbarBtnEvent(item, $event);
+                    }
+                    else {
+                        const gCommandOpts = commands.get(code);
+                        const params = { code, button: item, $table: $table, $grid: $xeGrid, $event };
+                        if (gCommandOpts) {
+                            const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
+                            if (tCommandMethod) {
+                                tCommandMethod(params);
+                            }
+                            else {
+                                errLog('vxe.error.notCommands', [code]);
+                            }
+                        }
+                        $xeToolbar.dispatchEvent('button-click', params, $event);
+                    }
+                });
+            }
+        };
+        const tolEvent = (eventParams, item) => {
+            const { $event } = eventParams;
+            const { connectTable } = internalData;
+            const $table = connectTable;
+            const { code } = item;
+            if (code) {
+                handleDefaultCodeEvent(eventParams, item, () => {
+                    if ($xeGrid) {
+                        $xeGrid.triggerToolbarTolEvent(item, $event);
+                    }
+                    else {
+                        const gCommandOpts = commands.get(code);
+                        const params = { code, button: null, tool: item, $table: $table, $grid: $xeGrid, $event };
+                        if (gCommandOpts) {
+                            const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
+                            if (tCommandMethod) {
+                                tCommandMethod(params);
+                            }
+                            else {
+                                errLog('vxe.error.notCommands', [code]);
+                            }
+                        }
+                        $xeToolbar.dispatchEvent('tool-click', params, $event);
+                    }
+                });
+            }
+        };
         const dispatchEvent = (type, params, evnt) => {
             emit(type, createEvent(evnt, { $toolbar: $xeToolbar }, params));
         };
@@ -276,7 +352,7 @@ export default defineVxeComponent({
                             permissionCode: child.permissionCode,
                             prefixTooltip: child.prefixTooltip,
                             suffixTooltip: child.suffixTooltip,
-                            onClick: ({ $event }) => isBtn ? btnEvent($event, child) : tolEvent($event, child)
+                            onClick: (eventParams) => isBtn ? btnEvent(eventParams, child) : tolEvent(eventParams, child)
                         })
                         : createCommentVNode();
                 });
@@ -330,7 +406,7 @@ export default defineVxeComponent({
                                     destroyOnClose: item.destroyOnClose,
                                     placement: item.placement,
                                     transfer: item.transfer,
-                                    onClick: ({ $event }) => btnEvent($event, item)
+                                    onClick: (eventParams) => btnEvent(eventParams, item)
                                 }, dropdowns && dropdowns.length
                                     ? {
                                         dropdowns: () => renderDropdowns(item, true)
@@ -394,7 +470,7 @@ export default defineVxeComponent({
                                     destroyOnClose: item.destroyOnClose,
                                     placement: item.placement,
                                     transfer: item.transfer,
-                                    onClick: ({ $event }) => tolEvent($event, item)
+                                    onClick: (eventParams) => tolEvent(eventParams, item)
                                 }, dropdowns && dropdowns.length
                                     ? {
                                         dropdowns: () => renderDropdowns(item, false)
@@ -418,7 +494,7 @@ export default defineVxeComponent({
                     circle: true,
                     icon: importOpts.icon || getIcon().TOOLBAR_TOOLS_IMPORT,
                     title: getI18n('vxe.toolbar.import'),
-                    onClick: importEvent
+                    onClick: openImportEvent
                 })
                 : createCommentVNode();
         };
@@ -430,7 +506,7 @@ export default defineVxeComponent({
                     circle: true,
                     icon: exportOpts.icon || getIcon().TOOLBAR_TOOLS_EXPORT,
                     title: getI18n('vxe.toolbar.export'),
-                    onClick: exportEvent
+                    onClick: openExportEvent
                 })
                 : createCommentVNode();
         };
@@ -442,7 +518,7 @@ export default defineVxeComponent({
                     circle: true,
                     icon: printOpts.icon || getIcon().TOOLBAR_TOOLS_PRINT,
                     title: getI18n('vxe.toolbar.print'),
-                    onClick: printEvent
+                    onClick: openPrintEvent
                 })
                 : createCommentVNode();
         };
@@ -525,12 +601,29 @@ export default defineVxeComponent({
         };
         $xeToolbar.renderVN = renderVN;
         nextTick(() => {
-            const { refresh } = props;
             const refreshOpts = computeRefreshOpts.value;
             const queryMethod = refreshOpts.queryMethod || refreshOpts.query;
-            if (refresh && !$xeGrid && !queryMethod) {
+            if (props.refresh && !$xeGrid && !queryMethod) {
                 warnLog('vxe.error.notFunc', ['queryMethod']);
             }
+            if (XEUtils.isPlainObject(props.custom)) {
+                warnLog('vxe.error.delProp', ['custom={...}', 'custom=boolean & custom-options={...}']);
+            }
+            if (XEUtils.isPlainObject(props.print)) {
+                warnLog('vxe.error.delProp', ['print={...}', 'print=boolean & print-options={...}']);
+            }
+            if (XEUtils.isPlainObject(props.export)) {
+                warnLog('vxe.error.delProp', ['export={...}', 'export=boolean & export-options={...}']);
+            }
+            if (XEUtils.isPlainObject(props.import)) {
+                warnLog('vxe.error.delProp', ['import={...}', 'import=boolean & import-options={...}']);
+            }
+            if (XEUtils.isPlainObject(props.refresh)) {
+                warnLog('vxe.error.delProp', ['refresh={...}', 'refresh=boolean & refresh-options={...}']);
+            }
+            if (XEUtils.isPlainObject(props.refresh)) {
+                warnLog('vxe.error.delProp', ['zoom={...}', 'zoom=boolean & zoom-options={...}']);
+            }
             const customOpts = computeCustomOpts.value;
             if (customOpts.isFooter) {
                 warnLog('vxe.error.delProp', ['toolbar.custom.isFooter', 'table.custom-config.showFooter']);

package/es/ui/index.js

@@ -1,6 +1,6 @@
 import { VxeUI } from '@vxe-ui/core';
 import { getFuncText } from './src/utils';
-export const version = "4.13.39";
+export const version = "4.13.41";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({
@@ -94,6 +94,14 @@ VxeUI.setConfig({
             showFooter: true,
             placement: 'top-right',
             //  storage: false,
+            storeOptions: {
+                visible: true,
+                resizable: true,
+                sort: true,
+                fixed: true
+                // rowGroup: false,
+                // aggFunc: false
+            },
             //  checkMethod () {},
             modalOptions: {
                 showMaximize: true,

package/es/ui/src/log.js

@@ -1,5 +1,5 @@
 import { VxeUI } from '@vxe-ui/core';
 const { log } = VxeUI;
-const version = `table v${"4.13.39"}`;
+const version = `table v${"4.13.41"}`;
 export const warnLog = log.create('warn', version);
 export const errLog = log.create('error', version);