vft 0.0.48 → 0.0.51

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

@@ -0,0 +1,147 @@
+import "@vft/utils";
+import "vue";
+import { buildProp as e, buildProps as l, definePropType as t } from "../../utils/vue/props/runtime.js";
+import "@vueuse/core";
+import { mutable as b } from "../../utils/typescript.js";
+import "../../utils/ns-cover.js";
+import "lodash";
+import { VERTICAL as f } from "./defaults.js";
+const o = e({
+  type: t([Number, Function]),
+  required: !0
+}), i = e({
+  type: Number
+}), a = e({
+  type: Number,
+  default: 2
+}), S = e({
+  type: String,
+  values: ["ltr", "rtl"],
+  default: "ltr"
+}), u = e({
+  type: Number,
+  default: 0
+}), r = e({
+  type: Number,
+  required: !0
+}), p = e({
+  type: String,
+  values: ["horizontal", "vertical"],
+  default: f
+}), s = l({
+  className: {
+    type: String,
+    default: ""
+  },
+  containerElement: {
+    type: t([String, Object]),
+    default: "div"
+  },
+  data: {
+    type: t(Array),
+    default: () => b([])
+  },
+  /**
+   * @description controls the horizontal direction.
+   */
+  direction: S,
+  height: {
+    type: [String, Number],
+    required: !0
+  },
+  innerElement: {
+    type: [String, Object],
+    default: "div"
+  },
+  style: {
+    type: t([Object, String, Array])
+  },
+  useIsScrolling: {
+    type: Boolean,
+    default: !1
+  },
+  width: {
+    type: [Number, String],
+    required: !1
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarAlwaysOn: {
+    type: Boolean,
+    default: !1
+  }
+}), O = l({
+  /**
+   * @description describes how many items should be pre rendered to the head
+   * and the tail of the window
+   */
+  cache: a,
+  estimatedItemSize: i,
+  /**
+   * @description controls the list's orientation
+   */
+  layout: p,
+  initScrollOffset: u,
+  /**
+   * @description describes the total number of the list.
+   */
+  total: r,
+  itemSize: o,
+  ...s
+}), n = {
+  type: Number,
+  default: 6
+}, c = { type: Number, default: 0 }, d = { type: Number, default: 2 }, B = l({
+  columnCache: a,
+  columnWidth: o,
+  estimatedColumnWidth: i,
+  estimatedRowHeight: i,
+  initScrollLeft: u,
+  initScrollTop: u,
+  itemKey: {
+    type: t(Function),
+    default: ({
+      columnIndex: m,
+      rowIndex: y
+    }) => `${y}:${m}`
+  },
+  rowCache: a,
+  rowHeight: o,
+  totalColumn: r,
+  totalRow: r,
+  hScrollbarSize: n,
+  vScrollbarSize: n,
+  scrollbarStartGap: c,
+  scrollbarEndGap: d,
+  role: String,
+  ...s
+}), C = l({
+  alwaysOn: Boolean,
+  class: String,
+  layout: p,
+  total: r,
+  ratio: {
+    type: Number,
+    required: !0
+  },
+  clientSize: {
+    type: Number,
+    required: !0
+  },
+  scrollFrom: {
+    type: Number,
+    required: !0
+  },
+  scrollbarSize: n,
+  startGap: c,
+  endGap: d,
+  visible: Boolean
+});
+export {
+  B as virtualizedGridProps,
+  O as virtualizedListProps,
+  s as virtualizedProps,
+  C as virtualizedScrollbarProps
+};

package/es/components/virtual-list/style/css.js

@@ -0,0 +1,3 @@
+import "vft/theme-style/base.css";
+import "vft/theme-style/vft-virtual-list.css";
+import "vft/theme-style/vft-scrollbar.css";

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

@@ -0,0 +1,3 @@
+import "vft/theme-style/src/base.scss";
+import "vft/theme-style/src/virtual-list.scss";
+import "vft/theme-style/src/scrollbar.scss";

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

@@ -0,0 +1,137 @@
+import type { CSSProperties, ComponentInternalInstance, Ref } from 'vue';
+export type Instance = ComponentInternalInstance;
+export type Alignment = 'auto' | 'smart' | 'center' | 'start' | 'end';
+export type ItemSize = (idx: number) => number;
+export type Direction = 'ltr' | 'rtl';
+export type LayoutDirection = 'horizontal' | 'vertical';
+export type RTLOffsetType = 'negative' | 'positive-descending' | 'positive-ascending';
+export type ItemProps<T> = {
+    data: T;
+    style: CSSProperties;
+    scrolling?: boolean;
+    index: number;
+};
+export type ListItem = {
+    offset: number;
+    size: number;
+};
+export type ListCache = {
+    items: Record<string, ListItem>;
+    estimatedItemSize: number;
+    lastVisitedIndex: number;
+    clearCacheAfterIndex: (idx: number, forceUpdate?: boolean) => void;
+};
+export type GridCache = {
+    column: Record<string, ListItem>;
+    row: Record<string, ListItem>;
+    estimatedColumnWidth: number;
+    estimatedRowHeight: number;
+    lastVisitedColumnIndex: number;
+    lastVisitedRowIndex: number;
+};
+export type ScrollDir = 'forwards' | 'backwards';
+export type ListItemSizer<T, P extends InitListCacheFunc<T>> = (props: T, index: number, cache: ReturnType<P>) => number;
+export type GetEstimatedTotalSize<T, P extends InitCacheFunc<T, GridCache | ListCache>> = (props: T, cache: ReturnType<P>) => number;
+export type GetOffset<T, P extends InitListCacheFunc<T>> = (props: T, idx: number, alignment: Alignment, offset: number, cache: ReturnType<P>) => number;
+export type GetStartIndexForOffset<T, P extends InitCacheFunc<T, GridCache | ListCache>> = (props: T, offset: number, cache: ReturnType<P>) => number;
+export type GetStopIndexForStartIndex<T, P extends InitCacheFunc<T, GridCache | ListCache>> = (props: T, startIndex: number, scrollOffset: number, cache: ReturnType<P>) => number;
+export type PropValidator<T> = (props: T) => void;
+export type InitCacheFunc<T, P> = (props: T, cache: Instance) => P;
+export type InitListCacheFunc<T> = InitCacheFunc<T, ListCache>;
+export type InitGridCacheFunc<T> = InitCacheFunc<T, GridCache>;
+export type ListConstructorProps<T, P extends InitListCacheFunc<T> = InitListCacheFunc<T>> = {
+    name?: string;
+    getItemOffset: ListItemSizer<T, P>;
+    getEstimatedTotalSize: GetEstimatedTotalSize<T, P>;
+    getItemSize: ListItemSizer<T, P>;
+    getOffset: GetOffset<T, P>;
+    getStartIndexForOffset: GetStartIndexForOffset<T, P>;
+    getStopIndexForStartIndex: GetStopIndexForStartIndex<T, P>;
+    initCache: P;
+    clearCache: boolean;
+    validateProps: PropValidator<T>;
+};
+export type ExposesStates = {
+    isScrolling: boolean;
+    updateRequested: boolean;
+};
+export type SharedExposes = {
+    windowRef: Ref<HTMLElement>;
+    innerRef: Ref<HTMLElement>;
+    getItemStyleCache: (_: any, __: any, ___: any) => CSSProperties;
+};
+export type ListExposes = {
+    scrollTo: (offset: number) => void;
+    scrollToItem: (idx: number, alignment?: Alignment) => void;
+    states: {
+        scrollDir: Direction;
+        scrollOffset: number;
+    } & ExposesStates;
+} & SharedExposes;
+export type GridExposes = {
+    states: {
+        scrollLeft: number;
+        scrollTop: number;
+        xAxisScrollDir: Direction;
+        yAxisScrollDir: Direction;
+    } & ExposesStates;
+    scrollTo: (props: {
+        scrollLeft: number;
+        scrollTop: number;
+    }) => void;
+    scrollToItem: (columnIndex?: number, rowIndex?: number, alignment?: Alignment) => void;
+} & SharedExposes;
+export type ScrollbarExpose = {
+    onMouseUp: () => void;
+};
+export type GetGridOffset<T, P extends InitGridCacheFunc<T>> = (props: T, index: number, alignment: Alignment, offset: number, cache: ReturnType<P>, scrollbarWidth: number) => number;
+export type GetPosition<T, P extends InitGridCacheFunc<T>> = (props: T, index: number, cache: ReturnType<P>) => [number, number];
+export type GridConstructorProps<T, P extends InitGridCacheFunc<T> = InitGridCacheFunc<T>> = {
+    name?: string;
+    getColumnOffset: GetGridOffset<T, P>;
+    getColumnPosition: GetPosition<T, P>;
+    getColumnStartIndexForOffset: GetStartIndexForOffset<T, P>;
+    getColumnStopIndexForStartIndex: GetStopIndexForStartIndex<T, P>;
+    getEstimatedTotalHeight: GetEstimatedTotalSize<T, P>;
+    getEstimatedTotalWidth: GetEstimatedTotalSize<T, P>;
+    getRowOffset: GetGridOffset<T, P>;
+    getRowPosition: GetPosition<T, P>;
+    getRowStartIndexForOffset: GetStartIndexForOffset<T, P>;
+    getRowStopIndexForStartIndex: GetStopIndexForStartIndex<T, P>;
+    initCache: P;
+    injectToInstance?: (instance: Instance, cache: Ref<ReturnType<P>>) => void;
+    clearCache: boolean;
+    validateProps: PropValidator<T>;
+};
+/**
+ * Instance methods and emits
+ */
+export type GridDefaultSlotParams = {
+    columnIndex: number;
+    rowIndex: number;
+    data: any;
+    key: number | string;
+    isScrolling?: boolean;
+    style: CSSProperties;
+};
+export type GridItemRenderedEvtParams = {
+    columnCacheStart: number;
+    columnCacheEnd: number;
+    rowCacheStart: number;
+    rowCacheEnd: number;
+    columnVisibleStart: number;
+    columnVisibleEnd: number;
+    rowVisibleStart: number;
+    rowVisibleEnd: number;
+};
+export type GridScrollOptions = {
+    scrollLeft?: number;
+    scrollTop?: number;
+};
+export type GridItemKeyGetter = <T extends {
+    [key: string | number]: any;
+}>(args: {
+    columnIndex: number;
+    data: T;
+    rowIndex: number;
+}) => string | number;

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,17 @@
+import type { CSSProperties } from 'vue';
+import type { Direction, LayoutDirection, RTLOffsetType } from './types';
+export declare const getScrollDir: (prev: number, cur: number) => "forward" | "backward";
+export declare const isHorizontal: (dir: string) => boolean;
+export declare const isRTL: (dir: Direction) => boolean;
+export declare function getRTLOffsetType(recalculate?: boolean): RTLOffsetType;
+export declare const getRelativePos: (e: TouchEvent | MouseEvent, layout: LayoutDirection) => any;
+type RenderThumbStyleParams = {
+    bar: {
+        size: 'height' | 'width';
+        axis: 'X' | 'Y';
+    };
+    size: string;
+    move: number;
+};
+export declare function renderThumbStyle({ move, size, bar }: RenderThumbStyleParams, layout: string): CSSProperties;
+export {};

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

@@ -0,0 +1,25 @@
+import { FORWARD as d, BACKWARD as f, LTR as h, RTL as c, HORIZONTAL as u, PageKey as i, RTL_OFFSET_POS_DESC as a, RTL_OFFSET_NAG as T, RTL_OFFSET_POS_ASC as m } from "./defaults.js";
+const p = (e, t) => e < t ? d : f, L = (e) => e === h || e === c || e === u, S = (e) => e === c;
+let l = null;
+function y(e = !1) {
+  if (l === null || e) {
+    const t = document.createElement("div"), o = t.style;
+    o.width = "50px", o.height = "50px", o.overflow = "scroll", o.direction = "rtl";
+    const r = document.createElement("div"), n = r.style;
+    return n.width = "100px", n.height = "100px", t.appendChild(r), document.body.appendChild(t), t.scrollLeft > 0 ? l = a : (t.scrollLeft = 1, t.scrollLeft === 0 ? l = T : l = m), document.body.removeChild(t), l;
+  }
+  return l;
+}
+const O = (e, t) => "touches" in e ? e.touches[0][i[t]] : e[i[t]];
+function _({ move: e, size: t, bar: o }, r) {
+  const n = {}, s = `translate${o.axis}(${e}px)`;
+  return n[o.size] = t, n.transform = s, n.msTransform = s, n.webkitTransform = s, r === "horizontal" ? n.height = "100%" : n.width = "100%", n;
+}
+export {
+  y as getRTLOffsetType,
+  O as getRelativePos,
+  p as getScrollDir,
+  L as isHorizontal,
+  S as isRTL,
+  _ as renderThumbStyle
+};

package/es/defaults.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
     version: string;
-    install: (app: import("vue").App<any>, options?: Partial<import("vft/es/components").ConfigProviderProps> | undefined) => void;
+    install: (app: import("vue").App<any>, options?: Partial<import("vft/es/components/config-provider/config-provider.vue").ConfigProviderProps> | undefined) => void;
 };
 export default _default;

