@aplus-frontend/ui 0.4.8 → 0.4.10

package/es/src/scroll-view/hooks/use-scroll-back.d.ts

@@ -0,0 +1,26 @@
+import { ScrollBarDirection } from '../../scroll-bar';
+import { Ref } from 'vue';
+type ScrollBackOptions = {
+    scrollOffset: {
+        x: number;
+        y: number;
+    };
+    maxScrollDistance: {
+        x: number;
+        y: number;
+    };
+    timer?: number;
+    onScroll?: (direction: ScrollBarDirection) => void;
+    onScrollEnd?: (direction: ScrollBarDirection) => void;
+};
+/**
+ * 在特定的时间内滚动到0
+ * @param options
+ * @returns
+ */
+declare const useScrollBack: ({ scrollOffset, maxScrollDistance, timer, onScroll, onScrollEnd }: ScrollBackOptions) => {
+    start: (direction: ScrollBarDirection) => void;
+    stop: () => void;
+    isActive: Readonly< Ref<boolean, boolean>>;
+};
+export { useScrollBack };

package/es/src/scroll-view/hooks/use-scroll-back.mjs

@@ -0,0 +1,37 @@
+import "../../scroll-bar/index.mjs";
+import { useRafFn as x } from "@vueuse/core";
+import { ensureRangeValue as u } from "../../scroll-bar/utils/index.mjs";
+const m = {
+  horizontal: "x",
+  vertical: "y"
+}, p = () => {
+}, M = (e) => 1 - Math.pow(1 - e, 3), y = ({
+  scrollOffset: e,
+  maxScrollDistance: d,
+  timer: l = 500,
+  onScroll: n = p,
+  onScrollEnd: f = p
+}) => {
+  let a, t, i;
+  const { pause: r, resume: g, isActive: h } = x(
+    () => {
+      const o = Date.now(), s = m[t], T = o - a, c = u(T / l, 0, 1), v = M(c);
+      c === 1 ? (e[s] = 0, r(), n(t), f(t)) : (e[s] = u(
+        i * (1 - v),
+        0,
+        d[s]
+      ), n(t));
+    },
+    { immediate: !1 }
+  );
+  function w(o) {
+    t = o, a = Date.now(), i = e[m[o]], g();
+  }
+  function D() {
+    r();
+  }
+  return { start: w, stop: D, isActive: h };
+};
+export {
+  y as useScrollBack
+};

package/es/src/scroll-view/hooks/use-scroll-smooth.d.ts

@@ -0,0 +1,26 @@
+import { ScrollOffsetType } from '../interface';
+import { Ref } from 'vue';
+type ScrollBackOptions = {
+    scrollOffset: {
+        x: number;
+        y: number;
+    };
+    maxScrollDistance: {
+        x: number;
+        y: number;
+    };
+    timer?: number;
+    onScroll?: (x: boolean, y: boolean) => void;
+    onScrollEnd?: (x: boolean, y: boolean) => void;
+};
+/**
+ * 在特定的时间内滚动到0
+ * @param options
+ * @returns
+ */
+declare const useScrollSmooth: ({ scrollOffset, maxScrollDistance, timer, onScroll, onScrollEnd }: ScrollBackOptions) => {
+    start: (target: Partial<ScrollOffsetType>) => void;
+    stop: () => void;
+    isActive: Readonly< Ref<boolean, boolean>>;
+};
+export { useScrollSmooth };

package/es/src/scroll-view/hooks/use-scroll-smooth.mjs

@@ -0,0 +1,50 @@
+import "../../scroll-bar/index.mjs";
+import { useRafFn as R } from "@vueuse/core";
+import { isDef as f } from "../../utils/index.mjs";
+import { ensureRangeValue as s } from "../../scroll-bar/utils/index.mjs";
+const g = () => {
+}, b = (i) => 1 - Math.pow(1 - i, 3), V = ({
+  scrollOffset: i,
+  maxScrollDistance: r,
+  timer: l = 500,
+  onScroll: u = g,
+  onScrollEnd: T = g
+}) => {
+  let m, e, t, o, n;
+  const { pause: a, resume: w, isActive: p } = R(
+    () => {
+      const v = Date.now() - m, c = s(v / l, 0, 1), y = b(c);
+      c === 1 ? (o && (i.x = t.x), n && (i.y = t.y), a(), u(o, n), T(o, n)) : (o && (t.x > e.x ? i.x = s(
+        e.x + (t.x - e.x) * y,
+        e.x,
+        r.x
+      ) : i.x = s(
+        t.x + (e.x - t.x) * (1 - y),
+        0,
+        e.x
+      )), n && (t.y > e.y ? i.y = s(
+        e.y + (t.y - e.y) * y,
+        e.y,
+        r.y
+      ) : i.y = s(
+        t.y + (e.y - t.y) * (1 - y),
+        0,
+        e.y
+      )), u(o, n));
+    },
+    { immediate: !1 }
+  );
+  function d(x) {
+    p.value && a(), m = Date.now(), e = {
+      x: i.x,
+      y: i.y
+    }, t = x, o = f(x.x), n = f(x.y), w();
+  }
+  function h() {
+    a();
+  }
+  return { start: d, stop: h, isActive: p };
+};
+export {
+  V as useScrollSmooth
+};

