@logicflow/core 2.0.13 → 2.0.14

package/__tests__/model/graphmodel.test.ts

@@ -1,11 +1,11 @@
-import type { NodeConfig, TextConfig } from '../../src/index';
-import { LogicFlow } from '../../src/index';
+import type { NodeConfig, TextConfig } from '../../src/index'
+import { LogicFlow } from '../../src/index'
 
-type NodeConfigTextObj = NodeConfig & { text: TextConfig };
+type NodeConfigTextObj = NodeConfig & { text: TextConfig }
 describe('graphmodel', () => {
-  const dom = document.createElement('div');
-  dom.id = 'main-graph';
-  document.body.appendChild(dom);
+  const dom = document.createElement('div')
+  dom.id = 'main-graph'
+  document.body.appendChild(dom)
   const lf = new LogicFlow({
     container: dom,
     width: 1000,
@@ -17,7 +17,7 @@ describe('graphmodel', () => {
     metaKeyMultipleSelected: true,
     grid: true,
     snapline: true,
-  });
+  })
 
   // 将node节点位置进行grid修正，同时处理node内文字的偏移量，返回一个位置修正过的复制节点NodeModel
   test('getModelAfterSnapToGrid', () => {
@@ -35,33 +35,53 @@ describe('graphmodel', () => {
           },
         },
       ],
-    };
-    lf.render(rawData);
+    }
+    lf.render(rawData)
 
-    const originNode = lf.getDataById('node1') as NodeConfigTextObj;
+    const originNode = lf.getDataById('node1') as NodeConfigTextObj
 
     // grid=true 默认 gridSize=20
-    const newNode = lf.graphModel.getModelAfterSnapToGrid(originNode) as NodeConfigTextObj;
-    expect(originNode.x - originNode.text.x).toEqual(newNode.x - newNode.text.x);
-    expect(originNode.y - originNode.text.y).toEqual(newNode.y - newNode.text.y);
-    expect(originNode.text.value).toEqual(newNode.text.value);
+    const newNode = lf.graphModel.getModelAfterSnapToGrid(
+      originNode,
+    ) as NodeConfigTextObj
+    expect(originNode.x - originNode.text.x).toEqual(newNode.x - newNode.text.x)
+    expect(originNode.y - originNode.text.y).toEqual(newNode.y - newNode.text.y)
+    expect(originNode.text.value).toEqual(newNode.text.value)
 
-    lf.graphModel.gridSize = 40;
-    const newNode1 = lf.graphModel.getModelAfterSnapToGrid(originNode) as NodeConfigTextObj;
-    expect(originNode.x - originNode.text.x).toEqual(newNode1.x - newNode1.text.x);
-    expect(originNode.y - originNode.text.y).toEqual(newNode1.y - newNode1.text.y);
-    expect(originNode.text.value).toEqual(newNode1.text.value);
+    lf.graphModel.gridSize = 40
+    const newNode1 = lf.graphModel.getModelAfterSnapToGrid(
+      originNode,
+    ) as NodeConfigTextObj
+    expect(originNode.x - originNode.text.x).toEqual(
+      newNode1.x - newNode1.text.x,
+    )
+    expect(originNode.y - originNode.text.y).toEqual(
+      newNode1.y - newNode1.text.y,
+    )
+    expect(originNode.text.value).toEqual(newNode1.text.value)
 
-    lf.graphModel.gridSize = 1;
-    const newNode2 = lf.graphModel.getModelAfterSnapToGrid(originNode) as NodeConfigTextObj;
-    expect(originNode.x - originNode.text.x).toEqual(newNode2.x - newNode2.text.x);
-    expect(originNode.y - originNode.text.y).toEqual(newNode2.y - newNode2.text.y);
-    expect(originNode.text.value).toEqual(newNode2.text.value);
+    lf.graphModel.gridSize = 1
+    const newNode2 = lf.graphModel.getModelAfterSnapToGrid(
+      originNode,
+    ) as NodeConfigTextObj
+    expect(originNode.x - originNode.text.x).toEqual(
+      newNode2.x - newNode2.text.x,
+    )
+    expect(originNode.y - originNode.text.y).toEqual(
+      newNode2.y - newNode2.text.y,
+    )
+    expect(originNode.text.value).toEqual(newNode2.text.value)
 
-    lf.graphModel.gridSize = 17;
-    const newNode3 = lf.graphModel.getModelAfterSnapToGrid(originNode) as NodeConfigTextObj;
-    expect(originNode.x - originNode.text.x).toEqual(newNode3.x - newNode3.text.x);
-    expect(originNode.y - originNode.text.y).toEqual(newNode3.y - newNode3.text.y);
-    expect(originNode.text.value).toEqual(newNode3.text.value);
-  });
-});
+    lf.graphModel.gridSize = 17
+    const newNode3 = lf.graphModel.getModelAfterSnapToGrid(
+      originNode,
+    ) as NodeConfigTextObj
+    expect(originNode.x - originNode.text.x).toEqual(
+      newNode3.x - newNode3.text.x,
+    )
+    expect(originNode.y - originNode.text.y).toEqual(
+      newNode3.y - newNode3.text.y,
+    )
+    expect(originNode.text.value).toEqual(newNode3.text.value)
+  })
+})

