@gitborlando/geo 4.1.1 → 5.1.0

package/dist/index.d.ts

@@ -47,7 +47,7 @@ declare class OBB {
         y: number;
     }];
     clone: () => OBB;
-    projectionLengthAt: (anotherAxis: IXY) => number;
+    projectAt: (anotherAxis: IXY) => number;
     collide: (another: OBB) => boolean;
     static identityOBB(): OBB;
     static fromRect(rect: IRect, rotation?: number): OBB;
@@ -63,180 +63,62 @@ declare class AABB {
     constructor(minX: number, minY: number, maxX: number, maxY: number);
     static rect(aabb: AABB): IRectWithCenter;
     static rectTuple(aabb: AABB): readonly [number, number, number, number];
+    static update(aabb: AABB, minX: number, minY: number, maxX: number, maxY: number): AABB;
+    static updateFromRect(aabb: AABB, rect: IRect): AABB;
+    static shift(aabb: AABB, delta: IXY): AABB;
     static collide(one: AABB, another: AABB): boolean;
     static include(one: AABB, another: AABB): number;
     static extend(aabb: AABB, ...expands: [number] | [number, number, number, number]): AABB;
-    static merge(...aabbList: AABB[]): AABB;
+    static merge(aabbList: AABB[] | Set<AABB>): AABB;
     static fromOBB(obb: OBB): AABB;
+    static updateFromOBB(aabb: AABB, obb: OBB): AABB;
 }
 
-declare const PI: number;
-declare const cos: (x: number) => number;
-declare const sin: (x: number) => number;
-declare const tan: (x: number) => number;
-declare const acos: (x: number) => number;
-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 cosSin(angle: number): {
+        cos: number;
+        sin: 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 minor(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;
-    };
+    static sweep(v1: IXY, v2?: IXY, clockwise?: boolean): number;
 }
 
-declare const sqrt: (x: number) => number;
-declare const abs: (x: number) => number;
-declare const min: (...values: number[]) => number;
-declare const max: (...values: number[]) => number;
-declare const round: (x: number) => number;
-declare const floor: (x: number) => number;
-declare const ceil: (x: number) => number;
-declare const random: () => number;
-declare function pow2(number: number): number;
-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;
+declare function minMax(val: number, min: number, max: 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): {
-        x: number;
-        y: number;
-    };
-    static applyAABB(aabb: AABB, matrix: IMatrix): {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    static invertPoint(xy: IXY, matrix: IMatrix): {
-        x: number;
-        y: number;
-    };
-    static invertAABB(aabb: AABB, matrix: IMatrix): {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-}
-
-type Point = {
-    x: number;
-    y: number;
-};
-declare function simplify(points: readonly Point[], distance: number): Point[];
-declare function simplifyPoints(points: readonly Point[], start: number, end: number, epsilon: number, newPoints?: Point[]): Point[];
-declare function pointsOnBezierCurves(points: readonly Point[], tolerance?: number, distance?: number): Point[];
-
-declare function xy_(x?: number, y?: number): {
-    x: number;
-    y: number;
-};
-declare function xy_client(e: any): {
-    x: any;
-    y: any;
-};
-declare function xy_from(xy: IXY): {
-    x: number;
-    y: number;
-};
-declare function xy_center(xy: {
-    centerX: number;
-    centerY: number;
-}): {
-    x: number;
-    y: number;
-};
-declare function xy_mutate(self: IXY, another: IXY): void;
-declare function xy_plus(self: IXY, another: IXY): {
-    x: number;
-    y: number;
-};
-declare function xy_plus_mutate(self: IXY, another: IXY): void;
-declare function xy_plus_all(...xys: IXY[]): IXY;
-declare function xy_minus(self: IXY, another: IXY): {
-    x: number;
-    y: number;
-};
-declare function xy_minus_mutate(self: IXY, another: IXY): void;
-declare function xy_multiply(self: IXY, ...numbers: number[]): {
-    x: number;
-    y: number;
-};
-declare function xy_multiply_mutate(self: IXY, ...numbers: number[]): void;
-declare function xy_divide(self: IXY, ...numbers: number[]): {
-    x: number;
-    y: number;
-};
-declare function xy_distance(self: IXY, another?: IXY): number;
-declare function xy_rotate(self: IXY, origin: IXY, rotation: number): {
-    x: number;
-    y: number;
-};
-declare function xy_dot(self: IXY, another: IXY): number;
-declare function xy_symmetric(self: IXY, origin: IXY): {
-    x: number;
-    y: number;
-};
-declare function xy_opposite(self: IXY): {
-    x: number;
-    y: number;
-};
-declare function xy_getRotation(self: IXY, another: IXY, origin: IXY): number;
-declare function xy_toArray(self: IXY): [number, number];
-declare function xy_xAxis(rotation: number): {
-    x: number;
-    y: number;
-};
-declare function xy_yAxis(rotation: number): {
-    x: number;
-    y: number;
-};
 declare class XY {
     x: number;
     y: number;
     constructor(x: number, y: number);
-    plain(): {
+    $(): {
         x: number;
         y: number;
     };
     tuple(): readonly [number, number];
-    plus(...others: IXY[]): XY;
-    minus(...others: IXY[]): XY;
-    multiply(...numbers: number[]): XY;
-    divide(...numbers: number[]): XY;
-    rotate(origin: IXY, rotation: number): XY;
-    symmetric(origin: IXY): XY;
-    ratio(another: IXY, t: number): XY;
-    getDot(another: IXY): number;
-    getDistance(another: IXY): number;
-    getAngle(another: IXY, origin: IXY): number;
-    static _(x?: number, y?: number): {
+    plus(...others: IXY[]): this;
+    plusNum(num: number): this;
+    minus(...others: IXY[]): this;
+    multiply(...numbers: number[]): this;
+    multiplyNum(num: number): this;
+    divide(...numbers: number[]): this;
+    rotate(origin: IXY, rotation: number): this;
+    static $(x?: number, y?: number): {
         x: number;
         y: number;
     };
-    static of(x: number, y: number): XY;
-    static from(xy: IXY): XY;
-    static center(xy: {
-        centerX: number;
-        centerY: number;
+    static of(xy: IXY): XY;
+    static from(x: number, y: number): XY;
+    static center(wh: {
+        width: number;
+        height: number;
     }): XY;
     static leftTop(e: {
         left: number;
@@ -246,9 +128,16 @@ declare class XY {
         clientX: number;
         clientY: number;
     }): XY;
-    static tuple(arr: [number, number]): XY;
-    static xAxis(rotation: number): XY;
-    static yAxis(rotation: number): XY;
+    static xAxis(rotation?: number): XY;
+    static yAxis(rotation?: number): XY;
+    static dot(self: IXY, another: IXY): number;
+    static distance(self: IXY, another: IXY): number;
+    static vector(self: IXY, another: IXY): XY;
+    static symmetric(self: IXY, origin?: {
+        x: number;
+        y: number;
+    }): XY;
+    static lerp(self: IXY, origin: IXY, t: 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 };
+export { AABB, Angle, type IRect, type IRectWithCenter, type IXY, OBB, XY, minMax, twoDecimal };