vft 0.0.48 → 0.0.51

package/es/components/roving-focus-group/roving-focus-item.vue2.js

@@ -0,0 +1,106 @@
+import { defineComponent as y, inject as l, ref as w, computed as d, unref as n, provide as R, nextTick as g } from "vue";
+import "../config-provider/hooks/use-global-config.js";
+import "@popperjs/core";
+import "lodash";
+import "../../hooks/use-z-index/index.js";
+import { useId as h } from "../../hooks/use-id/index.js";
+import "@vueuse/core";
+import "@vft/utils";
+import { composeEventHandlers as c } from "../../utils/event.js";
+import "../../utils/ns-cover.js";
+import "@vue/reactivity";
+import "@vue/shared";
+import { EVENT_CODE as k } from "../../constants/aria.js";
+import { VftCollectionItem as x, ROVING_FOCUS_COLLECTION_INJECTION_KEY as G } from "./types.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY as K, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as U } from "./tokens.js";
+import { getFocusIntent as V, reorderArray as J, focusFirst as L } from "./utils.js";
+const oe = y({
+  components: {
+    RovingFocusCollectionItem: x
+  },
+  props: {
+    focusable: {
+      type: Boolean,
+      default: !0
+    },
+    active: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["mousedown", "focus", "keydown"],
+  setup(I, { emit: s }) {
+    const { currentTabbedId: O, loop: _, onItemFocus: m, onItemShiftTab: C } = l(
+      K,
+      void 0
+    ), { getItems: v } = l(
+      G,
+      void 0
+    ), r = h(), E = w(null), a = c(
+      (e) => {
+        s("mousedown", e);
+      },
+      (e) => {
+        I.focusable ? m(n(r)) : e.preventDefault();
+      }
+    ), f = c(
+      (e) => {
+        s("focus", e);
+      },
+      () => {
+        m(n(r));
+      }
+    ), u = c(
+      (e) => {
+        s("keydown", e);
+      },
+      (e) => {
+        const { key: T, shiftKey: b, target: F, currentTarget: p } = e;
+        if (T === k.tab && b) {
+          C();
+          return;
+        }
+        if (F !== p)
+          return;
+        const i = V(e);
+        if (i) {
+          e.preventDefault();
+          let o = v().filter(
+            (t) => t.focusable
+          ).map((t) => t.ref);
+          switch (i) {
+            case "last": {
+              o.reverse();
+              break;
+            }
+            case "prev":
+            case "next": {
+              i === "prev" && o.reverse();
+              const t = o.indexOf(p);
+              o = _.value ? J(o, t + 1) : o.slice(t + 1);
+              break;
+            }
+          }
+          g(() => {
+            L(o);
+          });
+        }
+      }
+    ), N = d(() => O.value === n(r));
+    return R(U, {
+      rovingFocusGroupItemRef: E,
+      tabIndex: d(() => n(N) ? 0 : -1),
+      handleMousedown: a,
+      handleFocus: f,
+      handleKeydown: u
+    }), {
+      id: r,
+      handleKeydown: u,
+      handleFocus: f,
+      handleMousedown: a
+    };
+  }
+});
+export {
+  oe as default
+};

package/es/components/roving-focus-group/tokens.d.ts

@@ -0,0 +1,37 @@
+import type { InjectionKey, Ref, StyleValue } from 'vue';
+export interface VftRovingFocusGroupProps {
+    style?: StyleValue;
+    currentTabId?: string | null;
+    defaultCurrentTabId?: string;
+    loop?: boolean;
+    dir?: 'ltr' | 'rtl';
+    orientation?: string;
+    onBlur?: Function;
+    onFocus?: Function;
+    onMousedown?: Function;
+}
+type EventHandler<T = Event> = (e: T) => void;
+export type RovingGroupInjectionContext = {
+    currentTabbedId: Ref<string | null>;
+    dir: Ref<VftRovingFocusGroupProps['dir']>;
+    loop: Ref<VftRovingFocusGroupProps['loop']>;
+    orientation: Ref<VftRovingFocusGroupProps['orientation']>;
+    tabIndex: Ref<number>;
+    rovingFocusGroupRef: Ref<HTMLElement | null>;
+    rovingFocusGroupRootStyle: Ref<StyleValue>;
+    onBlur: EventHandler;
+    onFocus: EventHandler<FocusEvent>;
+    onMousedown: EventHandler;
+    onItemFocus: (id: string) => void;
+    onItemShiftTab: () => void;
+};
+export type RovingFocusGroupItemInjectionContext = {
+    rovingFocusGroupItemRef: Ref<HTMLElement | null>;
+    tabIndex: Ref<number>;
+    handleMousedown: EventHandler;
+    handleFocus: EventHandler;
+    handleKeydown: EventHandler;
+};
+export declare const ROVING_FOCUS_GROUP_INJECTION_KEY: InjectionKey<RovingGroupInjectionContext>;
+export declare const ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY: InjectionKey<RovingFocusGroupItemInjectionContext>;
+export {};

package/es/components/roving-focus-group/tokens.js

@@ -0,0 +1,5 @@
+const o = Symbol("vftRovingFocusGroup"), _ = Symbol("vftRovingFocusGroupItem");
+export {
+  o as ROVING_FOCUS_GROUP_INJECTION_KEY,
+  _ as ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY
+};

package/es/components/roving-focus-group/types.d.ts

@@ -0,0 +1,252 @@
+declare const VftCollection: {
+    name: string;
+    setup(): void;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+    template?: string | object | undefined;
+    render?: Function | undefined;
+    components?: Record<string, import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>> | undefined;
+    directives?: Record<string, import("vue").Directive<any, any>> | undefined;
+    inheritAttrs?: boolean | undefined;
+    emits?: ThisType<void> | (string[] & ThisType<void>) | undefined;
+    expose?: string[] | undefined;
+    serverPrefetch?(): void | Promise<any>;
+    compilerOptions?: import("vue").RuntimeCompilerOptions | undefined;
+    call: (<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, ...args: A) => void) & ((this: unknown, ...args: unknown[]) => never);
+    __defaults?: {} | undefined;
+    compatConfig?: (Partial<Record<import("vue").DeprecationTypes, boolean | "suppress-warning">> & {
+        MODE?: 2 | 3 | ((comp: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | null) => 2 | 3) | undefined;
+    }) | undefined;
+    data?: ((this: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>, vm: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>) => {}) | undefined;
+    computed?: {} | undefined;
+    methods?: {} | undefined;
+    watch?: {
+        [x: string]: (string | import("vue").WatchCallback<any, any> | ({
+            handler: string | import("vue").WatchCallback<any, any>;
+        } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback<any, any> | ({
+            handler: string | import("vue").WatchCallback<any, any>;
+        } & import("vue").WatchOptions<boolean>))[];
+    } | undefined;
+    provide?: import("vue").ComponentProvideOptions | undefined;
+    inject?: {} | string[] | undefined;
+    filters?: Record<string, Function> | undefined;
+    mixins?: import("vue").ComponentOptionsMixin[] | undefined;
+    extends?: import("vue").ComponentOptionsMixin | undefined;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    beforeDestroy?(): void;
+    beforeUnmount?(): void;
+    destroyed?(): void;
+    unmounted?(): void;
+    renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+    renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+    errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | undefined;
+    delimiters?: [string, string] | undefined;
+    __differentiator?: undefined;
+    __isBuiltIn?: boolean | undefined;
+    __file?: string | undefined;
+    __name?: string | undefined;
+    beforeRouteEnter?: import("vue-router").NavigationGuardWithThis<undefined> | undefined;
+    beforeRouteUpdate?: import("vue-router").NavigationGuard | undefined;
+    beforeRouteLeave?: import("vue-router").NavigationGuard | undefined;
+    key?: string | number | symbol | undefined;
+    ref?: import("vue").VNodeRef | undefined;
+    ref_for?: boolean | undefined;
+    ref_key?: string | undefined;
+    onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    class?: unknown;
+    style?: unknown;
+}, VftCollectionItem: {
+    name: string;
+    setup(_: unknown, { attrs }: {
+        attrs: {
+            [x: string]: unknown;
+        };
+        slots: Readonly<{
+            [name: string]: import("vue").Slot | undefined;
+        }>;
+        emit: (event: string, ...args: any[]) => void;
+        expose: (exposed?: Record<string, any> | undefined) => void;
+    } | {
+        attrs: {
+            [x: string]: unknown;
+        };
+        slots: Readonly<{
+            [name: string]: import("vue").Slot | undefined;
+        }>;
+        emit: (event: string, ...args: any[]) => void;
+        expose: (exposed?: Record<string, any> | undefined) => void;
+    }): void;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+    template?: string | object | undefined;
+    render?: Function | undefined;
+    components?: Record<string, import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>> | undefined;
+    directives?: Record<string, import("vue").Directive<any, any>> | undefined;
+    inheritAttrs?: boolean | undefined;
+    emits?: ThisType<void> | (string[] & ThisType<void>) | undefined;
+    expose?: string[] | undefined;
+    serverPrefetch?(): void | Promise<any>;
+    compilerOptions?: import("vue").RuntimeCompilerOptions | undefined;
+    call: (<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, ...args: A) => void) & ((this: unknown, ...args: unknown[]) => never);
+    __defaults?: {} | undefined;
+    compatConfig?: (Partial<Record<import("vue").DeprecationTypes, boolean | "suppress-warning">> & {
+        MODE?: 2 | 3 | ((comp: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | null) => 2 | 3) | undefined;
+    }) | undefined;
+    data?: ((this: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>, vm: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>) => {}) | undefined;
+    computed?: {} | undefined;
+    methods?: {} | undefined;
+    watch?: {
+        [x: string]: (string | import("vue").WatchCallback<any, any> | ({
+            handler: string | import("vue").WatchCallback<any, any>;
+        } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback<any, any> | ({
+            handler: string | import("vue").WatchCallback<any, any>;
+        } & import("vue").WatchOptions<boolean>))[];
+    } | undefined;
+    provide?: import("vue").ComponentProvideOptions | undefined;
+    inject?: {} | string[] | undefined;
+    filters?: Record<string, Function> | undefined;
+    mixins?: import("vue").ComponentOptionsMixin[] | undefined;
+    extends?: import("vue").ComponentOptionsMixin | undefined;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    beforeDestroy?(): void;
+    beforeUnmount?(): void;
+    destroyed?(): void;
+    unmounted?(): void;
+    renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+    renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+    errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | undefined;
+    delimiters?: [string, string] | undefined;
+    __differentiator?: undefined;
+    __isBuiltIn?: boolean | undefined;
+    __file?: string | undefined;
+    __name?: string | undefined;
+    beforeRouteEnter?: import("vue-router").NavigationGuardWithThis<undefined> | undefined;
+    beforeRouteUpdate?: import("vue-router").NavigationGuard | undefined;
+    beforeRouteLeave?: import("vue-router").NavigationGuard | undefined;
+    key?: string | number | symbol | undefined;
+    ref?: import("vue").VNodeRef | undefined;
+    ref_for?: boolean | undefined;
+    ref_key?: string | undefined;
+    onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    class?: unknown;
+    style?: unknown;
+}, COLLECTION_INJECTION_KEY: import("vue").InjectionKey<import("vft/es/components/collection").VftCollectionInjectionContext>, COLLECTION_ITEM_INJECTION_KEY: import("vue").InjectionKey<import("vft/es/components/collection").VftCollectionItemInjectionContext>;
+export { VftCollection, VftCollectionItem, COLLECTION_INJECTION_KEY as ROVING_FOCUS_COLLECTION_INJECTION_KEY, COLLECTION_ITEM_INJECTION_KEY as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY };

package/es/components/roving-focus-group/types.js

@@ -0,0 +1,13 @@
+import { createCollectionWithScope as C } from "../collection/collection.js";
+const {
+  VftCollection: O,
+  VftCollectionItem: o,
+  COLLECTION_INJECTION_KEY: E,
+  COLLECTION_ITEM_INJECTION_KEY: N
+} = C("RovingFocusGroup");
+export {
+  E as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
+  N as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
+  O as VftCollection,
+  o as VftCollectionItem
+};

package/es/components/roving-focus-group/utils.d.ts

@@ -0,0 +1,8 @@
+import type { HTMLAttributes } from 'vue';
+type Orientation = HTMLAttributes['aria-orientation'];
+type Direction = 'ltr' | 'rtl';
+type FocusIntent = 'first' | 'last' | 'prev' | 'next';
+export declare const getFocusIntent: (event: KeyboardEvent, orientation?: Orientation, dir?: Direction) => FocusIntent | undefined;
+export declare const reorderArray: <T>(array: T[], atIdx: number) => T[];
+export declare const focusFirst: (elements: HTMLElement[]) => void;
+export {};

package/es/components/roving-focus-group/utils.js

@@ -0,0 +1,36 @@
+import { EVENT_CODE as r } from "../../constants/aria.js";
+const c = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+}, i = (t, e) => {
+  if (e !== "rtl")
+    return t;
+  switch (t) {
+    case r.right:
+      return r.left;
+    case r.left:
+      return r.right;
+    default:
+      return t;
+  }
+}, u = (t, e, n) => {
+  const o = i(t.key, n);
+  if (!(e === "vertical" && [r.left, r.right].includes(o)) && !(e === "horizontal" && [r.up, r.down].includes(o)))
+    return c[o];
+}, f = (t, e) => t.map((n, o) => t[(o + e) % t.length]), l = (t) => {
+  const { activeElement: e } = document;
+  for (const n of t)
+    if (n === e || (n.focus(), e !== document.activeElement))
+      return;
+};
+export {
+  l as focusFirst,
+  u as getFocusIntent,
+  f as reorderArray
+};

