xrk-components 0.1.0 → 0.3.2

package/lib/index.umd.js

@@ -0,0 +1,2997 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('element-plus'), require('vue'), require('xrk-tools')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'element-plus', 'vue', 'xrk-tools'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Xrk = {}, global.ElementPlus, global.vue, global.xrkTools));
+})(this, (function (exports, ElementPlus, vue, xrkTools) { 'use strict';
+
+	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+	var ElementPlus__default = /*#__PURE__*/_interopDefaultLegacy(ElementPlus);
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var zhCn = {};
+
+	(function (exports) {
+
+		Object.defineProperty(exports, '__esModule', { value: true });
+
+		var zhCn = {
+		  name: "zh-cn",
+		  el: {
+		    colorpicker: {
+		      confirm: "\u786E\u5B9A",
+		      clear: "\u6E05\u7A7A"
+		    },
+		    datepicker: {
+		      now: "\u6B64\u523B",
+		      today: "\u4ECA\u5929",
+		      cancel: "\u53D6\u6D88",
+		      clear: "\u6E05\u7A7A",
+		      confirm: "\u786E\u5B9A",
+		      selectDate: "\u9009\u62E9\u65E5\u671F",
+		      selectTime: "\u9009\u62E9\u65F6\u95F4",
+		      startDate: "\u5F00\u59CB\u65E5\u671F",
+		      startTime: "\u5F00\u59CB\u65F6\u95F4",
+		      endDate: "\u7ED3\u675F\u65E5\u671F",
+		      endTime: "\u7ED3\u675F\u65F6\u95F4",
+		      prevYear: "\u524D\u4E00\u5E74",
+		      nextYear: "\u540E\u4E00\u5E74",
+		      prevMonth: "\u4E0A\u4E2A\u6708",
+		      nextMonth: "\u4E0B\u4E2A\u6708",
+		      year: "\u5E74",
+		      month1: "1 \u6708",
+		      month2: "2 \u6708",
+		      month3: "3 \u6708",
+		      month4: "4 \u6708",
+		      month5: "5 \u6708",
+		      month6: "6 \u6708",
+		      month7: "7 \u6708",
+		      month8: "8 \u6708",
+		      month9: "9 \u6708",
+		      month10: "10 \u6708",
+		      month11: "11 \u6708",
+		      month12: "12 \u6708",
+		      weeks: {
+		        sun: "\u65E5",
+		        mon: "\u4E00",
+		        tue: "\u4E8C",
+		        wed: "\u4E09",
+		        thu: "\u56DB",
+		        fri: "\u4E94",
+		        sat: "\u516D"
+		      },
+		      months: {
+		        jan: "\u4E00\u6708",
+		        feb: "\u4E8C\u6708",
+		        mar: "\u4E09\u6708",
+		        apr: "\u56DB\u6708",
+		        may: "\u4E94\u6708",
+		        jun: "\u516D\u6708",
+		        jul: "\u4E03\u6708",
+		        aug: "\u516B\u6708",
+		        sep: "\u4E5D\u6708",
+		        oct: "\u5341\u6708",
+		        nov: "\u5341\u4E00\u6708",
+		        dec: "\u5341\u4E8C\u6708"
+		      }
+		    },
+		    select: {
+		      loading: "\u52A0\u8F7D\u4E2D",
+		      noMatch: "\u65E0\u5339\u914D\u6570\u636E",
+		      noData: "\u65E0\u6570\u636E",
+		      placeholder: "\u8BF7\u9009\u62E9"
+		    },
+		    cascader: {
+		      noMatch: "\u65E0\u5339\u914D\u6570\u636E",
+		      loading: "\u52A0\u8F7D\u4E2D",
+		      placeholder: "\u8BF7\u9009\u62E9",
+		      noData: "\u6682\u65E0\u6570\u636E"
+		    },
+		    pagination: {
+		      goto: "\u524D\u5F80",
+		      pagesize: "\u6761/\u9875",
+		      total: "\u5171 {total} \u6761",
+		      pageClassifier: "\u9875",
+		      deprecationWarning: "\u4F60\u4F7F\u7528\u4E86\u4E00\u4E9B\u5DF2\u88AB\u5E9F\u5F03\u7684\u7528\u6CD5\uFF0C\u8BF7\u53C2\u8003 el-pagination \u7684\u5B98\u65B9\u6587\u6863"
+		    },
+		    messagebox: {
+		      title: "\u63D0\u793A",
+		      confirm: "\u786E\u5B9A",
+		      cancel: "\u53D6\u6D88",
+		      error: "\u8F93\u5165\u7684\u6570\u636E\u4E0D\u5408\u6CD5!"
+		    },
+		    upload: {
+		      deleteTip: "\u6309 delete \u952E\u53EF\u5220\u9664",
+		      delete: "\u5220\u9664",
+		      preview: "\u67E5\u770B\u56FE\u7247",
+		      continue: "\u7EE7\u7EED\u4E0A\u4F20"
+		    },
+		    table: {
+		      emptyText: "\u6682\u65E0\u6570\u636E",
+		      confirmFilter: "\u7B5B\u9009",
+		      resetFilter: "\u91CD\u7F6E",
+		      clearFilter: "\u5168\u90E8",
+		      sumText: "\u5408\u8BA1"
+		    },
+		    tree: {
+		      emptyText: "\u6682\u65E0\u6570\u636E"
+		    },
+		    transfer: {
+		      noMatch: "\u65E0\u5339\u914D\u6570\u636E",
+		      noData: "\u65E0\u6570\u636E",
+		      titles: ["\u5217\u8868 1", "\u5217\u8868 2"],
+		      filterPlaceholder: "\u8BF7\u8F93\u5165\u641C\u7D22\u5185\u5BB9",
+		      noCheckedFormat: "\u5171 {total} \u9879",
+		      hasCheckedFormat: "\u5DF2\u9009 {checked}/{total} \u9879"
+		    },
+		    image: {
+		      error: "\u52A0\u8F7D\u5931\u8D25"
+		    },
+		    pageHeader: {
+		      title: "\u8FD4\u56DE"
+		    },
+		    popconfirm: {
+		      confirmButtonText: "\u786E\u5B9A",
+		      cancelButtonText: "\u53D6\u6D88"
+		    }
+		  }
+		};
+
+		exports["default"] = zhCn;
+		
+	} (zhCn));
+
+	var locale = /*@__PURE__*/getDefaultExportFromCjs(zhCn);
+
+	/******************************************************************************
+	Copyright (c) Microsoft Corporation.
+
+	Permission to use, copy, modify, and/or distribute this software for any
+	purpose with or without fee is hereby granted.
+
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+	PERFORMANCE OF THIS SOFTWARE.
+	***************************************************************************** */
+
+	var __assign = function() {
+	    __assign = Object.assign || function __assign(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);
+	};
+
+	function __awaiter(thisArg, _arguments, P, generator) {
+	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+	    return new (P || (P = Promise))(function (resolve, reject) {
+	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+	        step((generator = generator.apply(thisArg, _arguments || [])).next());
+	    });
+	}
+
+	function __generator(thisArg, body) {
+	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+	    function verb(n) { return function (v) { return step([n, v]); }; }
+	    function step(op) {
+	        if (f) throw new TypeError("Generator is already executing.");
+	        while (_) try {
+	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+	            if (y = 0, t) op = [op[0] & 2, t.value];
+	            switch (op[0]) {
+	                case 0: case 1: t = op; break;
+	                case 4: _.label++; return { value: op[1], done: false };
+	                case 5: _.label++; y = op[1]; op = [0]; continue;
+	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+	                default:
+	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+	                    if (t[2]) _.ops.pop();
+	                    _.trys.pop(); continue;
+	            }
+	            op = body.call(thisArg, _);
+	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+	    }
+	}
+
+	function __spreadArray(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));
+	}
+
+	var __default__$l = {
+	    name: 'base-button'
+	};
+	var script$l = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$l), { props: {
+	        click: { type: null, required: false },
+	        loading: { type: Boolean, required: false },
+	        loadingIcon: { type: null, required: false },
+	        size: { type: String, required: false, default: 'default' },
+	        type: { type: String, required: false, default: 'primary' },
+	        plain: { type: Boolean, required: false },
+	        round: { type: Boolean, required: false },
+	        circle: { type: Boolean, required: false },
+	        disabled: { type: Boolean, required: false },
+	        autofocus: { type: Boolean, required: false },
+	        autoInsertSpace: { type: Boolean, required: false },
+	        nativeType: { type: String, required: false },
+	        icon: { type: null, required: false }
+	    }, setup: function (__props) {
+	        var _this = this;
+	        var _props = __props;
+	        var props = _props;
+	        var _a = (function () {
+	            var _loading = vue.ref(false);
+	            var isLoading = vue.computed(function () {
+	                return props.loading || _loading.value;
+	            });
+	            return {
+	                isLoading: isLoading,
+	                handleClick: (props.click
+	                    ? function () { return __awaiter(_this, void 0, void 0, function () {
+	                        var error_1;
+	                        var _a;
+	                        return __generator(this, function (_b) {
+	                            switch (_b.label) {
+	                                case 0:
+	                                    _loading.value = true;
+	                                    _b.label = 1;
+	                                case 1:
+	                                    _b.trys.push([1, 3, , 4]);
+	                                    return [4 /*yield*/, ((_a = props.click) === null || _a === void 0 ? void 0 : _a.call(props))];
+	                                case 2:
+	                                    _b.sent();
+	                                    _loading.value = false;
+	                                    return [3 /*break*/, 4];
+	                                case 3:
+	                                    error_1 = _b.sent();
+	                                    console.warn(error_1);
+	                                    _loading.value = false;
+	                                    return [3 /*break*/, 4];
+	                                case 4: return [2 /*return*/];
+	                            }
+	                        });
+	                    }); }
+	                    : undefined)
+	            };
+	        })(), handleClick = _a.handleClick, isLoading = _a.isLoading;
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElButton), {
+	                onClick: vue.unref(handleClick),
+	                loading: vue.unref(isLoading),
+	                size: __props.size,
+	                type: __props.type,
+	                plain: __props.plain,
+	                round: __props.round,
+	                circle: __props.circle,
+	                disabled: __props.disabled,
+	                autofocus: __props.autofocus,
+	                autoInsertSpace: __props.autoInsertSpace,
+	                nativeType: __props.nativeType,
+	                loadingIcon: __props.loadingIcon,
+	                icon: __props.icon
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["onClick", "loading", "size", "type", "plain", "round", "circle", "disabled", "autofocus", "autoInsertSpace", "nativeType", "loadingIcon", "icon"]));
+	        };
+	    } }));
+
+	script$l.__file = "packages/base/button/button.vue";
+
+	var BaseButton = script$l;
+
+	var __default__$k = {
+	    name: 'base-radio-button'
+	};
+	var script$k = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$k), { props: {
+	        modelValue: { type: null, required: false },
+	        size: { type: String, required: false },
+	        name: { type: String, required: false },
+	        label: { type: [String, Number, Boolean], required: false },
+	        disabled: { type: Boolean, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var emits = _a.emit;
+	        var handleChange = function (activeValue) {
+	            emits('update:modelValue', activeValue);
+	            emits('change', activeValue);
+	        };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElRadioButton), {
+	                "model-value": __props.modelValue,
+	                disabled: __props.disabled,
+	                name: __props.name,
+	                label: __props.label,
+	                size: __props.size,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "disabled", "name", "label", "size"]));
+	        };
+	    } }));
+
+	script$k.__file = "packages/base/radio/radio-button.vue";
+
+	/*
+	 * @Description:
+	 * @Date: 2022-07-01 11:46:30
+	 */
+	function isFunction(val) {
+	    return xrkTools.check.isFunction(val) || xrkTools.check.isAsyncFunction(val);
+	}
+
+	var _hoisted_1$6 = { style: { "display": "inline-block" } };
+	var __default__$j = {
+	    name: 'base-radio-group'
+	};
+	var script$j = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$j), { props: {
+	        modelValue: { type: null, required: false },
+	        size: { type: String, required: false },
+	        textColor: { type: String, required: false },
+	        fill: { type: String, required: false },
+	        disabled: { type: Boolean, required: false },
+	        checkBefore: { type: Function, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var props = __props;
+	        var vLoading = ElementPlus.vLoading;
+	        var _loading = vue.ref(false);
+	        var handleChange = function (activeValue) { return __awaiter(_this, void 0, void 0, function () {
+	            var _a;
+	            return __generator(this, function (_b) {
+	                switch (_b.label) {
+	                    case 0:
+	                        if (_loading.value)
+	                            return [2 /*return*/];
+	                        _loading.value = true;
+	                        _b.label = 1;
+	                    case 1:
+	                        _b.trys.push([1, 5, , 6]);
+	                        if (!((((_a = props.modelValue) === null || _a === void 0 ? void 0 : _a.length) || 0) < (activeValue === null || activeValue === void 0 ? void 0 : activeValue.length) &&
+	                            isFunction(props.checkBefore))) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.checkBefore(activeValue, function () {
+	                                emits('update:modelValue', activeValue);
+	                                emits('change', activeValue);
+	                            })];
+	                    case 2:
+	                        _b.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        emits('update:modelValue', activeValue);
+	                        emits('change', activeValue);
+	                        _b.label = 4;
+	                    case 4: return [3 /*break*/, 6];
+	                    case 5:
+	                        _b.sent();
+	                        return [3 /*break*/, 6];
+	                    case 6:
+	                        _loading.value = false;
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElRadioGroup), {
+	                class: "base-radio-group",
+	                "model-value": __props.modelValue,
+	                size: __props.size,
+	                disabled: __props.disabled,
+	                "text-color": __props.textColor,
+	                fill: __props.fill,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", _hoisted_1$6, [
+	                        vue.renderSlot(_ctx.$slots, "default")
+	                    ])), [
+	                        [vue.unref(vLoading), _loading.value]
+	                    ])
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "size", "disabled", "text-color", "fill"]));
+	        };
+	    } }));
+
+	script$j.__scopeId = "data-v-9d4003c2";
+	script$j.__file = "packages/base/radio/radio-group.vue";
+
+	var __default__$i = {
+	    name: 'base-radio'
+	};
+	var script$i = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$i), { props: {
+	        modelValue: { type: null, required: false },
+	        size: { type: String, required: false },
+	        name: { type: String, required: false },
+	        label: { type: [String, Number, Boolean], required: false },
+	        disabled: { type: Boolean, required: false },
+	        border: { type: Boolean, required: false },
+	        checkBefore: { type: Function, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var props = __props;
+	        var _loading = vue.ref(false);
+	        var handleChange = function (activeValue) { return __awaiter(_this, void 0, void 0, function () {
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (_loading.value)
+	                            return [2 /*return*/];
+	                        _loading.value = true;
+	                        _a.label = 1;
+	                    case 1:
+	                        _a.trys.push([1, 5, , 6]);
+	                        if (!(activeValue && isFunction(props.checkBefore))) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.checkBefore(activeValue, function () {
+	                                emits('update:modelValue', activeValue);
+	                                emits('change', activeValue);
+	                            })];
+	                    case 2:
+	                        _a.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        emits('update:modelValue', activeValue);
+	                        emits('change', activeValue);
+	                        _a.label = 4;
+	                    case 4: return [3 /*break*/, 6];
+	                    case 5:
+	                        _a.sent();
+	                        return [3 /*break*/, 6];
+	                    case 6:
+	                        _loading.value = false;
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElRadio), {
+	                class: "base-radio",
+	                "model-value": __props.modelValue,
+	                size: __props.size,
+	                name: __props.name,
+	                label: __props.label,
+	                disabled: __props.disabled,
+	                border: __props.border,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "size", "name", "label", "disabled", "border"]));
+	        };
+	    } }));
+
+	script$i.__scopeId = "data-v-56d41f26";
+	script$i.__file = "packages/base/radio/radio.vue";
+
+	var BaseRadioButton = script$k;
+	var BaseRadioGroup = script$j;
+	var BaseRadio = script$i;
+
+	var __default__$h = {
+	    name: 'base-checkbox-button'
+	};
+	var script$h = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$h), { props: {
+	        modelValue: { type: [String, Number, Boolean], required: false },
+	        size: { type: String, required: false },
+	        name: { type: String, required: false },
+	        label: { type: [String, Number, Boolean], required: false },
+	        disabled: { type: Boolean, required: false },
+	        border: { type: Boolean, required: false },
+	        trueLabel: { type: [String, Number], required: false },
+	        falseLabel: { type: [String, Number], required: false },
+	        checked: { type: Boolean, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var emits = _a.emit;
+	        var handleChange = function (activeValue) {
+	            emits('update:modelValue', activeValue);
+	            emits('change', activeValue);
+	        };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElCheckboxButton), {
+	                "model-value": __props.modelValue,
+	                size: __props.size,
+	                name: __props.name,
+	                label: __props.label,
+	                disabled: __props.disabled,
+	                border: __props.border,
+	                "true-label": __props.trueLabel,
+	                "false-label": __props.falseLabel,
+	                checked: __props.checked,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "size", "name", "label", "disabled", "border", "true-label", "false-label", "checked"]));
+	        };
+	    } }));
+
+	script$h.__file = "packages/base/checkbox/checkbox-button.vue";
+
+	var _hoisted_1$5 = { style: { "display": "inline-block" } };
+	var __default__$g = {
+	    name: 'base-checkbox-group'
+	};
+	var script$g = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$g), { props: {
+	        modelValue: { type: Array, required: false },
+	        size: { type: String, required: false },
+	        disabled: { type: Boolean, required: false },
+	        textColor: { type: String, required: false },
+	        fill: { type: String, required: false },
+	        label: { type: String, required: false },
+	        min: { type: Number, required: false },
+	        max: { type: Number, required: false },
+	        checkBefore: { type: Function, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var props = __props;
+	        var vLoading = ElementPlus.vLoading;
+	        var _loading = vue.ref(false);
+	        var handleChange = function (activeValue) { return __awaiter(_this, void 0, void 0, function () {
+	            var _a;
+	            return __generator(this, function (_b) {
+	                switch (_b.label) {
+	                    case 0:
+	                        if (_loading.value)
+	                            return [2 /*return*/];
+	                        _loading.value = true;
+	                        _b.label = 1;
+	                    case 1:
+	                        _b.trys.push([1, 5, , 6]);
+	                        if (!((((_a = props.modelValue) === null || _a === void 0 ? void 0 : _a.length) || 0) < (activeValue === null || activeValue === void 0 ? void 0 : activeValue.length) &&
+	                            isFunction(props.checkBefore))) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.checkBefore(activeValue, function () {
+	                                emits('update:modelValue', activeValue);
+	                                emits('change', activeValue);
+	                            })];
+	                    case 2:
+	                        _b.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        emits('update:modelValue', activeValue);
+	                        emits('change', activeValue);
+	                        _b.label = 4;
+	                    case 4: return [3 /*break*/, 6];
+	                    case 5:
+	                        _b.sent();
+	                        return [3 /*break*/, 6];
+	                    case 6:
+	                        _loading.value = false;
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElCheckboxGroup), {
+	                class: "base-checkbox-group",
+	                "model-value": __props.modelValue,
+	                size: __props.size,
+	                disabled: __props.disabled,
+	                "text-color": __props.textColor,
+	                fill: __props.fill,
+	                label: __props.label,
+	                min: __props.min,
+	                max: __props.max,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", _hoisted_1$5, [
+	                        vue.renderSlot(_ctx.$slots, "default")
+	                    ])), [
+	                        [vue.unref(vLoading), _loading.value]
+	                    ])
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "size", "disabled", "text-color", "fill", "label", "min", "max"]));
+	        };
+	    } }));
+
+	script$g.__scopeId = "data-v-1e1f0947";
+	script$g.__file = "packages/base/checkbox/checkbox-group.vue";
+
+	var __default__$f = {
+	    name: 'base-checkbox'
+	};
+	var script$f = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$f), { props: {
+	        modelValue: { type: [String, Number, Boolean], required: false },
+	        size: { type: String, required: false },
+	        name: { type: String, required: false },
+	        label: { type: [String, Number, Boolean], required: false },
+	        disabled: { type: Boolean, required: false },
+	        border: { type: Boolean, required: false },
+	        trueLabel: { type: [String, Number], required: false },
+	        falseLabel: { type: [String, Number], required: false },
+	        checked: { type: Boolean, required: false },
+	        indeterminate: { type: Boolean, required: false },
+	        checkBefore: { type: Function, required: false }
+	    }, emits: ["change", "update:modelValue"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var props = __props;
+	        var vLoading = ElementPlus.vLoading;
+	        var _loading = vue.ref(false);
+	        var handleChange = function (activeValue) { return __awaiter(_this, void 0, void 0, function () {
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (_loading.value)
+	                            return [2 /*return*/];
+	                        _loading.value = true;
+	                        _a.label = 1;
+	                    case 1:
+	                        _a.trys.push([1, 5, , 6]);
+	                        if (!(activeValue && isFunction(props.checkBefore))) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.checkBefore(activeValue, function () {
+	                                emits('update:modelValue', activeValue);
+	                                emits('change', activeValue);
+	                            })];
+	                    case 2:
+	                        _a.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        emits('update:modelValue', activeValue);
+	                        emits('change', activeValue);
+	                        _a.label = 4;
+	                    case 4: return [3 /*break*/, 6];
+	                    case 5:
+	                        _a.sent();
+	                        return [3 /*break*/, 6];
+	                    case 6:
+	                        _loading.value = false;
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElCheckbox), {
+	                class: "base-checkbox",
+	                "model-value": __props.modelValue,
+	                size: __props.size,
+	                name: __props.name,
+	                label: __props.label,
+	                disabled: __props.disabled,
+	                border: __props.border,
+	                "true-label": __props.trueLabel,
+	                "false-label": __props.falseLabel,
+	                checked: __props.checked,
+	                indeterminate: __props.indeterminate,
+	                onChange: handleChange
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model-value", "size", "name", "label", "disabled", "border", "true-label", "false-label", "checked", "indeterminate"])), [
+	                [vue.unref(vLoading), _loading.value]
+	            ]);
+	        };
+	    } }));
+
+	script$f.__scopeId = "data-v-53a67995";
+	script$f.__file = "packages/base/checkbox/checkbox.vue";
+
+	var BaseCheckboxButton = script$h;
+	var BaseCheckboxGroup = script$g;
+	var BaseCheckbox = script$f;
+
+	var __default__$e = {
+	    name: 'base-date-picker'
+	};
+	var script$e = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$e), { props: {
+	        modelValue: { type: null, required: false },
+	        readonly: { type: Boolean, required: false },
+	        disabled: { type: Boolean, required: false },
+	        size: { type: String, required: false },
+	        editable: { type: Boolean, required: false },
+	        clearable: { type: Boolean, required: false, default: true },
+	        placeholder: { type: String, required: false, default: '请选择日期' },
+	        startPlaceholder: { type: String, required: false, default: '请选择开始日期' },
+	        endPlaceholder: { type: String, required: false, default: '请选择结束日期' },
+	        type: { type: String, required: false, default: 'date' },
+	        format: { type: String, required: false },
+	        popperClass: { type: String, required: false },
+	        rangeSeparator: { type: String, required: false },
+	        defaultValue: { type: null, required: false },
+	        defaultTime: { type: null, required: false },
+	        valueFormat: { type: String, required: false },
+	        unlinkPanels: { type: Boolean, required: false },
+	        prefixIcon: { type: null, required: false },
+	        clearIcon: { type: null, required: false },
+	        validateEvent: { type: Boolean, required: false },
+	        disabledDate: { type: Function, required: false },
+	        shortcuts: { type: null, required: false },
+	        cellClassName: { type: Function, required: false },
+	        teleported: { type: Boolean, required: false, default: true }
+	    }, emits: ["change", "visibleChange", "calendarChange", "update:modelValue"], setup: function (__props, _a) {
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var props = _props;
+	        // 越过类型不匹配导致的ts报错
+	        var defaultTime = vue.computed(function () { return props.defaultTime; });
+	        var valueFormat = vue.computed(function () {
+	            return props.valueFormat ||
+	                (props.type &&
+	                    (['datetime', 'datetimerange'].includes(props.type)
+	                        ? 'YYYY-MM-DD HH:mm:ss'
+	                        : 'YYYY-MM-DD'));
+	        });
+	        var startDt = vue.ref(null);
+	        var dateValue = vue.ref(props.modelValue);
+	        // 父组件值发生改变时，同步dateValue
+	        vue.watch(function () { return props.modelValue; }, function (newV) {
+	            dateValue.value = newV;
+	        });
+	        var _disabledDate = function (date) {
+	            var _a;
+	            if (isFunction(props === null || props === void 0 ? void 0 : props.disabledDate)) {
+	                return (_a = props === null || props === void 0 ? void 0 : props.disabledDate) === null || _a === void 0 ? void 0 : _a.call(props, date, startDt.value);
+	            }
+	        };
+	        var handleChange = function (val) {
+	            emits('update:modelValue', val);
+	            emits('change', val);
+	        };
+	        var handleVisibleChange = function (visibility) {
+	            emits('visibleChange', visibility);
+	        };
+	        var handleCalendarChange = function (val) {
+	            startDt.value = val[0];
+	            emits('calendarChange', val);
+	        };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElDatePicker), {
+	                modelValue: dateValue.value,
+	                "onUpdate:modelValue": _cache[0] || (_cache[0] = function ($event) { return ((dateValue).value = $event); }),
+	                readonly: __props.readonly,
+	                disabled: __props.disabled,
+	                size: __props.size,
+	                editable: __props.editable,
+	                clearable: __props.clearable,
+	                placeholder: __props.placeholder,
+	                "start-placeholder": __props.startPlaceholder,
+	                "end-placeholder": __props.endPlaceholder,
+	                type: __props.type,
+	                format: __props.format,
+	                "popper-class": __props.popperClass,
+	                "range-separator": __props.rangeSeparator,
+	                "default-value": __props.defaultValue,
+	                "default-time": vue.unref(defaultTime),
+	                "value-format": vue.unref(valueFormat),
+	                "unlink-panels": __props.unlinkPanels,
+	                "prefix-icon": __props.prefixIcon,
+	                "clear-icon": __props.clearIcon,
+	                "validate-event": __props.validateEvent,
+	                "disabled-date": _disabledDate,
+	                shortcuts: __props.shortcuts,
+	                "cell-class-name": __props.cellClassName,
+	                teleported: __props.teleported,
+	                onChange: handleChange,
+	                onVisibleChange: handleVisibleChange,
+	                onCalendarChange: handleCalendarChange
+	            }, null, 8 /* PROPS */, ["modelValue", "readonly", "disabled", "size", "editable", "clearable", "placeholder", "start-placeholder", "end-placeholder", "type", "format", "popper-class", "range-separator", "default-value", "default-time", "value-format", "unlink-panels", "prefix-icon", "clear-icon", "validate-event", "shortcuts", "cell-class-name", "teleported"]));
+	        };
+	    } }));
+
+	script$e.__file = "packages/base/date-picker/date-picker.vue";
+
+	var BaseDatePicker = script$e;
+
+	var __default__$d = {
+	    name: 'base-input'
+	};
+	var script$d = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$d), { props: {
+	        modelValue: { type: [String, Number], required: false },
+	        type: { type: String, required: false, default: 'text' },
+	        maxlength: { type: [String, Number], required: false },
+	        minlength: { type: [String, Number], required: false },
+	        showWordLimit: { type: Boolean, required: false },
+	        placeholder: { type: String, required: false, default: '请输入' },
+	        clearable: { type: Boolean, required: false },
+	        formatter: { type: Function, required: false },
+	        parser: { type: Function, required: false },
+	        showPassword: { type: Boolean, required: false },
+	        disabled: { type: Boolean, required: false },
+	        size: { type: String, required: false },
+	        prefixIcon: { type: null, required: false },
+	        suffixIcon: { type: null, required: false },
+	        rows: { type: Number, required: false, default: 2 },
+	        autosize: { type: null, required: false },
+	        autocomplete: { type: String, required: false, default: 'off' },
+	        name: { type: String, required: false },
+	        readonly: { type: Boolean, required: false },
+	        max: { type: Number, required: false },
+	        min: { type: Number, required: false },
+	        step: { type: Number, required: false },
+	        resize: { type: String, required: false },
+	        autofocus: { type: Boolean, required: false },
+	        form: { type: String, required: false },
+	        label: { type: String, required: false },
+	        tabindex: { type: [String, Number], required: false },
+	        validateEvent: { type: Boolean, required: false, default: true },
+	        inputStyle: { type: null, required: false },
+	        inputRewrite: { type: null, required: false },
+	        changeRewrite: { type: null, required: false }
+	    }, emits: ["update:modelValue", "blur", "focus", "keyup", "change", "input", "clear"], setup: function (__props, _a) {
+	        var _this = this;
+	        var expose = _a.expose, emits = _a.emit;
+	        var _props = __props;
+	        var props = _props;
+	        var updateValue = function (value) {
+	            emits('update:modelValue', value); // 更新父级v-model绑定变量的值;
+	        };
+	        var handleBlur = function (event) {
+	            emits('blur', event);
+	        };
+	        var handleFocus = function (event) {
+	            emits('focus', event);
+	        };
+	        var handleChange = function (value) { return __awaiter(_this, void 0, void 0, function () {
+	            var _value, _a;
+	            var _b;
+	            return __generator(this, function (_c) {
+	                switch (_c.label) {
+	                    case 0:
+	                        if (!isFunction(props.changeRewrite)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, ((_b = props.changeRewrite) === null || _b === void 0 ? void 0 : _b.call(props, value))];
+	                    case 1:
+	                        _a = _c.sent();
+	                        return [3 /*break*/, 3];
+	                    case 2:
+	                        _a = value;
+	                        _c.label = 3;
+	                    case 3:
+	                        _value = (_a);
+	                        updateValue(_value);
+	                        emits('change', _value);
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleInput = function (value) { return __awaiter(_this, void 0, void 0, function () {
+	            var _value, _a;
+	            var _b;
+	            return __generator(this, function (_c) {
+	                switch (_c.label) {
+	                    case 0:
+	                        if (!isFunction(props.inputRewrite)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, ((_b = props.inputRewrite) === null || _b === void 0 ? void 0 : _b.call(props, value))];
+	                    case 1:
+	                        _a = _c.sent();
+	                        return [3 /*break*/, 3];
+	                    case 2:
+	                        _a = value;
+	                        _c.label = 3;
+	                    case 3:
+	                        _value = (_a);
+	                        updateValue(_value);
+	                        emits('input', _value);
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleClear = function () {
+	            emits('clear');
+	        };
+	        var handleKeyupEnter = function (event) {
+	            emits('keyup', event);
+	        };
+	        var BaseInputRef = vue.ref(null);
+	        expose({
+	            focus: function () {
+	                var _a, _b;
+	                (_b = (_a = BaseInputRef.value) === null || _a === void 0 ? void 0 : _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
+	            },
+	            blur: function () {
+	                var _a, _b;
+	                (_b = (_a = BaseInputRef.value) === null || _a === void 0 ? void 0 : _a.blur) === null || _b === void 0 ? void 0 : _b.call(_a);
+	            },
+	            select: function () {
+	                var _a, _b;
+	                (_b = (_a = BaseInputRef.value) === null || _a === void 0 ? void 0 : _a.select) === null || _b === void 0 ? void 0 : _b.call(_a);
+	            }
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElInput), {
+	                class: "base-input",
+	                type: __props.type,
+	                "model-value": __props.modelValue,
+	                minlength: __props.minlength,
+	                maxlength: __props.maxlength,
+	                "show-word-limit": __props.showWordLimit,
+	                placeholder: __props.placeholder,
+	                clearable: __props.clearable,
+	                formatter: __props.formatter,
+	                parser: __props.parser,
+	                "show-password": __props.showPassword,
+	                disabled: __props.disabled,
+	                size: __props.size,
+	                "prefix-icon": __props.prefixIcon,
+	                "suffix-icon": __props.suffixIcon,
+	                rows: __props.rows,
+	                autosize: __props.autosize,
+	                autocomplete: __props.autocomplete,
+	                name: __props.name,
+	                readonly: __props.readonly,
+	                max: __props.max,
+	                min: __props.min,
+	                step: __props.step,
+	                resize: __props.resize,
+	                autofocus: __props.autofocus,
+	                form: __props.form,
+	                label: __props.label,
+	                tabindex: __props.tabindex,
+	                "validate-event": __props.validateEvent,
+	                "input-style": __props.inputStyle,
+	                ref_key: "BaseInputRef",
+	                ref: BaseInputRef,
+	                onBlur: handleBlur,
+	                onFocus: handleFocus,
+	                onInput: handleInput,
+	                onChange: handleChange,
+	                onClear: handleClear,
+	                onKeyup: vue.withKeys(handleKeyupEnter, ["enter"])
+	            }, null, 8 /* PROPS */, ["type", "model-value", "minlength", "maxlength", "show-word-limit", "placeholder", "clearable", "formatter", "parser", "show-password", "disabled", "size", "prefix-icon", "suffix-icon", "rows", "autosize", "autocomplete", "name", "readonly", "max", "min", "step", "resize", "autofocus", "form", "label", "tabindex", "validate-event", "input-style", "onKeyup"]));
+	        };
+	    } }));
+
+	script$d.__scopeId = "data-v-36a4c1cb";
+	script$d.__file = "packages/base/input/input.vue";
+
+	var BaseInput = script$d;
+
+	var __default__$c = {
+	    name: 'base-tool-tip'
+	};
+	var script$c = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$c), { props: {
+	        popperClass: { type: String, required: false, default: 'base-tool-tip' },
+	        trigger: { type: String, required: false },
+	        transition: { type: String, required: false, default: 'el-fade-in-linear' },
+	        disabled: { type: Boolean, required: false },
+	        enterable: { type: Boolean, required: false, default: true },
+	        hideAfter: { type: Number, required: false, default: 100 },
+	        placement: { type: String, required: false, default: 'top' },
+	        content: { type: [String, Number], required: false },
+	        style: { type: null, required: false },
+	        overShow: { type: Boolean, required: false, default: false }
+	    }, setup: function (__props) {
+	        var props = __props;
+	        var _overShow = vue.ref(props.overShow);
+	        var toolTipDefault = vue.ref(null);
+	        var toolTipDefaultContent = vue.ref(null);
+	        var _content = vue.computed(function () { return props.content; });
+	        var handleMouseMove = function () {
+	            var _a, _b;
+	            if (((_a = toolTipDefault.value) === null || _a === void 0 ? void 0 : _a.tagName) && ((_b = toolTipDefaultContent.value) === null || _b === void 0 ? void 0 : _b.tagName)) {
+	                var _c = toolTipDefault.value, offsetWidth = _c.offsetWidth, offsetHeight = _c.offsetHeight;
+	                var _d = toolTipDefaultContent.value, childOffsetWidth = _d.offsetWidth, childOffsetHeight = _d.offsetHeight;
+	                _overShow.value = !(offsetWidth < childOffsetWidth || offsetHeight < childOffsetHeight);
+	            }
+	        };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTooltip), {
+	                key: _overShow.value ? '1' : '0',
+	                "popper-class": __props.popperClass,
+	                trigger: __props.trigger,
+	                transition: __props.transition,
+	                disabled: _overShow.value || __props.disabled,
+	                placement: __props.placement,
+	                hideAfter: __props.hideAfter,
+	                enterable: __props.enterable,
+	                content: vue.unref(_content)
+	            }, {
+	                content: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "content")
+	                ]; }),
+	                default: vue.withCtx(function () { return [
+	                    (__props.overShow)
+	                        ? (vue.openBlock(), vue.createElementBlock("div", {
+	                            key: 0,
+	                            style: vue.normalizeStyle([{ "width": "100%" }, __props.style]),
+	                            onMousemove: handleMouseMove,
+	                            ref_key: "toolTipDefault",
+	                            ref: toolTipDefault
+	                        }, [
+	                            vue.createElementVNode("span", {
+	                                ref_key: "toolTipDefaultContent",
+	                                ref: toolTipDefaultContent
+	                            }, [
+	                                vue.renderSlot(_ctx.$slots, "default")
+	                            ], 512 /* NEED_PATCH */)
+	                        ], 36 /* STYLE, HYDRATE_EVENTS */))
+	                        : vue.renderSlot(_ctx.$slots, "default", { key: 1 })
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["popper-class", "trigger", "transition", "disabled", "placement", "hideAfter", "enterable", "content"]));
+	        };
+	    } }));
+
+	script$c.__file = "packages/base/tool-tip/tool-tip.vue";
+
+	var BaseToolTip = script$c;
+
+	var __default__$b = {
+	    name: 'base-select'
+	};
+	var script$b = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$b), { props: {
+	        init: { type: Boolean, required: false, default: false },
+	        filterUseRemote: { type: Boolean, required: false, default: false },
+	        options: { type: null, required: false },
+	        group: { type: Boolean, required: false },
+	        labelKey: { type: String, required: false, default: 'label' },
+	        valueKey: { type: String, required: false, default: 'value' },
+	        optionsKey: { type: String, required: false, default: 'options' },
+	        modelValue: { type: null, required: false },
+	        multiple: { type: Boolean, required: false },
+	        disabled: { type: Boolean, required: false },
+	        size: { type: String, required: false },
+	        clearable: { type: Boolean, required: false },
+	        collapseTags: { type: Boolean, required: false },
+	        collapseTagsTooltip: { type: Boolean, required: false },
+	        multipleLimit: { type: Number, required: false },
+	        placeholder: { type: String, required: false },
+	        filterable: { type: Boolean, required: false },
+	        allowCreate: { type: Boolean, required: false },
+	        fitInputWidth: { type: Boolean, required: false, default: true },
+	        filterMethod: { type: Function, required: false },
+	        remoteMethod: { type: Function, required: false },
+	        loadingText: { type: String, required: false, default: '加载中' },
+	        noMatchText: { type: String, required: false, default: '暂无数据' },
+	        noDataText: { type: String, required: false, default: '暂无数据' }
+	    }, emits: ["update:modelValue", "change", "remove-tag", "visible-change", "clear"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var _Reflect = Reflect;
+	        var props = _props;
+	        var setOptionsData = function (val) { return __awaiter(_this, void 0, void 0, function () {
+	            var res, data, error_1;
+	            var _a;
+	            return __generator(this, function (_b) {
+	                switch (_b.label) {
+	                    case 0:
+	                        if (!isFunction(props.remoteMethod)) return [3 /*break*/, 4];
+	                        _b.label = 1;
+	                    case 1:
+	                        _b.trys.push([1, 3, , 4]);
+	                        loading.value = true;
+	                        return [4 /*yield*/, ((_a = props.remoteMethod) === null || _a === void 0 ? void 0 : _a.call(props, val))];
+	                    case 2:
+	                        res = _b.sent();
+	                        data = xrkTools.check.isObject(res.data)
+	                            ? Array.isArray(res.data.list)
+	                                ? res.data.list
+	                                : []
+	                            : Array.isArray(res.data)
+	                                ? res.data
+	                                : [];
+	                        loading.value = false;
+	                        // 避免多次请求接口 接口响应先后顺序不一致导致数据错乱
+	                        _options.value = Array.isArray(data)
+	                            ? data.filter(function (i) { return !val || "".concat(i[props.valueKey]).indexOf(val) > -1; })
+	                            : [];
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        error_1 = _b.sent();
+	                        loading.value = false;
+	                        console.error(error_1);
+	                        return [3 /*break*/, 4];
+	                    case 4: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var _filterable = vue.computed(function () { return props.filterable || isFunction(props.remoteMethod); });
+	        var debounceSetOptionsData = xrkTools.base.debounce(setOptionsData, 600);
+	        var _filterMethod = (props.filterUseRemote
+	            ? function (val) {
+	                loading.value = true;
+	                debounceSetOptionsData(val);
+	            }
+	            : props.filterMethod);
+	        var toolTipDisabled = vue.ref(true);
+	        var loading = vue.ref(false);
+	        var _options = vue.ref(props.options);
+	        var selectValue = vue.ref(props.multiple && props.modelValue && !Array.isArray(props.modelValue)
+	            ? [props.modelValue]
+	            : props.modelValue);
+	        // 父组件值发生改变时，同步selectValue
+	        vue.watch(function () { return props.modelValue; }, function (newV) {
+	            selectValue.value = newV;
+	        });
+	        var getSelectOptions = function (options, selectValue) {
+	            return options.reduce(function (pre, option) {
+	                if (Array.isArray(selectValue)
+	                    ? selectValue.includes(Reflect.get(option, props.valueKey))
+	                    : Reflect.get(option, props.valueKey) == selectValue) {
+	                    pre.push(option);
+	                }
+	                if (Array.isArray(option.options)) {
+	                    pre.push.apply(pre, getSelectOptions(option.options, selectValue));
+	                }
+	                return pre;
+	            }, []);
+	        };
+	        var handleChange = function (value) {
+	            emits('update:modelValue', value);
+	            emits('change', value, Array.isArray(_options.value) ? getSelectOptions(_options.value, value) : []);
+	        };
+	        var handleVisibleChange = function (visibleStatus) {
+	            toolTipDisabled.value = !visibleStatus;
+	            if (visibleStatus) {
+	                setOptionsData();
+	            }
+	            emits('visible-change', visibleStatus);
+	        };
+	        var handleClear = function () {
+	            emits('clear');
+	        };
+	        var handleRemoveTag = function (value) {
+	            emits('remove-tag', value);
+	        };
+	        if (props.init) {
+	            setOptionsData();
+	        }
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElSelect), {
+	                modelValue: vue.unref(selectValue),
+	                "onUpdate:modelValue": _cache[0] || (_cache[0] = function ($event) { return (vue.isRef(selectValue) ? (selectValue).value = $event : null); }),
+	                placeholder: __props.placeholder,
+	                multiple: __props.multiple,
+	                disabled: __props.disabled,
+	                size: __props.size,
+	                clearable: __props.clearable,
+	                collapseTags: __props.collapseTags,
+	                collapseTagsTooltip: __props.collapseTagsTooltip,
+	                multipleLimit: __props.multipleLimit,
+	                filterable: vue.unref(_filterable),
+	                allowCreate: __props.allowCreate,
+	                filterMethod: vue.unref(_filterMethod),
+	                loading: loading.value,
+	                remoteMethod: __props.remoteMethod,
+	                loadingText: __props.loadingText,
+	                noMatchText: __props.noMatchText,
+	                noDataText: __props.noDataText,
+	                fitInputWidth: __props.fitInputWidth,
+	                onChange: handleChange,
+	                onVisibleChange: handleVisibleChange,
+	                onRemoveTag: handleRemoveTag,
+	                onClear: handleClear
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    (__props.group)
+	                        ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_options.value, function (group) {
+	                            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElOptionGroup), {
+	                                key: vue.unref(_Reflect).get(group, __props.labelKey),
+	                                label: vue.unref(_Reflect).get(group, __props.labelKey)
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(_Reflect).get(group, __props.optionsKey) || [], function (item) {
+	                                        return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElOption), {
+	                                            class: "option",
+	                                            key: item[__props.valueKey],
+	                                            label: item[__props.labelKey],
+	                                            value: item[__props.valueKey]
+	                                        }, {
+	                                            default: vue.withCtx(function () { return [
+	                                                vue.createVNode(vue.unref(BaseToolTip), {
+	                                                    content: item[__props.labelKey],
+	                                                    hideAfter: 0,
+	                                                    enterable: false,
+	                                                    transition: "none",
+	                                                    disabled: toolTipDisabled.value,
+	                                                    overShow: true
+	                                                }, {
+	                                                    default: vue.withCtx(function () { return [
+	                                                        vue.createElementVNode("span", null, vue.toDisplayString(item[__props.labelKey]), 1 /* TEXT */)
+	                                                    ]; }),
+	                                                    _: 2 /* DYNAMIC */
+	                                                }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["content", "disabled"])
+	                                            ]; }),
+	                                            _: 2 /* DYNAMIC */
+	                                        }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["label", "value"]));
+	                                    }), 128 /* KEYED_FRAGMENT */))
+	                                ]; }),
+	                                _: 2 /* DYNAMIC */
+	                            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["label"]));
+	                        }), 128 /* KEYED_FRAGMENT */))
+	                        : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_options.value, function (item) {
+	                            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElOption), {
+	                                class: "option",
+	                                key: vue.unref(_Reflect).get(item, __props.labelKey),
+	                                label: vue.unref(_Reflect).get(item, __props.labelKey),
+	                                value: vue.unref(_Reflect).get(item, __props.valueKey)
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    vue.createVNode(vue.unref(BaseToolTip), {
+	                                        content: vue.unref(_Reflect).get(item, __props.labelKey),
+	                                        hideAfter: 0,
+	                                        enterable: false,
+	                                        transition: "none",
+	                                        disabled: toolTipDisabled.value,
+	                                        overShow: true
+	                                    }, {
+	                                        default: vue.withCtx(function () { return [
+	                                            vue.createTextVNode(vue.toDisplayString(vue.unref(_Reflect).get(item, __props.labelKey)), 1 /* TEXT */)
+	                                        ]; }),
+	                                        _: 2 /* DYNAMIC */
+	                                    }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["content", "disabled"])
+	                                ]; }),
+	                                _: 2 /* DYNAMIC */
+	                            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["label", "value"]));
+	                        }), 128 /* KEYED_FRAGMENT */))
+	                ]; }),
+	                _: 1 /* STABLE */
+	            }, 8 /* PROPS */, ["modelValue", "placeholder", "multiple", "disabled", "size", "clearable", "collapseTags", "collapseTagsTooltip", "multipleLimit", "filterable", "allowCreate", "filterMethod", "loading", "remoteMethod", "loadingText", "noMatchText", "noDataText", "fitInputWidth"]));
+	        };
+	    } }));
+
+	script$b.__scopeId = "data-v-545bd175";
+	script$b.__file = "packages/base/select/select.vue";
+
+	/*
+	 * @Description:
+	 * @Date: 2022-06-29 18:18:19
+	 */
+	var BaseSelect = script$b;
+
+	var __default__$a = {
+	    name: 'base-switch'
+	};
+	var script$a = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$a), { props: {
+	        modelValue: { type: [Boolean, String, Number], required: false },
+	        disabled: { type: Boolean, required: false },
+	        loading: { type: Boolean, required: false },
+	        size: { type: String, required: false },
+	        width: { type: Number, required: false },
+	        activeIcon: { type: null, required: false },
+	        activeText: { type: String, required: false },
+	        activeValue: { type: [Boolean, String, Number], required: false, default: true },
+	        inactiveIcon: { type: null, required: false },
+	        inactiveText: { type: String, required: false },
+	        inactiveValue: { type: [Boolean, String, Number], required: false, default: false },
+	        beforeChange: { type: Function, required: false }
+	    }, emits: ["update:modelValue", "change"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var props = _props;
+	        var _loading = vue.ref(props.loading);
+	        var _switchValue = vue.ref(props.modelValue);
+	        // 父组件值发生改变时，同步_switchValue
+	        vue.watch(function () { return props.modelValue; }, function (newV) {
+	            _switchValue.value = newV;
+	        });
+	        var _beforeChange = (function () { return __awaiter(_this, void 0, void 0, function () {
+	            var error_1;
+	            var _a;
+	            return __generator(this, function (_b) {
+	                switch (_b.label) {
+	                    case 0:
+	                        _b.trys.push([0, 3, , 4]);
+	                        _loading.value = true;
+	                        if (!isFunction(props.beforeChange)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, ((_a = props.beforeChange) === null || _a === void 0 ? void 0 : _a.call(props))];
+	                    case 1:
+	                        _b.sent();
+	                        _b.label = 2;
+	                    case 2:
+	                        _loading.value = false;
+	                        return [2 /*return*/, true];
+	                    case 3:
+	                        error_1 = _b.sent();
+	                        console.error('switch change fail', error_1);
+	                        _loading.value = false;
+	                        return [2 /*return*/, false];
+	                    case 4: return [2 /*return*/];
+	                }
+	            });
+	        }); });
+	        var handleChange = function (val) {
+	            _switchValue.value = val;
+	            emits('update:modelValue', val);
+	            emits('change', val);
+	        };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElSwitch), {
+	                class: "base-switch",
+	                modelValue: _switchValue.value,
+	                "onUpdate:modelValue": _cache[0] || (_cache[0] = function ($event) { return ((_switchValue).value = $event); }),
+	                disabled: __props.disabled,
+	                loading: _loading.value,
+	                size: __props.size,
+	                width: __props.width,
+	                activeIcon: __props.activeIcon,
+	                activeText: __props.activeText,
+	                activeValue: __props.activeValue,
+	                inactiveIcon: __props.inactiveIcon,
+	                inactiveText: __props.inactiveText,
+	                inactiveValue: __props.inactiveValue,
+	                beforeChange: vue.unref(_beforeChange),
+	                onChange: handleChange
+	            }, null, 8 /* PROPS */, ["modelValue", "disabled", "loading", "size", "width", "activeIcon", "activeText", "activeValue", "inactiveIcon", "inactiveText", "inactiveValue", "beforeChange"]));
+	        };
+	    } }));
+
+	script$a.__scopeId = "data-v-50b6e275";
+	script$a.__file = "packages/base/switch/switch.vue";
+
+	var BaseSwitch = script$a;
+
+	var __default__$9 = {
+	    name: 'base-tag'
+	};
+	var script$9 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$9), { props: {
+	        type: { type: String, required: false },
+	        closable: { type: Boolean, required: false },
+	        disableTransitions: { type: Boolean, required: false },
+	        hit: { type: Boolean, required: false },
+	        color: { type: String, required: false },
+	        size: { type: String, required: false, default: 'large' },
+	        effect: { type: String, required: false },
+	        round: { type: Boolean, required: false }
+	    }, emits: ["click", "close"], setup: function (__props, _a) {
+	        var emits = _a.emit;
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTag), {
+	                type: __props.type,
+	                closable: __props.closable,
+	                disableTransitions: __props.disableTransitions,
+	                hit: __props.hit,
+	                color: __props.color,
+	                size: __props.size,
+	                effect: __props.effect,
+	                round: __props.round,
+	                onClick: _cache[0] || (_cache[0] = function ($event) { return (emits('click')); }),
+	                onClose: _cache[1] || (_cache[1] = function ($event) { return (emits('close')); })
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["type", "closable", "disableTransitions", "hit", "color", "size", "effect", "round"]));
+	        };
+	    } }));
+
+	script$9.__file = "packages/base/tag/tag.vue";
+
+	var _hoisted_1$4 = { class: "base-tag-group" };
+	var __default__$8 = {
+	    name: 'base-tag-group'
+	};
+	var script$8 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$8), { props: {
+	        modelValue: { type: Array, required: false },
+	        labelKey: { type: String, required: false, default: 'label' },
+	        type: { type: String, required: false },
+	        disableTransitions: { type: Boolean, required: false },
+	        hit: { type: Boolean, required: false },
+	        color: { type: String, required: false },
+	        size: { type: String, required: false },
+	        effect: { type: String, required: false },
+	        round: { type: Boolean, required: false },
+	        beforeClose: { type: null, required: false },
+	        beforeAdd: { type: Function, required: false },
+	        showAdd: { type: Boolean, required: false, default: false },
+	        addBtnText: { type: String, required: false, default: '新增' },
+	        maxlength: { type: Number, required: false, default: 20 }
+	    }, emits: ["update:modelValue", "change", "click"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var vLoading = ElementPlus.vLoading;
+	        var _Reflect = Reflect;
+	        var props = _props;
+	        var tagsValue = vue.ref(props.modelValue);
+	        var closeIndex = vue.ref(-1);
+	        var adding = vue.ref(false);
+	        var handleTagClose = function (index) { return __awaiter(_this, void 0, void 0, function () {
+	            var error_1;
+	            var _a, _b, _c;
+	            return __generator(this, function (_d) {
+	                switch (_d.label) {
+	                    case 0:
+	                        if (closeIndex.value > -1)
+	                            return [2 /*return*/];
+	                        _d.label = 1;
+	                    case 1:
+	                        _d.trys.push([1, 4, , 5]);
+	                        closeIndex.value = index;
+	                        if (!isFunction(props.beforeClose)) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, ((_a = props.beforeClose) === null || _a === void 0 ? void 0 : _a.call(props, (_b = tagsValue.value) === null || _b === void 0 ? void 0 : _b[index]))];
+	                    case 2:
+	                        _d.sent();
+	                        _d.label = 3;
+	                    case 3:
+	                        (_c = tagsValue.value) === null || _c === void 0 ? void 0 : _c.splice(index, 1);
+	                        emits('update:modelValue', tagsValue.value);
+	                        emits('change', tagsValue.value);
+	                        closeIndex.value = -1;
+	                        return [3 /*break*/, 5];
+	                    case 4:
+	                        error_1 = _d.sent();
+	                        console.error(error_1);
+	                        closeIndex.value = -1;
+	                        return [3 /*break*/, 5];
+	                    case 5: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleTagClick = function (index) {
+	            var _a;
+	            emits('click', (_a = tagsValue.value) === null || _a === void 0 ? void 0 : _a[index]);
+	        };
+	        /**
+	         * 增加标签逻辑
+	         */
+	        var InputRef = vue.ref(null);
+	        var inputVisible = vue.ref(false);
+	        var inputValue = vue.ref('');
+	        var showInput = function () {
+	            inputVisible.value = true;
+	            vue.nextTick(function () {
+	                InputRef.value.focus();
+	            });
+	        };
+	        var handleInputConfirm = function () { return __awaiter(_this, void 0, void 0, function () {
+	            var _value, _a;
+	            var _b, _c;
+	            return __generator(this, function (_d) {
+	                switch (_d.label) {
+	                    case 0:
+	                        if (adding.value) {
+	                            return [2 /*return*/];
+	                        }
+	                        if (xrkTools.check.isFalseValue(inputValue.value)) {
+	                            inputVisible.value = false;
+	                            return [2 /*return*/];
+	                        }
+	                        _d.label = 1;
+	                    case 1:
+	                        _d.trys.push([1, 5, , 6]);
+	                        adding.value = true;
+	                        if (!isFunction(props.beforeAdd)) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, ((_b = props.beforeAdd) === null || _b === void 0 ? void 0 : _b.call(props, inputValue.value))];
+	                    case 2:
+	                        _a = _d.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        _a = { label: inputValue.value, value: inputValue.value, closable: true };
+	                        _d.label = 4;
+	                    case 4:
+	                        _value = (_a);
+	                        (_c = tagsValue.value) === null || _c === void 0 ? void 0 : _c.push(_value);
+	                        emits('update:modelValue', tagsValue.value);
+	                        emits('change', tagsValue.value);
+	                        inputVisible.value = false;
+	                        adding.value = false;
+	                        inputValue.value = '';
+	                        return [3 /*break*/, 6];
+	                    case 5:
+	                        _d.sent();
+	                        adding.value = false;
+	                        inputVisible.value = false;
+	                        inputValue.value = '';
+	                        return [3 /*break*/, 6];
+	                    case 6: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$4, [
+	                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.modelValue, function (item, index) {
+	                    return vue.withDirectives((vue.openBlock(), vue.createBlock(script$9, {
+	                        class: "base-tag",
+	                        key: index,
+	                        type: __props.type,
+	                        closable: item['closable'],
+	                        disableTransitions: __props.disableTransitions,
+	                        hit: __props.hit,
+	                        color: __props.color,
+	                        size: __props.size,
+	                        effect: __props.effect,
+	                        round: __props.round,
+	                        onClose: function ($event) { return (handleTagClose(index)); },
+	                        onClick: function ($event) { return (handleTagClick(index)); }
+	                    }, {
+	                        default: vue.withCtx(function () { return [
+	                            vue.createTextVNode(vue.toDisplayString(vue.unref(_Reflect).get(item, __props.labelKey)), 1 /* TEXT */)
+	                        ]; }),
+	                        _: 2 /* DYNAMIC */
+	                    }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["type", "closable", "disableTransitions", "hit", "color", "size", "effect", "round", "onClose", "onClick"])), [
+	                        [vue.unref(vLoading), closeIndex.value == index]
+	                    ]);
+	                }), 128 /* KEYED_FRAGMENT */)),
+	                (__props.showAdd)
+	                    ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+	                        (inputVisible.value)
+	                            ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(BaseInput), {
+	                                key: 0,
+	                                class: "base-input",
+	                                clearable: "",
+	                                disabled: adding.value,
+	                                ref_key: "InputRef",
+	                                ref: InputRef,
+	                                modelValue: inputValue.value,
+	                                "onUpdate:modelValue": _cache[0] || (_cache[0] = function ($event) { return ((inputValue).value = $event); }),
+	                                size: __props.size,
+	                                maxlength: __props.maxlength,
+	                                onKeyup: vue.withKeys(handleInputConfirm, ["enter"]),
+	                                onBlur: handleInputConfirm
+	                            }, null, 8 /* PROPS */, ["disabled", "modelValue", "size", "maxlength", "onKeyup"])), [
+	                                [vue.unref(vLoading), adding.value]
+	                            ])
+	                            : (vue.openBlock(), vue.createBlock(vue.unref(BaseButton), {
+	                                key: 1,
+	                                size: __props.size,
+	                                onClick: showInput,
+	                                disabled: adding.value
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    vue.createTextVNode(vue.toDisplayString(__props.addBtnText), 1 /* TEXT */)
+	                                ]; }),
+	                                _: 1 /* STABLE */
+	                            }, 8 /* PROPS */, ["size", "disabled"]))
+	                    ], 64 /* STABLE_FRAGMENT */))
+	                    : vue.createCommentVNode("v-if", true)
+	            ]));
+	        };
+	    } }));
+
+	script$8.__scopeId = "data-v-eb1feb46";
+	script$8.__file = "packages/base/tag/tag-group.vue";
+
+	var BaseTag = script$9;
+	var BaseTagGroup = script$8;
+
+	var __default__$7 = {
+	    name: 'base-pagination'
+	};
+	var script$7 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$7), { props: {
+	        small: { type: Boolean, required: false, default: true },
+	        currentPage: { type: Number, required: false, default: 1 },
+	        pageSize: { type: Number, required: false, default: 15 },
+	        total: { type: Number, required: false },
+	        pagerCount: { type: Number, required: false, default: 7 },
+	        pageSizes: { type: Array, required: false, default: function () { return [15, 60, 100]; } },
+	        hideOnSinglePage: { type: Boolean, required: false, default: false },
+	        layout: { type: Array, required: false, default: function () { return ['total', 'sizes', 'prev', 'pager', 'next', 'jumper']; } }
+	    }, emits: ["size-change", "current-change"], setup: function (__props, _a) {
+	        var expose = _a.expose, emits = _a.emit;
+	        var props = __props;
+	        var _pageSize = vue.ref(props.pageSize);
+	        var _currentPage = vue.ref(props.currentPage);
+	        var _layout = vue.ref(Array.isArray(props.layout) ? props.layout.join(',') : props.layout);
+	        var maxPage = vue.computed(function () { return Math.ceil((props.total || 0) / _pageSize.value); });
+	        var setCurrentPage = function (newCurrentPage) {
+	            if (!newCurrentPage || newCurrentPage == _currentPage.value)
+	                return;
+	            if (newCurrentPage > maxPage.value) {
+	                // 设置的页码超过最大页码
+	                console.warn("currentPage ".concat(newCurrentPage, " \u5927\u4E8E\u6700\u5927\u9875\u7801 ").concat(maxPage.value));
+	            }
+	            else {
+	                _currentPage.value = newCurrentPage;
+	            }
+	        };
+	        var setPageSize = function (newPageSize) {
+	            if (!newPageSize || newPageSize == _pageSize.value)
+	                return;
+	            if (props.pageSizes.includes(newPageSize)) {
+	                _pageSize.value = newPageSize;
+	            }
+	            else {
+	                console.warn("pageSize ".concat(newPageSize, " \u4E0D\u5728 pageSizes ").concat(props.pageSizes, " \u4E2D"));
+	            }
+	        };
+	        // watch(
+	        //   () => [props.currentPage, props.pageSize],
+	        //   ([newCurrentPage, newPageSize]) => {
+	        //     if (newCurrentPage > maxPage.value) {
+	        //       // 设置的页码超过最大页码
+	        //       emits('update:currentPage', _currentPage.value);
+	        //       console.warn(
+	        //         `currentPage ${newCurrentPage} 大于最大页码 ${maxPage.value}`
+	        //       );
+	        //     } else {
+	        //       _currentPage.value = newCurrentPage;
+	        //     }
+	        //     if (props.pageSizes.includes(newPageSize)) {
+	        //       _pageSize.value = newPageSize;
+	        //     } else {
+	        //       emits('update:pageSize', _pageSize.value);
+	        //       console.warn(
+	        //         `pageSize ${newPageSize} 不在 pageSizes ${props.pageSizes} 中`
+	        //       );
+	        //     }
+	        //   }
+	        // );
+	        var handleSizeChange = function (pageSize) {
+	            _pageSize.value = pageSize;
+	            // emits('update:pageSize', pageSize);
+	            if (maxPage.value >= _currentPage.value) {
+	                // 组件不会再次触发size-change事件，没有这个判断，会导致同事触发size-change 和 size-change
+	                emits('size-change', {
+	                    pageSize: pageSize,
+	                    currentPage: _currentPage.value
+	                });
+	            }
+	        };
+	        var handleCurrenChange = function (currentPage) {
+	            _currentPage.value = currentPage;
+	            // emits('update:currentPage', currentPage);
+	            emits('current-change', {
+	                pageSize: _pageSize.value,
+	                currentPage: currentPage
+	            });
+	        };
+	        expose({
+	            // 父组件调用，修改组件内页面显示，不会触发emits事件。
+	            setPageInfo: function (info) {
+	                setPageSize(info.pageSize);
+	                setCurrentPage(info.currentPage);
+	            },
+	            getPageInfo: function () { return ({
+	                pageSize: _pageSize.value,
+	                currentPage: _currentPage.value
+	            }); }
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElPagination), {
+	                class: "base-pagination",
+	                small: __props.small,
+	                "page-size": _pageSize.value,
+	                "current-page": _currentPage.value,
+	                layout: _layout.value,
+	                total: __props.total,
+	                pagerCount: __props.pagerCount,
+	                pageSizes: __props.pageSizes,
+	                hideOnSinglePage: __props.hideOnSinglePage,
+	                onSizeChange: handleSizeChange,
+	                onCurrentChange: handleCurrenChange
+	            }, null, 8 /* PROPS */, ["small", "page-size", "current-page", "layout", "total", "pagerCount", "pageSizes", "hideOnSinglePage"]));
+	        };
+	    } }));
+
+	script$7.__scopeId = "data-v-1a7c8335";
+	script$7.__file = "packages/base/pagination/pagination.vue";
+
+	var BasePagination = script$7;
+
+	var __default__$6 = {
+	    name: 'base-form'
+	};
+	var script$6 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$6), { props: {
+	        model: { type: null, required: true },
+	        rules: { type: null, required: false },
+	        inline: { type: Boolean, required: false },
+	        labelPosition: { type: String, required: false, default: 'left' },
+	        labelWidth: { type: [String, Number], required: false, default: 'auto' },
+	        labelSuffix: { type: String, required: false },
+	        hideRequiredAsterisk: { type: Boolean, required: false },
+	        showMessage: { type: Boolean, required: false, default: true },
+	        inlineMessage: { type: Boolean, required: false },
+	        statusIcon: { type: Boolean, required: false },
+	        validateOnRuleChange: { type: Boolean, required: false, default: true },
+	        size: { type: String, required: false },
+	        disabled: { type: Boolean, required: false }
+	    }, setup: function (__props, _a) {
+	        var expose = _a.expose;
+	        var BaseForm = vue.ref(null);
+	        expose({
+	            validate: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                return (_a = BaseForm.value) === null || _a === void 0 ? void 0 : _a.validate.apply(_a, args);
+	            },
+	            validateField: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                return (_a = BaseForm.value) === null || _a === void 0 ? void 0 : _a.validateField.apply(_a, args);
+	            },
+	            resetFields: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                return (_a = BaseForm.value) === null || _a === void 0 ? void 0 : _a.resetFields.apply(_a, args);
+	            },
+	            scrollToField: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                return (_a = BaseForm.value) === null || _a === void 0 ? void 0 : _a.scrollToField.apply(_a, args);
+	            },
+	            clearValidate: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                return (_a = BaseForm.value) === null || _a === void 0 ? void 0 : _a.clearValidate.apply(_a, args);
+	            }
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElForm), {
+	                ref_key: "BaseForm",
+	                ref: BaseForm,
+	                model: __props.model,
+	                rules: __props.rules,
+	                inline: __props.inline,
+	                labelPosition: __props.labelPosition,
+	                labelWidth: __props.labelWidth,
+	                labelSuffix: __props.labelSuffix,
+	                hideRequiredAsterisk: __props.hideRequiredAsterisk,
+	                showMessage: __props.showMessage,
+	                inlineMessage: __props.inlineMessage,
+	                statusIcon: __props.statusIcon,
+	                validateOnRuleChange: __props.validateOnRuleChange,
+	                size: __props.size,
+	                disabled: __props.disabled
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["model", "rules", "inline", "labelPosition", "labelWidth", "labelSuffix", "hideRequiredAsterisk", "showMessage", "inlineMessage", "statusIcon", "validateOnRuleChange", "size", "disabled"]));
+	        };
+	    } }));
+
+	script$6.__file = "packages/base/form/form.vue";
+
+	var __default__$5 = {
+	    name: 'base-form-item'
+	};
+	var script$5 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$5), { props: {
+	        prop: { type: null, required: true },
+	        label: { type: String, required: false },
+	        labelWidth: { type: [String, Number], required: false, default: 'auto' },
+	        required: { type: Boolean, required: false },
+	        rules: { type: null, required: false },
+	        error: { type: String, required: false },
+	        showMessage: { type: Boolean, required: false, default: true },
+	        inlineMessage: { type: Boolean, required: false },
+	        size: { type: String, required: false }
+	    }, setup: function (__props, _a) {
+	        var _b, _c;
+	        var expose = _a.expose;
+	        var BaseFormItem = vue.ref(null);
+	        expose({
+	            resetField: (_b = BaseFormItem.value) === null || _b === void 0 ? void 0 : _b.resetField,
+	            clearValidate: (_c = BaseFormItem.value) === null || _c === void 0 ? void 0 : _c.clearValidate
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElFormItem), {
+	                class: "base-form-item",
+	                ref_key: "BaseFormItem",
+	                ref: BaseFormItem,
+	                prop: __props.prop,
+	                label: __props.label,
+	                labelWidth: __props.labelWidth,
+	                required: __props.required,
+	                rules: __props.rules,
+	                error: __props.error,
+	                showMessage: __props.showMessage,
+	                inlineMessage: __props.inlineMessage,
+	                size: __props.size
+	            }, {
+	                default: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "default")
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["prop", "label", "labelWidth", "required", "rules", "error", "showMessage", "inlineMessage", "size"]));
+	        };
+	    } }));
+
+	script$5.__scopeId = "data-v-17eda5db";
+	script$5.__file = "packages/base/form/form-item.vue";
+
+	var BaseFormItem = script$5;
+	var BaseForm = script$6;
+
+	var _hoisted_1$3 = { class: "xrk-search" };
+	var __default__$4 = {
+	    name: 'xrk-search'
+	};
+	var script$4 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$4), { props: {
+	        columns: { type: null, required: true },
+	        searchBtn: { type: null, required: false, default: function () { return ({
+	                text: '搜索',
+	                show: true
+	            }); } },
+	        resetBtn: { type: null, required: false, default: function () { return ({
+	                text: '重置',
+	                show: true
+	            }); } },
+	        otherComponents: { type: null, required: false }
+	    }, emits: ["search"], setup: function (__props, _a) {
+	        var _this = this;
+	        var expose = _a.expose, emits = _a.emit;
+	        var _props = __props;
+	        var components = vue.ref({
+	            input: vue.shallowRef(script$d),
+	            select: vue.shallowRef(script$b),
+	            datePicker: vue.shallowRef(script$e)
+	        });
+	        var props = _props;
+	        var columnsToSearchValue = function (columns) {
+	            return columns.reduce(function (pre, _a) {
+	                var prop = _a.prop, defaultValue = _a.defaultValue;
+	                pre[prop] = defaultValue || '';
+	                return pre;
+	            }, {});
+	        };
+	        // 将 searchValue 传入 每个搜索项的监听事件
+	        var proxyColumnListener = function (listener) {
+	            return Object.keys(listener).reduce(function (pre, cur) {
+	                pre[cur] = function () {
+	                    var args = [];
+	                    for (var _i = 0; _i < arguments.length; _i++) {
+	                        args[_i] = arguments[_i];
+	                    }
+	                    listener[cur].apply(listener, __spreadArray(__spreadArray([], args, false), [searchValue], false));
+	                };
+	                return pre;
+	            }, {});
+	        };
+	        var searchValue = vue.reactive(columnsToSearchValue(props.columns));
+	        var BaseSearchRender = vue.defineComponent({
+	            name: 'search-render',
+	            props: {
+	                render: Function
+	            },
+	            render: function (ctx) {
+	                return ctx.render
+	                    ? ctx.render({ columns: props.columns, searchValue: searchValue })
+	                    : '';
+	            }
+	        });
+	        var handleSearchClick = function () { return __awaiter(_this, void 0, void 0, function () {
+	            var _searchValue;
+	            var _a, _b, _c, _d, _e, _f;
+	            return __generator(this, function (_g) {
+	                switch (_g.label) {
+	                    case 0:
+	                        _searchValue = xrkTools.base.deepClone(searchValue);
+	                        if (!isFunction((_a = props.searchBtn) === null || _a === void 0 ? void 0 : _a.beforeSearch)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, ((_c = (_b = props.searchBtn) === null || _b === void 0 ? void 0 : _b.beforeSearch) === null || _c === void 0 ? void 0 : _c.call(_b, _searchValue))];
+	                    case 1:
+	                        _searchValue = _g.sent();
+	                        _g.label = 2;
+	                    case 2:
+	                        emits('search', _searchValue);
+	                        if (!isFunction((_d = props.searchBtn) === null || _d === void 0 ? void 0 : _d.afterSearch)) return [3 /*break*/, 4];
+	                        return [4 /*yield*/, ((_f = (_e = props.searchBtn) === null || _e === void 0 ? void 0 : _e.afterSearch) === null || _f === void 0 ? void 0 : _f.call(_e, _searchValue))];
+	                    case 3:
+	                        _g.sent();
+	                        _g.label = 4;
+	                    case 4: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleResetClick = function () { return __awaiter(_this, void 0, void 0, function () {
+	            var _searchValue;
+	            var _a, _b, _c, _d, _e, _f;
+	            return __generator(this, function (_g) {
+	                switch (_g.label) {
+	                    case 0:
+	                        Object.keys(searchValue).forEach(function (searchKey) { return (searchValue[searchKey] = null); });
+	                        _searchValue = xrkTools.base.deepClone(searchValue);
+	                        if (!isFunction((_a = props.resetBtn) === null || _a === void 0 ? void 0 : _a.beforeReset)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, ((_c = (_b = props.resetBtn) === null || _b === void 0 ? void 0 : _b.beforeReset) === null || _c === void 0 ? void 0 : _c.call(_b, _searchValue))];
+	                    case 1:
+	                        _searchValue = _g.sent();
+	                        _g.label = 2;
+	                    case 2:
+	                        emits('search', _searchValue);
+	                        if (!isFunction((_d = props.resetBtn) === null || _d === void 0 ? void 0 : _d.afterReset)) return [3 /*break*/, 4];
+	                        return [4 /*yield*/, ((_f = (_e = props.resetBtn) === null || _e === void 0 ? void 0 : _e.afterReset) === null || _f === void 0 ? void 0 : _f.call(_e, _searchValue))];
+	                    case 3:
+	                        _g.sent();
+	                        _g.label = 4;
+	                    case 4: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        expose({
+	            getSearchValue: function () {
+	                return xrkTools.base.deepClone(searchValue);
+	            },
+	            setSearchValue: function (key, value) {
+	                if (props.columns.findIndex(function (_a) {
+	                    var prop = _a.prop;
+	                    return prop == key;
+	                }) == -1) {
+	                    console.warn("\u539F\u59CBsearch\u914D\u7F6E\u9879\u4E0D\u5B58\u5728".concat(key, "\u5C5E\u6027\uFF0C\u5EFA\u8BAE\u4FEE\u6539"));
+	                }
+	                searchValue[key] = value;
+	            },
+	            handleSearchClick: handleSearchClick,
+	            handleResetClick: handleResetClick
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, [
+	                vue.createVNode(script$6, { model: searchValue }, {
+	                    default: vue.withCtx(function () { return [
+	                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.columns, function (_a) {
+	                            var style = _a.style, label = _a.label, prop = _a.prop, type = _a.type, disabled = _a.disabled, config = _a.config, listener = _a.listener;
+	                            return (vue.openBlock(), vue.createBlock(script$5, {
+	                                prop: prop,
+	                                label: label,
+	                                key: prop
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    type
+	                                        ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(components.value[type]), vue.mergeProps({
+	                                            key: 0,
+	                                            style: style
+	                                        }, __assign(__assign({}, config), proxyColumnListener(listener || {})), {
+	                                            disabled: vue.unref(isFunction)(disabled) ? disabled(searchValue) : disabled,
+	                                            modelValue: searchValue[prop],
+	                                            "onUpdate:modelValue": function ($event) { return ((searchValue[prop]) = $event); }
+	                                        }), null, 16 /* FULL_PROPS */, ["style", "disabled", "modelValue", "onUpdate:modelValue"]))
+	                                        : vue.createCommentVNode("v-if", true)
+	                                ]; }),
+	                                _: 2 /* DYNAMIC */
+	                            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["prop", "label"]));
+	                        }), 128 /* KEYED_FRAGMENT */)),
+	                        (__props.searchBtn.show)
+	                            ? (vue.openBlock(), vue.createBlock(script$l, {
+	                                key: 0,
+	                                click: handleSearchClick
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    vue.createTextVNode(vue.toDisplayString(__props.searchBtn.text), 1 /* TEXT */)
+	                                ]; }),
+	                                _: 1 /* STABLE */
+	                            }))
+	                            : vue.createCommentVNode("v-if", true),
+	                        (__props.resetBtn.show)
+	                            ? (vue.openBlock(), vue.createBlock(script$l, {
+	                                key: 1,
+	                                plain: true,
+	                                click: handleResetClick
+	                            }, {
+	                                default: vue.withCtx(function () { return [
+	                                    vue.createTextVNode(vue.toDisplayString(__props.resetBtn.text), 1 /* TEXT */)
+	                                ]; }),
+	                                _: 1 /* STABLE */
+	                            }))
+	                            : vue.createCommentVNode("v-if", true),
+	                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.otherComponents, function (_a, index) {
+	                            var render = _a.render;
+	                            return (vue.openBlock(), vue.createBlock(vue.unref(BaseSearchRender), {
+	                                render: render,
+	                                key: index
+	                            }, null, 8 /* PROPS */, ["render"]));
+	                        }), 128 /* KEYED_FRAGMENT */))
+	                    ]; }),
+	                    _: 1 /* STABLE */
+	                }, 8 /* PROPS */, ["model"])
+	            ]));
+	        };
+	    } }));
+
+	script$4.__scopeId = "data-v-a1781a06";
+	script$4.__file = "packages/xrk/search/search.vue";
+
+	var XrkSearch = script$4;
+
+	/*
+	 * @Description:
+	 * @Date: 2022-03-14 19:18:12
+	 */
+	var useTableSetup = function () {
+	    var info = vue.reactive({
+	        selectionRows: new Map()
+	    });
+	    return {
+	        selectionRows: info.selectionRows,
+	        hasSelectionRow: function (rowId) {
+	            return info.selectionRows.has(rowId);
+	        },
+	        addSelectionRow: function (rowId, row) {
+	            info.selectionRows.set(rowId, row);
+	        },
+	        removeSelectionRow: function (rowId) {
+	            info.selectionRows.delete(rowId);
+	        },
+	        getSelectionRows: function () {
+	            var arr = [];
+	            info.selectionRows.forEach(function (value) {
+	                arr.push(value);
+	            });
+	            return arr;
+	        },
+	        clearSelectionRows: function () {
+	            info.selectionRows.clear();
+	        }
+	    };
+	};
+
+	var __default__$3 = {
+	    name: 'base-table'
+	};
+	var script$3 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$3), { props: {
+	        data: { type: Array, required: true },
+	        columns: { type: null, required: true },
+	        height: { type: [String, Number], required: false },
+	        maxHeight: { type: [String, Number], required: false },
+	        stripe: { type: Boolean, required: false },
+	        border: { type: Boolean, required: false, default: true },
+	        size: { type: String, required: false },
+	        fit: { type: Boolean, required: false, default: true },
+	        rowClassName: { type: null, required: false },
+	        rowStyle: { type: null, required: false },
+	        cellClassName: { type: null, required: false },
+	        cellStyle: { type: null, required: false },
+	        headerRowClassName: { type: null, required: false },
+	        headerRowStyle: { type: null, required: false },
+	        headerCellClassName: { type: null, required: false },
+	        headerCellStyle: { type: null, required: false },
+	        rowKey: { type: [Function, String], required: false },
+	        defaultExpandAll: { type: Boolean, required: false },
+	        expandRowKeys: { type: Array, required: false },
+	        emptyText: { type: String, required: false, default: '暂无数据' },
+	        defaultSort: { type: Object, required: false }
+	    }, emits: ["sort-change", "select", "select-all"], setup: function (__props, _a) {
+	        var expose = _a.expose, emits = _a.emit;
+	        var _b = useTableSetup(), selectionRows = _b.selectionRows, getSelectionRows = _b.getSelectionRows, addSelectionRow = _b.addSelectionRow, removeSelectionRow = _b.removeSelectionRow, clearSelectionRows = _b.clearSelectionRows;
+	        var handleSortChange = function (info) {
+	            emits('sort-change', info);
+	        };
+	        var handleColumnSelect = function (selection, row) {
+	            emits('select', selection, row);
+	        };
+	        var handleColumnSelectAll = function (selection) {
+	            emits('select-all', selection);
+	        };
+	        expose({
+	            getSelectionRows: getSelectionRows,
+	            addSelectionRow: addSelectionRow,
+	            removeSelectionRow: removeSelectionRow,
+	            clearSelectionRows: clearSelectionRows
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTable), {
+	                class: "base-table",
+	                data: __props.data,
+	                height: __props.height,
+	                maxHeight: __props.maxHeight,
+	                stripe: __props.stripe,
+	                border: __props.border,
+	                size: __props.size,
+	                fit: __props.fit,
+	                rowClassName: __props.rowClassName,
+	                rowStyle: __props.rowStyle,
+	                cellClassName: __props.cellClassName,
+	                cellStyle: __props.cellStyle,
+	                headerRowClassName: __props.headerRowClassName,
+	                headerRowStyle: __props.headerRowStyle,
+	                rowKey: __props.rowKey,
+	                defaultExpandAll: __props.defaultExpandAll,
+	                expandRowKeys: __props.expandRowKeys,
+	                defaultSort: __props.defaultSort,
+	                emptyText: __props.emptyText,
+	                onSortChange: handleSortChange
+	            }, {
+	                empty: vue.withCtx(function () { return [
+	                    vue.renderSlot(_ctx.$slots, "empty")
+	                ]; }),
+	                default: vue.withCtx(function () { return [
+	                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.columns, function (column) {
+	                        return (vue.openBlock(), vue.createBlock(vue.unref(BaseTableColumn), vue.mergeProps({
+	                            key: column.prop,
+	                            pageAllData: __props.data,
+	                            selectionRows: vue.unref(selectionRows),
+	                            getSelectionRows: vue.unref(getSelectionRows),
+	                            addSelectionRow: vue.unref(addSelectionRow),
+	                            removeSelectionRow: vue.unref(removeSelectionRow),
+	                            clearSelectionRows: vue.unref(clearSelectionRows)
+	                        }, column, {
+	                            onSelect: handleColumnSelect,
+	                            onSelectAll: handleColumnSelectAll
+	                        }), null, 16 /* FULL_PROPS */, ["pageAllData", "selectionRows", "getSelectionRows", "addSelectionRow", "removeSelectionRow", "clearSelectionRows"]));
+	                    }), 128 /* KEYED_FRAGMENT */))
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["data", "height", "maxHeight", "stripe", "border", "size", "fit", "rowClassName", "rowStyle", "cellClassName", "cellStyle", "headerRowClassName", "headerRowStyle", "rowKey", "defaultExpandAll", "expandRowKeys", "defaultSort", "emptyText"]));
+	        };
+	    } }));
+
+	script$3.__scopeId = "data-v-968a9a5a";
+	script$3.__file = "packages/base/table/table.vue";
+
+	var _hoisted_1$2 = ["onClick"];
+	var _hoisted_2$2 = {
+	    key: 2,
+	    class: "base-table-column"
+	};
+	var __default__$2 = {
+	    name: 'base-table-column'
+	};
+	var script$2 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$2), { props: {
+	        pageAllData: { type: Array, required: false },
+	        prop: { type: String, required: false },
+	        type: { type: String, required: false },
+	        index: { type: [Number, Function], required: false },
+	        label: { type: String, required: false },
+	        columnKey: { type: String, required: false },
+	        width: { type: [String, Number], required: false },
+	        minWidth: { type: [String, Number], required: false },
+	        fixed: { type: [Boolean, String], required: false },
+	        sortable: { type: [Boolean, String], required: false },
+	        sortMethod: { type: Function, required: false },
+	        sortBy: { type: [Array, String, Function], required: false },
+	        sortOrders: { type: Array, required: false },
+	        showOverflowTooltip: { type: Boolean, required: false, default: true },
+	        align: { type: String, required: false, default: 'center' },
+	        headerAlign: { type: String, required: false },
+	        className: { type: String, required: false },
+	        labelClassName: { type: String, required: false },
+	        textLineClamp: { type: Number, required: false, default: 1 },
+	        renderHeader: { type: Function, required: false },
+	        formatter: { type: Function, required: false },
+	        render: { type: Function, required: false },
+	        selectionDisabled: { type: [Function, Boolean], required: false },
+	        selectionRows: { type: null, required: false },
+	        hasSelectionRow: { type: Function, required: false },
+	        addSelectionRow: { type: Function, required: false },
+	        removeSelectionRow: { type: Function, required: false },
+	        getSelectionRows: { type: Function, required: false },
+	        clearSelectionRows: { type: Function, required: false },
+	        selectionAllBefore: { type: Function, required: false },
+	        selectionAddBefore: { type: Function, required: false },
+	        selectionAddAfter: { type: Function, required: false },
+	        selectionRemoveBefore: { type: Function, required: false },
+	        selectionRemoveAfter: { type: Function, required: false }
+	    }, emits: ["select", "select-all"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var vLoading = ElementPlus.vLoading;
+	        var props = _props;
+	        var _selectionAllLoading = vue.ref(false);
+	        var BaseTableColumnHeaderRender = vue.defineComponent({
+	            name: 'table-column-header-render',
+	            props: ['column', 'index'],
+	            render: function (params) {
+	                return props.renderHeader
+	                    ? props.renderHeader(props.type == '_selection'
+	                        ? {
+	                            column: params.column,
+	                            index: params.index,
+	                            selectionInfo: {
+	                                toggleCheckAll: handleCheckboxAllClick,
+	                                checkboxAllChecked: checkboxAllChecked,
+	                                checkboxAllIndeterminate: checkboxAllIndeterminate,
+	                                selectionAllLoading: _selectionAllLoading
+	                            }
+	                        }
+	                        : { column: params.column, index: params.index })
+	                    : '';
+	            }
+	        });
+	        var BaseTableColumnContentRender = vue.defineComponent({
+	            name: 'table-column-content-render',
+	            props: ['column', 'cellValue', 'row', 'index'],
+	            render: function (params) {
+	                return props.render
+	                    ? props.render({
+	                        column: params.column,
+	                        index: params.index,
+	                        cellValue: params.cellValue,
+	                        row: params.row
+	                    })
+	                    : '';
+	            }
+	        });
+	        var _selectionDisabled = function (row) {
+	            var _a;
+	            if (isFunction(props.selectionDisabled)) {
+	                var status_1 = (_a = props === null || props === void 0 ? void 0 : props.selectionDisabled) === null || _a === void 0 ? void 0 : _a.call(props, row);
+	                // if (status && props.prop && selectionRows?.has(row[props.prop])) {
+	                //   console.log(row[props.prop], row, '已被禁用，无法设置选中');
+	                //   removeSelectionRow?.(row[props.prop]);
+	                // }
+	                return status_1;
+	            }
+	            else {
+	                return props.selectionDisabled;
+	            }
+	        };
+	        var getColumnValue = function (row, index, column) {
+	            if (props.type == 'index')
+	                return "".concat(index + 1);
+	            if (props.formatter) {
+	                return props.formatter({
+	                    row: row,
+	                    column: column,
+	                    cellValue: props.prop && row[props.prop],
+	                    index: index
+	                });
+	            }
+	            return props.prop && row[props.prop];
+	        };
+	        var selectionRows = props.selectionRows, addSelectionRow = props.addSelectionRow, removeSelectionRow = props.removeSelectionRow, getSelectionRows = props.getSelectionRows;
+	        var checked = vue.computed(function () {
+	            return function (row) {
+	                return props.prop && (selectionRows === null || selectionRows === void 0 ? void 0 : selectionRows.has(row[props.prop]));
+	            };
+	        });
+	        var filterPageAllData = vue.computed(function () {
+	            return Array.isArray(props.pageAllData)
+	                ? props.pageAllData.filter(function (row) { return !_selectionDisabled(row); })
+	                : [];
+	        });
+	        var checkboxAllChecked = vue.computed(function () {
+	            return (filterPageAllData.value.length > 0 &&
+	                filterPageAllData.value.every(function (row) {
+	                    return props.prop && row[props.prop] && (selectionRows === null || selectionRows === void 0 ? void 0 : selectionRows.has(row[props.prop]));
+	                }));
+	        });
+	        var checkboxAllIndeterminate = vue.computed(function () {
+	            return (filterPageAllData.value.length > 0 &&
+	                !checkboxAllChecked.value &&
+	                filterPageAllData.value.some(function (row) {
+	                    return props.prop && row[props.prop] && (selectionRows === null || selectionRows === void 0 ? void 0 : selectionRows.has(row[props.prop]));
+	                }));
+	        });
+	        var handleCheckboxAllClick = function () { return __awaiter(_this, void 0, void 0, function () {
+	            var fn;
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!Array.isArray(props.pageAllData)) return [3 /*break*/, 7];
+	                        if (_selectionAllLoading.value)
+	                            return [2 /*return*/];
+	                        fn = function () {
+	                            if (checkboxAllChecked.value) {
+	                                // 已经选择全部
+	                                filterPageAllData.value.forEach(function (row) {
+	                                    props.prop && (removeSelectionRow === null || removeSelectionRow === void 0 ? void 0 : removeSelectionRow(row[props.prop]));
+	                                });
+	                            }
+	                            else {
+	                                filterPageAllData.value.forEach(function (row) {
+	                                    props.prop && (addSelectionRow === null || addSelectionRow === void 0 ? void 0 : addSelectionRow(row[props.prop], row));
+	                                });
+	                            }
+	                        };
+	                        _a.label = 1;
+	                    case 1:
+	                        _a.trys.push([1, 5, , 6]);
+	                        _selectionAllLoading.value = true;
+	                        if (!isFunction(props.selectionAllBefore)) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.selectionAllBefore(fn)];
+	                    case 2:
+	                        _a.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        fn();
+	                        _a.label = 4;
+	                    case 4: return [3 /*break*/, 6];
+	                    case 5:
+	                        _a.sent();
+	                        return [3 /*break*/, 6];
+	                    case 6:
+	                        _selectionAllLoading.value = false;
+	                        _a.label = 7;
+	                    case 7:
+	                        emits('select-all', getSelectionRows === null || getSelectionRows === void 0 ? void 0 : getSelectionRows());
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleCheckboxClick = function (row) { return __awaiter(_this, void 0, void 0, function () {
+	            var _a, _b;
+	            return __generator(this, function (_c) {
+	                switch (_c.label) {
+	                    case 0:
+	                        if (_selectionDisabled(row) || row._selectionLoading)
+	                            return [2 /*return*/];
+	                        if (!props.prop) return [3 /*break*/, 15];
+	                        row._selectionLoading = true;
+	                        _c.label = 1;
+	                    case 1:
+	                        _c.trys.push([1, 14, , 15]);
+	                        if (!(selectionRows === null || selectionRows === void 0 ? void 0 : selectionRows.has(row[props.prop]))) return [3 /*break*/, 7];
+	                        if (!isFunction(props.selectionRemoveBefore)) return [3 /*break*/, 3];
+	                        return [4 /*yield*/, props.selectionRemoveBefore(row, removeSelectionRow
+	                                ? removeSelectionRow.bind(null, row[props.prop])
+	                                : function () { })];
+	                    case 2:
+	                        _c.sent();
+	                        return [3 /*break*/, 4];
+	                    case 3:
+	                        removeSelectionRow === null || removeSelectionRow === void 0 ? void 0 : removeSelectionRow(row[props.prop]);
+	                        _c.label = 4;
+	                    case 4:
+	                        row._selectionLoading = false;
+	                        _a = isFunction(props.selectionRemoveAfter);
+	                        if (!_a) return [3 /*break*/, 6];
+	                        return [4 /*yield*/, props.selectionRemoveAfter(row)];
+	                    case 5:
+	                        _a = (_c.sent());
+	                        _c.label = 6;
+	                    case 6:
+	                        return [3 /*break*/, 13];
+	                    case 7:
+	                        if (!isFunction(props.selectionAddBefore)) return [3 /*break*/, 9];
+	                        return [4 /*yield*/, props.selectionAddBefore(row, addSelectionRow
+	                                ? addSelectionRow.bind(null, row[props.prop], row)
+	                                : function () { })];
+	                    case 8:
+	                        _c.sent();
+	                        return [3 /*break*/, 10];
+	                    case 9:
+	                        addSelectionRow === null || addSelectionRow === void 0 ? void 0 : addSelectionRow(row[props.prop], row);
+	                        _c.label = 10;
+	                    case 10:
+	                        row._selectionLoading = false;
+	                        _b = isFunction(props.selectionAddAfter);
+	                        if (!_b) return [3 /*break*/, 12];
+	                        return [4 /*yield*/, props.selectionAddAfter(row)];
+	                    case 11:
+	                        _b = (_c.sent());
+	                        _c.label = 12;
+	                    case 12:
+	                        _c.label = 13;
+	                    case 13:
+	                        emits('select', getSelectionRows === null || getSelectionRows === void 0 ? void 0 : getSelectionRows(), row);
+	                        return [3 /*break*/, 15];
+	                    case 14:
+	                        _c.sent();
+	                        row._selectionLoading = false;
+	                        return [3 /*break*/, 15];
+	                    case 15: return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTableColumn), {
+	                prop: __props.prop,
+	                type: __props.type,
+	                index: __props.index,
+	                label: __props.label,
+	                columnKey: __props.columnKey,
+	                width: __props.width,
+	                minWidth: __props.minWidth,
+	                fixed: __props.fixed,
+	                sortable: __props.sortable,
+	                sortMethod: __props.sortMethod,
+	                sortBy: __props.sortBy,
+	                sortOrders: __props.sortOrders,
+	                align: __props.align,
+	                headerAlign: __props.headerAlign,
+	                className: __props.className,
+	                labelClassName: __props.labelClassName,
+	                textLineClamp: __props.textLineClamp
+	            }, vue.createSlots({
+	                default: vue.withCtx(function (_a) {
+	                    var row = _a.row, column = _a.column, $index = _a.$index;
+	                    return [
+	                        (__props.render)
+	                            ? (vue.openBlock(), vue.createBlock(vue.unref(BaseTableColumnContentRender), {
+	                                key: 0,
+	                                row: row,
+	                                column: column,
+	                                cellValue: __props.prop ? row[__props.prop] : '',
+	                                index: $index
+	                            }, null, 8 /* PROPS */, ["row", "column", "cellValue", "index"]))
+	                            : (__props.type == '_selection')
+	                                ? (vue.openBlock(), vue.createElementBlock("div", {
+	                                    key: 1,
+	                                    style: { "display": "inline-block" },
+	                                    onClick: vue.withModifiers(function ($event) { return (handleCheckboxClick(row)); }, ["prevent"])
+	                                }, [
+	                                    vue.withDirectives(vue.createVNode(vue.unref(BaseCheckbox), {
+	                                        class: "table-base-checkbox",
+	                                        "model-value": vue.unref(checked)(row),
+	                                        disabled: _selectionDisabled(row)
+	                                    }, null, 8 /* PROPS */, ["model-value", "disabled"]), [
+	                                        [vue.unref(vLoading), row._selectionLoading]
+	                                    ])
+	                                ], 8 /* PROPS */, _hoisted_1$2))
+	                                : (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$2, [
+	                                    vue.createVNode(vue.unref(BaseToolTip), {
+	                                        content: getColumnValue(row, $index, column),
+	                                        hideAfter: 0,
+	                                        enterable: false,
+	                                        transition: "none",
+	                                        overShow: __props.showOverflowTooltip,
+	                                        style: vue.normalizeStyle({ '-webkit-line-clamp': __props.textLineClamp || 1 })
+	                                    }, {
+	                                        default: vue.withCtx(function () { return [
+	                                            vue.createTextVNode(vue.toDisplayString(getColumnValue(row, $index, column)), 1 /* TEXT */)
+	                                        ]; }),
+	                                        _: 2 /* DYNAMIC */
+	                                    }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["content", "overShow", "style"])
+	                                ]))
+	                    ];
+	                }),
+	                _: 2 /* DYNAMIC */
+	            }, [
+	                (__props.renderHeader)
+	                    ? {
+	                        name: "header",
+	                        fn: vue.withCtx(function (_a) {
+	                            var column = _a.column, $index = _a.$index;
+	                            return [
+	                                vue.createVNode(vue.unref(BaseTableColumnHeaderRender), {
+	                                    index: $index,
+	                                    column: column
+	                                }, null, 8 /* PROPS */, ["index", "column"])
+	                            ];
+	                        })
+	                    }
+	                    : (__props.type == '_selection')
+	                        ? {
+	                            name: "header",
+	                            fn: vue.withCtx(function () { return [
+	                                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(BaseCheckbox), {
+	                                    class: "table-base-checkbox",
+	                                    onClick: vue.withModifiers(handleCheckboxAllClick, ["prevent"]),
+	                                    "model-value": vue.unref(checkboxAllChecked),
+	                                    indeterminate: vue.unref(checkboxAllIndeterminate)
+	                                }, {
+	                                    default: vue.withCtx(function () { return [
+	                                        vue.createTextVNode(vue.toDisplayString(vue.unref(selectionRows).size > 0 ? "\u5DF2\u9009".concat(vue.unref(selectionRows).size, "\u9879") : ''), 1 /* TEXT */)
+	                                    ]; }),
+	                                    _: 1 /* STABLE */
+	                                }, 8 /* PROPS */, ["onClick", "model-value", "indeterminate"])), [
+	                                    [vue.unref(vLoading), _selectionAllLoading.value]
+	                                ])
+	                            ]; })
+	                        }
+	                        : undefined
+	            ]), 1032 /* PROPS, DYNAMIC_SLOTS */, ["prop", "type", "index", "label", "columnKey", "width", "minWidth", "fixed", "sortable", "sortMethod", "sortBy", "sortOrders", "align", "headerAlign", "className", "labelClassName", "textLineClamp"]));
+	        };
+	    } }));
+
+	script$2.__scopeId = "data-v-2a64ae40";
+	script$2.__file = "packages/base/table/table-column.vue";
+
+	var useTableColumn$1 = function (props) {
+	    return __assign({ minWidth: '120px', width: props.type === 'index' ? '90px' : '' }, props);
+	};
+
+	var BaseTable = script$3;
+	var BaseTableColumn = script$2;
+	var useTableColumn = useTableColumn$1;
+
+	var useTable = function (config) {
+	    var pageIsLoading = vue.ref(false);
+	    var pageAllData = vue.ref([]);
+	    var paginationTotal = vue.ref(0);
+	    var getList = function (query) { return __awaiter(void 0, void 0, void 0, function () {
+	        var res, error_1;
+	        return __generator(this, function (_a) {
+	            switch (_a.label) {
+	                case 0:
+	                    if (pageIsLoading.value)
+	                        return [2 /*return*/];
+	                    pageIsLoading.value = true;
+	                    _a.label = 1;
+	                case 1:
+	                    _a.trys.push([1, 4, , 5]);
+	                    if (!isFunction(config.getListAjax)) return [3 /*break*/, 3];
+	                    return [4 /*yield*/, config.getListAjax(query)];
+	                case 2:
+	                    res = _a.sent();
+	                    pageAllData.value = res.data.list;
+	                    paginationTotal.value = res.data.total;
+	                    _a.label = 3;
+	                case 3: return [3 /*break*/, 5];
+	                case 4:
+	                    error_1 = _a.sent();
+	                    console.warn(error_1);
+	                    return [3 /*break*/, 5];
+	                case 5:
+	                    pageIsLoading.value = false;
+	                    return [2 /*return*/];
+	            }
+	        });
+	    }); };
+	    return {
+	        pageIsLoading: pageIsLoading,
+	        pageAllData: pageAllData,
+	        paginationTotal: paginationTotal,
+	        getList: getList
+	    };
+	};
+
+	var _hoisted_1$1 = { class: "slot-before slot" };
+	var _hoisted_2$1 = { class: "slot-after slot" };
+	var __default__$1 = {
+	    name: 'xrk-table'
+	};
+	var script$1 = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__$1), { props: {
+	        requestNow: { type: Boolean, required: false, default: true },
+	        getListAjax: { type: Function, required: true },
+	        searchConfig: { type: Object, required: true },
+	        tableConfig: { type: Object, required: true },
+	        paginationConfig: { type: Object, required: false }
+	    }, setup: function (__props, _a) {
+	        var _b;
+	        var _c, _d;
+	        var expose = _a.expose;
+	        var _props = __props;
+	        var props = _props;
+	        var vLoading = ElementPlus.vLoading;
+	        var paginationConfig = vue.computed(function () { return (__assign({ pageNoKey: 'pageNo', pageSizeKey: 'pageSize', paginationPageSize: 60, paginationCurrentPage: 1 }, (props.paginationConfig || {}))); });
+	        var TableSelectionRows = vue.ref([]);
+	        var XrkSearchRef = vue.ref(null);
+	        var XrkTablebaseTableRef = vue.ref(null);
+	        var BasePaginationRef = vue.ref(null);
+	        var pageNoKey = paginationConfig.value.pageNoKey;
+	        var pageSizeKey = paginationConfig.value.pageSizeKey;
+	        var paginationQuery = vue.ref((_b = {},
+	            _b[pageNoKey] = (_c = paginationConfig.value) === null || _c === void 0 ? void 0 : _c.paginationCurrentPage,
+	            _b[pageSizeKey] = (_d = paginationConfig.value) === null || _d === void 0 ? void 0 : _d.paginationPageSize,
+	            _b));
+	        var searchQuery = vue.ref({});
+	        var query = vue.computed(function () { return (__assign(__assign({}, paginationQuery.value), searchQuery.value)); });
+	        var initSearchQuery = function () {
+	            var _a, _b;
+	            var searchQueryDefault = ((_b = (_a = XrkSearchRef.value) === null || _a === void 0 ? void 0 : _a.getSearchValue) === null || _b === void 0 ? void 0 : _b.call(_a)) || {};
+	            searchQuery.value = searchQueryDefault;
+	        };
+	        var initPageInfo = function (pageNo) {
+	            var _a;
+	            if (pageNo === void 0) { pageNo = 1; }
+	            (_a = BasePaginationRef.value) === null || _a === void 0 ? void 0 : _a.setPageInfo({
+	                pageSize: paginationQuery.value[pageSizeKey],
+	                currentPage: pageNo
+	            });
+	            paginationQuery.value[pageNoKey] = pageNo;
+	        };
+	        var clearSelectionRows = function () {
+	            var _a, _b;
+	            (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.clearSelectionRows) === null || _b === void 0 ? void 0 : _b.call(_a);
+	            TableSelectionRows.value = [];
+	        };
+	        var handleSearch = function (searchValue) {
+	            searchQuery.value = xrkTools.base.deepClone(searchValue);
+	            initPageInfo(1);
+	            clearSelectionRows();
+	            getList === null || getList === void 0 ? void 0 : getList(query.value);
+	        };
+	        var handlePageChange = function () {
+	            var _a;
+	            var _b, _c;
+	            var pageInfo = (_c = (_b = BasePaginationRef.value) === null || _b === void 0 ? void 0 : _b.getPageInfo) === null || _c === void 0 ? void 0 : _c.call(_b);
+	            paginationQuery.value = (_a = {},
+	                _a[pageNoKey] = pageInfo.currentPage,
+	                _a[pageSizeKey] = pageInfo.pageSize,
+	                _a);
+	            getList === null || getList === void 0 ? void 0 : getList(query.value);
+	        };
+	        var handleTableSelect = function () {
+	            var _a, _b;
+	            var res = (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.getSelectionRows) === null || _b === void 0 ? void 0 : _b.call(_a);
+	            TableSelectionRows.value = Array.isArray(res) ? res : [];
+	        };
+	        var _e = useTable({
+	            getListAjax: props.getListAjax
+	        }), pageAllData = _e.pageAllData, getList = _e.getList, paginationTotal = _e.paginationTotal, pageIsLoading = _e.pageIsLoading;
+	        vue.onMounted(function () {
+	            initSearchQuery();
+	            clearSelectionRows();
+	            props.requestNow && (getList === null || getList === void 0 ? void 0 : getList(query.value));
+	        });
+	        expose({
+	            getSelectionRows: function () { var _a, _b; return (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.getSelectionRows) === null || _b === void 0 ? void 0 : _b.call(_a); },
+	            addSelectionRow: function (rowId, row) { var _a, _b; return (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.addSelectionRow) === null || _b === void 0 ? void 0 : _b.call(_a, rowId, row); },
+	            removeSelectionRow: function (rowId) { var _a, _b; return (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.removeSelectionRow) === null || _b === void 0 ? void 0 : _b.call(_a, rowId); },
+	            clearSelectionRows: function () { var _a, _b; return (_b = (_a = XrkTablebaseTableRef.value) === null || _a === void 0 ? void 0 : _a.clearSelectionRows) === null || _b === void 0 ? void 0 : _b.call(_a); },
+	            setSearchValue: function (key, value) { var _a, _b; return (_b = (_a = XrkSearchRef.value) === null || _a === void 0 ? void 0 : _a.setSearchValue) === null || _b === void 0 ? void 0 : _b.call(_a, key, value); },
+	            initCurrentList: function (customQuery) {
+	                initSearchQuery();
+	                getList === null || getList === void 0 ? void 0 : getList(__assign(__assign({}, (customQuery || {})), query.value));
+	            },
+	            initList: function (customQuery) {
+	                initSearchQuery();
+	                initPageInfo(1);
+	                getList === null || getList === void 0 ? void 0 : getList(__assign(__assign({}, (customQuery || {})), query.value));
+	            }
+	        });
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+	                vue.createVNode(script$4, {
+	                    ref_key: "XrkSearchRef",
+	                    ref: XrkSearchRef,
+	                    columns: __props.searchConfig.searchColumns,
+	                    "search-btn": __props.searchConfig.searchBtn,
+	                    "reset-btn": __props.searchConfig.resetBtn,
+	                    "other-components": __props.searchConfig.othertComponents,
+	                    onSearch: handleSearch
+	                }, null, 8 /* PROPS */, ["columns", "search-btn", "reset-btn", "other-components"]),
+	                vue.createElementVNode("div", _hoisted_1$1, [
+	                    vue.renderSlot(_ctx.$slots, "tableBefore", {
+	                        selectionRows: TableSelectionRows.value,
+	                        tableData: vue.unref(pageAllData),
+	                        searchQuery: vue.unref(query)
+	                    })
+	                ]),
+	                vue.withDirectives(vue.createVNode(vue.unref(BaseTable), {
+	                    class: "xrk-table-content",
+	                    ref_key: "XrkTablebaseTableRef",
+	                    ref: XrkTablebaseTableRef,
+	                    data: vue.unref(pageAllData),
+	                    columns: __props.tableConfig.tableColumns,
+	                    onSelectAll: handleTableSelect,
+	                    onSelect: handleTableSelect
+	                }, null, 8 /* PROPS */, ["data", "columns"]), [
+	                    [vue.unref(vLoading), vue.unref(pageIsLoading)]
+	                ]),
+	                vue.createElementVNode("div", _hoisted_2$1, [
+	                    vue.renderSlot(_ctx.$slots, "tableAfter", {
+	                        selectionRows: TableSelectionRows.value,
+	                        tableData: vue.unref(pageAllData),
+	                        searchQuery: vue.unref(query)
+	                    })
+	                ]),
+	                vue.createVNode(vue.unref(BasePagination), {
+	                    ref_key: "BasePaginationRef",
+	                    ref: BasePaginationRef,
+	                    total: vue.unref(paginationTotal),
+	                    pageSize: vue.unref(paginationConfig).paginationPageSize,
+	                    currentPage: vue.unref(paginationConfig).paginationCurrentPage,
+	                    onSizeChange: handlePageChange,
+	                    onCurrentChange: handlePageChange
+	                }, null, 8 /* PROPS */, ["total", "pageSize", "currentPage"])
+	            ], 64 /* STABLE_FRAGMENT */));
+	        };
+	    } }));
+
+	script$1.__file = "packages/xrk/table/table.vue";
+
+	var XrkTable = script$1;
+
+	var _hoisted_1 = { key: 1 };
+	var _hoisted_2 = { key: 1 };
+	var __default__ = {
+	    name: 'base-dialog'
+	};
+	var script = /*#__PURE__*/ vue.defineComponent(__assign(__assign({}, __default__), { props: {
+	        modelValue: { type: Boolean, required: false, default: true },
+	        closeOnClickModal: { type: Boolean, required: false, default: false },
+	        closeOnPressEscape: { type: Boolean, required: false, default: false },
+	        appendToBody: { type: Boolean, required: false, default: true },
+	        destroyOnClose: { type: Boolean, required: false, default: true },
+	        center: { type: Boolean, required: false, default: true },
+	        showClose: { type: Boolean, required: false, default: false },
+	        beforeClose: { type: Function, required: false },
+	        beforeCancel: { type: Function, required: false },
+	        beforeConfirm: { type: Function, required: false },
+	        customClass: { type: String, required: false, default: '_base-dialog' },
+	        width: { type: [String, Number], required: false, default: '50%' },
+	        title: { type: String, required: false, default: '提示' },
+	        content: { type: String, required: false },
+	        showFooter: { type: Boolean, required: false, default: true },
+	        titleRender: { type: Function, required: false },
+	        contentRender: { type: Function, required: false },
+	        footerRender: { type: Function, required: false },
+	        confirmBtnConfig: { type: null, required: false, default: function () { return ({ show: true, content: '确定' }); } },
+	        cancelBtnConfig: { type: null, required: false, default: function () { return ({ show: true, content: '取消', plain: true }); } }
+	    }, emits: ["update:modelValue", "close"], setup: function (__props, _a) {
+	        var _this = this;
+	        var emits = _a.emit;
+	        var _props = __props;
+	        var props = _props;
+	        var show = vue.ref(props.modelValue || false);
+	        vue.watch(function () { return props.modelValue; }, function (newV) {
+	            show.value = newV || false;
+	        });
+	        var BaseDialogRender = vue.defineComponent({
+	            name: 'dialog-render',
+	            props: {
+	                render: Function
+	            },
+	            render: function (ctx) {
+	                return ctx.render
+	                    ? ctx.render(function () {
+	                        return hanldeBeforeClose(function () {
+	                            show.value = false;
+	                        });
+	                    })
+	                    : '';
+	            }
+	        });
+	        var hanldeBeforeClose = function (done) { return __awaiter(_this, void 0, void 0, function () {
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!isFunction(props.beforeClose)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, props.beforeClose(done)];
+	                    case 1:
+	                        _a.sent();
+	                        return [3 /*break*/, 3];
+	                    case 2:
+	                        done();
+	                        _a.label = 3;
+	                    case 3:
+	                        emits('close');
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleClosed = function () {
+	            emits('update:modelValue', !props.modelValue);
+	        };
+	        var handleCancelClick = function () { return __awaiter(_this, void 0, void 0, function () {
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!isFunction(props.beforeCancel)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, props.beforeCancel(function () {
+	                                show.value = false;
+	                            })];
+	                    case 1:
+	                        _a.sent();
+	                        return [3 /*break*/, 3];
+	                    case 2:
+	                        show.value = false;
+	                        _a.label = 3;
+	                    case 3:
+	                        emits('close');
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        var handleConfirmClick = function () { return __awaiter(_this, void 0, void 0, function () {
+	            return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!isFunction(props.beforeConfirm)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, props.beforeConfirm(function () {
+	                                show.value = false;
+	                            })];
+	                    case 1:
+	                        _a.sent();
+	                        return [3 /*break*/, 3];
+	                    case 2:
+	                        show.value = false;
+	                        _a.label = 3;
+	                    case 3:
+	                        emits('close');
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); };
+	        return function (_ctx, _cache) {
+	            return (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElDialog), {
+	                "custom-class": "".concat(__props.customClass, " ").concat(__props.showFooter ? '' : 'hide-footer'),
+	                modelValue: show.value,
+	                closeOnClickModal: __props.closeOnClickModal,
+	                closeOnPressEscape: __props.closeOnPressEscape,
+	                appendToBody: __props.appendToBody,
+	                destroyOnClose: __props.destroyOnClose,
+	                center: __props.center,
+	                width: __props.width,
+	                showClose: __props.showClose,
+	                "before-close": hanldeBeforeClose,
+	                onClosed: handleClosed
+	            }, {
+	                header: vue.withCtx(function () { return [
+	                    (__props.titleRender)
+	                        ? (vue.openBlock(), vue.createBlock(vue.unref(BaseDialogRender), {
+	                            key: 0,
+	                            render: __props.titleRender
+	                        }, null, 8 /* PROPS */, ["render"]))
+	                        : (__props.title)
+	                            ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1, vue.toDisplayString(__props.title), 1 /* TEXT */))
+	                            : vue.renderSlot(_ctx.$slots, "header", { key: 2 })
+	                ]; }),
+	                footer: vue.withCtx(function () { return [
+	                    (__props.footerRender)
+	                        ? (vue.openBlock(), vue.createBlock(vue.unref(BaseDialogRender), {
+	                            key: 0,
+	                            render: __props.footerRender
+	                        }, null, 8 /* PROPS */, ["render"]))
+	                        : (__props.showFooter)
+	                            ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+	                                (__props.cancelBtnConfig.show)
+	                                    ? (vue.openBlock(), vue.createBlock(vue.unref(BaseButton), vue.mergeProps({ key: 0 }, __props.cancelBtnConfig, { click: handleCancelClick }), {
+	                                        default: vue.withCtx(function () { return [
+	                                            vue.createTextVNode(vue.toDisplayString(__props.cancelBtnConfig.content), 1 /* TEXT */)
+	                                        ]; }),
+	                                        _: 1 /* STABLE */
+	                                    }, 16 /* FULL_PROPS */))
+	                                    : vue.createCommentVNode("v-if", true),
+	                                (__props.confirmBtnConfig.show)
+	                                    ? (vue.openBlock(), vue.createBlock(vue.unref(BaseButton), vue.mergeProps({ key: 1 }, __props.confirmBtnConfig, { click: handleConfirmClick }), {
+	                                        default: vue.withCtx(function () { return [
+	                                            vue.createTextVNode(vue.toDisplayString(__props.confirmBtnConfig.content), 1 /* TEXT */)
+	                                        ]; }),
+	                                        _: 1 /* STABLE */
+	                                    }, 16 /* FULL_PROPS */))
+	                                    : vue.createCommentVNode("v-if", true)
+	                            ]))
+	                            : vue.createCommentVNode("v-if", true)
+	                ]; }),
+	                default: vue.withCtx(function () { return [
+	                    (__props.contentRender)
+	                        ? (vue.openBlock(), vue.createBlock(vue.unref(BaseDialogRender), {
+	                            key: 0,
+	                            render: __props.contentRender
+	                        }, null, 8 /* PROPS */, ["render"]))
+	                        : vue.renderSlot(_ctx.$slots, "default", { key: 1 })
+	                ]; }),
+	                _: 3 /* FORWARDED */
+	            }, 8 /* PROPS */, ["custom-class", "modelValue", "closeOnClickModal", "closeOnPressEscape", "appendToBody", "destroyOnClose", "center", "width", "showClose"]));
+	        };
+	    } }));
+
+	script.__file = "packages/base/dialog/dialog.vue";
+
+	var BaseDialog = script;
+	var createDialog = function (config) {
+	    var _a;
+	    var container = document.createElement('div');
+	    var customDialogCount = document.querySelectorAll('._xrk_create_dialog').length;
+	    container.classList.add('_xrk_create_dialog');
+	    container.style.position = 'relative';
+	    container.style.zIndex = "".concat(200 + customDialogCount);
+	    vue.render(vue.h(script, __assign(__assign({ modelValue: true }, (config || {})), { appendToBody: false, onClose: function () { return __awaiter(void 0, void 0, void 0, function () {
+	            var _a, _b;
+	            return __generator(this, function (_c) {
+	                switch (_c.label) {
+	                    case 0: return [4 /*yield*/, ((_a = config === null || config === void 0 ? void 0 : config.onClose) === null || _a === void 0 ? void 0 : _a.call(config))];
+	                    case 1:
+	                        _c.sent();
+	                        (_b = document.querySelector('body')) === null || _b === void 0 ? void 0 : _b.removeChild(container);
+	                        return [2 /*return*/];
+	                }
+	            });
+	        }); } })), container);
+	    (_a = document.querySelector('body')) === null || _a === void 0 ? void 0 : _a.appendChild(container);
+	};
+
+	/*
+	 * @Description:
+	 * @Date: 2022-07-05 16:34:24
+	 */
+
+	var AllComponents = /*#__PURE__*/Object.freeze({
+		__proto__: null,
+		BaseButton: BaseButton,
+		BaseRadio: BaseRadio,
+		BaseRadioGroup: BaseRadioGroup,
+		BaseRadioButton: BaseRadioButton,
+		BaseCheckbox: BaseCheckbox,
+		BaseCheckboxGroup: BaseCheckboxGroup,
+		BaseCheckboxButton: BaseCheckboxButton,
+		BaseDatePicker: BaseDatePicker,
+		BaseInput: BaseInput,
+		BaseSelect: BaseSelect,
+		BaseSwitch: BaseSwitch,
+		BaseTag: BaseTag,
+		BaseTagGroup: BaseTagGroup,
+		BasePagination: BasePagination,
+		BaseForm: BaseForm,
+		BaseFormItem: BaseFormItem,
+		XrkSearch: XrkSearch,
+		BaseTable: BaseTable,
+		XrkTable: XrkTable,
+		BaseDialog: BaseDialog
+	});
+
+	/*
+	 * @Description:
+	 * @Date: 2022-06-29 15:58:37
+	 */
+	var useInputColumn = function (column) {
+	    return __assign(__assign({ type: 'input' }, column), { style: __assign({ width: '220px' }, (column.style || {})) });
+	};
+	var useSelectColumn = function (column) {
+	    return __assign(__assign({ type: 'select' }, column), { style: __assign({ width: '220px' }, (column.style || {})) });
+	};
+	var useDatePickerColumn = function (column) {
+	    var _a;
+	    return __assign(__assign({ type: 'datePicker' }, column), { style: __assign({ width: ['datetimerange', 'daterange', 'monthrange'].includes(((_a = column.config) === null || _a === void 0 ? void 0 : _a.type) || '')
+	                ? '280px'
+	                : '220px' }, (column.style || {})) });
+	};
+	var useSearchColumns = function (columns) {
+	    return columns.map(function (column) { return (__assign(__assign({}, column), { listener: column.listener || {}, config: __assign({ clearable: true }, (column.config || {})) })); });
+	};
+	var useSearchBtn = function (searchBtnConfig) {
+	    return __assign({ text: '搜索', show: true }, searchBtnConfig);
+	};
+	var useResetBtn = function (resetBtnConfig) {
+	    return __assign({ text: '重置', show: true }, resetBtnConfig);
+	};
+	var useOtherComponents = function (otherComponents) {
+	    return otherComponents;
+	};
+
+	/*
+	 * @Description:
+	 * @Date: 2022-06-30 22:57:28
+	 */
+	// 所有组件列表
+	var components = Object.values(AllComponents).map(function (i) { return i; });
+	var install = function (app) {
+	    app.use(ElementPlus__default["default"], { namespace: 'xrk', locale: locale });
+	    components.map(function (component) {
+	        app.component(component.name, component);
+	    });
+	};
+	var index = {
+	    version: '0.3.2',
+	    install: install
+	};
+
+	exports.BaseButton = BaseButton;
+	exports.BaseCheckbox = BaseCheckbox;
+	exports.BaseCheckboxButton = BaseCheckboxButton;
+	exports.BaseCheckboxGroup = BaseCheckboxGroup;
+	exports.BaseDatePicker = BaseDatePicker;
+	exports.BaseDialog = BaseDialog;
+	exports.BaseForm = BaseForm;
+	exports.BaseFormItem = BaseFormItem;
+	exports.BaseInput = BaseInput;
+	exports.BasePagination = BasePagination;
+	exports.BaseRadio = BaseRadio;
+	exports.BaseRadioButton = BaseRadioButton;
+	exports.BaseRadioGroup = BaseRadioGroup;
+	exports.BaseSelect = BaseSelect;
+	exports.BaseSwitch = BaseSwitch;
+	exports.BaseTable = BaseTable;
+	exports.BaseTag = BaseTag;
+	exports.BaseTagGroup = BaseTagGroup;
+	exports.XrkSearch = XrkSearch;
+	exports.XrkTable = XrkTable;
+	exports.createDialog = createDialog;
+	exports["default"] = index;
+	exports.useDatePickerColumn = useDatePickerColumn;
+	exports.useInputColumn = useInputColumn;
+	exports.useOtherComponents = useOtherComponents;
+	exports.useResetBtn = useResetBtn;
+	exports.useSearchBtn = useSearchBtn;
+	exports.useSearchColumns = useSearchColumns;
+	exports.useSelectColumn = useSelectColumn;
+	exports.useTableColumn = useTableColumn;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));