hongluan-ui/lib/components/scrollbar/src/scrollbar.js

Hongluan Component Library for Vue 3

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var core = require('@vueuse/core');
require('../../../utils/index.js');
require('../../../hooks/index.js');
require('../../../tokens/index.js');
var bar = require('./bar2.js');
var scrollbar = require('./scrollbar2.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var style = require('../../../utils/dom/style.js');
var shared = require('@vue/shared');
var types = require('../../../utils/types.js');
var error = require('../../../utils/error.js');
var scrollbar$1 = require('../../../tokens/scrollbar.js');
var index = require('../../../hooks/use-namespace/index.js');

const _sfc_main = vue.defineComponent({
  name: "Scrollbar",
  components: {
    Bar: bar["default"]
  },
  props: scrollbar.scrollbarProps,
  emits: ["scroll", "at-end"],
  setup(props, { emit }) {
    let stopResizeObserver = void 0;
    let stopResizeListener = void 0;
    let wrapScrollTop = 0;
    let wrapScrollLeft = 0;
    let oldScrollTop = Number.MAX_SAFE_INTEGER;
    const scrollbarRef = vue.ref();
    const wrapRef = vue.ref();
    const resizeRef = vue.ref();
    const barRef = vue.ref();
    const SCOPE = "Scrollbar";
    const style$1 = vue.computed(() => {
      const style2 = {};
      if (props.height)
        style2.height = style.addUnit(props.height);
      if (props.maxHeight)
        style2.maxHeight = style.addUnit(props.maxHeight);
      return [props.wrapStyle, style2];
    });
    const handleScroll = () => {
      var _a;
      if (wrapRef.value) {
        (_a = barRef.value) == null ? void 0 : _a.handleScroll(wrapRef.value);
        wrapScrollTop = wrapRef.value.scrollTop;
        wrapScrollLeft = wrapRef.value.scrollLeft;
        emit("scroll", {
          scrollTop: wrapRef.value.scrollTop,
          scrollLeft: wrapRef.value.scrollLeft
        });
        if (wrapRef.value.scrollTop > oldScrollTop && wrapRef.value.scrollTop + wrapRef.value.offsetHeight + props.distance >= wrapRef.value.scrollHeight) {
          emit("at-end", { vertical: true });
        }
        oldScrollTop = wrapRef.value.scrollTop;
      }
    };
    function scrollTo(arg1, arg2) {
      if (shared.isObject(arg1)) {
        wrapRef.value.scrollTo(arg1);
      } else if (types.isNumber(arg1) && types.isNumber(arg2)) {
        wrapRef.value.scrollTo(arg1, arg2);
      }
    }
    const setScrollTop = (value) => {
      if (!types.isNumber(value)) {
        error.debugWarn(SCOPE, "value must be a number");
        return;
      }
      wrapRef.value.scrollTop = value;
    };
    const setScrollLeft = (value) => {
      if (!types.isNumber(value)) {
        error.debugWarn(SCOPE, "value must be a number");
        return;
      }
      wrapRef.value.scrollLeft = value;
    };
    const update = () => {
      var _a;
      (_a = barRef.value) == null ? void 0 : _a.update();
    };
    vue.watch(() => props.noresize, (noresize) => {
      if (noresize) {
        stopResizeObserver == null ? void 0 : stopResizeObserver();
        stopResizeListener == null ? void 0 : stopResizeListener();
      } else {
        ({ stop: stopResizeObserver } = core.useResizeObserver(resizeRef, update));
        stopResizeListener = core.useEventListener("resize", update);
      }
    }, { immediate: true });
    vue.provide(scrollbar$1.scrollbarContextKey, vue.reactive({
      scrollbarElement: scrollbarRef,
      wrapElement: wrapRef
    }));
    vue.onActivated(() => {
      wrapRef.value.scrollTop = wrapScrollTop;
      wrapRef.value.scrollLeft = wrapScrollLeft;
    });
    vue.onMounted(() => {
      if (!props.native) {
        vue.nextTick(() => {
          update();
        });
      }
    });
    vue.onUpdated(() => update());
    const { namespace } = index.useNamespace("scrollbar");
    return {
      namespace,
      scrollbarRef,
      wrapRef,
      resizeRef,
      barRef,
      style: style$1,
      update,
      handleScroll,
      setScrollTop,
      setScrollLeft,
      scrollTo
    };
  }
});
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  const _component_bar = vue.resolveComponent("bar");
  return vue.openBlock(), vue.createElementBlock("div", {
    ref: "scrollbarRef",
    class: vue.normalizeClass(_ctx.namespace)
  }, [
    vue.createElementVNode("div", {
      ref: "wrapRef",
      class: vue.normalizeClass([
        _ctx.wrapClass,
        "scrollbar-wrap",
        _ctx.native ? "" : "scrollbar-wrap-hidden"
      ]),
      style: vue.normalizeStyle(_ctx.style),
      onScroll: _ctx.handleScroll
    }, [
      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
        id: _ctx.id,
        ref: "resizeRef",
        class: vue.normalizeClass(["scrollbar-view", _ctx.viewClass]),
        style: vue.normalizeStyle(_ctx.viewStyle),
        role: _ctx.role,
        "aria-label": _ctx.ariaLabel,
        "aria-orientation": _ctx.ariaOrientation
      }, {
        default: vue.withCtx(() => [
          vue.renderSlot(_ctx.$slots, "default")
        ]),
        _: 3
      }, 8, ["id", "class", "style", "role", "aria-label", "aria-orientation"]))
    ], 46, ["onScroll"]),
    !_ctx.native ? (vue.openBlock(), vue.createBlock(_component_bar, {
      key: 0,
      ref: "barRef",
      always: _ctx.always,
      "min-size": _ctx.minSize
    }, null, 8, ["always", "min-size"])) : vue.createCommentVNode("v-if", true)
  ], 2);
}
var Scrollbar = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["render", _sfc_render]]);

exports["default"] = Scrollbar;
//# sourceMappingURL=scrollbar.js.map