cnhis-design-vue 3.1.12-beta.6 → 3.1.13-beta.0

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

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

package/es/packages/fabric-chart/src/hooks/useLeft.d.ts

@@ -0,0 +1,4 @@
+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): void;

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

@@ -1 +1,181 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle, defaultTextStyle, defaultStyle, defaultRectStyle, drawPoint, drawTextGroup } from './useDraw.js';
 
+function useLeft(canvas, propItems, emits, setPopup, pointTipProps, getXValue, getYValue, getEqualXTypes) {
+  const {
+    originY,
+    endY,
+    originX,
+    endX,
+    yCellHeight,
+    borderStyle,
+    left,
+    vitalSignsOriginY,
+    painOriginY,
+    painHeight,
+    iconsWidth,
+    itemList
+  } = propItems;
+  function drwaPainScaleValue(item) {
+    const title = drawTextGroup({
+      width: originX - iconsWidth,
+      height: painHeight,
+      ...defaultRectStyle
+    }, {
+      value: `${item.title.slice(0, 2)}
+${item.title.slice(-2)}`,
+      ...defaultTextStyle,
+      ...item.titleStyle || {}
+    }, {
+      left: iconsWidth,
+      top: painOriginY.originY
+    });
+    const list = [];
+    item.list.forEach((v, i) => {
+      const top = painOriginY.endY - i * yCellHeight * item.spaceGridNumber;
+      const text = new fabric.Text(String(v), {
+        ...defaultTextStyle,
+        originX: "right",
+        left: originX - (item.marginRight || 3),
+        top: i === 0 ? endY - 5 : top,
+        ...item.style
+      });
+      list.push(text);
+    });
+    canvas.value.add(title, ...list);
+  }
+  function drawScaleValue() {
+    let groupList = [];
+    const column = !painHeight ? left.yScaleValue.length : left.yScaleValue.length - 1;
+    const colWidth = (originX - iconsWidth) / column;
+    const residue = (originX - iconsWidth) % column;
+    const firstColWidth = colWidth + residue;
+    left.yScaleValue.forEach((item, index) => {
+      if (item.type === "pain") {
+        drwaPainScaleValue(item);
+        return;
+      }
+      let list = [];
+      const rectWidth = index === 0 ? firstColWidth : colWidth;
+      const rectLeft = index === 0 ? iconsWidth : firstColWidth + iconsWidth + (index - 1) * colWidth;
+      const line = index > 0 ? new fabric.Line([rectLeft, vitalSignsOriginY.originY, rectLeft, vitalSignsOriginY.endY], {
+        ...defaultBorderStyle
+      }) : null;
+      line && list.push(line);
+      const leftVal = rectLeft + rectWidth / 2;
+      const spaceGridNumber = left.spaceGridNumber || 5;
+      item.list.forEach((v, i) => {
+        const top = vitalSignsOriginY.endY - i * yCellHeight * spaceGridNumber;
+        const text = new fabric.Text(String(v), {
+          ...defaultTextStyle,
+          left: leftVal,
+          top: i === 0 ? top - 5 : top,
+          ...item.style
+        });
+        list.push(text);
+      });
+      let title = item.title || "";
+      if (item.unit)
+        title += "\n" + item.unit;
+      title && list.push(new fabric.Text(String(title), {
+        ...defaultTextStyle,
+        left: leftVal,
+        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: originX - iconsWidth,
+      height: endY - originY,
+      left: iconsWidth,
+      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() {
+    let list = JSON.parse(JSON.stringify(itemList));
+    let topY = endY;
+    let leftX = iconsWidth - left.icons.marginRight;
+    list.reverse().forEach((item, index) => {
+      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
+        }
+      });
+      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");
+          }
+        }
+      }
+    });
+  }
+  onMounted(() => {
+    nextTick(() => {
+      iconsWidth && drawIcons();
+      drawScaleValue();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useLeft };

package/es/packages/fabric-chart/src/hooks/useOther.d.ts

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

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

@@ -0,0 +1,34 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultStyle } from './useDraw.js';
+
+function useOther(canvas, propItems, cumputedX) {
+  const { originY, other, vitalSignsOriginY } = propItems;
+  function drawOther() {
+    if (!other || !other.list)
+      return false;
+    const list = [];
+    other.list.forEach((v, i) => {
+      const text = new fabric.Text(String(v.value.toString().split("").join("\n")), {
+        originX: "center",
+        top: vitalSignsOriginY.originY,
+        left: cumputedX(v.time),
+        textAlign: "center",
+        ...defaultStyle,
+        ...other.style || {}
+      });
+      list.push(text);
+    });
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && group.sendToBack();
+    group && canvas.value.add(group);
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawOther();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useOther };

package/es/packages/fabric-chart/src/hooks/useRight.d.ts

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

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

@@ -1 +1,90 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle, defaultRectStyle, defaultStyle } from './useDraw.js';
 
+function useRight(canvas, propItems) {
+  const {
+    endX,
+    endY,
+    temperatureYCell,
+    canvasWidth,
+    canvasHeight,
+    left,
+    right,
+    breathingHeight,
+    vitalSignsOriginY,
+    painOriginY
+  } = propItems;
+  function drawScaleValue() {
+    var _a, _b, _c;
+    if (!right) {
+      canvas.value.add(new fabric.Line([canvasWidth - 1, 0, canvasWidth - 1, canvasHeight], defaultBorderStyle));
+      return false;
+    }
+    let list = [];
+    list.push(new fabric.Rect({
+      ...defaultRectStyle,
+      width: canvasWidth - endX - 1,
+      height: endY + breathingHeight,
+      left: endX,
+      top: 0,
+      originX: "left",
+      originY: "top"
+    }));
+    const difVal = 6;
+    const spaceScaleNumber = right.yScaleValue.spaceScaleNumber || 5;
+    const mainScaleWidth = 9;
+    const subScaleWidth = 5;
+    const cList = left.yScaleValue.find((v) => v.type === "temperature").list;
+    const minC = Math.min(...cList);
+    const h1 = right.yScaleValue.list[1];
+    const h0 = right.yScaleValue.list[0];
+    const c1 = 5 * (h1 - 32) / 9;
+    const c0 = 5 * (h0 - 32) / 9;
+    const top1 = vitalSignsOriginY.endY - (c1 - minC) * temperatureYCell - difVal;
+    const top0 = vitalSignsOriginY.endY - (c0 - minC) * temperatureYCell - difVal;
+    const spaceHVaule = (top0 - top1) / spaceScaleNumber;
+    let endTop = 0;
+    right.yScaleValue.list.forEach((v, i) => {
+      var _a2;
+      const c = 5 * (+v - 32) / 9;
+      const top = vitalSignsOriginY.endY - (c - minC) * temperatureYCell - difVal;
+      if (i === right.yScaleValue.list.length - 1)
+        endTop = top;
+      const text = new fabric.Text(`${v}\xB0`, {
+        left: endX + mainScaleWidth,
+        top: i === 0 ? vitalSignsOriginY.endY - 5 : top - 5,
+        originX: "left",
+        ...((_a2 = right.yScaleValue) == null ? void 0 : _a2.style) || {}
+      });
+      list.push(text);
+      const spaceHVaule0 = (vitalSignsOriginY.endY - top1) / spaceScaleNumber;
+      for (let k = 0; k < spaceScaleNumber; k++) {
+        const scaleTop = i === 0 ? vitalSignsOriginY.endY - k * spaceHVaule0 : top - k * spaceHVaule;
+        const line = new fabric.Line([endX, scaleTop, k > 0 ? endX + subScaleWidth : endX + mainScaleWidth, scaleTop], {
+          ...defaultBorderStyle
+        });
+        list.push(line);
+      }
+    });
+    const width = canvasWidth - endX;
+    const unit = right.yScaleValue.unit ? new fabric.Text((_b = (_a = right.yScaleValue) == null ? void 0 : _a.unit) == null ? void 0 : _b.split("").join("\n"), {
+      left: endX + width / 2,
+      top: endTop / 2,
+      originX: "center",
+      ...((_c = right.yScaleValue) == null ? void 0 : _c.style) || {}
+    }) : null;
+    unit && list.push(unit);
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && group.sendToBack();
+    group && canvas.value.add(group);
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawScaleValue();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useRight };

package/es/packages/fabric-chart/src/hooks/useShadow.d.ts

@@ -0,0 +1,6 @@
+import { fabric } from '../utils';
+declare type Point = [number, number];
+export declare function useShadow(): {
+    createShadowLines: (coordinates: Point[], angle?: number, space?: number) => fabric.Line[];
+};
+export {};

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

@@ -0,0 +1,127 @@
+import { useMemoize } from '@vueuse/core';
+import { fabric } from '../utils/index.js';
+
+const getTangent = useMemoize((angle) => {
+  return +Math.tan(angle * Math.PI / 180);
+});
+function useShadow() {
+  function createShadowLines(coordinates, angle = 45, space = 10) {
+    const result = [];
+    angle = normalizeAngle(angle);
+    if (angle === 0)
+      return result;
+    const minX = Math.min(...coordinates.map(([x]) => x));
+    const maxX = Math.max(...coordinates.map(([x]) => x));
+    const minY = Math.min(...coordinates.map(([, y]) => y));
+    const maxY = Math.max(...coordinates.map(([, y]) => y));
+    const offsetX = (maxY - minY) / getTangent(angle);
+    const isLeanRight = angle > 0 && angle < 90 || angle > 180 && angle < 270;
+    let start = minX;
+    let end = maxX;
+    if (isLeanRight) {
+      end += offsetX;
+    } else {
+      start += offsetX;
+    }
+    getLinePoints(start, end).forEach((linePoint) => {
+      let intersectionPoints = [];
+      getShapeLinePoints(coordinates).forEach((shapeLinePoint) => {
+        const intersectionPoint = getIntersectionPoint(linePoint[0], linePoint[1], shapeLinePoint[0], shapeLinePoint[1]);
+        intersectionPoint && intersectionPoints.push(intersectionPoint);
+      });
+      intersectionPoints = sortPoints(uniquePoints(intersectionPoints));
+      if (intersectionPoints.length >= 2) {
+        for (let i = 0; i < intersectionPoints.length; i++) {
+          if (intersectionPoints[i + 1] && isInnerLine(intersectionPoints[i], intersectionPoints[i + 1])) {
+            result.push(createLine(intersectionPoints[i], intersectionPoints[i + 1]));
+          }
+        }
+      }
+    });
+    return result;
+    function isInnerLine(point1, point2) {
+      return isInPolygon([(point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2], coordinates);
+    }
+    function normalizeAngle(angle2) {
+      angle2 = angle2 % 360;
+      angle2 = angle2 < 0 ? 180 - angle2 : angle2;
+      angle2 = angle2 >= 180 ? angle2 - 180 : angle2;
+      return angle2;
+    }
+    function getLinePoints(start2, end2) {
+      const result2 = [completePoint([start2, minY])];
+      while (start2 < end2) {
+        start2 += space;
+        result2.push(completePoint([start2, minY]));
+      }
+      return result2;
+    }
+    function completePoint(point) {
+      const otherPoint = [point[0] - offsetX, maxY];
+      return [point, otherPoint];
+    }
+    function getShapeLinePoints(coordinates2) {
+      return coordinates2.reduce((res, c, idx) => {
+        const next = coordinates2[idx + 1] || coordinates2[0];
+        res.push([c, next]);
+        return res;
+      }, []);
+    }
+    function createLine(startPoint, endPoint) {
+      return new fabric.Line([startPoint[0], startPoint[1], endPoint[0], endPoint[1]]);
+    }
+  }
+  return { createShadowLines };
+  function sortPoints(points) {
+    return points.sort((a, b) => a[1] - b[1]);
+  }
+  function getIntersectionPoint(a, b, c, d) {
+    const denominator = (b[1] - a[1]) * (d[0] - c[0]) - (a[0] - b[0]) * (c[1] - d[1]);
+    if (denominator === 0) {
+      return false;
+    }
+    const x = ((b[0] - a[0]) * (d[0] - c[0]) * (c[1] - a[1]) + (b[1] - a[1]) * (d[0] - c[0]) * a[0] - (d[1] - c[1]) * (b[0] - a[0]) * c[0]) / denominator;
+    const y = -((b[1] - a[1]) * (d[1] - c[1]) * (c[0] - a[0]) + (b[0] - a[0]) * (d[1] - c[1]) * a[1] - (d[0] - c[0]) * (b[1] - a[1]) * c[1]) / denominator;
+    if (((x - a[0]) * (x - b[0]) < 0 || nearlyEqual(x, a[0]) || nearlyEqual(x, b[0])) && ((y - a[1]) * (y - b[1]) < 0 || nearlyEqual(y, a[1]) || nearlyEqual(y, b[1])) && ((x - c[0]) * (x - d[0]) < 0 || nearlyEqual(x, c[0]) || nearlyEqual(x, d[0])) && ((y - c[1]) * (y - d[1]) < 0 || nearlyEqual(y, c[1]) || nearlyEqual(y, d[1]))) {
+      return [x, y];
+    }
+    return false;
+  }
+  function uniquePoints(points) {
+    return points.reduce((fin, point) => {
+      if (!hasPoint(fin, point))
+        fin.push(point);
+      return fin;
+    }, []);
+    function hasPoint(points2, point) {
+      return points2.some((p) => nearlyEqual(p[0], point[0]) && nearlyEqual(p[1], point[1]));
+    }
+  }
+  function isInPolygon(checkPoint, polygonPoints) {
+    let counter = 0;
+    let xinters;
+    let p1, p2;
+    let pointCount = polygonPoints.length;
+    p1 = polygonPoints[0];
+    for (let i = 1; i <= pointCount; i++) {
+      p2 = polygonPoints[i % pointCount];
+      if (checkPoint[0] > Math.min(p1[0], p2[0]) && checkPoint[0] <= Math.max(p1[0], p2[0])) {
+        if (checkPoint[1] <= Math.max(p1[1], p2[1])) {
+          if (p1[0] != p2[0]) {
+            xinters = (checkPoint[0] - p1[0]) * (p2[1] - p1[1]) / (p2[0] - p1[0]) + p1[1];
+            if (p1[1] == p2[1] || checkPoint[1] <= xinters) {
+              counter++;
+            }
+          }
+        }
+      }
+      p1 = p2;
+    }
+    return counter % 2 !== 0;
+  }
+  function nearlyEqual(v1, v2) {
+    return Math.abs(v1 - v2) <= 1e-4;
+  }
+}
+
+export { useShadow };

package/es/packages/fabric-chart/src/hooks/useTop.d.ts

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

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

@@ -1 +1,149 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultStyle, drawTextGroup, defaultTextStyle, defaultRectStyle } from './useDraw.js';
 
+function useTop(canvas, propItems) {
+  const {
+    originY,
+    grid,
+    originX,
+    xCellWidth,
+    gridXNumber,
+    top,
+    dateHeight,
+    hospitalDaysHeight,
+    operationDaysHeight,
+    xScalevalueHeight,
+    iconsWidth
+  } = propItems;
+  function drawTop() {
+    let list = [];
+    let topY = 0;
+    let topList = [];
+    for (let i in top) {
+      if (top[i].show) {
+        topList.push({
+          ...top[i],
+          key: i
+        });
+      }
+    }
+    topList.sort((a, b) => a.seq - b.seq);
+    topList.forEach((item, index) => {
+      if (index > 0) {
+        topY += propItems[`${topList[index - 1].key}Height`];
+      }
+      if (item.key == "xScalevalue") {
+        drawDay(list, topY);
+        drawTime(list, topY);
+      } else {
+        propItems[`${item.key}Height`] && drawDate(item, list, topY);
+      }
+    });
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && group.sendToBack();
+    group && canvas.value.add(group);
+  }
+  function drawTime(list, topY) {
+    var _a;
+    const dayHeight = top.xScalevalue.show ? top.dayHeight || 0 : 0;
+    const height = xScalevalueHeight - dayHeight;
+    const title = drawTextGroup({
+      width: originX - iconsWidth,
+      height: xScalevalueHeight,
+      ...defaultRectStyle
+    }, {
+      value: top.xScalevalue.title,
+      ...defaultTextStyle,
+      ...((_a = top.date) == null ? void 0 : _a.style) || {}
+    }, {
+      left: iconsWidth,
+      top: topY
+    });
+    list.push(title);
+    let timeList = [];
+    for (let j = 0; j < grid.mainXCell; j++) {
+      timeList.push(top.xScalevalue.list);
+    }
+    timeList.flat().forEach((v, i) => {
+      var _a2;
+      const left = originX + i * xCellWidth;
+      const textGroup = drawTextGroup({
+        width: xCellWidth,
+        height
+      }, {
+        value: v,
+        ...defaultTextStyle,
+        ...((_a2 = top.date) == null ? void 0 : _a2.style) || {}
+      }, {
+        left,
+        top: topY + dayHeight
+      });
+      list.push(textGroup);
+    });
+  }
+  function drawDay(list, topY) {
+    var _a;
+    if (!top.dayHeight)
+      return false;
+    const height = top.dayHeight;
+    const width = xCellWidth * grid.subSecondXCell;
+    const dayList = gridXNumber / grid.subSecondXCell;
+    for (let i = 0; i < dayList; i++) {
+      const left = originX + i * width;
+      const value = i % 2 === 0 ? "\u4E0A\u5348" : "\u4E0B\u5348";
+      const textGroup = drawTextGroup({
+        width,
+        height
+      }, {
+        value,
+        ...defaultTextStyle,
+        ...((_a = top.date) == null ? void 0 : _a.style) || {}
+      }, {
+        left,
+        top: topY
+      });
+      list.push(textGroup);
+    }
+  }
+  function drawDate(item, list, topY) {
+    let height = propItems[`${item.key}Height`];
+    const title = drawTextGroup({
+      width: originX - iconsWidth,
+      height,
+      ...defaultRectStyle
+    }, {
+      value: item.title,
+      ...defaultTextStyle,
+      ...(item == null ? void 0 : item.style) || {}
+    }, {
+      left: iconsWidth,
+      top: topY
+    });
+    list.push(title);
+    const width = xCellWidth * grid.subXCell;
+    item.list.forEach((v, i) => {
+      const left = originX + i * width;
+      const textGroup = drawTextGroup({
+        width,
+        height
+      }, {
+        value: v,
+        ...defaultTextStyle,
+        ...(item == null ? void 0 : item.style) || {}
+      }, {
+        left,
+        top: topY
+      });
+      list.push(textGroup);
+    });
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawTop();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useTop };