ep-craft 0.1.36 → 0.1.38

package/dist/components/virtual-list/src/builders/build-grid.js

@@ -0,0 +1,449 @@
+import { defineComponent as $t, getCurrentInstance as kt, ref as M, computed as m, unref as r, onMounted as Ft, nextTick as G, resolveDynamicComponent as K, h as b, mergeProps as Gt, Fragment as zt } from "vue";
+import { useEventListener as Nt, isClient as Vt } from "@vueuse/core";
+import { isNumber as E } from "../../../../utils/types.js";
+import "lodash-unified";
+import { isString as J, hasOwn as Ht } from "@vue/shared";
+import { getScrollBarWidth as Bt } from "../../../../utils/dom/scroll.js";
+import "@element-plus/icons-vue";
+import { useNamespace as qt } from "../../../../hooks/use-namespace/index.js";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+import Q from "../components/scrollbar.js";
+import { useGridWheel as Pt } from "../hooks/use-grid-wheel.js";
+import { useCache as Ut } from "../hooks/use-cache.js";
+import { useGridTouch as pt } from "../hooks/use-grid-touch.js";
+import { virtualizedGridProps as Xt } from "../props.js";
+import { getScrollDir as A, getRTLOffsetType as Z, isRTL as j } from "../utils.js";
+import { ITEM_RENDER_EVT as tt, SCROLL_EVT as et, FORWARD as _, AUTO_ALIGNMENT as Yt, BACKWARD as ot, RTL as Kt, RTL_OFFSET_POS_ASC as Jt, RTL_OFFSET_NAG as lt, RTL_OFFSET_POS_DESC as Qt } from "../defaults.js";
+const Le = ({
+  name: rt,
+  clearCache: W,
+  getColumnPosition: z,
+  getColumnStartIndexForOffset: nt,
+  getColumnStopIndexForStartIndex: ct,
+  getEstimatedTotalHeight: N,
+  getEstimatedTotalWidth: V,
+  getColumnOffset: it,
+  getRowOffset: at,
+  getRowPosition: st,
+  getRowStartIndexForOffset: ht,
+  getRowStopIndexForStartIndex: dt,
+  initCache: ut,
+  injectToInstance: D,
+  validateProps: mt
+}) => $t({
+  name: rt ?? "EpVirtualList",
+  props: Xt,
+  emits: [tt, et],
+  setup(t, { emit: H, expose: ft, slots: O }) {
+    const C = qt("vl");
+    mt(t);
+    const I = kt(), w = M(ut(t, I));
+    D == null || D(I, w);
+    const T = M(), B = M(), q = M(), P = M(), h = M({
+      isScrolling: !1,
+      scrollLeft: E(t.initScrollLeft) ? t.initScrollLeft : 0,
+      scrollTop: E(t.initScrollTop) ? t.initScrollTop : 0,
+      updateRequested: !1,
+      xAxisScrollDir: _,
+      yAxisScrollDir: _
+    }), $ = Ut(), R = m(
+      () => Number.parseInt(`${t.height}`, 10)
+    ), y = m(() => Number.parseInt(`${t.width}`, 10)), U = m(() => {
+      const { totalColumn: o, totalRow: e, columnCache: l } = t, { isScrolling: a, xAxisScrollDir: n, scrollLeft: c } = r(h);
+      if (o === 0 || e === 0)
+        return [0, 0, 0, 0];
+      const i = nt(
+        t,
+        c,
+        r(w)
+      ), s = ct(
+        t,
+        i,
+        c,
+        r(w)
+      ), d = !a || n === ot ? Math.max(1, l) : 1, u = !a || n === _ ? Math.max(1, l) : 1;
+      return [
+        Math.max(0, i - d),
+        Math.max(0, Math.min(o - 1, s + u)),
+        i,
+        s
+      ];
+    }), p = m(() => {
+      const { totalColumn: o, totalRow: e, rowCache: l } = t, { isScrolling: a, yAxisScrollDir: n, scrollTop: c } = r(h);
+      if (o === 0 || e === 0)
+        return [0, 0, 0, 0];
+      const i = ht(
+        t,
+        c,
+        r(w)
+      ), s = dt(
+        t,
+        i,
+        c,
+        r(w)
+      ), d = !a || n === ot ? Math.max(1, l) : 1, u = !a || n === _ ? Math.max(1, l) : 1;
+      return [
+        Math.max(0, i - d),
+        Math.max(0, Math.min(e - 1, s + u)),
+        i,
+        s
+      ];
+    }), x = m(
+      () => N(t, r(w))
+    ), g = m(
+      () => V(t, r(w))
+    ), St = m(() => [
+      {
+        position: "relative",
+        overflow: "hidden",
+        WebkitOverflowScrolling: "touch",
+        willChange: "transform"
+      },
+      {
+        direction: t.direction,
+        height: E(t.height) ? `${t.height}px` : t.height,
+        width: E(t.width) ? `${t.width}px` : t.width
+      },
+      t.style ?? {}
+    ]), wt = m(() => {
+      const o = `${r(g)}px`;
+      return {
+        height: `${r(x)}px`,
+        pointerEvents: r(h).isScrolling ? "none" : void 0,
+        width: o,
+        // fix scrolling issues in Firefox.
+        margin: 0,
+        boxSizing: "border-box"
+      };
+    }), k = () => {
+      const { totalColumn: o, totalRow: e } = t;
+      if (o > 0 && e > 0) {
+        const [
+          s,
+          d,
+          u,
+          v
+        ] = r(U), [f, S, F, It] = r(p);
+        H(tt, {
+          columnCacheStart: s,
+          columnCacheEnd: d,
+          rowCacheStart: f,
+          rowCacheEnd: S,
+          columnVisibleStart: u,
+          columnVisibleEnd: v,
+          rowVisibleStart: F,
+          rowVisibleEnd: It
+        });
+      }
+      const {
+        scrollLeft: l,
+        scrollTop: a,
+        updateRequested: n,
+        xAxisScrollDir: c,
+        yAxisScrollDir: i
+      } = r(h);
+      H(et, {
+        xAxisScrollDir: c,
+        scrollLeft: l,
+        yAxisScrollDir: i,
+        scrollTop: a,
+        updateRequested: n
+      });
+    }, vt = (o) => {
+      const {
+        clientHeight: e,
+        clientWidth: l,
+        scrollHeight: a,
+        scrollLeft: n,
+        scrollTop: c,
+        scrollWidth: i
+      } = o.currentTarget, s = r(h);
+      if (s.scrollTop === c && s.scrollLeft === n)
+        return;
+      let d = n;
+      if (j(t.direction))
+        switch (Z()) {
+          case lt:
+            d = -n;
+            break;
+          case Qt:
+            d = i - l - n;
+            break;
+        }
+      h.value = {
+        ...s,
+        isScrolling: !0,
+        scrollLeft: d,
+        scrollTop: Math.max(
+          0,
+          Math.min(c, a - e)
+        ),
+        updateRequested: !0,
+        xAxisScrollDir: A(s.scrollLeft, d),
+        yAxisScrollDir: A(s.scrollTop, c)
+      }, G(() => X()), Y(), k();
+    }, xt = (o, e) => {
+      const l = r(R), a = (x.value - l) / e * o;
+      L({
+        scrollTop: Math.min(x.value - l, a)
+      });
+    }, gt = (o, e) => {
+      const l = r(y), a = (g.value - l) / e * o;
+      L({
+        scrollLeft: Math.min(g.value - l, a)
+      });
+    }, { onWheel: Tt } = Pt(
+      {
+        atXStartEdge: m(() => h.value.scrollLeft <= 0),
+        atXEndEdge: m(
+          () => h.value.scrollLeft >= g.value - r(y)
+        ),
+        atYStartEdge: m(() => h.value.scrollTop <= 0),
+        atYEndEdge: m(
+          () => h.value.scrollTop >= x.value - r(R)
+        )
+      },
+      (o, e) => {
+        var n, c, i, s;
+        (c = (n = B.value) == null ? void 0 : n.onMouseUp) == null || c.call(n), (s = (i = q.value) == null ? void 0 : i.onMouseUp) == null || s.call(i);
+        const l = r(y), a = r(R);
+        L({
+          scrollLeft: Math.min(
+            h.value.scrollLeft + o,
+            g.value - l
+          ),
+          scrollTop: Math.min(
+            h.value.scrollTop + e,
+            x.value - a
+          )
+        });
+      }
+    );
+    Nt(T, "wheel", Tt, {
+      passive: !1
+    });
+    const L = ({
+      scrollLeft: o = h.value.scrollLeft,
+      scrollTop: e = h.value.scrollTop
+    }) => {
+      o = Math.max(o, 0), e = Math.max(e, 0);
+      const l = r(h);
+      e === l.scrollTop && o === l.scrollLeft || (h.value = {
+        ...l,
+        xAxisScrollDir: A(l.scrollLeft, o),
+        yAxisScrollDir: A(l.scrollTop, e),
+        scrollLeft: o,
+        scrollTop: e,
+        updateRequested: !0
+      }, G(() => X()), Y(), k());
+    }, { touchStartX: Lt, touchStartY: Mt, handleTouchStart: bt, handleTouchMove: Et } = pt(
+      T,
+      h,
+      L,
+      g,
+      x,
+      y,
+      R
+    ), Rt = (o = 0, e = 0, l = Yt) => {
+      const a = r(h);
+      e = Math.max(0, Math.min(e, t.totalColumn - 1)), o = Math.max(0, Math.min(o, t.totalRow - 1));
+      const n = Bt(C.namespace.value), c = r(w), i = N(t, c), s = V(t, c);
+      L({
+        scrollLeft: it(
+          t,
+          e,
+          l,
+          a.scrollLeft,
+          c,
+          s > t.width ? n : 0
+        ),
+        scrollTop: at(
+          t,
+          o,
+          l,
+          a.scrollTop,
+          c,
+          i > t.height ? n : 0
+        )
+      });
+    }, yt = (o, e) => {
+      const { columnWidth: l, direction: a, rowHeight: n } = t, c = $.value(
+        W && l,
+        W && n,
+        W && a
+      ), i = `${o},${e}`;
+      if (Ht(c, i))
+        return c[i];
+      {
+        const [, s] = z(t, e, r(w)), d = r(w), u = j(a), [v, f] = st(t, o, d), [S] = z(t, e, d);
+        return c[i] = {
+          position: "absolute",
+          left: u ? void 0 : `${s}px`,
+          right: u ? `${s}px` : void 0,
+          top: `${f}px`,
+          height: `${v}px`,
+          width: `${S}px`
+        }, c[i];
+      }
+    }, X = () => {
+      h.value.isScrolling = !1, G(() => {
+        $.value(-1, null, null);
+      });
+    };
+    Ft(() => {
+      if (!Vt) return;
+      const { initScrollLeft: o, initScrollTop: e } = t, l = r(T);
+      l && (E(o) && (l.scrollLeft = o), E(e) && (l.scrollTop = e)), k();
+    });
+    const Y = () => {
+      const { direction: o } = t, { scrollLeft: e, scrollTop: l, updateRequested: a } = r(h), n = r(T);
+      if (a && n) {
+        if (o === Kt)
+          switch (Z()) {
+            case lt: {
+              n.scrollLeft = -e;
+              break;
+            }
+            case Jt: {
+              n.scrollLeft = e;
+              break;
+            }
+            default: {
+              const { clientWidth: c, scrollWidth: i } = n;
+              n.scrollLeft = i - c - e;
+              break;
+            }
+          }
+        else
+          n.scrollLeft = Math.max(0, e);
+        n.scrollTop = Math.max(0, l);
+      }
+    }, { resetAfterColumnIndex: Ct, resetAfterRowIndex: At, resetAfter: _t } = I.proxy;
+    ft({
+      windowRef: T,
+      innerRef: P,
+      getItemStyleCache: $,
+      touchStartX: Lt,
+      touchStartY: Mt,
+      handleTouchStart: bt,
+      handleTouchMove: Et,
+      scrollTo: L,
+      scrollToItem: Rt,
+      states: h,
+      resetAfterColumnIndex: Ct,
+      resetAfterRowIndex: At,
+      resetAfter: _t
+    });
+    const Wt = () => {
+      const {
+        scrollbarAlwaysOn: o,
+        scrollbarStartGap: e,
+        scrollbarEndGap: l,
+        totalColumn: a,
+        totalRow: n
+      } = t, c = r(y), i = r(R), s = r(g), d = r(x), { scrollLeft: u, scrollTop: v } = r(h), f = b(Q, {
+        ref: B,
+        alwaysOn: o,
+        startGap: e,
+        endGap: l,
+        class: C.e("horizontal"),
+        clientSize: c,
+        layout: "horizontal",
+        onScroll: gt,
+        ratio: c * 100 / s,
+        scrollFrom: u / (s - c),
+        total: n,
+        visible: !0
+      }), S = b(Q, {
+        ref: q,
+        alwaysOn: o,
+        startGap: e,
+        endGap: l,
+        class: C.e("vertical"),
+        clientSize: i,
+        layout: "vertical",
+        onScroll: xt,
+        ratio: i * 100 / d,
+        scrollFrom: v / (d - i),
+        total: a,
+        visible: !0
+      });
+      return {
+        horizontalScrollbar: f,
+        verticalScrollbar: S
+      };
+    }, Dt = () => {
+      var v;
+      const [o, e] = r(U), [l, a] = r(p), { data: n, totalColumn: c, totalRow: i, useIsScrolling: s, itemKey: d } = t, u = [];
+      if (i > 0 && c > 0)
+        for (let f = l; f <= a; f++)
+          for (let S = o; S <= e; S++) {
+            const F = d({ columnIndex: S, data: n, rowIndex: f });
+            u.push(
+              b(
+                zt,
+                { key: F },
+                (v = O.default) == null ? void 0 : v.call(O, {
+                  columnIndex: S,
+                  data: n,
+                  isScrolling: s ? r(h).isScrolling : void 0,
+                  style: yt(f, S),
+                  rowIndex: f
+                })
+              )
+            );
+          }
+      return u;
+    }, Ot = () => {
+      const o = K(t.innerElement), e = Dt();
+      return [
+        b(
+          o,
+          Gt(t.innerProps, {
+            style: r(wt),
+            ref: P
+          }),
+          J(o) ? e : {
+            default: () => e
+          }
+        )
+      ];
+    };
+    return () => {
+      const o = K(
+        t.containerElement
+      ), { horizontalScrollbar: e, verticalScrollbar: l } = Wt(), a = Ot();
+      return b(
+        "div",
+        {
+          key: 0,
+          class: C.e("wrapper"),
+          role: t.role
+        },
+        [
+          b(
+            o,
+            {
+              class: t.className,
+              style: r(St),
+              onScroll: vt,
+              ref: T
+            },
+            J(o) ? a : { default: () => a }
+          ),
+          e,
+          l
+        ]
+      );
+    };
+  }
+});
+export {
+  Le as default
+};

