@plait/common 0.92.3 → 0.93.0

package/README.md

@@ -5,7 +5,7 @@ Common logic for drawing plugins. When writing drawing business code, if you fin
 
 `core` core logic, currently mainly places the base class of plugin components
 
-`generators` Generator is an abstract concept, mainly used for plug-in component rendering and management of drawing elements, 👉 [View more](https://plait-docs.vercel.app/guides/concepts/generator)
+`generators` Generator is an abstract concept, mainly used for plug-in component rendering and management of drawing elements, 👉 [View more](https://plait-docs.pages.dev/guides/concepts/generator)
 
 `plugins` places reusable plugin logic
 

package/fesm2022/plait-common.mjs

@@ -444,8 +444,8 @@ function getRatioByPoint(points, point) {
 }
 const removeDuplicatePoints = (points) => {
     const newArray = [];
-    points.forEach(point => {
-        const index = newArray.findIndex(otherPoint => {
+    points.forEach((point) => {
+        const index = newArray.findIndex((otherPoint) => {
             return Point.isEquals(point, otherPoint);
         });
         if (index === -1)
@@ -712,7 +712,7 @@ const getFirstTextManage = (element) => {
     return textManage;
 };
 const getTextEditorsByElement = (element) => {
-    return getTextManages(element).map(manage => {
+    return getTextManages(element).map((manage) => {
         return manage.editor;
     });
 };
@@ -726,7 +726,7 @@ const getFirstTextEditor = (element) => {
 const findFirstTextEditor = (board) => {
     const selectedElements = getSelectedElements(board);
     let firstEditor = null;
-    selectedElements.forEach(element => {
+    selectedElements.forEach((element) => {
         const editors = getTextEditorsByElement(element);
         if (!firstEditor && editors && editors.length > 0) {
             firstEditor = editors[0];
@@ -736,12 +736,12 @@ const findFirstTextEditor = (board) => {
 };
 const getElementsText = (elements) => {
     return elements
-        .map(item => {
+        .map((item) => {
         try {
             const editors = getTextEditorsByElement(item);
             if (editors.length) {
                 return editors
-                    .map(editor => {
+                    .map((editor) => {
                     const textsEntry = Node.texts(editor);
                     return Array.from(textsEntry).reduce((total, text) => (total += text[0].text), '');
                 })
@@ -753,21 +753,21 @@ const getElementsText = (elements) => {
             return '';
         }
     })
-        .filter(item => item)
+        .filter((item) => item)
         .join(' ');
 };
 const getTextEditors = (board, elements) => {
     const selectedElements = elements || getSelectedElements(board);
     if (selectedElements.length) {
         const textManages = [];
-        selectedElements.forEach(item => {
+        selectedElements.forEach((item) => {
             textManages.push(...getTextManages(item));
         });
-        const editingTextManage = textManages.find(textManage => textManage.isEditing);
+        const editingTextManage = textManages.find((textManage) => textManage.isEditing);
         if (editingTextManage) {
             return [editingTextManage.editor];
         }
-        return textManages.map(item => {
+        return textManages.map((item) => {
             return item.editor;
         });
     }
@@ -776,10 +776,10 @@ const getTextEditors = (board, elements) => {
 const getEditingTextEditor = (board, elements) => {
     const selectedElements = elements || getSelectedElements(board);
     const textManages = [];
-    selectedElements.forEach(item => {
+    selectedElements.forEach((item) => {
         textManages.push(...getTextManages(item));
     });
-    const editingTextManage = textManages.find(textManage => textManage.isEditing);
+    const editingTextManage = textManages.find((textManage) => textManage.isEditing);
     if (editingTextManage) {
         return editingTextManage.editor;
     }
@@ -886,7 +886,7 @@ class AStar {
             if (currentPoint[0] === end[0] && currentPoint[1] === end[1]) {
                 break;
             }
-            current.node.adjacentNodes.forEach(next => {
+            current.node.adjacentNodes.forEach((next) => {
                 let newCost = costSoFar.get(current.node) + this.heuristic(next.data, current.node.data);
                 const previousNode = this.cameFrom.get(current.node);
                 // Inflection point weight, if an inflection point occurs, cost + 1 to avoid the inflection point path
@@ -1014,7 +1014,7 @@ const routeAdjust = (path, options, board) => {
 const adjust = (route, options, board) => {
     const { parallelPaths, pointOfHit, sourceRectangle, targetRectangle } = options;
     let result = null;
-    parallelPaths.forEach(parallelPath => {
+    parallelPaths.forEach((parallelPath) => {
         // Construct a rectangle
         const tempRectPoints = [pointOfHit, parallelPath[0], parallelPath[1]];
         // directly use getCornerPoints will bring the precision issue (eg: 263.6923375175286 - 57.130859375)
@@ -1027,7 +1027,7 @@ const adjust = (route, options, board) => {
             const indexRangeInPath = [];
             const indexRangeInCorner = [];
             route.forEach((point, index) => {
-                const cornerResult = tempCorners.findIndex(corner => Point.isEquals(point, corner));
+                const cornerResult = tempCorners.findIndex((corner) => Point.isEquals(point, corner));
                 if (cornerResult !== -1) {
                     indexRangeInPath.push(index);
                     indexRangeInCorner.push(cornerResult);
@@ -1082,7 +1082,7 @@ const getGraphPoints = (options) => {
     const x = [];
     const y = [];
     let result = [];
-    [sourceOuterRectangle, targetOuterRectangle].forEach(rectangle => {
+    [sourceOuterRectangle, targetOuterRectangle].forEach((rectangle) => {
         x.push(rectangle.x, rectangle.x + rectangle.width / 2, rectangle.x + rectangle.width);
         y.push(rectangle.y, rectangle.y + rectangle.height / 2, rectangle.y + rectangle.height);
     });
@@ -1110,7 +1110,7 @@ const getGraphPoints = (options) => {
             }
         }
     }
-    result = removeDuplicatePoints(result).filter(point => {
+    result = removeDuplicatePoints(result).filter((point) => {
         const isInSource = RectangleClient.isPointInRectangle(sourceOuterRectangle, point);
         const isInTarget = RectangleClient.isPointInRectangle(targetOuterRectangle, point);
         return !isInSource && !isInTarget;
@@ -1121,7 +1121,7 @@ const createGraph = (points) => {
     const graph = new PointGraph();
     const Xs = [];
     const Ys = [];
-    points.forEach(p => {
+    points.forEach((p) => {
         const x = p[0], y = p[1];
         if (Xs.indexOf(x) < 0)
             Xs.push(x);
@@ -1311,13 +1311,13 @@ const getStrokeLineDash = (strokeStyle, strokeWidth) => {
 };
 
 const buildClipboardData = (board, elements, startPoint, elementBuilder) => {
-    return elements.map(element => {
+    return elements.map((element) => {
         const newElement = elementBuilder && elementBuilder(element);
         if (newElement) {
             return newElement;
         }
         if (element.points) {
-            const points = element.points.map(point => [point[0] - startPoint[0], point[1] - startPoint[1]]);
+            const points = element.points.map((point) => [point[0] - startPoint[0], point[1] - startPoint[1]]);
             return { ...element, points };
         }
         return element;
@@ -1325,14 +1325,14 @@ const buildClipboardData = (board, elements, startPoint, elementBuilder) => {
 };
 const insertClipboardData = (board, elements, startPoint, elementHandler) => {
     const idsMap = {};
-    elements.forEach(element => {
+    elements.forEach((element) => {
         idsMap[element.id] = idCreator();
     });
-    elements.forEach(element => {
+    elements.forEach((element) => {
         element.id = idsMap[element.id];
         elementHandler && elementHandler(element, idsMap);
         if (element.points) {
-            element.points = element.points.map(point => [startPoint[0] + point[0], startPoint[1] + point[1]]);
+            element.points = element.points.map((point) => [startPoint[0] + point[0], startPoint[1] + point[1]]);
         }
         Transforms.insertNode(board, element, [board.children.length]);
     });
@@ -1490,7 +1490,7 @@ class ImageGenerator extends Generator {
 
 const setProperty = (board, properties, options) => {
     const selectedElements = getSelectedElements(board);
-    selectedElements.forEach(element => {
+    selectedElements.forEach((element) => {
         if (options?.match && !options?.match(element))
             return;
         const path = PlaitBoard.findPath(board, element);
@@ -1569,7 +1569,7 @@ const alignRight = (board) => {
 function setOffset(board, getOffset) {
     const elements = getHighestSelectedElements(board);
     const outerRectangle = getRectangleByElements(board, elements, false);
-    elements.forEach(element => {
+    elements.forEach((element) => {
         if (!element.points && !PlaitGroupElement.isGroup(element))
             return;
         const rectangle = board.getRectangle(element);
@@ -1581,8 +1581,8 @@ function setOffset(board, getOffset) {
         else if (element.points) {
             updateElements = [element];
         }
-        updateElements.forEach(item => {
-            const newPoints = item.points.map(p => [p[0] + offset[0], p[1] + offset[1]]);
+        updateElements.forEach((item) => {
+            const newPoints = item.points.map((p) => [p[0] + offset[0], p[1] + offset[1]]);
             const path = PlaitBoard.findPath(board, item);
             Transforms.setNode(board, {
                 points: newPoints
@@ -1602,14 +1602,14 @@ const distribute = (board, isHorizontal) => {
     const axis = isHorizontal ? 'x' : 'y';
     const side = isHorizontal ? 'width' : 'height';
     const highestSelectedElements = getHighestSelectedElements(board);
-    const refs = highestSelectedElements.map(element => {
+    const refs = highestSelectedElements.map((element) => {
         return { element, rectangle: board.getRectangle(element) };
     });
     const outerRectangle = getRectangleByElements(board, highestSelectedElements, false);
     const minRectangleRef = refs.sort((a, b) => a.rectangle[axis] - b.rectangle[axis])[0];
     const maxRectangleRef = refs.sort((a, b) => b.rectangle[axis] + b.rectangle[side] - (a.rectangle[axis] + a.rectangle[side]))[0];
-    const minIndex = refs.findIndex(ref => ref === minRectangleRef);
-    const maxIndex = refs.findIndex(ref => ref === maxRectangleRef);
+    const minIndex = refs.findIndex((ref) => ref === minRectangleRef);
+    const maxIndex = refs.findIndex((ref) => ref === maxRectangleRef);
     let distributeRefs = refs.filter((element, index) => index !== minIndex && index !== maxIndex);
     const sum = distributeRefs.reduce((accumulator, current) => current.rectangle[side] + accumulator, 0);
     const offset = (outerRectangle[side] - minRectangleRef.rectangle[side] - maxRectangleRef.rectangle[side] - sum) / (distributeRefs.length + 1);
@@ -1621,7 +1621,7 @@ const distribute = (board, isHorizontal) => {
         const moveAxis = isHorizontal ? 0 : 1;
         moveOffset[moveAxis] = position - rectangle[axis];
         const path = PlaitBoard.findPath(board, distributeRefs[i].element);
-        const newPoints = distributeRefs[i].element.points.map(p => [p[0] + moveOffset[0], p[1] + moveOffset[1]]);
+        const newPoints = distributeRefs[i].element.points.map((p) => [p[0] + moveOffset[0], p[1] + moveOffset[1]]);
         Transforms.setNode(board, {
             points: newPoints
         }, path);
@@ -1684,7 +1684,7 @@ const withResize = (board, options) => {
             }
             startPoint = [event.x, event.y];
             const path = Array.isArray(resizeHitTestRef.element)
-                ? resizeHitTestRef.element.map(el => PlaitBoard.findPath(board, el))
+                ? resizeHitTestRef.element.map((el) => PlaitBoard.findPath(board, el))
                 : PlaitBoard.findPath(board, resizeHitTestRef.element);
             resizeRef = {
                 path,