@gitborlando/geo 4.1.1 → 5.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitborlando/geo",
-  "version": "4.1.1",
+  "version": "5.2.0",
   "description": "",
   "type": "module",
   "exports": {
@@ -21,15 +21,15 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@vitest/ui": "^3.2.4",
-    "vitest": "^3.2.4",
     "@changesets/cli": "^2.29.5",
     "@types/node": "^24.0.15",
-    "husky": "^9.1.7",
+    "@vitest/ui": "^3.2.4",
     "pretty-quick": "^4.2.2",
     "tsup": "^8.5.0",
     "tsx": "^4.20.3",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "simple-git-hooks": "^2.13.1"
   },
   "prettier": {
     "printWidth": 85,
@@ -40,10 +40,13 @@
     "singleQuote": true,
     "jsxSingleQuote": true
   },
+  "simple-git-hooks": {
+    "pre-commit": "npx pretty-quick --staged"
+  },
   "scripts": {
     "dev": "tsup --watch",
     "build": "tsup",
-    "clean": "rm -rf node_modules pnpm-lock.yaml",
+    "re-i": "rm -rf node_modules pnpm-lock.yaml",
     "test": "vitest",
     "test:run": "vitest run",
     "test:ui": "vitest --ui"

package/src/aabb.ts

@@ -1,6 +1,5 @@
-import { max, min } from './math'
 import { OBB } from './obb'
-import { IRectWithCenter } from './types'
+import { IRect, IRectWithCenter, IXY } from './types'
 import { XY } from './xy'
 
 export class AABB {
@@ -31,6 +30,32 @@ export class AABB {
     ] as const
   }
 
+  static update(aabb: AABB, minX: number, minY: number, maxX: number, maxY: number) {
+    aabb.minX = minX
+    aabb.minY = minY
+    aabb.maxX = maxX
+    aabb.maxY = maxY
+    return aabb
+  }
+
+  static updateFromRect(aabb: AABB, rect: IRect) {
+    return AABB.update(
+      aabb,
+      rect.x,
+      rect.y,
+      rect.x + rect.width,
+      rect.y + rect.height,
+    )
+  }
+
+  static shift(aabb: AABB, delta: IXY) {
+    aabb.minX += delta.x
+    aabb.minY += delta.y
+    aabb.maxX += delta.x
+    aabb.maxY += delta.y
+    return aabb
+  }
+
   static collide(one: AABB, another: AABB): boolean {
     return (
       one.minX <= another.maxX &&
@@ -74,20 +99,29 @@ export class AABB {
     }
   }
 
-  static merge(...aabbList: AABB[]) {
-    let [xMin, yMin, xMax, yMax] = [Infinity, Infinity, -Infinity, -Infinity]
-    aabbList.forEach((aabb) => {
-      xMin = min(xMin, aabb.minX)
-      yMin = min(yMin, aabb.minY)
-      xMax = max(xMax, aabb.maxX)
-      yMax = max(yMax, aabb.maxY)
-    })
+  static merge(aabbList: AABB[] | Set<AABB>) {
+    if (Array.isArray(aabbList)) {
+      if (aabbList.length === 0) return new AABB(0, 0, 0, 0)
+    } else {
+      if (aabbList.size === 0) return new AABB(0, 0, 0, 0)
+    }
+
+    let xMin = Infinity,
+      yMin = Infinity,
+      xMax = -Infinity,
+      yMax = -Infinity
+    for (const aabb of aabbList) {
+      xMin = Math.min(xMin, aabb.minX)
+      yMin = Math.min(yMin, aabb.minY)
+      xMax = Math.max(xMax, aabb.maxX)
+      yMax = Math.max(yMax, aabb.maxY)
+    }
     return new AABB(xMin, yMin, xMax, yMax)
   }
 
   static fromOBB(obb: OBB) {
-    const width = obb.projectionLengthAt(XY._(1, 0))
-    const height = obb.projectionLengthAt(XY._(0, 1))
+    const width = obb.projectAt(XY.$(1, 0))
+    const height = obb.projectAt(XY.$(0, 1))
     return new AABB(
       obb.center.x - width / 2,
       obb.center.y - height / 2,
@@ -95,4 +129,14 @@ export class AABB {
       obb.center.y + height / 2,
     )
   }
+
+  static updateFromOBB(aabb: AABB, obb: OBB) {
+    const width = obb.projectAt(XY.$(1, 0))
+    const height = obb.projectAt(XY.$(0, 1))
+    aabb.minX = obb.center.x - width / 2
+    aabb.minY = obb.center.y - height / 2
+    aabb.maxX = obb.center.x + width / 2
+    aabb.maxY = obb.center.y + height / 2
+    return aabb
+  }
 }

package/src/angle.ts

@@ -1,32 +1,26 @@
-export const { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math
+import { IXY } from './types'
+import { XY } from './xy'
 
 export class Angle {
   static cos(angle: number) {
-    return cos(Angle.radianFy(angle))
+    return Math.cos(Angle.radianFy(angle))
   }
 
   static sin(angle: number) {
-    return sin(Angle.radianFy(angle))
+    return Math.sin(Angle.radianFy(angle))
   }
 
-  static tan(angle: number) {
-    return tan(Angle.radianFy(angle))
-  }
-
-  static acos(angle: number) {
-    return Angle.angleFy(acos(Angle.radianFy(angle)))
-  }
-
-  static asin(angle: number) {
-    return Angle.angleFy(asin(Angle.radianFy(angle)))
+  static cosSin(angle: number) {
+    const radians = Angle.radianFy(angle)
+    return { cos: Math.cos(radians), sin: Math.sin(radians) }
   }
 
-  static atan(angle: number) {
-    return Angle.angleFy(atan(Angle.radianFy(angle)))
+  static tan(angle: number) {
+    return Math.tan(Angle.radianFy(angle))
   }
 
   static atan2(y: number, x: number) {
-    return Angle.angleFy(atan2(y, x))
+    return Angle.angleFy(Math.atan2(y, x))
   }
 
   static angleFy(radians: number) {
@@ -38,18 +32,20 @@ export class Angle {
   }
 
   static normal(angle: number) {
-    return (angle + 360) % 360
+    return ((angle % 360) + 360) % 360
+  }
+
+  static minor(angle: number) {
+    return Math.min(angle, 360 - angle)
   }
 
   static snap(angle: number, step = 90) {
     return Angle.normal(Math.round(angle / step) * step)
   }
 
-  static rotatePoint(ax: number, ay: number, ox: number, oy: number, angle: number) {
-    const radian = Angle.radianFy(angle)
-    return {
-      x: (ax - ox) * cos(radian) - (ay - oy) * sin(radian) + ox,
-      y: (ax - ox) * sin(radian) + (ay - oy) * cos(radian) + oy,
-    }
+  static sweep(v1: IXY, v2: IXY = XY.xAxis(), clockwise = false) {
+    const dot = v1.x * v2.x + v1.y * v2.y
+    const det = v1.x * v2.y - v1.y * v2.x
+    return Angle.normal(Angle.atan2(det, dot) * (clockwise ? 1 : -1))
   }
 }

package/src/index.ts

@@ -1,8 +1,6 @@
 export * from './aabb'
 export * from './angle'
-export * from './math'
-export * from './matrix'
+export * from './misc'
 export * from './obb'
-export * from './points-of-bezier'
 export * from './types'
 export * from './xy'

package/src/misc.ts

@@ -0,0 +1,7 @@
+export function twoDecimal(number: number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2))
+}
+
+export function minMax(val: number, min: number, max: number) {
+  return Math.min(Math.max(val, min), max)
+}

package/src/obb.ts

@@ -1,7 +1,7 @@
 import { AABB } from './aabb'
 import { Angle } from './angle'
 import { IRect, IXY } from './types'
-import { XY, xy_, xy_dot, xy_minus, xy_rotate } from './xy'
+import { XY } from './xy'
 
 type IAxis = { widthAxis: IXY; heightAxis: IXY }
 
@@ -25,19 +25,18 @@ export class OBB {
   }
 
   get xy() {
-    return xy_(this.x, this.y)
+    return XY.$(this.x, this.y)
   }
 
   #calcCenter = () => {
-    const center = xy_(this.x + this.width / 2, this.y + this.height / 2)
-    return xy_rotate(center, xy_(this.x, this.y), this.rotation)
+    const center = XY.center(this).plus(this.xy)
+    return center.rotate(this.xy, this.rotation)
   }
 
   #calcAxis = () => {
-    const cos = Angle.cos(this.rotation)
-    const sin = Angle.sin(this.rotation)
-    const widthAxis = xy_(cos, -sin)
-    const heightAxis = xy_(sin, cos)
+    const { cos, sin } = Angle.cosSin(this.rotation)
+    const widthAxis = XY.$(cos, -sin)
+    const heightAxis = XY.$(sin, cos)
     return (this.axis = { widthAxis, heightAxis })
   }
 
@@ -48,45 +47,69 @@ export class OBB {
     const sinWidth = sin * this.width
     const cosHeight = cos * this.height
     const sinHeight = sin * this.height
-    const TL = xy_(this.x, this.y)
-    const TR = xy_(this.x + cosWidth, this.y + sinWidth)
-    const BR = xy_(this.x + cosWidth - sinHeight, this.y + sinWidth + cosHeight)
-    const BL = xy_(this.x - sinHeight, this.y + cosHeight)
+    const TL = XY.$(this.x, this.y)
+    const TR = XY.$(this.x + cosWidth, this.y + sinWidth)
+    const BR = XY.$(this.x + cosWidth - sinHeight, this.y + sinWidth + cosHeight)
+    const BL = XY.$(this.x - sinHeight, this.y + cosHeight)
     return (this.vertexes = [TL, TR, BR, BL])
   }
 
+  plain = () => {
+    return {
+      x: this.x,
+      y: this.y,
+      width: this.width,
+      height: this.height,
+      rotation: this.rotation,
+      center: this.center,
+    }
+  }
+
   clone = () => {
     return new OBB(this.x, this.y, this.width, this.height, this.rotation)
   }
 
-  projectionLengthAt = (anotherAxis: IXY) => {
+  shift = (delta: IXY) => {
+    this.x += delta.x
+    this.y += delta.y
+    this.center.x += delta.x
+    this.center.y += delta.y
+    this.vertexes.forEach((vertex) => {
+      vertex.x += delta.x
+      vertex.y += delta.y
+    })
+    AABB.updateFromOBB(this.aabb, this)
+    return this
+  }
+
+  projectAt = (anotherAxis: IXY) => {
     const { widthAxis, heightAxis } = this.axis
     return (
-      Math.abs(xy_dot(widthAxis, anotherAxis)) * this.width +
-      Math.abs(xy_dot(heightAxis, anotherAxis)) * this.height
+      Math.abs(XY.dot(widthAxis, anotherAxis)) * this.width +
+      Math.abs(XY.dot(heightAxis, anotherAxis)) * this.height
     )
   }
 
   collide = (another: OBB) => {
-    const centerVector = xy_minus(this.center, another.center)
+    const centerVector = XY.vector(this.center, another.center)
     if (
-      this.projectionLengthAt(another.axis.widthAxis) + another.width <=
-      2 * Math.abs(xy_dot(centerVector, another.axis.widthAxis))
+      this.projectAt(another.axis.widthAxis) + another.width <=
+      2 * Math.abs(XY.dot(centerVector, another.axis.widthAxis))
     )
       return false
     if (
-      this.projectionLengthAt(another.axis.heightAxis) + another.height <=
-      2 * Math.abs(xy_dot(centerVector, another.axis.heightAxis))
+      this.projectAt(another.axis.heightAxis) + another.height <=
+      2 * Math.abs(XY.dot(centerVector, another.axis.heightAxis))
     )
       return false
     if (
-      another.projectionLengthAt(this.axis.widthAxis) + this.width <=
-      2 * Math.abs(xy_dot(centerVector, this.axis.widthAxis))
+      another.projectAt(this.axis.widthAxis) + this.width <=
+      2 * Math.abs(XY.dot(centerVector, this.axis.widthAxis))
     )
       return false
     if (
-      another.projectionLengthAt(this.axis.heightAxis) + this.height <=
-      2 * Math.abs(xy_dot(centerVector, this.axis.heightAxis))
+      another.projectAt(this.axis.heightAxis) + this.height <=
+      2 * Math.abs(XY.dot(centerVector, this.axis.heightAxis))
     )
       return false
     return true
@@ -104,7 +127,7 @@ export class OBB {
   static fromCenter(center: IXY, width: number, height: number, rotation = 0) {
     const dx = center.x - width / 2
     const dy = center.y - height / 2
-    const xy = XY.of(dx, dy).rotate(center, rotation)
+    const xy = XY.from(dx, dy).rotate(center, rotation)
     return new OBB(xy.x, xy.y, width, height, rotation)
   }
 

package/src/xy.ts

@@ -1,108 +1,13 @@
 import { Angle } from './angle'
-import { sqrt } from './math'
 import { IXY } from './types'
 
-export function xy_(x: number = 0, y: number = 0) {
-  return { x, y }
-}
-
-export function xy_client(e: any) {
-  return { x: e.clientX, y: e.clientY }
-}
-
-export function xy_from(xy: IXY) {
-  return { x: xy.x, y: xy.y }
-}
-
-export function xy_center(xy: { centerX: number; centerY: number }) {
-  return { x: xy.centerX, y: xy.centerY }
-}
-
-export function xy_mutate(self: IXY, another: IXY) {
-  self.x = another.x
-  self.y = another.y
-}
-
-export function xy_plus(self: IXY, another: IXY) {
-  return { x: self.x + another.x, y: self.y + another.y }
-}
-export function xy_plus_mutate(self: IXY, another: IXY) {
-  self.x = self.x + another.x
-  self.y = self.y + another.y
-}
-export function xy_plus_all(...xys: IXY[]) {
-  return xys.reduce((a, b) => xy_plus(a, b))
-}
-
-export function xy_minus(self: IXY, another: IXY) {
-  return { x: self.x - another.x, y: self.y - another.y }
-}
-export function xy_minus_mutate(self: IXY, another: IXY) {
-  self.x = self.x - another.x
-  self.y = self.y - another.y
-}
-
-export function xy_multiply(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  return { x: self.x * n, y: self.y * n }
-}
-export function xy_multiply_mutate(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  self.x = self.x * n
-  self.y = self.y * n
-}
-
-export function xy_divide(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  return { x: self.x / n, y: self.y / n }
-}
-
-export function xy_distance(self: IXY, another: IXY = xy_(0, 0)) {
-  return Math.sqrt((self.x - another.x) ** 2 + (self.y - another.y) ** 2)
-}
-
-export function xy_rotate(self: IXY, origin: IXY, rotation: number) {
-  if (rotation === 0) return self
-  return Angle.rotatePoint(self.x, self.y, origin.x, origin.y, rotation)
-}
-
-export function xy_dot(self: IXY, another: IXY) {
-  return self.x * another.x + self.y * another.y
-}
-
-export function xy_symmetric(self: IXY, origin: IXY) {
-  return { x: 2 * origin.x - self.x, y: 2 * origin.y - self.y }
-}
-
-export function xy_opposite(self: IXY) {
-  return { x: -self.x, y: -self.y }
-}
-
-export function xy_getRotation(self: IXY, another: IXY, origin: IXY) {
-  return Angle.angleFy(
-    Math.atan2(self.y - origin.y, self.x - origin.x) -
-      Math.atan2(another.y - origin.y, another.x - origin.x),
-  )
-}
-
-export function xy_toArray(self: IXY) {
-  return [self.x, self.y] as [number, number]
-}
-
-export function xy_xAxis(rotation: number) {
-  return { x: Angle.cos(rotation), y: Angle.sin(rotation) }
-}
-
-export function xy_yAxis(rotation: number) {
-  return { x: -Angle.sin(rotation), y: Angle.cos(rotation) }
-}
-
 export class XY {
   constructor(
     public x: number,
     public y: number,
   ) {}
-  plain() {
+
+  $() {
     return { x: this.x, y: this.y }
   }
 
@@ -111,91 +16,107 @@ export class XY {
   }
 
   plus(...others: IXY[]) {
-    const x = others.reduce((sum, cur) => sum + cur.x, this.x)
-    const y = others.reduce((sum, cur) => sum + cur.y, this.y)
-    return XY.of(x, y)
+    this.x = others.reduce((sum, cur) => sum + cur.x, this.x)
+    this.y = others.reduce((sum, cur) => sum + cur.y, this.y)
+    return this
+  }
+
+  plusNum(num: number) {
+    this.x += num
+    this.y += num
+    return this
   }
 
   minus(...others: IXY[]) {
-    const x = others.reduce((sum, cur) => sum - cur.x, this.x)
-    const y = others.reduce((sum, cur) => sum - cur.y, this.y)
-    return XY.of(x, y)
+    this.x = others.reduce((sum, cur) => sum - cur.x, this.x)
+    this.y = others.reduce((sum, cur) => sum - cur.y, this.y)
+    return this
   }
 
   multiply(...numbers: number[]) {
     const n = numbers.reduce((a, b) => a * b, 1)
-    return XY.of(this.x * n, this.y * n)
+    this.x *= n
+    this.y *= n
+    return this
+  }
+
+  multiplyNum(num: number) {
+    this.x *= num
+    this.y *= num
+    return this
   }
 
   divide(...numbers: number[]) {
     const n = numbers.reduce((a, b) => a * b, 1)
-    return XY.of(this.x / n, this.y / n)
+    this.x /= n
+    this.y /= n
+    return this
   }
 
   rotate(origin: IXY, rotation: number) {
-    if (rotation === 0) return XY.from(this)
-    return XY.from(Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation))
-  }
-
-  symmetric(origin: IXY) {
-    return XY.of(2 * origin.x - this.x, 2 * origin.y - this.y)
+    const { cos, sin } = Angle.cosSin(rotation)
+    const dx = this.x - origin.x
+    const dy = this.y - origin.y
+    this.x = dx * cos - dy * sin + origin.x
+    this.y = dx * sin + dy * cos + origin.y
+    return this
   }
 
-  ratio(another: IXY, t: number) {
-    const x = this.x + (another.x - this.x) * t
-    const y = this.y + (another.y - this.y) * t
-    return XY.of(x, y)
+  static $(x = 0, y = 0) {
+    return { x, y }
   }
 
-  getDot(another: IXY) {
-    return this.x * another.x + this.y * another.y
+  static of(xy: IXY) {
+    return new XY(xy.x, xy.y)
   }
 
-  getDistance(another: IXY) {
-    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2)
+  static from(x: number, y: number) {
+    return new XY(x, y)
   }
 
-  getAngle(another: IXY, origin: IXY) {
-    return Angle.angleFy(
-      Math.atan2(this.y - origin.y, this.x - origin.x) -
-        Math.atan2(another.y - origin.y, another.x - origin.x),
-    )
+  static center(wh: { width: number; height: number }) {
+    return new XY(wh.width / 2, wh.height / 2)
   }
 
-  static _(x: number = 0, y: number = 0) {
-    return { x, y }
+  static leftTop(e: { left: number; top: number }) {
+    return new XY(e.left, e.top)
   }
 
-  static of(x: number, y: number) {
-    return new XY(x, y)
+  static client(e: { clientX: number; clientY: number }) {
+    return new XY(e.clientX, e.clientY)
   }
 
-  static from(xy: IXY) {
-    if (xy instanceof XY) return xy
-    return XY.of(xy.x, xy.y)
+  static xAxis(rotation: number = 0) {
+    const { cos, sin } = Angle.cosSin(rotation)
+    return new XY(cos, sin)
   }
 
-  static center(xy: { centerX: number; centerY: number }) {
-    return XY.of(xy.centerX, xy.centerY)
+  static yAxis(rotation: number = 0) {
+    const { cos, sin } = Angle.cosSin(rotation)
+    return new XY(-sin, cos)
   }
 
-  static leftTop(e: { left: number; top: number }) {
-    return XY.of(e.left, e.top)
+  static dot(self: IXY, another: IXY) {
+    return self.x * another.x + self.y * another.y
   }
 
-  static client(e: { clientX: number; clientY: number }) {
-    return XY.of(e.clientX, e.clientY)
+  static distance(self: IXY, another: IXY) {
+    return Math.hypot(self.x - another.x, self.y - another.y)
   }
 
-  static tuple(arr: [number, number]) {
-    return XY.of(arr[0], arr[1])
+  static vector(self: IXY, another: IXY) {
+    return new XY(self.x - another.x, self.y - another.y)
   }
 
-  static xAxis(rotation: number) {
-    return XY.of(Angle.cos(rotation), Angle.sin(rotation))
+  static symmetric(self: IXY, origin = XY.$()) {
+    return new XY(2 * origin.x - self.x, 2 * origin.y - self.y)
   }
 
-  static yAxis(rotation: number) {
-    return XY.of(-Angle.sin(rotation), Angle.cos(rotation))
+  static lerp(self: IXY, origin: IXY, t: number) {
+    const distance = XY.distance(self, origin)
+    return new XY(
+      self.x + (self.x - origin.x) * (t / distance),
+      self.y + (self.y - origin.y) * (t / distance),
+    )
   }
 }