@vived/app 2.14.0 → 2.15.3

package/lib/ValueObjects/ParametricPlane.js

@@ -13,31 +13,31 @@ class ParametricPlane {
     }
     static FromThreePoints(A, B, C) {
         const point = A;
-        const AB = Vector3_1.Vector3.subtract(B, A);
-        const AC = Vector3_1.Vector3.subtract(C, A);
-        const normal = Vector3_1.Vector3.cross(AB, AC);
+        const AB = Vector3_1.Vector3.Subtract(B, A);
+        const AC = Vector3_1.Vector3.Subtract(C, A);
+        const normal = Vector3_1.Vector3.Cross(AB, AC);
         return new ParametricPlane(point, normal);
     }
     static XY() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const n = new Vector3_1.Vector3(0, 0, 1);
         return new ParametricPlane(p, n);
     }
     static ZX() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const n = new Vector3_1.Vector3(0, 1, 0);
         return new ParametricPlane(p, n);
     }
     static YZ() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const n = new Vector3_1.Vector3(1, 0, 0);
         return new ParametricPlane(p, n);
     }
-    getParameters() {
+    GetParameters() {
         const a = this.normal.x;
         const b = this.normal.y;
         const c = this.normal.z;
-        let d = Vector3_1.Vector3.dot(this.point, this.normal);
+        let d = Vector3_1.Vector3.Dot(this.point, this.normal);
         if (d !== 0) {
             d *= -1;
         }
@@ -50,14 +50,14 @@ class ParametricPlane {
     }
     intersectLine(line) {
         const { x0, y0, z0, a, b, c } = line;
-        const { a: A, b: B, c: C, d: D } = this.getParameters();
+        const { a: A, b: B, c: C, d: D } = this.GetParameters();
         const tNumerator = -(A * x0 + B * y0 + C * z0 + D);
         const tDenominator = A * a + B * b + C * c;
         if (tDenominator === 0) {
             return undefined;
         }
         const t = tNumerator / tDenominator;
-        const intersect = ParametricLine_1.ParametricLine.getPointAtDistance(line, t);
+        const intersect = ParametricLine_1.ParametricLine.GetPointAtDistance(line, t);
         return intersect;
     }
 }

package/lib/ValueObjects/Vector2.d.ts

@@ -1,17 +1,17 @@
 import { Angle } from ".";
 export declare class Vector2 {
     static zero(): Vector2;
-    static one(): Vector2;
-    static equal(a: Vector2, b: Vector2): boolean;
-    static add(a: Vector2, b: Vector2): Vector2;
-    static subtract(a: Vector2, b: Vector2): Vector2;
-    static close: (a: Vector2, b: Vector2, threshold?: number) => boolean;
-    static rotate: (vec: Vector2, angle: Angle) => Vector2;
-    static scale: (vector: Vector2, scale: number) => Vector2;
-    static newVectorOfLength: (vector: Vector2, length: number) => Vector2;
-    static dot: (a: Vector2, b: Vector2) => number;
-    static angleBetween: (a: Vector2, b: Vector2) => Angle;
-    static cross: (a: Vector2, b: Vector2) => number;
+    static One(): Vector2;
+    static Equal(a: Vector2, b: Vector2): boolean;
+    static Add(a: Vector2, b: Vector2): Vector2;
+    static Subtract(a: Vector2, b: Vector2): Vector2;
+    static Close: (a: Vector2, b: Vector2, threshold?: number) => boolean;
+    static Rotate: (vec: Vector2, angle: Angle) => Vector2;
+    static Scale: (vector: Vector2, scale: number) => Vector2;
+    static NewVectorOfLength: (vector: Vector2, length: number) => Vector2;
+    static Dot: (a: Vector2, b: Vector2) => number;
+    static AngleBetween: (a: Vector2, b: Vector2) => Angle;
+    static Cross: (a: Vector2, b: Vector2) => number;
     readonly x: number;
     readonly y: number;
     get magnitued(): number;

package/lib/ValueObjects/Vector2.js

@@ -10,20 +10,20 @@ class Vector2 {
     static zero() {
         return new Vector2(0, 0);
     }
-    static one() {
+    static One() {
         return new Vector2(1, 1);
     }
-    static equal(a, b) {
+    static Equal(a, b) {
         if (a.x !== b.x)
             return false;
         if (a.y !== b.y)
             return false;
         return true;
     }
-    static add(a, b) {
+    static Add(a, b) {
         return new Vector2(a.x + b.x, a.y + b.y);
     }
-    static subtract(a, b) {
+    static Subtract(a, b) {
         return new Vector2(a.x - b.x, a.y - b.y);
     }
     get magnitued() {
@@ -49,39 +49,39 @@ class Vector2 {
     }
 }
 exports.Vector2 = Vector2;
-Vector2.close = (a, b, threshold = 0.01) => {
-    const diff = Vector2.subtract(a, b);
+Vector2.Close = (a, b, threshold = 0.01) => {
+    const diff = Vector2.Subtract(a, b);
     const diffMag = diff.magnitued;
     if (diffMag < threshold)
         return true;
     else
         return false;
 };
-Vector2.rotate = (vec, angle) => {
+Vector2.Rotate = (vec, angle) => {
     const x = vec.x * Math.cos(angle.radians) - vec.y * Math.sin(angle.radians);
     const y = vec.x * Math.sin(angle.radians) + vec.y * Math.cos(angle.radians);
     return new Vector2(x, y);
 };
-Vector2.scale = (vector, scale) => {
+Vector2.Scale = (vector, scale) => {
     const x = scale * vector.x;
     const y = scale * vector.y;
     return new Vector2(x, y);
 };
-Vector2.newVectorOfLength = (vector, length) => {
+Vector2.NewVectorOfLength = (vector, length) => {
     const unit = vector.unit;
     const x = length * unit.x;
     const y = length * unit.y;
     return new Vector2(x, y);
 };
-Vector2.dot = (a, b) => {
+Vector2.Dot = (a, b) => {
     return a.x * b.x + a.y * b.y;
 };
-Vector2.angleBetween = (a, b) => {
-    const dot = Vector2.dot(a, b);
+Vector2.AngleBetween = (a, b) => {
+    const dot = Vector2.Dot(a, b);
     const magnitues = a.magnitued * b.magnitued;
     const angRadians = Math.acos(dot / magnitues);
-    return _1.Angle.fromRadians(angRadians);
+    return _1.Angle.FromRadians(angRadians);
 };
-Vector2.cross = (a, b) => {
+Vector2.Cross = (a, b) => {
     return a.x * b.y - a.y * b.x;
 };

package/lib/ValueObjects/Vector3.d.ts

@@ -1,20 +1,20 @@
 export declare class Vector3 {
-    static zero(): Vector3;
-    static one(): Vector3;
-    static right(length?: number): Vector3;
-    static left(length?: number): Vector3;
-    static up(length?: number): Vector3;
-    static down(length?: number): Vector3;
-    static forward(length?: number): Vector3;
-    static backward(length?: number): Vector3;
-    static fromArray(values: [number, number, number]): Vector3;
-    static add: (a: Vector3, b: Vector3) => Vector3;
-    static subtract: (a: Vector3, b: Vector3) => Vector3;
-    static equal: (a: Vector3, b: Vector3) => boolean;
-    static close: (a: Vector3, b: Vector3, tolerance?: number) => boolean;
-    static cross: (a: Vector3, b: Vector3) => Vector3;
-    static dot: (a: Vector3, b: Vector3) => number;
-    static newVectorOfLength: (vec: Vector3, length: number) => Vector3;
+    static Zero(): Vector3;
+    static One(): Vector3;
+    static Right(length?: number): Vector3;
+    static Left(length?: number): Vector3;
+    static Up(length?: number): Vector3;
+    static Down(length?: number): Vector3;
+    static Forward(length?: number): Vector3;
+    static Backward(length?: number): Vector3;
+    static FromArray(values: [number, number, number]): Vector3;
+    static Add: (a: Vector3, b: Vector3) => Vector3;
+    static Subtract: (a: Vector3, b: Vector3) => Vector3;
+    static Equal: (a: Vector3, b: Vector3) => boolean;
+    static Close: (a: Vector3, b: Vector3, tolerance?: number) => boolean;
+    static Cross: (a: Vector3, b: Vector3) => Vector3;
+    static Dot: (a: Vector3, b: Vector3) => number;
+    static NewVectorOfLength: (vec: Vector3, length: number) => Vector3;
     readonly x: number;
     readonly y: number;
     readonly z: number;

package/lib/ValueObjects/Vector3.js

@@ -7,31 +7,31 @@ class Vector3 {
         this.y = y;
         this.z = z;
     }
-    static zero() {
+    static Zero() {
         return new Vector3(0, 0, 0);
     }
-    static one() {
+    static One() {
         return new Vector3(1, 1, 1);
     }
-    static right(length = 1) {
+    static Right(length = 1) {
         return new Vector3(length, 0, 0);
     }
-    static left(length = 1) {
+    static Left(length = 1) {
         return new Vector3(-length, 0, 0);
     }
-    static up(length = 1) {
+    static Up(length = 1) {
         return new Vector3(0, length, 0);
     }
-    static down(length = 1) {
+    static Down(length = 1) {
         return new Vector3(0, -length, 0);
     }
-    static forward(length = 1) {
+    static Forward(length = 1) {
         return new Vector3(0, 0, length);
     }
-    static backward(length = 1) {
+    static Backward(length = 1) {
         return new Vector3(0, 0, -length);
     }
-    static fromArray(values) {
+    static FromArray(values) {
         return new Vector3(values[0], values[1], values[2]);
     }
     get magnitued() {
@@ -44,7 +44,7 @@ class Vector3 {
     get unit() {
         const mag = this.magnitued;
         if (mag === 0) {
-            return Vector3.zero();
+            return Vector3.Zero();
         }
         const unitX = this.x / mag;
         const unitY = this.y / mag;
@@ -56,36 +56,36 @@ class Vector3 {
     }
 }
 exports.Vector3 = Vector3;
-Vector3.add = (a, b) => {
+Vector3.Add = (a, b) => {
     return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
 };
-Vector3.subtract = (a, b) => {
+Vector3.Subtract = (a, b) => {
     return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
 };
-Vector3.equal = (a, b) => {
+Vector3.Equal = (a, b) => {
     if (a.x === b.x && a.y === b.y && a.z === b.z)
         return true;
     else
         return false;
 };
-Vector3.close = (a, b, tolerance = 0.01) => {
-    const diff = Vector3.subtract(a, b);
+Vector3.Close = (a, b, tolerance = 0.01) => {
+    const diff = Vector3.Subtract(a, b);
     const diffMag = diff.magnitued;
     if (diffMag < tolerance)
         return true;
     else
         return false;
 };
-Vector3.cross = (a, b) => {
+Vector3.Cross = (a, b) => {
     const x = a.y * b.z - a.z * b.y;
     const y = a.z * b.x - a.x * b.z;
     const z = a.x * b.y - a.y * b.x;
     return new Vector3(x, y, z);
 };
-Vector3.dot = (a, b) => {
+Vector3.Dot = (a, b) => {
     return a.x * b.x + a.y * b.y + a.z * b.z;
 };
-Vector3.newVectorOfLength = (vec, length) => {
+Vector3.NewVectorOfLength = (vec, length) => {
     const unit = vec.unit;
     return new Vector3(length * unit.x, length * unit.y, length * unit.z);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.14.0",
+  "version": "2.15.3",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",