vxe-table-demonic/es/v-x-e-table/src/renderer.js

一个基于 vue 的 PC 端表单/表格组件，支持增删改查、虚拟列表、虚拟树、懒加载、快捷菜单、数据校验、树形结构、打印导出、表单渲染、数据分页、弹窗、自定义模板、渲染器、JSON 配置式...

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
import { h, resolveComponent } from 'vue';
import XEUtils from 'xe-utils';
import GlobalConfig from './conf';
import { getCellValue, setCellValue } from '../../table/src/util';
import { getFuncText, formatText, isEmptyValue } from '../../tools/utils';
import { errLog, warnLog } from '../../tools/log';
import { getOnName } from '../../tools/vn';
var componentDefaultModelProp = 'modelValue';
var defaultCompProps = { transfer: true };
function getModelEvent(renderOpts) {
    switch (renderOpts.name) {
        case 'input':
        case 'textarea':
            return 'input';
    }
    return 'update:modelValue';
}
function getChangeEvent(renderOpts) {
    switch (renderOpts.name) {
        case 'input':
        case 'textarea':
        case '$input':
        case '$textarea':
            return 'input';
    }
    return 'change';
}
function parseDate(value, props) {
    return value && props.valueFormat ? XEUtils.toStringDate(value, props.valueFormat) : value;
}
function getFormatDate(value, props, defaultFormat) {
    var _a = props.dateConfig, dateConfig = _a === void 0 ? {} : _a;
    return XEUtils.toDateString(parseDate(value, props), dateConfig.labelFormat || defaultFormat);
}
function getLabelFormatDate(value, props) {
    return getFormatDate(value, props, GlobalConfig.i18n("vxe.input.date.labelFormat.".concat(props.type)));
}
function getComponentName(name) {
    return "vxe-".concat(name.replace('$', ''));
}
function getDefaultComponent(_a) {
    var name = _a.name;
    return resolveComponent(getComponentName(name));
}
function handleConfirmFilter(params, checked, option) {
    var $panel = params.$panel;
    $panel.changeOption({}, checked, option);
}
function getNativeAttrs(renderOpts) {
    var name = renderOpts.name, attrs = renderOpts.attrs;
    if (name === 'input') {
        attrs = Object.assign({ type: 'text' }, attrs);
    }
    return attrs;
}
function getInputImmediateModel(renderOpts) {
    var name = renderOpts.name, immediate = renderOpts.immediate, props = renderOpts.props;
    if (!immediate) {
        if (name === '$input') {
            var type = (props || {}).type;
            return !(!type || type === 'text' || type === 'number' || type === 'integer' || type === 'float');
        }
        if (name === 'input' || name === 'textarea' || name === '$textarea') {
            return false;
        }
        return true;
    }
    return immediate;
}
function getCellEditProps(renderOpts, params, value, defaultProps) {
    var _a;
    return XEUtils.assign({ immediate: getInputImmediateModel(renderOpts) }, defaultCompProps, defaultProps, renderOpts.props, (_a = {}, _a[componentDefaultModelProp] = value, _a));
}
function getCellEditFilterProps(renderOpts, params, value, defaultProps) {
    var _a;
    return XEUtils.assign({}, defaultCompProps, defaultProps, renderOpts.props, (_a = {}, _a[componentDefaultModelProp] = value, _a));
}
function getComponentFormItemProps(renderOpts, params, value, defaultProps) {
    var _a;
    return XEUtils.assign({}, defaultCompProps, defaultProps, renderOpts.props, (_a = {}, _a[componentDefaultModelProp] = value, _a));
}
function isImmediateCell(renderOpts, params) {
    return params.$type === 'cell' || getInputImmediateModel(renderOpts);
}
function getCellLabelVNs(renderOpts, params, cellLabel) {
    var placeholder = renderOpts.placeholder;
    return [
        h('span', {
            class: 'vxe-cell--label'
        }, placeholder && isEmptyValue(cellLabel) ? [
            h('span', {
                class: 'vxe-cell--placeholder'
            }, formatText(getFuncText(placeholder), 1))
        ] : formatText(cellLabel, 1))
    ];
}
/**
 * 原生事件处理
 * @param renderOpts
 * @param params
 * @param modelFunc
 * @param changeFunc
 */