package/__tests__/util/compatible.test.ts

@@ -1,4 +1,4 @@
-import { formatData } from '../../src/util/compatible';
+import { formatData } from '../../src/util/compatible'
 
 describe('util/compatible', () => {
   test('formatData', () => {
@@ -22,7 +22,7 @@ describe('util/compatible', () => {
         c: null,
         d: [],
       },
-    };
+    }
     expect(formatData(data)).toEqual({
       nodes: [
         {
@@ -43,6 +43,6 @@ describe('util/compatible', () => {
         c: null,
         d: [],
       },
-    });
-  });
-});
+    })
+  })
+})

package/__tests__/util/geometry.test.ts

@@ -1,14 +1,14 @@
-import { snapToGrid, getGridOffset } from '../../src/util';
+import { snapToGrid, getGridOffset } from '../../src/util'
 
 describe('util/geometry', () => {
   test('snapToGrid', () => {
-    const point = 2.5;
-    const grid = 1.5;
-    expect(snapToGrid(point, grid) - 3 < Number.EPSILON).toBeTruthy();
-  });
+    const point = 2.5
+    const grid = 1.5
+    expect(snapToGrid(point, grid) - 3 < Number.EPSILON).toBeTruthy()
+  })
   test('getGridOffset', () => {
-    const distance = 3;
-    const grid = 1.5;
-    expect(getGridOffset(distance, grid) - 2 < Number.EPSILON).toBeTruthy();
-  });
-});
+    const distance = 3
+    const grid = 1.5
+    expect(getGridOffset(distance, grid) - 2 < Number.EPSILON).toBeTruthy()
+  })
+})

package/__tests__/util/graph.test.ts

@@ -1,16 +1,16 @@
-import { isPointInArea } from '../../src/util/graph';
+import { isPointInArea } from '../../src/util/graph'
 
 describe('util/graph', () => {
   test('if element is in an area, truthy', () => {
-    const point: [number, number] = [1, 1];
-    const leftTopPoint: [number, number] = [0, 0];
-    const rightBottomPoint: [number, number] = [2, 2];
-    expect(isPointInArea(point, leftTopPoint, rightBottomPoint)).toBeTruthy();
-  });
+    const point: [number, number] = [1, 1]
+    const leftTopPoint: [number, number] = [0, 0]
+    const rightBottomPoint: [number, number] = [2, 2]
+    expect(isPointInArea(point, leftTopPoint, rightBottomPoint)).toBeTruthy()
+  })
   test('if element is in an area, falsy', () => {
-    const point: [number, number] = [1, 1];
-    const leftTopPoint: [number, number] = [2, 2];
-    const rightBottomPoint: [number, number] = [4, 4];
-    expect(isPointInArea(point, leftTopPoint, rightBottomPoint)).toBeFalsy();
-  });
-});
+    const point: [number, number] = [1, 1]
+    const leftTopPoint: [number, number] = [2, 2]
+    const rightBottomPoint: [number, number] = [4, 4]
+    expect(isPointInArea(point, leftTopPoint, rightBottomPoint)).toBeFalsy()
+  })
+})

package/__tests__/util/matrix.test.ts