package/dist/components/virtual-list/src/components/dynamic-size-grid.d.ts

@@ -0,0 +1,212 @@
+import type { GridInstance } from '../builders/build-grid';
+import type { ItemSize } from '../types';
+type Indices = {
+    columnIndex?: number;
+    rowIndex?: number;
+};
+declare const DynamicSizeGrid: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly className: import("../../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+    readonly data: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("../../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("../../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly innerProps: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly style: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerWidth: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("../../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly columnCache: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly columnWidth: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | (((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedColumnWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedRowHeight: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initScrollLeft: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly initScrollTop: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly itemKey: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => import("../types").GridItemKeyGetter) | (() => import("../types").GridItemKeyGetter) | {
+        (): import("../types").GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => import("../types").GridItemKeyGetter) | (() => import("../types").GridItemKeyGetter) | {
+        (): import("../types").GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, ({ columnIndex, rowIndex, }: {
+        columnIndex: number;
+        rowIndex: number;
+    }) => string, boolean>;
+    readonly rowCache: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | (((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly totalColumn: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly totalRow: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly hScrollbarSize: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly vScrollbarSize: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly scrollbarStartGap: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly role: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered")[], "scroll" | "itemRendered", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly className: import("../../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+    readonly data: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("../../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("../../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly innerProps: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly style: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerWidth: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("../../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly columnCache: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly columnWidth: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | (((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedColumnWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedRowHeight: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initScrollLeft: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly initScrollTop: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly itemKey: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => import("../types").GridItemKeyGetter) | (() => import("../types").GridItemKeyGetter) | {
+        (): import("../types").GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => import("../types").GridItemKeyGetter) | (() => import("../types").GridItemKeyGetter) | {
+        (): import("../types").GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, ({ columnIndex, rowIndex, }: {
+        columnIndex: number;
+        rowIndex: number;
+    }) => string, boolean>;
+    readonly rowCache: import("../../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<import("../../../../utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | (((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly totalColumn: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly totalRow: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly hScrollbarSize: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly vScrollbarSize: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly scrollbarStartGap: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly role: StringConstructor;
+}>> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+    onItemRendered?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly data: any[];
+    readonly style: import("vue").StyleValue;
+    readonly direction: import("../../../../utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;
+    readonly className: string;
+    readonly containerElement: import("../../../../utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown>;
+    readonly innerElement: import("../../../../utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
+    readonly innerProps: Record<string, unknown>;
+    readonly perfMode: import("../../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly useIsScrolling: boolean;
+    readonly scrollbarAlwaysOn: boolean;
+    readonly itemKey: import("../types").GridItemKeyGetter;
+    readonly columnCache: number;
+    readonly initScrollLeft: number;
+    readonly initScrollTop: number;
+    readonly rowCache: number;
+    readonly hScrollbarSize: number;
+    readonly vScrollbarSize: number;
+    readonly scrollbarStartGap: number;
+    readonly scrollbarEndGap: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default DynamicSizeGrid;
+export type ResetAfterIndex = (idx: number, forceUpdate: boolean) => void;
+export type ResetAfterIndices = (indices: Indices, forceUpdate: boolean) => void;
+export type DynamicSizeGridInstance = GridInstance & {
+    resetAfterColumnIndex: ResetAfterIndex;
+    resetAfterRowIndex: ResetAfterIndex;
+    resetAfter: ResetAfterIndices;
+};