function getElementOns(renderOpts, params, modelFunc, changeFunc) {
    var events = renderOpts.events;
    var modelEvent = getModelEvent(renderOpts);
    var changeEvent = getChangeEvent(renderOpts);
    var isSameEvent = changeEvent === modelEvent;
    var ons = {};
    if (events) {
        XEUtils.objectEach(events, function (func, key) {
            ons[getOnName(key)] = function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                func.apply(void 0, __spreadArray([params], args, false));
            };
        });
    }
    if (modelFunc) {
        ons[getOnName(modelEvent)] = function (targetEvnt) {
            modelFunc(targetEvnt);
            if (isSameEvent && changeFunc) {
                changeFunc(targetEvnt);
            }
            if (events && events[modelEvent]) {
                events[modelEvent](params, targetEvnt);
            }
        };
    }
    if (!isSameEvent && changeFunc) {
        ons[getOnName(changeEvent)] = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            changeFunc.apply(void 0, args);
            if (events && events[changeEvent]) {
                events[changeEvent].apply(events, __spreadArray([params], args, false));
            }
        };
    }
    return ons;
}
/**
 * 组件事件处理
 * @param renderOpts
 * @param params
 * @param modelFunc
 * @param changeFunc
 */
function getComponentOns(renderOpts, params, modelFunc, changeFunc) {
    var events = renderOpts.events;
    var modelEvent = getModelEvent(renderOpts);
    var changeEvent = getChangeEvent(renderOpts);
    var ons = {};
    XEUtils.objectEach(events, function (func, key) {
        ons[getOnName(key)] = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            if (process.env.NODE_ENV === 'development') {
                if (!XEUtils.isFunction(func)) {
                    errLog('vxe.error.errFunc', [func]);
                }
            }
            func.apply(void 0, __spreadArray([params], args, false));
        };
    });
    if (modelFunc) {
        ons[getOnName(modelEvent)] = function (targetEvnt) {
            modelFunc(targetEvnt);
            if (events && events[modelEvent]) {
                events[modelEvent](params, targetEvnt);
            }
        };
    }
    if (changeFunc) {
        ons[getOnName(changeEvent)] = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            changeFunc.apply(void 0, args);
            if (events && events[changeEvent]) {
                events[changeEvent].apply(events, __spreadArray([params], args, false));
            }
        };
    }
    return ons;
}
function getEditOns(renderOpts, params) {
    var $table = params.$table, row = params.row, column = params.column;
    var name = renderOpts.name;
    var model = column.model;
    var isImmediate = isImmediateCell(renderOpts, params);
    return getComponentOns(renderOpts, params, function (cellValue) {
        // 处理 model 值双向绑定
        if (isImmediate) {
            setCellValue(row, column, cellValue);
        }
        else {
            model.update = true;
            model.value = cellValue;
        }
    }, function (eventParams) {
        // 处理 change 事件相关逻辑
        if (!isImmediate && (name === '$input' || name === '$textarea')) {
            var cellValue = eventParams.value;
            model.update = true;
            model.value = cellValue;
            $table.updateStatus(params, cellValue);
        }
        else {
            $table.updateStatus(params);
        }
    });
}
function getFilterOns(renderOpts, params, option) {
    return getComponentOns(renderOpts, params, function (value) {
        // 处理 model 值双向绑定
        option.data = value;
    }, function () {
        handleConfirmFilter(params, !XEUtils.eqNull(option.data), option);
    });
}
function getItemOns(renderOpts, params) {
    var $form = params.$form, data = params.data, property = params.property;
    return getComponentOns(renderOpts, params, function (value) {
        // 处理 model 值双向绑定
        XEUtils.set(data, property, value);
    }, function () {
        // 处理 change 事件相关逻辑
        $form.updateStatus(params);
    });
}
function getNativeEditOns(renderOpts, params) {
    var $table = params.$table, row = params.row, column = params.column;
    var model = column.model;
    return getElementOns(renderOpts, params, function (evnt) {
        // 处理 model 值双向绑定
        var cellValue = evnt.target.value;
        if (isImmediateCell(renderOpts, params)) {
            setCellValue(row, column, cellValue);
        }
        else {
            model.update = true;
            model.value = cellValue;
        }
    }, function (evnt) {
        // 处理 change 事件相关逻辑
        var cellValue = evnt.target.value;
        $table.updateStatus(params, cellValue);
    });
}
function getNativeFilterOns(renderOpts, params, option) {
    return getElementOns(renderOpts, params, function (evnt) {
        // 处理 model 值双向绑定
        option.data = evnt.target.value;
    }, function () {
        handleConfirmFilter(params, !XEUtils.eqNull(option.data), option);
    });
}
function getNativeItemOns(renderOpts, params) {
    var $form = params.$form, data = params.data, property = params.property;
    return getElementOns(renderOpts, params, function (evnt) {
        // 处理 model 值双向绑定
        var itemValue = evnt.target.value;
        XEUtils.set(data, property, itemValue);
    }, function () {
        // 处理 change 事件相关逻辑
        $form.updateStatus(params);
    });
}
/**
 * 单元格可编辑渲染-原生的标签
 * input、textarea、select
 */
