winbox-ui-next/lib/split/split.js

We Design Vue 2.0: A Vue.js 3 UI Library

"use strict";
var vue = require("vue");
var resizeTrigger = require("../_components/resize-trigger.js");
var useMergeState = require("../_hooks/use-merge-state.js");
var globalConfig = require("../_utils/global-config.js");
var dom = require("../_utils/dom.js");
var pluginVue_exportHelper = require("../_virtual/plugin-vue_export-helper");
function px2percent(numerator, denominator) {
  return parseFloat(numerator) / parseFloat(denominator);
}
const _sfc_main = vue.defineComponent({
  name: "Split",
  components: {
    ResizeTrigger: resizeTrigger
  },
  props: {
    component: {
      type: String,
      default: "div"
    },
    direction: {
      type: String,
      default: "horizontal"
    },
    size: {
      type: [Number, String],
      default: void 0
    },
    defaultSize: {
      type: [Number, String],
      default: 0.5
    },
    min: {
      type: [Number, String]
    },
    max: {
      type: [Number, String]
    },
    disabled: {
      type: Boolean
    }
  },
  emits: [
    "moveStart",
    "moving",
    "moveEnd",
    "update:size"
  ],
  setup(props, { emit }) {
    const { direction, size: propSize, defaultSize, min, max } = vue.toRefs(props);
    const triggerSize = vue.ref(0);
    const record = {
      startPageX: 0,
      startPageY: 0,
      startWidth: 0,
      startHeight: 0,
      startSize: 0,
      moving: false
    };
    const wrapperRef = vue.ref();
    const prefixCls = globalConfig.getPrefixCls("split");
    const [size, setSize] = useMergeState(defaultSize.value, vue.reactive({
      value: propSize
    }));
    const numberSize = vue.computed(() => {
      return parseFloat(size.value);
    });
    const isHorizontal = vue.computed(() => direction.value === "horizontal");
    const classNames = vue.computed(() => [
      prefixCls,
      {
        [`${prefixCls}-horizontal`]: isHorizontal.value,
        [`${prefixCls}-vertical`]: !isHorizontal.value
      }
    ]);
    const isPxSize = vue.computed(() => propSize && typeof propSize.value === "string");
    const firstPaneStyles = vue.computed(() => {
      let firstPaneSize = "0";
      if (numberSize.value) {
        const unit = isPxSize.value ? "px" : "%";
        const baseVal = isPxSize.value ? numberSize.value : numberSize.value * 100;
        firstPaneSize = `calc(${baseVal}${unit} - ${triggerSize.value / 2}px)`;
      }
      return {
        flexBasis: firstPaneSize
      };
    });
    function getNewSize({
      startWrapperSize,
      startSize,
      startPosition,
      endPosition
    }) {
      const minOffset = min.value ? parseFloat(min.value) : 0;
      const maxOffset = max.value ? parseFloat(max.value) : isPxSize.value ? startWrapperSize : 1;
      let newSize = isPxSize.value ? startSize + (endPosition - startPosition) : px2percent(startWrapperSize * startSize + endPosition - startPosition, startWrapperSize);
      newSize = Math.max(newSize, minOffset);
      newSize = Math.min(newSize, maxOffset);
      return newSize;
    }
    function onMoving(e) {
      if (!record.moving)
        return;
      emit("moving", e);
      let newSize = isHorizontal.value ? getNewSize({
        startWrapperSize: record.startWidth,
        startSize: record.startSize,
        startPosition: record.startPageX,
        endPosition: e.pageX
      }) : getNewSize({
        startWrapperSize: record.startHeight,
        startSize: record.startSize,
        startPosition: record.startPageY,
        endPosition: e.pageY
      });
      if (isPxSize.value)
        newSize = `${newSize}px`;
      setSize(newSize);
      emit("update:size", newSize);
    }
    function onMovingEnd(e) {
      record.moving = false;
      dom.off(window, "mousemove", onMoving);
      dom.off(window, "mouseup", onMovingEnd);
      dom.off(window, "contextmenu", onMovingEnd);
      document.body.style.cursor = "default";
      emit("moveEnd", e);
    }
    function onMoveStart(e) {
      var _a, _b;
      emit("moveStart", e);
      record.moving = true;
      record.startPageX = e.pageX;
      record.startPageY = e.pageY;
      record.startWidth = ((_a = wrapperRef.value) == null ? void 0 : _a.clientWidth) || 0;
      record.startHeight = ((_b = wrapperRef.value) == null ? void 0 : _b.clientHeight) || 0;
      record.startSize = numberSize.value;
      dom.on(window, "mousemove", onMoving);
      dom.on(window, "mouseup", onMovingEnd);
      dom.on(window, "contextmenu", onMovingEnd);
      document.body.style.cursor = isHorizontal.value ? "col-resize" : "row-resize";
    }
    function onTiggerResize(entry) {
      const { width, height } = entry.contentRect;
      triggerSize.value = isHorizontal.value ? width : height;
    }
    return {
      size1: size,
      numberSize,
      prefixCls,
      classNames,
      isHorizontal,
      wrapperRef,
      onMoveStart,
      onTiggerResize,
      firstPaneStyles
    };
  }
});
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  const _component_ResizeTrigger = vue.resolveComponent("ResizeTrigger");
  return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.component), {
    ref: "wrapperRef",
    class: vue.normalizeClass(_ctx.classNames)
  }, {
    default: vue.withCtx(() => [
      vue.createElementVNode("div", {
        class: vue.normalizeClass([`${_ctx.prefixCls}-pane`, `${_ctx.prefixCls}-pane-first`]),
        style: vue.normalizeStyle(_ctx.firstPaneStyles)
      }, [
        vue.renderSlot(_ctx.$slots, "first")
      ], 6),
      !_ctx.disabled ? (vue.openBlock(), vue.createBlock(_component_ResizeTrigger, {
        key: 0,
        "prefix-cls": `${_ctx.prefixCls}-trigger`,
        direction: _ctx.isHorizontal ? "vertical" : "horizontal",
        onMousedown: _ctx.onMoveStart,
        onResize: _ctx.onTiggerResize
      }, {
        default: vue.withCtx(() => [
          vue.renderSlot(_ctx.$slots, "resize-trigger")
        ]),
        icon: vue.withCtx(() => [
          vue.renderSlot(_ctx.$slots, "resize-trigger-icon")
        ]),
        _: 3
      }, 8, ["prefix-cls", "direction", "onMousedown", "onResize"])) : vue.createCommentVNode("v-if", true),
      vue.createElementVNode("div", {
        class: vue.normalizeClass([`${_ctx.prefixCls}-pane`, `${_ctx.prefixCls}-pane-second`])
      }, [
        vue.renderSlot(_ctx.$slots, "second")
      ], 2)
    ]),
    _: 3
  }, 8, ["class"]);
}
var _Split = /* @__PURE__ */ pluginVue_exportHelper(_sfc_main, [["render", _sfc_render]]);
module.exports = _Split;