package/es/hooks/index.d.ts

@@ -11,3 +11,6 @@ export * from './use-ordered-children';
 export * from './use-model-toggle';
 export * from './use-prop';
 export * from './use-size';
+export * from './use-draggable';
+export * from './use-lockscreen';
+export * from './use-same-target';

package/es/hooks/index.js

@@ -1,42 +1,48 @@
-import { _bem as r, defaultNamespace as t, namespaceContextKey as p, useGetDerivedNamespace as s, useNamespace as u } from "./use-namespace/index.js";
+import { _bem as r, defaultNamespace as t, namespaceContextKey as s, useGetDerivedNamespace as p, useNamespace as m } from "./use-namespace/index.js";
 import { useCursor as a } from "./use-cursor/index.js";
-import { usePopper as x } from "./use-popper/index.js";
-import { defaultInitialZIndex as I, useZIndex as l, zIndexContextKey as n } from "./use-z-index/index.js";
-import { FORWARD_REF_INJECTION_KEY as C, useForwardRef as E, useForwardRefDirective as N } from "./use-forward-ref/index.js";
-import { ID_INJECTION_KEY as T, useId as _, useIdInjection as c } from "./use-id/index.js";
+import { usePopper as f } from "./use-popper/index.js";
+import { defaultInitialZIndex as l, useZIndex as I, zIndexContextKey as n } from "./use-z-index/index.js";
+import { FORWARD_REF_INJECTION_KEY as g, useForwardRef as C, useForwardRefDirective as c } from "./use-forward-ref/index.js";
+import { ID_INJECTION_KEY as N, useId as T, useIdInjection as _ } from "./use-id/index.js";
 import { usePopperContainer as K, usePopperContainerId as O } from "./use-popper-container/index.js";