function nativeEditRender(renderOpts, params) {
    var row = params.row, column = params.column;
    var name = renderOpts.name;
    var cellValue = isImmediateCell(renderOpts, params) ? getCellValue(row, column) : column.model.value;
    return [
        h(name, __assign(__assign(__assign({ class: "vxe-default-".concat(name) }, getNativeAttrs(renderOpts)), { value: cellValue }), getNativeEditOns(renderOpts, params)))
    ];
}
function defaultEditRender(renderOpts, params) {
    var row = params.row, column = params.column;
    var cellValue = getCellValue(row, column);
    return [
        h(getDefaultComponent(renderOpts), __assign(__assign({}, getCellEditProps(renderOpts, params, cellValue)), getEditOns(renderOpts, params)))
    ];
}
function defaultButtonEditRender(renderOpts, params) {
    return [
        h(resolveComponent('vxe-button'), __assign(__assign({}, getCellEditProps(renderOpts, params, null)), getComponentOns(renderOpts, params)))
    ];
}
function defaultButtonsEditRender(renderOpts, params) {
    return renderOpts.children.map(function (childRenderOpts) { return defaultButtonEditRender(childRenderOpts, params)[0]; });
}
function renderNativeOptgroups(renderOpts, params, renderOptionsMethods) {
    var optionGroups = renderOpts.optionGroups, _a = renderOpts.optionGroupProps, optionGroupProps = _a === void 0 ? {} : _a;
    var groupOptions = optionGroupProps.options || 'options';
    var groupLabel = optionGroupProps.label || 'label';
    return optionGroups.map(function (group, gIndex) {
        return h('optgroup', {
            key: gIndex,
            label: group[groupLabel]
        }, renderOptionsMethods(group[groupOptions], renderOpts, params));
    });
}
/**
 * 渲染原生的 option 标签
 */
