backend-management-ui 1.3.2 → 1.3.3

package/backend-management-ui.umd.js

@@ -1,13 +1,13 @@
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
+		module.exports = factory(require("vue"));
 	else if(typeof define === 'function' && define.amd)
 		define([], factory);
 	else if(typeof exports === 'object')
-		exports["backend-management-ui"] = factory();
+		exports["backend-management-ui"] = factory(require("vue"));
 	else
-		root["backend-management-ui"] = factory();
-})((typeof self !== 'undefined' ? self : this), function() {
+		root["backend-management-ui"] = factory(root["Vue"]);
+})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__9274__) {
 return /******/ (function() { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -210,6 +210,26 @@ module.exports = function (it, Prototype) {
 };
 
 
+/***/ }),
+
+/***/ 684:
+/***/ (function(module) {
+
+"use strict";
+
+// Should throw an error on invalid iterator
+// https://issues.chromium.org/issues/336839115
+module.exports = function (methodName, argument) {
+  // eslint-disable-next-line es/no-iterator -- required for testing
+  var method = typeof Iterator == 'function' && Iterator.prototype[methodName];
+  if (method) try {
+    method.call({ next: null }, argument).next();
+  } catch (error) {
+    return true;
+  }
+};
+
+
 /***/ }),
 
 /***/ 741:
@@ -428,6 +448,30 @@ module.exports = function (argument) {
 };
 
 
+/***/ }),
+
+/***/ 1385:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var iteratorClose = __webpack_require__(9539);
+
+module.exports = function (iters, kind, value) {
+  for (var i = iters.length - 1; i >= 0; i--) {
+    if (iters[i] === undefined) continue;
+    try {
+      value = iteratorClose(iters[i].iterator, kind, value);
+    } catch (error) {
+      kind = 'throw';
+      value = error;
+    }
+  }
+  if (kind === 'throw') throw value;
+  return value;
+};
+
+
 /***/ }),
 
 /***/ 1548:
@@ -485,6 +529,58 @@ $({ target: 'Set', proto: true, real: true, forced: FORCED }, {
 });
 
 
+/***/ }),
+
+/***/ 1701:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var call = __webpack_require__(9565);
+var aCallable = __webpack_require__(9306);
+var anObject = __webpack_require__(8551);
+var getIteratorDirect = __webpack_require__(1767);
+var createIteratorProxy = __webpack_require__(9462);
+var callWithSafeIterationClosing = __webpack_require__(6319);
+var iteratorClose = __webpack_require__(9539);
+var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(684);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
+var IS_PURE = __webpack_require__(6395);
+
+var MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('map', function () { /* empty */ });
+var mapWithoutClosingOnEarlyError = !IS_PURE && !MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  && iteratorHelperWithoutClosingOnEarlyError('map', TypeError);
+
+var FORCED = IS_PURE || MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || mapWithoutClosingOnEarlyError;
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var result = anObject(call(this.next, iterator));
+  var done = this.done = !!result.done;
+  if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
+});
+
+// `Iterator.prototype.map` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.map
+$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
+  map: function map(mapper) {
+    anObject(this);
+    try {
+      aCallable(mapper);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (mapWithoutClosingOnEarlyError) return call(mapWithoutClosingOnEarlyError, this, mapper);
+
+    return new IteratorProxy(getIteratorDirect(this), {
+      mapper: mapper
+    });
+  }
+});
+
+
 /***/ }),
 
 /***/ 1767:
@@ -532,6 +628,1045 @@ module.exports = function (object, names) {
 };
 
 
