cnhis-design-vue 3.1.40-release.5 → 3.1.40-release.6

package/es/components/fabric-chart/src/hooks/useBirthProcess.js

@@ -1,642 +0,0 @@
-import { useBirthProcessCumputedPoint } from './useCumputedPoint.js';
-import useGrid from './useGrid.js';
-import { drawLine, drawArrow, drawText, defaultTextStyle, drawPoint, defaultRectStyle } from './useDraw.js';
-import { fabric } from '../utils/index.js';
-import { getIndex, isEffectiveNode } from '../utils/utils.js';
-import { cloneDeep } from 'lodash-es';
-import { format } from 'date-fns';
-
-function useBirthProcess(canvas, propItems, emits, pointTipProps, pointMenuProps, commonFunc) {
-  const { cumputedX, cumputedY, getXValue, getYValue } = useBirthProcessCumputedPoint(propItems);
-  const { getEqualXTypes, repeatTip } = commonFunc;
-  const {
-    xAxis,
-    grid,
-    originX,
-    originY,
-    xCellWidth,
-    endY,
-    startTime,
-    leftAddAreaWidth,
-    leftScales,
-    rightScales,
-    yCellHeight,
-    endX,
-    scaleValues,
-    canvasWidth,
-    borderStyle,
-    rightAddAreaWidth,
-    event,
-    originYCervix,
-    other
-  } = propItems;
-  const yScaleValue = cloneDeep(scaleValues);
-  const gridPoints = /* @__PURE__ */ new Set();
-  useGrid(canvas, propItems, true);
-  init();
-  function init() {
-    drawBorder();
-    drawYScale();
-    drawXScale();
-    drawOther();
-    drawPolyLine();
-    setCanvasEvent();
-    drawIcons();
-  }
-  function drawPolyLine() {
-    yScaleValue.forEach((item, dataIndex) => {
-      var _a;
-      const pointList = [];
-      const lineList = [];
-      const otherList = [];
-      (_a = item.data) == null ? void 0 : _a.forEach((v, index) => {
-        const points = getPointer(v, item);
-        drawPointLine(points, v, index);
-      });
-      Promise.all(pointList).then((res) => {
-        const lineListFilter = lineList.filter((v) => v);
-        let prevPoint = null;
-        res = res.filter((v) => {
-          if (v && prevPoint) {
-            prevPoint.nextPoint = v;
-            v.prevPoint = prevPoint;
-          }
-          prevPoint = v || prevPoint;
-          return v;
-        });
-        Promise.all(otherList).then((r) => {
-          canvas.value.add(...lineListFilter, ...res, ...r);
-          res.forEach((point) => {
-            point == null ? void 0 : point.bringToFront();
-          });
-        });
-      });
-      function drawPointLine(points, v, index) {
-        let point;
-        let line;
-        const { pointAttr = {}, lineAttr = {}, title = "", key, type: pointType = "circle", childbirth = {} } = item;
-        const nextV = item.data[index + 1];
-        const nextPoint = getPointer(nextV, item);
-        if (points && nextPoint && !v.breakpoint) {
-          line = drawLine([...points, ...nextPoint], {
-            ...lineAttr
-          });
-        } else if (points && !nextPoint && !v.breakpoint) {
-          const nextLinePoint = getPointer(nextV, item);
-          line = nextLinePoint ? drawLine([...points, ...nextLinePoint], {
-            ...lineAttr
-          }) : null;
-        }
-        let arrowGroup;
-        let arrowGroupText;
-        if (v.childbirth) {
-          const top = points[1] + yCellHeight;
-          arrowGroup = drawArrow([points[0], points[1], top], childbirth.style || {});
-          otherList.push(arrowGroup);
-          if (childbirth.text) {
-            arrowGroupText = drawText([points[0] + xCellWidth / 2, top - yCellHeight / 2], {
-              value: String(childbirth.text),
-              ...defaultTextStyle,
-              ...{
-                originX: "left",
-                originY: "center"
-              },
-              ...childbirth.style || {}
-            });
-            otherList.push(arrowGroupText);
-          }
-        }
-        const previousLine = lineList[index - 1];
-        const pointAttrNew = {
-          origin: {
-            data: v,
-            title,
-            key: key || "",
-            dataIndex,
-            index
-          },
-          leftLine: previousLine,
-          rightLine: line,
-          arrowGroup,
-          arrowGroupText,
-          ...pointAttr,
-          ...propItems.event
-        };
-        if (previousLine) {
-          point = drawPoint(pointType, {
-            left: previousLine.get("x2"),
-            top: previousLine.get("y2"),
-            ...pointAttrNew
-          });
-        } else {
-          if (points) {
-            pointAttrNew.leftLine = null;
-            point = drawPoint(pointType, {
-              left: points[0],
-              top: points[1],
-              ...pointAttrNew
-            });
-          }
-        }
-        lineList.push(line);
-        if (point) {
-          setPointEvent(point);
-          pointList.push(point);
-          gridPoints.add(point);
-        }
-      }
-    });
-  }
-  function setPointEvent(point) {
-    if (event.hovered) {
-      point.on("mouseover", () => {
-        setPopup(point);
-      });
-      point.on("mouseout", () => {
-        pointTipProps.show = false;
-      });
-    }
-    point.on("moving", () => {
-      moveLimit(point);
-      updateLine(point);
-      event.hovered && setPopup(point);
-    });
-    point.on("mouseup", (event2) => {
-      pointTipProps.show = false;
-      if (event2.button === 1) {
-        const { key } = point.origin;
-        const params = {
-          ...point.origin,
-          data: {
-            ...point.origin.data,
-            time: getXValue(point.left),
-            value: getYValue(key, point.top)
-          }
-        };
-        canvas.value.discardActiveObject();
-        emits("change", params);
-        updateData(params, "change");
-      }
-    });
-  }
-  function updateData(params, mode = "add") {
-    const { dataIndex, data, index, key } = params;
-    const item = yScaleValue.find((v) => v.key === key);
-    switch (mode) {
-      case "remove":
-        item.data.splice(index, 1);
-        break;
-      case "change":
-        item.data[index] = data;
-        break;
-      default: {
-        const index2 = getIndex(data.time, item.data);
-        item.data.splice(index2, 0, data);
-        break;
-      }
-    }
-    redrawPoints();
-  }
-  function getRemovePoints(points) {
-    const removePoints = [];
-    points.forEach((point) => {
-      point && removePoints.push(point);
-      (point == null ? void 0 : point.leftLine) && removePoints.push(point == null ? void 0 : point.leftLine);
-      (point == null ? void 0 : point.rightLine) && removePoints.push(point == null ? void 0 : point.rightLine);
-      (point == null ? void 0 : point.arrowGroup) && removePoints.push(point == null ? void 0 : point.arrowGroup);
-      (point == null ? void 0 : point.arrowGroupText) && removePoints.push(point == null ? void 0 : point.arrowGroupText);
-    });
-    return removePoints;
-  }
-  function redrawPoints() {
-    var _a;
-    gridPoints.size && ((_a = canvas.value) == null ? void 0 : _a.remove(...getRemovePoints([...gridPoints])));
-    gridPoints.clear();
-    drawPolyLine();
-  }
-  function updateLine(point) {
-    var _a, _b, _c, _d;
-    (_a = point.leftLine) == null ? void 0 : _a.setCoords().set({ x2: point.left, y2: point.top });
-    (_b = point.rightLine) == null ? void 0 : _b.setCoords().set({ x1: point.left, y1: point.top });
-    (_c = point.arrowGroup) == null ? void 0 : _c.setCoords().set({ left: point.left, top: point.top });
-    (_d = point.arrowGroupText) == null ? void 0 : _d.setCoords().set({ left: point.left + xCellWidth / 2, top: point.top + yCellHeight / 2 });
-  }
-  function moveLimit(point) {
-    const limitLeft = point.prevPoint ? point.prevPoint.left : originX;
-    const limitRight = point.nextPoint ? point.nextPoint.left : endX;
-    point.setCoords();
-    ["cervix", "fetalPresentation"].includes(point.origin.key) && point.top < originYCervix && point.set("top", originYCervix);
-    point.top < originY && point.set("top", originY);
-    point.top > endY && point.set("top", endY);
-    point.left < limitLeft && point.set("left", limitLeft);
-    point.left > limitRight && point.set("left", limitRight);
-  }
-  function setPopup(point) {
-    const { title, key } = point.origin;
-    pointTipProps.point = {
-      x: point.left,
-      y: point.top
-    };
-    pointTipProps.list = [`${title} ${getYValue(key, point.top)}`, `\u65F6\u95F4 ${getXValue(point.left).slice(-5)}`];
-    pointTipProps.show = true;
-  }
-  function getPointer(v, item) {
-    if (isEffectiveNode(v) && isLimit(v.time)) {
-      const x = cumputedX(v.time);
-      const y = cumputedY(item.key, item.range, v.value);
-      return [x, y < originY ? originY : y > endY ? endY : y];
-    }
-  }
-  function isLimit(time) {
-    const maxMinute = startTime + 24 * 60 * 60 * 1e3;
-    const getTime = new Date(time).getTime();
-    return getTime >= startTime && getTime <= maxMinute;
-  }
-  function setCanvasEvent() {
-    if (!propItems.event.evented)
-      return;
-    canvas.value.on("mouse:up", (event2) => {
-      if (event2.button === 3) {
-        const { x = 0, y = 0 } = event2.pointer || {};
-        if (x >= originX && x <= endX && y >= originY && y <= endY) {
-          pointMenuProps.point = { x, y };
-          pointMenuProps.show = true;
-          if (!event2.target) {
-            pointMenuProps.target = null;
-            pointMenuProps.list = ["\u65B0\u589E\u8282\u70B9"];
-            yScaleValue.forEach((item) => {
-              if (!getEqualXTypes(x, "key", xCellWidth).includes(item.key)) {
-                if (["cervix", "fetalPresentation"].includes(item.key) && y < originYCervix)
-                  return;
-                pointMenuProps.list.push(getPointMenuList(item, event2.pointer));
-              }
-            });
-            if (pointMenuProps.list.length === 1) {
-              pointMenuProps.show = false;
-              repeatTip();
-              console.log("\u5F53\u524D\u65F6\u95F4\u6BB5\u5185\u65E0\u53EF\u65B0\u589E\u8282\u70B9");
-            }
-          } else {
-            pointMenuProps.target = event2.target;
-            pointMenuProps.list = ["\u5220\u9664\u8282\u70B9"];
-            canvas.value.forEachObject((obj) => {
-              if (obj.origin && obj.left === event2.target.left && obj.top === event2.target.top) {
-                pointMenuProps.list.push({
-                  renderItem: () => obj.origin.title,
-                  origin: { ...obj.origin },
-                  mode: "remove",
-                  pointer: event2.pointer
-                });
-              }
-            });
-          }
-        }
-      }
-    });
-    function getPointMenuList(item, pointer) {
-      const dataIndex = yScaleValue.findIndex((_item) => _item.key === item.key);
-      return {
-        renderItem: () => item.title,
-        origin: {
-          title: item.title,
-          unit: item.unit,
-          dataIndex,
-          key: item.key
-        },
-        pointer
-      };
-    }
-  }
-  function clickMenu({ item, target }) {
-    const params = {
-      ...item.origin
-    };
-    if (item.mode === "remove") {
-      emits("remove", params);
-      updateData(params, "remove");
-    } else {
-      Object.assign(params, {
-        data: {
-          time: getXValue(item.pointer.x),
-          value: getYValue(item.origin.key, item.pointer.y)
-        }
-      });
-      emits("add", params);
-      updateData(params);
-    }
-  }
-  function drawOther() {
-    const lineData = Object.values(other);
-    const lines = [];
-    const alertData = {};
-    const alertItem = yScaleValue.find((item) => item.key === "cervix");
-    const alertStartPoint = alertItem.data.find((_data) => +_data.value === 3);
-    lineData.forEach((line) => {
-      if (!line.show)
-        return;
-      const { key } = line;
-      switch (key) {
-        case "fetalPresentation": {
-          const { range } = yScaleValue.find((item) => item.key === key);
-          const y = cumputedY(key, range, 0);
-          lines.push(
-            drawLine([originX, y, endX, y], {
-              ...line
-            })
-          );
-          break;
-        }
-        case "alert": {
-          if (alertStartPoint) {
-            const { key: key2, range } = alertItem || {};
-            const _time = 6 * 60 * 60 * 1e3;
-            const endPoint = {
-              time: format(new Date(new Date(alertStartPoint.time).getTime() + _time), "yyyy-MM-dd HH:mm"),
-              value: 10
-            };
-            const [x1, y1] = [
-              cumputedX(alertStartPoint.time) - originX,
-              endY - cumputedY(key2, range, alertStartPoint.value)
-            ];
-            const [x2, y2] = [cumputedX(endPoint.time) - originX, endY - cumputedY(key2, range, endPoint.value)];
-            const k = (y2 - y1) / (x2 - x1);
-            const b = y1 - x1 * k;
-            const pointer = computePointer(k, b);
-            if (pointer.length > 0) {
-              lines.push(
-                drawLine(pointer, {
-                  ...line
-                })
-              );
-              Object.assign(alertData, {
-                k,
-                b
-              });
-            }
-          }
-          break;
-        }
-        case "handling": {
-          if (alertStartPoint) {
-            const { k, b } = alertData;
-            const _time = 4 * 60 * 60 * 1e3;
-            const endTime = cumputedX(
-              format(new Date(new Date(alertStartPoint.time).getTime() + _time), "yyyy-MM-dd HH:mm")
-            );
-            const a = endTime - cumputedX(alertStartPoint.time);
-            const _b = b - a * k;
-            const pointer = computePointer(k, _b);
-            if (pointer.length > 0) {
-              lines.push(
-                drawLine(pointer, {
-                  ...line
-                })
-              );
-            }
-          }
-          break;
-        }
-      }
-    });
-    function computePointer(k, b) {
-      const { key, range } = alertItem || {};
-      const _originY = cumputedY(key, range, 10);
-      const startPointer1 = [0, b];
-      const startPointer2 = [-(b / k), 0];
-      const endPointer1 = [(endY - _originY - b) / k, endY - _originY];
-      const endPointer2 = [endX - originX, k * (endX - originX) + b];
-      let startPointer = [];
-      let endPointer = [];
-      if (isLinePointer(startPointer1) && isLimit2(startPointer1)) {
-        startPointer = getActualValue(startPointer1);
-      }
-      if (isLinePointer(startPointer2) && isLimit2(startPointer2)) {
-        startPointer = getActualValue(startPointer2);
-      }
-      if (isLinePointer(endPointer1) && isLimit2(endPointer1)) {
-        endPointer = getActualValue(endPointer1);
-      }
-      if (isLinePointer(endPointer2) && isLimit2(endPointer2)) {
-        endPointer = getActualValue(endPointer2);
-      }
-      function isLinePointer([x, y]) {
-        return Math.abs(y - k * x - b) <= 1;
-      }
-      function isLimit2([x, y]) {
-        const [_x, _y] = [...getActualValue([x, y])];
-        return _x >= originX && _x <= endX && _y >= _originY && _y <= endY;
-      }
-      function getActualValue([x, y]) {
-        return [originX + x, endY - y];
-      }
-      return [...startPointer, ...endPointer];
-    }
-    canvas.value.add(...lines);
-  }
-  function drawIcons() {
-    const leftX = leftAddAreaWidth / 2;
-    const rightX = canvasWidth - rightAddAreaWidth / 2;
-    _drawIcons(leftScales, leftX);
-    _drawIcons(rightScales, rightX);
-    function _drawIcons(scales, left) {
-      if (!scales.length)
-        return;
-      let topY = originY;
-      const objs = [];
-      scales.forEach((item) => {
-        const title = item.title.split("").join("\n");
-        const dataIndex = scaleValues.findIndex((_item) => _item.key === item.key);
-        const text = new fabric.Text(String(title), {
-          ...defaultTextStyle,
-          ...item.titleStyle || {},
-          originY: "top",
-          left,
-          top: topY,
-          lineHeight: 1
-        });
-        const icon = drawPoint(item.type, {
-          left,
-          top: topY + text.height + 3,
-          ...item.pointAttr,
-          originY: "top",
-          origin: {
-            title: item.title,
-            unit: item.unit,
-            type: item.type,
-            dataIndex,
-            key: item.key,
-            isMenu: true
-          },
-          originLeft: left,
-          originTop: topY + text.height + 3,
-          ...propItems.event
-        });
-        topY += text.height + icon.height + 15;
-        setIconEvent(icon);
-        objs.push(text, icon);
-      });
-      setVerticalCenter(objs);
-      canvas.value.add(...objs);
-    }
-    function setVerticalCenter(objs) {
-      const lastobj = objs.at(-1);
-      const wrapHalf = (endY - originY) / 2;
-      const contentHalf = (lastobj.height + lastobj.top - originY) / 2;
-      objs.forEach((obj) => {
-        const top = obj.top + wrapHalf - contentHalf;
-        obj.set({
-          top,
-          originTop: top
-        });
-      });
-    }
-  }
-  function setIconEvent(point) {
-    point.on("moving", () => {
-      point.set("originY", "center");
-      if (isLimit2(point)) {
-        moveLimit(point);
-        setPopup(point);
-      } else {
-        pointTipProps.show = false;
-      }
-    });
-    point.on("mouseup:before", (event2) => {
-      pointTipProps.show = false;
-      if (event2.e.button === 0) {
-        if (isLimit2(point)) {
-          const isRepeat = getEqualXTypes(point.left, "key", xCellWidth).includes(point.origin.key);
-          if (isRepeat) {
-            repeatTip();
-          } else {
-            const params = {
-              data: {
-                time: getXValue(point.left),
-                value: getYValue(point.origin.key, point.top)
-              },
-              ...point.origin
-            };
-            emits("add", params);
-            updateData(params);
-          }
-        }
-      }
-      setRestore(point);
-    });
-    function isLimit2(point2) {
-      const { left, top } = point2;
-      return left >= originX && left <= endX && top >= originY && top <= endY;
-    }
-  }
-  function setRestore(point) {
-    point.setCoords().set({ originY: "top", left: point.originLeft, top: point.originTop });
-  }
-  function drawXScale() {
-    const { show, startTime: startTime2, range = [0, 23], position = "top", style } = xAxis.time;
-    const { show: processTimeShow, range: processTimeRange = [0, 23], style: processTimeStyle } = xAxis.processTime;
-    if (show || processTimeShow) {
-      const timeList = [];
-      const processTimeList = [];
-      const timeTextList = [];
-      const processTimeTextList = [];
-      const left = originX + xCellWidth / 2;
-      for (let i = 0; i < grid.mainXCell; i++) {
-        if (show) {
-          const currentTime = i === 0 ? +startTime2.slice(11, 13) : getCurrentTime(timeList.at(-1), range);
-          timeList.push(currentTime);
-          const top = position == "top" ? originY - 15 : endY + 15;
-          timeTextList.push(
-            drawText([left + i * xCellWidth, top], {
-              value: String(currentTime),
-              ...defaultTextStyle,
-              ...style || {}
-            })
-          );
-        }
-        if (processTimeShow) {
-          const currentProcessTime = i === 0 ? processTimeRange[0] : processTimeList.at(-1) + 1;
-          processTimeList.push(currentProcessTime);
-          const top = position == "top" ? endY + 15 : originY - 15;
-          processTimeTextList.push(
-            drawText([left + i * xCellWidth, top], {
-              value: String(currentProcessTime),
-              ...defaultTextStyle,
-              ...processTimeStyle || {}
-            })
-          );
-        }
-      }
-      const group = new fabric.Group([...timeTextList, ...processTimeTextList], {
-        evented: false,
-        selectable: false
-      });
-      canvas.value.add(group);
-      canvas.value.sendToBack(group);
-    }
-  }
-  function getCurrentTime(lastTime, range) {
-    return lastTime + 1 > range[1] ? range[0] : lastTime + 1;
-  }
-  function drawYScale() {
-    let baseLeft = leftAddAreaWidth;
-    [...leftScales, ...rightScales].forEach((item, index) => {
-      const { range, spaceValue, width, title, titleStyle, layout } = item;
-      const textList = [];
-      if (layout === "right")
-        baseLeft = endX;
-      const left = baseLeft + width / 2;
-      const list = getScaleNumberList(range, spaceValue);
-      list.forEach((num, i) => {
-        const top = i === 0 ? endY - 8 : endY - i * yCellHeight;
-        textList.push(
-          drawText([left, top], {
-            value: String(num),
-            ...defaultTextStyle
-          })
-        );
-      });
-      const border = new fabric.Rect({
-        ...defaultRectStyle,
-        width,
-        height: endY,
-        left,
-        top: endY / 2
-      });
-      const titleText = originY > 0 ? drawText([left, originY - yCellHeight / 2], {
-        value: String(title),
-        ...defaultTextStyle,
-        ...titleStyle
-      }) : null;
-      const group = new fabric.Group([...textList, border, ...titleText ? [titleText] : []], {
-        evented: false,
-        selectable: false
-      });
-      canvas.value.add(group);
-      baseLeft += width;
-    });
-  }
-  function getScaleNumberList(range, spaceValue) {
-    const list = [];
-    const [min, max] = range;
-    for (let i = min; spaceValue > 0 ? i <= max : i >= max; i += spaceValue) {
-      list.push(i);
-    }
-    return list;
-  }
-  function drawBorder() {
-    const border = new fabric.Rect({
-      ...borderStyle,
-      width: canvasWidth - leftAddAreaWidth - rightAddAreaWidth,
-      height: endY,
-      left: leftAddAreaWidth,
-      top: 0,
-      fill: "transparent"
-    });
-    canvas.value.add(border);
-  }
-  return {
-    clickMenu
-  };
-}
-
-export { useBirthProcess };