function renderNativeOptions(options, renderOpts, params) {
    var _a = renderOpts.optionProps, optionProps = _a === void 0 ? {} : _a;
    var row = params.row, column = params.column;
    var labelProp = optionProps.label || 'label';
    var valueProp = optionProps.value || 'value';
    var disabledProp = optionProps.disabled || 'disabled';
    var cellValue = isImmediateCell(renderOpts, params) ? getCellValue(row, column) : column.model.value;
    return options.map(function (option, oIndex) {
        return h('option', {
            key: oIndex,
            value: option[valueProp],
            disabled: option[disabledProp],
            /* eslint-disable eqeqeq */
            selected: option[valueProp] == cellValue
        }, option[labelProp]);
    });
}
function nativeFilterRender(renderOpts, params) {
    var column = params.column;
    var name = renderOpts.name;
    var attrs = getNativeAttrs(renderOpts);
    return column.filters.map(function (option, oIndex) {
        return h(name, __assign(__assign(__assign({ key: oIndex, class: "vxe-default-".concat(name) }, attrs), { value: option.data }), getNativeFilterOns(renderOpts, params, option)));
    });
}
function defaultFilterRender(renderOpts, params) {
    var column = params.column;
    return column.filters.map(function (option, oIndex) {
        var optionValue = option.data;
        return h(getDefaultComponent(renderOpts), __assign(__assign({ key: oIndex }, getCellEditFilterProps(renderOpts, renderOpts, optionValue)), getFilterOns(renderOpts, params, option)));
    });
}
function handleFilterMethod(_a) {
    var option = _a.option, row = _a.row, column = _a.column;
    var data = option.data;
    var cellValue = XEUtils.get(row, column.property);
    /* eslint-disable eqeqeq */
    return cellValue == data;
}
function nativeSelectEditRender(renderOpts, params) {
    return [
        h('select', __assign(__assign({ class: 'vxe-default-select' }, getNativeAttrs(renderOpts)), getNativeEditOns(renderOpts, params)), renderOpts.optionGroups ? renderNativeOptgroups(renderOpts, params, renderNativeOptions) : renderNativeOptions(renderOpts.options, renderOpts, params))
    ];
}
function defaultSelectEditRender(renderOpts, params) {
    var row = params.row, column = params.column;
    var options = renderOpts.options, optionProps = renderOpts.optionProps, optionGroups = renderOpts.optionGroups, optionGroupProps = renderOpts.optionGroupProps;
    var cellValue = getCellValue(row, column);
    return [
        h(getDefaultComponent(renderOpts), __assign(__assign({}, getCellEditProps(renderOpts, params, cellValue, { options: options, optionProps: optionProps, optionGroups: optionGroups, optionGroupProps: optionGroupProps })), getEditOns(renderOpts, params)))
    ];
}
function getSelectCellValue(renderOpts, _a) {
    var row = _a.row, column = _a.column;
    var _b = renderOpts.props, props = _b === void 0 ? {} : _b, options = renderOpts.options, optionGroups = renderOpts.optionGroups, _c = renderOpts.optionProps, optionProps = _c === void 0 ? {} : _c, _d = renderOpts.optionGroupProps, optionGroupProps = _d === void 0 ? {} : _d;
    var cellValue = XEUtils.get(row, column.property);
    var selectItem;
    var labelProp = optionProps.label || 'label';
    var valueProp = optionProps.value || 'value';
    if (!isEmptyValue(cellValue)) {
        return XEUtils.map(props.multiple ? cellValue : [cellValue], optionGroups ? function (value) {
            var groupOptions = optionGroupProps.options || 'options';
            for (var index = 0; index < optionGroups.length; index++) {
                /* eslint-disable eqeqeq */
                selectItem = XEUtils.find(optionGroups[index][groupOptions], function (item) { return item[valueProp] == value; });
                if (selectItem) {
                    break;
                }
            }
            return selectItem ? selectItem[labelProp] : value;
        } : function (value) {
            /* eslint-disable eqeqeq */
            selectItem = XEUtils.find(options, function (item) { return item[valueProp] == value; });
            return selectItem ? selectItem[labelProp] : value;
        }).join(', ');
    }
    return '';
}
/**
 * 渲染表单-项
 * 用于渲染原生的标签
 */
function nativeItemRender(renderOpts, params) {
    var data = params.data, property = params.property;
    var name = renderOpts.name;
    var attrs = getNativeAttrs(renderOpts);
    var itemValue = XEUtils.get(data, property);
    return [
        h(name, __assign(__assign(__assign({ class: "vxe-default-".concat(name) }, attrs), { value: attrs && name === 'input' && (attrs.type === 'submit' || attrs.type === 'reset') ? null : itemValue }), getNativeItemOns(renderOpts, params)))
    ];
}
function defaultItemRender(renderOpts, params) {
    var data = params.data, property = params.property;
    var itemValue = XEUtils.get(data, property);
    return [
        h(getDefaultComponent(renderOpts), __assign(__assign({}, getComponentFormItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)))
    ];
}
function defaultButtonItemRender(renderOpts, params) {
    return [
        h(resolveComponent('vxe-button'), __assign(__assign({}, getComponentFormItemProps(renderOpts, params, null)), getComponentOns(renderOpts, params)))
    ];
}
function defaultButtonsItemRender(renderOpts, params) {
    return renderOpts.children.map(function (childRenderOpts) { return defaultButtonItemRender(childRenderOpts, params)[0]; });
}
/**
 * 渲染原生的 select 标签
 */