@@ -1,41 +1,41 @@
-import { Matrix } from '../../src/util/matrix';
+import { Matrix } from '../../src/util/matrix'
 
 describe('util/matrix', () => {
   test('construct', () => {
-    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9]);
-    expect(m[0]).toEqual([1, 2, 3]);
-    expect(m[1]).toEqual([4, 5, 6]);
-    expect(m[2]).toEqual([7, 8, 9]);
-  });
+    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9])
+    expect(m[0]).toEqual([1, 2, 3])
+    expect(m[1]).toEqual([4, 5, 6])
+    expect(m[2]).toEqual([7, 8, 9])
+  })
   test('cross', () => {
-    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9]);
-    const n = new Matrix([9, 8, 7], [6, 5, 4], [3, 2, 1]);
+    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9])
+    const n = new Matrix([9, 8, 7], [6, 5, 4], [3, 2, 1])
     expect(m.cross(n)).toEqual(
       new Matrix([30, 24, 18], [84, 69, 54], [138, 114, 90]),
-    );
-  });
+    )
+  })
   test('transpose', () => {
-    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9]);
-    expect(m.transpose()).toEqual(new Matrix([1, 4, 7], [2, 5, 8], [3, 6, 9]));
-  });
+    const m = new Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9])
+    expect(m.transpose()).toEqual(new Matrix([1, 4, 7], [2, 5, 8], [3, 6, 9]))
+  })
   test('translate', () => {
-    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1]);
+    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1])
     expect(m.translate(2, 3)).toEqual(
       new Matrix([1, 0, 0], [0, 1, 0], [2, 3, 1]),
-    );
-  });
+    )
+  })
   test('rotate', () => {
-    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1]);
+    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1])
     expect(m.rotate(Math.PI / 2)).toEqual(
       new Matrix([0, 1, 0], [-1, 0, 0], [0, 0, 1]),
-    );
-  });
+    )
+  })
   test('scale', () => {
-    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1]);
-    expect(m.scale(2, 3)).toEqual(new Matrix([2, 0, 0], [0, 3, 0], [0, 0, 1]));
-  });
+    const m = new Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1])
+    expect(m.scale(2, 3)).toEqual(new Matrix([2, 0, 0], [0, 3, 0], [0, 0, 1]))
+  })
   test('toString', () => {
-    const m = new Matrix([1, 0, 0], [0, 1, 0], [1, 1, 1]);
-    expect(m.toString()).toEqual('matrix(1 0 0 1 1 1)');
-  });
-});
+    const m = new Matrix([1, 0, 0], [0, 1, 0], [1, 1, 1])
+    expect(m.toString()).toEqual('matrix(1 0 0 1 1 1)')
+  })
+})

package/__tests__/util/node.test.ts

@@ -3,66 +3,66 @@ import {
   isInNode,
   getCrossPointWithCircle,
   getCrossPointWithEllipse,
-} from '../../src/util/node';
+} from '../../src/util/node'
 
 describe('util/node', () => {
   test('get closest anchor', () => {
-    const position = { x: 0, y: 0 };
+    const position = { x: 0, y: 0 }
     const node = {
       anchors: [
         { x: 0, y: 0, id: '1' },
         { x: 1, y: 1, id: '2' },
         { x: 2, y: 2, id: '3' },
       ],
-    };
+    }
     expect(getClosestAnchor(position, node)).toEqual({
       anchor: { x: 0, y: 0, id: '1' },
       index: 0,
-    });
-  });
+    })
+  })
   test('is point inside the node', () => {
-    const position1 = { x: 0, y: 0 };
-    const position2 = { x: 110, y: 110 };
+    const position1 = { x: 0, y: 0 }
+    const position2 = { x: 110, y: 110 }
     const node = {
       x: 0,
       y: 0,
       width: 100,
       height: 100,
-    };
-    expect(isInNode(position1, node)).toBeTruthy();
-    expect(isInNode(position2, node)).toBeFalsy();
-  });
+    }
+    expect(isInNode(position1, node)).toBeTruthy()
+    expect(isInNode(position2, node)).toBeFalsy()
+  })
   test('get cross point with circle', () => {
-    const position = { x: 0, y: 0 };
+    const position = { x: 0, y: 0 }
     const node = {
       x: 0,
       y: 0,
       r: 10,
-    };
+    }
     expect(getCrossPointWithCircle(position, 'horizontal', node)).toEqual({
       x: 10,
       y: 0,
-    });
+    })
     expect(getCrossPointWithCircle(position, 'vertical', node)).toEqual({
       x: 0,
       y: 10,
-    });
-  });
+    })
+  })
   test('get cross point with ellipse', () => {
-    const position = { x: 0, y: 0 };
+    const position = { x: 0, y: 0 }
     const node = {
       x: 0,
       y: 0,
       rx: 10,
       ry: 5,
-    };
+    }
     expect(getCrossPointWithEllipse(position, 'horizontal', node)).toEqual({
       x: 10,
       y: 0,
-    });
+    })
     expect(getCrossPointWithEllipse(position, 'vertical', node)).toEqual({
       x: 0,
       y: 5,
-    });
-  });
-});
+    })
+  })
+})

package/__tests__/util/sampling.test.ts

