@dialpad/dialtone 9.71.0-beta.1 → 9.71.0

package/dist/vue3/components/scroller/DtScroller.vue.js

@@ -0,0 +1,186 @@
+import { provide, ref, computed, watch, openBlock, createBlock, resolveDynamicComponent, normalizeStyle, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import _sfc_main$2 from "./modules/core_scroller.vue.js";
+import DynamicScroller from "./modules/dynamic_scroller.vue.js";
+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;
+    provide("emit", emits);
+    const scroller = ref(null);
+    const computedStyle = computed(() => {
+      return {
+        width: typeof props.scrollerWidth === "number" ? `${props.scrollerWidth}px` : props.scrollerWidth,
+        height: typeof props.scrollerHeight === "number" ? `${props.scrollerHeight}px` : props.scrollerHeight
+      };
+    });
+    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 openBlock(), createBlock(resolveDynamicComponent(__props.dynamic ? DynamicScroller : _sfc_main$2), {
+        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: normalizeStyle(computedStyle.value),
+        tabindex: "0",
+        onUserPosition: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("user-position", $event))
+      }, {
+        default: withCtx(({ item, index, active }) => [
+          renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps({
+            item,
+            index,
+            active
+          })))
+        ]),
+        _: 3
+      }, 40, ["items", "item-size", "min-item-size", "direction", "key-field", "list-tag", "item-tag", "style"]);
+    };
+  }
+};
+const _sfc_main$1 = _sfc_main;
+export {
+  _sfc_main$1 as default
+};
+//# sourceMappingURL=DtScroller.vue.js.map