function renderNativeFormOptions(options, renderOpts, params) {
    var data = params.data, property = params.property;
    var _a = renderOpts.optionProps, optionProps = _a === void 0 ? {} : _a;
    var labelProp = optionProps.label || 'label';
    var valueProp = optionProps.value || 'value';
    var disabledProp = optionProps.disabled || 'disabled';
    var cellValue = XEUtils.get(data, property);
    return options.map(function (item, oIndex) {
        return h('option', {
            key: oIndex,
            value: item[valueProp],
            disabled: item[disabledProp],
            /* eslint-disable eqeqeq */
            selected: item[valueProp] == cellValue
        }, item[labelProp]);
    });
}
function handleExportSelectMethod(params) {
    var row = params.row, column = params.column, options = params.options;
    return options.original ? getCellValue(row, column) : getSelectCellValue(column.editRender || column.cellRender, params);
}
/**
 * 渲染表单-项中
 * 单选框和复选框
 */
function defaultFormItemRadioAndCheckboxRender(renderOpts, params) {
    var name = renderOpts.name, options = renderOpts.options, _a = renderOpts.optionProps, optionProps = _a === void 0 ? {} : _a;
    var data = params.data, property = params.property;
    var labelProp = optionProps.label || 'label';
    var valueProp = optionProps.value || 'value';
    var disabledProp = optionProps.disabled || 'disabled';
    var itemValue = XEUtils.get(data, property);
    var compName = getComponentName(name);
    // 如果是分组
    if (options) {
        return [
            h(resolveComponent("".concat(compName, "-group")), __assign(__assign({}, getComponentFormItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)), {
                default: function () {
                    return options.map(function (item, index) {
                        return h(resolveComponent(compName), {
                            key: index,
                            label: item[valueProp],
                            content: item[labelProp],
                            disabled: item[disabledProp]
                        });
                    });
                }
            })
        ];
    }
    return [
        h(resolveComponent(compName), __assign(__assign({}, getComponentFormItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)))
    ];
}
/**
 * 内置的组件渲染
 */
