@gitborlando/geo 4.1.1 → 5.1.0

package/src/__test__/angle.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { Angle, PI } from '../angle'
-
-describe('Angle', () => {
-  it('should export PI constant correctly', () => {
-    expect(PI).toBe(Math.PI)
-  })
-
-  it('should calculate cosine correctly', () => {
-    expect(Angle.cos(0)).toBe(1)
-    expect(Angle.cos(90)).toBeCloseTo(0, 10)
-    expect(Angle.cos(180)).toBeCloseTo(-1, 10)
-  })
-
-  it('should calculate sine correctly', () => {
-    expect(Angle.sin(0)).toBe(0)
-    expect(Angle.sin(90)).toBeCloseTo(1, 10)
-    expect(Angle.sin(180)).toBeCloseTo(0, 10)
-  })
-
-  it('should calculate tangent correctly', () => {
-    expect(Angle.tan(0)).toBe(0)
-    expect(Angle.tan(45)).toBeCloseTo(1, 10)
-  })
-
-  it('should convert radians to degrees correctly', () => {
-    expect(Angle.angleFy(Math.PI)).toBe(180)
-    expect(Angle.angleFy(Math.PI / 2)).toBe(90)
-    expect(Angle.angleFy(0)).toBe(0)
-  })
-
-  it('should convert degrees to radians correctly', () => {
-    expect(Angle.radianFy(180)).toBe(Math.PI)
-    expect(Angle.radianFy(90)).toBe(Math.PI / 2)
-    expect(Angle.radianFy(0)).toBe(0)
-  })
-
-  it('should normalize angles correctly', () => {
-    expect(Angle.normal(370)).toBe(10)
-    expect(Angle.normal(-10)).toBe(350)
-    expect(Angle.normal(0)).toBe(0)
-  })
-
-  it('should snap angles to steps correctly', () => {
-    expect(Angle.snap(45)).toBe(90) // 45度四舍五入到90度
-    expect(Angle.snap(80)).toBe(90)
-    expect(Angle.snap(120)).toBe(90)
-    expect(Angle.snap(135)).toBe(180)
-    expect(Angle.snap(0)).toBe(0)
-    expect(Angle.snap(30)).toBe(0) // 30度四舍五入到0度
-  })
-
-  it('should rotate point correctly', () => {
-    const result = Angle.rotatePoint(1, 0, 0, 0, 90)
-    expect(result.x).toBeCloseTo(0, 10)
-    expect(result.y).toBeCloseTo(1, 10)
-  })
-})

package/src/__test__/index.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import * as Geo from '../index'
-
-describe('Index exports', () => {
-  it('should export all modules correctly', () => {
-    // 验证AABB相关导出
-    expect(typeof Geo.AABB).toBe('function')
-
-    // 验证Angle相关导出
-    expect(typeof Geo.Angle).toBe('function')
-    expect(typeof Geo.PI).toBe('number')
-
-    // 验证数学函数导出
-    expect(typeof Geo.sqrt).toBe('function')
-    expect(typeof Geo.abs).toBe('function')
-    expect(typeof Geo.pow2).toBe('function')
-    expect(typeof Geo.pow3).toBe('function')
-    expect(typeof Geo.multiply).toBe('function')
-    expect(typeof Geo.divide).toBe('function')
-    expect(typeof Geo.numberHalfFix).toBe('function')
-
-    // 验证Matrix相关导出
-    expect(typeof Geo.Matrix).toBe('function')
-
-    // 验证OBB相关导出
-    expect(typeof Geo.OBB).toBe('function')
-
-    // 验证贝塞尔曲线相关导出
-    expect(typeof Geo.pointsOnBezierCurves).toBe('function')
-    expect(typeof Geo.simplify).toBe('function')
-    expect(typeof Geo.simplifyPoints).toBe('function')
-
-    // 验证XY相关导出
-    expect(typeof Geo.xy_).toBe('function')
-    expect(typeof Geo.xy_client).toBe('function')
-    expect(typeof Geo.xy_from).toBe('function')
-    expect(typeof Geo.xy_plus).toBe('function')
-    expect(typeof Geo.xy_minus).toBe('function')
-    expect(typeof Geo.xy_multiply).toBe('function')
-    expect(typeof Geo.xy_divide).toBe('function')
-    expect(typeof Geo.xy_distance).toBe('function')
-    expect(typeof Geo.xy_dot).toBe('function')
-    expect(typeof Geo.XY).toBe('function')
-  })
-
-  it('should export type interfaces', () => {
-    // 验证可以使用导出的类型
-    const point: Geo.IXY = { x: 10, y: 20 }
-    const rect: Geo.IRect = { x: 0, y: 0, width: 100, height: 50 }
-    const rectWithCenter: Geo.IRectWithCenter = {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 50,
-      centerX: 50,
-      centerY: 25,
-    }
-
-    expect(point.x).toBe(10)
-    expect(rect.width).toBe(100)
-    expect(rectWithCenter.centerX).toBe(50)
-  })
-
-  it('should allow creating instances from exported classes', () => {
-    // 测试能够创建实例
-    const aabb = new Geo.AABB(0, 0, 10, 10)
-    const obb = new Geo.OBB(0, 0, 10, 10, 0)
-    const xy = new Geo.XY(5, 5)
-
-    expect(aabb.minX).toBe(0)
-    expect(obb.width).toBe(10)
-    expect(xy.x).toBe(5)
-  })
-
-  it('should allow using static methods from exported classes', () => {
-    // 测试静态方法
-    const matrix = Geo.Matrix.create()
-    const normalizedAngle = Geo.Angle.normal(370)
-    const distance = Geo.xy_distance({ x: 0, y: 0 }, { x: 3, y: 4 })
-
-    expect(matrix).toEqual([1, 0, 0, 1, 0, 0])
-    expect(normalizedAngle).toBe(10)
-    expect(distance).toBe(5)
-  })
-})

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))
-}