cnhis-design-vue 3.1.17 → 3.1.18-beta.11

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

@@ -0,0 +1,182 @@
+import { fabric } from '../utils/index.js';
+
+const defaultStyle = {
+  evented: false,
+  selectable: false
+};
+const defaultBorderStyle = {
+  stroke: "#999",
+  strokeWidth: 1,
+  ...defaultStyle
+};
+const defaultLineStyle = {
+  stroke: "#000",
+  strokeWidth: 1,
+  strokeDashArray: [0, 0],
+  ...defaultStyle
+};
+const defaultRectStyle = {
+  fill: "transparent",
+  stroke: "#999",
+  strokeWidth: 1,
+  originX: "center",
+  originY: "center",
+  ...defaultStyle
+};
+const defaultTextStyle = {
+  fontFamily: "\u5FAE\u8F6F\u96C5\u9ED1",
+  fontSize: 12,
+  fill: "#000",
+  centeredRotation: true,
+  originX: "center",
+  originY: "center",
+  lineHeight: 1,
+  ...defaultStyle
+};
+function drawLine(points, style) {
+  return new fabric.Line(points, {
+    ...defaultLineStyle,
+    ...style
+  });
+}
+function drawText([x, y], style) {
+  const text = new fabric.Text(String(style.value), {
+    ...defaultTextStyle,
+    left: x,
+    top: y,
+    ...style
+  });
+  return text;
+}
+function drawArrow([x, y1, y2], style, type = "down") {
+  const arrowLine = drawLine([x, y1, x, y2], {
+    strokeWidth: 1,
+    stroke: style.fill
+  });
+  const arrow = drawText([x + 0.5, type === "up" ? y2 - 3 : y2 + 3], {
+    value: "v",
+    originX: "center",
+    originY: "bottom",
+    fontSize: 16,
+    angle: type === "up" ? 180 : 0,
+    ...style
+  });
+  const arrowGroup = new fabric.Group([arrowLine, arrow], {
+    ...defaultStyle,
+    originX: "center",
+    originY: "top"
+  });
+  return arrowGroup;
+}
+function drawTextGroup(rectStyle, fontStyle, groupStyle) {
+  const rect = new fabric.Rect({
+    ...defaultRectStyle,
+    ...rectStyle
+  });
+  const { value = "\u6807\u9898", textAlign = "center", verticalAlign = "center" } = fontStyle;
+  const textLeft = rectStyle.width / 2;
+  const textTop = rectStyle.height / 2;
+  const texts = new fabric.Text(String(value), {
+    ...defaultTextStyle,
+    ...fontStyle,
+    ...textAlign == "left" || textAlign == "right" ? {
+      originX: textAlign,
+      left: textAlign == "left" ? -textLeft : textLeft
+    } : {},
+    ...verticalAlign == "top" || verticalAlign == "bottom" ? {
+      originY: verticalAlign,
+      top: verticalAlign == "top" ? -textTop : textTop
+    } : {}
+  });
+  return new fabric.Group([rect, texts], {
+    ...defaultStyle,
+    ...groupStyle
+  });
+}
+function drawPoint(type = "circle", style) {
+  const newStyle = {
+    originX: "center",
+    originY: "center",
+    hasControls: false,
+    hasBorders: false,
+    hoverCursor: "pointer",
+    ...style
+  };
+  const createCircleBorder = () => {
+    return new fabric.Circle({
+      objectCaching: false,
+      strokeWidth: style.strokeWidth || 1,
+      stroke: style.stroke || "red",
+      radius: style.radius || 5,
+      fill: "#fff"
+    });
+  };
+  switch (type) {
+    case "triangle":
+      return new fabric.Triangle({
+        width: 20,
+        height: 20,
+        strokeWidth: 1,
+        scale: 1,
+        ...newStyle
+      });
+    case "circle":
+      return new fabric.Circle({
+        objectCaching: false,
+        strokeWidth: 1,
+        radius: 5,
+        scale: 1,
+        ...newStyle
+      });
+    case "image":
+      if (style == null ? void 0 : style.url) ; else {
+        return new fabric.Image(style.element, {
+          ...newStyle,
+          scale: 1
+        });
+      }
+    case "yemai":
+      const createAdd = () => {
+        const width = ((style.radius || 5) + (style.strokeWidth || 1)) * 2;
+        const subLineStyle = {
+          stroke: style.strokeX || "blue",
+          strokeWidth: style.strokeWidthX || 1,
+          originX: "center",
+          originY: "center"
+        };
+        const line1 = new fabric.Line([0, width / 2, width, width / 2], subLineStyle);
+        const line2 = new fabric.Line([width / 2, 0, width / 2, width], subLineStyle);
+        return new fabric.Group([line1, line2]);
+      };
+      return new fabric.Group([createCircleBorder(), createAdd()], {
+        scale: 1,
+        ...newStyle
+      });
+    case "koumai":
+      const left = (style.radius || 5) + (style.strokeWidth || 1);
+      const circle = new fabric.Circle({
+        objectCaching: false,
+        radius: style.radiusCircle || 2,
+        fill: style.fillCircle || "#000",
+        originX: "center",
+        originY: "center",
+        left,
+        top: left
+      });
+      return new fabric.Group([createCircleBorder(), circle], {
+        scale: 1,
+        ...newStyle
+      });
+    default:
+      style && Reflect.deleteProperty(style, "stroke");
+      return new fabric.Text(String(type), {
+        fontFamily: "\u5FAE\u8F6F\u96C5\u9ED1",
+        scale: 1,
+        fontSize: 14,
+        fill: "#000",
+        ...newStyle
+      });
+  }
+}
+
+export { defaultBorderStyle, defaultLineStyle, defaultRectStyle, defaultStyle, defaultTextStyle, drawArrow, drawLine, drawPoint, drawText, drawTextGroup };

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

