vft 0.0.48 → 0.0.51

package/es/components/virtual-list/components/scrollbar.d.ts

@@ -0,0 +1,79 @@
+declare const ScrollBar: import("vue").DefineComponent<{
+    readonly alwaysOn: BooleanConstructor;
+    readonly class: StringConstructor;
+    readonly layout: import("vft/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly ratio: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly clientSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollFrom: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollbarSize: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly startGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly endGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly visible: BooleanConstructor;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "start-move" | "stop-move")[], "scroll" | "start-move" | "stop-move", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly alwaysOn: BooleanConstructor;
+    readonly class: StringConstructor;
+    readonly layout: import("vft/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly ratio: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly clientSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollFrom: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollbarSize: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly startGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly endGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly visible: BooleanConstructor;
+}>> & {
+    onScroll?: ((...args: any[]) => any) | undefined;
+    "onStart-move"?: ((...args: any[]) => any) | undefined;
+    "onStop-move"?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly layout: import("vft/es/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;
+    readonly visible: boolean;
+    readonly alwaysOn: boolean;
+    readonly scrollbarSize: number;
+    readonly startGap: number;
+    readonly endGap: number;
+}>;
+export default ScrollBar;

package/es/components/virtual-list/components/scrollbar.js

@@ -0,0 +1,137 @@
+import { defineComponent as C, computed as a, ref as E, reactive as N, unref as d, watch as k, onBeforeUnmount as O, h as x, withModifiers as _ } from "vue";
+import "../../scrollbar/index.js";
+import "@vft/utils";
+import "lodash";
+import { cAF as F, rAF as G } from "../../../utils/vue/raf.js";
+import "../../../utils/ns-cover.js";
+import "@vueuse/core";
+import { useNamespace as L } from "../../../hooks/use-namespace/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "@vue/reactivity";
+import "@vue/shared";
+import { HORIZONTAL as R, ScrollbarDirKey as H, SCROLLBAR_MIN_SIZE as V } from "../defaults.js";
+import { virtualizedScrollbarProps as Z } from "../props.js";
+import { renderThumbStyle as $ } from "../utils.js";
+import { BAR_MAP as K } from "../../scrollbar/util.js";
+const st = C({
+  name: "ElVirtualScrollBar",
+  props: Z,
+  emits: ["scroll", "start-move", "stop-move"],
+  setup(e, { emit: u }) {
+    const b = a(() => e.startGap + e.endGap), z = L("virtual-scrollbar"), I = L("scrollbar"), f = E(), l = E();
+    let S = null, h = null;
+    const n = N({
+      isDragging: !1,
+      traveled: 0
+    }), o = a(() => K[e.layout]), M = a(() => e.clientSize - d(b)), A = a(() => ({
+      position: "absolute",
+      width: `${R === e.layout ? M.value : e.scrollbarSize}px`,
+      height: `${R === e.layout ? e.scrollbarSize : M.value}px`,
+      [H[e.layout]]: "2px",
+      right: "2px",
+      bottom: "2px",
+      borderRadius: "4px"
+    })), g = a(() => {
+      const t = e.ratio, r = e.clientSize;
+      if (t >= 100)
+        return Number.POSITIVE_INFINITY;
+      if (t >= 50)
+        return t * r / 100;
+      const i = r / 3;
+      return Math.floor(
+        Math.min(
+          Math.max(t * r, V),
+          i
+        )
+      );
+    }), B = a(() => {
+      if (!Number.isFinite(g.value))
+        return {
+          display: "none"
+        };
+      const t = `${g.value}px`;
+      return $(
+        {
+          bar: o.value,
+          size: t,
+          move: n.traveled
+        },
+        e.layout
+      );
+    }), s = a(
+      () => Math.floor(e.clientSize - g.value - d(b))
+    ), T = () => {
+      window.addEventListener("mousemove", m), window.addEventListener("mouseup", c);
+      const t = d(l);
+      t && (h = document.onselectstart, document.onselectstart = () => !1, t.addEventListener("touchmove", m), t.addEventListener("touchend", c));
+    }, y = () => {
+      window.removeEventListener("mousemove", m), window.removeEventListener("mouseup", c), document.onselectstart = h, h = null;
+      const t = d(l);
+      t && (t.removeEventListener("touchmove", m), t.removeEventListener("touchend", c));
+    }, p = (t) => {
+      t.stopImmediatePropagation(), !(t.ctrlKey || [1, 2].includes(t.button)) && (n.isDragging = !0, n[o.value.axis] = t.currentTarget[o.value.offset] - (t[o.value.client] - t.currentTarget.getBoundingClientRect()[o.value.direction]), u("start-move"), T());
+    }, c = () => {
+      n.isDragging = !1, n[o.value.axis] = 0, u("stop-move"), y();
+    }, m = (t) => {
+      const { isDragging: r } = n;
+      if (!r || !l.value || !f.value)
+        return;
+      const i = n[o.value.axis];
+      if (!i)
+        return;
+      F(S);
+      const v = (f.value.getBoundingClientRect()[o.value.direction] - t[o.value.client]) * -1, P = l.value[o.value.offset] - i, w = v - P;
+      S = G(() => {
+        n.traveled = Math.max(
+          e.startGap,
+          Math.min(
+            w,
+            s.value
+            // 2 is the top value
+          )
+        ), u("scroll", w, s.value);
+      });
+    }, D = (t) => {
+      const r = Math.abs(
+        t.target.getBoundingClientRect()[o.value.direction] - t[o.value.client]
+      ), i = l.value[o.value.offset] / 2, v = r - i;
+      n.traveled = Math.max(0, Math.min(v, s.value)), u("scroll", v, s.value);
+    };
+    return k(
+      () => e.scrollFrom,
+      (t) => {
+        n.isDragging || (n.traveled = Math.ceil(t * s.value));
+      }
+    ), O(() => {
+      y();
+    }), () => x(
+      "div",
+      {
+        role: "presentation",
+        ref: f,
+        class: [
+          z.b(),
+          e.class,
+          (e.alwaysOn || n.isDragging) && "always-on"
+        ],
+        style: A.value,
+        onMousedown: _(D, ["stop", "prevent"]),
+        onTouchstartPrevent: p
+      },
+      x(
+        "div",
+        {
+          ref: l,
+          class: I.e("thumb"),
+          style: B.value,
+          onMousedown: p
+        },
+        []
+      )
+    );
+  }
+});
+export {
+  st as default
+};

package/es/components/virtual-list/defaults.d.ts

@@ -0,0 +1,30 @@
+export declare const DEFAULT_DYNAMIC_LIST_ITEM_SIZE = 50;
+export declare const ITEM_RENDER_EVT = "itemRendered";
+export declare const SCROLL_EVT = "scroll";
+export declare const FORWARD = "forward";
+export declare const BACKWARD = "backward";
+export declare const AUTO_ALIGNMENT = "auto";
+export declare const SMART_ALIGNMENT = "smart";
+export declare const START_ALIGNMENT = "start";
+export declare const CENTERED_ALIGNMENT = "center";
+export declare const END_ALIGNMENT = "end";
+export declare const HORIZONTAL = "horizontal";
+export declare const VERTICAL = "vertical";
+export declare const LTR = "ltr";
+export declare const RTL = "rtl";
+export declare const RTL_OFFSET_NAG = "negative";
+export declare const RTL_OFFSET_POS_ASC = "positive-ascending";
+export declare const RTL_OFFSET_POS_DESC = "positive-descending";
+export declare const PageKey: {
+    horizontal: string;
+    vertical: string;
+};
+export declare const ScrollbarSizeKey: {
+    horizontal: string;
+    vertical: string;
+};
+export declare const ScrollbarDirKey: {
+    horizontal: string;
+    vertical: string;
+};
+export declare const SCROLLBAR_MIN_SIZE = 20;

package/es/components/virtual-list/defaults.js

@@ -0,0 +1,33 @@
+const n = 50, c = "itemRendered", s = "scroll", T = "forward", e = "backward", E = "auto", _ = "smart", R = "start", r = "center", A = "end", t = "horizontal", o = "vertical", L = "ltr", N = "rtl", S = "negative", a = "positive-ascending", i = "positive-descending", I = {
+  [t]: "pageX",
+  [o]: "pageY"
+}, l = {
+  [t]: "height",
+  [o]: "width"
+}, O = {
+  [t]: "left",
+  [o]: "top"
+}, M = 20;
+export {
+  E as AUTO_ALIGNMENT,
+  e as BACKWARD,
+  r as CENTERED_ALIGNMENT,
+  n as DEFAULT_DYNAMIC_LIST_ITEM_SIZE,
+  A as END_ALIGNMENT,
+  T as FORWARD,
+  t as HORIZONTAL,
+  c as ITEM_RENDER_EVT,
+  L as LTR,
+  I as PageKey,
+  N as RTL,
+  S as RTL_OFFSET_NAG,
+  a as RTL_OFFSET_POS_ASC,
+  i as RTL_OFFSET_POS_DESC,
+  M as SCROLLBAR_MIN_SIZE,
+  s as SCROLL_EVT,
+  _ as SMART_ALIGNMENT,
+  R as START_ALIGNMENT,
+  O as ScrollbarDirKey,
+  l as ScrollbarSizeKey,
+  o as VERTICAL
+};

package/es/components/virtual-list/hooks/use-cache.d.ts

@@ -0,0 +1 @@
+export declare const useCache: () => import("vue").ComputedRef<(((_: any, __: any, ___: any) => {}) & import("lodash").MemoizedFunction) | import("memoize-one").MemoizedFn<(_: any, __: any, ___: any) => {}>>;

package/es/components/virtual-list/hooks/use-cache.js

@@ -0,0 +1,13 @@
+import { getCurrentInstance as r, computed as t } from "vue";
+import { memoize as m } from "lodash";
+import p from "memoize-one";
+const a = () => {
+  const o = r().proxy.$props;
+  return t(() => {
+    const e = (c, s, _) => ({});
+    return o.perfMode ? m(e) : p(e);
+  });
+};
+export {
+  a as useCache
+};

package/es/components/virtual-list/hooks/use-grid-wheel.d.ts

@@ -0,0 +1,13 @@
+import type { ComputedRef } from 'vue';
+interface GridWheelState {
+    atXStartEdge: ComputedRef<boolean>;
+    atXEndEdge: ComputedRef<boolean>;
+    atYStartEdge: ComputedRef<boolean>;
+    atYEndEdge: ComputedRef<boolean>;
+}
+type GridWheelHandler = (x: number, y: number) => void;
+export declare const useGridWheel: ({ atXEndEdge, atXStartEdge, atYEndEdge, atYStartEdge }: GridWheelState, onWheelDelta: GridWheelHandler) => {
+    hasReachedEdge: (x: number, y: number) => boolean;
+    onWheel: (e: WheelEvent) => void;
+};
+export {};

package/es/components/virtual-list/hooks/use-grid-wheel.js

@@ -0,0 +1,26 @@
+import "@vft/utils";
+import "vue";
+import "lodash";
+import { cAF as c, rAF as m } from "../../../utils/vue/raf.js";
+import "../../../utils/ns-cover.js";
+import "@vueuse/core";
+const W = ({ atXEndEdge: s, atXStartEdge: f, atYEndEdge: i, atYStartEdge: d }, h) => {
+  let n = null, r = 0, a = 0;
+  const o = (l, t) => {
+    const e = l <= 0 && f.value || l >= 0 && s.value, u = t <= 0 && d.value || t >= 0 && i.value;
+    return e && u;
+  };
+  return {
+    hasReachedEdge: o,
+    onWheel: (l) => {
+      c(n);
+      let t = l.deltaX, e = l.deltaY;
+      Math.abs(t) > Math.abs(e) ? e = 0 : t = 0, l.shiftKey && e !== 0 && (t = e, e = 0), !(o(r, a) && o(r + t, a + e)) && (r += t, a += e, l.preventDefault(), n = m(() => {
+        h(r, a), r = 0, a = 0;
+      }));
+    }
+  };
+};
+export {
+  W as useGridWheel
+};

package/es/components/virtual-list/hooks/use-wheel.d.ts

@@ -0,0 +1,13 @@
+import type { ComputedRef } from 'vue';
+import type { LayoutDirection } from '../types';
+interface ListWheelState {
+    atStartEdge: ComputedRef<boolean>;
+    atEndEdge: ComputedRef<boolean>;
+    layout: ComputedRef<LayoutDirection>;
+}
+type ListWheelHandler = (offset: number) => void;
+declare const useWheel: ({ atEndEdge, atStartEdge, layout }: ListWheelState, onWheelDelta: ListWheelHandler) => {
+    hasReachedEdge: (offset: number) => boolean;
+    onWheel: (e: WheelEvent) => void;
+};
+export default useWheel;

package/es/components/virtual-list/hooks/use-wheel.js

@@ -0,0 +1,27 @@
+import { isFirefox as i } from "@vft/utils";
+import "vue";
+import "lodash";
+import { cAF as m, rAF as c } from "../../../utils/vue/raf.js";
+import "../../../utils/ns-cover.js";
+import "@vueuse/core";
+import { HORIZONTAL as d, VERTICAL as u } from "../defaults.js";
+const p = {
+  [d]: "deltaX",
+  [u]: "deltaY"
+}, W = ({ atEndEdge: n, atStartEdge: l, layout: s }, f) => {
+  let a, e = 0;
+  const o = (t) => t < 0 && l.value || t > 0 && n.value;
+  return {
+    hasReachedEdge: o,
+    onWheel: (t) => {
+      m(a);
+      const r = t[p[s.value]];
+      o(e) && o(e + r) || (e += r, i() || t.preventDefault(), a = c(() => {
+        f(e), e = 0;
+      }));
+    }
+  };
+};
+export {
+  W as default
+};

package/es/components/virtual-list/index.d.ts

@@ -0,0 +1,8 @@
+export { default as FixedSizeList } from './components/fixed-size-list';
+export { default as DynamicSizeList } from './components/dynamic-size-list';
+export { default as FixedSizeGrid } from './components/fixed-size-grid';
+export { default as DynamicSizeGrid } from './components/dynamic-size-grid';
+export * from './props';
+export type { GridInstance } from './builders/build-grid';
+export type { DynamicSizeGridInstance, ResetAfterIndex, ResetAfterIndices } from './components/dynamic-size-grid';
+export * from './types';

package/es/components/virtual-list/index.js

@@ -0,0 +1,15 @@
+import { default as e } from "./components/fixed-size-list.js";
+import { default as a } from "./components/dynamic-size-list.js";
+import { default as d } from "./components/fixed-size-grid.js";
+import { default as l } from "./components/dynamic-size-grid.js";
+import { virtualizedGridProps as p, virtualizedListProps as u, virtualizedProps as z, virtualizedScrollbarProps as m } from "./props.js";
+export {
+  l as DynamicSizeGrid,
+  a as DynamicSizeList,
+  d as FixedSizeGrid,
+  e as FixedSizeList,
+  p as virtualizedGridProps,
+  u as virtualizedListProps,
+  z as virtualizedProps,
+  m as virtualizedScrollbarProps
+};

package/es/components/virtual-list/props.d.ts

@@ -0,0 +1,201 @@
+import type { ExtractPropTypes, StyleValue } from 'vue';
+import type { GridItemKeyGetter, ItemSize } from './types';
+export declare const virtualizedProps: {
+    readonly className: import("vft/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown, "div", boolean>;
+    readonly data: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("vft/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("vft/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly useIsScrolling: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly width: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+};
+export declare const virtualizedListProps: {
+    readonly className: import("vft/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown, "div", boolean>;
+    readonly data: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("vft/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("vft/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly useIsScrolling: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly width: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly cache: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly estimatedItemSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly layout: import("vft/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly initScrollOffset: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly itemSize: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | ((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize))[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const virtualizedGridProps: {
+    readonly className: import("vft/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown, "div", boolean>;
+    readonly data: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("vft/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("vft/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly useIsScrolling: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly width: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly columnCache: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly columnWidth: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | ((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize))[], 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("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly initScrollTop: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly itemKey: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => GridItemKeyGetter) | (() => GridItemKeyGetter) | {
+        (): GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => GridItemKeyGetter) | (() => GridItemKeyGetter) | {
+        (): GridItemKeyGetter;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, ({ columnIndex, rowIndex }: {
+        columnIndex: number;
+        rowIndex: number;
+    }) => string, boolean>;
+    readonly rowCache: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => number | ItemSize) | (() => number | ItemSize) | ((new (...args: any[]) => number | ItemSize) | (() => number | ItemSize))[], 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("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly vScrollbarSize: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly scrollbarStartGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly role: StringConstructor;
+};
+export declare const virtualizedScrollbarProps: {
+    readonly alwaysOn: BooleanConstructor;
+    readonly class: StringConstructor;
+    readonly layout: import("vft/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly ratio: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly clientSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollFrom: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly scrollbarSize: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly startGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly endGap: import("vft/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly visible: BooleanConstructor;
+};
+export type VirtualizedProps = ExtractPropTypes<typeof virtualizedProps>;
+export type VirtualizedListProps = ExtractPropTypes<typeof virtualizedListProps>;
+export type VirtualizedGridProps = ExtractPropTypes<typeof virtualizedGridProps>;
+export type VirtualizedScrollbarProps = ExtractPropTypes<typeof virtualizedScrollbarProps>;