feat: fix lint errors (#1140)

Author: pubuzhixing8

packages/common/src/algorithms/a-star.ts

@@ -30,7 +30,7 @@ export 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

packages/common/src/plugins/with-group.spec.ts

@@ -149,14 +149,14 @@ describe('with group plugin', () => {
     it('should remove the group if there is only one element left within after deletion', () => {
         addSelectedElement(board, [board.children[0]]);
         deleteFragment(board);
-        const group = board.children.find(item => item.id === board.children[0].groupId);
+        const group = board.children.find((item) => item.id === board.children[0].groupId);
         expect(group).toBe(undefined);
     });
 
     it('should update element groupId if there is only one element left within after deletion', () => {
         addSelectedElement(board, [board.children[4]]);
         deleteFragment(board);
-        const group = board.children.find(item => item.id === board.children[4].groupId);
+        const group = board.children.find((item) => item.id === board.children[4].groupId);
         expect(group).toBe(undefined);
         expect(board.children[3].groupId).toBe(group2[group2.length - 1].id);
 

packages/common/src/plugins/with-resize.ts

@@ -52,7 +52,7 @@ export const withResize = <T extends PlaitElementOrArray = PlaitElementOrArray,
             }
             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,

packages/common/src/text/types.ts

@@ -1,9 +1,9 @@
 import { BaseElement } from 'slate';
 
-export type ElementSize =  {
+export type ElementSize = {
     width: number;
     height: number;
-}
+};
 
 export enum Alignment {
     left = 'left',

packages/common/src/transforms/align.ts

@@ -60,7 +60,7 @@ export const alignRight = (board: PlaitBoard) => {
 function setOffset(board: PlaitBoard, getOffset: (outerRectangle: RectangleClient, rectangle: RectangleClient) => Point) {
     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)!;
         const offset = getOffset(outerRectangle, rectangle);
@@ -70,8 +70,8 @@ function setOffset(board: PlaitBoard, getOffset: (outerRectangle: RectangleClien
         } else if (element.points) {
             updateElements = [element];
         }
-        updateElements.forEach(item => {
-            const newPoints = item.points!.map(p => [p[0] + offset[0], p[1] + offset[1]]) as Point[];
+        updateElements.forEach((item) => {
+            const newPoints = item.points!.map((p) => [p[0] + offset[0], p[1] + offset[1]]) as Point[];
             const path = PlaitBoard.findPath(board, item);
             Transforms.setNode(
                 board,
@@ -98,14 +98,14 @@ const distribute = (board: PlaitBoard, isHorizontal: boolean) => {
     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 =
@@ -118,7 +118,7 @@ const distribute = (board: PlaitBoard, isHorizontal: boolean) => {
         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]]) as Point[];
+        const newPoints = distributeRefs[i].element.points!.map((p) => [p[0] + moveOffset[0], p[1] + moveOffset[1]]) as Point[];
         Transforms.setNode(
             board,
             {

packages/common/src/transforms/property.ts

@@ -9,7 +9,7 @@ export interface SetOptions<T extends PlaitElement = PlaitElement> {
 
 export const setProperty = <T extends PlaitElement = PlaitElement>(board: PlaitBoard, properties: Partial<T>, options?: SetOptions<T>) => {
     const selectedElements = getSelectedElements(board) as T[];
-    selectedElements.forEach(element => {
+    selectedElements.forEach((element) => {
         if (options?.match && !options?.match(element)) return;
         const path = PlaitBoard.findPath(board, element);
         const memorizeKey = options?.getMemorizeKey ? options?.getMemorizeKey(element) : '';

packages/common/src/utils/clipboard.ts

@@ -6,13 +6,13 @@ export const buildClipboardData = (
     startPoint: Point,
     elementBuilder?: (element: PlaitElement) => PlaitElement | undefined
 ) => {
-    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;
@@ -26,14 +26,14 @@ export const insertClipboardData = (
     elementHandler?: (element: PlaitElement, idsMap: Record<string, string>) => void
 ) => {
     const idsMap: Record<string, string> = {};
-    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]]) as [Point, Point];
+            element.points = element.points.map((point) => [startPoint[0] + point[0], startPoint[1] + point[1]]) as [Point, Point];
         }
         Transforms.insertNode(board, element, [board.children.length]);
     });

packages/common/src/utils/default-orthogonal-routing.ts

@@ -1,8 +1,8 @@
 // Credits to xyflow
 // https://github.com/xyflow/xyflow/blob/main/packages/system/src/utils/edges/smoothstep-edge.ts
 
-import { Direction, Point } from "@plait/core";
-import { getDirectionFactor } from "./direction";
+import { Direction, Point } from '@plait/core';
+import { getDirectionFactor } from './direction';
 
 export const getPoints = (source: Point, sourcePosition: Direction, target: Point, targetPosition: Direction, offset: number) => {
     const sourceDirectionFactors = getDirectionFactor(sourcePosition);
@@ -99,4 +99,4 @@ function getEdgeCenter({
     const centerY = targetY < sourceY ? targetY + yOffset : targetY - yOffset;
 
     return [centerX, centerY, xOffset, yOffset];
-}
+}

packages/common/src/utils/elbow-line-route.ts

@@ -48,7 +48,11 @@ export const generateElbowLineRoute = (options: ElbowLineRouteOptions, board?: P
     const isHitY = RectangleClient.isHitY(options.sourceOuterRectangle, options.targetOuterRectangle);
     const centerX = isHitX ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, true);
     const centerY = isHitY ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, false);
-    route = routeAdjust(route, { centerX, centerY, sourceRectangle: options.sourceRectangle, targetRectangle: options.targetRectangle }, board);
+    route = routeAdjust(
+        route,
+        { centerX, centerY, sourceRectangle: options.sourceRectangle, targetRectangle: options.targetRectangle },
+        board
+    );
     return route;
 };
 
@@ -61,7 +65,11 @@ export const routeAdjust = (path: Point[], options: RouteAdjustOptions, board?:
         const optionsX = getAdjustOptions(path, centerX, true);
         const resultX =
             optionsX.pointOfHit &&
-            adjust(path, { parallelPaths: optionsX.parallelPaths, pointOfHit: optionsX.pointOfHit, sourceRectangle, targetRectangle }, board);
+            adjust(
+                path,
+                { parallelPaths: optionsX.parallelPaths, pointOfHit: optionsX.pointOfHit, sourceRectangle, targetRectangle },
+                board
+            );
         if (resultX) {
             path = resultX;
         }
@@ -70,7 +78,11 @@ export const routeAdjust = (path: Point[], options: RouteAdjustOptions, board?:
         const optionsY = getAdjustOptions(path, centerY, false);
         const resultY =
             optionsY.pointOfHit &&
-            adjust(path, { parallelPaths: optionsY.parallelPaths, pointOfHit: optionsY.pointOfHit, sourceRectangle, targetRectangle },  board);
+            adjust(
+                path,
+                { parallelPaths: optionsY.parallelPaths, pointOfHit: optionsY.pointOfHit, sourceRectangle, targetRectangle },
+                board
+            );
         if (resultY) {
             path = resultY;
         }
@@ -81,7 +93,7 @@ export const routeAdjust = (path: Point[], options: RouteAdjustOptions, board?:
 const adjust = (route: Point[], options: AdjustOptions, board?: PlaitBoard): null | Point[] => {
     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)
@@ -94,7 +106,7 @@ const adjust = (route: Point[], options: AdjustOptions, board?: PlaitBoard): nul
             const indexRangeInPath: number[] = [];
             const indexRangeInCorner: number[] = [];
             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);
@@ -153,7 +165,7 @@ export const getGraphPoints = (options: ElbowLineRouteOptions) => {
     const y: number[] = [];
     let result: Point[] = [];
 
-    [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);
     });
@@ -181,7 +193,7 @@ export const getGraphPoints = (options: ElbowLineRouteOptions) => {
             }
         }
     }
-    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;
@@ -193,7 +205,7 @@ export const createGraph = (points: Point[]) => {
     const graph = new PointGraph();
     const Xs: number[] = [];
     const Ys: number[] = [];
-    points.forEach(p => {
+    points.forEach((p) => {
         const x = p[0],
             y = p[1];
         if (Xs.indexOf(x) < 0) Xs.push(x);

packages/common/src/utils/image.ts

@@ -53,7 +53,7 @@ function getImageSize(file: File, defaultImageWidth: number): Promise<{ width: n
         const image = new Image();
         image.src = URL.createObjectURL(file);
 
-        image.onload = function() {
+        image.onload = function () {
             const width = defaultImageWidth;
             const height = (defaultImageWidth * image.naturalHeight) / image.naturalWidth;
             resolve(