@logicflow/core 2.2.0-alpha.7 → 2.2.1

package/__tests__/algorithm/egde.test.ts

@@ -1,131 +0,0 @@
-import { getCrossPointOfLine, isInSegment } from '../../src/algorithm/edge'
-
-describe('algorithm/edge', () => {
-  // one intersection
-  test('one intersection', () => {
-    const line1 = [
-      {
-        x: 0,
-        y: 0,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    const line2 = [
-      {
-        x: 10,
-        y: 0,
-      },
-      {
-        x: 0,
-        y: 10,
-      },
-    ]
-    expect(
-      getCrossPointOfLine(line1[0], line1[1], line2[0], line2[1]),
-    ).toBeTruthy()
-  })
-  // multiple intersection
-  test('multiple intersection', () => {
-    const line1 = [
-      {
-        x: 0,
-        y: 0,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    const line2 = [
-      {
-        x: 0,
-        y: 0,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    expect(
-      getCrossPointOfLine(line1[0], line1[1], line2[0], line2[1]),
-    ).toBeFalsy()
-  })
-  // no intersection
-  test('intersection', () => {
-    const line1 = [
-      {
-        x: 0,
-        y: 0,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    const line2 = [
-      {
-        x: 10,
-        y: 0,
-      },
-      {
-        x: 20,
-        y: 10,
-      },
-    ]
-    expect(
-      getCrossPointOfLine(line1[0], line1[1], line2[0], line2[1]),
-    ).toBeFalsy()
-  })
-
-  test('in segment', () => {
-    const point = {
-      x: 0,
-      y: 0,
-    }
-    const line1 = [
-      {
-        x: -10,
-        y: -10,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    const line2 = [
-      {
-        x: -10,
-        y: 10,
-      },
-      {
-        x: 10,
-        y: -10,
-      },
-    ]
-    expect(isInSegment(point, line1[0], line1[1])).toBeTruthy()
-    expect(isInSegment(point, line1[1], line1[0])).toBeTruthy()
-    expect(isInSegment(point, line2[0], line2[1])).toBeTruthy()
-    expect(isInSegment(point, line2[1], line2[0])).toBeTruthy()
-  })
-  // not in segment
-  test('not in segment', () => {
-    const point = {
-      x: 10,
-      y: 0,
-    }
-    const line = [
-      {
-        x: -10,
-        y: -10,
-      },
-      {
-        x: 10,
-        y: 10,
-      },
-    ]
-    expect(isInSegment(point, line[0], line[1])).toBeFalsy()
-  })
-})

package/__tests__/algorithm/index.test.ts

@@ -1,74 +0,0 @@
-import { getVerticalPointOfLine } from '../../src/algorithm'
-
-describe('algorithm/index', () => {
-  test('getVerticalPointOfLine', () => {
-    const config1 = {
-      start: {
-        x: 0,
-        y: 0,
-      },
-      end: {
-        x: 0,
-        y: 10,
-      },
-      offset: 3,
-      verticalLength: 3,
-      type: 'start',
-    }
-
-    const config2 = {
-      start: {
-        x: 0,
-        y: 0,
-      },
-      end: {
-        x: 10,
-        y: 0,
-      },
-      offset: 3,
-      verticalLength: 3,
-      type: 'end',
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const config3 = {
-      start: {
-        x: 10,
-        y: 10,
-      },
-      end: {
-        x: 0,
-        y: 0,
-      },
-      offset: 3,
-      verticalLength: 3,
-      type: 'start',
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const config4 = {
-      start: {
-        x: 10,
-        y: 10,
-      },
-      end: {
-        x: 0,
-        y: 0,
-      },
-      offset: 3,
-      verticalLength: 3,
-      type: 'end',
-    }
-    const res1 = getVerticalPointOfLine(config1)
-    expect(Math.abs(res1.leftX) - 5 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res1.leftY) - 3 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res1.rightX) - 5 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res1.rightY) - 3 < Number.EPSILON).toBeTruthy()
-
-    const res2 = getVerticalPointOfLine(config2)
-    expect(Math.abs(res2.leftX) - 7 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res2.leftY) - 3 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res2.rightX) - 7 < Number.EPSILON).toBeTruthy()
-    expect(Math.abs(res2.rightY) - 3 < Number.EPSILON).toBeTruthy()
-  })
-})

package/__tests__/algorithm/outline.test.ts

@@ -1,43 +0,0 @@
-import { getEdgeOutline } from '../../src/algorithm/outline'
-
-describe('algorithm/outline', () => {
-  test('get edge outline', () => {
-    const edge1 = {
-      modelType: 'line-edge',
-      startPoint: {
-        x: 0,
-        y: 0,
-      },
-      endPoint: {
-        x: 10,
-        y: 10,
-      },
-    }
-    expect(getEdgeOutline(edge1)).toEqual({
-      x: -5,
-      y: -5,
-      x1: 15,
-      y1: 15,
-    })
-    const edge2 = {
-      modelType: 'polyline-edge',
-      points: '0,0 10,10',
-    }
-    expect(getEdgeOutline(edge2)).toEqual({
-      x: -4,
-      y: -4,
-      x1: 14,
-      y1: 14,
-    })
-    const edge3 = {
-      modelType: 'bezier-edge',
-      path: 'M 270 195C 370 195,305 290,405 290',
-    }
-    expect(getEdgeOutline(edge3)).toEqual({
-      x: 266,
-      y: 191,
-      x1: 409,
-      y1: 294,
-    })
-  })
-})

package/__tests__/bugs/1545-spec.test.ts

@@ -1,42 +0,0 @@
-import LogicFlow from '../../src/index'
-
-import NodeConfig = LogicFlow.NodeConfig
-import TextConfig = LogicFlow.TextConfig
-
-type NodeConfigTextObj = NodeConfig & {
-  text: TextConfig
-}
-describe('#1545', () => {
-  const dom = document.createElement('div')
-  dom.id = 'main-graph'
-  document.body.appendChild(dom)
-  const lf = new LogicFlow({
-    container: dom,
-    width: 1000,
-    height: 1000,
-    grid: true,
-  })
-
-  it('clone node text pos should snap to grid', () => {
-    lf.render({
-      nodes: [
-        {
-          id: 'node_id_1',
-          type: 'rect',
-          x: 300,
-          y: 300,
-          text: {
-            x: 32,
-            y: 19,
-            value: '文本1',
-          },
-        },
-      ],
-    })
-    const originNode = lf.getDataById('node_id_1') as NodeConfigTextObj
-    const newNode = lf.cloneNode('node_id_1') 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)
-  })
-})

package/__tests__/event/event.test.ts

@@ -1,22 +0,0 @@
-import EventEmitter from '../../src/event/eventEmitter'
-
-describe('event/eventEmitter', () => {
-  const em = new EventEmitter()
-  test('event emitter', () => {
-    const fn = jest.fn()
-    em.on('test', fn)
-    em.emit('test', { a: 1 })
-    expect(fn).toBeCalledWith({ a: 1 })
-    em.off('test', fn)
-    em.emit('test', { a: 1 })
-    expect(fn).toBeCalledTimes(1)
-
-    em.once('test1', fn)
-    em.emit('test1', { a: 1 })
-    expect(fn).toBeCalledTimes(2)
-    em.once('test1', fn)
-    em.emit('test1', { a: 1 })
-    const test1Events = em.getEvents().test1
-    expect(test1Events).toBeUndefined()
-  })
-})

package/__tests__/history/history.test.ts

@@ -1,28 +0,0 @@
-import History from '../../src/history/History'
-import EventEmitter from '../../src/event/eventEmitter'
-
-describe('history', () => {
-  const event = new EventEmitter()
-  const history = new History(event)
-  expect(history).toBeDefined()
-  test('add', () => {
-    history.add(1)
-    expect(history.undos).toEqual([1])
-    expect(history.redos).toEqual([])
-  })
-  test('undo', () => {
-    history.add(1)
-    history.add(2)
-    history.undo()
-    expect(history.undos).toEqual([])
-    expect(history.redos).toEqual([2])
-  })
-  test('redo', () => {
-    history.add(1)
-    history.add(2)
-    history.undo()
-    history.redo()
-    expect(history.undos).toEqual([])
-    expect(history.redos).toEqual([])
-  })
-})