package/es/components/scrollbar/bar.vue.d.ts

@@ -0,0 +1,54 @@
+import type { PropType as __PropType } from 'vue';
+export interface barProps {
+    always?: boolean;
+    width?: string;
+    height?: string;
+    ratioX?: number;
+    ratioY?: number;
+}
+declare const _sfc_main: import("vue").DefineComponent<{
+    always: {
+        type: __PropType<boolean | undefined>;
+        required: false;
+    };
+    width: {
+        type: __PropType<string | undefined>;
+        required: false;
+    };
+    height: {
+        type: __PropType<string | undefined>;
+        required: false;
+    };
+    ratioX: {
+        type: __PropType<number | undefined>;
+        required: false;
+    };
+    ratioY: {
+        type: __PropType<number | undefined>;
+        required: false;
+    };
+}, {
+    handleScroll: (wrap: HTMLDivElement) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    always: {
+        type: __PropType<boolean | undefined>;
+        required: false;
+    };
+    width: {
+        type: __PropType<string | undefined>;
+        required: false;
+    };
+    height: {
+        type: __PropType<string | undefined>;
+        required: false;
+    };
+    ratioX: {
+        type: __PropType<number | undefined>;
+        required: false;
+    };
+    ratioY: {
+        type: __PropType<number | undefined>;
+        required: false;
+    };
+}>>, {}>;
+export default _sfc_main;

