cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/components/fabric-chart/src/hooks/useCumputedPoint.d.ts

@@ -0,0 +1,7 @@
+import { IPropItems, IPointType } from '../interface';
+export declare function useCumputedPoint(propItems: IPropItems): {
+    cumputedX: (value: number | string, setAllCenter?: boolean) => any;
+    cumputedY: (type: IPointType, scaleValueList: number[], value: number | string) => number;
+    getXValue: (pointX: number) => string | undefined;
+    getYValue: (type: IPointType, pointY: number) => number;
+};

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

@@ -0,0 +1,60 @@
+function useCumputedPoint(propItems) {
+  const { xScaleList, originX, endY, xCellWidth, left, vitalSignsOriginY, painOriginY, canvasWidth } = propItems;
+  function cumputedX(value, setAllCenter = false) {
+    const time = new Date(value).getTime();
+    const [minScale] = xScaleList;
+    const maxScale = xScaleList.at(-1);
+    if (time < minScale.start)
+      return 0;
+    if (time > maxScale.end)
+      return canvasWidth;
+    const index = xScaleList.findIndex((v) => v.end >= time);
+    if (index > -1) {
+      const item = xScaleList[index];
+      if (time === item.start && !setAllCenter) {
+        return item.left;
+      } else {
+        return item.center;
+      }
+    }
+  }
+  function cumputedY(type, scaleValueList, value) {
+    const yScaleCell = propItems[`${type}YCell`];
+    const yCellUnit = +value - Math.min(...scaleValueList);
+    const newEndY = type === "pain" ? painOriginY.endY : vitalSignsOriginY.endY;
+    return newEndY - yScaleCell * yCellUnit;
+  }
+  function getXValue(pointX) {
+    const index = xScaleList.findIndex((v) => v.left + xCellWidth >= pointX);
+    if (index > -1) {
+      const item = xScaleList[index];
+      const residueX = pointX - item.left;
+      const residueTime = item.scaleCell * residueX;
+      const time = item.start + residueTime;
+      const d = new Date(time);
+      const month = `00${d.getMonth() + 1}`.slice(-2);
+      const day = `00${d.getDate()}`.slice(-2);
+      const hours = `00${d.getHours()}`.slice(-2);
+      const minutes = `00${d.getMinutes()}`.slice(-2);
+      const date = `${d.getFullYear()}-${month}-${day} ${hours}:${minutes}`;
+      return date;
+    }
+  }
+  function getYValue(type, pointY) {
+    var _a;
+    const yScaleCell = propItems[`${type}YCell`];
+    const list = ((_a = left.yScaleValue.find((v) => v.type === type)) == null ? void 0 : _a.list) || [];
+    const minVal = list.length ? Math.min(...list) : 0;
+    const newEndY = type === "pain" ? painOriginY.endY : vitalSignsOriginY.endY;
+    const y = (newEndY - pointY) / yScaleCell + minVal;
+    return Math.floor(y * 100) / 100;
+  }
+  return {
+    cumputedX,
+    cumputedY,
+    getXValue,
+    getYValue
+  };
+}
+
+export { useCumputedPoint };

package/es/components/fabric-chart/src/hooks/useDraw.d.ts

@@ -0,0 +1,44 @@
+import { fabric } from '../utils';
+import { ILineOptions, ITextOptions } from '../interface';
+export declare const defaultStyle: {
+    evented: boolean;
+    selectable: boolean;
+};
+export declare const defaultBorderStyle: {
+    evented: boolean;
+    selectable: boolean;
+    stroke: string;
+    strokeWidth: number;
+};
+export declare const defaultLineStyle: {
+    evented: boolean;
+    selectable: boolean;
+    stroke: string;
+    strokeWidth: number;
+    strokeDashArray: number[];
+};
+export declare const defaultRectStyle: {
+    evented: boolean;
+    selectable: boolean;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    originX: string;
+    originY: string;
+};
+export declare const defaultTextStyle: {
+    evented: boolean;
+    selectable: boolean;
+    fontFamily: string;
+    fontSize: number;
+    fill: string;
+    centeredRotation: boolean;
+    originX: string;
+    originY: string;
+    lineHeight: number;
+};
+export declare function drawLine(points: number[], style: Partial<ILineOptions>): fabric.Line;
+export declare function drawText([x, y]: [x: number, y: number], style: ITextOptions): fabric.Text;
+export declare function drawArrow([x, y1, y2]: [x: number, y1: number, y2: number], style: ITextOptions | any, type?: string): fabric.Group;
+export declare function drawTextGroup(rectStyle: Partial<fabric.IRectOptions>, fontStyle: Partial<ITextOptions>, groupStyle: Partial<fabric.IGroupOptions>): fabric.Group;
+export declare function drawPoint(type: string | undefined, style: any): fabric.Object;

package/es/components/fabric-chart/src/hooks/useDraw.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":
+      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.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useEvent(element: HTMLCanvasElement | any): void;
+export declare function useCanvasEvent(canvas: Ref<fabric.Canvas>, propItems: IPropItems, emits: any): {
+    select: (key: string) => void;
+};

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