var renderMap = {
    input: {
        autofocus: 'input',
        renderEdit: nativeEditRender,
        renderDefault: nativeEditRender,
        renderFilter: nativeFilterRender,
        defaultFilterMethod: handleFilterMethod,
        renderItemContent: nativeItemRender
    },
    textarea: {
        autofocus: 'textarea',
        renderEdit: nativeEditRender,
        renderItemContent: nativeItemRender
    },
    select: {
        renderEdit: nativeSelectEditRender,
        renderDefault: nativeSelectEditRender,
        renderCell: function (renderOpts, params) {
            return getCellLabelVNs(renderOpts, params, getSelectCellValue(renderOpts, params));
        },
        renderFilter: function (renderOpts, params) {
            var column = params.column;
            return column.filters.map(function (option, oIndex) {
                return h('select', __assign(__assign({ key: oIndex, class: 'vxe-default-select' }, getNativeAttrs(renderOpts)), getNativeFilterOns(renderOpts, params, option)), renderOpts.optionGroups ? renderNativeOptgroups(renderOpts, params, renderNativeOptions) : renderNativeOptions(renderOpts.options, renderOpts, params));
            });
        },
        defaultFilterMethod: handleFilterMethod,
        renderItemContent: function (renderOpts, params) {
            return [
                h('select', __assign(__assign({ class: 'vxe-default-select' }, getNativeAttrs(renderOpts)), getNativeItemOns(renderOpts, params)), renderOpts.optionGroups ? renderNativeOptgroups(renderOpts, params, renderNativeFormOptions) : renderNativeFormOptions(renderOpts.options, renderOpts, params))
            ];
        },
        cellExportMethod: handleExportSelectMethod
    },
    $input: {
        autofocus: '.vxe-input--inner',
        renderEdit: defaultEditRender,
        renderCell: function (renderOpts, params) {
            var _a = renderOpts.props, props = _a === void 0 ? {} : _a;
            var row = params.row, column = params.column;
            var digits = props.digits || GlobalConfig.input.digits;
            var cellValue = XEUtils.get(row, column.property);
            if (cellValue) {
                switch (props.type) {
                    case 'date':
                    case 'week':
                    case 'month':
                    case 'year':
                        cellValue = getLabelFormatDate(cellValue, props);
                        break;
                    case 'float':
                        cellValue = XEUtils.toFixed(XEUtils.floor(cellValue, digits), digits);
                        break;
                }
            }
            return getCellLabelVNs(renderOpts, params, cellValue);
        },
        renderDefault: defaultEditRender,
        renderFilter: defaultFilterRender,
        defaultFilterMethod: handleFilterMethod,
        renderItemContent: defaultItemRender
    },
    $textarea: {
        autofocus: '.vxe-textarea--inner',
        renderItemContent: defaultItemRender
    },
    $button: {
        renderDefault: defaultButtonEditRender,
        renderItemContent: defaultButtonItemRender
    },
    $buttons: {
        renderDefault: defaultButtonsEditRender,
        renderItemContent: defaultButtonsItemRender
    },
    $select: {
        autofocus: '.vxe-input--inner',
        renderEdit: defaultSelectEditRender,
        renderDefault: defaultSelectEditRender,
        renderCell: function (renderOpts, params) {
            return getCellLabelVNs(renderOpts, params, getSelectCellValue(renderOpts, params));
        },
        renderFilter: function (renderOpts, params) {
            var column = params.column;
            var options = renderOpts.options, optionProps = renderOpts.optionProps, optionGroups = renderOpts.optionGroups, optionGroupProps = renderOpts.optionGroupProps;
            return column.filters.map(function (option, oIndex) {
                var optionValue = option.data;
                return h(getDefaultComponent(renderOpts), __assign(__assign({ key: oIndex }, getCellEditFilterProps(renderOpts, params, optionValue, { options: options, optionProps: optionProps, optionGroups: optionGroups, optionGroupProps: optionGroupProps })), getFilterOns(renderOpts, params, option)));
            });
        },
        defaultFilterMethod: handleFilterMethod,
        renderItemContent: function (renderOpts, params) {
            var data = params.data, property = params.property;
            var options = renderOpts.options, optionProps = renderOpts.optionProps, optionGroups = renderOpts.optionGroups, optionGroupProps = renderOpts.optionGroupProps;
            var itemValue = XEUtils.get(data, property);
            return [
                h(getDefaultComponent(renderOpts), __assign(__assign({}, getComponentFormItemProps(renderOpts, params, itemValue, { options: options, optionProps: optionProps, optionGroups: optionGroups, optionGroupProps: optionGroupProps })), getItemOns(renderOpts, params)))
            ];
        },
        cellExportMethod: handleExportSelectMethod
    },
    $radio: {
        autofocus: '.vxe-radio--input',
        renderItemContent: defaultFormItemRadioAndCheckboxRender
    },
    $checkbox: {
        autofocus: '.vxe-checkbox--input',
        renderItemContent: defaultFormItemRadioAndCheckboxRender
    },
    $switch: {
        autofocus: '.vxe-switch--button',
        renderEdit: defaultEditRender,
        renderDefault: defaultEditRender,
        renderItemContent: defaultItemRender
    }
};
/**
 * 全局渲染器
 */
export var renderer = {
    mixin: function (opts) {
        XEUtils.each(opts, function (options, name) { return renderer.add(name, options); });
        return renderer;
    },
    get: function (name) {
        return renderMap[name] || null;
    },
    add: function (name, options) {
        if (name && options) {
            var renders_1 = renderMap[name];
            if (renders_1) {
                // 检测是否覆盖
                if (process.env.NODE_ENV === 'development') {
                    XEUtils.each(options, function (val, key) {
                        if (!XEUtils.eqNull(renders_1[key]) && renders_1[key] !== val) {
                            warnLog('vxe.error.coverProp', ["Renderer.".concat(name), key]);
                        }
                    });
                }
                Object.assign(renders_1, options);
            }
            else {
                renderMap[name] = options;
            }
        }
        return renderer;
    },
    delete: function (name) {
        delete renderMap[name];
        return renderer;
    }
};