vue-gantt-3/lib/components/ganttView/ganttBody/ganttTimeLineView/useTimeLineMove.js

A gantt component for Vue 3

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const vue = require("vue");
const common = require("../../../../utils/common.js");
const useTimeLineMove = ({
  edgeSpacing,
  ganttViewWidth,
  rowNodeMap,
  movingTimeLineRowId,
  movingTimeLine,
  timeLineMoving,
  visibleTimeLineMap,
  disableMove,
  closeEdgeScroll,
  sortTimeLineNodes,
  mergeOverlapTimeLine,
  freshVisibleTimeLines,
  getDiffSecondByDistance,
  getDistanceByDiffDate,
  emitUpdateMinDate,
  emitUpdateMaxDate,
  updateParentTimeLine
}) => {
  const wrapRef = vue.inject("wrapRef");
  const freshRowNodeDateByTimeLine = vue.inject("freshRowNodeDateByTimeLine");
  const getGanttMinAndMaxDate = vue.inject("getGanttMinAndMaxDate");
  const timeLineMoveChange = vue.inject("timeLineMoveChange");
  const clearDateCache = vue.inject("clearDateCache");
  const startTimeLineMove = (e, timeLine, rowId) => {
    if (disableMove.value || timeLine.disableMove) return;
    timeLine.moving = true;
    movingTimeLine.value = timeLine;
    movingTimeLineRowId.value = rowId;
    let lastX = e.clientX;
    let startScrollX = 0;
    const wrapWidth = wrapRef.value.offsetWidth;
    const oldStartDate = timeLine.startDate;
    const currentRowNode = rowNodeMap.value.get(rowId);
    const onMouseMove = (event) => {
      let currentX = event.clientX;
      const layerX = event.layerX;
      const diffX = currentX - lastX;
      timeLineMove(timeLine, rowId, diffX);
      const scrollDistance = 10;
      const scrollLeft = wrapRef.value.scrollLeft;
      if (layerX <= scrollLeft + edgeSpacing || timeLine.translateX <= edgeSpacing) {
        if (diffX < 0) {
          if (!timeLineMoving.value) {
            timeLineMoving.value = true;
            startScrollX = lastX;
            closeEdgeScroll(-10, (moveSpacing) => {
              timeLineMove(timeLine, rowId, moveSpacing);
            });
          }
        } else if (currentX >= startScrollX) {
          timeLineMoving.value = false;
        }
      } else if (layerX >= wrapWidth + scrollLeft - edgeSpacing || timeLine.translateX + timeLine.width >= ganttViewWidth.value - edgeSpacing) {
        if (diffX > 0) {
          if (!timeLineMoving.value) {
            timeLineMoving.value = true;
            startScrollX = lastX;
            closeEdgeScroll(scrollDistance, (moveSpacing) => {
              timeLineMove(timeLine, rowId, moveSpacing);
            });
          }
        } else if (currentX <= startScrollX) {
          timeLineMoving.value = false;
        }
      } else {
        timeLineMoving.value = false;
      }
      lastX = currentX;
    };
    const onMouseUp = () => {
      timeLine.moving = false;
      timeLineMoving.value = false;
      movingTimeLine.value = null;
      movingTimeLineRowId.value = "";
      clearDateCache();
      if (!oldStartDate.isSame(timeLine.startDate)) {
        freshRowNodeDateByTimeLine(rowId);
        if (currentRowNode == null ? void 0 : currentRowNode.timeLineNodes) {
          sortTimeLineNodes(currentRowNode.timeLineNodes);
          currentRowNode.timeLineNodes = mergeOverlapTimeLine(currentRowNode.timeLineNodes);
          const diffSecond = timeLine.startDate.diff(oldStartDate, "second", true);
          onTimeLineMoveChange(rowId, timeLine, diffSecond);
          visibleTimeLineMap.value.delete(rowId);
          freshVisibleTimeLines(false);
        }
      }
      vue.triggerRef(visibleTimeLineMap);
      window.removeEventListener("mousemove", onMouseMove);
      window.removeEventListener("mouseup", onMouseUp);
    };
    vue.triggerRef(visibleTimeLineMap);
    window.addEventListener("mousemove", onMouseMove);
    window.addEventListener("mouseup", onMouseUp);
  };
  const timeLineMove = (timeLine, rowId, distance) => {
    const nextStartDate = getDiffSecondByDistance(distance, timeLine.startDate);
    timeLine.startDate = nextStartDate;
    timeLine.timeLineNode.startDate = nextStartDate;
    const nextEndDate = getDiffSecondByDistance(distance, timeLine.endDate);
    timeLine.endDate = nextEndDate;
    timeLine.timeLineNode.endDate = nextEndDate;
    if (common.getRound(timeLine.translateX) === edgeSpacing && distance > 0) {
      const { minStartDate } = getGanttMinAndMaxDate([rowId], true, false);
      if (!minStartDate || nextStartDate.isBefore(minStartDate)) {
        emitUpdateMinDate(nextStartDate);
        timeLine.translateX = edgeSpacing;
        updateParentTimeLine(rowId);
        return;
      } else if (nextStartDate.isAfter(minStartDate) || nextStartDate.isSame(minStartDate)) {
        timeLine.translateX += getDistanceByDiffDate(minStartDate, nextStartDate);
        emitUpdateMinDate(minStartDate);
        updateParentTimeLine(rowId);
        return;
      }
    } else if (common.getRound(timeLine.translateX + timeLine.width + edgeSpacing) === common.getRound(ganttViewWidth.value) && distance < 0) {
      const { maxEndDate } = getGanttMinAndMaxDate([rowId], false, true);
      if (!maxEndDate || nextEndDate.isAfter(maxEndDate)) {
        timeLine.translateX += distance;
        emitUpdateMaxDate(nextEndDate);
        updateParentTimeLine(rowId);
        return;
      } else if (nextEndDate.isBefore(maxEndDate) || nextEndDate.isSame(maxEndDate)) {
        emitUpdateMaxDate(maxEndDate);
      }
    }
    timeLine.translateX += distance;
    if (timeLine.translateX < edgeSpacing) {
      emitUpdateMinDate(timeLine.startDate);
      timeLine.translateX = edgeSpacing;
    } else if (timeLine.translateX + timeLine.width + edgeSpacing > ganttViewWidth.value) {
      emitUpdateMaxDate(timeLine.endDate);
    }
    updateParentTimeLine(rowId);
    vue.triggerRef(visibleTimeLineMap);
  };
  const onTimeLineMoveChange = (rowId, timeLine, diffSecond) => {
    const timeLineNode = timeLine.timeLineNode;
    const mergedTimeLineNodes = timeLineNode.mergedTimeLineNodes || [];
    const allTimeLineNodes = [timeLineNode, ...mergedTimeLineNodes.filter((node) => node.id !== timeLineNode.id)];
    const timeLineIds = [];
    const result = [];
    for (let currentTimeLineNode of allTimeLineNodes) {
      timeLineIds.push(currentTimeLineNode.id);
      if (currentTimeLineNode.id !== timeLineNode.id) {
        currentTimeLineNode.startDate = currentTimeLineNode.startDate.add(diffSecond, "second");
        currentTimeLineNode.endDate = currentTimeLineNode.endDate.add(diffSecond, "second");
      }
      const movedResult = {
        timeLineId: currentTimeLineNode.id,
        startDate: currentTimeLineNode.startDate,
        endDate: currentTimeLineNode.endDate
      };
      if (currentTimeLineNode.timePointNodes) {
        const timePointsData = [];
        currentTimeLineNode.timePointNodes.forEach((timePointNode) => {
          timePointNode.date = timePointNode.date.add(diffSecond, "second");
          timePointsData.push({ id: timePointNode.id, date: timePointNode.date });
        });
        movedResult.timePoints = timePointsData;
      }
      result.push(movedResult);
    }
    timeLineMoveChange(rowId, timeLineIds, result);
  };
  return {
    startTimeLineMove
  };
};
exports.useTimeLineMove = useTimeLineMove;
//# sourceMappingURL=useTimeLineMove.js.map