@ldmjs/ui 1.0.19 → 1.0.20

package/dist/index.js

@@ -11575,13 +11575,29 @@ function ld_select_list_box_reg(vue, options) {
 }
 /* harmony default export */ const src_ld_select_list_box = (ld_select_list_box_reg);
 
-;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use!./src/ld-checkbox/ld-checkbox.vue?vue&type=template&id=26c765c2&ts=true
+;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use!./src/ld-checkbox/ld-checkbox.vue?vue&type=template&id=3c187dcd&ts=true
 
-const ld_checkboxvue_type_template_id_26c765c2_ts_true_hoisted_1 = { class: "d-flex align-center" };
-const ld_checkboxvue_type_template_id_26c765c2_ts_true_hoisted_2 = ["checked", "data-testid", "tabindex", "disabled"];
-function ld_checkboxvue_type_template_id_26c765c2_ts_true_render(_ctx, _cache, $props, $setup, $data, $options) {
+const ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_1 = { class: "d-flex align-center" };
+const ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_2 = ["checked", "data-testid", "tabindex", "disabled"];
+const ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_3 = /*#__PURE__*/ (0,external_vue_.createElementVNode)("i", { class: "v-icon" }, [
+    /*#__PURE__*/ (0,external_vue_.createElementVNode)("svg", {
+        width: "14",
+        height: "15",
+        viewBox: "0 0 14 15",
+        fill: "none",
+        id: "done_outline_24",
+        version: "1.1",
+        xmlns: "http://www.w3.org/2000/svg"
+    }, [
+        /*#__PURE__*/ (0,external_vue_.createElementVNode)("path", {
+            d: "M 5.2991701,9.7649048 2.4198478,6.8856204 c -0.1480901,-0.1481205 -0.3881923,-0.1481205 -0.5362898,0 L 1.6235017,7.1456842 c -0.1480902,0.1480445 -0.1480902,0.3881619 0,0.5362822 l 3.4075197,3.4075266 c 0.1480976,0.148046 0.3881999,0.148046 0.5362596,0 l 7.047968,-7.047989 c 0.14812,-0.1480976 0.14812,-0.3881999 0,-0.5362899 L 12.355185,3.245158 c -0.148045,-0.1480978 -0.388162,-0.1480978 -0.536283,0 z",
+            fill: "#fff",
+            style: { "stroke": "#fff", "stroke-width": "1", "stroke-opacity": "1" }
+        })
+    ])
+], -1);
+function ld_checkboxvue_type_template_id_3c187dcd_ts_true_render(_ctx, _cache, $props, $setup, $data, $options) {
     const _component_v_tooltip = (0,external_vue_.resolveComponent)("v-tooltip");
-    const _component_v_icon = (0,external_vue_.resolveComponent)("v-icon");
     return ((0,external_vue_.openBlock)(), (0,external_vue_.createElementBlock)("div", {
         class: (0,external_vue_.normalizeClass)(["ld-checkbox", { 'ld-checkbox--focused': _ctx.isFocused }])
     }, [
@@ -11615,7 +11631,7 @@ function ld_checkboxvue_type_template_id_26c765c2_ts_true_render(_ctx, _cache, $
             ]))
             : (0,external_vue_.createCommentVNode)("", true),
         (0,external_vue_.createTextVNode)(),
-        (0,external_vue_.createElementVNode)("label", ld_checkboxvue_type_template_id_26c765c2_ts_true_hoisted_1, [
+        (0,external_vue_.createElementVNode)("label", ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_1, [
             (0,external_vue_.createElementVNode)("input", {
                 ref: "checkbox",
                 type: "checkbox",
@@ -11632,9 +11648,9 @@ function ld_checkboxvue_type_template_id_26c765c2_ts_true_render(_ctx, _cache, $
                 onInput: _cache[3] || (_cache[3] =
                     //@ts-ignore
                     (...args) => (_ctx.onChange && _ctx.onChange(...args)))
-            }, null, 40, ld_checkboxvue_type_template_id_26c765c2_ts_true_hoisted_2),
+            }, null, 40, ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_2),
             (0,external_vue_.createTextVNode)(),
-            (0,external_vue_.createVNode)(_component_v_icon, { icon: "check" })
+            ld_checkboxvue_type_template_id_3c187dcd_ts_true_hoisted_3
         ]),
         (0,external_vue_.createTextVNode)(),
         (_ctx.label && !_ctx.labelOnLeft)
@@ -11670,7 +11686,7 @@ function ld_checkboxvue_type_template_id_26c765c2_ts_true_render(_ctx, _cache, $
     ], 2));
 }
 
-;// CONCATENATED MODULE: ./src/ld-checkbox/ld-checkbox.vue?vue&type=template&id=26c765c2&ts=true
+;// CONCATENATED MODULE: ./src/ld-checkbox/ld-checkbox.vue?vue&type=template&id=3c187dcd&ts=true
 
 ;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./src/ld-checkbox/ld-checkbox.ts?vue&type=script&lang=ts&external
 var ld_checkboxvue_type_script_lang_ts_external_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
@@ -11827,7 +11843,7 @@ ld_checkboxvue_type_script_lang_ts_external_decorate([
     ld_checkboxvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
 ], CheckboxComponent.prototype, "emitUpdateModelValue", null);
 ld_checkboxvue_type_script_lang_ts_external_decorate([
-    (0,external_vue_property_decorator_.Watch)('modelValue'),
+    (0,external_vue_property_decorator_.Watch)('modelValue', { deep: true }),
     ld_checkboxvue_type_script_lang_ts_external_metadata("design:type", Function),
     ld_checkboxvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
     ld_checkboxvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
@@ -11843,7 +11859,7 @@ ld_checkboxvue_type_script_lang_ts_external_decorate([
 ;
 
 
-const ld_checkbox_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(CheckboxComponent, [['render',ld_checkboxvue_type_template_id_26c765c2_ts_true_render]])
+const ld_checkbox_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(CheckboxComponent, [['render',ld_checkboxvue_type_template_id_3c187dcd_ts_true_render]])
 
 /* harmony default export */ const ld_checkbox = (ld_checkbox_exports_);
 ;// CONCATENATED MODULE: ./src/ld-checkbox/index.ts
@@ -15299,9 +15315,46 @@ function toServerString(dt) {
     };
     return `${dt.getFullYear()}-${pad(dt.getMonth() + 1)}-${pad(dt.getDate())}T${pad(dt.getHours())}:${pad(dt.getMinutes())}:${pad(dt.getSeconds())}${dif}${pad(tzo / 60)}:${pad(tzo % 60)}`;
 }
+function convert(d) {
+    // Converts the date in d to a date-object. The input can be:
+    //   a date object    : returned without modification
+    //   an array         : Interpreted as [year,month,day]. NOTE: month is 0-11.
+    //   a number         : Interpreted as number of milliseconds
+    //                      since 1 Jan 1970 (a timestamp)
+    //   a string         : Any format supported by the javascript engine, like
+    //                      "YYYY/MM/DD", "MM/DD/YYYY", "Jan 31 2009" etc.
+    //   an object        : Interpreted as an object with year, month and date
+    //                      attributes.  **NOTE** month is 0-11.
+    if (d instanceof Date) {
+        return d;
+    }
+    if (Array.isArray(d)) {
+        return new Date(d[0], d[1], d[2]);
+    }
+    if (typeof d === 'number' || typeof d === 'string') {
+        return new Date(d);
+    }
+    if (typeof d === 'object' && 'year' in d && 'month' in d && 'date' in d) {
+        return new Date(d.year, d.month, d.date, d.hours, d.minutes, d.seconds, d.ms);
+    }
+    return d;
+}
+function compare(a, b) {
+    // Compare two dates (could be of any type supported by the convert
+    // function above) and returns:
+    //  -1 : if a < b
+    //   0 : if a = b
+    //   1 : if a > b
+    // NaN : if a or b is an illegal date
+    // NOTE: The code inside isFinite does an assignment (=).
+    const a1 = a ? convert(a).valueOf() : 0;
+    const b1 = b ? convert(b).valueOf() : 0;
+    return isFinite(a1) && isFinite(b1) ? Number(a1 > b1) - Number(a1 < b1) : NaN;
+}
 const datetime = {
     dateLocalToISO,
-    toServerString
+    toServerString,
+    compare
 };
 
 
@@ -16698,6 +16751,1369 @@ function ld_dialog_reg(vue, options) {
 }
 /* harmony default export */ const src_ld_dialog = (ld_dialog_reg);
 
+;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use!./src/ld-data-iterator/ld-data-iterator.vue?vue&type=template&id=7f1ec2b2&ts=true
+
+const ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_hoisted_1 = { class: "ld-data-iterator" };
+const ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_hoisted_2 = {
+    key: 0,
+    class: "top-fixed-item-wrapper"
+};
+function ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_render(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_iterator_item = (0,external_vue_.resolveComponent)("iterator-item");
+    return ((0,external_vue_.openBlock)(), (0,external_vue_.createElementBlock)("div", ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_hoisted_1, [
+        (_ctx.fixedTopContext)
+            ? ((0,external_vue_.openBlock)(), (0,external_vue_.createElementBlock)("div", ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_hoisted_2, [
+                (0,external_vue_.createVNode)(_component_iterator_item, {
+                    id: 'idx' + _ctx.fixedTopContext.rowIndex,
+                    class: "top-fixed-item",
+                    "data-uid": _ctx.id(_ctx.fixedTopContext.row),
+                    "data-test-id": "topFixedIeratorItem",
+                    onClick: _cache[0] || (_cache[0] = ($event) => (_ctx.onClick(_ctx.fixedTopContext))),
+                    onDblclick: _cache[1] || (_cache[1] = ($event) => (_ctx.onClick(_ctx.fixedTopContext))),
+                    onUpdateHeight: _ctx.onUpdateFixedTopHeight
+                }, {
+                    default: (0,external_vue_.withCtx)(() => [
+                        (0,external_vue_.renderSlot)(_ctx.$slots, "default", (0,external_vue_.normalizeProps)((0,external_vue_.guardReactiveProps)({ item: _ctx.fixedTopContext.row })), () => [
+                            (0,external_vue_.createTextVNode)((0,external_vue_.toDisplayString)(_ctx.entityFromItem(_ctx.fixedTopContext.row)[_ctx.keyProp]), 1)
+                        ])
+                    ]),
+                    _: 3
+                }, 8, ["id", "data-uid", "onUpdateHeight"])
+            ]))
+            : (0,external_vue_.createCommentVNode)("", true),
+        (0,external_vue_.createTextVNode)(),
+        (0,external_vue_.createElementVNode)("div", {
+            ref: "list",
+            id: "iterator-list",
+            class: "iterator-list",
+            style: (0,external_vue_.normalizeStyle)(_ctx.listStyles)
+        }, [
+            (0,external_vue_.createElementVNode)("div", {
+                ref: "scroller",
+                class: (0,external_vue_.normalizeClass)(["scroller", { mobile: _ctx.isMobileGlobal }]),
+                style: (0,external_vue_.normalizeStyle)(_ctx.scrollerStyles)
+            }, [
+                ((0,external_vue_.openBlock)(true), (0,external_vue_.createElementBlock)(external_vue_.Fragment, null, (0,external_vue_.renderList)(_ctx.visibleItems, (item) => {
+                    return ((0,external_vue_.openBlock)(), (0,external_vue_.createBlock)(_component_iterator_item, {
+                        id: 'idx' + item.rowIndex,
+                        class: (0,external_vue_.normalizeClass)(["item", { 'active-list-item': _ctx.isItemActive(item), mobile: _ctx.isMobileGlobal, blink: _ctx.isItemRemoving(item) }]),
+                        key: _ctx.id(item.row),
+                        "data-uid": _ctx.id(item.row),
+                        style: (0,external_vue_.normalizeStyle)(_ctx.itemStyles(item)),
+                        "refresh-counter": _ctx.refreshCounter,
+                        "data-test-id": "iteratorItem",
+                        onClick: ($event) => (_ctx.onClick(item)),
+                        onDblclick: ($event) => (_ctx.onClick(item)),
+                        onUpdateHeight: ($event) => (_ctx.onUpdateItemHeight(item, $event))
+                    }, {
+                        default: (0,external_vue_.withCtx)(() => [
+                            (0,external_vue_.renderSlot)(_ctx.$slots, "default", (0,external_vue_.normalizeProps)((0,external_vue_.guardReactiveProps)({ item: item.row, itemContext: { index: item.rowIndex } })), () => [
+                                (0,external_vue_.createTextVNode)((0,external_vue_.toDisplayString)(_ctx.entityFromItem(item.row) ? _ctx.entityFromItem(item.row)[_ctx.keyProp] : 'empty item'), 1)
+                            ])
+                        ]),
+                        _: 2
+                    }, 1032, ["id", "class", "data-uid", "style", "refresh-counter", "onClick", "onDblclick", "onUpdateHeight"]));
+                }), 128))
+            ], 6)
+        ], 4)
+    ]));
+}
+
+;// CONCATENATED MODULE: ./src/ld-data-iterator/ld-data-iterator.vue?vue&type=template&id=7f1ec2b2&ts=true
+
+;// CONCATENATED MODULE: ./src/ld-data-iterator/iteratorItem.ts
+var iteratorItem_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var iteratorItem_metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var IteratorItemComponent_1;
+
+
+let IteratorItemComponent = IteratorItemComponent_1 = class IteratorItemComponent extends external_vue_property_decorator_.Vue {
+    constructor() {
+        super(...arguments);
+        this.height = 0;
+        this.width = 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.resizeObserver = null;
+        this.elem = null;
+    }
+    emitUpdateHeight(value) {
+        return value;
+    }
+    emitRefreshCounterChanged() {
+        this.emitUpdateHeight(this.$el.clientHeight);
+    }
+    mounted() {
+        this.setupResizeObserver();
+        this.elem = this.$el;
+        this.resizeObserver.observe(this.$el);
+    }
+    beforeUpdate() {
+        if (this.elem !== this.$el) {
+            if (this.resizeObserver) {
+                this.resizeObserver.unobserve(this.elem);
+            }
+            this.setupResizeObserver();
+            this.resizeObserver.observe(this.$el);
+        }
+    }
+    beforeUnmount() {
+        this.resizeObserver.unobserve(this.$el);
+    }
+    setupResizeObserver() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const vm = this;
+        this.resizeObserver = new window.ResizeObserver(entries => {
+            let height = 0;
+            if (entries.length && entries[0].contentRect) {
+                height = entries[0].contentRect.height;
+                vm.width = entries[0].contentRect.width;
+            }
+            else {
+                height = vm.$el.clientHeight;
+                vm.width = vm.$el.clientWidth;
+            }
+            if (height > IteratorItemComponent_1.MIN_HEIGHT_EMTPY_ITEM && height !== vm.height) {
+                vm.height = height;
+                vm.emitUpdateHeight(vm.height);
+            }
+        });
+    }
+};
+IteratorItemComponent.MIN_HEIGHT_EMTPY_ITEM = 20;
+iteratorItem_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    iteratorItem_metadata("design:type", Number)
+], IteratorItemComponent.prototype, "refreshCounter", void 0);
+iteratorItem_decorate([
+    Emit('update-height'),
+    iteratorItem_metadata("design:type", Function),
+    iteratorItem_metadata("design:paramtypes", [Number]),
+    iteratorItem_metadata("design:returntype", void 0)
+], IteratorItemComponent.prototype, "emitUpdateHeight", null);
+iteratorItem_decorate([
+    (0,external_vue_property_decorator_.Watch)('refreshCounter'),
+    iteratorItem_metadata("design:type", Function),
+    iteratorItem_metadata("design:paramtypes", []),
+    iteratorItem_metadata("design:returntype", void 0)
+], IteratorItemComponent.prototype, "emitRefreshCounterChanged", null);
+IteratorItemComponent = IteratorItemComponent_1 = iteratorItem_decorate([
+    (0,external_vue_property_decorator_.Options)({
+        name: 'IteratorItem',
+        template: `
+    <div @click="$emit('click', $event)" @dblclick="$emit('dblclick', $event)">
+      <slot></slot>
+    </div>
+  `,
+        emits: ['click', 'dblclick'],
+    })
+], IteratorItemComponent);
+/* harmony default export */ const iteratorItem = (IteratorItemComponent);
+
+;// CONCATENATED MODULE: ./src/utils/strings.ts
+function camelCase(str) {
+    // Replace special characters with a space
+    str = str.replace(/[^\d A-Za-z]/g, ' ');
+    // put a space before an uppercase letter
+    str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
+    // Lower case first character and some other stuff
+    str = str
+        .replace(/([^\d A-Za-z])|^\d+/g, '')
+        .trim()
+        .toLowerCase();
+    // uppercase characters preceded by a space or number
+    str = str.replace(/([\d ]+)([A-Za-z])/g, (a, b, c) => b.trim() + c.toUpperCase());
+    return str;
+}
+const strings = {
+    camelCase
+};
+
+
+;// CONCATENATED MODULE: ./src/ld-data-iterator/prefixes.ts
+/* eslint-disable no-undefined */
+
+const cache = {};
+const testStyle = typeof document !== 'undefined' ? document.createElement('div').style : undefined;
+// Get Prefix
+// http://davidwalsh.name/vendor-prefix
+const prefix = (function () {
+    const styles = typeof window !== 'undefined' ? window.getComputedStyle(document.documentElement, '') : undefined;
+    const match = typeof styles !== 'undefined'
+        ? Array.prototype.slice
+            .call(styles)
+            .join('')
+            .match(/-(moz|webkit|ms)-/)
+        : null;
+    const pre = match !== null ? match[1] : undefined;
+    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+    const dom = typeof pre !== 'undefined' ? 'WebKit|Moz|MS|O'.match(new RegExp('(' + pre + ')', 'i'))[1] : undefined;
+    return dom
+        ? {
+            dom,
+            lowercase: pre,
+            css: `-${pre}-`,
+            js: pre[0].toUpperCase() + pre.substr(1),
+        }
+        : undefined;
+})();
+function getVendorPrefixedName(property) {
+    const name = strings.camelCase(property);
+    if (!cache[name]) {
+        if (prefix !== undefined && testStyle[(prefix.css + property)] !== undefined) {
+            cache[name] = prefix.css + property;
+        }
+        else if (testStyle[property] !== undefined) {
+            cache[name] = property;
+        }
+    }
+    return cache[name];
+}
+
+;// CONCATENATED MODULE: ./src/ld-data-iterator/translate.ts
+
+
+// browser detection and prefixing tools
+const transform = typeof window !== 'undefined' ? getVendorPrefixedName('transform') : undefined;
+const backfaceVisibility = typeof window !== 'undefined' ? getVendorPrefixedName('backfaceVisibility') : undefined;
+const hasCSSTransforms = typeof window !== 'undefined' ? Boolean(getVendorPrefixedName('transform')) : undefined;
+const hasCSS3DTransforms = typeof window !== 'undefined' ? Boolean(getVendorPrefixedName('perspective')) : undefined;
+const ua = typeof window !== 'undefined' ? window.navigator.userAgent : 'Chrome';
+const isSafari = ua.includes('Safari/') && !ua.includes('Chrome/');
+function translateXY(styles, x, y) {
+    if (typeof transform !== 'undefined' && hasCSSTransforms) {
+        if (!isSafari && hasCSS3DTransforms) {
+            styles[transform] = `translate3d(${x}px, ${y}px, 0)`;
+            styles[backfaceVisibility] = 'hidden';
+        }
+        else {
+            styles[strings.camelCase(transform)] = `translate(${x}px, ${y}px)`;
+        }
+    }
+    else {
+        styles.top = `${y}px`;
+        styles.left = `${x}px`;
+    }
+}
+
+;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./src/ld-data-iterator/ld-data-iterator.ts?vue&type=script&lang=ts&external
+var ld_data_iteratorvue_type_script_lang_ts_external_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ld_data_iteratorvue_type_script_lang_ts_external_metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var DataIteratorComponent_1;
+var ld_data_iteratorvue_type_script_lang_ts_external_a, ld_data_iteratorvue_type_script_lang_ts_external_b, ld_data_iteratorvue_type_script_lang_ts_external_c, ld_data_iteratorvue_type_script_lang_ts_external_d, ld_data_iteratorvue_type_script_lang_ts_external_e, ld_data_iteratorvue_type_script_lang_ts_external_f, ld_data_iteratorvue_type_script_lang_ts_external_g, ld_data_iteratorvue_type_script_lang_ts_external_h, ld_data_iteratorvue_type_script_lang_ts_external_j, _k, _l, _m;
+
+
+
+
+
+
+var ScrollTo;
+(function (ScrollTo) {
+    ScrollTo[ScrollTo["None"] = 0] = "None";
+    ScrollTo[ScrollTo["Page"] = 1] = "Page";
+    ScrollTo[ScrollTo["ActiveRow"] = 2] = "ActiveRow";
+    ScrollTo[ScrollTo["DoubleCheck"] = 3] = "DoubleCheck";
+})(ScrollTo || (ScrollTo = {}));
+let DataIteratorComponent = DataIteratorComponent_1 = class DataIteratorComponent extends (0,external_vue_property_decorator_.mixins)(ViewportMixin) {
+    constructor() {
+        super(...arguments);
+        this.clicks = 0;
+        this.scrollbarV = true;
+        this.innerWidth = 0;
+        this.bodyHeight = 0;
+        this.offsetY = 0;
+        this.currentPage = 0;
+        this.activeRowIndex = -1;
+        this.oldRowCount = 0;
+        this.rowContexts = [];
+        this.visibleItems = [];
+        this.afterEmptyItems = [];
+        this.beforeEmptyItems = [];
+        this.rowHeightsUpdate = [];
+        this.lastRowOffsetY = 0;
+        this.enabledPages = null;
+        this.itemsWaitingHeight = new Set();
+        this.refreshCounter = 0;
+        this.fixedTopContext = null;
+        this.firstVisible = 0;
+        this.lastVisible = 0;
+        this.loading = false;
+        this.scrollTo = ScrollTo.None;
+        this.removingIndex = -1;
+        this.changedItemsPromise = Promise.resolve();
+    }
+    emitUpdateLoading(value) {
+        return value;
+    }
+    emitUpdateTotalPages(value) {
+        return value;
+    }
+    emitUpdatePage(value) {
+        return value;
+    }
+    emitUpdateSelect(row, index) {
+        //
+    }
+    emitClick(row, index) {
+        //
+    }
+    emitDblclick(row, index) {
+        //
+    }
+    emitLoadingChanged() {
+        this.emitUpdateLoading(this.loading);
+    }
+    async onItemsChanged(newVal, oldVal) {
+        if (newVal === oldVal) {
+            // дождемся обработки предыдущего изменения (т.к. удаление работает с задержкой на анимацию)
+            await this.changedItemsPromise;
+            let changeReason = 'updated';
+            if (newVal.length < this.oldRowCount) {
+                changeReason = 'removed';
+            }
+            else if (newVal.length > this.oldRowCount) {
+                changeReason = 'added';
+            }
+            if (changeReason === 'removed' && this.removedItem) {
+                this.changedItemsPromise = this.removeItem();
+                await this.changedItemsPromise;
+                this.removingIndex = -1;
+            }
+            this.rowContexts.forEach((rc, i) => {
+                if (newVal[rc.index]) {
+                    rc.row = newVal[rc.index];
+                }
+            });
+            if (changeReason === 'added') {
+                const diff = newVal.length - this.oldRowCount;
+                for (let i = 0; i < diff; i++) {
+                    const rc = this.rowContexts[this.oldRowCount - 1 + i];
+                    this.rowContexts.push({
+                        index: this.oldRowCount + i,
+                        rowIndex: this.oldRowCount + i,
+                        offsetY: rc ? rc.offsetY + this.approximateRowHeight : 0,
+                        row: newVal[this.oldRowCount + i],
+                        rowHeight: this.approximateRowHeight,
+                    });
+                }
+                this.sort();
+                this.updateRows(true);
+            }
+            this.oldRowCount = this.rowContexts.length;
+            return;
+        }
+        this.visibleItems = [];
+        this.rowContexts = [];
+        if (newVal !== oldVal) {
+            await this.$nextTick();
+        }
+        this.rowsChanged = true;
+        this.init();
+        this.sort();
+        this.oldRowCount = this.rowContexts.length;
+        this.offsetY = -1;
+        this.currentPage = -1;
+        this.totalPages = this.rowCount && this.page >= 0 ? this.page + 1 : 1;
+        this.emitUpdateTotalPages(this.totalPages);
+        this.listEl.scrollTop = 0;
+        if (newVal !== oldVal) {
+            this.listEl.style['visibility'] = 'hidden';
+        }
+        this.waitingForFirstPageRendered = true;
+        DataIteratorComponent_1.CNT = 0;
+        DataIteratorComponent_1.COUNTER = 0;
+        if (!this.rowContexts.length) {
+            this.renderPromise = Promise.resolve();
+        }
+        else {
+            this.renderPromise = new Promise(resolve => {
+                this.renderResolve = resolve;
+            });
+        }
+        try {
+            await this.renderPromise;
+            if (!this.selectedIndices.length) {
+                this.setSelected(0);
+            }
+        }
+        finally {
+            if (this.listEl) {
+                this.listEl.style['visibility'] = 'unset';
+            }
+            this.waitingForFirstPageRendered = false;
+            if (this.rowContexts.length) {
+                this.onPageChanged();
+            }
+        }
+    }
+    onScrollHeightChanged() {
+        this.calcTotalPages();
+    }
+    async onFixTopActiveItemChanged() {
+        if (!this.activeItem && !this.fixTopActiveItem) {
+            return;
+        }
+        if (this.fixTopActiveItem) {
+            this.fixedTopContext = this.excludeItem(this.activeItem);
+        }
+        else {
+            this.includeItem(this.fixedTopContext);
+            this.fixedTopContext = null;
+        }
+        await this.$nextTick();
+        if (this.listEl) {
+            const dims = this.listEl.getBoundingClientRect();
+            this.innerWidth = Math.floor(dims.width);
+            this.bodyHeight = dims.height;
+        }
+        this.updateRows(true);
+        this.updatePage();
+        await this.$nextTick();
+        this.calcTotalPages();
+    }
+    onMinRowHeightChanged() {
+        this.onItemsChanged(this.items, null);
+    }
+    onPageChanged() {
+        if (this.page === this.currentPage ||
+            this.waitingForFirstPageRendered ||
+            // eslint-disable-next-line no-undefined
+            this.waitingForFirstPageRendered === undefined) {
+            return;
+        }
+        DataIteratorComponent_1.COUNTER = 0;
+        if ((this.rowCount && !this.visibleItems.length) || !this.listEl) {
+            this.callOnPageChanged = true;
+            this.startCheckAllRowsIsRendered();
+            return;
+        }
+        // установить offsetY начала страницы
+        let offsetY = (this.page - 1) * this.bodyHeight;
+        offsetY += 1;
+        const pageDiff = Math.abs(this.currentPage - this.page);
+        let first = this.getRowIndex(offsetY);
+        this.firstRowForPage = first;
+        this.scrollTo = ScrollTo.Page;
+        const last = Math.min(first + this.visibleItems.length - 1, this.rowHeightsUpdate.length - 1);
+        if ((pageDiff > 1 || (this.toLastPage && !this.scrollToActiveItem)) &&
+            (!this.rowHeightsUpdate[first] || !this.rowHeightsUpdate[last])) {
+            this.loading = true;
+            // найдем 1-й элемент по средней высоте элемента
+            first = this.getRowIndexByAverage(offsetY);
+            if (first >= this.items.length - 1) {
+                first = this.items.length - 10;
+            }
+            this.firstRowForPage = first;
+        }
+        const rowContext = this.rowContexts[first];
+        this.fromPager = true;
+        if (this.scrollToActiveItem && this.currentPage < 0) {
+            // для режима превью и первой загрузки списка перейдем к активному элементу (т.е., возможно, изменим страницу)
+            this.scrollTo = ScrollTo.ActiveRow;
+            this.firstRowForPage = null;
+        }
+        this.currentPage = this.page;
+        if (rowContext) {
+            this.listEl.scrollTop = rowContext.offsetY;
+            if (this.shouldSetActiveRow) {
+                this.shouldSetActiveRow = false;
+                this.setSelected(first);
+            }
+        }
+        this.startCheckAllRowsIsRendered();
+    }
+    onSortFieldChanged(newVal, oldVal) {
+        if (newVal?.prop !== oldVal?.prop || newVal?.direction !== oldVal?.direction) {
+            this.sort();
+            this.updateRows(true);
+        }
+    }
+    onSelectedIndicesChanged() {
+        if (Array.isArray(this.selectedIndices) && this.selectedIndices.length) {
+            const index = this.selectedIndices[0];
+            const i = this.rowContexts.findIndex(r => r.index === index);
+            if (i >= 0) {
+                this.activeRowIndex = i;
+            }
+        }
+        else {
+            this.activeRowIndex = -1;
+        }
+    }
+    async onFirstItemSelectCounterChanged() {
+        await this.renderPromise;
+        this.setSelected(0);
+    }
+    onNextItemSelectCounterChanged() {
+        if (this.activeRowIndex + 1 < this.rowContexts.length) {
+            this.setSelected(this.activeRowIndex + 1);
+        }
+    }
+    async onInnerWidthChanged(newVal, oldVal) {
+        if (!oldVal) {
+            return;
+        }
+        this.updateRowOffsetsCache(0, true);
+        this.updateRows(true);
+        this.updatePage();
+        await this.$nextTick();
+        this.calcTotalPages();
+    }
+    created() {
+        this.onItemsChanged(this.items, null);
+    }
+    mounted() {
+        if (window.ResizeObserver) {
+            this.resizeObserver = new window.ResizeObserver(entries => {
+                if (entries.length && entries[0].contentRect) {
+                    this.bodyHeight = entries[0].contentRect.height;
+                    this.innerWidth = entries[0].contentRect.width;
+                }
+                else {
+                    this.bodyHeight = this.$el.clientHeight;
+                    this.innerWidth = this.$el.clientWidth;
+                }
+            });
+            this.resizeObserver.observe(this.$el);
+        }
+        this.listEl = this.$el.querySelector('#iterator-list');
+        const dims = this.listEl.getBoundingClientRect();
+        this.innerWidth = Math.floor(dims.width);
+        this.bodyHeight = dims.height;
+        this.init();
+        this.offsetY = 0;
+        this.currentPage = -1;
+        this.totalPages = 1;
+        this.onKeyDownHandler = this.onKeyDown.bind(this);
+        document.addEventListener('keydown', this.onKeyDownHandler);
+        this.tick();
+    }
+    beforeUnmount() {
+        this.stopTick = true;
+        document.removeEventListener('keydown', this.onKeyDownHandler);
+        if (this.resizeObserver) {
+            this.resizeObserver.unobserve(this.$el);
+        }
+    }
+    tick(force = false) {
+        if (this.stopTick) {
+            return;
+        }
+        requestAnimationFrame(() => this.tick());
+        this.loading = this.waitingForFirstPageRendered || Boolean(this.scrollTo !== ScrollTo.None);
+        if (this.scrollbarV) {
+            if (!this.listEl) {
+                return;
+            }
+            const scrollTop = this.listEl.scrollTop;
+            if (!force && this.offsetY === scrollTop) {
+                return;
+            }
+            this.offsetY = scrollTop;
+            clearTimeout(this.updatePageTimeoutId);
+            if (this.scrollTo === ScrollTo.Page) {
+                // чтобы был виден лоадер нужно вызвать через setTimeout
+                setTimeout(() => this.updateRows(), 10);
+            }
+            else {
+                this.updateRows();
+            }
+            this.updatePageTimeoutId = setTimeout(() => this.updatePage(), 100);
+        }
+    }
+    isItemActive(item) {
+        return item.row === this.activeItem;
+    }
+    isItemRemoving(rc) {
+        return rc.rowIndex === this.removingIndex;
+    }
+    onClick(rc) {
+        this.clicks++;
+        if (this.clicks === 1) {
+            this.timerId = setTimeout(() => {
+                this.emitClick(rc.row, rc.index);
+                this.clicks = 0;
+            }, 200);
+        }
+        else {
+            clearTimeout(this.timerId);
+            this.emitDblclick(rc.row, rc.index);
+            this.clicks = 0;
+        }
+        this.setSelected(rc.rowIndex);
+    }
+    onFocus() {
+        this.isFocused = true;
+    }
+    onBlur() {
+        this.isFocused = false;
+    }
+    onUpdateFixedTopHeight(height) {
+        if (!this.fixedTopContext) {
+            return;
+        }
+        this.fixedTopContext.rowHeight = height;
+    }
+    onUpdateItemHeight(rowContext, height) {
+        try {
+            height += this.itemGap;
+            if (this.rowHeightsUpdate[rowContext.rowIndex] && rowContext.rowHeight === height) {
+                return;
+            }
+            rowContext.rowHeight = height;
+            this.itemsWaitingHeight.delete(rowContext.rowIndex);
+            if (rowContext.rowIndex === 0) {
+                rowContext.offsetY = 0;
+            }
+            clearTimeout(this.waitForAllRowsUpdatedTimer);
+            this.waitForAllRowsUpdatedTimer = setTimeout(() => {
+                if (this.itemsWaitingHeight.size && DataIteratorComponent_1.CNT < 50) {
+                    DataIteratorComponent_1.CNT++;
+                    return;
+                }
+                if (this.waitingForFirstPageRendered) {
+                    this.renderResolve();
+                }
+                else {
+                    this.startCheckAllRowsIsRendered();
+                }
+            }, 50);
+        }
+        finally {
+            this.rowHeightsUpdate[rowContext.rowIndex] = true;
+            if (!this.itemsWaitingHeight.size) {
+                this.updateRowOffsetsCache(this.firstVisible, true);
+            }
+        }
+    }
+    startCheckAllRowsIsRendered(timeout) {
+        this.stopCheckAllRowsIsRendered();
+        this.checkRowsUpdatedTimer = setTimeout(() => this.checkRowsUpdated(), timeout ?? 50);
+    }
+    stopCheckAllRowsIsRendered() {
+        clearTimeout(this.checkRowsUpdatedTimer);
+    }
+    checkRowsUpdated() {
+        if (this.itemsWaitingHeight.size || !this.listEl) {
+            DataIteratorComponent_1.COUNTER++;
+            if (DataIteratorComponent_1.COUNTER > 50) {
+                this.itemsWaitingHeight.clear();
+                this.updateRowOffsetsCache(0, true);
+            }
+            this.startCheckAllRowsIsRendered();
+            return;
+        }
+        this.stopCheckAllRowsIsRendered();
+        this.fromPager = false;
+        if (this.callOnPageChanged) {
+            // нужно дополнительно вызвать onPageChanged
+            this.callOnPageChanged = false;
+            this.$nextTick(() => this.onPageChanged());
+            return;
+        }
+        if (this.scrollTo === ScrollTo.DoubleCheck) {
+            let first = this.firstRowForPage ?? this.activeRowIndex;
+            // eslint-disable-next-line no-undefined
+            if (first === null || first === undefined || first < 0) {
+                this.onSelectedIndicesChanged();
+                first = this.activeRowIndex;
+                this.setSelected(first);
+            }
+            if (first >= 0 && this.rowHeightsUpdate[first]) {
+                const rc = this.rowContexts[first];
+                const el = this.listEl;
+                const bottom = el.scrollTop + this.bodyHeight;
+                if (rc.offsetY >= el.scrollTop && (rc.offsetY + rc.rowHeight <= bottom || rc.rowHeight >= bottom)) {
+                    this.scrollTo = ScrollTo.None;
+                    this.firstRowForPage = null;
+                    this.updatePage();
+                    if (this.toLastPage && this.currentPage < this.totalPages && DataIteratorComponent_1.COUNTER < 10) {
+                        DataIteratorComponent_1.COUNTER++;
+                        this.scrollTo = ScrollTo.Page;
+                        this.firstRowForPage = this.rowCount - 5;
+                    }
+                }
+                else {
+                    el.scrollTop = rc.offsetY;
+                }
+            }
+            else {
+                this.scrollTo = ScrollTo.None;
+            }
+        }
+        if (this.scrollTo === ScrollTo.Page || this.scrollTo === ScrollTo.ActiveRow) {
+            // переход на страницу, которая еще не рендерилась
+            let first = this.firstRowForPage;
+            if (this.scrollTo === ScrollTo.ActiveRow) {
+                if (this.activeRowIndex < 0) {
+                    this.onSelectedIndicesChanged();
+                    this.setSelected(this.activeRowIndex);
+                }
+                first = this.activeRowIndex;
+            }
+            this.scrollTo = ScrollTo.DoubleCheck;
+            if (first >= 0) {
+                const rc = this.rowContexts[first];
+                const el = this.listEl;
+                el.scrollTop = rc?.offsetY ?? 0;
+            }
+        }
+        if (this.scrollTo !== ScrollTo.None) {
+            this.startCheckAllRowsIsRendered(100);
+        }
+    }
+    updateRowOffsetsCache(rowIndex, all) {
+        let context = this.rowContexts[rowIndex];
+        if (!context) {
+            return;
+        }
+        let offsetY = context.offsetY;
+        let height = 0;
+        const last = all ? this.rowContexts.length : this.lastVisible + 1;
+        while (context && rowIndex < last) {
+            context.offsetY = offsetY;
+            this.rowContexts[rowIndex] = context;
+            height = context.rowHeight;
+            offsetY += height;
+            rowIndex++;
+            context = this.rowContexts[rowIndex];
+        }
+        this.lastRowOffsetY = offsetY;
+    }
+    itemStyles(rowContext) {
+        const styles = {};
+        if (rowContext.rowIndex === 0) {
+            translateXY(styles, 0, 0);
+            return styles;
+        }
+        if (rowContext.offsetY) {
+            translateXY(styles, 0, rowContext.offsetY);
+            return styles;
+        }
+        const posY = this.rowContexts[rowContext.rowIndex].offsetY;
+        translateXY(styles, 0, posY);
+        return styles;
+    }
+    topFixedStyles() {
+        return {
+            height: this.fixedTopContext?.rowHeight + 'px',
+        };
+    }
+    emptyItemStyles(rowContext) {
+        const styles = {
+            height: rowContext.rowHeight + 'px',
+        };
+        if (rowContext.offsetY) {
+            translateXY(styles, 0, rowContext.offsetY);
+        }
+        return styles;
+    }
+    onKeyDown(event) {
+        const target = event.target;
+        if (target.tagName !== 'BODY') {
+            return;
+        }
+        if (['ArrowUp', 'PageUp', 'ArrowDown', 'PageDown'].includes(event.code)) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+        if (['PageUp', 'PageDown'].includes(event.code)) {
+            if (event.code === 'PageUp' && this.currentPage > 0) {
+                this.shouldSetActiveRow = true;
+                this.emitUpdatePage(this.currentPage - 1);
+                return;
+            }
+            if (event.code === 'PageDown' && this.currentPage < this.totalPages) {
+                this.shouldSetActiveRow = true;
+                this.emitUpdatePage(this.currentPage + 1);
+                return;
+            }
+        }
+        let nextRowIndex = -1;
+        const maxRowIndex = this.rowContexts[this.rowContexts.length - 1]?.rowIndex;
+        switch (event.code) {
+            case 'ArrowUp':
+                if (this.activeRowIndex > 0) {
+                    nextRowIndex = this.activeRowIndex - 1;
+                }
+                break;
+            case 'ArrowDown':
+                if (this.activeRowIndex < this.rowContexts.length - 1) {
+                    nextRowIndex = this.activeRowIndex + 1;
+                }
+                break;
+        }
+        if (nextRowIndex < 0 || nextRowIndex > maxRowIndex) {
+            return;
+        }
+        const { offsetY, rowHeight } = this.rowContexts[nextRowIndex];
+        if (!rowHeight) {
+            return;
+        }
+        let h = 0;
+        let scrollTop = this.listEl.scrollTop;
+        if (event.code === 'ArrowDown') {
+            h = offsetY + rowHeight - (scrollTop + this.bodyHeight);
+        }
+        else if (event.code === 'ArrowUp') {
+            h = offsetY - rowHeight - scrollTop;
+        }
+        if (h > 0 && event.code === 'ArrowDown') {
+            scrollTop += h;
+        }
+        else if (h < 0 && event.code === 'ArrowUp') {
+            scrollTop += h;
+        }
+        else if (h === 0 && event.code === 'ArrowUp' && [0, 1, 2].includes(this.activeRowIndex)) {
+            scrollTop = h;
+        }
+        this.listEl.scrollTop = scrollTop;
+        this.setSelected(nextRowIndex);
+    }
+    calcTotalPages() {
+        let totalPages = this.bodyHeight ? this.scrollHeight / this.bodyHeight : 1;
+        const rounded = Math.floor(totalPages);
+        const rest = totalPages - rounded;
+        const averageHeight = this.getAverageItemHeight();
+        if (rest >= averageHeight / this.scrollHeight) {
+            totalPages = Math.ceil(totalPages);
+        }
+        else {
+            totalPages = rounded;
+        }
+        if (this.totalPages !== totalPages) {
+            this.totalPages = totalPages;
+            this.emitUpdateTotalPages(totalPages);
+        }
+        if (!this.scrollToActiveItem && this.toLastPage && this.currentPage < this.totalPages) {
+            // для перехода на последнюю страницу (для НЕ превью) изменим страницу
+            this.emitUpdatePage(this.totalPages);
+        }
+        return totalPages;
+    }
+    updatePage() {
+        if (this.fromPager || this.currentPage < 0 || this.firstRowForPage || this.callOnPageChanged) {
+            return;
+        }
+        let offset;
+        let realLastVisible = this.lastVisible;
+        for (let i = this.lastVisible; i >= 0; i--) {
+            const rowContext = this.rowContexts[i];
+            if (!rowContext) {
+                throw new Error('null rowContext');
+            }
+            if (this.offsetY + this.bodyHeight >= rowContext.offsetY) {
+                realLastVisible = i;
+                break;
+            }
+        }
+        if (realLastVisible >= this.rowCount - 1 || this.scrollHeight - this.bodyHeight === this.offsetY) {
+            offset = this.totalPages;
+            this.emitUpdateTotalPages(this.totalPages);
+        }
+        else {
+            const index = this.getRowIndex(this.offsetY);
+            const height = this.rowContexts && this.rowContexts.length > index
+                ? this.rowContexts[index]?.rowHeight
+                : this.approximateRowHeight;
+            offset = !index || height >= this.bodyHeight ? 1 : (this.offsetY + height * 2) / this.bodyHeight;
+            if (offset < 1) {
+                offset = 1;
+            }
+            else {
+                offset = Math.ceil(offset);
+            }
+        }
+        if (this.currentPage !== offset) {
+            this.currentPage = offset;
+            this.emitUpdatePage(offset);
+        }
+    }
+    init() {
+        if (this.items?.length) {
+            this.rowContexts = new Array(this.items.length).fill(null);
+            this.rowContexts.forEach((row, i) => {
+                const offsetY = i === 0 ? 0 : this.rowContexts[i - 1].offsetY + this.approximateRowHeight;
+                this.rowContexts[i] = {
+                    offsetY,
+                    row: this.items[i],
+                    rowIndex: i,
+                    index: i,
+                    rowHeight: this.approximateRowHeight,
+                };
+            });
+            this.rowHeightsUpdate = new Array(this.rowCount);
+        }
+        else {
+            this.rowContexts = [];
+            this.rowHeightsUpdate = [];
+        }
+        this.itemsWaitingHeight.clear();
+    }
+    async updateRows(force = false, afterRowsHeight = false) {
+        const { first, last } = this.getIndexes();
+        if (last < first) {
+            return;
+        }
+        if (!force && !this.rowsChanged && this.firstVisible === first && this.lastVisible === last) {
+            return;
+        }
+        this.rowsChanged = false;
+        this.firstVisible = first;
+        this.lastVisible = last;
+        let rowIndex = first;
+        let idx = 0;
+        const temp = new Array(last - first);
+        while (rowIndex <= last && rowIndex < this.rowCount) {
+            const rc = this.rowContexts[rowIndex];
+            if (rc) {
+                temp[idx] = rc;
+                idx++;
+                if (!this.fixedRowHeight && !this.rowHeightsUpdate[rowIndex]) {
+                    this.itemsWaitingHeight.add(rowIndex);
+                }
+            }
+            rowIndex++;
+            if (rowIndex % 50 === 0) {
+                await this.$nextTick();
+            }
+        }
+        this.pageSize = temp.length - 1;
+        this.visibleItems = temp;
+    }
+    getIndexes() {
+        let first = -1;
+        let last = -1;
+        if (!this.rowContexts.length) {
+            return { first, last };
+        }
+        if (this.scrollbarV) {
+            first = this.getRowIndex(this.offsetY);
+            first = Math.max(first - 1, 0);
+            while (first > 0) {
+                if (!this.rowHeightsUpdate[first - 1]) {
+                    first--;
+                }
+                else {
+                    break;
+                }
+            }
+            for (let i = first; i < this.rowContexts.length; i++) {
+                const rowContext = this.rowContexts[i];
+                if (!rowContext) {
+                    throw new Error('null');
+                }
+                if (last === -1 && this.offsetY + this.bodyHeight <= rowContext.offsetY) {
+                    last = i;
+                    break;
+                }
+            }
+        }
+        last = last > 0 ? last : this.rowContexts.length - 1;
+        return { first, last };
+    }
+    getRowIndexByAverage(offsetY) {
+        if (offsetY === 0 || !this.visibleItems.length) {
+            return 0;
+        }
+        const averageHeight = this.getAverageItemHeight();
+        return Math.floor(offsetY / averageHeight);
+    }
+    getAverageItemHeight() {
+        let h = 0;
+        for (const rowContext of this.visibleItems) {
+            h += rowContext.rowHeight;
+        }
+        return this.visibleItems.length ? h / this.visibleItems.length : 0;
+    }
+    getRowIndex(offsetY) {
+        if (offsetY === 0) {
+            return 0;
+        }
+        let n = Math.floor(offsetY / this.approximateRowHeight);
+        n = n >= this.rowCount ? this.rowCount - 1 : n;
+        let result = 0;
+        const diff = 10;
+        for (let i = n; i > 0; i--) {
+            result = i;
+            if (this.rowHeightsUpdate[i] && this.rowContexts[i].offsetY - diff <= offsetY) {
+                return result;
+            }
+        }
+        return 0;
+    }
+    setSelected(rowIndex) {
+        if (rowIndex >= 0) {
+            const rc = this.rowContexts[rowIndex];
+            if (rc) {
+                this.emitUpdateSelect(rc.row, rc.index);
+            }
+        }
+    }
+    sort() {
+        if (!this.rowContexts?.length || !this.sortField || !this.entityFromItem) {
+            return;
+        }
+        this.rowContexts.sort((a, b) => {
+            try {
+                const first = this.entityFromItem(a.row);
+                const second = this.entityFromItem(b.row);
+                if (first && second) {
+                    let result = 0;
+                    switch (this.sortField.type) {
+                        case 'date':
+                            if (!this.$utils.isDefined(first[this.sortField.prop]) || !this.$utils.isDefined(second[this.sortField.prop])) {
+                                result = -1;
+                            }
+                            else {
+                                result = datetime.compare(first[this.sortField.prop], second[this.sortField.prop]);
+                            }
+                            break;
+                        case 'string':
+                            if (!this.$utils.isDefined(first[this.sortField.prop]) || !this.$utils.isDefined(second[this.sortField.prop])) {
+                                result = -1;
+                            }
+                            else {
+                                result = first[this.sortField.prop].localeCompare(second[this.sortField.prop]);
+                            }
+                            break;
+                        case 'number':
+                            if (!this.$utils.isDefined(first[this.sortField.prop]) || !this.$utils.isDefined(second[this.sortField.prop])) {
+                                result = -1;
+                            }
+                            else {
+                                result = first[this.sortField.prop] < second[this.sortField.prop] ? -1 : 1;
+                            }
+                            break;
+                    }
+                    return this.sortField.direction === 'asc' ? result : result * -1;
+                }
+                return 0;
+            }
+            catch (e) {
+                /* eslint-disable no-console */
+                console.error(e);
+            }
+        });
+        this.rowContexts.forEach((rc, i) => {
+            rc.rowIndex = i;
+        });
+        this.rowContexts[0].offsetY = 0;
+        this.updateRowOffsetsCache(0, true);
+    }
+    id(item) {
+        const entity = this.entityFromItem(item);
+        return entity ? entity[this.keyProp] : null;
+    }
+    removeItem() {
+        if (!this.removedItem) {
+            return Promise.resolve();
+        }
+        const rc = this.rowContexts.find(r => r.index === this.removedItem.index);
+        if (!rc) {
+            return;
+        }
+        this.removingIndex = rc.rowIndex;
+        return new Promise(resolve => {
+            // setTimeout позволяет анимировать удаление элемента
+            setTimeout(() => {
+                if (rc) {
+                    this.rowContexts.splice(rc.rowIndex, 1);
+                }
+                for (const rc1 of this.rowContexts) {
+                    if (rc1.rowIndex >= rc.rowIndex) {
+                        rc1.rowIndex--;
+                    }
+                    if (rc1.index > this.removedItem.index) {
+                        rc1.index--;
+                    }
+                }
+                const start = rc.rowIndex - 1 >= 0 ? rc.rowIndex - 1 : 0;
+                if (start === 0 && this.rowContexts.length) {
+                    this.rowContexts[0].offsetY = 0;
+                }
+                this.updateRowOffsetsCache(start, true);
+                this.updateRows(true);
+                resolve();
+            }, 500);
+        });
+    }
+    excludeItem(item) {
+        const index = this.rowContexts.findIndex(c => c.row === item);
+        if (index) {
+            const rowContext = this.rowContexts[index];
+            this.rowContexts.splice(index, 1);
+            return rowContext;
+        }
+        return null;
+    }
+    includeItem(rowContext) {
+        if (!rowContext) {
+            return;
+        }
+        this.rowContexts.splice(rowContext.rowIndex, 0, rowContext);
+    }
+    get listStyles() {
+        return {
+            'padding-left': this.padding + 'px',
+            'padding-right': this.padding + 'px',
+        };
+    }
+    get rowCount() {
+        return this.rowContexts?.length ?? 0;
+    }
+    get approximateRowHeight() {
+        if (this.fixedRowHeight) {
+            return this.rowHeight + this.itemGap;
+        }
+        return this.minRowHeight ?? 50;
+    }
+    get fixedRowHeight() {
+        return typeof this.rowHeight === 'number';
+    }
+    get scrollHeight() {
+        if (!this.bodyHeight) {
+            // вызов нужен для того, чтобы при изменении bodyHeight пересчитался scrollHeight
+            return 0;
+        }
+        let result = 0;
+        if (this.scrollbarV && this.rowCount) {
+            if (this.fixedRowHeight && typeof this.rowHeight === 'number') {
+                const height = this.rowHeight;
+                result = height * this.rowCount;
+            }
+            else if (Array.isArray(this.rowContexts) && this.rowContexts.length) {
+                const rowContext = this.rowContexts[this.rowCount - 1];
+                result = rowContext?.offsetY + rowContext?.rowHeight;
+                result = Math.max(result, this.lastRowOffsetY - this.itemGap);
+            }
+        }
+        if (!result) {
+            result = this.approximateRowHeight * this.rowCount;
+        }
+        return result;
+    }
+    get scrollerStyles() {
+        return {
+            height: (this.scrollHeight || this.approximateRowHeight * this.rowCount) + 'px',
+            width: '100%',
+        };
+    }
+};
+DataIteratorComponent.COUNTER = 0;
+DataIteratorComponent.CNT = 0;
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ type: Array, default: () => [] }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", typeof (ld_data_iteratorvue_type_script_lang_ts_external_a = typeof Array !== "undefined" && Array) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_a : Object)
+], DataIteratorComponent.prototype, "items", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "page", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ required: true }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", String)
+], DataIteratorComponent.prototype, "keyProp", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", typeof (ld_data_iteratorvue_type_script_lang_ts_external_b = typeof TSortField !== "undefined" && TSortField) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_b : Object)
+], DataIteratorComponent.prototype, "sortField", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ type: Function, default: (item) => item }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function)
+], DataIteratorComponent.prototype, "entityFromItem", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ type: Array, default: () => [] }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", typeof (ld_data_iteratorvue_type_script_lang_ts_external_c = typeof Array !== "undefined" && Array) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_c : Object)
+], DataIteratorComponent.prototype, "selectedIndices", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "firstItemSelectCounter", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "nextItemSelectCounter", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "minRowHeight", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Object)
+], DataIteratorComponent.prototype, "rowHeight", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", typeof (ld_data_iteratorvue_type_script_lang_ts_external_d = typeof TListItem !== "undefined" && TListItem) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_d : Object)
+], DataIteratorComponent.prototype, "activeItem", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Boolean)
+], DataIteratorComponent.prototype, "fixTopActiveItem", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "padding", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ default: 5 }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Number)
+], DataIteratorComponent.prototype, "itemGap", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)({ default: false }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Boolean)
+], DataIteratorComponent.prototype, "toLastPage", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Boolean)
+], DataIteratorComponent.prototype, "scrollToActiveItem", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Prop)(),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", typeof (ld_data_iteratorvue_type_script_lang_ts_external_e = typeof TRemovedItem !== "undefined" && TRemovedItem) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_e : Object)
+], DataIteratorComponent.prototype, "removedItem", void 0);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('loading-update'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [Boolean]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitUpdateLoading", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('total-pages'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitUpdateTotalPages", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('page'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitUpdatePage", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('select'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [typeof (ld_data_iteratorvue_type_script_lang_ts_external_f = typeof TListItem !== "undefined" && TListItem) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_f : Object, Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitUpdateSelect", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('click'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [typeof (ld_data_iteratorvue_type_script_lang_ts_external_g = typeof TListItem !== "undefined" && TListItem) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_g : Object, Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitClick", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    Emit('dblclick'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [typeof (ld_data_iteratorvue_type_script_lang_ts_external_h = typeof TListItem !== "undefined" && TListItem) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_h : Object, Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitDblclick", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('loading'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "emitLoadingChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('items', { deep: true }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [typeof (ld_data_iteratorvue_type_script_lang_ts_external_j = typeof Array !== "undefined" && Array) === "function" ? ld_data_iteratorvue_type_script_lang_ts_external_j : Object, typeof (_k = typeof Array !== "undefined" && Array) === "function" ? _k : Object]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", Promise)
+], DataIteratorComponent.prototype, "onItemsChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('scrollHeight'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onScrollHeightChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('fixTopActiveItem'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", Promise)
+], DataIteratorComponent.prototype, "onFixTopActiveItemChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('minRowHeight'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onMinRowHeightChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('page'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onPageChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('sortField'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [typeof (_l = typeof TSortField !== "undefined" && TSortField) === "function" ? _l : Object, typeof (_m = typeof TSortField !== "undefined" && TSortField) === "function" ? _m : Object]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onSortFieldChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('selectedIndices', { immediate: true }),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onSelectedIndicesChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('firstItemSelectCounter'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", Promise)
+], DataIteratorComponent.prototype, "onFirstItemSelectCounterChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('nextItemSelectCounter'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", []),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", void 0)
+], DataIteratorComponent.prototype, "onNextItemSelectCounterChanged", null);
+ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Watch)('innerWidth'),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:type", Function),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:paramtypes", [Number, Number]),
+    ld_data_iteratorvue_type_script_lang_ts_external_metadata("design:returntype", Promise)
+], DataIteratorComponent.prototype, "onInnerWidthChanged", null);
+DataIteratorComponent = DataIteratorComponent_1 = ld_data_iteratorvue_type_script_lang_ts_external_decorate([
+    (0,external_vue_property_decorator_.Options)({
+        name: 'IteratorVirtual',
+        components: {
+            IteratorItem: iteratorItem
+        },
+        emits: ['click', 'dblclick'],
+    })
+], DataIteratorComponent);
+/* harmony default export */ const ld_data_iteratorvue_type_script_lang_ts_external = (DataIteratorComponent);
+
+;// CONCATENATED MODULE: ./src/ld-data-iterator/ld-data-iterator.ts?vue&type=script&lang=ts&external
+ 
+;// CONCATENATED MODULE: ./src/ld-data-iterator/ld-data-iterator.vue
+
+
+
+
+;
+const ld_data_iterator_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(ld_data_iteratorvue_type_script_lang_ts_external, [['render',ld_data_iteratorvue_type_template_id_7f1ec2b2_ts_true_render]])
+
+/* harmony default export */ const ld_data_iterator = (ld_data_iterator_exports_);
+;// CONCATENATED MODULE: ./src/ld-data-iterator/index.ts
+
+function ld_data_iterator_reg(vue, options) {
+    vue.component(options.aliases['ld-data-iterator'], ld_data_iterator);
+}
+/* harmony default export */ const src_ld_data_iterator = (ld_data_iterator_reg);
+
 // EXTERNAL MODULE: external "vue-toastification"
 var external_vue_toastification_ = __webpack_require__(7982);
 var external_vue_toastification_default = /*#__PURE__*/__webpack_require__.n(external_vue_toastification_);
@@ -17017,6 +18433,7 @@ const ValidateMixinOptions = mixin;
 
 
 
+
 
 
 const ldmuiPlugin = {
@@ -17050,6 +18467,7 @@ const ldmuiPlugin = {
             'ld-text-markup': options.aliases?.['ld-text-markup'] ?? 'ld-text-markup',
             'ld-switch': options.aliases?.['ld-switch'] ?? 'ld-switch',
             'ld-dialog': options.aliases?.['ld-dialog'] ?? 'ld-dialog',
+            'ld-data-iterator': options.aliases?.['ld-data-iterator'] ?? 'ld-data-iterator',
         };
         vue.config.globalProperties.$utils = {
             ...src_utils_namespaceObject,
@@ -17101,6 +18519,7 @@ const ldmuiPlugin = {
         src_ld_text_markup(vue, options);
         src_ld_switch(vue, options);
         src_ld_dialog(vue, options);
+        src_ld_data_iterator(vue, options);
     },
 };
 /* harmony default export */ const src = (ldmuiPlugin);