@gitborlando/geo 2.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @gitborlando/geo
 
+## 3.0.0
+
+### Major Changes
+
+- f121a3e: XY类破坏性更新
+
+## 2.1.0
+
+### Minor Changes
+
+- 7bd75bc: 新增一些方法
+
 ## 2.0.0
 
 ### Major Changes

package/__test__/xy.test.ts

@@ -124,7 +124,7 @@ describe('XY class', () => {
   })
 
   it('should create from array correctly', () => {
-    const xy = XY.fromArray([15, 25])
+    const xy = XY.tuple([15, 25])
     expect(xy.x).toBe(15)
     expect(xy.y).toBe(25)
   })
@@ -137,7 +137,7 @@ describe('XY class', () => {
 
   it('should calculate distance correctly', () => {
     const xy = new XY(0, 0)
-    const distance = xy.distance({ x: 3, y: 4 })
+    const distance = xy.getDistance({ x: 3, y: 4 })
     expect(distance).toBe(5)
   })
 })

package/dist/index.d.ts

@@ -51,6 +51,7 @@ declare class OBB {
     collide: (another: OBB) => boolean;
     static identityOBB(): OBB;
     static fromRect(rect: IRect, rotation?: number): OBB;
+    static fromCenter(center: IXY, width: number, height: number, rotation?: number): OBB;
     static fromAABB(aabb: AABB): OBB;
 }
 
@@ -107,6 +108,7 @@ declare function pow3(number: number): number;
 declare function multiply(...numbers: number[]): number;
 declare function divide(a: number, b: number): number;
 declare function numberHalfFix(number: number): number;
+declare function twoDecimal(number: number): number;
 
 type IMatrix = [number, number, number, number, number, number];
 declare class Matrix {
@@ -210,36 +212,30 @@ declare class XY {
     x: number;
     y: number;
     constructor(x: number, y: number);
-    from(xy: IXY): this;
-    client(e: {
-        clientX: number;
-        clientY: number;
-    }): this;
-    center(xy: {
+    plus(...others: IXY[]): XY;
+    minus(...others: IXY[]): XY;
+    multiply(...numbers: number[]): XY;
+    divide(...numbers: number[]): XY;
+    rotate(origin: IXY, rotation: number): XY;
+    symmetric(another: IXY, origin: IXY): XY;
+    getDot(another: IXY): number;
+    getDistance(another: IXY): number;
+    getAngle(another: IXY, origin: IXY): number;
+    static of(x: number, y: number): XY;
+    static from(xy: IXY): XY;
+    static center(xy: {
         centerX: number;
         centerY: number;
-    }): this;
-    plus(another: IXY): this;
-    minus(another: IXY): this;
-    multiply(...numbers: number[]): this;
-    divide(...numbers: number[]): this;
-    distance(another: IXY): number;
-    rotate(origin: IXY, rotation: number): {
-        x: number;
-        y: number;
-    };
-    dot(another: IXY): number;
-    opposite(): {
-        x: number;
-        y: number;
-    };
-    symmetric(another: IXY, origin: IXY): {
-        x: number;
-        y: number;
-    };
-    angle(another: IXY, origin: IXY): number;
-    static from(xy: IXY): XY;
-    static fromArray(arr: [number, number]): XY;
+    }): XY;
+    static leftTop(e: {
+        left: number;
+        top: number;
+    }): XY;
+    static client(e: {
+        clientX: number;
+        clientY: number;
+    }): XY;
+    static tuple(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 };
+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, twoDecimal, 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

@@ -18,6 +18,9 @@ function numberHalfFix(number) {
   const halfFixed = floatPart >= 0.75 ? 1 : floatPart >= 0.25 ? 0.5 : 0;
   return integerPart + halfFixed;
 }
+function twoDecimal(number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2));
+}
 
 // src/angle.ts
 var { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math;
@@ -146,69 +149,59 @@ var XY = class _XY {
     this.x = x;
     this.y = y;
   }
-  from(xy) {
-    this.x = xy.x;
-    this.y = xy.y;
-    return this;
-  }
-  client(e) {
-    this.x = e.clientX;
-    this.y = e.clientY;
-    return this;
-  }
-  center(xy) {
-    this.x = xy.centerX;
-    this.y = xy.centerY;
-    return this;
-  }
-  plus(another) {
-    this.x = this.x + another.x;
-    this.y = this.y + another.y;
-    return this;
+  plus(...others) {
+    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);
   }
-  minus(another) {
-    this.x = this.x - another.x;
-    this.y = this.y - another.y;
-    return this;
+  minus(...others) {
+    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);
   }
   multiply(...numbers) {
     const n = numbers.reduce((a, b) => a * b, 1);
-    this.x = this.x * n;
-    this.y = this.y * n;
-    return this;
+    return _XY.of(this.x * n, this.y * n);
   }
   divide(...numbers) {
     const n = numbers.reduce((a, b) => a * b, 1);
-    this.x = this.x / n;
-    this.y = this.y / n;
-    return this;
-  }
-  distance(another) {
-    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2);
+    return _XY.of(this.x / n, this.y / n);
   }
   rotate(origin, rotation) {
-    if (rotation === 0) return this;
-    return Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation);
+    if (rotation === 0) return _XY.from(this);
+    return _XY.from(Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation));
   }
