@gitborlando/geo 4.1.0 → 5.1.0

package/src/__test__/math.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  abs,
-  ceil,
-  divide,
-  floor,
-  max,
-  min,
-  multiply,
-  numberHalfFix,
-  pow2,
-  pow3,
-  random,
-  round,
-  sqrt,
-} from '../math'
-
-describe('Math utilities', () => {
-  it('should export Math functions correctly', () => {
-    expect(sqrt(16)).toBe(4)
-    expect(abs(-5)).toBe(5)
-    expect(min(3, 1, 4)).toBe(1)
-    expect(max(3, 1, 4)).toBe(4)
-    expect(round(3.7)).toBe(4)
-    expect(floor(3.7)).toBe(3)
-    expect(ceil(3.2)).toBe(4)
-    expect(typeof random()).toBe('number')
-  })
-
-  it('should calculate power of 2 correctly', () => {
-    expect(pow2(3)).toBe(9)
-    expect(pow2(4)).toBe(16)
-    expect(pow2(0)).toBe(0)
-  })
-
-  it('should calculate power of 3 correctly', () => {
-    expect(pow3(2)).toBe(8)
-    expect(pow3(3)).toBe(27)
-    expect(pow3(1)).toBe(1)
-  })
-
-  it('should multiply numbers correctly', () => {
-    expect(multiply(2, 3, 4)).toBe(24)
-    expect(multiply(1, 2, 3, 4, 5)).toBe(120)
-    expect(multiply()).toBe(1)
-  })
-
-  it('should divide numbers correctly', () => {
-    expect(divide(10, 2)).toBe(5)
-    expect(divide(7, 3)).toBeCloseTo(2.333, 3)
-    expect(divide(5, 0)).toBe(1) // 除零返回1
-  })
-
-  it('should fix number to half correctly', () => {
-    expect(numberHalfFix(1.1)).toBe(1)
-    expect(numberHalfFix(1.3)).toBe(1.5)
-    expect(numberHalfFix(1.8)).toBe(2)
-    expect(numberHalfFix(2.25)).toBe(2.5)
-    expect(numberHalfFix(2.75)).toBe(3)
-  })
-})

package/src/__test__/matrix.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { AABB } from '../aabb'
-import { IMatrix, Matrix } from '../matrix'
-
-describe('Matrix', () => {
-  it('should create identity matrix correctly', () => {
-    const matrix = Matrix.create()
-    expect(matrix).toEqual([1, 0, 0, 1, 0, 0])
-  })
-
-  it('should invert matrix correctly', () => {
-    const matrix: IMatrix = [2, 0, 0, 2, 10, 20]
-    const inverted = Matrix.invert(matrix)
-    expect(inverted[0]).toBeCloseTo(0.5)
-    expect(inverted[1]).toBeCloseTo(0)
-    expect(inverted[2]).toBeCloseTo(0)
-    expect(inverted[3]).toBeCloseTo(0.5)
-    expect(inverted[4]).toBeCloseTo(-5)
-    expect(inverted[5]).toBeCloseTo(-10)
-  })
-
-  it('should apply matrix to point correctly', () => {
-    const point = { x: 10, y: 20 }
-    const matrix: IMatrix = [2, 0, 0, 2, 5, 10] // 缩放2倍，平移(5,10)
-    const result = Matrix.applyPoint(point, matrix)
-    expect(result.x).toBe(25) // 10*2 + 5 = 25
-    expect(result.y).toBe(50) // 20*2 + 10 = 50
-  })
-
-  it('should apply matrix to AABB correctly', () => {
-    const aabb = new AABB(0, 0, 10, 20)
-    const matrix: IMatrix = [2, 0, 0, 2, 0, 0] // 缩放2倍
-    const result = Matrix.applyAABB(aabb, matrix)
-    expect(result.minX).toBe(0)
-    expect(result.minY).toBe(0)
-    expect(result.maxX).toBe(20)
-    expect(result.maxY).toBe(40)
-  })
-
-  it('should invert point transformation correctly', () => {
-    const point = { x: 25, y: 50 }
-    const matrix: IMatrix = [2, 0, 0, 2, 5, 10]
-    const result = Matrix.invertPoint(point, matrix)
-    expect(result.x).toBe(10) // (25-5)/2 = 10
-    expect(result.y).toBe(20) // (50-10)/2 = 20
-  })
-
-  it('should invert AABB transformation correctly', () => {
-    const transformedAABB = { minX: 0, minY: 0, maxX: 20, maxY: 40 }
-    const matrix: IMatrix = [2, 0, 0, 2, 0, 0]
-    const result = Matrix.invertAABB(transformedAABB, matrix)
-    expect(result.minX).toBe(0)
-    expect(result.minY).toBe(0)
-    expect(result.maxX).toBe(10)
-    expect(result.maxY).toBe(20)
-  })
-
-  it('should handle translation matrix correctly', () => {
-    const point = { x: 5, y: 10 }
-    const translationMatrix: IMatrix = [1, 0, 0, 1, 15, 25]
-    const result = Matrix.applyPoint(point, translationMatrix)
-    expect(result.x).toBe(20) // 5 + 15
-    expect(result.y).toBe(35) // 10 + 25
-  })
-
-  it('should handle rotation matrix correctly', () => {
-    const point = { x: 1, y: 0 }
-    const rotationMatrix: IMatrix = [0, 1, -1, 0, 0, 0] // 90度旋转
-    const result = Matrix.applyPoint(point, rotationMatrix)
-    expect(result.x).toBeCloseTo(0, 10)
-    expect(result.y).toBeCloseTo(1, 10)
-  })
-})

