@logicflow/core 1.2.27 → 2.0.0-beta.1

package/src/util/geometry.ts

@@ -0,0 +1,53 @@
+import LogicFlow from '../LogicFlow'
+import PointTuple = LogicFlow.PointTuple
+
+export function snapToGrid(point: number, gridSize: number) {
+  // 保证 x, y 的值为 gridSize 的整数倍
+  return gridSize * Math.round(point / gridSize) || point
+}
+
+// 获取节点偏移时，产生的偏移量。当节点基于gridSize进行了偏移后，
+// 节点上的文本可以基于此方法移动对应的距离来保持与节点相对位置不变。
+export function getGridOffset(distance: number, gridSize: number) {
+  return distance % gridSize
+}
+
+/**
+ * 多边形设置 points 后，坐标平移至原点 并 根据 width、height 缩放
+ * @param points
+ * @param width
+ * @param height
+ */
+export function normalizePolygon(
+  points?: PointTuple[],
+  width?: number,
+  height?: number,
+): PointTuple[] {
+  if (!points) return []
+
+  // 计算边界框
+  const minX = Math.min(...points.map((p) => p[0]))
+  const maxX = Math.max(...points.map((p) => p[0]))
+  const minY = Math.min(...points.map((p) => p[1]))
+  const maxY = Math.max(...points.map((p) => p[1]))
+
+  // 平移至原点
+  const dx = -minX
+  const dy = -minY
+  const translatedPoints: PointTuple[] = points.map(([x, y]) => [
+    x + dx,
+    y + dy,
+  ])
+
+  // 计算边界框的宽度和高度
+  const bboxWidth = maxX - minX
+  const bboxHeight = maxY - minY
+
+  // 计算缩放因子
+  const scaleX = width ? width / bboxWidth : 1
+  const scaleY = height ? height / bboxHeight : 1
+  const scaleFactor = Math.min(scaleX, scaleY)
+
+  // 缩放顶点
+  return translatedPoints.map(([x, y]) => [x * scaleFactor, y * scaleFactor])
+}

package/src/util/graph.ts

@@ -0,0 +1,46 @@
+import LogicFlow from '..'
+import { EditConfigModel } from 'src/model'
+
+import PointTuple = LogicFlow.PointTuple
+
+/**
+ * 判断一个点是否在指定区域
+ * @param point 当前点
+ * @param leftTopPoint 区域左上角点
+ * @param rightBottomPoint 区域的右下角点
+ */
+export const isPointInArea = (
+  [x, y]: PointTuple,
+  [leftTopX, leftTopY]: PointTuple,
+  [rightBottomX, rightBottomY]: PointTuple,
+): boolean =>
+  x > leftTopX && x < rightBottomX && y > leftTopY && y < rightBottomY
+
+/**
+ * 判断鼠标点击选中元素的时候，是否为多选
+ */
+export const isMultipleSelect = (
+  e: MouseEvent,
+  editConfigModel: EditConfigModel,
+): boolean => {
+  const { multipleSelectKey } = editConfigModel
+  let isMultiple = false
+  switch (multipleSelectKey) {
+    case 'meta':
+      isMultiple = e.metaKey
+      break
+    case 'alt':
+      isMultiple = e.altKey
+      break
+    case 'shift':
+      isMultiple = e.shiftKey
+      break
+    case 'ctrl':
+      isMultiple = e.ctrlKey // Mac上ctrl + 点击节点会触发上下文菜单，所以ctrl尽量用在非Mac系统
+      break
+    default:
+      isMultiple = false
+      break
+  }
+  return isMultiple
+}

package/src/util/index.ts

@@ -0,0 +1,16 @@
+export * from './animation'
+export * from './browser'
+export * from './compatible'
+export * from './drag'
+export * from './edge'
+export * from './geometry'
+export * from './graph'
+export * from './matrix'
+export * from './mobx'
+export * from './node'
+export * from './raf'
+export * from './sampling'
+export * from './theme'
+export * from './uuid'
+export * from './vector'
+export * from './zIndex'

package/src/util/matrix.ts

