bt-core-app 2.2.5 → 2.2.6

package/dist/bt-core/core/node_modules/vuetify/lib/components/VTextField/VTextField.mjs

@@ -0,0 +1,204 @@
+import { computed as x, ref as h, createVNode as p, mergeProps as b, createElementVNode as o, Fragment as C, withDirectives as te, normalizeClass as le, cloneVNode as ne, nextTick as P } from "vue";
+import "../../../../../../../_virtual/VTextField.sass.mjs";
+import { VCounter as oe } from "../VCounter/VCounter.mjs";
+import { makeVFieldProps as ue, VField as T } from "../VField/VField.mjs";
+import { makeVInputProps as ie, VInput as B } from "../VInput/VInput.mjs";
+import { makeAutocompleteProps as ae, useAutocomplete as re } from "../../composables/autocomplete.mjs";
+import { useAutofocus as ce } from "../../composables/autofocus.mjs";
+import { useFocus as se } from "../../composables/focus.mjs";
+import { forwardRefs as de } from "../../composables/forwardRefs.mjs";
+import { useProxiedModel as fe } from "../../composables/proxiedModel.mjs";
+import E from "../../directives/intersect/index.mjs";
+import { propsFactory as me } from "../../util/propsFactory.mjs";
+import { omit as M, filterInputAttrs as ve, callEvent as xe } from "../../util/helpers.mjs";
+import { genericComponent as Ve } from "../../util/defineComponent.mjs";
+import { useRender as ge } from "../../util/useRender.mjs";
+const ye = ["color", "file", "time", "date", "datetime-local", "week", "month"], he = me({
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: [Number, Function],
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  suffix: String,
+  role: String,
+  type: {
+    type: String,
+    default: "text"
+  },
+  modelModifiers: Object,
+  ...ae(),
+  ...M(ie(), ["direction"]),
+  ...ue()
+}, "VTextField"), Be = Ve()({
+  name: "VTextField",
+  directives: {
+    vIntersect: E
+  },
+  inheritAttrs: !1,
+  props: he(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, O) {
+    let {
+      attrs: V,
+      emit: F,
+      slots: n
+    } = O;
+    const u = fe(e, "modelValue", void 0, (t) => Object.is(t, -0) ? "-0" : t), {
+      isFocused: a,
+      focus: k,
+      blur: j
+    } = se(e), {
+      onIntersect: z
+    } = ce(e), U = x(() => typeof e.counterValue == "function" ? e.counterValue(u.value) : typeof e.counterValue == "number" ? e.counterValue : (u.value ?? "").toString().length), $ = x(() => {
+      if (V.maxlength)
+        return V.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), _ = x(() => ["plain", "underlined"].includes(e.variant)), S = h(), A = h(), r = h(), f = re(e), q = x(() => ye.includes(e.type) || e.persistentPlaceholder || a.value || e.active);
+    function I() {
+      f.isSuppressing.value && f.update(), a.value || k(), P(() => {
+        var t;
+        r.value !== document.activeElement && ((t = r.value) == null || t.focus());
+      });
+    }
+    function G(t) {
+      F("mousedown:control", t), t.target !== r.value && (I(), t.preventDefault());
+    }
+    function H(t) {
+      F("click:control", t);
+    }
+    function J(t, l) {
+      t.stopPropagation(), I(), P(() => {
+        l(), xe(e["onClick:clear"], t);
+      });
+    }
+    function K(t) {
+      var v;
+      const l = t.target;
+      if (!((v = e.modelModifiers) != null && v.trim && ["text", "search", "password", "tel", "url"].includes(e.type))) {
+        u.value = l.value;
+        return;
+      }
+      const c = l.value, m = l.selectionStart, g = l.selectionEnd;
+      u.value = c, P(() => {
+        let s = 0;
+        c.trimStart().length === l.value.length && (s = c.length - l.value.length), m != null && (l.selectionStart = m - s), g != null && (l.selectionEnd = g - s);
+      });
+    }
+    return ge(() => {
+      const t = !!(n.counter || e.counter !== !1 && e.counter != null), l = !!(t || n.details), [c, m] = ve(V), {
+        modelValue: g,
+        ...v
+      } = B.filterProps(e), s = T.filterProps(e);
+      return p(B, b({
+        ref: S,
+        modelValue: u.value,
+        "onUpdate:modelValue": (d) => u.value = d,
+        class: ["v-text-field", {
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-input--plain-underlined": _.value
+        }, e.class],
+        style: e.style
+      }, c, v, {
+        centerAffix: !_.value,
+        focused: a.value
+      }), {
+        ...n,
+        default: (d) => {
+          let {
+            id: i,
+            isDisabled: w,
+            isDirty: N,
+            isReadonly: L,
+            isValid: Q,
+            hasDetails: W,
+            reset: X
+          } = d;
+          return p(T, b({
+            ref: A,
+            onMousedown: G,
+            onClick: H,
+            "onClick:clear": (y) => J(y, X),
+            role: e.role
+          }, M(s, ["onClick:clear"]), {
+            id: i.value,
+            labelId: `${i.value}-label`,
+            active: q.value || N.value,
+            dirty: N.value || e.dirty,
+            disabled: w.value,
+            focused: a.value,
+            details: W.value,
+            error: Q.value === !1
+          }), {
+            ...n,
+            default: (y) => {
+              let {
+                props: {
+                  class: R,
+                  ...Y
+                },
+                controlRef: Z
+              } = y;
+              const D = o("input", b({
+                ref: (ee) => r.value = Z.value = ee,
+                value: u.value,
+                onInput: K,
+                autofocus: e.autofocus,
+                readonly: L.value,
+                disabled: w.value,
+                name: f.fieldName.value,
+                autocomplete: f.fieldAutocomplete.value,
+                placeholder: e.placeholder,
+                size: 1,
+                role: e.role,
+                type: e.type,
+                onFocus: k,
+                onBlur: j,
+                "aria-labelledby": `${i.value}-label`
+              }, Y, m), null);
+              return o(C, null, [e.prefix && o("span", {
+                class: "v-text-field__prefix"
+              }, [o("span", {
+                class: "v-text-field__prefix__text"
+              }, [e.prefix])]), te(n.default ? o("div", {
+                class: le(R),
+                "data-no-activator": ""
+              }, [n.default({
+                id: i
+              }), D]) : ne(D, {
+                class: R
+              }), [[E, z, null, {
+                once: !0
+              }]]), e.suffix && o("span", {
+                class: "v-text-field__suffix"
+              }, [o("span", {
+                class: "v-text-field__suffix__text"
+              }, [e.suffix])])]);
+            }
+          });
+        },
+        details: l ? (d) => {
+          var i;
+          return o(C, null, [(i = n.details) == null ? void 0 : i.call(n, d), t && o(C, null, [o("span", null, null), p(oe, {
+            active: e.persistentCounter || a.value,
+            value: U.value,
+            max: $.value,
+            disabled: e.disabled
+          }, n.counter)])]);
+        } : void 0
+      });
+    }), de({}, S, A, r);
+  }
+});
+export {
+  Be as VTextField,
+  he as makeVTextFieldProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VTextarea/VTextarea.mjs

@@ -0,0 +1,258 @@
+import { computed as C, ref as w, shallowRef as re, watchEffect as ce, onMounted as se, watch as f, onBeforeUnmount as de, nextTick as P, createVNode as H, mergeProps as A, createElementVNode as r, Fragment as M, withDirectives as U, normalizeClass as fe, vModelText as me } from "vue";
+import "../../../../../../../_virtual/VTextarea.sass.mjs";
+import "../../../../../../../_virtual/VTextField.sass.mjs";
+import { VCounter as ve } from "../VCounter/VCounter.mjs";
+import { makeVFieldProps as xe, VField as $ } from "../VField/VField.mjs";
+import { makeVInputProps as ge, VInput as O } from "../VInput/VInput.mjs";
+import { makeAutocompleteProps as he, useAutocomplete as we } from "../../composables/autocomplete.mjs";
+import { useAutofocus as ye } from "../../composables/autofocus.mjs";
+import { useFocus as Ve } from "../../composables/focus.mjs";
+import { forwardRefs as be } from "../../composables/forwardRefs.mjs";
+import { useProxiedModel as Fe } from "../../composables/proxiedModel.mjs";
+import W from "../../directives/intersect/index.mjs";
+import { useDisplay as Ce } from "../../composables/display.mjs";
+import { propsFactory as Pe } from "../../util/propsFactory.mjs";
+import { omit as pe, convertToUnit as z, filterInputAttrs as ke, callEvent as Ie, clamp as Ne } from "../../util/helpers.mjs";
+import { genericComponent as Re } from "../../util/defineComponent.mjs";
+import { useRender as Se } from "../../util/useRender.mjs";
+const He = Pe({
+  autoGrow: Boolean,
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: Function,
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  noResize: Boolean,
+  rows: {
+    type: [Number, String],
+    default: 5,
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  maxHeight: {
+    type: [Number, String],
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  maxRows: {
+    type: [Number, String],
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  suffix: String,
+  modelModifiers: Object,
+  ...he(),
+  ...pe(ge(), ["direction"]),
+  ...xe()
+}, "VTextarea"), Le = Re()({
+  name: "VTextarea",
+  directives: {
+    vIntersect: W
+  },
+  inheritAttrs: !1,
+  props: He(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "update:rows": (e) => !0
+  },
+  setup(e, j) {
+    let {
+      attrs: p,
+      emit: k,
+      slots: n
+    } = j;
+    const l = Fe(e, "modelValue"), {
+      isFocused: y,
+      focus: q,
+      blur: J
+    } = Ve(e), {
+      onIntersect: K
+    } = ye(e), L = C(() => typeof e.counterValue == "function" ? e.counterValue(l.value) : (l.value || "").toString().length), Q = C(() => {
+      if (p.maxlength)
+        return p.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), B = w(), b = w(), T = re(""), m = w(), I = w(0), {
+      platform: X
+    } = Ce(), F = we(e), Y = C(() => e.persistentPlaceholder || y.value || e.active);
+    function N() {
+      var t;
+      F.isSuppressing.value && F.update(), m.value !== document.activeElement && ((t = m.value) == null || t.focus()), y.value || q();
+    }
+    function Z(t) {
+      N(), k("click:control", t);
+    }
+    function ee(t) {
+      k("mousedown:control", t);
+    }
+    function te(t) {
+      t.stopPropagation(), N(), P(() => {
+        l.value = "", Ie(e["onClick:clear"], t);
+      });
+    }
+    function ae(t) {
+      var g;
+      const a = t.target;
+      if (!((g = e.modelModifiers) != null && g.trim)) {
+        l.value = a.value;
+        return;
+      }
+      const o = a.value, x = a.selectionStart, s = a.selectionEnd;
+      l.value = o, P(() => {
+        let d = 0;
+        o.trimStart().length === a.value.length && (d = o.length - a.value.length), x != null && (a.selectionStart = x - d), s != null && (a.selectionEnd = s - d);
+      });
+    }
+    const v = w(), V = w(Number(e.rows)), R = C(() => ["plain", "underlined"].includes(e.variant));
+    ce(() => {
+      e.autoGrow || (V.value = Number(e.rows));
+    });
+    function c() {
+      P(() => {
+        if (!m.value)
+          return;
+        if (X.value.firefox) {
+          I.value = 12;
+          return;
+        }
+        const {
+          offsetWidth: t,
+          clientWidth: a
+        } = m.value;
+        I.value = Math.max(0, t - a);
+      }), e.autoGrow && P(() => {
+        if (!v.value || !b.value)
+          return;
+        const t = getComputedStyle(v.value), a = getComputedStyle(b.value.$el), o = parseFloat(t.getPropertyValue("--v-field-padding-top")) + parseFloat(t.getPropertyValue("--v-input-padding-top")) + parseFloat(t.getPropertyValue("--v-field-padding-bottom")), x = v.value.scrollHeight, s = parseFloat(t.lineHeight), g = Math.max(parseFloat(e.rows) * s + o, parseFloat(a.getPropertyValue("--v-input-control-height"))), d = e.maxHeight ? parseFloat(e.maxHeight) : parseFloat(e.maxRows) * s + o || 1 / 0, u = Ne(x ?? 0, g, d);
+        V.value = Math.floor((u - o) / s), T.value = z(u);
+      });
+    }
+    se(c), f(l, c), f(() => e.rows, c), f(() => e.maxHeight, c), f(() => e.maxRows, c), f(() => e.density, c), f(V, (t) => {
+      k("update:rows", t);
+    });
+    let i;
+    return f(v, (t) => {
+      t ? (i = new ResizeObserver(c), i.observe(v.value)) : i == null || i.disconnect();
+    }), de(() => {
+      i == null || i.disconnect();
+    }), Se(() => {
+      const t = !!(n.counter || e.counter || e.counterValue), a = !!(t || n.details), [o, x] = ke(p), {
+        modelValue: s,
+        ...g
+      } = O.filterProps(e), d = {
+        ...$.filterProps(e),
+        "onClick:clear": te
+      };
+      return H(O, A({
+        ref: B,
+        modelValue: l.value,
+        "onUpdate:modelValue": (u) => l.value = u,
+        class: ["v-textarea v-text-field", {
+          "v-textarea--prefixed": e.prefix,
+          "v-textarea--suffixed": e.suffix,
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-textarea--auto-grow": e.autoGrow,
+          "v-textarea--no-resize": e.noResize || e.autoGrow,
+          "v-input--plain-underlined": R.value
+        }, e.class],
+        style: [{
+          "--v-textarea-max-height": e.maxHeight ? z(e.maxHeight) : void 0,
+          "--v-textarea-scroll-bar-width": z(I.value)
+        }, e.style]
+      }, o, g, {
+        centerAffix: V.value === 1 && !R.value,
+        focused: y.value
+      }), {
+        ...n,
+        default: (u) => {
+          let {
+            id: h,
+            isDisabled: _,
+            isDirty: D,
+            isReadonly: le,
+            isValid: oe,
+            hasDetails: ne
+          } = u;
+          return H($, A({
+            ref: b,
+            style: {
+              "--v-textarea-control-height": T.value
+            },
+            onClick: Z,
+            onMousedown: ee,
+            "onClick:prependInner": e["onClick:prependInner"],
+            "onClick:appendInner": e["onClick:appendInner"]
+          }, d, {
+            id: h.value,
+            active: Y.value || D.value,
+            labelId: `${h.value}-label`,
+            centerAffix: V.value === 1 && !R.value,
+            dirty: D.value || e.dirty,
+            disabled: _.value,
+            focused: y.value,
+            details: ne.value,
+            error: oe.value === !1
+          }), {
+            ...n,
+            default: (ie) => {
+              let {
+                props: {
+                  class: E,
+                  ...G
+                },
+                controlRef: ue
+              } = ie;
+              return r(M, null, [e.prefix && r("span", {
+                class: "v-text-field__prefix"
+              }, [e.prefix]), U(r("textarea", A({
+                ref: (S) => m.value = ue.value = S,
+                class: E,
+                value: l.value,
+                onInput: ae,
+                autofocus: e.autofocus,
+                readonly: le.value,
+                disabled: _.value,
+                placeholder: e.placeholder,
+                rows: e.rows,
+                name: F.fieldName.value,
+                autocomplete: F.fieldAutocomplete.value,
+                onFocus: N,
+                onBlur: J,
+                "aria-labelledby": `${h.value}-label`
+              }, G, x), null), [[W, {
+                handler: K
+              }, null, {
+                once: !0
+              }]]), e.autoGrow && U(r("textarea", {
+                class: fe([E, "v-textarea__sizer"]),
+                id: `${G.id}-sizer`,
+                "onUpdate:modelValue": (S) => l.value = S,
+                ref: v,
+                readonly: !0,
+                "aria-hidden": "true"
+              }, null), [[me, l.value]]), e.suffix && r("span", {
+                class: "v-text-field__suffix"
+              }, [e.suffix])]);
+            }
+          });
+        },
+        details: a ? (u) => {
+          var h;
+          return r(M, null, [(h = n.details) == null ? void 0 : h.call(n, u), t && r(M, null, [r("span", null, null), H(ve, {
+            active: e.persistentCounter || y.value,
+            value: L.value,
+            max: Q.value,
+            disabled: e.disabled
+          }, n.counter)])]);
+        } : void 0
+      });
+    }), be({}, B, b, m);
+  }
+});
+export {
+  Le as VTextarea,
+  He as makeVTextareaProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VToolbar/VToolbarItems.mjs

@@ -0,0 +1,38 @@
+import { toRef as e, createElementVNode as a, normalizeClass as i, normalizeStyle as n } from "vue";
+import { makeComponentProps as l } from "../../composables/component.mjs";
+import { provideDefaults as s } from "../../composables/defaults.mjs";
+import { makeVariantProps as p } from "../../composables/variant.mjs";
+import { propsFactory as f } from "../../util/propsFactory.mjs";
+import { genericComponent as c } from "../../util/defineComponent.mjs";
+import { useRender as V } from "../../util/useRender.mjs";
+const v = f({
+  ...l(),
+  ...p({
+    variant: "text"
+  })
+}, "VToolbarItems"), k = c()({
+  name: "VToolbarItems",
+  props: v(),
+  setup(o, m) {
+    let {
+      slots: r
+    } = m;
+    return s({
+      VBtn: {
+        color: e(() => o.color),
+        height: "inherit",
+        variant: e(() => o.variant)
+      }
+    }), V(() => {
+      var t;
+      return a("div", {
+        class: i(["v-toolbar-items", o.class]),
+        style: n(o.style)
+      }, [(t = r.default) == null ? void 0 : t.call(r)]);
+    }), {};
+  }
+});
+export {
+  k as VToolbarItems,
+  v as makeVToolbarItemsProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VVirtualScroll/VVirtualScroll.mjs

@@ -0,0 +1,106 @@
+import { toRef as I, createVNode as P, createElementVNode as a, Fragment as T, normalizeClass as _, normalizeStyle as x, onMounted as R, onScopeDispose as B } from "vue";
+import "../../../../../../../_virtual/VVirtualScroll.sass.mjs";
+import { VVirtualScrollItem as C } from "./VVirtualScrollItem.mjs";
+import { makeComponentProps as E } from "../../composables/component.mjs";
+import { makeDimensionProps as z, useDimension as D } from "../../composables/dimensions.mjs";
+import { useToggleScope as L } from "../../composables/toggleScope.mjs";
+import { makeVirtualProps as F, useVirtual as N } from "../../composables/virtual.mjs";
+import { propsFactory as U } from "../../util/propsFactory.mjs";
+import { genericComponent as b } from "../../util/defineComponent.mjs";
+import { getCurrentInstance as w } from "../../util/getCurrentInstance.mjs";
+import { useRender as A } from "../../util/useRender.mjs";
+import { convertToUnit as s } from "../../util/helpers.mjs";
+import { getScrollParent as M } from "../../util/getScrollParent.mjs";
+const j = U({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  renderless: Boolean,
+  ...F(),
+  ...E(),
+  ...z()
+}, "VVirtualScroll"), le = b()({
+  name: "VVirtualScroll",
+  props: j(),
+  setup(e, f) {
+    let {
+      slots: i
+    } = f;
+    const g = w("VVirtualScroll"), {
+      dimensionStyles: V
+    } = D(e), {
+      calculateVisibleItems: S,
+      containerRef: r,
+      markerRef: c,
+      handleScroll: m,
+      handleScrollend: d,
+      handleItemResize: y,
+      scrollToIndex: h,
+      paddingTop: u,
+      paddingBottom: p,
+      computedItems: k
+    } = N(e, I(() => e.items));
+    return L(() => e.renderless, () => {
+      function t() {
+        var n, v;
+        const l = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) ? "addEventListener" : "removeEventListener";
+        r.value === document.documentElement ? (document[l]("scroll", m, {
+          passive: !0
+        }), document[l]("scrollend", d)) : ((n = r.value) == null || n[l]("scroll", m, {
+          passive: !0
+        }), (v = r.value) == null || v[l]("scrollend", d));
+      }
+      R(() => {
+        r.value = M(g.vnode.el, !0), t(!0);
+      }), B(t);
+    }), A(() => {
+      const t = k.value.map((o) => P(C, {
+        key: o.key,
+        renderless: e.renderless,
+        "onUpdate:height": (l) => y(o.index, l)
+      }, {
+        default: (l) => {
+          var n;
+          return (n = i.default) == null ? void 0 : n.call(i, {
+            item: o.raw,
+            index: o.index,
+            ...l
+          });
+        }
+      }));
+      return e.renderless ? a(T, null, [a("div", {
+        ref: c,
+        class: "v-virtual-scroll__spacer",
+        style: {
+          paddingTop: s(u.value)
+        }
+      }, null), t, a("div", {
+        class: "v-virtual-scroll__spacer",
+        style: {
+          paddingBottom: s(p.value)
+        }
+      }, null)]) : a("div", {
+        ref: r,
+        class: _(["v-virtual-scroll", e.class]),
+        onScrollPassive: m,
+        onScrollend: d,
+        style: x([V.value, e.style])
+      }, [a("div", {
+        ref: c,
+        class: "v-virtual-scroll__container",
+        style: {
+          paddingTop: s(u.value),
+          paddingBottom: s(p.value)
+        }
+      }, [t])]);
+    }), {
+      calculateVisibleItems: S,
+      scrollToIndex: h
+    };
+  }
+});
+export {
+  le as VVirtualScroll,
+  j as makeVVirtualScrollProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VVirtualScroll/VVirtualScrollItem.mjs

@@ -0,0 +1,47 @@
+import { watch as u, createElementVNode as m, Fragment as c, mergeProps as p } from "vue";
+import { makeComponentProps as f } from "../../composables/component.mjs";
+import { useResizeObserver as d } from "../../composables/resizeObserver.mjs";
+import { propsFactory as V } from "../../util/propsFactory.mjs";
+import { genericComponent as h } from "../../util/defineComponent.mjs";
+import { useRender as g } from "../../util/useRender.mjs";
+const v = V({
+  renderless: Boolean,
+  ...f()
+}, "VVirtualScrollItem"), k = h()({
+  name: "VVirtualScrollItem",
+  inheritAttrs: !1,
+  props: v(),
+  emits: {
+    "update:height": (r) => !0
+  },
+  setup(r, i) {
+    let {
+      attrs: a,
+      emit: n,
+      slots: t
+    } = i;
+    const {
+      resizeRef: o,
+      contentRect: s
+    } = d(void 0, "border");
+    u(() => {
+      var e;
+      return (e = s.value) == null ? void 0 : e.height;
+    }, (e) => {
+      e != null && n("update:height", e);
+    }), g(() => {
+      var e, l;
+      return r.renderless ? m(c, null, [(e = t.default) == null ? void 0 : e.call(t, {
+        itemRef: o
+      })]) : m("div", p({
+        ref: o,
+        class: ["v-virtual-scroll__item", r.class],
+        style: r.style
+      }, a), [(l = t.default) == null ? void 0 : l.call(t)]);
+    });
+  }
+});
+export {
+  k as VVirtualScrollItem,
+  v as makeVVirtualScrollItemProps
+};