package/es/src/scroll-view/hooks/use-scroll-wrapper.d.ts

@@ -0,0 +1,19 @@
+import { InternalScrollBarExpose } from '../../scroll-bar';
+import { Ref } from 'vue';
+declare const useScrollWrapper: () => {
+    maxScrollDistance: {
+        x: number;
+        y: number;
+    };
+    scrollOffset: {
+        x: number;
+        y: number;
+    };
+    xBarRef: Ref<InternalScrollBarExpose | undefined, InternalScrollBarExpose | undefined>;
+    yBarRef: Ref<InternalScrollBarExpose | undefined, InternalScrollBarExpose | undefined>;
+    scrollYBar: () => void;
+    scrollXBar: () => void;
+    containerRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    updateMaxScrollDistance: () => void;
+};
+export default useScrollWrapper;

package/es/src/scroll-view/hooks/use-scroll-wrapper.mjs

@@ -0,0 +1,54 @@
+import { getScrollable as c } from "../../scroll-bar/utils/index.mjs";
+import { ref as i, reactive as v, watch as p, unref as b } from "vue";
+const B = () => {
+  const t = i(), n = v({ x: 0, y: 0 }), a = v({ x: 0, y: 0 }), s = i(), u = i();
+  p(
+    () => t.value,
+    () => {
+      f();
+    }
+  );
+  function f() {
+    const e = b(t);
+    if (!e)
+      return;
+    const { visibleSize: l, totalSize: r } = c(
+      e,
+      "horizontal"
+    ), { visibleSize: o, totalSize: x } = c(e, "vertical");
+    n.x = r - l, n.y = x - o;
+  }
+  function S() {
+    var o;
+    if (!t.value)
+      return;
+    const { totalSize: e, visibleSize: l } = c(
+      t.value,
+      "vertical"
+    ), r = a.y / (e - l || 1) * 100;
+    (o = u.value) == null || o.scroll(r);
+  }
+  function z() {
+    var o;
+    if (!t.value)
+      return;
+    const { totalSize: e, visibleSize: l } = c(
+      t.value,
+      "horizontal"
+    ), r = a.x / (e - l || 1) * 100;
+    (o = s.value) == null || o.scroll(r);
+  }
+  return {
+    maxScrollDistance: n,
+    scrollOffset: a,
+    xBarRef: s,
+    yBarRef: u,
+    scrollYBar: S,
+    scrollXBar: z,
+    containerRef: t,
+    updateMaxScrollDistance: f
+  };
+};
+export {
+  B as default
+};

package/es/src/scroll-view/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ScrollView } from './index.vue';
+export { ScrollView };
+export * from './interface';

package/es/src/scroll-view/index.mjs

@@ -0,0 +1,2 @@
+import "./index.vue2.mjs";
+import "./interface.mjs";

package/es/src/scroll-view/index.vue.d.ts