package/src/__test__/obb.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { AABB } from '../aabb'
-import { OBB } from '../obb'
-
-describe('OBB', () => {
-  it('should create OBB correctly', () => {
-    const obb = new OBB(0, 0, 10, 20, 0)
-    expect(obb.x).toBe(0)
-    expect(obb.y).toBe(0)
-    expect(obb.width).toBe(10)
-    expect(obb.height).toBe(20)
-    expect(obb.rotation).toBe(0)
-  })
-
-  it('should calculate center correctly', () => {
-    const obb = new OBB(0, 0, 10, 20, 0)
-    expect(obb.center.x).toBe(5)
-    expect(obb.center.y).toBe(10)
-  })
-
-  it('should get xy property correctly', () => {
-    const obb = new OBB(5, 10, 15, 20, 0)
-    const xy = obb.xy
-    expect(xy.x).toBe(5)
-    expect(xy.y).toBe(10)
-  })
-
-  it('should calculate vertex positions correctly', () => {
-    const obb = new OBB(0, 0, 10, 20, 0)
-    const vertexes = obb.calcVertexXY()
-    expect(vertexes).toHaveLength(4)
-    expect(vertexes[0]).toEqual({ x: 0, y: 0 }) // TL
-    expect(vertexes[1]).toEqual({ x: 10, y: 0 }) // TR
-    expect(vertexes[2]).toEqual({ x: 10, y: 20 }) // BR
-    expect(vertexes[3]).toEqual({ x: 0, y: 20 }) // BL
-  })
-
-  it('should clone OBB correctly', () => {
-    const original = new OBB(5, 10, 15, 20, 45)
-    const clone = original.clone()
-    expect(clone.x).toBe(original.x)
-    expect(clone.y).toBe(original.y)
-    expect(clone.width).toBe(original.width)
-    expect(clone.height).toBe(original.height)
-    expect(clone.rotation).toBe(original.rotation)
-    expect(clone).not.toBe(original) // 确保是不同的实例
-  })
-
-  it('should calculate projection length correctly', () => {
-    const obb = new OBB(0, 0, 10, 20, 0)
-    const xAxis = { x: 1, y: 0 }
-    const yAxis = { x: 0, y: 1 }
-
-    expect(obb.projectionLengthAt(xAxis)).toBe(10)
-    expect(obb.projectionLengthAt(yAxis)).toBe(20)
-  })
-
-  it('should detect collision correctly', () => {
-    const obb1 = new OBB(0, 0, 10, 10, 0)
-    const obb2 = new OBB(5, 5, 10, 10, 0) // 重叠
-    const obb3 = new OBB(20, 20, 10, 10, 0) // 不重叠
-
-    expect(obb1.collide(obb2)).toBe(true)
-    expect(obb1.collide(obb3)).toBe(false)
-  })
-
-  it('should create identity OBB correctly', () => {
-    const identity = OBB.identityOBB()
-    expect(identity.x).toBe(0)
-    expect(identity.y).toBe(0)
-    expect(identity.width).toBe(0)
-    expect(identity.height).toBe(0)
-    expect(identity.rotation).toBe(0)
-  })
-
-  it('should create from rect correctly', () => {
-    const rect = { x: 10, y: 20, width: 30, height: 40 }
-    const obb = OBB.fromRect(rect, 45)
-    expect(obb.x).toBe(10)
-    expect(obb.y).toBe(20)
-    expect(obb.width).toBe(30)
-    expect(obb.height).toBe(40)
-    expect(obb.rotation).toBe(45)
-  })
-
-  it('should create from AABB correctly', () => {
-    const aabb = new AABB(5, 10, 15, 25)
-    const obb = OBB.fromAABB(aabb)
-    expect(obb.x).toBe(5)
-    expect(obb.y).toBe(10)
-    expect(obb.width).toBe(10)
-    expect(obb.height).toBe(15)
-    expect(obb.rotation).toBe(0)
-  })
-})

