@vxe-ui/plugin-render-element 4.2.4 → 4.3.1

package/es/table/index.js

@@ -0,0 +1,633 @@
+import { h } from 'vue';
+import { getCurrComponent, hasInputType } from '../util/comp';
+import XEUtils from 'xe-utils';
+import dayjs from 'dayjs';
+/**
+ * 表格 - 渲染器
+ */
+export function defineTableRender(VxeUI) {
+    function isEmptyValue(cellValue) {
+        return cellValue === null || cellValue === undefined || cellValue === '';
+    }
+    function getOnName(type) {
+        return 'on' + type.substring(0, 1).toLocaleUpperCase() + type.substring(1);
+    }
+    function getModelProp(renderOpts) {
+        return 'modelValue';
+    }
+    function getModelEvent(renderOpts) {
+        return 'update:modelValue';
+    }
+    function getChangeEvent(renderOpts) {
+        let type = 'change';
+        switch (renderOpts.name) {
+            case 'ElAutocomplete':
+                type = 'select';
+                break;
+            case 'ElInput':
+            case 'ElInputNumber':
+                type = 'input';
+                break;
+        }
+        return type;
+    }
+    function toDayStringDate(value, format) {
+        return dayjs(value, format).toDate();
+    }
+    function toDayDateString(date, format) {
+        return dayjs(date).format(format);
+    }
+    function parseDate(value, props) {
+        return value && props.valueFormat ? toDayStringDate(value, props.valueFormat) : value;
+    }
+    function getFormatDate(value, props, defaultFormat) {
+        return value ? toDayDateString(parseDate(value, props), props.format || props.valueFormat || defaultFormat) : value;
+    }
+    function getFormatDates(values, props, separator, defaultFormat) {
+        return XEUtils.map(values, (date) => getFormatDate(date, props, defaultFormat)).join(separator);
+    }
+    function equalDateRange(cellValue, data, props, defaultFormat) {
+        cellValue = getFormatDate(cellValue, props, defaultFormat);
+        return cellValue >= getFormatDate(data[0], props, defaultFormat) && cellValue <= getFormatDate(data[1], props, defaultFormat);
+    }
+    function getCellEditFilterProps(renderOpts, params, value, defaultProps) {
+        return XEUtils.assign({}, defaultProps, renderOpts.props, { [getModelProp(renderOpts)]: value });
+    }
+    function formatText(cellValue) {
+        return '' + (isEmptyValue(cellValue) ? '' : cellValue);
+    }
+    function updateFilterChangeOption(params, checked, option) {
+        const { $table } = params;
+        $table.updateFilterOptionStatus(option, checked);
+    }
+    function saveFilterEvent(params) {
+        const { $table, column } = params;
+        $table.saveFilterByEvent(new Event('change'), column);
+    }
+    function getCellLabelVNs(renderOpts, params, cellLabel) {
+        const { placeholder } = renderOpts;
+        return [
+            h('span', {
+                class: 'vxe-cell--label'
+            }, placeholder && isEmptyValue(cellLabel)
+                ? [
+                    h('span', {
+                        class: 'vxe-cell--placeholder'
+                    }, formatText(VxeUI.getI18n(placeholder)))
+                ]
+                : formatText(cellLabel))
+        ];
+    }
+    const blurEvent = 'blur';
+    const clearEvent = 'clear';
+    /**
+   * 组件事件处理
+   * @param renderOpts
+   * @param params
+   * @param modelFunc
+   * @param changeFunc
+   */
+    function getComponentOns(renderOpts, params, eFns, eventOns) {
+        const { events } = renderOpts;
+        const modelEvent = getModelEvent(renderOpts);
+        const changeEvent = getChangeEvent(renderOpts);
+        const { model: modelFunc, change: changeFunc, blur: blurFunc, clear: clearFunc } = eFns || {};
+        const ons = {};
+        XEUtils.objectEach(events, (func, key) => {
+            ons[getOnName(key)] = function (...args) {
+                if (!XEUtils.isFunction(func)) {
+                    console.error(`Parameter "${func}" is not a method`);
+                }
+                func(params, ...args);
+            };
+        });
+        if (modelFunc) {
+            ons[getOnName(modelEvent)] = function (targetEvnt) {
+                modelFunc(targetEvnt);
+                if (events && events[modelEvent]) {
+                    events[modelEvent](params, targetEvnt);
+                }
+            };
+        }
+        if (changeFunc) {
+            ons[getOnName(changeEvent)] = function (...args) {
+                changeFunc(...args);
+                if (events && events[changeEvent]) {
+                    events[changeEvent](params, ...args);
+                }
+            };
+        }
+        if (blurFunc) {
+            ons[getOnName(blurEvent)] = function (...args) {
+                blurFunc(...args);
+                if (events && events[blurEvent]) {
+                    events[blurEvent](params, ...args);
+                }
+            };
+        }
+        if (clearFunc) {
+            ons[getOnName(clearEvent)] = function (...args) {
+                clearFunc(...args);
+                if (events && events[clearEvent]) {
+                    events[clearEvent](params, ...args);
+                }
+            };
+        }
+        return eventOns ? Object.assign(ons, eventOns) : ons;
+    }
+    function getEditOns(renderOpts, params) {
+        const { $table, row, column } = params;
+        return getComponentOns(renderOpts, params, {
+            model(value) {
+                // 处理 model 值双向绑定
+                XEUtils.set(row, column.field, value);
+            },
+            change() {
+                // 处理 change 事件相关逻辑
+                $table.updateStatus(params);
+            }
+        });
+    }
+    function getFilterOns(renderOpts, params, option, changeFunc) {
+        return getComponentOns(renderOpts, params, {
+            model(value) {
+                // 处理 model 值双向绑定
+                option.data = value;
+            },
+            change: changeFunc
+        });
+    }
+    function getFloatingFilterOns(renderOpts, params, option) {
+        const { $table, column } = params;
+        if (hasInputType(renderOpts)) {
+            return getComponentOns(renderOpts, params, {
+                model(value) {
+                    // 处理 model 值双向绑定
+                    option.data = value;
+                },
+                change() {
+                    updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+                },
+                clear() {
+                    updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+                    saveFilterEvent(params);
+                },
+                blur() {
+                    $table.saveFilterByEvent(new Event('change'), column);
+                }
+            });
+        }
+        return getComponentOns(renderOpts, params, {
+            model(value) {
+                // 处理 model 值双向绑定
+                option.data = value;
+            },
+            clear() {
+                updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+                $table.saveFilterByEvent(new Event('change'), column);
+            },
+            change() {
+                updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+                $table.saveFilterByEvent(new Event('change'), column);
+            }
+        });
+    }
+    function matchCascaderData(index, list, values, labels) {
+        const val = values[index];
+        if (list && values.length > index) {
+            XEUtils.each(list, (item) => {
+                if (item.value === val) {
+                    labels.push(item.label);
+                    matchCascaderData(++index, item.children, values, labels);
+                }
+            });
+        }
+    }
+    function getSelectCellValue(renderOpts, params) {
+        const { options = [], optionGroups, props = {}, optionProps = {}, optionGroupProps = {} } = renderOpts;
+        const { $table, rowid, row, column } = params;
+        const { filterable, multiple } = props;
+        const labelProp = optionProps.label || 'label';
+        const valueProp = optionProps.value || 'value';
+        const groupOptions = optionGroupProps.options || 'options';
+        const cellValue = XEUtils.get(row, column.field);
+        const colid = column.id;
+        let cellData;
+        if (filterable) {
+            const { internalData } = $table;
+            const { fullAllDataRowIdData } = internalData;
+            const rest = fullAllDataRowIdData[rowid];
+            if (rest) {
+                cellData = rest.cellData;
+                if (!cellData) {
+                    cellData = rest.cellData = {};
+                }
+            }
+            if (rest && cellData[colid] && cellData[colid].value === cellValue) {
+                return cellData[colid].label;
+            }
+        }
+        if (!isEmptyValue(cellValue)) {
+            const selectlabel = XEUtils.map(multiple ? cellValue : [cellValue], optionGroups
+                ? (value) => {
+                    let selectItem;
+                    for (let index = 0; index < optionGroups.length; index++) {
+                        selectItem = XEUtils.find(optionGroups[index][groupOptions], (item) => item[valueProp] === value);
+                        if (selectItem) {
+                            break;
+                        }
+                    }
+                    return selectItem ? selectItem[labelProp] : value;
+                }
+                : (value) => {
+                    const selectItem = XEUtils.find(options, (item) => item[valueProp] === value);
+                    return selectItem ? selectItem[labelProp] : value;
+                }).join(', ');
+            if (cellData && options && options.length) {
+                cellData[colid] = { value: cellValue, label: selectlabel };
+            }
+            return selectlabel;
+        }
+        return '';
+    }
+    function getCascaderCellValue(renderOpts, params) {
+        const { props = {} } = renderOpts;
+        const { row, column } = params;
+        const cellValue = XEUtils.get(row, column.field);
+        const values = cellValue || [];
+        const labels = [];
+        matchCascaderData(0, props.options, values, labels);
+        return (props.showAllLevels === false ? labels.slice(labels.length - 1, labels.length) : labels).join(` ${props.separator || '/'} `);
+    }
+    function getDatePickerCellValue(renderOpts, params) {
+        const { props = {} } = renderOpts;
+        const { row, column } = params;
+        const { rangeSeparator = '-' } = props;
+        let cellValue = XEUtils.get(row, column.field);
+        switch (props.type) {
+            case 'week':
+                cellValue = getFormatDate(cellValue, props, 'YYYYwWW');
+                break;
+            case 'month':
+                cellValue = getFormatDate(cellValue, props, 'YYYY-MM');
+                break;
+            case 'year':
+                cellValue = getFormatDate(cellValue, props, 'YYYY');
+                break;
+            case 'dates':
+                cellValue = getFormatDates(cellValue, props, ', ', 'YYYY-MM-DD');
+                break;
+            case 'daterange':
+                cellValue = getFormatDates(cellValue, props, ` ${rangeSeparator} `, 'YYYY-MM-DD');
+                break;
+            case 'datetimerange':
+                cellValue = getFormatDates(cellValue, props, ` ${rangeSeparator} `, 'YYYY-MM-DD HH:ss:mm');
+                break;
+            case 'monthrange':
+                cellValue = getFormatDates(cellValue, props, ` ${rangeSeparator} `, 'YYYY-MM');
+                break;
+            default:
+                cellValue = getFormatDate(cellValue, props, 'YYYY-MM-DD');
+        }
+        return cellValue;
+    }
+    function getTimePickerCellValue(renderOpts, params) {
+        const { props = {} } = renderOpts;
+        const { row, column } = params;
+        const { isRange, format = 'HH:mm:ss', rangeSeparator = '-' } = props;
+        let cellValue = XEUtils.get(row, column.field);
+        if (cellValue && isRange) {
+            cellValue = XEUtils.map(cellValue, (date) => toDayDateString(parseDate(date, props), format)).join(` ${rangeSeparator} `);
+        }
+        return toDayDateString(parseDate(cellValue, props), format);
+    }
+    function createEditRender(defaultProps) {
+        return function (renderOpts, params) {
+            const { row, column } = params;
+            const { name, attrs, props } = renderOpts;
+            const cellValue = XEUtils.get(row, column.field);
+            return [
+                h(getCurrComponent(name), Object.assign(Object.assign(Object.assign(Object.assign({}, attrs), props), getCellEditFilterProps(renderOpts, params, cellValue, defaultProps)), getEditOns(renderOpts, params)))
+            ];
+        };
+    }
+    function defaultButtonEditRender(renderOpts, params) {
+        const { attrs, props } = renderOpts;
+        return [
+            h(getCurrComponent('el-button'), Object.assign(Object.assign(Object.assign(Object.assign({}, attrs), props), getCellEditFilterProps(renderOpts, params, null)), getComponentOns(renderOpts, params)), cellText(renderOpts.content))
+        ];
+    }
+    function defaultButtonsEditRender(renderOpts, params) {
+        const { children } = renderOpts;
+        if (children) {
+            return children.map((childRenderOpts) => defaultButtonEditRender(childRenderOpts, params)[0]);
+        }
+        return [];
+    }
+    function createFilterRender(defaultProps) {
+        return function (renderOpts, params) {
+            const { column } = params;
+            const { name, attrs, props } = renderOpts;
+            return [
+                h('div', {
+                    class: 'vxe-table--filter-element-wrapper'
+                }, column.filters.map((option, oIndex) => {
+                    const optionValue = option.data;
+                    return h(getCurrComponent(name), Object.assign(Object.assign(Object.assign(Object.assign({ key: oIndex }, attrs), props), getCellEditFilterProps(renderOpts, params, optionValue, defaultProps)), getFilterOns(renderOpts, params, option, () => {
+                        // 处理 change 事件相关逻辑
+                        handleConfirmFilter(params, !!option.data, option);
+                    })));
+                }))
+            ];
+        };
+    }
+    function createFloatingFilterRender(defaultProps) {
+        return function (renderOpts, params) {
+            const { option } = params;
+            const { name, attrs, props } = renderOpts;
+            const optionValue = option.data;
+            return [
+                h(getCurrComponent(name), Object.assign(Object.assign(Object.assign(Object.assign({}, attrs), props), getCellEditFilterProps(renderOpts, params, optionValue, defaultProps)), getFloatingFilterOns(renderOpts, params, option)))
+            ];
+        };
+    }
+    function handleConfirmFilter(params, checked, option) {
+        const { $panel } = params;
+        $panel.changeOption(null, checked, option);
+    }
+    /**
+     * 模糊匹配
+     * @param params
+     */
+    function defaultFuzzyFilterMethod(params) {
+        const { option, row, column } = params;
+        const { data } = option;
+        const cellValue = XEUtils.get(row, column.field);
+        return XEUtils.toValueString(cellValue).indexOf(data) > -1;
+    }
+    /**
+     * 精确匹配
+     * @param params
+     */
+    function defaultExactFilterMethod(params) {
+        const { option, row, column } = params;
+        const { data } = option;
+        const cellValue = XEUtils.get(row, column.field);
+        /* eslint-disable eqeqeq */
+        return cellValue === data;
+    }
+    function renderOptions(options, optionProps) {
+        const labelProp = optionProps.label || 'label';
+        const valueProp = optionProps.value || 'value';
+        return XEUtils.map(options, (item, oIndex) => {
+            return h(getCurrComponent('el-option'), {
+                key: oIndex,
+                value: item[valueProp],
+                label: item[labelProp],
+                disabled: item.disabled
+            });
+        });
+    }
+    function cellText(cellValue) {
+        return [formatText(cellValue)];
+    }
+    function createExportMethod(getExportCellValue) {
+        return function (params) {
+            const { row, column, options } = params;
+            return options && options.original ? XEUtils.get(row, column.field) : getExportCellValue(column.editRender || column.cellRender, params);
+        };
+    }
+    function defaultFilterOptions() {
+        return [
+            { data: null }
+        ];
+    }
+    VxeUI.renderer.mixin({
+        ElAutocomplete: {
+            tableAutoFocus: 'input',
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter: createFilterRender(),
+            tableFilterDefaultMethod: defaultExactFilterMethod
+        },
+        ElInput: {
+            tableAutoFocus: 'input',
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter: createFilterRender(),
+            renderTableFloatingFilter: createFloatingFilterRender(),
+            tableFilterDefaultMethod: defaultFuzzyFilterMethod
+        },
+        ElInputNumber: {
+            tableAutoFocus: 'input',
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter: createFilterRender(),
+            renderTableFloatingFilter: createFloatingFilterRender(),
+            tableFilterDefaultMethod: defaultFuzzyFilterMethod
+        },
+        ElSelect: {
+            tableAutoFocus: 'input',
+            renderTableEdit(renderOpts, params) {
+                const { options = [], optionGroups, optionProps = {}, optionGroupProps = {} } = renderOpts;
+                const { row, column } = params;
+                const { attrs } = renderOpts;
+                const cellValue = XEUtils.get(row, column.field);
+                const props = getCellEditFilterProps(renderOpts, params, cellValue);
+                const ons = getEditOns(renderOpts, params);
+                if (optionGroups) {
+                    const groupOptions = optionGroupProps.options || 'options';
+                    const groupLabel = optionGroupProps.label || 'label';
+                    return [
+                        h(getCurrComponent('el-select'), Object.assign(Object.assign(Object.assign({}, attrs), props), ons), {
+                            default: () => {
+                                return XEUtils.map(optionGroups, (group, gIndex) => {
+                                    return h(getCurrComponent('el-option-group'), {
+                                        key: gIndex,
+                                        label: group[groupLabel]
+                                    }, {
+                                        default: () => renderOptions(group[groupOptions], optionProps)
+                                    });
+                                });
+                            }
+                        })
+                    ];
+                }
+                return [
+                    h(getCurrComponent('el-select'), Object.assign(Object.assign(Object.assign({}, props), attrs), ons), {
+                        default: () => renderOptions(options, optionProps)
+                    })
+                ];
+            },
+            renderTableCell(renderOpts, params) {
+                return getCellLabelVNs(renderOpts, params, getSelectCellValue(renderOpts, params));
+            },
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter(renderOpts, params) {
+                const { options = [], optionGroups, optionProps = {}, optionGroupProps = {} } = renderOpts;
+                const groupOptions = optionGroupProps.options || 'options';
+                const groupLabel = optionGroupProps.label || 'label';
+                const { column } = params;
+                const { attrs } = renderOpts;
+                return [
+                    h('div', {
+                        class: 'vxe-table--filter-element-wrapper'
+                    }, optionGroups
+                        ? column.filters.map((option, oIndex) => {
+                            const optionValue = option.data;
+                            const props = getCellEditFilterProps(renderOpts, params, optionValue);
+                            return h(getCurrComponent('el-select'), Object.assign(Object.assign(Object.assign({ key: oIndex }, attrs), props), getFilterOns(renderOpts, params, option, () => {
+                                // 处理 change 事件相关逻辑
+                                handleConfirmFilter(params, props.multiple ? (option.data && option.data.length > 0) : !XEUtils.eqNull(option.data), option);
+                            })), {
+                                default: () => {
+                                    return XEUtils.map(optionGroups, (group, gIndex) => {
+                                        return h(getCurrComponent('el-option-group'), {
+                                            key: gIndex,
+                                            label: group[groupLabel]
+                                        }, {
+                                            default: () => renderOptions(group[groupOptions], optionProps)
+                                        });
+                                    });
+                                }
+                            });
+                        })
+                        : column.filters.map((option, oIndex) => {
+                            const optionValue = option.data;
+                            const props = getCellEditFilterProps(renderOpts, params, optionValue);
+                            return h(getCurrComponent('el-select'), Object.assign(Object.assign(Object.assign({ key: oIndex }, attrs), props), getFilterOns(renderOpts, params, option, () => {
+                                // 处理 change 事件相关逻辑
+                                handleConfirmFilter(params, props.multiple ? (option.data && option.data.length > 0) : !XEUtils.eqNull(option.data), option);
+                            })), {
+                                default: () => renderOptions(options, optionProps)
+                            });
+                        }))
+                ];
+            },
+            tableFilterDefaultMethod(params) {
+                const { option, row, column } = params;
+                const { data } = option;
+                const { field, filterRender: renderOpts } = column;
+                const { props = {} } = renderOpts;
+                const cellValue = XEUtils.get(row, field);
+                if (props.multiple) {
+                    if (XEUtils.isArray(cellValue)) {
+                        return XEUtils.includeArrays(cellValue, data);
+                    }
+                    return data.indexOf(cellValue) > -1;
+                }
+                /* eslint-disable eqeqeq */
+                return cellValue == data;
+            },
+            tableExportMethod: createExportMethod(getSelectCellValue)
+        },
+        ElCascader: {
+            tableAutoFocus: 'input',
+            renderTableEdit: createEditRender(),
+            renderTableCell(renderOpts, params) {
+                return getCellLabelVNs(renderOpts, params, getCascaderCellValue(renderOpts, params));
+            },
+            tableExportMethod: createExportMethod(getCascaderCellValue)
+        },
+        ElDatePicker: {
+            tableAutoFocus: 'input',
+            renderTableEdit: createEditRender(),
+            renderTableCell(renderOpts, params) {
+                return getCellLabelVNs(renderOpts, params, getDatePickerCellValue(renderOpts, params));
+            },
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter(renderOpts, params) {
+                const { column } = params;
+                const { name, attrs } = renderOpts;
+                return [
+                    h('div', {
+                        class: 'vxe-table--filter-element-wrapper'
+                    }, column.filters.map((option, oIndex) => {
+                        const optionValue = option.data;
+                        return h(getCurrComponent(name), Object.assign(Object.assign(Object.assign({ key: oIndex }, attrs), getCellEditFilterProps(renderOpts, params, optionValue)), getFilterOns(renderOpts, params, option, () => {
+                            // 处理 change 事件相关逻辑
+                            handleConfirmFilter(params, !!option.data, option);
+                        })));
+                    }))
+                ];
+            },
+            renderTableFloatingFilter: createFloatingFilterRender(),
+            tableFilterDefaultMethod(params) {
+                const { option, row, column } = params;
+                const { data } = option;
+                const { filterRender: renderOpts } = column;
+                const { props = {} } = renderOpts;
+                const cellValue = XEUtils.get(row, column.field);
+                if (data) {
+                    switch (props.type) {
+                        case 'daterange':
+                            return equalDateRange(cellValue, data, props, 'YYYY-MM-DD');
+                        case 'datetimerange':
+                            return equalDateRange(cellValue, data, props, 'YYYY-MM-DD HH:ss:mm');
+                        case 'monthrange':
+                            return equalDateRange(cellValue, data, props, 'YYYY-MM');
+                        default:
+                            return cellValue === data;
+                    }
+                }
+                return false;
+            },
+            tableExportMethod: createExportMethod(getDatePickerCellValue)
+        },
+        ElTimePicker: {
+            tableAutoFocus: 'input',
+            renderTableEdit: createEditRender(),
+            renderTableCell(renderOpts, params) {
+                return getCellLabelVNs(renderOpts, params, getTimePickerCellValue(renderOpts, params));
+            },
+            tableExportMethod: createExportMethod(getTimePickerCellValue)
+        },
+        ElTimeSelect: {
+            tableAutoFocus: 'input',
+            renderTableEdit: createEditRender()
+        },
+        ElRate: {
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter: createFilterRender(),
+            tableFilterDefaultMethod: defaultExactFilterMethod
+        },
+        ElSwitch: {
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            renderTableFilter(renderOpts, params) {
+                const { column } = params;
+                const { name, attrs } = renderOpts;
+                return [
+                    h('div', {
+                        class: 'vxe-table--filter-element-wrapper'
+                    }, column.filters.map((option, oIndex) => {
+                        const optionValue = option.data;
+                        return h(getCurrComponent(name), Object.assign(Object.assign(Object.assign({ key: oIndex }, attrs), getCellEditFilterProps(renderOpts, params, optionValue)), getFilterOns(renderOpts, params, option, () => {
+                            // 处理 change 事件相关逻辑
+                            handleConfirmFilter(params, XEUtils.isBoolean(option.data), option);
+                        })));
+                    }))
+                ];
+            },
+            tableFilterDefaultMethod: defaultExactFilterMethod
+        },
+        ElSlider: {
+            renderTableDefault: createEditRender(),
+            renderTableEdit: createEditRender(),
+            createTableFilterOptions: defaultFilterOptions,
+            renderTableFilter: createFilterRender(),
+            tableFilterDefaultMethod: defaultExactFilterMethod
+        },
+        ElButton: {
+            renderTableDefault: defaultButtonEditRender
+        },
+        ElButtons: {
+            renderTableDefault: defaultButtonsEditRender
+        }
+    });
+}