@@ -0,0 +1,129 @@
+import { Vector, Point } from './vector'
+
+export class Matrix extends Array {
+  rows: number
+  columns: number
+
+  constructor(...vectors: any[]) {
+    super(vectors.length)
+    this.fill(new Array(3))
+    vectors.forEach((v: any, index: number) => {
+      this[index] = v
+    })
+    this.columns = vectors[0].length
+    this.rows = vectors.length
+    Object.setPrototypeOf(this, Matrix.prototype)
+  }
+
+  getRow(index: number) {
+    return this[index]
+  }
+
+  getColumn(index: number) {
+    return [...this.map((row: Vector) => row[index])]
+  }
+
+  // 转置
+  transpose() {
+    const vectors: any[] = []
+    for (let i = 0; i < this.columns; i++) {
+      vectors.push(this.getColumn(i))
+    }
+    return new Matrix(...vectors)
+  }
+
+  // 叉乘
+  cross(m1: Matrix) {
+    const arr = new Array(this.rows).fill('').map((): any => [])
+    if (this.columns === m1.rows) {
+      for (let i = 0; i < this.rows; i++) {
+        const row = this.getRow(i)
+        for (let j = 0; j < m1.columns; j++) {
+          const column = m1.getColumn(j)
+          // eslint-disable-next-line max-len
+          arr[i][j] = row.reduce(
+            (prev: number, r: number, index: number) =>
+              prev + r * column[index],
+            0,
+          )
+        }
+      }
+    }
+    return new Matrix(...arr)
+  }
+
+  // 返回二维坐标（降维）
+  to2D() {
+    return this.map((item: any) => [item[0], item[1]])
+  }
+
+  toPoints() {
+    return this.map((item: any) => new Point(item[0], item[1]))
+  }
+
+  toString(): string {
+    const [a, b] = this[0]
+    const [c, d] = this[1]
+    const [e, f] = this[2]
+    return `matrix(${a} ${b} ${c} ${d} ${e} ${f})`
+  }
+
+  translate(tx: number, ty: number): Matrix {
+    return this.cross(new TranslateMatrix(tx, ty))
+  }
+
+  rotate(angle: number): Matrix {
+    return this.cross(new RotateMatrix(angle))
+  }
+
+  scale(sx: number, sy: number): Matrix {
+    return this.cross(new ScaleMatrix(sx, sy))
+  }
+}
+
+export class RotateMatrix extends Matrix {
+  constructor(theta: number) {
+    super(
+      new Vector(+Math.cos(theta).toFixed(2), +Math.sin(theta).toFixed(2), 0),
+      new Vector(-Math.sin(theta).toFixed(2), +Math.cos(theta).toFixed(2), 0),
+      new Vector(0, 0, 1),
+    )
+    Object.setPrototypeOf(this, RotateMatrix.prototype)
+  }
+
+  inverse() {
+    return this.transpose()
+  }
+}
+
+export class ScaleMatrix extends Matrix {
+  private sx: number
+  private sy: number
+
+  constructor(sx: number, sy: number) {
+    super(new Vector(sx, 0, 0), new Vector(0, sy, 0), new Vector(0, 0, 1))
+    this.sx = sx
+    this.sy = sy
+    Object.setPrototypeOf(this, ScaleMatrix.prototype)
+  }
+
+  inverse() {
+    return new ScaleMatrix(1 / this.sx, 1 / this.sy)
+  }
+}
+
+export class TranslateMatrix extends Matrix {
+  private tx: number
+  private ty: number
+
+  constructor(tx: number, ty: number) {
+    super(new Vector(1, 0, 0), new Vector(0, 1, 0), new Vector(tx, ty, 1))
+    this.tx = tx
+    this.ty = ty
+    Object.setPrototypeOf(this, TranslateMatrix.prototype)
+  }
+
+  inverse() {
+    return new TranslateMatrix(-this.tx, -this.ty)
+  }
+}

package/src/util/mobx.ts

@@ -0,0 +1,23 @@
+import {
+  action,
+  observable,
+  computed,
+  toJS,
+  isObservable,
+  configure,
+  reaction,
+  IReactionDisposer,
+} from 'mobx'
+
+configure({ isolateGlobalState: true })
+
+export {
+  action,
+  observable,
+  computed,
+  isObservable,
+  toJS,
+  configure,
+  reaction,
+  IReactionDisposer,
+}