@gitborlando/geo 1.0.1

package/__test__/xy.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest'
+import {
+  XY,
+  xy_,
+  xy_center,
+  xy_client,
+  xy_distance,
+  xy_divide,
+  xy_dot,
+  xy_from,
+  xy_minus,
+  xy_multiply,
+  xy_mutate,
+  xy_opposite,
+  xy_plus,
+  xy_toArray,
+} from '../src/xy'
+
+describe('XY utilities', () => {
+  it('should create xy point correctly', () => {
+    const point = xy_(10, 20)
+    expect(point.x).toBe(10)
+    expect(point.y).toBe(20)
+  })
+
+  it('should create xy from client event correctly', () => {
+    const event = { clientX: 100, clientY: 200 }
+    const point = xy_client(event)
+    expect(point.x).toBe(100)
+    expect(point.y).toBe(200)
+  })
+
+  it('should copy xy point correctly', () => {
+    const original = { x: 5, y: 10 }
+    const copy = xy_from(original)
+    expect(copy.x).toBe(5)
+    expect(copy.y).toBe(10)
+  })
+
+  it('should get center point correctly', () => {
+    const rect = { centerX: 50, centerY: 75 }
+    const center = xy_center(rect)
+    expect(center.x).toBe(50)
+    expect(center.y).toBe(75)
+  })
+
+  it('should mutate xy point correctly', () => {
+    const point1 = { x: 1, y: 2 }
+    const point2 = { x: 3, y: 4 }
+    xy_mutate(point1, point2)
+    expect(point1.x).toBe(3)
+    expect(point1.y).toBe(4)
+  })
+
+  it('should add xy points correctly', () => {
+    const point1 = { x: 1, y: 2 }
+    const point2 = { x: 3, y: 4 }
+    const result = xy_plus(point1, point2)
+    expect(result.x).toBe(4)
+    expect(result.y).toBe(6)
+  })
+
+  it('should subtract xy points correctly', () => {
+    const point1 = { x: 5, y: 8 }
+    const point2 = { x: 2, y: 3 }
+    const result = xy_minus(point1, point2)
+    expect(result.x).toBe(3)
+    expect(result.y).toBe(5)
+  })
+
+  it('should multiply xy point correctly', () => {
+    const point = { x: 2, y: 3 }
+    const result = xy_multiply(point, 2, 3)
+    expect(result.x).toBe(12)
+    expect(result.y).toBe(18)
+  })
+
+  it('should divide xy point correctly', () => {
+    const point = { x: 12, y: 18 }
+    const result = xy_divide(point, 2, 3)
+    expect(result.x).toBe(2)
+    expect(result.y).toBe(3)
+  })
+
+  it('should calculate distance correctly', () => {
+    const point1 = { x: 0, y: 0 }
+    const point2 = { x: 3, y: 4 }
+    const distance = xy_distance(point1, point2)
+    expect(distance).toBe(5)
+  })
+
+  it('should calculate dot product correctly', () => {
+    const point1 = { x: 2, y: 3 }
+    const point2 = { x: 4, y: 5 }
+    const dot = xy_dot(point1, point2)
+    expect(dot).toBe(23) // 2*4 + 3*5 = 8 + 15 = 23
+  })
+
+  it('should get opposite point correctly', () => {
+    const point = { x: 3, y: -4 }
+    const opposite = xy_opposite(point)
+    expect(opposite.x).toBe(-3)
+    expect(opposite.y).toBe(4)
+  })
+
+  it('should convert to array correctly', () => {
+    const point = { x: 7, y: 11 }
+    const array = xy_toArray(point)
+    expect(array).toEqual([7, 11])
+  })
+})
+
+describe('XY class', () => {
+  it('should create XY instance correctly', () => {
+    const xy = new XY(10, 20)
+    expect(xy.x).toBe(10)
+    expect(xy.y).toBe(20)
+  })
+
+  it('should create from point correctly', () => {
+    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])
+    expect(xy.x).toBe(15)
+    expect(xy.y).toBe(25)
+  })
+
+  it('should perform chained operations correctly', () => {
+    const xy = new XY(2, 3).plus({ x: 1, y: 2 }).multiply(2)
+    expect(xy.x).toBe(6) // (2+1)*2 = 6
+    expect(xy.y).toBe(10) // (3+2)*2 = 10
+  })
+
+  it('should calculate distance correctly', () => {
+    const xy = new XY(0, 0)
+    const distance = xy.distance({ x: 3, y: 4 })
+    expect(distance).toBe(5)
+  })
+})

package/dist/index.d.ts

@@ -0,0 +1,245 @@
+interface IXY {
+    x: number;
+    y: number;
+}
+interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface IRectWithCenter extends IRect {
+    centerX: number;
+    centerY: number;
+}
+
+type IAxis = {
+    widthAxis: IXY;
+    heightAxis: IXY;
+};
+declare class OBB {
+    #private;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    center: IXY;
+    axis: IAxis;
+    aabb: AABB;
+    vertexes: [IXY, IXY, IXY, IXY];
+    constructor(x: number, y: number, width: number, height: number, rotation: number);
+    get xy(): {
+        x: number;
+        y: number;
+    };
+    calcVertexXY: () => [{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }];
+    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;
+}
+
+declare class AABB {
+    minX: number;
+    minY: number;
+    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;
+}
+
+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 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;
+    };
+}
+
+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;
+
+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);
+    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): {
+        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;
+}
+
+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 };