@dialpad/dialtone-vue 3.120.0 → 3.120.2

package/dist/lib/scroller.cjs

@@ -1,2 +1,1091 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("vue"),fe=require("../chunks/_plugin-vue_export-helper-6_y-gaV6.js"),ie={__name:"core_scroller",props:{items:{type:Array,required:!0},keyField:{type:String,default:"id"},direction:{type:String,default:"vertical",validator:e=>["vertical","horizontal"].includes(e)},itemSize:{type:Number,default:null},minItemSize:{type:[Number,String],default:null},sizeField:{type:String,default:"size"},buffer:{type:Number,default:200},skipHover:{type:Boolean,default:!1},listTag:{type:String,default:"div"},itemTag:{type:String,default:"div"},listClass:{type:[String,Object,Array],default:""},itemClass:{type:[String,Object,Array],default:""}},emits:["user-position"],setup(e,{expose:s,emit:n}){const i=e,y=n,m=t.reactive(new Map),z=t.reactive(new Map),h=t.ref([]),S=t.ref(null),g=t.ref(!1),p=t.ref(null),B=t.ref("top");let I=0,F=!1,A=0,R=null,U=null,j=0,se=0;const N=t.computed(()=>{if(i.itemSize===null){const o={"-1":{accumulator:0}},a=i.items,l=i.sizeField,D=i.minItemSize;let v=1e4,w=0,u;for(let k=0,P=a.length;k<P;k++)u=a[k][l]||D,u<v&&(v=u),w+=u,o[k]={accumulator:w,size:u};return U=v,o}return[]}),le=t.computed(()=>i.items.length&&typeof i.items[0]!="object"),re=t.computed(()=>{const o={};for(let a=0,l=i.items.length;a<l;a++)o[i.items[a][i.keyField]]=a;return o});t.watch(N,()=>{V(!1)},{deep:!0}),t.onMounted(()=>{t.nextTick(()=>{V(!0),g.value=!0})});const E=(o,a,l,D,v)=>{const w=t.markRaw({id:se++,index:a,used:!0,key:D,type:v}),u=t.shallowReactive({item:l,position:0,nr:w});return o.value.push(u),u},W=(o,a=!1)=>{const l=z,D=o.nr.type;let v=l.get(D);v||(v=[],l.set(D,v)),v.push(o),a||(o.nr.used=!1,o.position=-9999)},oe=()=>{const o=i.direction==="vertical";let a;return o?a={start:p.value.scrollTop,end:p.value.scrollTop+p.value.clientHeight}:a={start:p.value.scrollLeft,end:p.value.scrollLeft+p.value.clientWidth},a},ne=()=>{throw setTimeout(()=>{console.error("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",p),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")},ae=()=>{h.value.sort((o,a)=>o.nr.index-a.nr.index)},V=(o,a=!1)=>{var Y,X,G,J,Q,Z;const l=i.itemSize,D=U,v=le.value?null:i.keyField,w=i.items,u=w.length,k=N.value,P=m,L=z,M=h,me=re;let $,f,H;if(!u)$=f=H=0;else{const c=oe();if(a){let d=c.start-A.value;if(d<0&&(d=-d),l===null&&d<D.value||d<l)return{continuous:!0}}A=c.start;const _=i.buffer;if(c.start-=_,c.end+=_,l===null){let d,O=0,ee=u-1,b=~~(u/2),te;do te=b,d=(Y=k[b])==null?void 0:Y.accumulator,d<c.start?O=b:b<u-1&&((X=k[b+1])==null?void 0:X.accumulator)>c.start&&(ee=b),b=~~((O+ee)/2);while(b!==te);for(b<0&&(b=0),$=b,H=(G=k[u-1])==null?void 0:G.accumulator,f=b;f<u&&((J=k[f])==null?void 0:J.accumulator)<c.end;f++);f===-1?f=w.length-1:(f++,f>u&&(f=u))}else{$=~~(c.start/l);const d=$%1;$-=d,f=Math.ceil(c.end/l),$<0&&($=0),f>u&&(f=u),H=Math.ceil(u/1)*l}}f-$>1e3&&ne(),j=H;let r;const C=$<=I&&f>=$;if(C)for(let c=0,_=M.value.length;c<_;c++)r=M.value[c],r!=null&&r.nr.used&&(o&&(r.nr.index=me[r.item[v]]),(r.nr.index==null||r.nr.index<$||r.nr.index>=f)&&W(r));const K=C?null:new Map;let T,x,q;for(let c=$;c<f;c++){T=w[c];const _=v?T==null?void 0:T[v]:T;if(_==null)throw new Error(`Key is ${_} on item (keyField is '${v}')`);if(r=P.get(_),!l&&!((Q=k[c])!=null&&Q.size)){r&&W(r);continue}x=T.type;let d=L.get(x);if(!r)C?d&&d.length?r=d.pop():r=E(M,c,T,_,x):(q=K.get(x)||0,(!d||q>=d.length)&&(r=E(M,c,T,_,x),W(r,!0),d=L.get(x)),r=d[q],K.set(x,q+1)),P.delete(r.nr.key),r.nr.used=!0,r.nr.index=c,r.nr.key=_,r.nr.type=x,P.set(_,r);else if(!r.nr.used&&(r.nr.used=!0,d)){const O=d.indexOf(r);O!==-1&&d.splice(O,1)}r.item=T,l===null?(r.position=(Z=k[c-1])==null?void 0:Z.accumulator,r.offset=0):(r.position=Math.floor(c)*l,r.offset=c%1*l)}return I=f,clearTimeout(R),R=setTimeout(ae,300),{continuous:C}},ce=o=>{const a=i.direction==="vertical"?{scroll:"scrollTop",start:"top"}:{scroll:"scrollLeft",start:"left"},l=p.value,D=a.scroll;l[D]=o},de=o=>{var l;let a;i.itemSize===null?a=o>0?(l=N.value[o-1])==null?void 0:l.accumulator:0:a=Math.floor(o)*i.itemSize,ce(a)},ue=()=>{const o=p.value;B.value!=="middle"&&(B.value="middle",y("user-position","middle")),o.scrollTop===0&&(B.value="top",y("user-position","top")),o.scrollTop+o.clientHeight===o.scrollHeight&&(B.value="bottom",y("user-position","bottom")),F||(F=!0,requestAnimationFrame(()=>{F=!1,V(!1,!0)}))};return s({scrollToItem:de,_updateVisibleItems:V}),(o,a)=>(t.openBlock(),t.createElementBlock("div",{ref_key:"scroller",ref:p,class:t.normalizeClass(["vue-recycle-scroller",{ready:g.value,[`direction-${e.direction}`]:!0}]),onScrollPassive:ue},[(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.listTag),{ref:"wrapper",style:t.normalizeStyle({[e.direction==="vertical"?"minHeight":"minWidth"]:`${t.unref(j)}px`}),class:t.normalizeClass(["vue-recycle-scroller__item-wrapper",e.listClass])},{default:t.withCtx(()=>[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(h.value,l=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.itemTag),t.mergeProps({key:l.nr.id,style:g.value?{transform:`translate${e.direction==="vertical"?"Y":"X"}(${l.position}px) translate${e.direction==="vertical"?"X":"Y"}(${l.offset}px)`,width:void 0,height:void 0}:null,class:["vue-recycle-scroller__item-view",[e.itemClass,{hover:!e.skipHover&&S.value===l.nr.key}]]},t.toHandlers(e.skipHover?{}:{mouseenter:()=>{S.value=l.nr.key},mouseleave:()=>{S.value=null}})),{default:t.withCtx(()=>[t.renderSlot(o.$slots,"default",{item:l.item,index:l.nr.index,active:l.nr.used})]),_:2},1040,["style","class"]))),128))]),_:3},8,["style","class"]))],34))}},he={name:"DtScrollerItem",inject:["vscrollData","vscrollParent","vscrollResizeObserver"],props:{item:{required:!0},watchData:{type:Boolean,default:!1},active:{type:Boolean,required:!0},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(e,s){if(this.$el.$_vs_id=this.id,this.size||this.onDataUpdate(),this.$_sizeObserved){const n=this.vscrollData.sizes[s],i=this.vscrollData.sizes[e];n!=null&&n!==i&&this.applySize(n)}},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()}},created(){if(!this.$isServer&&(this.$_forceNextVScrollUpdate=null,this.updateWatchData(),!this.vscrollResizeObserver))for(const e in this.sizeDependencies)this.$watch(()=>this.sizeDependencies[e],this.onDataUpdate)},mounted(){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},updateWatchData(){this.watchData&&!this.vscrollResizeObserver?this.$_watchData=this.$watch("item",()=>{this.onDataUpdate()},{deep:!0}):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()},onDataUpdate(){this.updateSize()},computeSize(e){this.$nextTick(()=>{if(this.id===e){const s=this.$el.offsetWidth,n=this.$el.offsetHeight;this.applyWidthHeight(s,n)}this.$_pendingSizeUpdate=null})},applyWidthHeight(e,s){const n=~~(this.vscrollParent.direction==="vertical"?s:e);n&&this.size!==n&&this.applySize(n)},applySize(e){this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=void 0),this.vscrollData.sizes[this.id]=e},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))},unobserveSize(){this.vscrollResizeObserver&&this.$_sizeObserved&&(this.vscrollResizeObserver.unobserve(this.$el),this.$el.$_vs_onResize=void 0,this.$_sizeObserved=!1)},onResize(e,s,n){this.id===e&&this.applyWidthHeight(s,n)}},render(){return t.h(this.tag,this.$slots.default())}},pe={name:"DynamicScroller",components:{CoreScroller:ie,DtScrollerItem:he},provide(){return typeof ResizeObserver<"u"&&(this.$_resizeObserver=new ResizeObserver(e=>{requestAnimationFrame(()=>{if(Array.isArray(e)){for(const s of e)if(s.target&&s.target.$_vs_onResize){let n,i;if(s.borderBoxSize){const y=s.borderBoxSize[0];n=y.inlineSize,i=y.blockSize}else n=s.contentRect.width,i=s.contentRect.height;s.target.$_vs_onResize(s.target.$_vs_id,n,i)}}})})),{vscrollData:this.vscrollData,vscrollParent:this,vscrollResizeObserver:this.$_resizeObserver}},inheritAttrs:!1,props:{items:{type:Array,required:!0},dynamic:{type:Boolean,default:!1},keyField:{type:String,default:"id"},direction:{type:String,default:"vertical",validator:e=>["vertical","horizontal"].includes(e)},listTag:{type:String,default:"div"},itemTag:{type:String,default:"div"},minItemSize:{type:[Number,String]}},data(){return{vscrollData:{active:!0,sizes:{},keyField:this.keyField,simpleArray:!1}}},computed:{simpleArray(){return this.items.length&&typeof this.items[0]!="object"},itemsWithSize(){const e=[],{items:s,keyField:n,simpleArray:i}=this,y=this.vscrollData.sizes,m=s.length;for(let z=0;z<m;z++){const h=s[z],S=i?z:h[n];let g=y[S];typeof g>"u"&&!this.$_undefinedMap[S]&&(g=0),e.push({item:h,[n]:S,size:g})}return e}},watch:{simpleArray:{handler(e){this.vscrollData.simpleArray=e},immediate:!0},itemsWithSize(e,s){const n=this.$el.scrollTop;let i=0,y=0;const m=Math.min(e.length,s.length);for(let h=0;h<m&&!(i>=n);h++)i+=s[h].size||this.minItemSize,y+=e[h].size||this.minItemSize;const z=y-i;z!==0&&(this.$el.scrollTop+=z)}},beforeCreate(){this.$_updates=[],this.$_undefinedSizes=0,this.$_undefinedMap={}},activated(){this.vscrollData.active=!0},deactivated(){this.vscrollData.active=!1},methods:{dynamicScrollerUpdateItems(){const e=this.$refs.scroller;e&&e._updateVisibleItems(!0)},dynamicScrollerUpdateItemsFromBottom(){const e=this.$refs.scroller;e&&e._updateVisibleItems(!1,!0)},scrollToItem(e){const s=this.$refs.scroller;s&&s.scrollToItem(e)},scrollToBottom(){if(this.$_scrollingToBottom)return;this.$_scrollingToBottom=!0;const e=this.$el;this.$nextTick(()=>{e.scrollTop=e.scrollHeight+5e3;const s=()=>{e.scrollTop=e.scrollHeight+5e3,requestAnimationFrame(()=>{e.scrollTop=e.scrollHeight+5e3,this.$_undefinedSizes===0?this.$_scrollingToBottom=!1:requestAnimationFrame(s)})};requestAnimationFrame(s)})}}};function ve(e,s,n,i,y,m){const z=t.resolveComponent("dt-scroller-item"),h=t.resolveComponent("core-scroller");return t.openBlock(),t.createBlock(h,t.mergeProps({ref:"scroller",items:m.itemsWithSize,"min-item-size":n.minItemSize,direction:n.direction,"key-field":n.keyField,"list-tag":n.listTag,"item-tag":n.itemTag},e.$attrs),{default:t.withCtx(({item:S,index:g,active:p})=>[t.createVNode(z,{item:S,active:p,"size-dependencies":[S.message],"data-index":g},{default:t.withCtx(()=>[t.renderSlot(e.$slots,"default",t.normalizeProps(t.guardReactiveProps({item:S.item,index:g,active:p,itemWithSize:S})))]),_:2},1032,["item","active","size-dependencies","data-index"])]),_:3},16,["items","min-item-size","direction","key-field","list-tag","item-tag"])}const ye=fe._(pe,[["render",ve]]),ze={__name:"DtScroller",props:{direction:{type:String,default:"vertical",validator:e=>["vertical","horizontal"].includes(e)},dynamic:{type:Boolean,default:!1},itemSize:{type:Number,default:null},itemTag:{type:String,default:"div"},items:{type:Array,required:!0},keyField:{type:String,default:"id"},listTag:{type:String,default:"div"},minItemSize:{type:[Number,String],default:null},scrollerHeight:{type:[String,Number],default:"100%"},scrollerWidth:{type:[String,Number],default:"100%"}},emits:["user-position"],setup(e,{expose:s,emit:n}){const i=e,y=n;t.provide("emit",y);const m=t.ref(null),z=t.computed(()=>({width:typeof i.scrollerWidth=="number"?`${i.scrollerWidth}px`:i.scrollerWidth,height:typeof i.scrollerHeight=="number"?`${i.scrollerHeight}px`:i.scrollerHeight}));t.watch(i,()=>{B()},{deep:!0,immediate:!0});function h(){m.value&&m.value.scrollToBottom()}function S(I){m.value&&m.value.scrollToItem(I)}function g(){m.value&&(i.dynamic?m.value.dynamicScrollerUpdateItems():m.value._updateVisibleItems(!0))}function p(){m.value&&(i.dynamic?m.value.dynamicScrollerUpdateItemsFromBottom():m.value._updateVisibleItems(!1,!0))}function B(){i.dynamic&&!i.minItemSize&&console.error("scroller error: 'minItemSize' is required on 'dynamic' mode."),!i.dynamic&&!i.itemSize&&console.error("scroller error: 'itemSize' is required.")}return s({scrollToBottom:h,scrollToItem:S,updateItems:g,updateItemsFromBottom:p}),(I,F)=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.dynamic?ye:ie),{ref_key:"scroller",ref:m,"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:t.normalizeStyle(z.value),tabindex:"0",onUserPosition:F[0]||(F[0]=A=>I.$emit("user-position",A))},{default:t.withCtx(({item:A,index:R,active:U})=>[t.renderSlot(I.$slots,"default",t.normalizeProps(t.guardReactiveProps({item:A,index:R,active:U})))]),_:3},40,["items","item-size","min-item-size","direction","key-field","list-tag","item-tag","style"]))}};exports.DtScroller=ze;
+"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;
 //# sourceMappingURL=scroller.cjs.map