@gitborlando/geo 1.0.1 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @gitborlando/geo
 
+## 2.0.0
+
+### Major Changes
+
+- b2c20d9: 修正了多个类的方法名称，统一为小写格式，更新了相关测试用例以匹配新的方法名。同时，更新了 package.json 中的导出路径，从 src 目录改为 dist 目录。
+
 ## 1.0.1
 
 ### Patch Changes

package/__test__/aabb.test.ts

@@ -15,7 +15,7 @@ describe('AABB', () => {
 
   it('should convert to rect correctly', () => {
     const aabb = new AABB(5, 10, 15, 25)
-    const rect = AABB.Rect(aabb)
+    const rect = AABB.rect(aabb)
     expect(rect.x).toBe(5)
     expect(rect.y).toBe(10)
     expect(rect.width).toBe(10)
@@ -29,8 +29,8 @@ describe('AABB', () => {
     const aabb2 = new AABB(5, 5, 15, 15)
     const aabb3 = new AABB(20, 20, 30, 30)
 
-    expect(AABB.Collide(aabb1, aabb2)).toBe(true)
-    expect(AABB.Collide(aabb1, aabb3)).toBe(false)
+    expect(AABB.collide(aabb1, aabb2)).toBe(true)
+    expect(AABB.collide(aabb1, aabb3)).toBe(false)
   })
 
   it('should detect inclusion correctly', () => {
@@ -38,14 +38,14 @@ describe('AABB', () => {
     const small = new AABB(5, 5, 15, 15)
     const outside = new AABB(25, 25, 35, 35)
 
-    expect(AABB.Include(large, small)).toBe(1) // large包含small
-    expect(AABB.Include(small, large)).toBe(0) // small被large包含
-    expect(AABB.Include(large, outside)).toBe(-1) // 不包含
+    expect(AABB.include(large, small)).toBe(1) // large包含small
+    expect(AABB.include(small, large)).toBe(0) // small被large包含
+    expect(AABB.include(large, outside)).toBe(-1) // 不包含
   })
 
   it('should expand correctly with single value', () => {
     const aabb = new AABB(5, 5, 15, 15)
-    const expanded = AABB.Expand(aabb, 2)
+    const expanded = AABB.expand(aabb, 2)
     expect(expanded.minX).toBe(3)
     expect(expanded.minY).toBe(3)
     expect(expanded.maxX).toBe(17)
@@ -54,7 +54,7 @@ describe('AABB', () => {
 
   it('should expand correctly with four values', () => {
     const aabb = new AABB(5, 5, 15, 15)
-    const expanded = AABB.Expand(aabb, 1, 2, 3, 4)
+    const expanded = AABB.expand(aabb, 1, 2, 3, 4)
     expect(expanded.minX).toBe(4)
     expect(expanded.minY).toBe(3)
     expect(expanded.maxX).toBe(18)
@@ -66,7 +66,7 @@ describe('AABB', () => {
     const aabb2 = new AABB(10, 10, 15, 15)
     const aabb3 = new AABB(-5, -5, 0, 0)
 
-    const merged = AABB.Merge(aabb1, aabb2, aabb3)
+    const merged = AABB.merge(aabb1, aabb2, aabb3)
     expect(merged.minX).toBe(-5)
     expect(merged.minY).toBe(-5)
     expect(merged.maxX).toBe(15)
@@ -75,7 +75,7 @@ describe('AABB', () => {
 
   it('should create from OBB correctly', () => {
     const obb = new OBB(0, 0, 10, 20, 0)
-    const aabb = AABB.FromOBB(obb)
+    const aabb = AABB.fromOBB(obb)
     expect(aabb.minX).toBe(0)
     expect(aabb.minY).toBe(0)
     expect(aabb.maxX).toBe(10)

package/__test__/angle.test.ts

@@ -7,51 +7,51 @@ describe('Angle', () => {
   })
 
   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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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度
+    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)
+    const result = Angle.rotatePoint(1, 0, 0, 0, 90)
     expect(result.x).toBeCloseTo(0, 10)
     expect(result.y).toBeCloseTo(1, 10)
   })

package/__test__/index.test.ts

@@ -74,8 +74,8 @@ describe('Index exports', () => {
 
   it('should allow using static methods from exported classes', () => {
     // 测试静态方法
-    const matrix = Geo.Matrix.Create()
-    const normalizedAngle = Geo.Angle.Normal(370)
+    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])

package/__test__/matrix.test.ts

@@ -4,13 +4,13 @@ import { IMatrix, Matrix } from '../src/matrix'
 
 describe('Matrix', () => {
   it('should create identity matrix correctly', () => {
-    const matrix = Matrix.Create()
+    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)
+    const inverted = Matrix.invert(matrix)
     expect(inverted[0]).toBeCloseTo(0.5)
     expect(inverted[1]).toBeCloseTo(0)
     expect(inverted[2]).toBeCloseTo(0)
@@ -22,7 +22,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.applyPoint(point, matrix)
     expect(result.x).toBe(25) // 10*2 + 5 = 25
     expect(result.y).toBe(50) // 20*2 + 10 = 50
   })
@@ -30,7 +30,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.applyAABB(aabb, matrix)
     expect(result.minX).toBe(0)
     expect(result.minY).toBe(0)
     expect(result.maxX).toBe(20)
@@ -40,7 +40,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.invertPoint(point, matrix)
     expect(result.x).toBe(10) // (25-5)/2 = 10
     expect(result.y).toBe(20) // (50-10)/2 = 20
   })
@@ -48,7 +48,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.invertAABB(transformedAABB, matrix)
     expect(result.minX).toBe(0)
     expect(result.minY).toBe(0)
     expect(result.maxX).toBe(10)
@@ -58,7 +58,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.applyPoint(point, translationMatrix)
     expect(result.x).toBe(20) // 5 + 15
     expect(result.y).toBe(35) // 10 + 25
   })
@@ -66,7 +66,7 @@ describe('Matrix', () => {
   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)
+    const result = Matrix.applyPoint(point, rotationMatrix)
     expect(result.x).toBeCloseTo(0, 10)
     expect(result.y).toBeCloseTo(1, 10)
   })

package/__test__/obb.test.ts

@@ -65,7 +65,7 @@ describe('OBB', () => {
   })
 
   it('should create identity OBB correctly', () => {
-    const identity = OBB.IdentityOBB()
+    const identity = OBB.identityOBB()
     expect(identity.x).toBe(0)
     expect(identity.y).toBe(0)
     expect(identity.width).toBe(0)
@@ -75,7 +75,7 @@ describe('OBB', () => {
 
   it('should create from rect correctly', () => {
     const rect = { x: 10, y: 20, width: 30, height: 40 }
-    const obb = OBB.FromRect(rect, 45)
+    const obb = OBB.fromRect(rect, 45)
     expect(obb.x).toBe(10)
     expect(obb.y).toBe(20)
     expect(obb.width).toBe(30)
@@ -85,7 +85,7 @@ describe('OBB', () => {
 
   it('should create from AABB correctly', () => {
     const aabb = new AABB(5, 10, 15, 25)
-    const obb = OBB.FromAABB(aabb)
+    const obb = OBB.fromAABB(aabb)
     expect(obb.x).toBe(5)
     expect(obb.y).toBe(10)
     expect(obb.width).toBe(10)

package/__test__/xy.test.ts

@@ -118,13 +118,13 @@ describe('XY class', () => {
   })
 
   it('should create from point correctly', () => {
-    const xy = XY.From({ x: 5, y: 10 })
+    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.FromArray([15, 25])
+    const xy = XY.fromArray([15, 25])
     expect(xy.x).toBe(15)
     expect(xy.y).toBe(25)
   })

package/dist/index.d.ts

@@ -49,9 +49,9 @@ declare class OBB {
     clone: () => OBB;
     projectionLengthAt: (anotherAxis: IXY) => number;
     collide: (another: OBB) => boolean;
-    static IdentityOBB(): OBB;
-    static FromRect(rect: IRect, rotation?: number): OBB;
-    static FromAABB(aabb: AABB): OBB;
+    static identityOBB(): OBB;
+    static fromRect(rect: IRect, rotation?: number): OBB;
+    static fromAABB(aabb: AABB): OBB;
 }
 
 declare class AABB {
@@ -60,12 +60,12 @@ declare class AABB {
     maxX: number;
     maxY: number;
     constructor(minX: number, minY: number, maxX: number, maxY: number);
-    static Rect(aabb: AABB): IRectWithCenter;
-    static Collide(one: AABB, another: AABB): boolean;
-    static Include(one: AABB, another: AABB): number;
-    static Expand(aabb: AABB, ...expands: [number] | [number, number, number, number]): AABB;
-    static Merge(...aabbList: AABB[]): AABB;
-    static FromOBB(obb: OBB): AABB;
+    static rect(aabb: AABB): IRectWithCenter;
+    static collide(one: AABB, another: AABB): boolean;
+    static include(one: AABB, another: AABB): number;
+    static expand(aabb: AABB, ...expands: [number] | [number, number, number, number]): AABB;
+    static merge(...aabbList: AABB[]): AABB;
+    static fromOBB(obb: OBB): AABB;
 }
 
 declare const PI: number;
@@ -77,18 +77,18 @@ declare const asin: (x: number) => number;
 declare const atan: (x: number) => number;
 declare const atan2: (y: number, x: number) => number;
 declare class Angle {
-    static Cos(angle: number): number;
-    static Sin(angle: number): number;
-    static Tan(angle: number): number;
-    static ACos(angle: number): number;
-    static ASin(angle: number): number;
-    static ATan(angle: number): number;
-    static ATan2(y: number, x: number): number;
-    static AngleFy(radians: number): number;
-    static RadianFy(angle: number): number;
-    static Normal(angle: number): number;
-    static Snap(angle: number, step?: number): number;
-    static RotatePoint(ax: number, ay: number, ox: number, oy: number, angle: number): {
+    static cos(angle: number): number;
+    static sin(angle: number): number;
+    static tan(angle: number): number;
+    static acos(angle: number): number;
+    static asin(angle: number): number;
+    static atan(angle: number): number;
+    static atan2(y: number, x: number): number;
+    static angleFy(radians: number): number;
+    static radianFy(angle: number): number;
+    static normal(angle: number): number;
+    static snap(angle: number, step?: number): number;
+    static rotatePoint(ax: number, ay: number, ox: number, oy: number, angle: number): {
         x: number;
         y: number;
     };
@@ -110,23 +110,23 @@ declare function numberHalfFix(number: number): number;
 
 type IMatrix = [number, number, number, number, number, number];
 declare class Matrix {
-    static Create(): IMatrix;
-    static Invert(matrix: IMatrix): IMatrix;
-    static ApplyPoint(xy: IXY, matrix: IMatrix): {
+    static create(): IMatrix;
+    static invert(matrix: IMatrix): IMatrix;
+    static applyPoint(xy: IXY, matrix: IMatrix): {
         x: number;
         y: number;
     };
-    static ApplyAABB(aabb: AABB, matrix: IMatrix): {
+    static applyAABB(aabb: AABB, matrix: IMatrix): {
         minX: number;
         minY: number;
         maxX: number;
         maxY: number;
     };
-    static InvertPoint(xy: IXY, matrix: IMatrix): {
+    static invertPoint(xy: IXY, matrix: IMatrix): {
         x: number;
         y: number;
     };
-    static InvertAABB(aabb: AABB, matrix: IMatrix): {
+    static invertAABB(aabb: AABB, matrix: IMatrix): {
         minX: number;
         minY: number;
         maxX: number;
@@ -238,8 +238,8 @@ declare class XY {
         y: number;
     };
     angle(another: IXY, origin: IXY): number;
-    static From(xy: IXY): XY;
-    static FromArray(arr: [number, number]): XY;
+    static from(xy: IXY): XY;
+    static fromArray(arr: [number, number]): XY;
 }
 
 export { AABB, Angle, type IMatrix, type IRect, type IRectWithCenter, type IXY, Matrix, OBB, PI, type Point, XY, abs, acos, asin, atan, atan2, ceil, cos, divide, floor, max, min, multiply, numberHalfFix, pointsOnBezierCurves, pow2, pow3, random, round, simplify, simplifyPoints, sin, sqrt, tan, xy_, xy_center, xy_client, xy_distance, xy_divide, xy_dot, xy_from, xy_getRotation, xy_minus, xy_minus_mutate, xy_multiply, xy_multiply_mutate, xy_mutate, xy_opposite, xy_plus, xy_plus_all, xy_plus_mutate, xy_rotate, xy_symmetric, xy_toArray, xy_xAxis, xy_yAxis };

package/dist/index.js

@@ -22,41 +22,41 @@ function numberHalfFix(number) {
 // src/angle.ts
 var { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math;
 var Angle = class _Angle {
-  static Cos(angle) {
-    return cos(_Angle.RadianFy(angle));
+  static cos(angle) {
+    return cos(_Angle.radianFy(angle));
   }
-  static Sin(angle) {
-    return sin(_Angle.RadianFy(angle));
+  static sin(angle) {
+    return sin(_Angle.radianFy(angle));
   }
-  static Tan(angle) {
-    return tan(_Angle.RadianFy(angle));
+  static tan(angle) {
+    return tan(_Angle.radianFy(angle));
   }
-  static ACos(angle) {
-    return _Angle.AngleFy(acos(_Angle.RadianFy(angle)));
+  static acos(angle) {
+    return _Angle.angleFy(acos(_Angle.radianFy(angle)));
   }
-  static ASin(angle) {
-    return _Angle.AngleFy(asin(_Angle.RadianFy(angle)));
+  static asin(angle) {
+    return _Angle.angleFy(asin(_Angle.radianFy(angle)));
   }
-  static ATan(angle) {
-    return _Angle.AngleFy(atan(_Angle.RadianFy(angle)));
+  static atan(angle) {
+    return _Angle.angleFy(atan(_Angle.radianFy(angle)));
   }
-  static ATan2(y, x) {
-    return _Angle.AngleFy(atan2(y, x));
+  static atan2(y, x) {
+    return _Angle.angleFy(atan2(y, x));
   }
-  static AngleFy(radians) {
+  static angleFy(radians) {
     return radians * (180 / Math.PI);
   }
-  static RadianFy(angle) {
+  static radianFy(angle) {
     return angle * (Math.PI / 180);
   }
-  static Normal(angle) {
+  static normal(angle) {
     return (angle + 360) % 360;
   }
-  static Snap(angle, step = 90) {
-    return _Angle.Normal(Math.round(angle / step) * step);
+  static snap(angle, step = 90) {
+    return _Angle.normal(Math.round(angle / step) * step);
   }
-  static RotatePoint(ax, ay, ox, oy, angle) {
-    const radian = _Angle.RadianFy(angle);
+  static rotatePoint(ax, ay, ox, oy, angle) {
+    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
@@ -116,7 +116,7 @@ function xy_distance(self, another = xy_(0, 0)) {
 }
 function xy_rotate(self, origin, rotation) {
   if (rotation === 0) return self;
-  return Angle.RotatePoint(self.x, self.y, origin.x, origin.y, rotation);
+  return Angle.rotatePoint(self.x, self.y, origin.x, origin.y, rotation);
 }
 function xy_dot(self, another) {
   return self.x * another.x + self.y * another.y;
@@ -128,7 +128,7 @@ function xy_opposite(self) {
   return { x: -self.x, y: -self.y };
 }
 function xy_getRotation(self, another, origin) {
-  return Angle.AngleFy(
+  return Angle.angleFy(
     Math.atan2(self.y - origin.y, self.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
   );
 }
@@ -136,10 +136,10 @@ function xy_toArray(self) {
   return [self.x, self.y];
 }
 function xy_xAxis(rotation) {
-  return { x: Angle.Cos(rotation), y: Angle.Sin(rotation) };
+  return { x: Angle.cos(rotation), y: Angle.sin(rotation) };
 }
 function xy_yAxis(rotation) {
-  return { x: -Angle.Sin(rotation), y: Angle.Cos(rotation) };
+  return { x: -Angle.sin(rotation), y: Angle.cos(rotation) };
 }
 var XY = class _XY {
   constructor(x, y) {
@@ -188,7 +188,7 @@ var XY = class _XY {
   }
   rotate(origin, rotation) {
     if (rotation === 0) return this;
-    return Angle.RotatePoint(this.x, this.y, origin.x, origin.y, rotation);
+    return Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation);
   }
   dot(another) {
     return this.x * another.x + this.y * another.y;
@@ -200,14 +200,14 @@ var XY = class _XY {
     return { x: 2 * origin.x - another.x, y: 2 * origin.y - another.y };
   }
   angle(another, origin) {
-    return Angle.AngleFy(
+    return Angle.angleFy(
       Math.atan2(this.y - origin.y, this.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
     );
   }
-  static From(xy) {
+  static from(xy) {
     return new _XY(xy.x, xy.y);
   }
-  static FromArray(arr) {
+  static fromArray(arr) {
     return new _XY(arr[0], arr[1]);
   }
 };
@@ -220,7 +220,7 @@ var AABB = class _AABB {
     this.maxX = maxX;
     this.maxY = maxY;
   }
-  static Rect(aabb) {
+  static rect(aabb) {
     return {
       x: aabb.minX,
       y: aabb.minY,
@@ -230,10 +230,10 @@ var AABB = class _AABB {
       centerY: aabb.minY + (aabb.maxY - aabb.minY) / 2
     };
   }
-  static Collide(one, another) {
+  static collide(one, another) {
     return one.minX <= another.maxX && one.maxX >= another.minX && one.minY <= another.maxY && one.maxY >= another.minY;
   }
-  static Include(one, another) {
+  static include(one, another) {
     let result = 1;
     let [large, small] = [one, another];
     if (one.maxX - one.minX < another.maxX - another.minX) {
@@ -244,7 +244,7 @@ var AABB = class _AABB {
     const included = large.minX <= small.minX && large.maxX >= small.maxX && large.minY <= small.minY && large.maxY >= small.maxY;
     return included ? result : -1;
   }
-  static Expand(aabb, ...expands) {
+  static expand(aabb, ...expands) {
     const { minX, minY, maxX, maxY } = aabb;
     if (expands.length === 1) {
       const expand = expands[0];
@@ -258,7 +258,7 @@ var AABB = class _AABB {
       );
     }
   }
-  static Merge(...aabbList) {
+  static merge(...aabbList) {
     let [xMin, yMin, xMax, yMax] = [Infinity, Infinity, -Infinity, -Infinity];
     aabbList.forEach((aabb) => {
       xMin = min(xMin, aabb.minX);
@@ -268,7 +268,7 @@ var AABB = class _AABB {
     });
     return new _AABB(xMin, yMin, xMax, yMax);
   }
-  static FromOBB(obb) {
+  static fromOBB(obb) {
     const width = obb.projectionLengthAt(xy_(1, 0));
     const height = obb.projectionLengthAt(xy_(0, 1));
     return new _AABB(
@@ -282,27 +282,27 @@ var AABB = class _AABB {
 
 // src/matrix.ts
 var Matrix = class _Matrix {
-  static Create() {
+  static create() {
     return [1, 0, 0, 1, 0, 0];
   }
-  static Invert(matrix) {
+  static invert(matrix) {
     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
     );
   }
-  static ApplyPoint(xy, matrix) {
+  static applyPoint(xy, matrix) {
     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, matrix) {
+  static applyAABB(aabb, matrix) {
     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);
+    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),
@@ -310,11 +310,11 @@ var Matrix = class _Matrix {
       maxY: max(xy1.y, xy2.y, xy3.y, xy4.y)
     };
   }
-  static InvertPoint(xy, matrix) {
-    return _Matrix.ApplyPoint(xy, _Matrix.Invert(matrix));
+  static invertPoint(xy, matrix) {
+    return _Matrix.applyPoint(xy, _Matrix.invert(matrix));
   }
-  static InvertAABB(aabb, matrix) {
-    return _Matrix.ApplyAABB(aabb, _Matrix.Invert(matrix));
+  static invertAABB(aabb, matrix) {
+    return _Matrix.applyAABB(aabb, _Matrix.invert(matrix));
   }
 };
 
@@ -329,7 +329,7 @@ var OBB = class _OBB {
     this.center = this.#calcCenter();
     this.axis = this.#calcAxis();
     this.vertexes = this.calcVertexXY();
-    this.aabb = AABB.FromOBB(this);
+    this.aabb = AABB.fromOBB(this);
   }
   center;
   axis;
@@ -343,15 +343,15 @@ var OBB = class _OBB {
     return xy_rotate(center, xy_(this.x, this.y), this.rotation);
   };
   #calcAxis = () => {
-    const cos2 = Angle.Cos(this.rotation);
-    const sin2 = Angle.Sin(this.rotation);
+    const cos2 = Angle.cos(this.rotation);
+    const sin2 = Angle.sin(this.rotation);
     const widthAxis = xy_(cos2, -sin2);
     const heightAxis = xy_(sin2, cos2);
     return this.axis = { widthAxis, heightAxis };
   };
   calcVertexXY = () => {
-    const cos2 = Angle.Cos(this.rotation);
-    const sin2 = Angle.Sin(this.rotation);
+    const cos2 = Angle.cos(this.rotation);
+    const sin2 = Angle.sin(this.rotation);
     const cosWidth = cos2 * this.width;
     const sinWidth = sin2 * this.width;
     const cosHeight = cos2 * this.height;
@@ -381,14 +381,14 @@ var OBB = class _OBB {
       return false;
     return true;
   };
-  static IdentityOBB() {
+  static identityOBB() {
     return new _OBB(0, 0, 0, 0, 0);
   }
-  static FromRect(rect, rotation = 0) {
+  static fromRect(rect, rotation = 0) {
     const { x, y, width, height } = rect;
     return new _OBB(x, y, width, height, rotation);
   }
-  static FromAABB(aabb) {
+  static fromAABB(aabb) {
     const { minX, minY, maxX, maxY } = aabb;
     return new _OBB(minX, minY, maxX - minX, maxY - minY, 0);
   }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gitborlando/geo",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./src/index.js",
-      "types": "./src/index.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "publishConfig": {

package/src/aabb.ts

@@ -11,7 +11,7 @@ export class AABB {
     public maxY: number,
   ) {}
 
-  static Rect(aabb: AABB): IRectWithCenter {
+  static rect(aabb: AABB): IRectWithCenter {
     return {
       x: aabb.minX,
       y: aabb.minY,
@@ -22,7 +22,7 @@ export class AABB {
     }
   }
 
-  static Collide(one: AABB, another: AABB): boolean {
+  static collide(one: AABB, another: AABB): boolean {
     return (
       one.minX <= another.maxX &&
       one.maxX >= another.minX &&
@@ -31,7 +31,7 @@ export class AABB {
     )
   }
 
-  static Include(one: AABB, another: AABB) {
+  static include(one: AABB, another: AABB) {
     let result = 1
     let [large, small] = [one, another]
     if (one.maxX - one.minX < another.maxX - another.minX) {
@@ -47,7 +47,7 @@ export class AABB {
     return included ? result : -1
   }
 
-  static Expand(
+  static expand(
     aabb: AABB,
     ...expands: [number] | [number, number, number, number]
   ): AABB {
@@ -65,7 +65,7 @@ export class AABB {
     }
   }
 
-  static Merge(...aabbList: AABB[]) {
+  static merge(...aabbList: AABB[]) {
     let [xMin, yMin, xMax, yMax] = [Infinity, Infinity, -Infinity, -Infinity]
     aabbList.forEach((aabb) => {
       xMin = min(xMin, aabb.minX)
@@ -76,7 +76,7 @@ export class AABB {
     return new AABB(xMin, yMin, xMax, yMax)
   }
 
-  static FromOBB(obb: OBB) {
+  static fromOBB(obb: OBB) {
     const width = obb.projectionLengthAt(xy_(1, 0))
     const height = obb.projectionLengthAt(xy_(0, 1))
     return new AABB(

package/src/angle.ts

@@ -1,52 +1,52 @@
 export const { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math
 
 export class Angle {
-  static Cos(angle: number) {
-    return cos(Angle.RadianFy(angle))
+  static cos(angle: number) {
+    return cos(Angle.radianFy(angle))
   }
 
-  static Sin(angle: number) {
-    return sin(Angle.RadianFy(angle))
+  static sin(angle: number) {
+    return sin(Angle.radianFy(angle))
   }
 
-  static Tan(angle: number) {
-    return tan(Angle.RadianFy(angle))
+  static tan(angle: number) {
+    return tan(Angle.radianFy(angle))
   }
 
-  static ACos(angle: number) {
-    return Angle.AngleFy(acos(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 asin(angle: number) {
+    return Angle.angleFy(asin(Angle.radianFy(angle)))
   }
 
-  static ATan(angle: number) {
-    return Angle.AngleFy(atan(Angle.RadianFy(angle)))
+  static atan(angle: number) {
+    return Angle.angleFy(atan(Angle.radianFy(angle)))
   }
 
-  static ATan2(y: number, x: number) {
-    return Angle.AngleFy(atan2(y, x))
+  static atan2(y: number, x: number) {
+    return Angle.angleFy(atan2(y, x))
   }
 
-  static AngleFy(radians: number) {
+  static angleFy(radians: number) {
     return radians * (180 / Math.PI)
   }
 
-  static RadianFy(angle: number) {
+  static radianFy(angle: number) {
     return angle * (Math.PI / 180)
   }
 
-  static Normal(angle: number) {
+  static normal(angle: number) {
     return (angle + 360) % 360
   }
 
-  static Snap(angle: number, step = 90) {
-    return Angle.Normal(Math.round(angle / step) * step)
+  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)
+  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,

package/src/matrix.ts

@@ -6,11 +6,11 @@ import { xy_ } from './xy'
 export type IMatrix = [number, number, number, number, number, number]
 
 export class Matrix {
-  static Create() {
+  static create() {
     return [1, 0, 0, 1, 0, 0] as IMatrix
   }
 
-  static Invert(matrix: 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(
@@ -18,18 +18,18 @@ export class Matrix {
     ) as IMatrix
   }
 
-  static ApplyPoint(xy: IXY, matrix: 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) {
+  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)
+    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),
@@ -38,11 +38,11 @@ export class Matrix {
     }
   }
 
-  static InvertPoint(xy: IXY, matrix: IMatrix) {
-    return Matrix.ApplyPoint(xy, Matrix.Invert(matrix))
+  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))
+  static invertAABB(aabb: AABB, matrix: IMatrix) {
+    return Matrix.applyAABB(aabb, Matrix.invert(matrix))
   }
 }

package/src/obb.ts

@@ -21,7 +21,7 @@ export class OBB {
     this.center = this.#calcCenter()
     this.axis = this.#calcAxis()
     this.vertexes = this.calcVertexXY()
-    this.aabb = AABB.FromOBB(this)
+    this.aabb = AABB.fromOBB(this)
   }
 
   get xy() {
@@ -34,16 +34,16 @@ export class OBB {
   }
 
   #calcAxis = () => {
-    const cos = Angle.Cos(this.rotation)
-    const sin = Angle.Sin(this.rotation)
+    const cos = Angle.cos(this.rotation)
+    const sin = Angle.sin(this.rotation)
     const widthAxis = xy_(cos, -sin)
     const heightAxis = xy_(sin, cos)
     return (this.axis = { widthAxis, heightAxis })
   }
 
   calcVertexXY = () => {
-    const cos = Angle.Cos(this.rotation)
-    const sin = Angle.Sin(this.rotation)
+    const cos = Angle.cos(this.rotation)
+    const sin = Angle.sin(this.rotation)
     const cosWidth = cos * this.width
     const sinWidth = sin * this.width
     const cosHeight = cos * this.height
@@ -92,16 +92,16 @@ export class OBB {
     return true
   }
 
-  static IdentityOBB() {
+  static identityOBB() {
     return new OBB(0, 0, 0, 0, 0)
   }
 
-  static FromRect(rect: IRect, rotation = 0): OBB {
+  static fromRect(rect: IRect, rotation = 0): OBB {
     const { x, y, width, height } = rect
     return new OBB(x, y, width, height, rotation)
   }
 
-  static FromAABB(aabb: AABB): OBB {
+  static fromAABB(aabb: AABB): OBB {
     const { minX, minY, maxX, maxY } = aabb
     return new OBB(minX, minY, maxX - minX, maxY - minY, 0)
   }

package/src/xy.ts

@@ -63,7 +63,7 @@ export function xy_distance(self: IXY, another: IXY = xy_(0, 0)) {
 
 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)
+  return Angle.rotatePoint(self.x, self.y, origin.x, origin.y, rotation)
 }
 
 export function xy_dot(self: IXY, another: IXY) {
@@ -79,7 +79,7 @@ export function xy_opposite(self: IXY) {
 }
 
 export function xy_getRotation(self: IXY, another: IXY, origin: IXY) {
-  return Angle.AngleFy(
+  return Angle.angleFy(
     Math.atan2(self.y - origin.y, self.x - origin.x) -
       Math.atan2(another.y - origin.y, another.x - origin.x),
   )
@@ -90,11 +90,11 @@ export function xy_toArray(self: IXY) {
 }
 
 export function xy_xAxis(rotation: number) {
-  return { x: Angle.Cos(rotation), y: Angle.Sin(rotation) }
+  return { x: Angle.cos(rotation), y: Angle.sin(rotation) }
 }
 
 export function xy_yAxis(rotation: number) {
-  return { x: -Angle.Sin(rotation), y: Angle.Cos(rotation) }
+  return { x: -Angle.sin(rotation), y: Angle.cos(rotation) }
 }
 
 export class XY {
@@ -153,7 +153,7 @@ export class XY {
 
   rotate(origin: IXY, rotation: number) {
     if (rotation === 0) return this
-    return Angle.RotatePoint(this.x, this.y, origin.x, origin.y, rotation)
+    return Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation)
   }
 
   dot(another: IXY) {
@@ -169,17 +169,17 @@ export class XY {
   }
 
   angle(another: IXY, origin: IXY) {
-    return Angle.AngleFy(
+    return Angle.angleFy(
       Math.atan2(this.y - origin.y, this.x - origin.x) -
         Math.atan2(another.y - origin.y, another.x - origin.x),
     )
   }
 
-  static From(xy: IXY) {
+  static from(xy: IXY) {
     return new XY(xy.x, xy.y)
   }
 
-  static FromArray(arr: [number, number]) {
+  static fromArray(arr: [number, number]) {
     return new XY(arr[0], arr[1])
   }
 }