+/***/ }),
+
+/***/ 2044:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+__webpack_require__(4114);
+__webpack_require__(8111);
+__webpack_require__(2489);
+__webpack_require__(7588);
+__webpack_require__(1701);
+__webpack_require__(8237);
+/*!
+ * vue-virtual-scroll-list v2.3.4
+ * open source under the MIT license
+ * https://github.com/tangbc/vue-virtual-scroll-list#readme
+ */
+
+(function (global, factory) {
+   true ? module.exports = factory(__webpack_require__(9274)) : 0;
+})(this, function (Vue) {
+  'use strict';
+
+  Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue;
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+    return target;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+  }
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+  }
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  /**
+   * virtual list core calculating center
+   */
+
+  var DIRECTION_TYPE = {
+    FRONT: 'FRONT',
+    // scroll up or left
+    BEHIND: 'BEHIND' // scroll down or right
+  };
+  var CALC_TYPE = {
+    INIT: 'INIT',
+    FIXED: 'FIXED',
+    DYNAMIC: 'DYNAMIC'
+  };
+  var LEADING_BUFFER = 0;
+  var Virtual = /*#__PURE__*/function () {
+    function Virtual(param, callUpdate) {
+      _classCallCheck(this, Virtual);
+      this.init(param, callUpdate);
+    }
+    _createClass(Virtual, [{
+      key: "init",
+      value: function init(param, callUpdate) {
+        // param data
+        this.param = param;
+        this.callUpdate = callUpdate;
+
+        // size data
+        this.sizes = new Map();
+        this.firstRangeTotalSize = 0;
+        this.firstRangeAverageSize = 0;
+        this.fixedSizeValue = 0;
+        this.calcType = CALC_TYPE.INIT;
+
+        // scroll data
+        this.offset = 0;
+        this.direction = '';
+
+        // range data
+        this.range = Object.create(null);
+        if (param) {
+          this.checkRange(0, param.keeps - 1);
+        }
+
+        // benchmark test data
+        // this.__bsearchCalls = 0
+        // this.__getIndexOffsetCalls = 0
+      }
+    }, {
+      key: "destroy",
+      value: function destroy() {
+        this.init(null, null);
+      }
+
+      // return current render range
+    }, {
+      key: "getRange",
+      value: function getRange() {
+        var range = Object.create(null);
+        range.start = this.range.start;
+        range.end = this.range.end;
+        range.padFront = this.range.padFront;
+        range.padBehind = this.range.padBehind;
+        return range;
+      }
+    }, {
+      key: "isBehind",
+      value: function isBehind() {
+        return this.direction === DIRECTION_TYPE.BEHIND;
+      }
+    }, {
+      key: "isFront",
+      value: function isFront() {
+        return this.direction === DIRECTION_TYPE.FRONT;
+      }
+
+      // return start index offset
+    }, {
+      key: "getOffset",
+      value: function getOffset(start) {
+        return (start < 1 ? 0 : this.getIndexOffset(start)) + this.param.slotHeaderSize;
+      }
+    }, {
+      key: "updateParam",
+      value: function updateParam(key, value) {
+        var _this = this;
+        if (this.param && key in this.param) {
+          // if uniqueIds change, find out deleted id and remove from size map
+          if (key === 'uniqueIds') {
+            this.sizes.forEach(function (v, key) {
+              if (!value.includes(key)) {
+                _this.sizes["delete"](key);
+              }
+            });
+          }
+          this.param[key] = value;
+        }
+      }
+
+      // save each size map by id
+    }, {
+      key: "saveSize",
+      value: function saveSize(id, size) {
+        this.sizes.set(id, size);
+
+        // we assume size type is fixed at the beginning and remember first size value
+        // if there is no size value different from this at next comming saving
+        // we think it's a fixed size list, otherwise is dynamic size list
+        if (this.calcType === CALC_TYPE.INIT) {
+          this.fixedSizeValue = size;
+          this.calcType = CALC_TYPE.FIXED;
+        } else if (this.calcType === CALC_TYPE.FIXED && this.fixedSizeValue !== size) {
+          this.calcType = CALC_TYPE.DYNAMIC;
+          // it's no use at all
+          delete this.fixedSizeValue;
+        }
+
+        // calculate the average size only in the first range
+        if (this.calcType !== CALC_TYPE.FIXED && typeof this.firstRangeTotalSize !== 'undefined') {
+          if (this.sizes.size < Math.min(this.param.keeps, this.param.uniqueIds.length)) {
+            this.firstRangeTotalSize = _toConsumableArray(this.sizes.values()).reduce(function (acc, val) {
+              return acc + val;
+            }, 0);
+            this.firstRangeAverageSize = Math.round(this.firstRangeTotalSize / this.sizes.size);
+          } else {
+            // it's done using
+            delete this.firstRangeTotalSize;
+          }
+        }
+      }
+
+      // in some special situation (e.g. length change) we need to update in a row
+      // try goiong to render next range by a leading buffer according to current direction
+    }, {
+      key: "handleDataSourcesChange",
+      value: function handleDataSourcesChange() {
+        var start = this.range.start;
+        if (this.isFront()) {
+          start = start - LEADING_BUFFER;
+        } else if (this.isBehind()) {
+          start = start + LEADING_BUFFER;
+        }
+        start = Math.max(start, 0);
+        this.updateRange(this.range.start, this.getEndByStart(start));
+      }
+
+      // when slot size change, we also need force update
+    }, {
+      key: "handleSlotSizeChange",
+      value: function handleSlotSizeChange() {
+        this.handleDataSourcesChange();
+      }
+
+      // calculating range on scroll
+    }, {
+      key: "handleScroll",
+      value: function handleScroll(offset) {
+        this.direction = offset < this.offset || offset === 0 ? DIRECTION_TYPE.FRONT : DIRECTION_TYPE.BEHIND;
+        this.offset = offset;
+        if (!this.param) {
+          return;
+        }
+        if (this.direction === DIRECTION_TYPE.FRONT) {
+          this.handleFront();
+        } else if (this.direction === DIRECTION_TYPE.BEHIND) {
+          this.handleBehind();
+        }
+      }
+
+      // ----------- public method end -----------
+    }, {
+      key: "handleFront",
+      value: function handleFront() {
+        var overs = this.getScrollOvers();
+        // should not change range if start doesn't exceed overs
+        if (overs > this.range.start) {
+          return;
+        }
+
+        // move up start by a buffer length, and make sure its safety
+        var start = Math.max(overs - this.param.buffer, 0);
+        this.checkRange(start, this.getEndByStart(start));
+      }
+    }, {
+      key: "handleBehind",
+      value: function handleBehind() {
+        var overs = this.getScrollOvers();
+        // range should not change if scroll overs within buffer
+        if (overs < this.range.start + this.param.buffer) {
+          return;
+        }
+        this.checkRange(overs, this.getEndByStart(overs));
+      }
+
+      // return the pass overs according to current scroll offset
+    }, {
+      key: "getScrollOvers",
+      value: function getScrollOvers() {
+        // if slot header exist, we need subtract its size
+        var offset = this.offset - this.param.slotHeaderSize;
+        if (offset <= 0) {
+          return 0;
+        }
+
+        // if is fixed type, that can be easily
+        if (this.isFixedType()) {
+          return Math.floor(offset / this.fixedSizeValue);
+        }
+        var low = 0;
+        var middle = 0;
+        var middleOffset = 0;
+        var high = this.param.uniqueIds.length;
+        while (low <= high) {
+          // this.__bsearchCalls++
+          middle = low + Math.floor((high - low) / 2);
+          middleOffset = this.getIndexOffset(middle);
+          if (middleOffset === offset) {
+            return middle;
+          } else if (middleOffset < offset) {
+            low = middle + 1;
+          } else if (middleOffset > offset) {
+            high = middle - 1;
+          }
+        }
+        return low > 0 ? --low : 0;
+      }
+
+      // return a scroll offset from given index, can efficiency be improved more here?
+      // although the call frequency is very high, its only a superposition of numbers
+    }, {
+      key: "getIndexOffset",
+      value: function getIndexOffset(givenIndex) {
+        if (!givenIndex) {
+          return 0;
+        }
+        var offset = 0;
+        var indexSize = 0;
+        for (var index = 0; index < givenIndex; index++) {
+          // this.__getIndexOffsetCalls++
+          indexSize = this.sizes.get(this.param.uniqueIds[index]);
+          offset = offset + (typeof indexSize === 'number' ? indexSize : this.getEstimateSize());
+        }
+        return offset;
+      }
+
+      // is fixed size type
+    }, {
+      key: "isFixedType",
+      value: function isFixedType() {
+        return this.calcType === CALC_TYPE.FIXED;
+      }
+
+      // return the real last index
+    }, {
+      key: "getLastIndex",
+      value: function getLastIndex() {
+        return this.param.uniqueIds.length - 1;
+      }
+
+      // in some conditions range is broke, we need correct it
+      // and then decide whether need update to next range
+    }, {
+      key: "checkRange",
+      value: function checkRange(start, end) {
+        var keeps = this.param.keeps;
+        var total = this.param.uniqueIds.length;
+
+        // datas less than keeps, render all
+        if (total <= keeps) {
+          start = 0;
+          end = this.getLastIndex();
+        } else if (end - start < keeps - 1) {
+          // if range length is less than keeps, corrent it base on end
+          start = end - keeps + 1;
+        }
+        if (this.range.start !== start) {
+          this.updateRange(start, end);
+        }
+      }
+
+      // setting to a new range and rerender
+    }, {
+      key: "updateRange",
+      value: function updateRange(start, end) {
+        this.range.start = start;
+        this.range.end = end;
+        this.range.padFront = this.getPadFront();
+        this.range.padBehind = this.getPadBehind();
+        this.callUpdate(this.getRange());
+      }
+
+      // return end base on start
+    }, {
+      key: "getEndByStart",
+      value: function getEndByStart(start) {
+        var theoryEnd = start + this.param.keeps - 1;
+        var truelyEnd = Math.min(theoryEnd, this.getLastIndex());
+        return truelyEnd;
+      }
+
+      // return total front offset
+    }, {
+      key: "getPadFront",
+      value: function getPadFront() {
+        if (this.isFixedType()) {
+          return this.fixedSizeValue * this.range.start;
+        } else {
+          return this.getIndexOffset(this.range.start);
+        }
+      }
+
+      // return total behind offset
+    }, {
+      key: "getPadBehind",
+      value: function getPadBehind() {
+        var end = this.range.end;
+        var lastIndex = this.getLastIndex();
+        if (this.isFixedType()) {
+          return (lastIndex - end) * this.fixedSizeValue;
+        }
+        return (lastIndex - end) * this.getEstimateSize();
+      }
+
+      // get the item estimate size
+    }, {
+      key: "getEstimateSize",
+      value: function getEstimateSize() {
+        return this.isFixedType() ? this.fixedSizeValue : this.firstRangeAverageSize || this.param.estimateSize;
+      }
+    }]);
+    return Virtual;
+  }();
+
+  /**
+   * props declaration for default, item and slot component
+   */
+
+  var VirtualProps = {
+    dataKey: {
+      type: [String, Function],
+      required: true
+    },
+    dataSources: {
+      type: Array,
+      required: true
+    },
+    dataComponent: {
+      type: [Object, Function],
+      required: true
+    },
+    keeps: {
+      type: Number,
+      "default": 30
+    },
+    extraProps: {
+      type: Object
+    },
+    estimateSize: {
+      type: Number,
+      "default": 50
+    },
+    direction: {
+      type: String,
+      "default": 'vertical' // the other value is horizontal
+    },
+    start: {
+      type: Number,
+      "default": 0
+    },
+    offset: {
+      type: Number,
+      "default": 0
+    },
+    topThreshold: {
+      type: Number,
+      "default": 0
+    },
+    bottomThreshold: {
+      type: Number,
+      "default": 0
+    },
+    pageMode: {
+      type: Boolean,
+      "default": false
+    },
+    rootTag: {
+      type: String,
+      "default": 'div'
+    },
+    wrapTag: {
+      type: String,
+      "default": 'div'
+    },
+    wrapClass: {
+      type: String,
+      "default": ''
+    },
+    wrapStyle: {
+      type: Object
+    },
+    itemTag: {
+      type: String,
+      "default": 'div'
+    },
+    itemClass: {
+      type: String,
+      "default": ''
+    },
+    itemClassAdd: {
+      type: Function
+    },
+    itemStyle: {
+      type: Object
+    },
+    headerTag: {
+      type: String,
+      "default": 'div'
+    },
+    headerClass: {
+      type: String,
+      "default": ''
+    },
+    headerStyle: {
+      type: Object
+    },
+    footerTag: {
+      type: String,
+      "default": 'div'
+    },
+    footerClass: {
+      type: String,
+      "default": ''
+    },
+    footerStyle: {
+      type: Object
+    },
+    itemScopedSlots: {
+      type: Object
+    }
+  };
+  var ItemProps = {
+    index: {
+      type: Number
+    },
+    event: {
+      type: String
+    },
+    tag: {
+      type: String
+    },
+    horizontal: {
+      type: Boolean
+    },
+    source: {
+      type: Object
+    },
+    component: {
+      type: [Object, Function]
+    },
+    slotComponent: {
+      type: Function
+    },
+    uniqueKey: {
+      type: [String, Number]
+    },
+    extraProps: {
+      type: Object
+    },
+    scopedSlots: {
+      type: Object
+    }
+  };
+  var SlotProps = {
+    event: {
+      type: String
+    },
+    uniqueKey: {
+      type: String
+    },
+    tag: {
+      type: String
+    },
+    horizontal: {
+      type: Boolean
+    }
+  };
+  var Wrapper = {
+    created: function created() {
+      this.shapeKey = this.horizontal ? 'offsetWidth' : 'offsetHeight';
+    },
+    mounted: function mounted() {
+      var _this = this;
+      if (typeof ResizeObserver !== 'undefined') {
+        this.resizeObserver = new ResizeObserver(function () {
+          _this.dispatchSizeChange();
+        });
+        this.resizeObserver.observe(this.$el);
+      }
+    },
+    // since componet will be reused, so disptach when updated
+    updated: function updated() {
+      // this.dispatchSizeChange()
+      this.resizeObserver.observe(this.$el);
+    },
+    beforeDestroy: function beforeDestroy() {
+      if (this.resizeObserver) {
+        this.resizeObserver.disconnect();
+        this.resizeObserver = null;
+      }
+    },
+    methods: {
+      getCurrentSize: function getCurrentSize() {
+        return this.$el ? this.$el[this.shapeKey] : 0;
+      },
+      // tell parent current size identify by unqiue key
+      dispatchSizeChange: function dispatchSizeChange() {
+        this.$parent.$emit(this.event, this.uniqueKey, this.getCurrentSize(), this.hasInitial);
+      }
+    }
+  };
+
+  // wrapping for item
+  var Item = Vue.component('virtual-list-item', {
+    mixins: [Wrapper],
+    props: ItemProps,
+    render: function render(h) {
+      var tag = this.tag,
+        component = this.component,
+        _this$extraProps = this.extraProps,
+        extraProps = _this$extraProps === void 0 ? {} : _this$extraProps,
+        index = this.index,
+        source = this.source,
+        _this$scopedSlots = this.scopedSlots,
+        scopedSlots = _this$scopedSlots === void 0 ? {} : _this$scopedSlots,
+        uniqueKey = this.uniqueKey,
+        slotComponent = this.slotComponent;
+      var props = _objectSpread2(_objectSpread2({}, extraProps), {}, {
+        source: source,
+        index: index
+      });
+      return h(tag, {
+        key: uniqueKey,
+        attrs: {
+          role: 'listitem'
+        }
+      }, [slotComponent ? slotComponent({
+        item: source,
+        index: index,
+        scope: props
+      }) : h(component, {
+        props: props,
+        scopedSlots: scopedSlots
+      })]);
+    }
+  });
+
+  // wrapping for slot
+  var Slot = Vue.component('virtual-list-slot', {
+    mixins: [Wrapper],
+    props: SlotProps,
+    render: function render(h) {
+      var tag = this.tag,
+        uniqueKey = this.uniqueKey;
+      return h(tag, {
+        key: uniqueKey,
+        attrs: {
+          role: uniqueKey
+        }
+      }, this.$slots["default"]);
+    }
+  });
+
+  /**
+   * virtual list default component
+   */
+  var EVENT_TYPE = {
+    ITEM: 'item_resize',
+    SLOT: 'slot_resize'
+  };
+  var SLOT_TYPE = {
+    HEADER: 'thead',
+    // string value also use for aria role attribute
+    FOOTER: 'tfoot'
+  };
+  var VirtualList = Vue.component('virtual-list', {
+    props: VirtualProps,
+    data: function data() {
+      return {
+        range: null
+      };
+    },
+    watch: {
+      'dataSources.length': function dataSourcesLength() {
+        this.virtual.updateParam('uniqueIds', this.getUniqueIdFromDataSources());
+        this.virtual.handleDataSourcesChange();
+      },
+      keeps: function keeps(newValue) {
+        this.virtual.updateParam('keeps', newValue);
+        this.virtual.handleSlotSizeChange();
+      },
+      start: function start(newValue) {
+        this.scrollToIndex(newValue);
+      },
+      offset: function offset(newValue) {
+        this.scrollToOffset(newValue);
+      }
+    },
+    created: function created() {
+      this.isHorizontal = this.direction === 'horizontal';
+      this.directionKey = this.isHorizontal ? 'scrollLeft' : 'scrollTop';
+      this.installVirtual();
+
+      // listen item size change
+      this.$on(EVENT_TYPE.ITEM, this.onItemResized);
+
+      // listen slot size change
+      if (this.$slots.header || this.$slots.footer) {
+        this.$on(EVENT_TYPE.SLOT, this.onSlotResized);
+      }
+    },
+    activated: function activated() {
+      // set back offset when awake from keep-alive
+      this.scrollToOffset(this.virtual.offset);
+      if (this.pageMode) {
+        document.addEventListener('scroll', this.onScroll, {
+          passive: false
+        });
+      }
+    },
+    deactivated: function deactivated() {
+      if (this.pageMode) {
+        document.removeEventListener('scroll', this.onScroll);
+      }
+    },
+    mounted: function mounted() {
+      // set position
+      if (this.start) {
+        this.scrollToIndex(this.start);
+      } else if (this.offset) {
+        this.scrollToOffset(this.offset);
+      }
+
+      // in page mode we bind scroll event to document
+      if (this.pageMode) {
+        this.updatePageModeFront();
+        document.addEventListener('scroll', this.onScroll, {
+          passive: false
+        });
+      }
+    },
+    beforeDestroy: function beforeDestroy() {
+      this.virtual.destroy();
+      if (this.pageMode) {
+        document.removeEventListener('scroll', this.onScroll);
+      }
+    },
+    methods: {
+      // get item size by id
+      getSize: function getSize(id) {
+        return this.virtual.sizes.get(id);
+      },
+      // get the total number of stored (rendered) items
+      getSizes: function getSizes() {
+        return this.virtual.sizes.size;
+      },
+      // return current scroll offset
+      getOffset: function getOffset() {
+        if (this.pageMode) {
+          return document.documentElement[this.directionKey] || document.body[this.directionKey];
+        } else {
+          var root = this.$refs.root;
+          return root ? Math.ceil(root[this.directionKey]) : 0;
+        }
+      },
+      // return client viewport size
+      getClientSize: function getClientSize() {
+        var key = this.isHorizontal ? 'clientWidth' : 'clientHeight';
+        if (this.pageMode) {
+          return document.documentElement[key] || document.body[key];
+        } else {
+          var root = this.$refs.root;
+          return root ? Math.ceil(root[key]) : 0;
+        }
+      },
+      // return all scroll size
+      getScrollSize: function getScrollSize() {
+        var key = this.isHorizontal ? 'scrollWidth' : 'scrollHeight';
+        if (this.pageMode) {
+          return document.documentElement[key] || document.body[key];
+        } else {
+          var root = this.$refs.root;
+          return root ? Math.ceil(root[key]) : 0;
+        }
+      },
+      // set current scroll position to a expectant offset
+      scrollToOffset: function scrollToOffset(offset) {
+        if (this.pageMode) {
+          document.body[this.directionKey] = offset;
+          document.documentElement[this.directionKey] = offset;
+        } else {
+          var root = this.$refs.root;
+          if (root) {
+            root[this.directionKey] = offset;
+          }
+        }
+      },
+      // set current scroll position to a expectant index
+      scrollToIndex: function scrollToIndex(index) {
+        // scroll to bottom
+        if (index >= this.dataSources.length - 1) {
+          this.scrollToBottom();
+        } else {
+          var offset = this.virtual.getOffset(index);
+          this.scrollToOffset(offset);
+        }
+      },
+      // set current scroll position to bottom
+      scrollToBottom: function scrollToBottom() {
+        var _this = this;
+        var shepherd = this.$refs.shepherd;
+        if (shepherd) {
+          var offset = shepherd[this.isHorizontal ? 'offsetLeft' : 'offsetTop'];
+          this.scrollToOffset(offset);
+
+          // check if it's really scrolled to the bottom
+          // maybe list doesn't render and calculate to last range
+          // so we need retry in next event loop until it really at bottom
+          setTimeout(function () {
+            if (_this.getOffset() + _this.getClientSize() + 1 < _this.getScrollSize()) {
+              _this.scrollToBottom();
+            }
+          }, 3);
+        }
+      },
+      // when using page mode we need update slot header size manually
+      // taking root offset relative to the browser as slot header size
+      updatePageModeFront: function updatePageModeFront() {
+        var root = this.$refs.root;
+        if (root) {
+          var rect = root.getBoundingClientRect();
+          var defaultView = root.ownerDocument.defaultView;
+          var offsetFront = this.isHorizontal ? rect.left + defaultView.pageXOffset : rect.top + defaultView.pageYOffset;
+          this.virtual.updateParam('slotHeaderSize', offsetFront);
+        }
+      },
+      // reset all state back to initial
+      reset: function reset() {
+        this.virtual.destroy();
+        this.scrollToOffset(0);
+        this.installVirtual();
+      },
+      // ----------- public method end -----------
+      installVirtual: function installVirtual() {
+        this.virtual = new Virtual({
+          slotHeaderSize: 0,
+          slotFooterSize: 0,
+          keeps: this.keeps,
+          estimateSize: this.estimateSize,
+          buffer: Math.round(this.keeps / 3),
+          // recommend for a third of keeps
+          uniqueIds: this.getUniqueIdFromDataSources()
+        }, this.onRangeChanged);
+
+        // sync initial range
+        this.range = this.virtual.getRange();
+      },
+      getUniqueIdFromDataSources: function getUniqueIdFromDataSources() {
+        var dataKey = this.dataKey;
+        return this.dataSources.map(function (dataSource) {
+          return typeof dataKey === 'function' ? dataKey(dataSource) : dataSource[dataKey];
+        });
+      },
+      // event called when each item mounted or size changed
+      onItemResized: function onItemResized(id, size) {
+        this.virtual.saveSize(id, size);
+        this.$emit('resized', id, size);
+      },
+      // event called when slot mounted or size changed
+      onSlotResized: function onSlotResized(type, size, hasInit) {
+        if (type === SLOT_TYPE.HEADER) {
+          this.virtual.updateParam('slotHeaderSize', size);
+        } else if (type === SLOT_TYPE.FOOTER) {
+          this.virtual.updateParam('slotFooterSize', size);
+        }
+        if (hasInit) {
+          this.virtual.handleSlotSizeChange();
+        }
+      },
+      // here is the rerendering entry
+      onRangeChanged: function onRangeChanged(range) {
+        this.range = range;
+      },
+      onScroll: function onScroll(evt) {
+        var offset = this.getOffset();
+        var clientSize = this.getClientSize();
+        var scrollSize = this.getScrollSize();
+
+        // iOS scroll-spring-back behavior will make direction mistake
+        if (offset < 0 || offset + clientSize > scrollSize + 1 || !scrollSize) {
+          return;
+        }
+        this.virtual.handleScroll(offset);
+        this.emitEvent(offset, clientSize, scrollSize, evt);
+      },
+      // emit event in special position
+      emitEvent: function emitEvent(offset, clientSize, scrollSize, evt) {
+        this.$emit('scroll', evt, this.virtual.getRange());
+        if (this.virtual.isFront() && !!this.dataSources.length && offset - this.topThreshold <= 0) {
+          this.$emit('totop');
+        } else if (this.virtual.isBehind() && offset + clientSize + this.bottomThreshold >= scrollSize) {
+          this.$emit('tobottom');
+        }
+      },
+      // get the real render slots based on range data
+      // in-place patch strategy will try to reuse components as possible
+      // so those components that are reused will not trigger lifecycle mounted
+      getRenderSlots: function getRenderSlots(h) {
+        var slots = [];
+        var _this$range = this.range,
+          start = _this$range.start,
+          end = _this$range.end;
+        var dataSources = this.dataSources,
+          dataKey = this.dataKey,
+          itemClass = this.itemClass,
+          itemTag = this.itemTag,
+          itemStyle = this.itemStyle,
+          isHorizontal = this.isHorizontal,
+          extraProps = this.extraProps,
+          dataComponent = this.dataComponent,
+          itemScopedSlots = this.itemScopedSlots;
+        var slotComponent = this.$scopedSlots && this.$scopedSlots.item;
+        for (var index = start; index <= end; index++) {
+          var dataSource = dataSources[index];
+          if (dataSource) {
+            var uniqueKey = typeof dataKey === 'function' ? dataKey(dataSource) : dataSource[dataKey];
+            if (typeof uniqueKey === 'string' || typeof uniqueKey === 'number') {
+              slots.push(h(Item, {
+                props: {
+                  index: index,
+                  tag: itemTag,
+                  event: EVENT_TYPE.ITEM,
+                  horizontal: isHorizontal,
+                  uniqueKey: uniqueKey,
+                  source: dataSource,
+                  extraProps: extraProps,
+                  component: dataComponent,
+                  slotComponent: slotComponent,
+                  scopedSlots: itemScopedSlots
+                },
+                style: itemStyle,
+                "class": "".concat(itemClass).concat(this.itemClassAdd ? ' ' + this.itemClassAdd(index) : '')
+              }));
+            } else {
+              console.warn("Cannot get the data-key '".concat(dataKey, "' from data-sources."));
+            }
+          } else {
+            console.warn("Cannot get the index '".concat(index, "' from data-sources."));
+          }
+        }
+        return slots;
+      }
+    },
+    // render function, a closer-to-the-compiler alternative to templates
+    // https://vuejs.org/v2/guide/render-function.html#The-Data-Object-In-Depth
+    render: function render(h) {
+      var _this$$slots = this.$slots,
+        header = _this$$slots.header,
+        footer = _this$$slots.footer;
+      var _this$range2 = this.range,
+        padFront = _this$range2.padFront,
+        padBehind = _this$range2.padBehind;
+      var isHorizontal = this.isHorizontal,
+        pageMode = this.pageMode,
+        rootTag = this.rootTag,
+        wrapTag = this.wrapTag,
+        wrapClass = this.wrapClass,
+        wrapStyle = this.wrapStyle,
+        headerTag = this.headerTag,
+        headerClass = this.headerClass,
+        headerStyle = this.headerStyle,
+        footerTag = this.footerTag,
+        footerClass = this.footerClass,
+        footerStyle = this.footerStyle;
+      var paddingStyle = {
+        padding: isHorizontal ? "0px ".concat(padBehind, "px 0px ").concat(padFront, "px") : "".concat(padFront, "px 0px ").concat(padBehind, "px")
+      };
+      var wrapperStyle = wrapStyle ? Object.assign({}, wrapStyle, paddingStyle) : paddingStyle;
+      return h(rootTag, {
+        ref: 'root',
+        on: {
+          '&scroll': !pageMode && this.onScroll
+        }
+      }, [
+      // header slot
+      header ? h(Slot, {
+        "class": headerClass,
+        style: headerStyle,
+        props: {
+          tag: headerTag,
+          event: EVENT_TYPE.SLOT,
+          uniqueKey: SLOT_TYPE.HEADER
+        }
+      }, header) : null,
+      // main list
+      h(wrapTag, {
+        "class": wrapClass,
+        attrs: {
+          role: 'group'
+        },
+        style: wrapperStyle
+      }, this.getRenderSlots(h)),
+      // footer slot
+      footer ? h(Slot, {
+        "class": footerClass,
+        style: footerStyle,
+        props: {
+          tag: footerTag,
+          event: EVENT_TYPE.SLOT,
+          uniqueKey: SLOT_TYPE.FOOTER
+        }
+      }, footer) : null,
+      // an empty element use to scroll to bottom
+      h('div', {
+        ref: 'shepherd',
+        style: {
+          width: isHorizontal ? '0px' : '100%',
+          height: isHorizontal ? '100%' : '0px'
+        }
+      })]);
+    }
+  });
+  return VirtualList;
+});
+
 /***/ }),
 
 /***/ 2106:
@@ -708,11 +1843,84 @@ var INCORRECT = !setMethodAcceptSetLike('isSupersetOf', function (result) {
   return !result;
 });
 
-// `Set.prototype.isSupersetOf` method
-// https://tc39.es/ecma262/#sec-set.prototype.issupersetof
-$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
-  isSupersetOf: isSupersetOf
-});
+// `Set.prototype.isSupersetOf` method
+// https://tc39.es/ecma262/#sec-set.prototype.issupersetof
+$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
+  isSupersetOf: isSupersetOf
+});
+
+
+/***/ }),
+
+/***/ 2489:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var call = __webpack_require__(9565);
+var aCallable = __webpack_require__(9306);
+var anObject = __webpack_require__(8551);
+var getIteratorDirect = __webpack_require__(1767);
+var createIteratorProxy = __webpack_require__(9462);
+var callWithSafeIterationClosing = __webpack_require__(6319);
+var IS_PURE = __webpack_require__(6395);
+var iteratorClose = __webpack_require__(9539);
+var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(684);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
+
+var FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('filter', function () { /* empty */ });
+var filterWithoutClosingOnEarlyError = !IS_PURE && !FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  && iteratorHelperWithoutClosingOnEarlyError('filter', TypeError);
+
+var FORCED = IS_PURE || FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR || filterWithoutClosingOnEarlyError;
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var predicate = this.predicate;
+  var next = this.next;
+  var result, done, value;
+  while (true) {
+    result = anObject(call(next, iterator));
+    done = this.done = !!result.done;
+    if (done) return;
+    value = result.value;
+    if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value;
+  }
+});
+
+// `Iterator.prototype.filter` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.filter
+$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
+  filter: function filter(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (filterWithoutClosingOnEarlyError) return call(filterWithoutClosingOnEarlyError, this, predicate);
+
+    return new IteratorProxy(getIteratorDirect(this), {
+      predicate: predicate
+    });
+  }
+});
+
+
+/***/ }),
+
+/***/ 2529:
+/***/ (function(module) {
+
+"use strict";
+
+// `CreateIterResultObject` abstract operation
+// https://tc39.es/ecma262/#sec-createiterresultobject
+module.exports = function (value, done) {
+  return { value: value, done: done };
+};
 
 
 /***/ }),