package/es/components/scrollbar/bar.vue.js

@@ -0,0 +1,4 @@
+import f from "./bar.vue2.js";
+export {
+  f as default
+};

package/es/components/scrollbar/bar.vue2.js

@@ -0,0 +1,41 @@
+import { defineComponent as m, ref as i, openBlock as u, createElementBlock as h, Fragment as d, createVNode as n } from "vue";
+import { GAP as r } from "./util.js";
+import f from "./thumb.vue2.js";
+const z = /* @__PURE__ */ m({
+  __name: "bar",
+  props: {
+    always: { type: Boolean, default: !0 },
+    width: null,
+    height: null,
+    ratioX: { default: 1 },
+    ratioY: { default: 1 }
+  },
+  setup(e, { expose: s }) {
+    const a = i(0), l = i(0);
+    return s({
+      handleScroll: (t) => {
+        if (t) {
+          const o = t.offsetHeight - r, c = t.offsetWidth - r;
+          l.value = t.scrollTop * 100 / o * e.ratioY, a.value = t.scrollLeft * 100 / c * e.ratioX;
+        }
+      }
+    }), (t, o) => (u(), h(d, null, [
+      n(f, {
+        move: a.value,
+        ratio: e.ratioX,
+        size: e.width,
+        always: e.always
+      }, null, 8, ["move", "ratio", "size", "always"]),
+      n(f, {
+        move: l.value,
+        ratio: e.ratioY,
+        size: e.height,
+        vertical: "",
+        always: e.always
+      }, null, 8, ["move", "ratio", "size", "always"])
+    ], 64));
+  }
+});
+export {
+  z as default
+};

package/es/components/scrollbar/constants.d.ts

@@ -0,0 +1,6 @@
+import type { InjectionKey } from 'vue';
+export interface ScrollbarContext {
+    scrollbarElement: HTMLDivElement;
+    wrapElement: HTMLDivElement;
+}
+export declare const scrollbarContextKey: InjectionKey<ScrollbarContext>;

package/es/components/scrollbar/constants.js

@@ -0,0 +1,6 @@
+const o = Symbol(
+  "scrollbarContextKey"
+);
+export {
+  o as scrollbarContextKey
+};