@@ -1,16 +1,12 @@
-import {
-  degrees,
-  getThetaOfVector,
-  Vector,
-} from '../../src/util';
+import { degrees, getThetaOfVector, Vector } from '../../src/util'
 
 describe('util/sampling', () => {
   test('degrees', () => {
-    expect(degrees(1)).toBe(57.29577951308232);
-  });
+    expect(degrees(1)).toBe(57.29577951308232)
+  })
   test('getThetaOfVector', () => {
     expect(
       getThetaOfVector(new Vector(1, 1)) - 45 < Number.EPSILON,
-    ).toBeTruthy();
-  });
-});
+    ).toBeTruthy()
+  })
+})

package/__tests__/util/vector.test.ts

@@ -1,50 +1,50 @@
-import { Vector } from '../../src/util/vector';
+import { Vector } from '../../src/util/vector'
 
 describe('util/vector', () => {
   test('construct', () => {
-    const v = new Vector(1, 2);
-    expect(v.x).toEqual(1);
-    expect(v[0]).toEqual(1);
+    const v = new Vector(1, 2)
+    expect(v.x).toEqual(1)
+    expect(v[0]).toEqual(1)
 
-    expect(v.y).toEqual(2);
-    expect(v[1]).toEqual(2);
+    expect(v.y).toEqual(2)
+    expect(v[1]).toEqual(2)
 
-    expect(v.z).toEqual(0);
-    expect(v[2]).toEqual(0);
-  });
+    expect(v.z).toEqual(0)
+    expect(v[2]).toEqual(0)
+  })
   test('add', () => {
-    const v = new Vector(1, 2);
-    const v1 = new Vector(3, 4);
-    expect(v.add(v1)).toEqual(new Vector(4, 6));
-  });
+    const v = new Vector(1, 2)
+    const v1 = new Vector(3, 4)
+    expect(v.add(v1)).toEqual(new Vector(4, 6))
+  })
   test('subtract', () => {
-    const v = new Vector(1, 2);
-    const v1 = new Vector(3, 4);
-    expect(v.subtract(v1)).toEqual(new Vector(-2, -2));
-  });
+    const v = new Vector(1, 2)
+    const v1 = new Vector(3, 4)
+    expect(v.subtract(v1)).toEqual(new Vector(-2, -2))
+  })
   test('dot', () => {
-    const v = new Vector(1, 2);
-    const v1 = new Vector(3, 4);
-    expect(v.dot(v1)).toEqual(11);
-  });
+    const v = new Vector(1, 2)
+    const v1 = new Vector(3, 4)
+    expect(v.dot(v1)).toEqual(11)
+  })
   test('cross', () => {
-    const v = new Vector(1, 2);
-    const v1 = new Vector(3, 4);
-    expect(v.cross(v1)).toEqual(new Vector(0, 0, -2));
-  });
+    const v = new Vector(1, 2)
+    const v1 = new Vector(3, 4)
+    expect(v.cross(v1)).toEqual(new Vector(0, 0, -2))
+  })
   test('getLength', () => {
-    const v = new Vector(1, 2);
-    expect(v.getLength()).toEqual(Math.sqrt(5));
-  });
+    const v = new Vector(1, 2)
+    expect(v.getLength()).toEqual(Math.sqrt(5))
+  })
   test('normalize', () => {
-    const v = new Vector(1, 2);
+    const v = new Vector(1, 2)
     expect(v.normalize()).toEqual(
       new Vector(1 / Math.sqrt(5), 2 / Math.sqrt(5)),
-    );
-  });
+    )
+  })
   test('angle', () => {
-    const v = new Vector(1, 1);
-    const v1 = new Vector(0, 1);
-    expect(v.angle(v1) - Math.PI / 4 < Number.EPSILON).toBeTruthy();
-  });
-});
+    const v = new Vector(1, 1)
+    const v1 = new Vector(0, 1)
+    expect(v.angle(v1) - Math.PI / 4 < Number.EPSILON).toBeTruthy()
+  })
+})

package/__tests__/util/zIndex.test.ts

@@ -1,10 +1,10 @@
-import { getZIndex, getMinIndex } from '../../src/util/zIndex';
+import { getZIndex, getMinIndex } from '../../src/util/zIndex'
 
 describe('util/zIndex', () => {
   test('getZIndex', () => {
-    expect(getZIndex()).toBe(1001);
-  });
+    expect(getZIndex()).toBe(1001)
+  })
   test('getMinIndex', () => {
-    expect(getMinIndex()).toBe(998);
-  });
-});
+    expect(getMinIndex()).toBe(998)
+  })
+})