package/es/util/comp.js

@@ -0,0 +1,18 @@
+import { resolveComponent } from 'vue';
+import { globalConfig, componentMaps } from '../store';
+export function getCurrComponent(name) {
+    const comp = componentMaps[name] || (globalConfig.ElementPlus ? globalConfig.ElementPlus[name] : null);
+    if (comp) {
+        return comp;
+    }
+    return resolveComponent(name);
+}
+export function hasInputType(renderOpts) {
+    switch (renderOpts.name) {
+        case 'ElInput':
+        case 'ElInputNumber':
+        case 'ElTextarea':
+            return true;
+    }
+    return false;
+}

package/{dist → lib}/form/index.js

@@ -97,6 +97,9 @@ function defineFormRender(VxeUI) {
     }, function () {
       // 处理 change 事件相关逻辑
       $form.updateStatus(params);
+      if (renderOpts.changeToSubmit) {
+        $form.handleSubmitEvent(new Event('change'));
+      }
     });
   }
   function renderOptions(options, optionProps) {

package/{dist → lib}/index.common.js

@@ -56,7 +56,7 @@ var VxeUIPluginRenderElement = exports.VxeUIPluginRenderElement = {
       _store.componentMaps[kcName] = comp;
       _store.componentMaps[ccName] = comp;
     } else {
-      console.error('[@vxe-ui/plugin-render-element 4.2.4] error component.', comp);
+      console.error('[@vxe-ui/plugin-render-element 4.3.1] error component.', comp);
     }
   },
   install: function install(VxeUI, options) {
@@ -70,11 +70,11 @@ var VxeUIPluginRenderElement = exports.VxeUIPluginRenderElement = {
       var pVersion = 4;
       var sVersion = 11;
       if (!VxeUI.checkVersion(VxeUI.tableVersion, pVersion, sVersion)) {
-        console.error("[@vxe-ui/plugin-render-element 4.2.4] ".concat(VxeUI.getI18n('vxe.error.errorVersion', ["vxe-table@".concat(VxeUI.tableVersion || '?'), "vxe-table v".concat(pVersion, ".").concat(sVersion, "+")]), " https://vxeui.com/other4/#/plugin-render-element/install"));
+        console.error("[@vxe-ui/plugin-render-element 4.3.1] ".concat(VxeUI.getI18n('vxe.error.errorVersion', ["vxe-table@".concat(VxeUI.tableVersion || '?'), "vxe-table v".concat(pVersion, ".").concat(sVersion, "+")]), " https://vxeui.com/other4/#/plugin-render-element/install"));
       }
     } else {
       if (!/^(4)\./.test(VxeUI.uiVersion || VxeUI.tableVersion)) {
-        console.error('[@vxe-ui/plugin-render-element 4.2.4] Requires vxe-table 4.7.0+ version. https://vxeui.com/other4/#/plugin-render-element/install');
+        console.error('[@vxe-ui/plugin-render-element 4.3.1] Requires vxe-table 4.7.0+ version. https://vxeui.com/other4/#/plugin-render-element/install');
       }
     }
     /**