package/dist/vue3/components/scroller/DtScroller.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DtScroller.vue.js","sources":["../../../components/scroller/DtScroller.vue"],"sourcesContent":["<template>\n  <component\n    :is=\"dynamic ? DynamicScroller : CoreScroller\"\n    ref=\"scroller\"\n    data-qa=\"dt-scroller\"\n    :items=\"items\"\n    :item-size=\"itemSize\"\n    :min-item-size=\"minItemSize\"\n    :direction=\"direction\"\n    :key-field=\"keyField\"\n    :list-tag=\"listTag\"\n    :item-tag=\"itemTag\"\n    :style=\"computedStyle\"\n    tabindex=\"0\"\n    @user-position=\"$emit('user-position', $event)\"\n  >\n    <template\n      #default=\"{ item, index, active }\"\n    >\n      <slot\n        v-bind=\"{\n          item: item,\n          index,\n          active,\n        }\"\n      />\n    </template>\n  </component>\n</template>\n\n<script setup>\nimport CoreScroller from './modules/core_scroller.vue';\nimport DynamicScroller from './modules/dynamic_scroller.vue';\nimport { provide, computed, watch, ref } from 'vue';\n\nconst props = defineProps({\n  /**\n      * The direction of the scroller.\n      * @values vertical, horizontal\n     */\n  direction: {\n    type: String,\n    default: 'vertical',\n    validator: (value) => ['vertical', 'horizontal'].includes(value),\n  },\n\n  /**\n     * Indicates if the items need to react to changes in their size.\n     * If disabled the itemSize prop is required and you will get improved performance.\n     * If enabled the minItemSize prop is required and you\n     * will have reduced performance but the ability to reactively size list items\n      * @values true, false\n     */\n  dynamic: {\n    type: Boolean,\n    default: false,\n  },\n\n  /**\n      * Display height (or width in horizontal mode) of the items in pixels\n      * used to calculate the scroll size and position.\n     *  Required if DYNAMIC is false\n     */\n  itemSize: {\n    type: Number,\n    default: null,\n  },\n\n  /**\n      * The tag to use for the items.\n     */\n  itemTag: {\n    type: String,\n    default: 'div',\n  },\n\n  /**\n      * The items to render.\n      * If the items are simple arrays, the index will be used as the key.\n      * If the items are objects, the keyField will be used as the key.\n     * @example items: [ 'item1', 'item2', 'item3' ]\n     * @example items: [ { id: 1, name: 'item1' }, { id: 2, name: 'item2' }, { id: 3, name: 'item3' } ]\n     */\n  items: {\n    type: Array,\n    required: true,\n  },\n\n  /**\n      * The key field to use for the items.\n      * If the items are objects, the scroller needs to be able to identify them.\n      * By default it will look for an id field on the items.\n      * This can be configured with this prop if you are using another field name.\n     */\n  keyField: {\n    type: String,\n    default: 'id',\n  },\n\n  /**\n      * The tag to use for the list.\n     */\n  listTag: {\n    type: String,\n    default: 'div',\n  },\n\n  /**\n      * Minimum size used if the height (or width in horizontal mode) of a item is unknown.\n      * Is required for the initial render of items in DYNAMIC size mode.\n     */\n  minItemSize: {\n    type: [Number, String],\n    default: null,\n  },\n\n  /**\n      * The height of the scroller.\n      * Can be a number (in pixels) or a string (in CSS units).\n     */\n  scrollerHeight: {\n    type: [String, Number],\n    default: '100%',\n  },\n\n  /**\n    * The width of the scroller.\n    * Can be a number (in pixels) or a string (in CSS units).\n    */\n  scrollerWidth: {\n    type: [String, Number],\n    default: '100%',\n  },\n});\n\nconst emits = defineEmits([\n  /**\n   * Describe when the scroller changes from start/middle/end\n   * @param {string} position The position of the scroller.\n   * @values start, middle, end\n   */\n  'user-position',\n]);\n\nprovide('emit', emits);\n\nconst scroller = ref(null);\n\nconst computedStyle = computed(() => {\n  return {\n    width: typeof props.scrollerWidth === 'number' ? `${props.scrollerWidth}px` : props.scrollerWidth,\n    height: typeof props.scrollerHeight === 'number' ? `${props.scrollerHeight}px` : props.scrollerHeight,\n  };\n});\n\nwatch(props, () => {\n  validateProps();\n}, { deep: true, immediate: true });\n\nfunction scrollToBottom () {\n  if (scroller.value) scroller.value.scrollToBottom();\n}\n\nfunction scrollToItem (index) {\n  if (scroller.value) scroller.value.scrollToItem(index);\n}\n\nfunction updateItems () {\n  if (!scroller.value) return;\n  if (props.dynamic) {\n    scroller.value.dynamicScrollerUpdateItems();\n  } else {\n    scroller.value._updateVisibleItems(true);\n  }\n}\n\nfunction updateItemsFromBottom () {\n  if (!scroller.value) return;\n  if (props.dynamic) {\n    scroller.value.dynamicScrollerUpdateItemsFromBottom();\n  } else {\n    scroller.value._updateVisibleItems(false, true);\n  }\n}\n\nfunction validateProps () {\n  if (props.dynamic && !props.minItemSize) {\n    console.error('scroller error: \\'minItemSize\\' is required on \\'dynamic\\' mode.');\n  }\n\n  if (!props.dynamic && !props.itemSize) {\n    console.error('scroller error: \\'itemSize\\' is required.');\n  }\n}\n\ndefineExpose({\n  scrollToBottom,\n  scrollToItem,\n  updateItems,\n  updateItemsFromBottom,\n});\n</script>\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,UAAM,QAAQ;AAoGd,UAAM,QAAQ;AASd,YAAQ,QAAQ,KAAK;AAErB,UAAM,WAAW,IAAI,IAAI;AAEzB,UAAM,gBAAgB,SAAS,MAAM;AACnC,aAAO;AAAA,QACL,OAAO,OAAO,MAAM,kBAAkB,WAAW,GAAG,MAAM,aAAa,OAAO,MAAM;AAAA,QACpF,QAAQ,OAAO,MAAM,mBAAmB,WAAW,GAAG,MAAM,cAAc,OAAO,MAAM;AAAA,MAC3F;AAAA,IACA,CAAC;AAED,UAAM,OAAO,MAAM;AACjB;IACF,GAAG,EAAE,MAAM,MAAM,WAAW,KAAM,CAAA;AAElC,aAAS,iBAAkB;AACzB,UAAI,SAAS,MAAO,UAAS,MAAM,eAAc;AAAA,IACnD;AAEA,aAAS,aAAc,OAAO;AAC5B,UAAI,SAAS,MAAO,UAAS,MAAM,aAAa,KAAK;AAAA,IACvD;AAEA,aAAS,cAAe;AACtB,UAAI,CAAC,SAAS,MAAO;AACrB,UAAI,MAAM,SAAS;AACjB,iBAAS,MAAM;MACnB,OAAS;AACL,iBAAS,MAAM,oBAAoB,IAAI;AAAA,MACxC;AAAA,IACH;AAEA,aAAS,wBAAyB;AAChC,UAAI,CAAC,SAAS,MAAO;AACrB,UAAI,MAAM,SAAS;AACjB,iBAAS,MAAM;MACnB,OAAS;AACL,iBAAS,MAAM,oBAAoB,OAAO,IAAI;AAAA,MAC/C;AAAA,IACH;AAEA,aAAS,gBAAiB;AACxB,UAAI,MAAM,WAAW,CAAC,MAAM,aAAa;AACvC,gBAAQ,MAAM,8DAAkE;AAAA,MACjF;AAED,UAAI,CAAC,MAAM,WAAW,CAAC,MAAM,UAAU;AACrC,gBAAQ,MAAM,yCAA2C;AAAA,MAC1D;AAAA,IACH;AAEA,aAAa;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/vue3/components/scroller/modules/core_scroller.vue.cjs

@@ -0,0 +1,462 @@
+"use strict";
+const vue = require("vue");
+;/* empty css                     */
+const _sfc_main = {
+  __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);
+    };
+  }
+};
+module.exports = _sfc_main;
+//# sourceMappingURL=core_scroller.vue.cjs.map