@dialpad/dialtone-vue 3.120.0 → 3.120.2

package/dist/lib/scroller.js

@@ -1,6 +1,6 @@
-import { reactive as ae, ref as U, computed as j, watch as me, onMounted as we, nextTick as xe, openBlock as O, createElementBlock as ce, normalizeClass as de, createBlock as E, resolveDynamicComponent as Y, normalizeStyle as fe, unref as Fe, withCtx as B, Fragment as Ae, renderList as Ue, mergeProps as he, toHandlers as Oe, renderSlot as X, markRaw as Pe, shallowReactive as Re, h as Be, resolveComponent as ue, createVNode as Ve, normalizeProps as pe, guardReactiveProps as ve, provide as Me } from "vue";
-import { _ as He } from "../chunks/_plugin-vue_export-helper-hUChTQA_.js";
-const ye = {
+import { reactive, ref, computed, watch, onMounted, nextTick, openBlock, createElementBlock, normalizeClass, createBlock, resolveDynamicComponent, normalizeStyle, unref, withCtx, Fragment, renderList, mergeProps, toHandlers, renderSlot, markRaw, shallowReactive, h, resolveComponent, createVNode, normalizeProps, guardReactiveProps, provide } from "vue";
+import { _export_sfc } from "../chunks/_plugin-vue_export-helper-caHeSgYY.js";
+const _sfc_main$3 = {
   __name: "core_scroller",
   props: {
     /**
@@ -8,7 +8,7 @@ const ye = {
        */
     items: {
       type: Array,
-      required: !0
+      required: true
     },
     /**
        *
@@ -24,7 +24,7 @@ const ye = {
     direction: {
       type: String,
       default: "vertical",
-      validator: (e) => ["vertical", "horizontal"].includes(e)
+      validator: (value) => ["vertical", "horizontal"].includes(value)
     },
     /**
        * Size of the items in the list.
@@ -61,7 +61,7 @@ const ye = {
        */
     skipHover: {
       type: Boolean,
-      default: !1
+      default: false
     },
     /**
        * The element to render as the list's wrapper.
@@ -93,194 +93,375 @@ const ye = {
     }
   },
   emits: ["user-position"],
-  setup(e, { expose: i, emit: o }) {
-    const t = e, z = o, u = ae(/* @__PURE__ */ new Map()), v = ae(/* @__PURE__ */ new Map()), f = U([]), y = U(null), S = U(!1), h = U(null), x = U("top");
-    let w = 0, F = !1, A = 0, V = null, M = null, G = 0, ze = 0;
-    const L = j(() => {
-      if (t.itemSize === null) {
-        const r = {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const views = reactive(/* @__PURE__ */ new Map());
+    const unusedViews = reactive(/* @__PURE__ */ new Map());
+    const pool = ref([]);
+    const hoverKey = ref(null);
+    const ready = ref(false);
+    const scroller = ref(null);
+    const userPosition = 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 = computed(() => {
+      if (props.itemSize === null) {
+        const sizes2 = {
           "-1": { accumulator: 0 }
-        }, n = t.items, s = t.sizeField, D = t.minItemSize;
-        let p = 1e4, k = 0, d;
-        for (let b = 0, P = n.length; b < P; b++)
-          d = n[b][s] || D, d < p && (p = d), k += d, r[b] = { accumulator: k, size: d };
-        return M = p, r;
+        };
+        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 [];
-    }), Se = j(() => t.items.length && typeof t.items[0] != "object"), ge = j(() => {
-      const r = {};
-      for (let n = 0, s = t.items.length; n < s; n++)
-        r[t.items[n][t.keyField]] = n;
-      return r;
     });
-    me(L, () => {
-      H(!1);
-    }, { deep: !0 }), we(() => {
-      xe(() => {
-        H(!0), S.value = !0;
+    const simpleArray = computed(() => {
+      return props.items.length && typeof props.items[0] !== "object";
+    });
+    const itemIndexByKey = computed(() => {
+      const result = {};
+      for (let i = 0, l = props.items.length; i < l; i++) {
+        result[props.items[i][props.keyField]] = i;
+      }
+      return result;
+    });
+    watch(sizes, () => {
+      _updateVisibleItems(false);
+    }, { deep: true });
+    onMounted(() => {
+      nextTick(() => {
+        _updateVisibleItems(true);
+        ready.value = true;
       });
     });
-    const J = (r, n, s, D, p) => {
-      const k = Pe({
-        id: ze++,
-        index: n,
-        used: !0,
-        key: D,
-        type: p
-      }), d = Re({
-        item: s,
+    const _addView = (pool2, index, item, key, type) => {
+      const nr = markRaw({
+        id: uid++,
+        index,
+        used: true,
+        key,
+        type
+      });
+      const view = shallowReactive({
+        item,
         position: 0,
-        nr: k
+        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.");
       });
-      return r.value.push(d), d;
-    }, K = (r, n = !1) => {
-      const s = v, D = r.nr.type;
-      let p = s.get(D);
-      p || (p = [], s.set(D, p)), p.push(r), n || (r.nr.used = !1, r.position = -9999);
-    }, $e = () => {
-      const r = t.direction === "vertical";
-      let n;
-      return r ? n = {
-        start: h.value.scrollTop,
-        end: h.value.scrollTop + h.value.clientHeight
-      } : n = {
-        start: h.value.scrollLeft,
-        end: h.value.scrollLeft + h.value.clientWidth
-      }, n;
-    }, _e = () => {
-      throw setTimeout(() => {
-        console.error("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", h), 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.");
-      }), new Error("Rendered items limit reached");
-    }, be = () => {
-      f.value.sort((r, n) => r.nr.index - n.nr.index);
-    }, H = (r, n = !1) => {
-      var ee, te, ie, se, le, re;
-      const s = t.itemSize, D = M, p = Se.value ? null : t.keyField, k = t.items, d = k.length, b = L.value, P = u, Q = v, q = f, Ie = ge;
-      let g, m, N;
-      if (!d)
-        g = m = N = 0;
-      else {
-        const a = $e();
-        if (n) {
-          let c = a.start - A.value;
-          if (c < 0 && (c = -c), s === null && c < D.value || c < s)
+      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: !0
+              continuous: true
             };
+          }
         }
-        A = a.start;
-        const $ = t.buffer;
-        if (a.start -= $, a.end += $, s === null) {
-          let c, R = 0, oe = d - 1, _ = ~~(d / 2), ne;
-          do
-            ne = _, c = (ee = b[_]) == null ? void 0 : ee.accumulator, c < a.start ? R = _ : _ < d - 1 && ((te = b[_ + 1]) == null ? void 0 : te.accumulator) > a.start && (oe = _), _ = ~~((R + oe) / 2);
-          while (_ !== ne);
-          for (_ < 0 && (_ = 0), g = _, N = (ie = b[d - 1]) == null ? void 0 : ie.accumulator, m = _; m < d && ((se = b[m]) == null ? void 0 : se.accumulator) < a.end; m++)
+        lastUpdateScrollPosition = scroll.start;
+        const _buffer = props.buffer;
+        scroll.start -= _buffer;
+        scroll.end += _buffer;
+        if (itemSize === null) {
+          let h2;
+          let a = 0;
+          let b = count - 1;
+          let i = ~~(count / 2);
+          let oldI;
+          do {
+            oldI = i;
+            h2 = (_a = _sizes[i]) == null ? void 0 : _a.accumulator;
+            if (h2 < 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++)
             ;
-          m === -1 ? m = k.length - 1 : (m++, m > d && (m = d));
+          if (_endIndex === -1) {
+            _endIndex = items.length - 1;
+          } else {
+            _endIndex++;
+            _endIndex > count && (_endIndex = count);
+          }
         } else {
-          g = ~~(a.start / s);
-          const c = g % 1;
-          g -= c, m = Math.ceil(a.end / s), g < 0 && (g = 0), m > d && (m = d), N = Math.ceil(d / 1) * s;
+          _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;
         }
       }
-      m - g > 1e3 && _e(), G = N;
-      let l;
-      const W = g <= w && m >= g;
-      if (W)
-        for (let a = 0, $ = q.value.length; a < $; a++)
-          l = q.value[a], l != null && l.nr.used && (r && (l.nr.index = Ie[l.item[p]]), (l.nr.index == null || l.nr.index < g || l.nr.index >= m) && K(l));
-      const Z = W ? null : /* @__PURE__ */ new Map();
-      let T, I, C;
-      for (let a = g; a < m; a++) {
-        T = k[a];
-        const $ = p ? T == null ? void 0 : T[p] : T;
-        if ($ == null)
-          throw new Error(`Key is ${$} on item (keyField is '${p}')`);
-        if (l = P.get($), !s && !((le = b[a]) != null && le.size)) {
-          l && K(l);
+      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;
         }
-        I = T.type;
-        let c = Q.get(I);
-        if (!l)
-          W ? c && c.length ? l = c.pop() : l = J(q, a, T, $, I) : (C = Z.get(I) || 0, (!c || C >= c.length) && (l = J(q, a, T, $, I), K(l, !0), c = Q.get(I)), l = c[C], Z.set(I, C + 1)), P.delete(l.nr.key), l.nr.used = !0, l.nr.index = a, l.nr.key = $, l.nr.type = I, P.set($, l);
-        else if (!l.nr.used && (l.nr.used = !0, c)) {
-          const R = c.indexOf(l);
-          R !== -1 && c.splice(R, 1);
+        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;
         }
-        l.item = T, s === null ? (l.position = (re = b[a - 1]) == null ? void 0 : re.accumulator, l.offset = 0) : (l.position = Math.floor(a) * s, l.offset = a % 1 * s);
       }
-      return w = m, clearTimeout(V), V = setTimeout(be, 300), {
-        continuous: W
+      endIndex = _endIndex;
+      clearTimeout(sortTimer);
+      sortTimer = setTimeout(_sortViews, 300);
+      return {
+        continuous
       };
-    }, De = (r) => {
-      const n = t.direction === "vertical" ? { scroll: "scrollTop", start: "top" } : { scroll: "scrollLeft", start: "left" }, s = h.value, D = n.scroll;
-      s[D] = r;
-    }, Te = (r) => {
-      var s;
-      let n;
-      t.itemSize === null ? n = r > 0 ? (s = L.value[r - 1]) == null ? void 0 : s.accumulator : 0 : n = Math.floor(r) * t.itemSize, De(n);
-    }, ke = () => {
-      const r = h.value;
-      x.value !== "middle" && (x.value = "middle", z("user-position", "middle")), r.scrollTop === 0 && (x.value = "top", z("user-position", "top")), r.scrollTop + r.clientHeight === r.scrollHeight && (x.value = "bottom", z("user-position", "bottom")), F || (F = !0, requestAnimationFrame(() => {
-        F = !1, H(!1, !0);
-      }));
     };
-    return i({
-      scrollToItem: Te,
-      _updateVisibleItems: H
-    }), (r, n) => (O(), ce("div", {
-      ref_key: "scroller",
-      ref: h,
-      class: de(["vue-recycle-scroller", {
-        ready: S.value,
-        [`direction-${e.direction}`]: !0
-      }]),
-      onScrollPassive: ke
-    }, [
-      (O(), E(Y(e.listTag), {
-        ref: "wrapper",
-        style: fe({ [e.direction === "vertical" ? "minHeight" : "minWidth"]: `${Fe(G)}px` }),
-        class: de(["vue-recycle-scroller__item-wrapper", e.listClass])
-      }, {
-        default: B(() => [
-          (O(!0), ce(Ae, null, Ue(f.value, (s) => (O(), E(Y(e.itemTag), he({
-            key: s.nr.id,
-            style: S.value ? {
-              transform: `translate${e.direction === "vertical" ? "Y" : "X"}(${s.position}px) translate${e.direction === "vertical" ? "X" : "Y"}(${s.offset}px)`,
-              width: void 0,
-              height: void 0
-            } : null,
-            class: ["vue-recycle-scroller__item-view", [
-              e.itemClass,
-              {
-                hover: !e.skipHover && y.value === s.nr.key
-              }
-            ]]
-          }, Oe(e.skipHover ? {} : {
-            mouseenter: () => {
-              y.value = s.nr.key;
-            },
-            mouseleave: () => {
-              y.value = null;
-            }
-          })), {
-            default: B(() => [
-              X(r.$slots, "default", {
-                item: s.item,
-                index: s.nr.index,
-                active: s.nr.used
-              })
-            ]),
-            _: 2
-          }, 1040, ["style", "class"]))), 128))
-        ]),
-        _: 3
-      }, 8, ["style", "class"]))
-    ], 34));
+    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 openBlock(), createElementBlock("div", {
+        ref_key: "scroller",
+        ref: scroller,
+        class: normalizeClass(["vue-recycle-scroller", {
+          ready: ready.value,
+          [`direction-${__props.direction}`]: true
+        }]),
+        onScrollPassive: handleScroll
+      }, [
+        (openBlock(), createBlock(resolveDynamicComponent(__props.listTag), {
+          ref: "wrapper",
+          style: normalizeStyle({ [__props.direction === "vertical" ? "minHeight" : "minWidth"]: `${unref(totalSize)}px` }),
+          class: normalizeClass(["vue-recycle-scroller__item-wrapper", __props.listClass])
+        }, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(pool.value, (view) => {
+              return openBlock(), createBlock(resolveDynamicComponent(__props.itemTag), 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
+                  }
+                ]]
+              }, toHandlers(__props.skipHover ? {} : {
+                mouseenter: () => {
+                  hoverKey.value = view.nr.key;
+                },
+                mouseleave: () => {
+                  hoverKey.value = null;
+                }
+              })), {
+                default: withCtx(() => [
+                  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);
+    };
   }
-}, qe = {
+};
+const _sfc_main$2 = {
   name: "DtScrollerItem",
   inject: [
     "vscrollData",
@@ -290,18 +471,18 @@ const ye = {
   props: {
     // eslint-disable-next-line vue/require-prop-types
     item: {
-      required: !0
+      required: true
     },
     watchData: {
       type: Boolean,
-      default: !1
+      default: false
     },
     /**
      * Indicates if the view is actively used to display an item.
      */
     active: {
       type: Boolean,
-      required: !0
+      required: true
     },
     index: {
       type: Number,
@@ -333,102 +514,189 @@ const ye = {
   },
   watch: {
     watchData: "updateWatchData",
-    id(e, i) {
-      if (this.$el.$_vs_id = this.id, this.size || this.onDataUpdate(), this.$_sizeObserved) {
-        const o = this.vscrollData.sizes[i], t = this.vscrollData.sizes[e];
-        o != null && o !== t && this.applySize(o);
+    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(e) {
-      this.size || (e ? this.vscrollParent.$_undefinedMap[this.id] || (this.vscrollParent.$_undefinedSizes++, this.vscrollParent.$_undefinedMap[this.id] = !0) : this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = !1)), this.vscrollResizeObserver ? e ? this.observeSize() : this.unobserveSize() : e && this.$_pendingVScrollUpdate === this.id && this.updateSize();
+    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 && (this.$_forceNextVScrollUpdate = null, this.updateWatchData(), !this.vscrollResizeObserver))
-      for (const e in this.sizeDependencies)
-        this.$watch(() => this.sizeDependencies[e], this.onDataUpdate);
+    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() {
-    this.finalActive && (this.updateSize(), this.observeSize());
+    if (this.finalActive) {
+      this.updateSize();
+      this.observeSize();
+    }
   },
   beforeUnmount() {
     this.unobserveSize();
   },
   methods: {
     updateSize() {
-      this.finalActive ? this.$_pendingSizeUpdate !== this.id && (this.$_pendingSizeUpdate = this.id, this.$_forceNextVScrollUpdate = null, this.$_pendingVScrollUpdate = null, this.computeSize(this.id)) : this.$_forceNextVScrollUpdate = this.id;
+      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() {
-      this.watchData && !this.vscrollResizeObserver ? this.$_watchData = this.$watch("item", () => {
-        this.onDataUpdate();
-      }, {
-        deep: !0
-      }) : this.$_watchData && (this.$_watchData(), this.$_watchData = null);
+      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: e }) {
-      !this.finalActive && e && (this.$_pendingVScrollUpdate = this.id), (this.$_forceNextVScrollUpdate === this.id || e || !this.size) && this.updateSize();
+    onVscrollUpdate({ force }) {
+      if (!this.finalActive && force) {
+        this.$_pendingVScrollUpdate = this.id;
+      }
+      if (this.$_forceNextVScrollUpdate === this.id || force || !this.size) {
+        this.updateSize();
+      }
     },
     onDataUpdate() {
       this.updateSize();
     },
-    computeSize(e) {
+    computeSize(id) {
       this.$nextTick(() => {
-        if (this.id === e) {
-          const i = this.$el.offsetWidth, o = this.$el.offsetHeight;
-          this.applyWidthHeight(i, o);
+        if (this.id === id) {
+          const width = this.$el.offsetWidth;
+          const height = this.$el.offsetHeight;
+          this.applyWidthHeight(width, height);
         }
         this.$_pendingSizeUpdate = null;
       });
     },
-    applyWidthHeight(e, i) {
-      const o = ~~(this.vscrollParent.direction === "vertical" ? i : e);
-      o && this.size !== o && this.applySize(o);
+    applyWidthHeight(width, height) {
+      const size = ~~(this.vscrollParent.direction === "vertical" ? height : width);
+      if (size && this.size !== size) {
+        this.applySize(size);
+      }
     },
-    applySize(e) {
-      this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = void 0), this.vscrollData.sizes[this.id] = e;
+    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() {
-      this.vscrollResizeObserver && (this.$_sizeObserved || (this.vscrollResizeObserver.observe(this.$el), this.$el.$_vs_id = this.id, this.$el.$_vs_onResize = this.onResize, this.$_sizeObserved = !0));
+      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() {
-      this.vscrollResizeObserver && this.$_sizeObserved && (this.vscrollResizeObserver.unobserve(this.$el), this.$el.$_vs_onResize = void 0, this.$_sizeObserved = !1);
+      if (!this.vscrollResizeObserver)
+        return;
+      if (!this.$_sizeObserved)
+        return;
+      this.vscrollResizeObserver.unobserve(this.$el);
+      this.$el.$_vs_onResize = void 0;
+      this.$_sizeObserved = false;
     },
-    onResize(e, i, o) {
-      this.id === e && this.applyWidthHeight(i, o);
+    onResize(id, width, height) {
+      if (this.id === id) {
+        this.applyWidthHeight(width, height);
+      }
     }
   },
   render() {
-    return Be(this.tag, this.$slots.default());
+    return h(this.tag, this.$slots.default());
   }
-}, Ne = {
+};
+const _sfc_main$1 = {
   name: "DynamicScroller",
   components: {
-    CoreScroller: ye,
-    DtScrollerItem: qe
+    CoreScroller: _sfc_main$3,
+    DtScrollerItem: _sfc_main$2
   },
   provide() {
-    return typeof ResizeObserver < "u" && (this.$_resizeObserver = new ResizeObserver((e) => {
-      requestAnimationFrame(() => {
-        if (Array.isArray(e)) {
-          for (const i of e)
-            if (i.target && i.target.$_vs_onResize) {
-              let o, t;
-              if (i.borderBoxSize) {
-                const z = i.borderBoxSize[0];
-                o = z.inlineSize, t = z.blockSize;
-              } else
-                o = i.contentRect.width, t = i.contentRect.height;
-              i.target.$_vs_onResize(i.target.$_vs_id, o, t);
+    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: !1,
+  inheritAttrs: false,
   props: {
     /*
       * The items to render.
@@ -437,7 +705,7 @@ const ye = {
      */
     items: {
       type: Array,
-      required: !0
+      required: true
     },
     /*
       * Indicates if the items are dynamic.
@@ -446,7 +714,7 @@ const ye = {
      */
     dynamic: {
       type: Boolean,
-      default: !1
+      default: false
     },
     /*
       * The key field to use for the items.
@@ -463,7 +731,7 @@ const ye = {
     direction: {
       type: String,
       default: "vertical",
-      validator: (e) => ["vertical", "horizontal"].includes(e)
+      validator: (value) => ["vertical", "horizontal"].includes(value)
     },
     /*
       * The tag to use for the list.
@@ -491,113 +759,141 @@ const ye = {
   data() {
     return {
       vscrollData: {
-        active: !0,
+        active: true,
         sizes: {},
         keyField: this.keyField,
-        simpleArray: !1
+        simpleArray: false
       }
     };
   },
   computed: {
     simpleArray() {
-      return this.items.length && typeof this.items[0] != "object";
+      return this.items.length && typeof this.items[0] !== "object";
     },
     itemsWithSize() {
-      const e = [], { items: i, keyField: o, simpleArray: t } = this, z = this.vscrollData.sizes, u = i.length;
-      for (let v = 0; v < u; v++) {
-        const f = i[v], y = t ? v : f[o];
-        let S = z[y];
-        typeof S > "u" && !this.$_undefinedMap[y] && (S = 0), e.push({
-          item: f,
-          [o]: y,
-          size: S
+      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 e;
+      return result;
     }
   },
   watch: {
     simpleArray: {
-      handler(e) {
-        this.vscrollData.simpleArray = e;
+      handler(value) {
+        this.vscrollData.simpleArray = value;
       },
-      immediate: !0
-    },
-    itemsWithSize(e, i) {
-      const o = this.$el.scrollTop;
-      let t = 0, z = 0;
-      const u = Math.min(e.length, i.length);
-      for (let f = 0; f < u && !(t >= o); f++)
-        t += i[f].size || this.minItemSize, z += e[f].size || this.minItemSize;
-      const v = z - t;
-      v !== 0 && (this.$el.scrollTop += v);
+      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 = {};
+    this.$_updates = [];
+    this.$_undefinedSizes = 0;
+    this.$_undefinedMap = {};
   },
   activated() {
-    this.vscrollData.active = !0;
+    this.vscrollData.active = true;
   },
   deactivated() {
-    this.vscrollData.active = !1;
+    this.vscrollData.active = false;
   },
   methods: {
     dynamicScrollerUpdateItems() {
-      const e = this.$refs.scroller;
-      e && e._updateVisibleItems(!0);
+      const scroller = this.$refs.scroller;
+      if (scroller)
+        scroller._updateVisibleItems(true);
     },
     dynamicScrollerUpdateItemsFromBottom() {
-      const e = this.$refs.scroller;
-      e && e._updateVisibleItems(!1, !0);
+      const scroller = this.$refs.scroller;
+      if (scroller)
+        scroller._updateVisibleItems(false, true);
     },
-    scrollToItem(e) {
-      const i = this.$refs.scroller;
-      i && i.scrollToItem(e);
+    scrollToItem(index) {
+      const scroller = this.$refs.scroller;
+      if (scroller)
+        scroller.scrollToItem(index);
     },
     scrollToBottom() {
       if (this.$_scrollingToBottom)
         return;
-      this.$_scrollingToBottom = !0;
-      const e = this.$el;
+      this.$_scrollingToBottom = true;
+      const el = this.$el;
       this.$nextTick(() => {
-        e.scrollTop = e.scrollHeight + 5e3;
-        const i = () => {
-          e.scrollTop = e.scrollHeight + 5e3, requestAnimationFrame(() => {
-            e.scrollTop = e.scrollHeight + 5e3, this.$_undefinedSizes === 0 ? this.$_scrollingToBottom = !1 : requestAnimationFrame(i);
+        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(i);
+        requestAnimationFrame(cb);
       });
     }
   }
 };
-function We(e, i, o, t, z, u) {
-  const v = ue("dt-scroller-item"), f = ue("core-scroller");
-  return O(), E(f, he({
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_dt_scroller_item = resolveComponent("dt-scroller-item");
+  const _component_core_scroller = resolveComponent("core-scroller");
+  return openBlock(), createBlock(_component_core_scroller, mergeProps({
     ref: "scroller",
-    items: u.itemsWithSize,
-    "min-item-size": o.minItemSize,
-    direction: o.direction,
-    "key-field": o.keyField,
-    "list-tag": o.listTag,
-    "item-tag": o.itemTag
-  }, e.$attrs), {
-    default: B(({ item: y, index: S, active: h }) => [
-      Ve(v, {
-        item: y,
-        active: h,
+    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: withCtx(({ item: itemWithSize, index, active }) => [
+      createVNode(_component_dt_scroller_item, {
+        item: itemWithSize,
+        active,
         "size-dependencies": [
-          y.message
+          itemWithSize.message
         ],
-        "data-index": S
+        "data-index": index
       }, {
-        default: B(() => [
-          X(e.$slots, "default", pe(ve({
-            item: y.item,
-            index: S,
-            active: h,
-            itemWithSize: y
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps({
+            item: itemWithSize.item,
+            index,
+            active,
+            itemWithSize
           })))
         ]),
         _: 2
@@ -606,7 +902,8 @@ function We(e, i, o, t, z, u) {
     _: 3
   }, 16, ["items", "min-item-size", "direction", "key-field", "list-tag", "item-tag"]);
 }
-const Ce = /* @__PURE__ */ He(Ne, [["render", We]]), Le = {
+const DynamicScroller = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render]]);
+const _sfc_main = {
   __name: "DtScroller",
   props: {
     /**
@@ -616,7 +913,7 @@ const Ce = /* @__PURE__ */ He(Ne, [["render", We]]), Le = {
     direction: {
       type: String,
       default: "vertical",
-      validator: (e) => ["vertical", "horizontal"].includes(e)
+      validator: (value) => ["vertical", "horizontal"].includes(value)
     },
     /**
        * Indicates if the items need to react to changes in their size.
@@ -627,7 +924,7 @@ const Ce = /* @__PURE__ */ He(Ne, [["render", We]]), Le = {
        */
     dynamic: {
       type: Boolean,
-      default: !1
+      default: false
     },
     /**
         * Display height (or width in horizontal mode) of the items in pixels
@@ -654,7 +951,7 @@ const Ce = /* @__PURE__ */ He(Ne, [["render", We]]), Le = {
        */
     items: {
       type: Array,
-      required: !0
+      required: true
     },
     /**
         * The key field to use for the items.
@@ -706,63 +1003,89 @@ const Ce = /* @__PURE__ */ He(Ne, [["render", We]]), Le = {
      */
     "user-position"
   ],
-  setup(e, { expose: i, emit: o }) {
-    const t = e;
-    Me("emit", o);
-    const u = U(null), v = j(() => ({
-      width: typeof t.scrollerWidth == "number" ? `${t.scrollerWidth}px` : t.scrollerWidth,
-      height: typeof t.scrollerHeight == "number" ? `${t.scrollerHeight}px` : t.scrollerHeight
-    }));
-    me(t, () => {
-      x();
-    }, { deep: !0, immediate: !0 });
-    function f() {
-      u.value && u.value.scrollToBottom();
+  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 y(w) {
-      u.value && u.value.scrollToItem(w);
+    function scrollToItem(index) {
+      if (scroller.value)
+        scroller.value.scrollToItem(index);
     }
-    function S() {
-      u.value && (t.dynamic ? u.value.dynamicScrollerUpdateItems() : u.value._updateVisibleItems(!0));
+    function updateItems() {
+      if (!scroller.value)
+        return;
+      if (props.dynamic) {
+        scroller.value.dynamicScrollerUpdateItems();
+      } else {
+        scroller.value._updateVisibleItems(true);
+      }
     }
-    function h() {
-      u.value && (t.dynamic ? u.value.dynamicScrollerUpdateItemsFromBottom() : u.value._updateVisibleItems(!1, !0));
+    function updateItemsFromBottom() {
+      if (!scroller.value)
+        return;
+      if (props.dynamic) {
+        scroller.value.dynamicScrollerUpdateItemsFromBottom();
+      } else {
+        scroller.value._updateVisibleItems(false, true);
+      }
     }
-    function x() {
-      t.dynamic && !t.minItemSize && console.error("scroller error: 'minItemSize' is required on 'dynamic' mode."), !t.dynamic && !t.itemSize && console.error("scroller error: 'itemSize' is required.");
+    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.");
+      }
     }
-    return i({
-      scrollToBottom: f,
-      scrollToItem: y,
-      updateItems: S,
-      updateItemsFromBottom: h
-    }), (w, F) => (O(), E(Y(e.dynamic ? Ce : ye), {
-      ref_key: "scroller",
-      ref: u,
-      "data-qa": "dt-scroller",
-      items: e.items,
-      "item-size": e.itemSize,
-      "min-item-size": e.minItemSize,
-      direction: e.direction,
-      "key-field": e.keyField,
-      "list-tag": e.listTag,
-      "item-tag": e.itemTag,
-      style: fe(v.value),
-      tabindex: "0",
-      onUserPosition: F[0] || (F[0] = (A) => w.$emit("user-position", A))
-    }, {
-      default: B(({ item: A, index: V, active: M }) => [
-        X(w.$slots, "default", pe(ve({
-          item: A,
-          index: V,
-          active: M
-        })))
-      ]),
-      _: 3
-    }, 40, ["items", "item-size", "min-item-size", "direction", "key-field", "list-tag", "item-tag", "style"]));
+    __expose({
+      scrollToBottom,
+      scrollToItem,
+      updateItems,
+      updateItemsFromBottom
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(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: 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"]);
+    };
   }
 };
 export {
-  Le as DtScroller
+  _sfc_main as DtScroller
 };
 //# sourceMappingURL=scroller.js.map