@gitborlando/geo 2.1.0 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @gitborlando/geo
 
+## 3.1.0
+
+### Minor Changes
+
+- 2b4693c: 更新xy类
+- 0ee9da2: XY类小幅更新
+
+## 3.0.0
+
+### Major Changes
+
+- f121a3e: XY类破坏性更新
+
 ## 2.1.0
 
 ### Minor 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

@@ -212,37 +212,38 @@ 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: {
-        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): {
+    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;
+    primitive(): {
         x: number;
         y: number;
     };
-    dot(another: IXY): number;
-    opposite(): {
+    static _(x?: number, y?: number): {
         x: number;
         y: number;
     };
-    symmetric(another: IXY, origin: IXY): {
-        x: number;
-        y: number;
-    };
-    angle(another: IXY, origin: IXY): number;
     static of(x: number, y: number): XY;
     static from(xy: IXY): XY;
-    static fromArray(arr: [number, number]): XY;
+    static center(xy: {
+        centerX: number;
+        centerY: number;
+    }): 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, 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

@@ -149,72 +149,66 @@ 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;
-  }
-  minus(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(...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)
     );
   }
+  primitive() {
+    return { x: this.x, y: this.y };
+  }
+  static _(x = 0, y = 0) {
+    return { x, y };
+  }
   static of(x, y) {
     return new _XY(x, y);
   }
   static from(xy) {
-    return new _XY(xy.x, xy.y);
+    if (xy instanceof _XY) return xy;
+    return _XY.of(xy.x, xy.y);
+  }
+  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 fromArray(arr) {
-    return new _XY(arr[0], arr[1]);
+  static tuple(arr) {
+    return _XY.of(arr[0], arr[1]);
   }
 };
 

package/package.json

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

package/src/xy.ts

@@ -102,88 +102,82 @@ 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),
     )
   }
 
+  primitive() {
+    return { x: this.x, y: this.y }
+  }
+
+  static _(x: number = 0, y: number = 0) {
+    return { x, y }
+  }
+
   static of(x: number, y: number) {
     return new XY(x, y)
   }
 
   static from(xy: IXY) {
-    return new XY(xy.x, xy.y)
+    if (xy instanceof XY) return xy
+    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])
   }
 }