@@ -0,0 +1,214 @@
+import { ScrollOptions, ScrollViewProps } from './interface';
+import { ScrollBarDirection, InternalScrollBarProps } from '../scroll-bar';
+import { CreateComponentPublicInstanceWithMixins, Ref, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DefineComponent, ComputedRef } from 'vue';
+declare function scroll(x?: number, y?: number): void;
+declare function scrollTo({ smooth, left, top }: ScrollOptions): void;
+declare function scrollIntoView(element: HTMLElement, position?: 'start' | 'center' | 'end'): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        contentRef: HTMLDivElement;
+        yBarRef: CreateComponentPublicInstanceWithMixins<Readonly< InternalScrollBarProps> & Readonly<{}>, {
+            currentScroll: Ref<number, number>;
+            container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scroll: (percent: number) => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+            scroll: number;
+            disabled: boolean;
+            direction: ScrollBarDirection;
+            trackSpeed: number;
+            barLength: number;
+            showTrack: boolean;
+        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+            container: HTMLDivElement;
+            track: HTMLDivElement;
+            bar: HTMLDivElement;
+        }, HTMLDivElement, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< InternalScrollBarProps> & Readonly<{}>, {
+            currentScroll: Ref<number, number>;
+            container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scroll: (percent: number) => void;
+        }, {}, {}, {}, {
+            scroll: number;
+            disabled: boolean;
+            direction: ScrollBarDirection;
+            trackSpeed: number;
+            barLength: number;
+            showTrack: boolean;
+        }> | null;
+        xBarRef: CreateComponentPublicInstanceWithMixins<Readonly< InternalScrollBarProps> & Readonly<{}>, {
+            currentScroll: Ref<number, number>;
+            container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scroll: (percent: number) => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+            scroll: number;
+            disabled: boolean;
+            direction: ScrollBarDirection;
+            trackSpeed: number;
+            barLength: number;
+            showTrack: boolean;
+        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+            container: HTMLDivElement;
+            track: HTMLDivElement;
+            bar: HTMLDivElement;
+        }, HTMLDivElement, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< InternalScrollBarProps> & Readonly<{}>, {
+            currentScroll: Ref<number, number>;
+            container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scroll: (percent: number) => void;
+        }, {}, {}, {}, {
+            scroll: number;
+            disabled: boolean;
+            direction: ScrollBarDirection;
+            trackSpeed: number;
+            barLength: number;
+            showTrack: boolean;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ScrollViewProps, {
+    scrollTop: ComputedRef<number>;
+    scrollLeft: ComputedRef<number>;
+    scroll: typeof scroll;
+    scrollTo: typeof scrollTo;
+    scrollIntoView: typeof scrollIntoView;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollViewProps> & Readonly<{}>, {
+    showXBar: boolean;
+    showYBar: boolean;
+    xBarProps: {
+        width?: number | undefined;
+        onScroll?: ((percent: number) => void) | undefined;
+        disabled?: boolean | undefined;
+        trackSpeed?: number | undefined;
+        barColor?: import("csstype").Property.BackgroundColor | undefined;
+        trackColor?: import("csstype").Property.BackgroundColor | undefined;
+        trackWidth?: number | undefined;
+        showTrack?: boolean | undefined;
+        onScrollStart?: ((percent: number) => void) | undefined;
+        onScrollEnd?: ((percent: number) => void) | undefined;
+    };
+    yBarProps: {
+        width?: number | undefined;
+        onScroll?: ((percent: number) => void) | undefined;
+        disabled?: boolean | undefined;
+        trackSpeed?: number | undefined;
+        barColor?: import("csstype").Property.BackgroundColor | undefined;
+        trackColor?: import("csstype").Property.BackgroundColor | undefined;
+        trackWidth?: number | undefined;
+        showTrack?: boolean | undefined;
+        onScrollStart?: ((percent: number) => void) | undefined;
+        onScrollEnd?: ((percent: number) => void) | undefined;
+    };
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    contentRef: HTMLDivElement;
+    yBarRef: CreateComponentPublicInstanceWithMixins<Readonly< InternalScrollBarProps> & Readonly<{}>, {
+        currentScroll: Ref<number, number>;
+        container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scroll: (percent: number) => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        scroll: number;
+        disabled: boolean;
+        direction: ScrollBarDirection;
+        trackSpeed: number;
+        barLength: number;
+        showTrack: boolean;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        container: HTMLDivElement;
+        track: HTMLDivElement;
+        bar: HTMLDivElement;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< InternalScrollBarProps> & Readonly<{}>, {
+        currentScroll: Ref<number, number>;
+        container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scroll: (percent: number) => void;
+    }, {}, {}, {}, {
+        scroll: number;
+        disabled: boolean;
+        direction: ScrollBarDirection;
+        trackSpeed: number;
+        barLength: number;
+        showTrack: boolean;
+    }> | null;
+    xBarRef: CreateComponentPublicInstanceWithMixins<Readonly< InternalScrollBarProps> & Readonly<{}>, {
+        currentScroll: Ref<number, number>;
+        container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scroll: (percent: number) => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        scroll: number;
+        disabled: boolean;
+        direction: ScrollBarDirection;
+        trackSpeed: number;
+        barLength: number;
+        showTrack: boolean;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        container: HTMLDivElement;
+        track: HTMLDivElement;
+        bar: HTMLDivElement;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< InternalScrollBarProps> & Readonly<{}>, {
+        currentScroll: Ref<number, number>;
+        container: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        bar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        track: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scroll: (percent: number) => void;
+    }, {}, {}, {}, {
+        scroll: number;
+        disabled: boolean;
+        direction: ScrollBarDirection;
+        trackSpeed: number;
+        barLength: number;
+        showTrack: boolean;
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/scroll-view/index.vue.mjs

@@ -0,0 +1,253 @@
+import { defineComponent as fe, ref as ue, reactive as he, computed as v, unref as l, watchEffect as _, watch as pe, openBlock as P, createElementBlock as ye, normalizeClass as B, normalizeStyle as M, withModifiers as A, createElementVNode as z, renderSlot as me, createBlock as L, mergeProps as O, createCommentVNode as T } from "vue";
+import "../config-provider/index.mjs";
+import "../scroll-bar/index.mjs";
+import { isDef as f } from "../utils/index.mjs";
+import { ensureRangeValue as n, getScrollable as k } from "../scroll-bar/utils/index.mjs";
+import de from "./hooks/use-scroll-wrapper.mjs";
+import { isString as j } from "lodash-unified";
+import { useElementSize as F, useRafFn as ve } from "@vueuse/core";
+import { wait as R } from "@aplus-frontend/utils";
+import { useScrollBack as xe } from "./hooks/use-scroll-back.mjs";
+import { useScrollSmooth as Be } from "./hooks/use-scroll-smooth.mjs";
+import { getElementScrollOffset as we } from "./utils/index.mjs";
+import { useNamespace as ge } from "../config-provider/hooks/use-namespace.mjs";
+import H from "../scroll-bar/internal.vue.mjs";
+const Ye = /* @__PURE__ */ fe({
+  name: "ScrollView",
+  __name: "index",
+  props: {
+    width: {},
+    heigth: {},
+    showXBar: { type: Boolean, default: !0 },
+    showYBar: { type: Boolean, default: !0 },
+    autoPlay: { type: [Boolean, Object] },
+    xBarProps: { default: () => ({}) },
+    yBarProps: { default: () => ({}) },
+    onWheel: {}
+  },
+  setup(I, { expose: q }) {
+    const o = I, G = {
+      direction: "vertical",
+      rate: 1,
+      repeat: !0
+    }, { b: J, e: w, em: W } = ge("scroll-view"), u = ue(), c = he({ x: 30, y: 30 });
+    let g = !1;
+    const {
+      scrollOffset: r,
+      maxScrollDistance: i,
+      xBarRef: K,
+      yBarRef: Q,
+      containerRef: s,
+      scrollYBar: h,
+      scrollXBar: p,
+      updateMaxScrollDistance: U
+    } = de(), { width: Z, height: ee } = F(u), { width: te, height: re } = F(s), { start: N } = xe({
+      scrollOffset: r,
+      maxScrollDistance: i,
+      onScroll: (t) => {
+        t === "horizontal" ? p() : h();
+      },
+      async onScrollEnd() {
+        await R(200), S();
+      }
+    }), { start: $ } = Be({
+      scrollOffset: r,
+      maxScrollDistance: i,
+      onScroll(t, e) {
+        V.value && (y(), g = !0), t && p(), e && h();
+      },
+      async onScrollEnd() {
+        g && (await R(200), S(), g = !1);
+      }
+    }), { resume: S, pause: y, isActive: V } = ve(
+      () => {
+        if (!o.autoPlay) {
+          y();
+          return;
+        }
+        const t = o.autoPlay === !0 ? {} : o.autoPlay, e = {
+          ...G,
+          ...t
+        };
+        if (e.direction === "horizontal") {
+          if (r.x === i.x) {
+            y(), e.repeat && N("horizontal");
+            return;
+          }
+          r.x = n(
+            r.x + e.rate,
+            0,
+            i.x
+          ), p();
+        } else {
+          if (r.y === i.y) {
+            y(), e.repeat && N("vertical");
+            return;
+          }
+          r.y = n(
+            r.y + e.rate,
+            0,
+            i.y
+          ), h();
+        }
+      },
+      { immediate: !0 }
+    ), m = v(() => o.showXBar && c.x !== 100), x = v(() => o.showYBar && c.y !== 100), oe = v(() => ({
+      width: f(o.width) ? j(o.width) ? o.width : Number.isNaN(o.width) ? void 0 : `${o.width}px` : void 0,
+      height: f(o.heigth) ? j(o.heigth) ? o.heigth : Number.isNaN(o.heigth) ? void 0 : `${o.heigth}px` : void 0,
+      padding: `${o.xBarProps.trackWidth || 10}px ${o.yBarProps.trackWidth || 10}px`
+    }));
+    async function b() {
+      V.value && (y(), await R(500), S());
+    }
+    async function ae(t) {
+      var e;
+      if (l(x))
+        t.preventDefault(), t.stopPropagation();
+      else
+        return;
+      r.y = n(
+        r.y + t.deltaY,
+        0,
+        i.y
+      ), h(), (e = o.onWheel) == null || e.call(o, "vertical", r.y), b();
+    }
+    function le(t) {
+      var e;
+      if (l(m))
+        t.preventDefault(), t.stopPropagation();
+      else
+        return;
+      r.x = n(
+        r.x + t.deltaX,
+        0,
+        i.x
+      ), p(), (e = o.onWheel) == null || e.call(o, "horizontal", r.x), b();
+    }
+    function E() {
+      if (o.showYBar) {
+        const { visibleSize: t, totalSize: e } = k(
+          s.value,
+          "vertical"
+        );
+        c.y = n(
+          Math.min(t / (e || 1) * 100)
+        );
+      }
+      if (o.showXBar) {
+        const { visibleSize: t, totalSize: e } = k(
+          s.value,
+          "horizontal"
+        );
+        c.x = n(
+          Math.min(t / (e || 1) * 100)
+        );
+      }
+    }
+    function X(t, e) {
+      const a = l(s), d = l(u);
+      if (!a || !d) return;
+      const { visibleSize: C, totalSize: D } = k(a, e);
+      if (D <= C) return;
+      const Y = (D - C) * t / 100, ce = e === "vertical";
+      if (b(), ce) {
+        r.y = Y;
+        return;
+      }
+      r.x = Y;
+    }
+    _(
+      () => {
+        l(s.value) && E();
+      },
+      { flush: "post" }
+    ), pe(
+      () => [
+        Z.value,
+        ee.value,
+        te.value,
+        re.value
+      ],
+      () => {
+        E(), U();
+      }
+    ), _(() => {
+      u.value && (u.value.style.transform = `translate3d(-${r.x}px, -${r.y}px, 0px)`);
+    });
+    function ie(t, e) {
+      f(t) && m.value && (r.x = n(t, 0, i.x), p()), f(e) && x.value && (r.y = n(e, 0, i.y), h());
+    }
+    function ne({ smooth: t, left: e, top: a }) {
+      t ? $({ x: e, y: a }) : (f(e) && (r.x = e), f(a) && (r.y = a));
+    }
+    function se(t, e = "start") {
+      const a = we(
+        s.value,
+        t,
+        e
+      ), d = {};
+      m.value && (d.x = n(
+        r.x + a.x,
+        0,
+        i.x
+      )), x.value && (d.y = n(
+        r.y + a.y,
+        0,
+        i.y
+      )), $(d);
+    }
+    return q({
+      scrollTop: v(() => r.y),
+      scrollLeft: v(() => r.x),
+      scroll: ie,
+      scrollTo: ne,
+      scrollIntoView: se
+    }), (t, e) => (P(), ye("div", {
+      ref_key: "containerRef",
+      ref: s,
+      class: B(l(J)()),
+      style: M(oe.value),
+      onWheel: [
+        A(ae, ["exact"]),
+        A(le, ["shift"])
+      ]
+    }, [
+      z("div", {
+        ref_key: "contentRef",
+        ref: u,
+        class: B(l(w)("content"))
+      }, [
+        me(t.$slots, "default")
+      ], 2),
+      z("div", {
+        class: B([l(w)("bar-wrapper"), l(W)("bar-wrapper", "vertical")]),
+        style: M(`height: calc(100% - ${m.value ? t.xBarProps.trackWidth || 10 : 0}px)`)
+      }, [
+        x.value ? (P(), L(l(H), O({
+          key: 0,
+          ref_key: "yBarRef",
+          ref: Q
+        }, t.yBarProps, {
+          "bar-length": c.y,
+          onScroll: e[0] || (e[0] = (a) => X(a, "vertical"))
+        }), null, 16, ["bar-length"])) : T("", !0)
+      ], 6),
+      z("div", {
+        class: B([l(w)("bar-wrapper"), l(W)("bar-wrapper", "horizontal")])
+      }, [
+        m.value ? (P(), L(l(H), O({
+          key: 0,
+          ref_key: "xBarRef",
+          ref: K
+        }, t.xBarProps, {
+          direction: "horizontal",
+          "bar-length": c.x,
+          onScroll: e[1] || (e[1] = (a) => X(a, "horizontal"))
+        }), null, 16, ["bar-length"])) : T("", !0)
+      ], 2)
+    ], 38));
+  }
+});
+export {
+  Ye as default
+};

package/es/src/scroll-view/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};