package/src/__test__/points-of-bezier.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  Point,
-  pointsOnBezierCurves,
-  simplify,
-  simplifyPoints,
-} from '../points-of-bezier'
-
-describe('Points of Bezier', () => {
-  const createBezierPoints = (): Point[] => [
-    { x: 0, y: 0 }, // 起点
-    { x: 10, y: 20 }, // 控制点1
-    { x: 30, y: 20 }, // 控制点2
-    { x: 40, y: 0 }, // 终点
-  ]
-
-  it('should generate points on bezier curve correctly', () => {
-    const controlPoints = createBezierPoints()
-    const points = pointsOnBezierCurves(controlPoints, 0.15)
-
-    expect(points.length).toBeGreaterThan(2)
-    expect(points[0]).toEqual({ x: 0, y: 0 }) // 起点
-    expect(points[points.length - 1]).toEqual({ x: 40, y: 0 }) // 终点
-  })
-
-  it('should generate points with custom tolerance', () => {
-    const controlPoints = createBezierPoints()
-    const highTolerance = pointsOnBezierCurves(controlPoints, 1.0)
-    const lowTolerance = pointsOnBezierCurves(controlPoints, 0.01)
-
-    expect(lowTolerance.length).toBeGreaterThan(highTolerance.length)
-  })
-
-  it('should generate points with distance simplification', () => {
-    const controlPoints = createBezierPoints()
-    const points = pointsOnBezierCurves(controlPoints, 0.15, 5.0)
-    const pointsWithoutSimplify = pointsOnBezierCurves(controlPoints, 0.15)
-
-    expect(points.length).toBeLessThanOrEqual(pointsWithoutSimplify.length)
-  })
-
-  it('should simplify points correctly', () => {
-    const points: Point[] = [
-      { x: 0, y: 0 },
-      { x: 1, y: 0.1 },
-      { x: 2, y: 0.2 },
-      { x: 3, y: 0.1 },
-      { x: 4, y: 0 },
-      { x: 10, y: 0 },
-    ]
-
-    const simplified = simplify(points, 0.5)
-    expect(simplified.length).toBeLessThan(points.length)
-    expect(simplified[0]).toEqual(points[0]) // 起点保持
-    expect(simplified[simplified.length - 1]).toEqual(points[points.length - 1]) // 终点保持
-  })
-
-  it('should simplify points with Ramer-Douglas-Peucker algorithm', () => {
-    const points: Point[] = [
-      { x: 0, y: 0 },
-      { x: 1, y: 1 },
-      { x: 2, y: 0 },
-      { x: 3, y: 1 },
-      { x: 4, y: 0 },
-    ]
-
-    const simplified = simplifyPoints(points, 0, points.length, 0.5)
-    expect(simplified.length).toBeGreaterThanOrEqual(2) // 至少保留起点和终点
-    expect(simplified[0]).toEqual(points[0])
-  })
-
-  it('should handle empty bezier curves correctly', () => {
-    const emptyPoints: Point[] = []
-    const result = pointsOnBezierCurves(emptyPoints)
-    expect(result).toEqual([])
-  })
-
-  it('should handle single segment bezier correctly', () => {
-    const singleSegment = createBezierPoints()
-    const points = pointsOnBezierCurves(singleSegment, 0.15)
-
-    expect(points.length).toBeGreaterThanOrEqual(2)
-    expect(points[0].x).toBe(0)
-    expect(points[0].y).toBe(0)
-    expect(points[points.length - 1].x).toBe(40)
-    expect(points[points.length - 1].y).toBe(0)
-  })
-
-  it('should handle multiple bezier segments correctly', () => {
-    const multipleSegments: Point[] = [
-      { x: 0, y: 0 }, // 第一段：起点
-      { x: 10, y: 20 }, // 控制点1
-      { x: 30, y: 20 }, // 控制点2
-      { x: 40, y: 0 }, // 终点/第二段起点
-      { x: 50, y: -20 }, // 控制点1
-      { x: 70, y: -20 }, // 控制点2
-      { x: 80, y: 0 }, // 第二段：终点
-    ]
-
-    const points = pointsOnBezierCurves(multipleSegments, 0.15)
-    expect(points.length).toBeGreaterThan(4) // 应该有更多点
-  })
-})