-import { useDelayedToggle as F } from "./use-delayed-toggle/index.js";
-import { useTimeout as b } from "./use-timeout/index.js";
+import { useDelayedToggle as b } from "./use-delayed-toggle/index.js";
+import { useTimeout as P } from "./use-timeout/index.js";
 import { useOrderedChildren as J } from "./use-ordered-children/index.js";
-import { createModelToggleComposable as Y, useModelToggle as Z, useModelToggleEmits as v } from "./use-model-toggle/index.js";
-import { useProp as z } from "./use-prop/index.js";
-import { SIZE_INJECTION_KEY as S, useGlobalSize as h } from "./use-size/index.js";
+import { createModelToggleComposable as S, useModelToggle as Y, useModelToggleEmits as Z } from "./use-model-toggle/index.js";
+import { useProp as w } from "./use-prop/index.js";
+import { SIZE_INJECTION_KEY as G, useGlobalSize as h } from "./use-size/index.js";
+import { useDraggable as k } from "./use-draggable/index.js";
+import { useLockscreen as L } from "./use-lockscreen/index.js";
+import { useSameTarget as q } from "./use-same-target/index.js";
 export {
-  C as FORWARD_REF_INJECTION_KEY,
-  T as ID_INJECTION_KEY,
-  S as SIZE_INJECTION_KEY,
+  g as FORWARD_REF_INJECTION_KEY,
+  N as ID_INJECTION_KEY,
+  G as SIZE_INJECTION_KEY,
   r as _bem,
-  Y as createModelToggleComposable,
-  I as defaultInitialZIndex,
+  S as createModelToggleComposable,
+  l as defaultInitialZIndex,
   t as defaultNamespace,
-  p as namespaceContextKey,
+  s as namespaceContextKey,
   a as useCursor,
-  F as useDelayedToggle,
-  E as useForwardRef,
-  N as useForwardRefDirective,
-  s as useGetDerivedNamespace,
+  b as useDelayedToggle,
+  k as useDraggable,
+  C as useForwardRef,
+  c as useForwardRefDirective,
+  p as useGetDerivedNamespace,
   h as useGlobalSize,
-  _ as useId,
-  c as useIdInjection,
-  Z as useModelToggle,
-  v as useModelToggleEmits,
-  u as useNamespace,
+  T as useId,
+  _ as useIdInjection,
+  L as useLockscreen,
+  Y as useModelToggle,
+  Z as useModelToggleEmits,
+  m as useNamespace,
   J as useOrderedChildren,
-  x as usePopper,
+  f as usePopper,
   K as usePopperContainer,
   O as usePopperContainerId,
-  z as useProp,
-  b as useTimeout,
-  l as useZIndex,
+  w as useProp,
+  q as useSameTarget,
+  P as useTimeout,
+  I as useZIndex,
   n as zIndexContextKey
 };

