better typings for vectors classes

Author: LCluber

.size-snapshot.json

@@ -29,9 +29,9 @@
     "gzipped": 4836
   },
   "type6.js": {
-    "bundled": 31154,
-    "minified": 16069,
-    "gzipped": 4042,
+    "bundled": 31220,
+    "minified": 16113,
+    "gzipped": 4047,
     "treeshaked": {
       "rollup": {
         "code": 2944,

CHANGELOG.md

@@ -1,3 +1,7 @@
+Version 3.0.0-beta.1 (May 7th 2021)
+-----------------------------
+ * improved typings for Vector2 and Vector3 use with Typescript
+
 Version 3.0.0-beta.0 (May 5th 2021)
 -----------------------------
  * Vector class:
@@ -7,11 +11,12 @@ Version 3.0.0-beta.0 (May 5th 2021)
     * Constructor now accept numbers, array or Vector2 as parameters
     * set() method now accept numbers, array or Vector2 as parameters 
     * Delete copy() and setFromAngle() methods
-    * Add setFromRadian(), setFromDegree, setMinAxis(), setMaxAxis() methods
+    * Add isEqualTo(), setFromRadian(), setFromDegree, setMinAxis(), setMaxAxis() methods
     * opposite() and absolute() methods now accept an axis name as parameter to set only this axis.
  * Vector3 class:
     * Constructor now accept numbers, array or Vector3 as parameters
     * set() method now accept numbers, array or Vector3 as parameters
+    * Add isEqualTo() method
     * Delete copy() method
  * Circle class:
     * First parameter of set() method and constructor is now Radius.

dist/type6.cjs.js

@@ -336,6 +336,9 @@ class Vector {
     isEqualTo(scalar) {
         return this.compareAxes('!==', scalar);
     }
+    isOrigin() {
+        return this.compareAxes('!==', 0);
+    }
     toArray() {
         let array = [];
         for (const axis in this) {

dist/type6.d.ts

@@ -211,6 +211,8 @@ export declare class Utils {
     static isIn(x: number, min: number, max: number): boolean;
     static isOut(x: number, min: number, max: number): boolean;
 }
+
+
 export interface Vector {
     'x': number;
     'y': number;
@@ -222,36 +224,37 @@ export declare class Vector {
     constructor();
     isPositive(): boolean;
     isEqualTo(scalar: number): boolean;
+    isOrigin(): boolean;
     toArray(): number[];
     toString(): string;
-    origin(): Vector;
+    origin(): Vector2 | Vector3;
     getMagnitude(square?: boolean): number;
     private getSquaredMagnitude;
-    getDistance(v: Vector, square?: boolean): number;
-    add(v: Vector): Vector;
-    addScaledVector(v: Vector, scalar: number): Vector;
-    addScalar(scalar: number): Vector;
-    subtract(v: Vector): Vector;
-    subtractScaledVector(v: Vector, scalar: number): Vector;
-    subtractScalar(scalar: number): Vector;
-    multiply(v: Vector): Vector;
-    multiplyScaledVector(v: Vector, scalar: number): Vector;
-    scale(scalar: number): Vector;
-    divide(v: Vector): Vector;
-    divideScaledVector(v: Vector, scalar: number): Vector;
-    halve(): Vector;
-    max(v: Vector): Vector;
-    min(v: Vector): Vector;
-    maxScalar(scalar: number): Vector;
-    minScalar(scalar: number): Vector;
-    normalize(): Vector;
-    absolute(a?: 'x' | 'y' | 'z'): Vector;
-    opposite(a?: 'x' | 'y' | 'z'): Vector;
-    dotProduct(v: Vector): number;
+    getDistance(v: Vector2 | Vector3, square?: boolean): number;
+    add(v: Vector2 | Vector3): Vector2 | Vector3;
+    addScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3;
+    addScalar(scalar: number): Vector2 | Vector3;
+    subtract(v: Vector2 | Vector3): Vector2 | Vector3;
+    subtractScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3;
+    subtractScalar(scalar: number): Vector2 | Vector3;
+    multiply(v: Vector2 | Vector3): Vector2 | Vector3;
+    multiplyScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3;
+    scale(scalar: number): Vector2 | Vector3;
+    divide(v: Vector2 | Vector3): Vector2 | Vector3;
+    divideScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3;
+    halve(): Vector2 | Vector3;
+    max(v: Vector2 | Vector3): Vector2 | Vector3;
+    min(v: Vector2 | Vector3): Vector2 | Vector3;
+    maxScalar(scalar: number): Vector2 | Vector3;
+    minScalar(scalar: number): Vector2 | Vector3;
+    normalize(): Vector2 | Vector3;
+    absolute(a?: 'x' | 'y' | 'z'): Vector2 | Vector3;
+    opposite(a?: 'x' | 'y' | 'z'): Vector2 | Vector3;
+    dotProduct(v: Vector2 | Vector3): number;
     protected setFromArray(array: number[]): void;
-    protected copy(v: Vector): Vector;
+    protected copy(v: Vector2 | Vector3): Vector2 | Vector3;
     private compareAxes;
-    protected updateAxes(operator: UpdateOperator, scalar: number): Vector;
+    protected updateAxes(operator: UpdateOperator, scalar: number): Vector2 | Vector3;
     private updateAxesByVector;
     private updateAxesWithMath;
     private updateAxesWithMathByVector;

dist/type6.iife.js

@@ -586,6 +586,11 @@ var Type6 = (function (exports) {
       value: function isEqualTo(scalar) {
         return this.compareAxes('!==', scalar);
       }
+    }, {
+      key: "isOrigin",
+      value: function isOrigin() {
+        return this.compareAxes('!==', 0);
+      }
     }, {
       key: "toArray",
       value: function toArray() {

dist/type6.iife.min.js

@@ -334,6 +334,9 @@ class Vector {
     isEqualTo(scalar) {
         return this.compareAxes('!==', scalar);
     }
+    isOrigin() {
+        return this.compareAxes('!==', 0);
+    }
     toArray() {
         let array = [];
         for (const axis in this) {

dist/type6.js

@@ -1,6 +1,6 @@
 {
   "name": "@lcluber/type6js",
-  "version": "3.0.0-beta.0",
+  "version": "3.0.0-beta.1",
   "description": "Mathematics library for Javascript",
   "keywords": [
     "maths",

package.json

@@ -1,3 +1,5 @@
+import { Vector2 } from './vector2';
+import { Vector3 } from './vector3';
 
 export interface Vector {
   'x': number;
@@ -20,11 +22,16 @@ export class Vector {
     return this.compareAxes('<=', 0);
   }
 
-  //true if vector is equal to (scalar;scalar)
+  //true if vector2 is equal to (scalar;scalar)
   public isEqualTo(scalar: number): boolean {
     return this.compareAxes('!==', scalar);
   }
 
+  //true if vector2 is equal to (0;0)
+  public isOrigin(): boolean {
+    return this.compareAxes('!==', 0);
+  }
+
   public toArray(): number[] {
     let array = [];
     for(const axis in this) {
@@ -46,7 +53,7 @@ export class Vector {
     // '(x = ' + this.x + '; y = ' + this.y + '; z = ' + this.z + ')';
   }
 
-  public origin(): Vector {
+  public origin(): Vector2 | Vector3 {
     return this.updateAxes('=', 0.0);
   }
 
@@ -65,109 +72,109 @@ export class Vector {
     return squaredMagnitude;
   }
 
-  public getDistance(v: Vector, square: boolean = false): number {
+  public getDistance(v: Vector2 | Vector3, square: boolean = false): number {
     this.subtract(v);
     const magnitude = this.getMagnitude(square);
     this.add(v);
     return magnitude;
   }
 
-  public add(v: Vector): Vector {
+  public add(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesByVector('+=', v, null);
   }
 
-  public addScaledVector(v: Vector, scalar: number): Vector {
+  public addScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3 {
     return this.updateAxesByVector('+=', v, scalar);
   }
 
-  public addScalar(scalar: number): Vector {
+  public addScalar(scalar: number): Vector2 | Vector3 {
     return this.updateAxes('+=', scalar);
   }
 
-  public subtract(v: Vector): Vector {
+  public subtract(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesByVector('-=', v, null);
   }
 
-  public subtractScaledVector(v: Vector, scalar: number): Vector {
+  public subtractScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3 {
     return this.updateAxesByVector('-=', v, scalar);
   }
 
-  public subtractScalar(scalar: number): Vector {
+  public subtractScalar(scalar: number): Vector2 | Vector3 {
     return this.updateAxes('-=', scalar);
   }
 
   //component product
-  public multiply(v: Vector): Vector {
+  public multiply(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesByVector('*=', v, null);
   }
 
-  public multiplyScaledVector(v: Vector, scalar: number): Vector {
+  public multiplyScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3 {
     return this.updateAxesByVector('*=', v, scalar);
   }
 
-  public scale(scalar: number): Vector {
+  public scale(scalar: number): Vector2 | Vector3 {
     return this.updateAxes('*=', scalar);
   }
 
-  public divide(v: Vector): Vector {
+  public divide(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesByVector('/=', v, null);
   }
 
-  public divideScaledVector(v: Vector, scalar: number): Vector {
+  public divideScaledVector(v: Vector2 | Vector3, scalar: number): Vector2 | Vector3 {
     return this.updateAxesByVector('/=', v, scalar);
   }
 
-  public halve(): Vector {
+  public halve(): Vector2 | Vector3 {
     return this.updateAxes('*=', 0.5);
   }
 
-  public max(v: Vector): Vector {
+  public max(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesWithMathByVector(v, 'max');
   }
 
-  public min(v: Vector): Vector {
+  public min(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesWithMathByVector(v, 'min');
   }
 
-  public maxScalar(scalar: number): Vector {
+  public maxScalar(scalar: number): Vector2 | Vector3 {
     return this.updateAxesWithMath(scalar, 'max');
   }
 
-  public minScalar(scalar: number): Vector {
+  public minScalar(scalar: number): Vector2 | Vector3 {
     return this.updateAxesWithMath(scalar, 'min');
   }
 
-  public normalize(): Vector {
+  public normalize(): Vector2 | Vector3 {
     let length = this.getMagnitude();
     if( length && length != 1) {
       this.scale(1/length);
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  public absolute(a?: 'x' | 'y' | 'z'): Vector {
+  public absolute(a?: 'x' | 'y' | 'z'): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis)) {
         if (!a || a === axis) {
           (this[axis] as number) = Math.abs(this[axis]);
         }
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  public opposite(a?: 'x' | 'y' | 'z'): Vector {
+  public opposite(a?: 'x' | 'y' | 'z'): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis)) {
         if (!a || a === axis) {
           (this[axis] as number) = -this[axis];
         }
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  public dotProduct(v: Vector): number { //scalar product
+  public dotProduct(v: Vector2 | Vector3): number { //scalar product
     let dotProduct = 0;
     for(const axis in this) {
       if (this.hasOwnProperty(axis) && v.hasOwnProperty(axis)) {
@@ -190,7 +197,7 @@ export class Vector {
     }
   }
 
-  protected copy(v: Vector): Vector {
+  protected copy(v: Vector2 | Vector3): Vector2 | Vector3 {
     return this.updateAxesByVector('=', v, null);
   }
 
@@ -205,40 +212,40 @@ export class Vector {
     return true;
   }
 
-  protected updateAxes(operator: UpdateOperator, scalar: number): Vector {
+  protected updateAxes(operator: UpdateOperator, scalar: number): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis)) {
         this[operator](axis, scalar);
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  private updateAxesByVector(operator: UpdateOperator, vector: Vector, scalar: number | null): Vector {
+  private updateAxesByVector(operator: UpdateOperator, vector: Vector2 | Vector3, scalar: number | null): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis) && vector.hasOwnProperty(axis)) {
         this[operator](axis, vector[axis] * (scalar ?? 1.0));
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  private updateAxesWithMath(scalar: number, operator: 'max' | 'min'): Vector {
+  private updateAxesWithMath(scalar: number, operator: 'max' | 'min'): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis)) {
         (this[axis] as number) = Math[operator](this[axis], scalar);
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
-  private updateAxesWithMathByVector(v: Vector, operator: 'max' | 'min'): Vector {
+  private updateAxesWithMathByVector(v: Vector2 | Vector3, operator: 'max' | 'min'): Vector2 | Vector3 {
     for(const axis in this) {
       if (this.hasOwnProperty(axis) && v.hasOwnProperty(axis)) {
         (this[axis] as number) = Math[operator](this[axis], v[axis]);
       }
     }
-    return this;
+    return this as unknown as Vector2 | Vector3;
   }
 
   private '<='(axis: Extract<keyof this, string>, value: number): boolean {