package/src/__test__/types.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { IRect, IRectWithCenter, IXY } from '../types'
-
-describe('Types', () => {
-  it('should define IXY interface correctly', () => {
-    const point: IXY = { x: 10, y: 20 }
-    expect(point.x).toBe(10)
-    expect(point.y).toBe(20)
-  })
-
-  it('should define IRect interface correctly', () => {
-    const rect: IRect = { x: 0, y: 0, width: 100, height: 50 }
-    expect(rect.x).toBe(0)
-    expect(rect.y).toBe(0)
-    expect(rect.width).toBe(100)
-    expect(rect.height).toBe(50)
-  })
-
-  it('should define IRectWithCenter interface correctly', () => {
-    const rectWithCenter: IRectWithCenter = {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 50,
-      centerX: 50,
-      centerY: 25,
-    }
-    expect(rectWithCenter.centerX).toBe(50)
-    expect(rectWithCenter.centerY).toBe(25)
-  })
-})

package/src/__test__/xy.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  XY,
-  xy_,
-  xy_center,
-  xy_client,
-  xy_distance,
-  xy_divide,
-  xy_dot,
-  xy_from,
-  xy_minus,
-  xy_multiply,
-  xy_mutate,
-  xy_opposite,
-  xy_plus,
-  xy_toArray,
-} from '../xy'
-
-describe('XY utilities', () => {
-  it('should create xy point correctly', () => {
-    const point = xy_(10, 20)
-    expect(point.x).toBe(10)
-    expect(point.y).toBe(20)
-  })
-
-  it('should create xy from client event correctly', () => {
-    const event = { clientX: 100, clientY: 200 }
-    const point = xy_client(event)
-    expect(point.x).toBe(100)
-    expect(point.y).toBe(200)
-  })
-
-  it('should copy xy point correctly', () => {
-    const original = { x: 5, y: 10 }
-    const copy = xy_from(original)
-    expect(copy.x).toBe(5)
-    expect(copy.y).toBe(10)
-  })
-
-  it('should get center point correctly', () => {
-    const rect = { centerX: 50, centerY: 75 }
-    const center = xy_center(rect)
-    expect(center.x).toBe(50)
-    expect(center.y).toBe(75)
-  })
-
-  it('should mutate xy point correctly', () => {
-    const point1 = { x: 1, y: 2 }
-    const point2 = { x: 3, y: 4 }
-    xy_mutate(point1, point2)
-    expect(point1.x).toBe(3)
-    expect(point1.y).toBe(4)
-  })
-
-  it('should add xy points correctly', () => {
-    const point1 = { x: 1, y: 2 }
-    const point2 = { x: 3, y: 4 }
-    const result = xy_plus(point1, point2)
-    expect(result.x).toBe(4)
-    expect(result.y).toBe(6)
-  })
-
-  it('should subtract xy points correctly', () => {
-    const point1 = { x: 5, y: 8 }
-    const point2 = { x: 2, y: 3 }
-    const result = xy_minus(point1, point2)
-    expect(result.x).toBe(3)
-    expect(result.y).toBe(5)
-  })
-
-  it('should multiply xy point correctly', () => {
-    const point = { x: 2, y: 3 }
-    const result = xy_multiply(point, 2, 3)
-    expect(result.x).toBe(12)
-    expect(result.y).toBe(18)
-  })
-
-  it('should divide xy point correctly', () => {
-    const point = { x: 12, y: 18 }
-    const result = xy_divide(point, 2, 3)
-    expect(result.x).toBe(2)
-    expect(result.y).toBe(3)
-  })
-
-  it('should calculate distance correctly', () => {
-    const point1 = { x: 0, y: 0 }
-    const point2 = { x: 3, y: 4 }
-    const distance = xy_distance(point1, point2)
-    expect(distance).toBe(5)
-  })
-
-  it('should calculate dot product correctly', () => {
-    const point1 = { x: 2, y: 3 }
-    const point2 = { x: 4, y: 5 }
-    const dot = xy_dot(point1, point2)
-    expect(dot).toBe(23) // 2*4 + 3*5 = 8 + 15 = 23
-  })
-
-  it('should get opposite point correctly', () => {
-    const point = { x: 3, y: -4 }
-    const opposite = xy_opposite(point)
-    expect(opposite.x).toBe(-3)
-    expect(opposite.y).toBe(4)
-  })
-
-  it('should convert to array correctly', () => {
-    const point = { x: 7, y: 11 }
-    const array = xy_toArray(point)
-    expect(array).toEqual([7, 11])
-  })
-})
-
-describe('XY class', () => {
-  it('should create XY instance correctly', () => {
-    const xy = new XY(10, 20)
-    expect(xy.x).toBe(10)
-    expect(xy.y).toBe(20)
-  })
-
-  it('should create from point correctly', () => {
-    const xy = XY.from({ x: 5, y: 10 })
-    expect(xy.x).toBe(5)
-    expect(xy.y).toBe(10)
-  })
-
-  it('should create from array correctly', () => {
-    const xy = XY.tuple([15, 25])
-    expect(xy.x).toBe(15)
-    expect(xy.y).toBe(25)
-  })
-
-  it('should perform chained operations correctly', () => {
-    const xy = new XY(2, 3).plus({ x: 1, y: 2 }).multiply(2)
-    expect(xy.x).toBe(6) // (2+1)*2 = 6
-    expect(xy.y).toBe(10) // (3+2)*2 = 10
-  })
-
-  it('should calculate distance correctly', () => {
-    const xy = new XY(0, 0)
-    const distance = xy.getDistance({ x: 3, y: 4 })
-    expect(distance).toBe(5)
-  })
-})

