@formily-design/shared 1.0.0 → 1.0.1

package/src/coordinate.ts

@@ -1,633 +0,0 @@
-import { isValidNumber } from './types'
-export interface IPoint {
-  x: number
-  y: number
-}
-
-export interface ISize {
-  width: number
-  height: number
-}
-
-export interface ILineSegment {
-  start: IPoint
-  end: IPoint
-}
-
-export interface IRectEdgeLines {
-  v: ILineSegment[]
-  h: ILineSegment[]
-}
-
-export function isRect(rect: any): rect is IRect {
-  return rect?.x && rect?.y && rect?.width && rect?.height
-}
-
-export function isPoint(val: any): val is IPoint {
-  return isValidNumber(val?.x) && isValidNumber(val?.y)
-}
-
-export function isLineSegment(val: any): val is ILineSegment {
-  return isPoint(val?.start) && isPoint(val?.end)
-}
-
-export class Point implements IPoint {
-  x: number
-  y: number
-  constructor(x: number, y: number) {
-    this.x = x
-    this.y = y
-  }
-}
-
-export class Rect implements IRect {
-  x = 0
-  y = 0
-  width = 0
-  height = 0
-  constructor(x: number, y: number, width: number, height: number) {
-    this.x = x
-    this.y = y
-    this.width = width
-    this.height = height
-  }
-
-  get left() {
-    return this.x
-  }
-
-  get right() {
-    return this.x + this.width
-  }
-
-  get top() {
-    return this.y
-  }
-
-  get bottom() {
-    return this.y + this.height
-  }
-}
-
-export class LineSegment {
-  start: IPoint
-  end: IPoint
-  constructor(start: IPoint, end: IPoint) {
-    this.start = { ...start }
-    this.end = { ...end }
-  }
-}
-
-export interface IRect {
-  x: number
-  y: number
-  width: number
-  height: number
-}
-
-export enum RectQuadrant {
-  Inner1 = 'I1', //内部第一象限
-  Inner2 = 'I2', //内部第二象限
-  Inner3 = 'I3', //内部第三象限
-  Inner4 = 'I4', //内部第四象限
-  Outer1 = 'O1', //内部第五象限
-  Outer2 = 'O2', //内部第六象限
-  Outer3 = 'O3', //内部第七象限
-  Outer4 = 'O4', //内部第八象限
-}
-
-export interface IPointToRectRelative {
-  quadrant: RectQuadrant
-  distance: number
-}
-
-export function isPointInRect(point: IPoint, rect: IRect, sensitive = true) {
-  const boundSensor = (value: number) => {
-    if (!sensitive) return 0
-    const sensor = value * 0.1
-    if (sensor > 20) return 20
-    if (sensor < 10) return 10
-    return sensor
-  }
-
-  return (
-    point.x >= rect.x + boundSensor(rect.width) &&
-    point.x <= rect.x + rect.width - boundSensor(rect.width) &&
-    point.y >= rect.y + boundSensor(rect.height) &&
-    point.y <= rect.y + rect.height - boundSensor(rect.height)
-  )
-}
-
-export function isEqualRect(target: IRect, source: IRect) {
-  return (
-    target?.x === source?.x &&
-    target.y === source.y &&
-    target.width === source.width &&
-    target.height === source.height
-  )
-}
-
-export function getRectPoints(source: IRect) {
-  const p1 = new Point(source.x, source.y)
-  const p2 = new Point(source.x + source.width, source.y)
-  const p3 = new Point(source.x + source.width, source.y + source.height)
-  const p4 = new Point(source.x, source.y + source.height)
-  return [p1, p2, p3, p4]
-}
-
-export function isRectInRect(target: IRect, source: IRect) {
-  const [p1, p2, p3, p4] = getRectPoints(target)
-  return (
-    isPointInRect(p1, source, false) &&
-    isPointInRect(p2, source, false) &&
-    isPointInRect(p3, source, false) &&
-    isPointInRect(p4, source, false)
-  )
-}
-
-export function isCrossRectInRect(target: IRect, source: IRect) {
-  const targetCenterPoint = new Point(
-    target.x + target.width / 2,
-    target.y + target.height / 2
-  )
-  const sourceCenterPoint = new Point(
-    source.x + source.width / 2,
-    source.y + source.height / 2
-  )
-  return (
-    Math.abs(targetCenterPoint.x - sourceCenterPoint.x) <=
-      target.width / 2 + source.width / 2 &&
-    Math.abs(targetCenterPoint.y - sourceCenterPoint.y) <=
-      target.height / 2 + source.height / 2
-  )
-}
-
-/**
- * 计算点在矩形的哪个象限
- * @param point
- * @param rect
- */
-export function calcQuadrantOfPointToRect(point: IPoint, rect: IRect) {
-  const isInner = isPointInRect(point, rect)
-  if (point.x <= rect.x + rect.width / 2) {
-    if (point.y <= rect.y + rect.height / 2) {
-      if (isInner) {
-        return RectQuadrant.Inner1
-      } else {
-        return RectQuadrant.Outer1
-      }
-    } else {
-      if (isInner) {
-        return RectQuadrant.Inner4
-      } else {
-        return RectQuadrant.Outer4
-      }
-    }
-  } else {
-    if (point.y <= rect.y + rect.height / 2) {
-      if (isInner) {
-        return RectQuadrant.Inner2
-      } else {
-        return RectQuadrant.Outer2
-      }
-    } else {
-      if (isInner) {
-        return RectQuadrant.Inner3
-      } else {
-        return RectQuadrant.Outer3
-      }
-    }
-  }
-}
-
-export function calcDistanceOfPointToRect(point: IPoint, rect: IRect) {
-  let minX = Math.min(
-    Math.abs(point.x - rect.x),
-    Math.abs(point.x - (rect.x + rect.width))
-  )
-  let minY = Math.min(
-    Math.abs(point.y - rect.y),
-    Math.abs(point.y - (rect.y + rect.height))
-  )
-  if (point.x >= rect.x && point.x <= rect.x + rect.width) {
-    minX = 0
-  }
-  if (point.y >= rect.y && point.y <= rect.y + rect.height) {
-    minY = 0
-  }
-
-  return Math.sqrt(minX ** 2 + minY ** 2)
-}
-
-export function calcDistancePointToEdge(point: IPoint, rect: IRect) {
-  const distanceTop = Math.abs(point.y - rect.y)
-  const distanceBottom = Math.abs(point.y - (rect.y + rect.height))
-  const distanceLeft = Math.abs(point.x - rect.x)
-  const distanceRight = Math.abs(point.x - (rect.x + rect.width))
-  return Math.min(distanceTop, distanceBottom, distanceLeft, distanceRight)
-}
-
-export function isNearAfter(point: IPoint, rect: IRect, inline = false) {
-  if (inline) {
-    return (
-      Math.abs(point.x - rect.x) + Math.abs(point.y - rect.y) >
-      Math.abs(point.x - (rect.x + rect.width)) +
-        Math.abs(point.y - (rect.y + rect.height))
-    )
-  }
-  return Math.abs(point.y - rect.y) > Math.abs(point.y - (rect.y + rect.height))
-}
-
-/**
- * 计算点鱼矩形的相对位置信息
- * @param point
- * @param rect
- */
-export function calcRelativeOfPointToRect(
-  point: IPoint,
-  rect: IRect
-): IPointToRectRelative {
-  const distance = calcDistanceOfPointToRect(point, rect)
-  const quadrant = calcQuadrantOfPointToRect(point, rect)
-  return {
-    quadrant,
-    distance,
-  }
-}
-
-export function calcBoundingRect(rects: IRect[]) {
-  if (!rects?.length) return
-  if (rects?.length === 1 && !rects[0]) return
-  let minTop = Infinity
-  let maxBottom = -Infinity
-  let minLeft = Infinity
-  let maxRight = -Infinity
-  rects.forEach((item) => {
-    const rect = new Rect(item.x, item.y, item.width, item.height)
-    if (rect.top <= minTop) {
-      minTop = rect.top
-    }
-    if (rect.bottom >= maxBottom) {
-      maxBottom = rect.bottom
-    }
-    if (rect.left <= minLeft) {
-      minLeft = rect.left
-    }
-    if (rect.right >= maxRight) {
-      maxRight = rect.right
-    }
-  })
-  return new Rect(minLeft, minTop, maxRight - minLeft, maxBottom - minTop)
-}
-
-export function calcRectByStartEndPoint(
-  startPoint: IPoint,
-  endPoint: IPoint,
-  scrollX = 0,
-  scrollY = 0
-) {
-  let drawStartX = 0,
-    drawStartY = 0
-  if (
-    endPoint.x + scrollX >= startPoint.x &&
-    endPoint.y + scrollY >= startPoint.y
-  ) {
-    //4象限
-    drawStartX = startPoint.x
-    drawStartY = startPoint.y
-    return new Rect(
-      drawStartX - scrollX,
-      drawStartY - scrollY,
-      Math.abs(endPoint.x - startPoint.x + scrollX),
-      Math.abs(endPoint.y - startPoint.y + scrollY)
-    )
-  } else if (
-    endPoint.x + scrollX < startPoint.x &&
-    endPoint.y + scrollY < startPoint.y
-  ) {
-    //1象限
-    drawStartX = endPoint.x
-    drawStartY = endPoint.y
-    return new Rect(
-      drawStartX,
-      drawStartY,
-      Math.abs(endPoint.x - startPoint.x + scrollX),
-      Math.abs(endPoint.y - startPoint.y + scrollY)
-    )
-  } else if (
-    endPoint.x + scrollX < startPoint.x &&
-    endPoint.y + scrollY >= startPoint.y
-  ) {
-    //3象限
-    drawStartX = endPoint.x
-    drawStartY = startPoint.y
-    return new Rect(
-      drawStartX - scrollX,
-      drawStartY - scrollY,
-      Math.abs(endPoint.x - startPoint.x + scrollX),
-      Math.abs(endPoint.y - startPoint.y + scrollY)
-    )
-  } else {
-    //2象限
-    drawStartX = startPoint.x
-    drawStartY = endPoint.y
-    return new Rect(
-      drawStartX,
-      drawStartY,
-      Math.abs(endPoint.x - startPoint.x + scrollX),
-      Math.abs(endPoint.y - startPoint.y + scrollY)
-    )
-  }
-}
-
-export function calcEdgeLinesOfRect(rect: IRect): IRectEdgeLines {
-  return {
-    v: [
-      new LineSegment(
-        new Point(rect.x, rect.y),
-        new Point(rect.x, rect.y + rect.height)
-      ),
-      new LineSegment(
-        new Point(rect.x + rect.width / 2, rect.y),
-        new Point(rect.x + rect.width / 2, rect.y + rect.height)
-      ),
-      new LineSegment(
-        new Point(rect.x + rect.width, rect.y),
-        new Point(rect.x + rect.width, rect.y + rect.height)
-      ),
-    ],
-    h: [
-      new LineSegment(
-        new Point(rect.x, rect.y),
-        new Point(rect.x + rect.width, rect.y)
-      ),
-      new LineSegment(
-        new Point(rect.x, rect.y + rect.height / 2),
-        new Point(rect.x + rect.width, rect.y + rect.height / 2)
-      ),
-      new LineSegment(
-        new Point(rect.x, rect.y + rect.height),
-        new Point(rect.x + rect.width, rect.y + rect.height)
-      ),
-    ],
-  }
-}
-
-export function calcRectOfAxisLineSegment(line: ILineSegment) {
-  if (!isLineSegment(line)) return
-  const isXAxis = line.start.x === line.end.x
-  return new Rect(
-    line.start.x,
-    line.start.y,
-    isXAxis ? 0 : line.end.x - line.start.x,
-    isXAxis ? line.end.y - line.start.y : 0
-  )
-}
-
-export function calcSpaceBlockOfRect(
-  target: IRect,
-  source: IRect,
-  type?: string
-) {
-  const targetRect = new Rect(target.x, target.y, target.width, target.height)
-  const sourceRect = new Rect(source.x, source.y, source.width, source.height)
-  if (sourceRect.bottom < targetRect.top && sourceRect.left > targetRect.right)
-    return
-  if (sourceRect.top > targetRect.bottom && sourceRect.left > targetRect.right)
-    return
-  if (sourceRect.bottom < targetRect.top && sourceRect.right < targetRect.left)
-    return
-  if (sourceRect.top > targetRect.bottom && sourceRect.right < targetRect.left)
-    return
-  if (sourceRect.bottom < targetRect.top) {
-    const distance = targetRect.top - sourceRect.bottom
-    const left = Math.min(sourceRect.left, targetRect.left)
-    const right = Math.max(sourceRect.right, targetRect.right)
-    if (type && type !== 'top') return
-    return {
-      type: 'top',
-      distance,
-      rect: new Rect(left, sourceRect.bottom, right - left, distance),
-    }
-  } else if (sourceRect.top > targetRect.bottom) {
-    const distance = sourceRect.top - targetRect.bottom
-    const left = Math.min(sourceRect.left, targetRect.left)
-    const right = Math.max(sourceRect.right, targetRect.right)
-    if (type && type !== 'bottom') return
-    return {
-      type: 'bottom',
-      distance,
-      rect: new Rect(left, targetRect.bottom, right - left, distance),
-    }
-  } else if (sourceRect.right < targetRect.left) {
-    const distance = targetRect.left - sourceRect.right
-    const top = Math.min(sourceRect.top, targetRect.top)
-    const bottom = Math.max(sourceRect.bottom, targetRect.bottom)
-    if (type && type !== 'left') return
-    return {
-      type: 'left',
-      distance,
-      rect: new Rect(sourceRect.right, top, distance, bottom - top),
-    }
-  } else if (sourceRect.left > targetRect.right) {
-    const distance = sourceRect.left - targetRect.right
-    const top = Math.min(sourceRect.top, targetRect.top)
-    const bottom = Math.max(sourceRect.bottom, targetRect.bottom)
-    if (type && type !== 'right') return
-    return {
-      type: 'right',
-      distance,
-      rect: new Rect(targetRect.right, top, distance, bottom - top),
-    }
-  }
-}
-
-export function calcExtendsLineSegmentOfRect(
-  targetRect: Rect,
-  referRect: Rect
-) {
-  if (
-    referRect.right < targetRect.right &&
-    targetRect.left <= referRect.right
-  ) {
-    //右侧
-    if (referRect.bottom < targetRect.top) {
-      //上方
-      return {
-        start: { x: referRect.right, y: referRect.bottom },
-        end: { x: targetRect.right, y: referRect.bottom },
-      }
-    } else if (referRect.top > targetRect.bottom) {
-      //下方
-      return {
-        start: { x: referRect.right, y: referRect.top },
-        end: { x: targetRect.right, y: referRect.top },
-      }
-    }
-  } else if (
-    referRect.left > targetRect.left &&
-    targetRect.right >= referRect.left
-  ) {
-    //左侧
-    if (referRect.bottom < targetRect.top) {
-      //上方
-      return {
-        start: { x: targetRect.left, y: referRect.bottom },
-        end: { x: referRect.left, y: referRect.bottom },
-      }
-    } else if (referRect.top > targetRect.bottom) {
-      //下方
-      return {
-        start: { x: targetRect.left, y: referRect.top },
-        end: { x: referRect.left, y: referRect.top },
-      }
-    }
-  }
-  if (referRect.top < targetRect.top && targetRect.bottom >= referRect.top) {
-    //refer在上方
-    if (referRect.right < targetRect.left) {
-      //右侧
-      return {
-        start: { x: referRect.right, y: referRect.bottom },
-        end: { x: referRect.right, y: targetRect.bottom },
-      }
-    } else if (referRect.left > targetRect.right) {
-      //左侧
-      return {
-        start: { x: referRect.left, y: referRect.bottom },
-        end: { x: referRect.left, y: targetRect.bottom },
-      }
-    }
-  } else if (
-    referRect.bottom > targetRect.bottom &&
-    referRect.top <= targetRect.bottom
-  ) {
-    //refer下方
-    if (referRect.right < targetRect.left) {
-      //右侧
-      return {
-        start: { x: referRect.right, y: targetRect.top },
-        end: { x: referRect.right, y: referRect.top },
-      }
-    } else if (referRect.left > targetRect.right) {
-      //左侧
-      return {
-        start: { x: referRect.left, y: targetRect.top },
-        end: { x: referRect.left, y: referRect.top },
-      }
-    }
-  }
-}
-
-export function calcOffsetOfSnapLineSegmentToEdge(
-  line: ILineSegment,
-  current: IRect
-) {
-  const edges = calcEdgeLinesOfRect(current)
-  const isVerticalLine = line.start.x === line.end.x
-  if (isVerticalLine) {
-    return { x: calcMinDistanceValue(edges.x, line.start.x) - current.x, y: 0 }
-  }
-  function calcEdgeLinesOfRect(rect: IRect) {
-    return {
-      x: [rect.x, rect.x + rect.width / 2, rect.x + rect.width],
-      y: [rect.y, rect.y + rect.height / 2, rect.y + rect.height],
-    }
-  }
-  function calcMinDistanceValue(edges: number[], targetValue: number) {
-    let minDistance = Infinity,
-      minDistanceIndex = -1
-    for (let i = 0; i < edges.length; i++) {
-      const distance = Math.abs(edges[i] - targetValue)
-      if (minDistance > distance) {
-        minDistance = distance
-        minDistanceIndex = i
-      }
-    }
-    return edges[minDistanceIndex]
-  }
-
-  return { x: 0, y: calcMinDistanceValue(edges.y, line.start.y) - current.y }
-}
-
-export function calcDistanceOfSnapLineToEdges(
-  line: ILineSegment,
-  edges: IRectEdgeLines
-) {
-  let distance = Infinity
-  if (line?.start?.y === line?.end?.y) {
-    edges.h.forEach((target) => {
-      const _distance = Math.abs(target.start.y - line.start.y)
-      if (_distance < distance) {
-        distance = _distance
-      }
-    })
-  } else if (line?.start?.x === line?.end?.x) {
-    edges.v.forEach((target) => {
-      const _distance = Math.abs(target.start.x - line.start.x)
-      if (_distance < distance) {
-        distance = _distance
-      }
-    })
-  } else {
-    throw new Error('can not calculate slash distance')
-  }
-  return distance
-}
-
-export function calcCombineSnapLineSegment(
-  target: ILineSegment,
-  source: ILineSegment
-): ILineSegment {
-  if (target.start.x === target.end.x) {
-    return new LineSegment(
-      new Point(
-        target.start.x,
-        target.start.y > source.start.y ? source.start.y : target.start.y
-      ),
-      new Point(
-        target.start.x,
-        target.end.y > source.end.y ? target.end.y : source.end.y
-      )
-    )
-  }
-
-  return new LineSegment(
-    new Point(
-      target.start.x > source.start.x ? source.start.x : target.start.x,
-      target.start.y
-    ),
-    new Point(
-      target.end.x > source.end.x ? target.end.x : source.end.x,
-      target.end.y
-    )
-  )
-}
-
-export function calcClosestEdges(
-  line: ILineSegment,
-  edges: IRectEdgeLines
-): [number, ILineSegment] {
-  let result: ILineSegment
-  let distance = Infinity
-  if (line?.start?.y === line?.end?.y) {
-    edges.h.forEach((target) => {
-      const _distance = Math.abs(target.start.y - line.start.y)
-      if (_distance < distance) {
-        distance = _distance
-        result = target
-      }
-    })
-  } else if (line?.start?.x === line?.end?.x) {
-    edges.v.forEach((target) => {
-      const _distance = Math.abs(target.start.x - line.start.x)
-      if (_distance < distance) {
-        distance = _distance
-        result = target
-      }
-    })
-  } else {
-    throw new Error('can not calculate slash distance')
-  }
-  return [distance, result]
-}