@dialpad/dialtone 9.70.1 → 9.71.0-beta.2

package/dist/vue3/lib/scroller.cjs

@@ -1,1091 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-const _pluginVue_exportHelper = require("../chunks/_plugin-vue_export-helper-fhnQq0tA.js");
-const _sfc_main$3 = {
-  __name: "core_scroller",
-  props: {
-    /**
-       * List of items you want to display in the scroller.
-       */
-    items: {
-      type: Array,
-      required: true
-    },
-    /**
-       *
-       * Field used to identify items and optimize managing rendered views
-       */
-    keyField: {
-      type: String,
-      default: "id"
-    },
-    /**
-       * Direction of the scroller. Can be either `vertical` or `horizontal`.
-       */
-    direction: {
-      type: String,
-      default: "vertical",
-      validator: (value) => ["vertical", "horizontal"].includes(value)
-    },
-    /**
-       * Size of the items in the list.
-       * If it is set to null (the default value), it will use variable size mode.
-       */
-    itemSize: {
-      type: Number,
-      default: null
-    },
-    /**
-       * Minimum size used if the height (or width in horizontal mode) of an item is unknown.
-       */
-    minItemSize: {
-      type: [Number, String],
-      default: null
-    },
-    /**
-       * Field used to get the item's size in variable size mode.
-       */
-    sizeField: {
-      type: String,
-      default: "size"
-    },
-    /**
-       * Amount of pixel to add to edges of the scrolling visible area to start rendering items further away.
-       */
-    buffer: {
-      type: Number,
-      default: 200
-    },
-    /**
-       * If true, the hover state will be skipped.
-       * This can be useful if you want to use the hover state for other purposes.
-       */
-    skipHover: {
-      type: Boolean,
-      default: false
-    },
-    /**
-       * The element to render as the list's wrapper.
-       */
-    listTag: {
-      type: String,
-      default: "div"
-    },
-    /**
-       * The element to render as the list item.
-       */
-    itemTag: {
-      type: String,
-      default: "div"
-    },
-    /**
-       * The custom classes added to the item list wrapper.
-       */
-    listClass: {
-      type: [String, Object, Array],
-      default: ""
-    },
-    /**
-       * The custom classes added to each item.
-       */
-    itemClass: {
-      type: [String, Object, Array],
-      default: ""
-    }
-  },
-  emits: ["user-position"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    const views = vue.reactive(/* @__PURE__ */ new Map());
-    const unusedViews = vue.reactive(/* @__PURE__ */ new Map());
-    const pool = vue.ref([]);
-    const hoverKey = vue.ref(null);
-    const ready = vue.ref(false);
-    const scroller = vue.ref(null);
-    const userPosition = vue.ref("top");
-    let endIndex = 0;
-    let scrollDirty = false;
-    let lastUpdateScrollPosition = 0;
-    let sortTimer = null;
-    let computedMinItemSize = null;
-    let totalSize = 0;
-    let uid = 0;
-    const sizes = vue.computed(() => {
-      if (props.itemSize === null) {
-        const sizes2 = {
-          "-1": { accumulator: 0 }
-        };
-        const items = props.items;
-        const field = props.sizeField;
-        const minItemSize = props.minItemSize;
-        let computedMinSize = 1e4;
-        let accumulator = 0;
-        let current;
-        for (let i = 0, l = items.length; i < l; i++) {
-          current = items[i][field] || minItemSize;
-          if (current < computedMinSize) {
-            computedMinSize = current;
-          }
-          accumulator += current;
-          sizes2[i] = { accumulator, size: current };
-        }
-        computedMinItemSize = computedMinSize;
-        return sizes2;
-      }
-      return [];
-    });
-    const simpleArray = vue.computed(() => {
-      return props.items.length && typeof props.items[0] !== "object";
-    });
-    const itemIndexByKey = vue.computed(() => {
-      const result = {};
-      for (let i = 0, l = props.items.length; i < l; i++) {
-        result[props.items[i][props.keyField]] = i;
-      }
-      return result;
-    });
-    vue.watch(sizes, () => {
-      _updateVisibleItems(false);
-    }, { deep: true });
-    vue.onMounted(() => {
-      vue.nextTick(() => {
-        _updateVisibleItems(true);
-        ready.value = true;
-      });
-    });
-    const _addView = (pool2, index, item, key, type) => {
-      const nr = vue.markRaw({
-        id: uid++,
-        index,
-        used: true,
-        key,
-        type
-      });
-      const view = vue.shallowReactive({
-        item,
-        position: 0,
-        nr
-      });
-      pool2.value.push(view);
-      return view;
-    };
-    const _unuseView = (view, fake = false) => {
-      const _unusedViews = unusedViews;
-      const type = view.nr.type;
-      let unusedPool = _unusedViews.get(type);
-      if (!unusedPool) {
-        unusedPool = [];
-        _unusedViews.set(type, unusedPool);
-      }
-      unusedPool.push(view);
-      if (!fake) {
-        view.nr.used = false;
-        view.position = -9999;
-      }
-    };
-    const _getScroll = () => {
-      const isVertical = props.direction === "vertical";
-      let scrollState;
-      if (isVertical) {
-        scrollState = {
-          start: scroller.value.scrollTop,
-          end: scroller.value.scrollTop + scroller.value.clientHeight
-        };
-      } else {
-        scrollState = {
-          start: scroller.value.scrollLeft,
-          end: scroller.value.scrollLeft + scroller.value.clientWidth
-        };
-      }
-      return scrollState;
-    };
-    const _itemsLimitError = () => {
-      setTimeout(() => {
-        console.error("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", scroller);
-        console.error("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.");
-      });
-      throw new Error("Rendered items limit reached");
-    };
-    const _sortViews = () => {
-      pool.value.sort((viewA, viewB) => viewA.nr.index - viewB.nr.index);
-    };
-    const _updateVisibleItems = (checkItem, checkPositionDiff = false) => {
-      var _a, _b, _c, _d, _e, _f;
-      const itemSize = props.itemSize;
-      const minItemSize = computedMinItemSize;
-      const keyField = simpleArray.value ? null : props.keyField;
-      const items = props.items;
-      const count = items.length;
-      const _sizes = sizes.value;
-      const _views = views;
-      const _unusedViews = unusedViews;
-      const _pool = pool;
-      const _itemIndexByKey = itemIndexByKey;
-      let _startIndex, _endIndex;
-      let _totalSize;
-      if (!count) {
-        _startIndex = _endIndex = _totalSize = 0;
-      } else {
-        const scroll = _getScroll();
-        if (checkPositionDiff) {
-          let positionDiff = scroll.start - lastUpdateScrollPosition.value;
-          if (positionDiff < 0)
-            positionDiff = -positionDiff;
-          if (itemSize === null && positionDiff < minItemSize.value || positionDiff < itemSize) {
-            return {
-              continuous: true
-            };
-          }
-        }
-        lastUpdateScrollPosition = scroll.start;
-        const _buffer = props.buffer;
-        scroll.start -= _buffer;
-        scroll.end += _buffer;
-        if (itemSize === null) {
-          let h;
-          let a = 0;
-          let b = count - 1;
-          let i = ~~(count / 2);
-          let oldI;
-          do {
-            oldI = i;
-            h = (_a = _sizes[i]) == null ? void 0 : _a.accumulator;
-            if (h < scroll.start) {
-              a = i;
-            } else if (i < count - 1 && ((_b = _sizes[i + 1]) == null ? void 0 : _b.accumulator) > scroll.start) {
-              b = i;
-            }
-            i = ~~((a + b) / 2);
-          } while (i !== oldI);
-          i < 0 && (i = 0);
-          _startIndex = i;
-          _totalSize = (_c = _sizes[count - 1]) == null ? void 0 : _c.accumulator;
-          for (_endIndex = i; _endIndex < count && ((_d = _sizes[_endIndex]) == null ? void 0 : _d.accumulator) < scroll.end; _endIndex++)
-            ;
-          if (_endIndex === -1) {
-            _endIndex = items.length - 1;
-          } else {
-            _endIndex++;
-            _endIndex > count && (_endIndex = count);
-          }
-        } else {
-          _startIndex = ~~(scroll.start / itemSize);
-          const remainer = _startIndex % 1;
-          _startIndex -= remainer;
-          _endIndex = Math.ceil(scroll.end / itemSize);
-          _startIndex < 0 && (_startIndex = 0);
-          _endIndex > count && (_endIndex = count);
-          _totalSize = Math.ceil(count / 1) * itemSize;
-        }
-      }
-      if (_endIndex - _startIndex > 1e3) {
-        _itemsLimitError();
-      }
-      totalSize = _totalSize;
-      let view;
-      const continuous = _startIndex <= endIndex && _endIndex >= _startIndex;
-      if (continuous) {
-        for (let i = 0, l = _pool.value.length; i < l; i++) {
-          view = _pool.value[i];
-          if (view == null ? void 0 : view.nr.used) {
-            if (checkItem) {
-              view.nr.index = _itemIndexByKey[view.item[keyField]];
-            }
-            if (view.nr.index == null || view.nr.index < _startIndex || view.nr.index >= _endIndex) {
-              _unuseView(view);
-            }
-          }
-        }
-      }
-      const unusedIndex = continuous ? null : /* @__PURE__ */ new Map();
-      let item, type;
-      let v;
-      for (let i = _startIndex; i < _endIndex; i++) {
-        item = items[i];
-        const key = keyField ? item == null ? void 0 : item[keyField] : item;
-        if (key == null) {
-          throw new Error(`Key is ${key} on item (keyField is '${keyField}')`);
-        }
-        view = _views.get(key);
-        if (!itemSize && !((_e = _sizes[i]) == null ? void 0 : _e.size)) {
-          if (view)
-            _unuseView(view);
-          continue;
-        }
-        type = item.type;
-        let unusedPool = _unusedViews.get(type);
-        if (!view) {
-          if (continuous) {
-            if (unusedPool && unusedPool.length) {
-              view = unusedPool.pop();
-            } else {
-              view = _addView(_pool, i, item, key, type);
-            }
-          } else {
-            v = unusedIndex.get(type) || 0;
-            if (!unusedPool || v >= unusedPool.length) {
-              view = _addView(_pool, i, item, key, type);
-              _unuseView(view, true);
-              unusedPool = _unusedViews.get(type);
-            }
-            view = unusedPool[v];
-            unusedIndex.set(type, v + 1);
-          }
-          _views.delete(view.nr.key);
-          view.nr.used = true;
-          view.nr.index = i;
-          view.nr.key = key;
-          view.nr.type = type;
-          _views.set(key, view);
-        } else {
-          if (!view.nr.used) {
-            view.nr.used = true;
-            if (unusedPool) {
-              const index = unusedPool.indexOf(view);
-              if (index !== -1)
-                unusedPool.splice(index, 1);
-            }
-          }
-        }
-        view.item = item;
-        if (itemSize === null) {
-          view.position = (_f = _sizes[i - 1]) == null ? void 0 : _f.accumulator;
-          view.offset = 0;
-        } else {
-          view.position = Math.floor(i) * itemSize;
-          view.offset = i % 1 * itemSize;
-        }
-      }
-      endIndex = _endIndex;
-      clearTimeout(sortTimer);
-      sortTimer = setTimeout(_sortViews, 300);
-      return {
-        continuous
-      };
-    };
-    const _scrollToPosition = (position) => {
-      const direction = props.direction === "vertical" ? { scroll: "scrollTop", start: "top" } : { scroll: "scrollLeft", start: "left" };
-      const viewport = scroller.value;
-      const scrollDirection = direction.scroll;
-      viewport[scrollDirection] = position;
-    };
-    const scrollToItem = (index) => {
-      var _a;
-      let scroll;
-      if (props.itemSize === null) {
-        scroll = index > 0 ? (_a = sizes.value[index - 1]) == null ? void 0 : _a.accumulator : 0;
-      } else {
-        scroll = Math.floor(index) * props.itemSize;
-      }
-      _scrollToPosition(scroll);
-    };
-    const handleScroll = () => {
-      const container = scroller.value;
-      if (userPosition.value !== "middle") {
-        userPosition.value = "middle";
-        emit("user-position", "middle");
-      }
-      if (container.scrollTop === 0) {
-        userPosition.value = "top";
-        emit("user-position", "top");
-      }
-      if (container.scrollTop + container.clientHeight === container.scrollHeight) {
-        userPosition.value = "bottom";
-        emit("user-position", "bottom");
-      }
-      if (!scrollDirty) {
-        scrollDirty = true;
-        const requestUpdate = () => requestAnimationFrame(() => {
-          scrollDirty = false;
-          _updateVisibleItems(false, true);
-        });
-        requestUpdate();
-      }
-    };
-    __expose({
-      scrollToItem,
-      _updateVisibleItems
-    });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
-        ref_key: "scroller",
-        ref: scroller,
-        class: vue.normalizeClass(["vue-recycle-scroller", {
-          ready: ready.value,
-          [`direction-${__props.direction}`]: true
-        }]),
-        onScrollPassive: handleScroll
-      }, [
-        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.listTag), {
-          ref: "wrapper",
-          style: vue.normalizeStyle({ [__props.direction === "vertical" ? "minHeight" : "minWidth"]: `${vue.unref(totalSize)}px` }),
-          class: vue.normalizeClass(["vue-recycle-scroller__item-wrapper", __props.listClass])
-        }, {
-          default: vue.withCtx(() => [
-            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(pool.value, (view) => {
-              return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.itemTag), vue.mergeProps({
-                key: view.nr.id,
-                style: ready.value ? {
-                  transform: `translate${__props.direction === "vertical" ? "Y" : "X"}(${view.position}px) translate${__props.direction === "vertical" ? "X" : "Y"}(${view.offset}px)`,
-                  width: void 0,
-                  height: void 0
-                } : null,
-                class: ["vue-recycle-scroller__item-view", [
-                  __props.itemClass,
-                  {
-                    hover: !__props.skipHover && hoverKey.value === view.nr.key
-                  }
-                ]]
-              }, vue.toHandlers(__props.skipHover ? {} : {
-                mouseenter: () => {
-                  hoverKey.value = view.nr.key;
-                },
-                mouseleave: () => {
-                  hoverKey.value = null;
-                }
-              })), {
-                default: vue.withCtx(() => [
-                  vue.renderSlot(_ctx.$slots, "default", {
-                    item: view.item,
-                    index: view.nr.index,
-                    active: view.nr.used
-                  })
-                ]),
-                _: 2
-              }, 1040, ["style", "class"]);
-            }), 128))
-          ]),
-          _: 3
-        }, 8, ["style", "class"]))
-      ], 34);
-    };
-  }
-};
-const _sfc_main$2 = {
-  name: "DtScrollerItem",
-  inject: [
-    "vscrollData",
-    "vscrollParent",
-    "vscrollResizeObserver"
-  ],
-  props: {
-    // eslint-disable-next-line vue/require-prop-types
-    item: {
-      required: true
-    },
-    watchData: {
-      type: Boolean,
-      default: false
-    },
-    /**
-     * Indicates if the view is actively used to display an item.
-     */
-    active: {
-      type: Boolean,
-      required: true
-    },
-    index: {
-      type: Number,
-      default: void 0
-    },
-    sizeDependencies: {
-      type: [Array, Object],
-      default: null
-    },
-    tag: {
-      type: String,
-      default: "div"
-    }
-  },
-  computed: {
-    id() {
-      if (this.vscrollData.simpleArray)
-        return this.index;
-      if (this.vscrollData.keyField in this.item)
-        return this.item[this.vscrollData.keyField];
-      throw new Error(`keyField '${this.vscrollData.keyField}' not found in your item. You should set a valid keyField prop on your Scroller`);
-    },
-    size() {
-      return this.vscrollData.sizes[this.id] || 0;
-    },
-    finalActive() {
-      return this.active && this.vscrollData.active;
-    }
-  },
-  watch: {
-    watchData: "updateWatchData",
-    id(value, oldValue) {
-      this.$el.$_vs_id = this.id;
-      if (!this.size) {
-        this.onDataUpdate();
-      }
-      if (this.$_sizeObserved) {
-        const oldSize = this.vscrollData.sizes[oldValue];
-        const size = this.vscrollData.sizes[value];
-        if (oldSize != null && oldSize !== size) {
-          this.applySize(oldSize);
-        }
-      }
-    },
-    finalActive(value) {
-      if (!this.size) {
-        if (value) {
-          if (!this.vscrollParent.$_undefinedMap[this.id]) {
-            this.vscrollParent.$_undefinedSizes++;
-            this.vscrollParent.$_undefinedMap[this.id] = true;
-          }
-        } else {
-          if (this.vscrollParent.$_undefinedMap[this.id]) {
-            this.vscrollParent.$_undefinedSizes--;
-            this.vscrollParent.$_undefinedMap[this.id] = false;
-          }
-        }
-      }
-      if (this.vscrollResizeObserver) {
-        if (value) {
-          this.observeSize();
-        } else {
-          this.unobserveSize();
-        }
-      } else if (value && this.$_pendingVScrollUpdate === this.id) {
-        this.updateSize();
-      }
-    }
-  },
-  created() {
-    if (this.$isServer)
-      return;
-    this.$_forceNextVScrollUpdate = null;
-    this.updateWatchData();
-    if (!this.vscrollResizeObserver) {
-      for (const k in this.sizeDependencies) {
-        this.$watch(() => this.sizeDependencies[k], this.onDataUpdate);
-      }
-    }
-  },
-  mounted() {
-    if (this.finalActive) {
-      this.updateSize();
-      this.observeSize();
-    }
-  },
-  beforeUnmount() {
-    this.unobserveSize();
-  },
-  methods: {
-    updateSize() {
-      if (this.finalActive) {
-        if (this.$_pendingSizeUpdate !== this.id) {
-          this.$_pendingSizeUpdate = this.id;
-          this.$_forceNextVScrollUpdate = null;
-          this.$_pendingVScrollUpdate = null;
-          this.computeSize(this.id);
-        }
-      } else {
-        this.$_forceNextVScrollUpdate = this.id;
-      }
-    },
-    updateWatchData() {
-      if (this.watchData && !this.vscrollResizeObserver) {
-        this.$_watchData = this.$watch("item", () => {
-          this.onDataUpdate();
-        }, {
-          deep: true
-        });
-      } else if (this.$_watchData) {
-        this.$_watchData();
-        this.$_watchData = null;
-      }
-    },
-    onVscrollUpdate({ force }) {
-      if (!this.finalActive && force) {
-        this.$_pendingVScrollUpdate = this.id;
-      }
-      if (this.$_forceNextVScrollUpdate === this.id || force || !this.size) {
-        this.updateSize();
-      }
-    },
-    onDataUpdate() {
-      this.updateSize();
-    },
-    computeSize(id) {
-      this.$nextTick(() => {
-        if (this.id === id) {
-          const width = this.$el.offsetWidth;
-          const height = this.$el.offsetHeight;
-          this.applyWidthHeight(width, height);
-        }
-        this.$_pendingSizeUpdate = null;
-      });
-    },
-    applyWidthHeight(width, height) {
-      const size = ~~(this.vscrollParent.direction === "vertical" ? height : width);
-      if (size && this.size !== size) {
-        this.applySize(size);
-      }
-    },
-    applySize(size) {
-      if (this.vscrollParent.$_undefinedMap[this.id]) {
-        this.vscrollParent.$_undefinedSizes--;
-        this.vscrollParent.$_undefinedMap[this.id] = void 0;
-      }
-      this.vscrollData.sizes[this.id] = size;
-    },
-    observeSize() {
-      if (!this.vscrollResizeObserver)
-        return;
-      if (this.$_sizeObserved)
-        return;
-      this.vscrollResizeObserver.observe(this.$el);
-      this.$el.$_vs_id = this.id;
-      this.$el.$_vs_onResize = this.onResize;
-      this.$_sizeObserved = true;
-    },
-    unobserveSize() {
-      if (!this.vscrollResizeObserver)
-        return;
-      if (!this.$_sizeObserved)
-        return;
-      this.vscrollResizeObserver.unobserve(this.$el);
-      this.$el.$_vs_onResize = void 0;
-      this.$_sizeObserved = false;
-    },
-    onResize(id, width, height) {
-      if (this.id === id) {
-        this.applyWidthHeight(width, height);
-      }
-    }
-  },
-  render() {
-    return vue.h(this.tag, this.$slots.default());
-  }
-};
-const _sfc_main$1 = {
-  name: "DynamicScroller",
-  components: {
-    CoreScroller: _sfc_main$3,
-    DtScrollerItem: _sfc_main$2
-  },
-  provide() {
-    if (typeof ResizeObserver !== "undefined") {
-      this.$_resizeObserver = new ResizeObserver((entries) => {
-        requestAnimationFrame(() => {
-          if (!Array.isArray(entries)) {
-            return;
-          }
-          for (const entry of entries) {
-            if (entry.target && entry.target.$_vs_onResize) {
-              let width, height;
-              if (entry.borderBoxSize) {
-                const resizeObserverSize = entry.borderBoxSize[0];
-                width = resizeObserverSize.inlineSize;
-                height = resizeObserverSize.blockSize;
-              } else {
-                width = entry.contentRect.width;
-                height = entry.contentRect.height;
-              }
-              entry.target.$_vs_onResize(entry.target.$_vs_id, width, height);
-            }
-          }
-        });
-      });
-    }
-    return {
-      vscrollData: this.vscrollData,
-      vscrollParent: this,
-      vscrollResizeObserver: this.$_resizeObserver
-    };
-  },
-  inheritAttrs: false,
-  props: {
-    /*
-      * The items to render.
-      * If the items are simple arrays, the index will be used as the key.
-      * If the items are objects, the keyField will be used as the key.
-     */
-    items: {
-      type: Array,
-      required: true
-    },
-    /*
-      * Indicates if the items are dynamic.
-      * If true, the items will be wrapped in a DtScrollerItem component.
-      * This is required for dynamic items to be able to react to changes in their size.
-     */
-    dynamic: {
-      type: Boolean,
-      default: false
-    },
-    /*
-      * The key field to use for the items.
-      * Only used if the items are objects.
-     */
-    keyField: {
-      type: String,
-      default: "id"
-    },
-    /*
-      * The direction of the scroller.
-      * Can be either 'vertical' or 'horizontal'.
-     */
-    direction: {
-      type: String,
-      default: "vertical",
-      validator: (value) => ["vertical", "horizontal"].includes(value)
-    },
-    /*
-      * The tag to use for the list.
-     */
-    listTag: {
-      type: String,
-      default: "div"
-    },
-    /*
-      * The tag to use for the items.
-     */
-    itemTag: {
-      type: String,
-      default: "div"
-    },
-    /*
-      * Display height (or width in horizontal mode) of the items in pixels
-      * used to calculate the scroll size and position.
-      * Is required for the initial render of items in DYNAMIC size mode.
-     */
-    minItemSize: {
-      type: [Number, String]
-    }
-  },
-  data() {
-    return {
-      vscrollData: {
-        active: true,
-        sizes: {},
-        keyField: this.keyField,
-        simpleArray: false
-      }
-    };
-  },
-  computed: {
-    simpleArray() {
-      return this.items.length && typeof this.items[0] !== "object";
-    },
-    itemsWithSize() {
-      const result = [];
-      const { items, keyField, simpleArray } = this;
-      const sizes = this.vscrollData.sizes;
-      const l = items.length;
-      for (let i = 0; i < l; i++) {
-        const item = items[i];
-        const id = simpleArray ? i : item[keyField];
-        let size = sizes[id];
-        if (typeof size === "undefined" && !this.$_undefinedMap[id]) {
-          size = 0;
-        }
-        result.push({
-          item,
-          [keyField]: id,
-          size
-        });
-      }
-      return result;
-    }
-  },
-  watch: {
-    simpleArray: {
-      handler(value) {
-        this.vscrollData.simpleArray = value;
-      },
-      immediate: true
-    },
-    itemsWithSize(next, prev) {
-      const scrollTop = this.$el.scrollTop;
-      let prevActiveTop = 0;
-      let activeTop = 0;
-      const length = Math.min(next.length, prev.length);
-      for (let i = 0; i < length; i++) {
-        if (prevActiveTop >= scrollTop) {
-          break;
-        }
-        prevActiveTop += prev[i].size || this.minItemSize;
-        activeTop += next[i].size || this.minItemSize;
-      }
-      const offset = activeTop - prevActiveTop;
-      if (offset === 0) {
-        return;
-      }
-      this.$el.scrollTop += offset;
-    }
-  },
-  beforeCreate() {
-    this.$_updates = [];
-    this.$_undefinedSizes = 0;
-    this.$_undefinedMap = {};
-  },
-  activated() {
-    this.vscrollData.active = true;
-  },
-  deactivated() {
-    this.vscrollData.active = false;
-  },
-  methods: {
-    dynamicScrollerUpdateItems() {
-      const scroller = this.$refs.scroller;
-      if (scroller)
-        scroller._updateVisibleItems(true);
-    },
-    dynamicScrollerUpdateItemsFromBottom() {
-      const scroller = this.$refs.scroller;
-      if (scroller)
-        scroller._updateVisibleItems(false, true);
-    },
-    scrollToItem(index) {
-      const scroller = this.$refs.scroller;
-      if (scroller)
-        scroller.scrollToItem(index);
-    },
-    scrollToBottom() {
-      if (this.$_scrollingToBottom)
-        return;
-      this.$_scrollingToBottom = true;
-      const el = this.$el;
-      this.$nextTick(() => {
-        el.scrollTop = el.scrollHeight + 5e3;
-        const cb = () => {
-          el.scrollTop = el.scrollHeight + 5e3;
-          requestAnimationFrame(() => {
-            el.scrollTop = el.scrollHeight + 5e3;
-            if (this.$_undefinedSizes === 0) {
-              this.$_scrollingToBottom = false;
-            } else {
-              requestAnimationFrame(cb);
-            }
-          });
-        };
-        requestAnimationFrame(cb);
-      });
-    }
-  }
-};
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_dt_scroller_item = vue.resolveComponent("dt-scroller-item");
-  const _component_core_scroller = vue.resolveComponent("core-scroller");
-  return vue.openBlock(), vue.createBlock(_component_core_scroller, vue.mergeProps({
-    ref: "scroller",
-    items: $options.itemsWithSize,
-    "min-item-size": $props.minItemSize,
-    direction: $props.direction,
-    "key-field": $props.keyField,
-    "list-tag": $props.listTag,
-    "item-tag": $props.itemTag
-  }, _ctx.$attrs), {
-    default: vue.withCtx(({ item: itemWithSize, index, active }) => [
-      vue.createVNode(_component_dt_scroller_item, {
-        item: itemWithSize,
-        active,
-        "size-dependencies": [
-          itemWithSize.message
-        ],
-        "data-index": index
-      }, {
-        default: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps({
-            item: itemWithSize.item,
-            index,
-            active,
-            itemWithSize
-          })))
-        ]),
-        _: 2
-      }, 1032, ["item", "active", "size-dependencies", "data-index"])
-    ]),
-    _: 3
-  }, 16, ["items", "min-item-size", "direction", "key-field", "list-tag", "item-tag"]);
-}
-const DynamicScroller = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$1, [["render", _sfc_render]]);
-const _sfc_main = {
-  __name: "DtScroller",
-  props: {
-    /**
-        * The direction of the scroller.
-        * @values vertical, horizontal
-       */
-    direction: {
-      type: String,
-      default: "vertical",
-      validator: (value) => ["vertical", "horizontal"].includes(value)
-    },
-    /**
-       * Indicates if the items need to react to changes in their size.
-       * If disabled the itemSize prop is required and you will get improved performance.
-       * If enabled the minItemSize prop is required and you
-       * will have reduced performance but the ability to reactively size list items
-        * @values true, false
-       */
-    dynamic: {
-      type: Boolean,
-      default: false
-    },
-    /**
-        * Display height (or width in horizontal mode) of the items in pixels
-        * used to calculate the scroll size and position.
-       *  Required if DYNAMIC is false
-       */
-    itemSize: {
-      type: Number,
-      default: null
-    },
-    /**
-        * The tag to use for the items.
-       */
-    itemTag: {
-      type: String,
-      default: "div"
-    },
-    /**
-        * The items to render.
-        * If the items are simple arrays, the index will be used as the key.
-        * If the items are objects, the keyField will be used as the key.
-       * @example items: [ 'item1', 'item2', 'item3' ]
-       * @example items: [ { id: 1, name: 'item1' }, { id: 2, name: 'item2' }, { id: 3, name: 'item3' } ]
-       */
-    items: {
-      type: Array,
-      required: true
-    },
-    /**
-        * The key field to use for the items.
-        * If the items are objects, the scroller needs to be able to identify them.
-        * By default it will look for an id field on the items.
-        * This can be configured with this prop if you are using another field name.
-       */
-    keyField: {
-      type: String,
-      default: "id"
-    },
-    /**
-        * The tag to use for the list.
-       */
-    listTag: {
-      type: String,
-      default: "div"
-    },
-    /**
-        * Minimum size used if the height (or width in horizontal mode) of a item is unknown.
-        * Is required for the initial render of items in DYNAMIC size mode.
-       */
-    minItemSize: {
-      type: [Number, String],
-      default: null
-    },
-    /**
-        * The height of the scroller.
-        * Can be a number (in pixels) or a string (in CSS units).
-       */
-    scrollerHeight: {
-      type: [String, Number],
-      default: "100%"
-    },
-    /**
-      * The width of the scroller.
-      * Can be a number (in pixels) or a string (in CSS units).
-      */
-    scrollerWidth: {
-      type: [String, Number],
-      default: "100%"
-    }
-  },
-  emits: [
-    /**
-     * Describe when the scroller changes from start/middle/end
-     * @param {string} position The position of the scroller.
-     * @values start, middle, end
-     */
-    "user-position"
-  ],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    vue.provide("emit", emits);
-    const scroller = vue.ref(null);
-    const computedStyle = vue.computed(() => {
-      return {
-        width: typeof props.scrollerWidth === "number" ? `${props.scrollerWidth}px` : props.scrollerWidth,
-        height: typeof props.scrollerHeight === "number" ? `${props.scrollerHeight}px` : props.scrollerHeight
-      };
-    });
-    vue.watch(props, () => {
-      validateProps();
-    }, { deep: true, immediate: true });
-    function scrollToBottom() {
-      if (scroller.value)
-        scroller.value.scrollToBottom();
-    }
-    function scrollToItem(index) {
-      if (scroller.value)
-        scroller.value.scrollToItem(index);
-    }
-    function updateItems() {
-      if (!scroller.value)
-        return;
-      if (props.dynamic) {
-        scroller.value.dynamicScrollerUpdateItems();
-      } else {
-        scroller.value._updateVisibleItems(true);
-      }
-    }
-    function updateItemsFromBottom() {
-      if (!scroller.value)
-        return;
-      if (props.dynamic) {
-        scroller.value.dynamicScrollerUpdateItemsFromBottom();
-      } else {
-        scroller.value._updateVisibleItems(false, true);
-      }
-    }
-    function validateProps() {
-      if (props.dynamic && !props.minItemSize) {
-        console.error("scroller error: 'minItemSize' is required on 'dynamic' mode.");
-      }
-      if (!props.dynamic && !props.itemSize) {
-        console.error("scroller error: 'itemSize' is required.");
-      }
-    }
-    __expose({
-      scrollToBottom,
-      scrollToItem,
-      updateItems,
-      updateItemsFromBottom
-    });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.dynamic ? DynamicScroller : _sfc_main$3), {
-        ref_key: "scroller",
-        ref: scroller,
-        "data-qa": "dt-scroller",
-        items: __props.items,
-        "item-size": __props.itemSize,
-        "min-item-size": __props.minItemSize,
-        direction: __props.direction,
-        "key-field": __props.keyField,
-        "list-tag": __props.listTag,
-        "item-tag": __props.itemTag,
-        style: vue.normalizeStyle(computedStyle.value),
-        tabindex: "0",
-        onUserPosition: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("user-position", $event))
-      }, {
-        default: vue.withCtx(({ item, index, active }) => [
-          vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps({
-            item,
-            index,
-            active
-          })))
-        ]),
-        _: 3
-      }, 40, ["items", "item-size", "min-item-size", "direction", "key-field", "list-tag", "item-tag", "style"]);
-    };
-  }
-};
-exports.DtScroller = _sfc_main;
+const DtScroller = require("../components/scroller/DtScroller.vue.cjs");
+exports.DtScroller = DtScroller;
 //# sourceMappingURL=scroller.cjs.map