package/src/math.ts

@@ -1,26 +0,0 @@
-export const { sqrt, abs, min, max, round, floor, ceil, random } = Math
-
-export function pow2(number: number) {
-  return Math.pow(number, 2)
-}
-export function pow3(number: number) {
-  return Math.pow(number, 3)
-}
-
-export function multiply(...numbers: number[]) {
-  return numbers.reduce((i, all) => (all *= i), 1)
-}
-export function divide(a: number, b: number) {
-  return b === 0 ? 1 : a / b
-}
-
-export function numberHalfFix(number: number) {
-  const integerPart = ~~number
-  const floatPart = number - integerPart
-  const halfFixed = floatPart >= 0.75 ? 1 : floatPart >= 0.25 ? 0.5 : 0
-  return integerPart + halfFixed
-}
-
-export function twoDecimal(number: number) {
-  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2))
-}

package/src/matrix.ts

@@ -1,48 +0,0 @@
-import { AABB } from './aabb'
-import { max, min } from './math'
-import { IXY } from './types'
-import { xy_ } from './xy'
-
-export type IMatrix = [number, number, number, number, number, number]
-
-export class Matrix {
-  static create() {
-    return [1, 0, 0, 1, 0, 0] as IMatrix
-  }
-
-  static invert(matrix: IMatrix) {
-    const [a, b, c, d, e, f] = matrix
-    const invDet = 1 / (a * d - b * c)
-    return [d, -b, -c, a, c * f - d * e, b * e - a * f].map(
-      (i) => i * invDet,
-    ) as IMatrix
-  }
-
-  static applyPoint(xy: IXY, matrix: IMatrix) {
-    const { x, y } = xy
-    const [a, b, c, d, e, f] = matrix
-    return xy_(a * x + c * y + e, b * x + d * y + f)
-  }
-
-  static applyAABB(aabb: AABB, matrix: IMatrix) {
-    const { minX, minY, maxX, maxY } = aabb
-    const xy1 = Matrix.applyPoint(xy_(minX, minY), matrix)
-    const xy2 = Matrix.applyPoint(xy_(maxX, minY), matrix)
-    const xy3 = Matrix.applyPoint(xy_(maxX, maxY), matrix)
-    const xy4 = Matrix.applyPoint(xy_(minX, maxY), matrix)
-    return {
-      minX: min(xy1.x, xy2.x, xy3.x, xy4.x),
-      minY: min(xy1.y, xy2.y, xy3.y, xy4.y),
-      maxX: max(xy1.x, xy2.x, xy3.x, xy4.x),
-      maxY: max(xy1.y, xy2.y, xy3.y, xy4.y),
-    }
-  }
-
-  static invertPoint(xy: IXY, matrix: IMatrix) {
-    return Matrix.applyPoint(xy, Matrix.invert(matrix))
-  }
-
-  static invertAABB(aabb: AABB, matrix: IMatrix) {
-    return Matrix.applyAABB(aabb, Matrix.invert(matrix))
-  }
-}