@@ -0,0 +1 @@
+export { useCanvasEvent, useEvent } from './useEvent2.js';

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

@@ -0,0 +1 @@
+export { default } from './useGrid2.js';

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

@@ -0,0 +1,50 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { drawLine } from './useDraw2.js';
+
+function useGrid(canvas, propItems) {
+  var _a, _b;
+  const { gridYNumber, originY, grid, originX, endX, xCellWidth, yCellHeight, gridXNumber, endY } = propItems;
+  const yList = [];
+  const xList = [];
+  const mainList = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= gridYNumber; i++) {
+    const y = originY + parseInt(String(yCellHeight * (gridYNumber - i)));
+    const style = i % grid.subYCell === 0 ? ((_a = grid.mainLineStyle) == null ? void 0 : _a.x) || {} : grid.subLineStyle || {};
+    const line = drawLine([originX, y, endX, y], style);
+    if (i % grid.subYCell === 0) {
+      mainList.add(line);
+    } else {
+      yList.push(line);
+    }
+  }
+  for (let i = 0; i <= gridXNumber; i++) {
+    const x = originX + parseInt(String(xCellWidth * i));
+    let style = grid.subLineStyle || {};
+    if (i % grid.subSecondXCell === 0) {
+      style = grid.subSecondLineStyle || {};
+    }
+    if (i % grid.subXCell === 0) {
+      style = ((_b = grid.mainLineStyle) == null ? void 0 : _b.y) || {};
+    }
+    const line = drawLine([x, originY, x, endY], style);
+    if (i % grid.subXCell === 0) {
+      mainList.add(line);
+    } else {
+      xList.push(line);
+    }
+  }
+  const group = new fabric.Group([...xList, ...yList, ...mainList], {
+    evented: false,
+    selectable: false
+  });
+  onMounted(() => {
+    nextTick(() => {
+      canvas.value.add(group);
+      canvas.value.sendToBack(group);
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useGrid as default };

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

@@ -0,0 +1 @@
+export { useLeft } from './useLeft2.js';

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

@@ -0,0 +1,282 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle, defaultTextStyle, defaultStyle, defaultRectStyle, drawPoint, drawTextGroup } from './useDraw2.js';
+
+function useLeft(canvas, propItems, emits, setPopup, pointTipProps, getXValue, getYValue, getEqualXTypes) {
+  const {
+    originY,
+    endY,
+    originX,
+    endX,
+    yCellHeight,
+    left,
+    vitalSignsOriginY,
+    painOriginY,
+    painHeight,
+    iconsWidth,
+    itemList,
+    painIndex,
+    right,
+    getRightInfo
+  } = propItems;
+  const mainScaleWidth = 9;
+  const subScaleWidth = 5;
+  function drawScaleNumber(text, item, left2, top) {
+    const { position } = item;
+    return new fabric.Text(String(text), {
+      ...defaultTextStyle,
+      originX: position == "left" ? "right" : position == "right" ? "left" : "center",
+      left: left2,
+      top,
+      ...item.style
+    });
+  }
+  function getScaleInfo(position = "center", x, width) {
+    let scaleLeft = x + width / 2;
+    let lineXMain = [scaleLeft - mainScaleWidth / 2, scaleLeft + mainScaleWidth / 2];
+    let lineXSub = [scaleLeft - subScaleWidth / 2, scaleLeft + subScaleWidth / 2];
+    let textLeft = scaleLeft;
+    if (position === "right") {
+      scaleLeft = x;
+      lineXMain = [scaleLeft, scaleLeft + mainScaleWidth];
+      lineXSub = [scaleLeft, scaleLeft + subScaleWidth];
+      textLeft = lineXMain[1];
+    }
+    if (position === "left") {
+      scaleLeft = x + width;
+      lineXMain = [scaleLeft - mainScaleWidth, scaleLeft];
+      lineXSub = [scaleLeft - subScaleWidth, scaleLeft];
+      textLeft = lineXMain[0];
+    }
+    return { lineXMain, lineXSub, textLeft };
+  }
+  function drwaPainScaleValue(item) {
+    const title = drawTextGroup({
+      width: originX - iconsWidth,
+      height: painHeight,
+      ...defaultRectStyle
+    }, {
+      value: `${item.title}`,
+      ...defaultTextStyle,
+      ...item.style || {}
+    }, {
+      left: iconsWidth,
+      top: painOriginY.originY
+    });
+    const list = [];
+    if (item.showScale || item.showNumber) {
+      const { lineXMain, textLeft } = getScaleInfo(item.position, iconsWidth, originX - iconsWidth);
+      const listLen = item.list.length;
+      item.list.forEach((v, i) => {
+        let top = painOriginY.endY - i * yCellHeight * item.spaceGridNumber;
+        if (i === 0) {
+          top = endY - 5;
+        }
+        const isMaxMinNumber = i === 0 || i === listLen - 1;
+        if (item.showNumber && (isMaxMinNumber ? item.showMaxMinNumber : true)) {
+          list.push(drawScaleNumber(v, item, textLeft, top));
+        }
+        if (item.showScale && i !== 0) {
+          const [x1, x2] = lineXMain;
+          const line = new fabric.Line([x1, top, x2, top], {
+            ...defaultBorderStyle,
+            ...item.style
+          });
+          list.push(line);
+        }
+      });
+    }
+    canvas.value.add(title, ...list);
+    title.sendToBack();
+  }
+  function drawScaleValue(yScaleValueList) {
+    var _a;
+    if (!(yScaleValueList == null ? void 0 : yScaleValueList.length))
+      return;
+    const { layout } = yScaleValueList[0];
+    let start = iconsWidth;
+    let end = originX;
+    if (layout === "right") {
+      start = endX;
+      end = endX + ((_a = right == null ? void 0 : right.width) != null ? _a : 0);
+    }
+    const groupList = [];
+    const column = !painHeight || layout === "right" ? yScaleValueList.length : yScaleValueList.length - 1;
+    const colWidth = (end - start) / column;
+    const residue = (end - start) % column;
+    const firstColWidth = colWidth + residue;
+    yScaleValueList.forEach((item, index) => {
+      if (item.type === "pain") {
+        drwaPainScaleValue(item);
+        return;
+      }
+      const list = [];
+      function createLine(points) {
+        const line2 = new fabric.Line(points, {
+          ...defaultBorderStyle,
+          ...item.style
+        });
+        list.push(line2);
+      }
+      const rectWidth = index === 0 ? firstColWidth : colWidth;
+      const rectLeft = index === 0 ? start : firstColWidth + start + (index - 1) * colWidth;
+      const line = index > 0 ? new fabric.Line([rectLeft, vitalSignsOriginY.originY, rectLeft, vitalSignsOriginY.endY], {
+        ...defaultBorderStyle
+      }) : null;
+      line && list.push(line);
+      const centerX = rectLeft + rectWidth / 2;
+      const spaceGridNumber = item.spaceGridNumber || 5;
+      if (item.showScale || item.showNumber) {
+        const spaceScale = spaceGridNumber * yCellHeight / 5;
+        const position = item.position || "center";
+        const { lineXMain, lineXSub, textLeft } = getScaleInfo(item.position, rectLeft, rectWidth);
+        const listLen = item.list.length;
+        item.list.forEach((v, i) => {
+          const top = vitalSignsOriginY.endY - i * yCellHeight * spaceGridNumber;
+          const isMaxMinNumber = i === 0 || i === listLen - 1;
+          if (item.showNumber && (isMaxMinNumber ? item.showMaxMinNumber : true)) {
+            const y = i == 0 ? top - 5 : top;
+            y > vitalSignsOriginY.originY && list.push(drawScaleNumber(v, item, textLeft, y));
+          }
+          if (item.showScale && i !== listLen - 1) {
+            for (let j = 0; j < 5; j++) {
+              if (j > 0 || !item.showNumber || position !== "center") {
+                const x1 = j == 0 ? lineXMain[0] : lineXSub[0];
+                const x2 = j == 0 ? lineXMain[1] : lineXSub[1];
+                const y = top - j * spaceScale;
+                if (y > vitalSignsOriginY.originY) {
+                  createLine([x1, y, x2, y]);
+                  if (i == listLen - 2 && j == 4) {
+                    createLine([lineXMain[0], y - spaceScale, lineXMain[1], y - spaceScale]);
+                  }
+                }
+              }
+            }
+          }
+        });
+      }
+      let title = item.title || "";
+      if (item.unit)
+        title += "\n" + item.unit;
+      title && list.push(new fabric.Text(String(title), {
+        ...defaultTextStyle,
+        left: centerX,
+        top: vitalSignsOriginY.originY + yCellHeight * spaceGridNumber / 2,
+        textAlign: "center",
+        ...item.style
+      }));
+      const group2 = new fabric.Group(list, defaultStyle);
+      groupList.push(group2);
+    });
+    groupList.push(new fabric.Rect({
+      ...defaultRectStyle,
+      width: layout === "right" ? end - start - 1 : end - start,
+      height: layout === "right" ? endY - originY - 1 : endY - originY,
+      left: start,
+      top: originY,
+      originX: "left",
+      originY: "top"
+    }));
+    const group = groupList.length > 0 ? new fabric.Group([...groupList], { ...defaultStyle }) : null;
+    group && canvas.value.add(group);
+    group && group.sendToBack();
+  }
+  function drawIcons() {
+    const list = JSON.parse(JSON.stringify(itemList));
+    let topY = endY;
+    const leftX = iconsWidth - left.icons.marginRight;
+    list.reverse().forEach((item) => {
+      topY -= 10;
+      let title = item.title.replace(/(.{2})/g, "$1\n");
+      if (title.endsWith("\n")) {
+        title = title.slice(0, title.length - 1);
+      }
+      const text = new fabric.Text(String(title), {
+        ...defaultStyle,
+        ...item.titleStyle || {},
+        originX: "right",
+        originY: "bottom",
+        left: leftX - (item.pointAttr.width || 10) - 5,
+        top: topY,
+        lineHeight: 1,
+        fontSize: 12
+      });
+      const icon = drawPoint(item.type, {
+        left: leftX,
+        top: topY - (text.height || 30) / 2,
+        ...item.pointAttr,
+        originY: "center",
+        originX: "right",
+        origin: {
+          title: item.title,
+          unit: item.unit,
+          type: item.bigType,
+          dataIndex: item.dataIndex,
+          key: item.key
+        },
+        originLeft: leftX,
+        originTop: topY - (text.height || 30) / 2,
+        ...propItems.event
+      });
+      topY -= text.height || 30;
+      setPointEvent(icon);
+      canvas.value.add(text, icon);
+    });
+  }
+  function isLimit(point) {
+    return point.left >= originX && point.left <= endX && point.top >= originY && point.top <= endY;
+  }
+  function setPointEvent(point) {
+    point.on("moving", () => {
+      if (isLimit(point)) {
+        setPopup(point);
+      } else {
+        pointTipProps.show = false;
+      }
+    });
+    point.on("mouseup:before", (event) => {
+      pointTipProps.show = false;
+      if (event.e.button === 0) {
+        if (isLimit(point)) {
+          if (!getEqualXTypes(point.left).includes(point.origin.type)) {
+            emits("add", {
+              data: {
+                time: getXValue(point.left),
+                value: getYValue(point.origin.type, point.top)
+              },
+              ...point.origin
+            });
+          } else {
+            console.log("\u5F53\u524D\u65F6\u95F4\u6BB5\u5185\u65E0\u53EF\u65B0\u589E\u8282\u70B9");
+            setRestore();
+          }
+        } else {
+          setRestore();
+        }
+      }
+      function setRestore() {
+        point.setCoords();
+        point.set({ left: point.originLeft, top: point.originTop });
+      }
+    });
+  }
+  onMounted(() => {
+    nextTick(() => {
+      var _a;
+      iconsWidth && drawIcons();
+      const yScaleValueList = left.yScaleValue.filter((v) => v.layout === "left" && v.type !== "pain");
+      if ((right == null ? void 0 : right.width) && ((_a = right == null ? void 0 : right.yScaleValue) == null ? void 0 : _a.layout) === "left") {
+        yScaleValueList.push(getRightInfo);
+      }
+      painIndex == 0 && yScaleValueList.unshift(left.yScaleValue[painIndex]);
+      painIndex == left.yScaleValue.length - 1 && yScaleValueList.push(left.yScaleValue[painIndex]);
+      drawScaleValue(yScaleValueList);
+      canvas.value.renderAll();
+    });
+  });
+  return {
+    drawScaleValue
+  };
+}
+
+export { useLeft };

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

@@ -0,0 +1 @@
+export { useOther } from './useOther2.js';

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

@@ -0,0 +1,85 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultStyle } from './useDraw2.js';
+
+function useOther(canvas, propItems, cumputedX) {
+  const { other, vitalSignsOriginY } = propItems;
+  function drawOther() {
+    if (!(other == null ? void 0 : other.list))
+      return false;
+    const list = [];
+    const otherList = [];
+    other.list.forEach((item) => {
+      const align = item.align || "vertical";
+      const left = cumputedX(item.time);
+      const obj = otherList.find((v) => v.left == left);
+      if (obj) {
+        obj[align].push(item);
+      } else {
+        const initObj = {
+          left,
+          vertical: [],
+          horizontal: []
+        };
+        initObj[align].push(item);
+        otherList.push(initObj);
+      }
+    });
+    let textWidth = 0;
+    otherList.forEach((item) => {
+      let topY = vitalSignsOriginY.originY;
+      let leftX = item.left;
+      let textHeight = 0;
+      item.vertical.forEach((v) => {
+        const { commonOptions, value } = getTextData(v);
+        topY += (v.baseTop || 0) + textHeight;
+        const text = new fabric.Text(value, {
+          top: topY,
+          left: item.left,
+          ...commonOptions
+        });
+        textHeight = text.height || 0;
+        setTextWidth(text);
+      });
+      item.horizontal.forEach((v, i) => {
+        if (i > 0 || item.vertical.length) {
+          leftX += textWidth;
+        }
+        const { commonOptions, value } = getTextData(v);
+        const text = new fabric.Text(value, {
+          top: vitalSignsOriginY.originY,
+          left: leftX,
+          ...commonOptions
+        });
+        setTextWidth(text);
+      });
+    });
+    function setTextWidth(text) {
+      if (!textWidth) {
+        textWidth = text.width || 0;
+      }
+      list.push(text);
+    }
+    function getTextData(v) {
+      return {
+        commonOptions: {
+          originX: "center",
+          textAlign: "center",
+          ...defaultStyle,
+          ...v.style || {}
+        },
+        value: String(v.value.toString().split("").join("\n"))
+      };
+    }
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && canvas.value.add(group);
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawOther();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useOther };

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

@@ -0,0 +1 @@
+export { useRight } from './useRight2.js';

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

@@ -0,0 +1,27 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle } from './useDraw2.js';
+
+function useRight(canvas, propItems, drawScaleValue) {
+  const { left, right, getRightInfo, canvasWidth, endY, endX, originY } = propItems;
+  onMounted(() => {
+    nextTick(() => {
+      var _a;
+      const yScaleValueList = left.yScaleValue.filter((v) => v.layout === "right");
+      if ((right == null ? void 0 : right.width) && ((_a = right == null ? void 0 : right.yScaleValue) == null ? void 0 : _a.layout) === "right") {
+        yScaleValueList.push(getRightInfo);
+      }
+      if ((right == null ? void 0 : right.width) || yScaleValueList.length > 0) {
+        const rightBorderLine = new fabric.Line([canvasWidth - 1, 0, canvasWidth - 1, endY], defaultBorderStyle);
+        const rightBorderLine2 = new fabric.Line([endX + 1, originY, canvasWidth - 1, originY], {
+          ...defaultBorderStyle,
+          stroke: "#fff"
+        });
+        canvas.value.add(rightBorderLine, rightBorderLine2);
+      }
+      drawScaleValue(yScaleValueList);
+    });
+  });
+}
+
+export { useRight };

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

@@ -0,0 +1 @@
+export { useShadow } from './useShadow2.js';

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

@@ -0,0 +1 @@
+export { useTop } from './useTop2.js';