@@ -0,0 +1,161 @@
+import { useEventListener } from '@vueuse/core';
+import { fabric } from '../utils/index.js';
+
+function useEvent(element) {
+  useEventListener(element.nextSibling, "contextmenu", (e) => {
+    e.preventDefault();
+    return false;
+  });
+}
+function useCanvasEvent(canvas, propItems, emits) {
+  const { originY, originX, endX, endY, iconsWidth, selectionStyle, topList } = propItems;
+  function drawRect(options, key) {
+    const { left, top, width, height } = options;
+    const rect = new fabric.Rect({
+      key,
+      left: left != null ? left : 0,
+      top: top != null ? top : 0,
+      width,
+      height,
+      stroke: "transparent",
+      fill: "transparent",
+      lockMovementX: true,
+      lockMovementY: true,
+      transparentCorners: false,
+      hasControls: false,
+      ...selectionStyle,
+      strokeWidth: 0
+    });
+    canvas.value.add(rect);
+    return rect;
+  }
+  let selections = [];
+  function initSelection() {
+    const selections2 = [];
+    selections2.push(
+      drawRect(
+        {
+          left: iconsWidth,
+          top: originY + 1,
+          width: originX - iconsWidth,
+          height: endY - originY - 3
+        },
+        "left"
+      )
+    );
+    let topY = 0;
+    topList.forEach((item, index) => {
+      if (index > 0) {
+        topY += propItems[`${topList[index - 1].key}Height`];
+      }
+      const commonOptions = {
+        top: topY + 1,
+        height: propItems[`${item.key}Height`] - 1
+      };
+      selections2.push(
+        drawRect(
+          {
+            left: iconsWidth,
+            width: endX - iconsWidth,
+            ...commonOptions
+          },
+          item.key + "All"
+        )
+      );
+      selections2.push(
+        drawRect(
+          {
+            left: iconsWidth,
+            width: originX - iconsWidth,
+            ...commonOptions
+          },
+          item.key + "Title"
+        )
+      );
+      selections2.push(
+        drawRect(
+          {
+            left: originX,
+            width: endX - originX,
+            ...commonOptions
+          },
+          item.key
+        )
+      );
+    });
+    selections2.push(
+      drawRect(
+        {
+          left: originX,
+          top: originY + 1,
+          width: endX - originX,
+          height: endY - originY - 3
+        },
+        "grid"
+      )
+    );
+    selections2.forEach((obj) => {
+      if (obj.key.endsWith("All")) {
+        obj.sendToBack();
+        obj.on("mouseup", (event) => {
+          const { button, pointer } = event;
+          if (button == 1) {
+            const _key = obj.key.replace("All", "");
+            const key = pointer.x <= originX ? _key + "Title" : _key;
+            obj.sendToBack();
+            select(key);
+            emits("select", key);
+          }
+        });
+      } else {
+        obj.on("mousedown", () => {
+          resetStrokeWidth();
+          setActiveObj(obj);
+          emits("select", obj.key);
+        });
+        setTimeout(() => {
+          obj.bringToFront();
+        });
+      }
+    });
+    canvas.value.renderAll();
+    return selections2;
+  }
+  function addSelectionListener() {
+    canvas.value.on("selection:cleared", selectionCB);
+    function selectionCB(event) {
+      const { deselected = [] } = event;
+      deselected.forEach((obj) => {
+        obj.set("strokeWidth", 0);
+        obj.key.endsWith("All") && obj.sendToBack();
+      });
+    }
+  }
+  function select(key) {
+    canvas.value.discardActiveObject().renderAll();
+    resetStrokeWidth();
+    const obj = selections == null ? void 0 : selections.find((obj2) => obj2.key === key);
+    setActiveObj(obj);
+    obj && canvas.value.setActiveObject(obj);
+  }
+  function init() {
+    if (typeof (selectionStyle == null ? void 0 : selectionStyle.evented) === "boolean" && !(selectionStyle == null ? void 0 : selectionStyle.evented))
+      return;
+    selections = initSelection();
+    addSelectionListener();
+  }
+  function resetStrokeWidth() {
+    selections.forEach((obj) => {
+      obj.set("strokeWidth", 0);
+      obj.key.endsWith("All") && obj.sendToBack();
+    });
+  }
+  function setActiveObj(obj) {
+    var _a;
+    obj == null ? void 0 : obj.bringToFront().set("strokeWidth", (_a = selectionStyle.strokeWidth) != null ? _a : 2);
+  }
+  init();
+  return { select };
+}
+
+export { useCanvasEvent, useEvent };

package/es/components/fabric-chart/src/hooks/useGrid.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export default function useGrid(canvas: Ref<fabric.Canvas>, propItems: IPropItems): void;

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

@@ -0,0 +1,50 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { drawLine } from './useDraw.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.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useLeft(canvas: Ref<fabric.Canvas>, propItems: IPropItems, emits: any, setPopup: Function, pointTipProps: any, getXValue: Function, getYValue: Function, getEqualXTypes: Function, isAddPoint: Function): {
+    drawScaleValue: (yScaleValueList: any[]) => void;
+};