package/es/hooks/use-draggable/index.d.ts

@@ -0,0 +1,2 @@
+import type { ComputedRef, Ref } from 'vue';
+export declare const useDraggable: (targetRef: Ref<HTMLElement | undefined>, dragRef: Ref<HTMLElement | undefined>, draggable: ComputedRef<boolean>) => void;

package/es/hooks/use-draggable/index.js

@@ -0,0 +1,42 @@
+import { onMounted as W, watchEffect as B, onBeforeUnmount as U } from "vue";
+import { addUnit as g } from "@vft/utils";
+const C = (t, e, p) => {
+  let c = {
+    offsetX: 0,
+    offsetY: 0
+  };
+  const m = (u) => {
+    const L = u.clientX, M = u.clientY, { offsetX: n, offsetY: s } = c, o = t.value.getBoundingClientRect(), a = o.left, l = o.top, w = o.width, X = o.height, Y = document.documentElement.clientWidth, x = document.documentElement.clientHeight, b = -a + n, D = -l + s, H = Y - a - w + n, T = x - l - X + s, d = (f) => {
+      const r = Math.min(
+        Math.max(n + f.clientX - L, b),
+        H
+      ), h = Math.min(
+        Math.max(s + f.clientY - M, D),
+        T
+      );
+      c = {
+        offsetX: r,
+        offsetY: h
+      }, t.value.style.transform = `translate(${g(
+        r
+      )}, ${g(h)})`;
+    }, v = () => {
+      document.removeEventListener("mousemove", d), document.removeEventListener("mouseup", v);
+    };
+    document.addEventListener("mousemove", d), document.addEventListener("mouseup", v);
+  }, E = () => {
+    e.value && t.value && e.value.addEventListener("mousedown", m);
+  }, i = () => {
+    e.value && t.value && e.value.removeEventListener("mousedown", m);
+  };
+  W(() => {
+    B(() => {
+      p.value ? E() : i();
+    });
+  }), U(() => {
+    i();
+  });
+};
+export {
+  C as useDraggable
+};