-  dot(another) {
-    return this.x * another.x + this.y * another.y;
+  symmetric(another, origin) {
+    return _XY.of(2 * origin.x - another.x, 2 * origin.y - another.y);
   }
-  opposite() {
-    return { x: -this.x, y: -this.y };
+  getDot(another) {
+    return this.x * another.x + this.y * another.y;
   }
-  symmetric(another, origin) {
-    return { x: 2 * origin.x - another.x, y: 2 * origin.y - another.y };
+  getDistance(another) {
+    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2);
   }
-  angle(another, origin) {
+  getAngle(another, origin) {
     return Angle.angleFy(
       Math.atan2(this.y - origin.y, this.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
     );
   }
+  static of(x, y) {
+    return new _XY(x, y);
+  }
   static from(xy) {
-    return new _XY(xy.x, xy.y);
+    return _XY.of(xy.x, xy.y);
   }
-  static fromArray(arr) {
-    return new _XY(arr[0], arr[1]);
+  static center(xy) {
+    return _XY.of(xy.centerX, xy.centerY);
+  }
+  static leftTop(e) {
+    return _XY.of(e.left, e.top);
+  }
+  static client(e) {
+    return _XY.of(e.clientX, e.clientY);
+  }
+  static tuple(arr) {
+    return _XY.of(arr[0], arr[1]);
   }
 };
 
@@ -388,6 +381,12 @@ var OBB = class _OBB {
     const { x, y, width, height } = rect;
     return new _OBB(x, y, width, height, rotation);
   }
+  static fromCenter(center, width, height, rotation = 0) {
+    const dx = center.x - width / 2;
+    const dy = center.y - height / 2;
+    const xy = XY.of(dx, dy).rotate(center, rotation);
+    return new _OBB(xy.x, xy.y, width, height, rotation);
+  }
   static fromAABB(aabb) {
     const { minX, minY, maxX, maxY } = aabb;
     return new _OBB(minX, minY, maxX - minX, maxY - minY, 0);
@@ -533,6 +532,7 @@ export {
   sin,
   sqrt,
   tan,
+  twoDecimal,
   xy_,
   xy_center,
   xy_client,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitborlando/geo",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "",
   "type": "module",
   "exports": {

package/src/math.ts

@@ -20,3 +20,7 @@ export function numberHalfFix(number: number) {
   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/obb.ts

@@ -1,7 +1,7 @@
 import { AABB } from './aabb'
 import { Angle } from './angle'
 import { IRect, IXY } from './types'
-import { xy_, xy_dot, xy_minus, xy_rotate } from './xy'
+import { XY, xy_, xy_dot, xy_minus, xy_rotate } from './xy'
 
 type IAxis = { widthAxis: IXY; heightAxis: IXY }
 
@@ -101,6 +101,13 @@ export class OBB {
     return new OBB(x, y, width, height, rotation)
   }
 
+  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)
+    return new OBB(xy.x, xy.y, width, height, rotation)
+  }
+
   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

@@ -102,84 +102,73 @@ export class XY {
     public x: number,
     public y: number,
   ) {}
-
-  from(xy: IXY) {
-    this.x = xy.x
-    this.y = xy.y
-    return this
-  }
-
-  client(e: { clientX: number; clientY: number }) {
-    this.x = e.clientX
-    this.y = e.clientY
-    return this
-  }
-
-  center(xy: { centerX: number; centerY: number }) {
-    this.x = xy.centerX
-    this.y = xy.centerY
-    return this
-  }
-
-  plus(another: IXY) {
-    this.x = this.x + another.x
-    this.y = this.y + another.y
-    return this
+  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)
   }
 
-  minus(another: IXY) {
-    this.x = this.x - another.x
-    this.y = this.y - another.y
-    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)
   }
 
   multiply(...numbers: number[]) {
     const n = numbers.reduce((a, b) => a * b, 1)
-    this.x = this.x * n
-    this.y = this.y * n
-    return this
+    return XY.of(this.x * n, this.y * n)
   }
 
   divide(...numbers: number[]) {
     const n = numbers.reduce((a, b) => a * b, 1)
-    this.x = this.x / n
-    this.y = this.y / n
-    return this
-  }
-
-  distance(another: IXY) {
-    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2)
+    return XY.of(this.x / n, this.y / n)
   }
 
   rotate(origin: IXY, rotation: number) {
-    if (rotation === 0) return this
-    return Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation)
+    if (rotation === 0) return XY.from(this)
+    return XY.from(Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation))
   }
 
-  dot(another: IXY) {
-    return this.x * another.x + this.y * another.y
+  symmetric(another: IXY, origin: IXY) {
+    return XY.of(2 * origin.x - another.x, 2 * origin.y - another.y)
   }
 
-  opposite() {
-    return { x: -this.x, y: -this.y }
+  getDot(another: IXY) {
+    return this.x * another.x + this.y * another.y
   }
 
-  symmetric(another: IXY, origin: IXY) {
-    return { x: 2 * origin.x - another.x, y: 2 * origin.y - another.y }
+  getDistance(another: IXY) {
+    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2)
   }
 
-  angle(another: IXY, origin: IXY) {
+  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 of(x: number, y: number) {
+    return new XY(x, y)
+  }
+
   static from(xy: IXY) {
-    return new XY(xy.x, xy.y)
+    return XY.of(xy.x, xy.y)
+  }
+
+  static center(xy: { centerX: number; centerY: number }) {
+    return XY.of(xy.centerX, xy.centerY)
+  }
+
+  static leftTop(e: { left: number; top: number }) {
+    return XY.of(e.left, e.top)
+  }
+
+  static client(e: { clientX: number; clientY: number }) {
+    return XY.of(e.clientX, e.clientY)
   }
 
-  static fromArray(arr: [number, number]) {
-    return new XY(arr[0], arr[1])
+  static tuple(arr: [number, number]) {
+    return XY.of(arr[0], arr[1])
   }
 }