@@ -2912,6 +4120,41 @@ module.exports = function (obj) {
 module.exports = {};
 
 
+/***/ }),
+
+/***/ 6279:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var defineBuiltIn = __webpack_require__(6840);
+
+module.exports = function (target, src, options) {
+  for (var key in src) defineBuiltIn(target, key, src[key], options);
+  return target;
+};
+
+
+/***/ }),
+
+/***/ 6319:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var anObject = __webpack_require__(8551);
+var iteratorClose = __webpack_require__(9539);
+
+// call something on iterator step with safe closing on error
+module.exports = function (iterator, fn, value, ENTRIES) {
+  try {
+    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+  } catch (error) {
+    iteratorClose(iterator, 'throw', error);
+  }
+};
+
+
 /***/ }),
 
 /***/ 6395:
@@ -3791,6 +5034,66 @@ module.exports = function (name) {
 };
 
 
+/***/ }),
+
+/***/ 8237:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var iterate = __webpack_require__(2652);
+var aCallable = __webpack_require__(9306);
+var anObject = __webpack_require__(8551);
+var getIteratorDirect = __webpack_require__(1767);
+var iteratorClose = __webpack_require__(9539);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
+var apply = __webpack_require__(8745);
+var fails = __webpack_require__(9039);
+
+var $TypeError = TypeError;
+
+// https://bugs.webkit.org/show_bug.cgi?id=291651
+var FAILS_ON_INITIAL_UNDEFINED = fails(function () {
+  // eslint-disable-next-line es/no-iterator-prototype-reduce, es/no-array-prototype-keys, array-callback-return -- required for testing
+  [].keys().reduce(function () { /* empty */ }, undefined);
+});
+
+var reduceWithoutClosingOnEarlyError = !FAILS_ON_INITIAL_UNDEFINED && iteratorHelperWithoutClosingOnEarlyError('reduce', $TypeError);
+
+// `Iterator.prototype.reduce` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.reduce
+$({ target: 'Iterator', proto: true, real: true, forced: FAILS_ON_INITIAL_UNDEFINED || reduceWithoutClosingOnEarlyError }, {
+  reduce: function reduce(reducer /* , initialValue */) {
+    anObject(this);
+    try {
+      aCallable(reducer);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    var noInitial = arguments.length < 2;
+    var accumulator = noInitial ? undefined : arguments[1];
+    if (reduceWithoutClosingOnEarlyError) {
+      return apply(reduceWithoutClosingOnEarlyError, this, noInitial ? [reducer] : [reducer, accumulator]);
+    }
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    iterate(record, function (value) {
+      if (noInitial) {
+        noInitial = false;
+        accumulator = value;
+      } else {
+        accumulator = reducer(accumulator, value, counter);
+      }
+      counter++;
+    }, { IS_RECORD: true });
+    if (noInitial) throw new $TypeError('Reduce of empty iterator with no initial value');
+    return accumulator;
+  }
+});
+
+
 /***/ }),
 
 /***/ 8469:
@@ -3934,6 +5237,25 @@ module.exports = [
 ];
 
 
+/***/ }),
+
+/***/ 8745:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var NATIVE_BIND = __webpack_require__(616);
+
+var FunctionPrototype = Function.prototype;
+var apply = FunctionPrototype.apply;
+var call = FunctionPrototype.call;
+
+// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
+module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
+  return call.apply(apply, arguments);
+});
+
+
 /***/ }),
 
 /***/ 8750:
@@ -4029,6 +5351,14 @@ module.exports = function (exec) {
 };
 
 
+/***/ }),
+
+/***/ 9274:
+/***/ (function(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__9274__;
+
 /***/ }),
 
 /***/ 9286:
@@ -4134,6 +5464,100 @@ module.exports = function (key, value) {
 };
 
 
+/***/ }),
+
+/***/ 9462:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var call = __webpack_require__(9565);
+var create = __webpack_require__(2360);
+var createNonEnumerableProperty = __webpack_require__(6699);
+var defineBuiltIns = __webpack_require__(6279);
+var wellKnownSymbol = __webpack_require__(8227);
+var InternalStateModule = __webpack_require__(1181);
+var getMethod = __webpack_require__(5966);
+var IteratorPrototype = (__webpack_require__(7657).IteratorPrototype);
+var createIterResultObject = __webpack_require__(2529);
+var iteratorClose = __webpack_require__(9539);
+var iteratorCloseAll = __webpack_require__(1385);
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var ITERATOR_HELPER = 'IteratorHelper';
+var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
+var NORMAL = 'normal';
+var THROW = 'throw';
+var setInternalState = InternalStateModule.set;
+
+var createIteratorProxyPrototype = function (IS_ITERATOR) {
+  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
+
+  return defineBuiltIns(create(IteratorPrototype), {
+    next: function next() {
+      var state = getInternalState(this);
+      // for simplification:
+      //   for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject`
+      //   for `%IteratorHelperPrototype%.next` - just a value
+      if (IS_ITERATOR) return state.nextHandler();
+      if (state.done) return createIterResultObject(undefined, true);
+      try {
+        var result = state.nextHandler();
+        return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
+      } catch (error) {
+        state.done = true;
+        throw error;
+      }
+    },
+    'return': function () {
+      var state = getInternalState(this);
+      var iterator = state.iterator;
+      state.done = true;
+      if (IS_ITERATOR) {
+        var returnMethod = getMethod(iterator, 'return');
+        return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);
+      }
+      if (state.inner) try {
+        iteratorClose(state.inner.iterator, NORMAL);
+      } catch (error) {
+        return iteratorClose(iterator, THROW, error);
+      }
+      if (state.openIters) try {
+        iteratorCloseAll(state.openIters, NORMAL);
+      } catch (error) {
+        return iteratorClose(iterator, THROW, error);
+      }
+      if (iterator) iteratorClose(iterator, NORMAL);
+      return createIterResultObject(undefined, true);
+    }
+  });
+};
+
+var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+
+createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
+
+module.exports = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
+  var IteratorProxy = function Iterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+    state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
+    state.nextHandler = nextHandler;
+    state.counter = 0;
+    state.done = false;
+    setInternalState(this, state);
+  };
+
+  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+
+  return IteratorProxy;
+};
+
+
 /***/ }),
 
 /***/ 9504:
@@ -4420,6 +5844,7 @@ __webpack_require__.d(__webpack_exports__, {
   UiDialog: function() { return /* reexport */ ui_dialog; },
   UiForm: function() { return /* reexport */ ui_form; },
   UiTable: function() { return /* reexport */ ui_table; },
+  UiVirtualSelect: function() { return /* reexport */ ui_virtual_select; },
   "default": function() { return /* binding */ entry_lib; }
 });
 
@@ -5430,13 +6855,304 @@ var ui_dialog_component = normalizeComponent(
 )
 
 /* harmony default export */ var ui_dialog = (ui_dialog_component.exports);
+;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-82.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/index.vue?vue&type=template&id=4776e956&scoped=true
+var ui_virtual_selectvue_type_template_id_4776e956_scoped_true_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    staticClass: "select-wrap"
+  }, [_c('el-select', _vm._b({
+    ref: "elSelectRef",
+    attrs: {
+      "value": _vm.innerValue,
+      "popper-class": "virtual-select-popper",
+      "filterable": "",
+      "filter-method": _vm.filterMethod,
+      "popper-append-to-body": true
+    },
+    on: {
+      "visible-change": _vm.handleVisibleChange,
+      "change": _vm.handleSelectChange
+    }
+  }, 'el-select', _vm.$attrs, false), [_c('vue-virtual-scroll-list', {
+    ref: "virtualList",
+    staticClass: "virtual-list",
+    attrs: {
+      "data-key": _vm.fields.value,
+      "data-sources": _vm.filteredData,
+      "data-component": _vm.itemComponent,
+      "keeps": 20,
+      "extra-props": {
+        label: _vm.fields.label,
+        value: _vm.fields.value,
+        rightLabel: _vm.fields.rightLabel
+      },
+      "estimate-size": 34
+    },
+    on: {
+      "item-click": _vm.handleItemClick
+    }
+  })], 1)], 1);
+};
+var ui_virtual_selectvue_type_template_id_4776e956_scoped_true_staticRenderFns = [];
+
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.push.js
+var es_array_push = __webpack_require__(4114);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.filter.js
+var es_iterator_filter = __webpack_require__(2489);
+// EXTERNAL MODULE: ./node_modules/vue-virtual-scroll-list/dist/index.js
+var dist = __webpack_require__(2044);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-82.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/itemComponent.vue?vue&type=template&id=68d8f45e&scoped=true
+var itemComponentvue_type_template_id_68d8f45e_scoped_true_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    staticClass: "item",
+    on: {
+      "click": _vm.handleItemClick
+    }
+  }, [_c('el-option', {
+    attrs: {
+      "label": _vm.source[_vm.label],
+      "value": _vm.source[_vm.value]
+    }
+  }, [_c('span', {
+    staticClass: "left-text"
+  }, [_vm._v(_vm._s(_vm.source[_vm.label]))]), _vm.rightLabel ? _c('span', {
+    staticClass: "right-text"
+  }, [_vm._v(_vm._s(_vm.source[_vm.rightLabel]))]) : _vm._e()])], 1);
+};
+var itemComponentvue_type_template_id_68d8f45e_scoped_true_staticRenderFns = [];
+
+;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-82.use[1]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/itemComponent.vue?vue&type=script&lang=js
+/* harmony default export */ var itemComponentvue_type_script_lang_js = ({
+  props: {
+    source: {
+      type: Object,
+      default: () => ({})
+    },
+    label: {
+      type: String,
+      required: true
+    },
+    value: {
+      type: String,
+      required: true
+    },
+    rightLabel: {
+      type: String,
+      default: ''
+    }
+  },
+  methods: {
+    // 核心：点击选项时，向上传递选中值
+    handleItemClick() {
+      const selectedValue = this.source[this.value];
+      // 触发自定义事件，将选中值传递给父组件
+      this.$emit('item-click', selectedValue);
+    }
+  }
+});
+;// ./src/elementConfig/ui-virtual-select/itemComponent.vue?vue&type=script&lang=js
+ /* harmony default export */ var ui_virtual_select_itemComponentvue_type_script_lang_js = (itemComponentvue_type_script_lang_js); 
+;// ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-54.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-54.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-54.use[2]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/itemComponent.vue?vue&type=style&index=0&id=68d8f45e&prod&scoped=true&lang=css
+// extracted by mini-css-extract-plugin
+
+;// ./src/elementConfig/ui-virtual-select/itemComponent.vue?vue&type=style&index=0&id=68d8f45e&prod&scoped=true&lang=css
+
+;// ./src/elementConfig/ui-virtual-select/itemComponent.vue
+
+
+
+;
+
+
+/* normalize component */
+
+var itemComponent_component = normalizeComponent(
+  ui_virtual_select_itemComponentvue_type_script_lang_js,
+  itemComponentvue_type_template_id_68d8f45e_scoped_true_render,
+  itemComponentvue_type_template_id_68d8f45e_scoped_true_staticRenderFns,
+  false,
+  null,
+  "68d8f45e",
+  null
+  
+)
+
+/* harmony default export */ var itemComponent = (itemComponent_component.exports);
+;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-82.use[1]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/index.vue?vue&type=script&lang=js
+
+
+
+
+
+
+/* harmony default export */ var ui_virtual_selectvue_type_script_lang_js = ({
+  name: 'UiVirtualSelect',
+  components: {
+    VueVirtualScrollList: (dist_default())
+  },
+  props: {
+    options: {
+      type: Array,
+      default: () => []
+    },
+    fields: {
+      type: Object,
+      default: () => ({
+        label: 'label',
+        value: 'value'
+      })
+    },
+    value: {
+      type: [String, Array],
+      default: () => []
+    } // 接收父组件v-model传递的值
+  },
+  data() {
+    return {
+      filteredData: [...this.options],
+      maxItemWidth: 0,
+      itemComponent: itemComponent,
+      innerValue: [...this.value] // 内部维护选中值，避免直接修改props
+    };
+  },
+  watch: {
+    // 监听父组件v-model值变化，同步更新内部选中值
+    value: {
+      deep: true,
+      immediate: true,
+      handler(newVal) {
+        this.innerValue = Array.isArray(newVal) ? [...newVal] : newVal;
+      }
+    },
+    options: {
+      deep: true,
+      handler() {
+        this.filteredData = [...this.options];
+        this.calcMaxItemWidth();
+      }
+    }
+  },
+  mounted() {
+    this.calcMaxItemWidth();
+  },
+  methods: {
+    calcMaxItemWidth() {
+      if (!this.options.length) return;
+      const temp = document.createElement('div');
+      temp.style.cssText = `
+          position: absolute;
+          top: -9999px;
+          left: -9999px;
+          white-space: nowrap;
+          padding: 0 20px;
+          font-size: 14px;
+          box-sizing: border-box;
+        `;
+      document.body.appendChild(temp);
+      let maxWidth = 0;
+      this.options.forEach(item => {
+        const label = item[this.fields.label] || '';
+        const rightLabel = item[this.fields.rightLabel] || '';
+        temp.innerHTML = `<span>${label}</span><span style="margin-left:10px;color:#939393">${rightLabel}</span>`;
+        maxWidth = Math.max(maxWidth, temp.offsetWidth);
+      });
+      this.maxItemWidth = maxWidth + 6;
+      document.body.removeChild(temp);
+      this.setPopperWidth();
+    },
+    setPopperWidth() {
+      const popper = document.querySelector('.virtual-select-popper');
+      if (popper) {
+        popper.style.width = `${this.maxItemWidth}px`;
+        popper.style.minWidth = 'unset';
+        popper.style.maxWidth = 'unset';
+      }
+    },
+    filterMethod(query) {
+      this.filteredData = query ? this.options.filter(item => {
+        const labelMatch = item[this.fields.label].toLowerCase().includes(query.toLowerCase());
+        const rightLabelMatch = this.fields.rightLabel ? item[this.fields.rightLabel].toLowerCase().includes(query.toLowerCase()) : false;
+        return labelMatch || rightLabelMatch;
+      }) : [...this.options];
+      this.$nextTick(() => this.$refs.virtualList?.scrollToIndex(0));
+    },
+    handleVisibleChange(visible) {
+      if (visible) {
+        this.$nextTick(() => {
+          this.setPopperWidth();
+        });
+      } else {
+        this.$refs.virtualList?.reset();
+      }
+    },
+    // 核心：接收子组件选中值，更新内部状态并通知el-select
+    handleItemClick(selectedValue) {
+      const isMultiple = this.$attrs.multiple; // 判断是否为多选模式
+
+      if (isMultiple) {
+        // 多选：切换选中状态（存在则移除，不存在则添加）
+        const valueIndex = this.innerValue.findIndex(val => val === selectedValue);
+        if (valueIndex > -1) {
+          this.innerValue.splice(valueIndex, 1);
+        } else {
+          this.innerValue.push(selectedValue);
+        }
+      } else {
+        // 单选：直接赋值，并关闭下拉面板
+        this.innerValue = selectedValue;
+        this.$refs.elSelectRef.visible = false; // 手动关闭下拉
+      }
+
+      // 手动触发el-select的change事件，同步更新状态
+      this.$refs.elSelectRef.$emit('change', isMultiple ? [...this.innerValue] : this.innerValue);
+    },
+    // 监听el-select原生change事件，向父组件传递更新后的值（支持v-model）
+    handleSelectChange(val) {
+      this.$emit('input', val); // v-model的核心：触发input事件更新绑定值
+      this.$emit('change', val); // 保留原有change事件，兼容手动监听
+    }
+  }
+});
+;// ./src/elementConfig/ui-virtual-select/index.vue?vue&type=script&lang=js
+ /* harmony default export */ var elementConfig_ui_virtual_selectvue_type_script_lang_js = (ui_virtual_selectvue_type_script_lang_js); 
+;// ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-54.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-54.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-54.use[2]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/elementConfig/ui-virtual-select/index.vue?vue&type=style&index=0&id=4776e956&prod&scoped=true&lang=css
+// extracted by mini-css-extract-plugin
+
+;// ./src/elementConfig/ui-virtual-select/index.vue?vue&type=style&index=0&id=4776e956&prod&scoped=true&lang=css
+
+;// ./src/elementConfig/ui-virtual-select/index.vue
+
+
+
+;
+
+
+/* normalize component */
+
+var ui_virtual_select_component = normalizeComponent(
+  elementConfig_ui_virtual_selectvue_type_script_lang_js,
+  ui_virtual_selectvue_type_template_id_4776e956_scoped_true_render,
+  ui_virtual_selectvue_type_template_id_4776e956_scoped_true_staticRenderFns,
+  false,
+  null,
+  "4776e956",
+  null
+  
+)
+
+/* harmony default export */ var ui_virtual_select = (ui_virtual_select_component.exports);
 ;// ./src/elementConfig/index.js
 
 
 
 
 
-const components = [ui_form, ui_table, ui_btns, business_status, ui_dialog];
+
+const components = [ui_form, ui_table, ui_btns, business_status, ui_dialog, ui_virtual_select];
 const install = function (Vue) {
   components.forEach(component => {
     Vue.component(component.name, component);