package/es/hooks/use-id/index.js

@@ -2,8 +2,8 @@ import { getCurrentInstance as n, inject as i, computed as c, unref as s } from
 import { isClient as u } from "@vueuse/core";
 import "@vft/utils";
 import { debugWarn as d } from "../../utils/error.js";
-import "../../utils/ns-cover.js";
 import "lodash";
+import "../../utils/ns-cover.js";
 import { useGetDerivedNamespace as p } from "../use-namespace/index.js";
 const r = {
   prefix: Math.floor(Math.random() * 1e4),

package/es/hooks/use-lockscreen/index.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+import type { UseNamespaceReturn } from '../use-namespace';
+export type UseLockScreenOptions = {
+    ns?: UseNamespaceReturn;
+};
+/**
+ * Hook that monitoring the ref value to lock or unlock the screen.
+ * When the trigger became true, it assumes modal is now opened and vice versa.
+ * @param trigger {Ref<boolean>}
+ */
+export declare const useLockscreen: (trigger: Ref<boolean>, options?: UseLockScreenOptions) => void;

package/es/hooks/use-lockscreen/index.js

@@ -0,0 +1,36 @@
+import { isRef as a, watch as p, onScopeDispose as f } from "vue";
+import { computed as y } from "@vue/reactivity";
+import { isClient as h } from "@vueuse/core";
+import { hasClass as c, getStyle as b, addClass as v, removeClass as w } from "@vft/utils";
+import { throwError as C } from "../../utils/error.js";
+import "lodash";
+import "../../utils/ns-cover.js";
+import { getScrollBarWidth as H } from "../../utils/dom/scroll.js";
+import { useNamespace as S } from "../use-namespace/index.js";
+const D = (s, m = {}) => {
+  a(s) || C(
+    "[useLockscreen]",
+    "You need to pass a ref param to this function"
+  );
+  const d = m.ns || S("popup"), o = y(() => d.bm("parent", "hidden"));
+  if (!h || c(document.body, o.value))
+    return;
+  let t = 0, e = !1, r = "0";
+  const n = () => {
+    setTimeout(() => {
+      w(document == null ? void 0 : document.body, o.value), e && document && (document.body.style.width = r);
+    }, 200);
+  };
+  p(s, (i) => {
+    if (!i) {
+      n();
+      return;
+    }
+    e = !c(document.body, o.value), e && (r = document.body.style.width), t = H(d.namespace.value);
+    const l = document.documentElement.clientHeight < document.body.scrollHeight, u = b(document.body, "overflowY");
+    t > 0 && (l || u === "scroll") && e && (document.body.style.width = `calc(100% - ${t}px)`), v(document.body, o.value);
+  }), f(() => n());
+};
+export {
+  D as useLockscreen
+};

package/es/hooks/use-ordered-children/index.js

@@ -1,19 +1,20 @@
 import { shallowRef as s, isVNode as m } from "vue";
 import "@vft/utils";
-import { flattedChildren as c } from "../../utils/vue/vnode.js";
-import "../../utils/ns-cover.js";
+import { flattedChildren as p } from "../../utils/vue/vnode.js";
 import "lodash";
-const p = (t, i, d) => c(t.subTree).filter(
+import "@vueuse/core";
+import "../../utils/ns-cover.js";
+const c = (t, i, d) => p(t.subTree).filter(
   (e) => {
     var r;
     return m(e) && ((r = e.type) == null ? void 0 : r.name) === i && !!e.component;
   }
-).map((e) => e.component.uid).map((e) => d[e]).filter((e) => !!e), v = (t, i) => {
+).map((e) => e.component.uid).map((e) => d[e]).filter((e) => !!e), O = (t, i) => {
   const d = {}, o = s([]);
   return {
     children: o,
     addChild: (r) => {
-      d[r.uid] = r, o.value = p(t, i, d);
+      d[r.uid] = r, o.value = c(t, i, d);
     },
     removeChild: (r) => {
       delete d[r], o.value = o.value.filter(
@@ -23,5 +24,5 @@ const p = (t, i, d) => c(t.subTree).filter(
   };
 };
 export {
-  v as useOrderedChildren
+  O as useOrderedChildren
 };

package/es/hooks/use-popper/index.d.ts

@@ -41,13 +41,13 @@ export declare const usePopper: (referenceElementRef: Ref<ReferenceElement>, pop
                 popperEscapeOffsets: import("@popperjs/core").SideObject;
             } | undefined;
             offset?: {
-                bottom?: import("@popperjs/core").Offsets | undefined;
-                left?: import("@popperjs/core").Offsets | undefined;
-                right?: import("@popperjs/core").Offsets | undefined;
-                top?: import("@popperjs/core").Offsets | undefined;
                 auto?: import("@popperjs/core").Offsets | undefined;
                 "auto-start"?: import("@popperjs/core").Offsets | undefined;
                 "auto-end"?: import("@popperjs/core").Offsets | undefined;
+                top?: import("@popperjs/core").Offsets | undefined;
+                bottom?: import("@popperjs/core").Offsets | undefined;
+                right?: import("@popperjs/core").Offsets | undefined;
+                left?: import("@popperjs/core").Offsets | undefined;
                 "top-start"?: import("@popperjs/core").Offsets | undefined;
                 "top-end"?: import("@popperjs/core").Offsets | undefined;
                 "bottom-start"?: import("@popperjs/core").Offsets | undefined;

package/es/hooks/use-same-target/index.d.ts

@@ -0,0 +1,5 @@
+export declare const useSameTarget: (handleClick?: ((e: MouseEvent) => void) | undefined) => {
+    onClick: (e: MouseEvent) => void;
+    onMousedown: (e: MouseEvent) => void;
+    onMouseup: (e: MouseEvent) => void;
+};

package/es/hooks/use-same-target/index.js

@@ -0,0 +1,16 @@
+import { NOOP as n } from "@vue/shared";
+const g = (r) => {
+  if (!r)
+    return { onClick: n, onMousedown: n, onMouseup: n };
+  let e = !1, t = !1;
+  return { onClick: (o) => {
+    e && t && r(o), e = t = !1;
+  }, onMousedown: (o) => {
+    e = o.target === o.currentTarget;
+  }, onMouseup: (o) => {
+    t = o.target === o.currentTarget;
+  } };
+};
+export {
+  g as useSameTarget
+};

package/es/hooks/use-size/index.d.ts

@@ -4,4 +4,4 @@ export interface SizeContext {
     size: Ref<ComponentSize>;
 }
 export declare const SIZE_INJECTION_KEY: InjectionKey<SizeContext>;
-export declare const useGlobalSize: () => import("vue").ComputedRef<"" | "large" | "small" | "default">;
+export declare const useGlobalSize: () => import("vue").ComputedRef<"" | "default" | "small" | "large">;

package/es/index.d.ts

@@ -5,7 +5,7 @@ export * from 'vft/es/hooks';
 export * from 'vft/es/utils';
 export * from './make-installer';
 export * from './comp-resolver';
-export declare const install: (app: import("vue").App<any>, options?: Partial<import("vft/es/components").ConfigProviderProps> | undefined) => void;
+export declare const install: (app: import("vue").App<any>, options?: Partial<import("vft/es/components/config-provider/config-provider.vue").ConfigProviderProps> | undefined) => void;
 export declare const version: string;
 export default installer;
 export { default as dayjs } from 'dayjs';