@vived/app 2.15.1 → 2.15.2

package/lib/Entities/Babylon.js

@@ -78,7 +78,7 @@ class BabylonImp {
             this.sceneRay = rayer;
         };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
-        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.one(), this.observers.notify);
+        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
     }
     get showInspector() {
         return this.memoizedShowInspector.val;

package/lib/Entities/FocusCamera.js

@@ -14,7 +14,7 @@ class FocusCameraImp {
         this.defaultAlpha = 0;
         this.defaultBeta = 30;
         this.defaultRadius = 8;
-        this.defaultTarget = ValueObjects_1.Vector3.zero();
+        this.defaultTarget = ValueObjects_1.Vector3.Zero();
         this.limitRadius = false;
         this.minRadius = 0;
         this.maxRadius = 0;
@@ -25,13 +25,13 @@ class FocusCameraImp {
         this.minBeta = 0;
         this.maxBeta = 0;
         this.limitTarget = false;
-        this.maxTargetPosition = ValueObjects_1.Vector3.zero();
-        this.minTargetPosition = ValueObjects_1.Vector3.zero();
+        this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.minTargetPosition = ValueObjects_1.Vector3.Zero();
         this.observers = new _1.ObserverList();
         this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
-        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.zero(), this.observers.notify);
+        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
         this.setRadiusLimits = (min, max) => {
             if (min < 0) {
                 throw new Error("[Orbit Camera] Mininum Radius must be greater >= 0");
@@ -103,8 +103,8 @@ class FocusCameraImp {
             this.target = this.target;
         };
         this.clearTargetLimits = () => {
-            this.maxTargetPosition = ValueObjects_1.Vector3.zero();
-            this.minTargetPosition = ValueObjects_1.Vector3.zero();
+            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.minTargetPosition = ValueObjects_1.Vector3.Zero();
             this.limitTarget = false;
         };
         this.registerLerp = (lerper) => {
@@ -210,7 +210,7 @@ class FocusCameraImp {
                 targetVals[i] = v;
             }
         }
-        this.memoizedTarget.val = ValueObjects_1.Vector3.fromArray(targetVals);
+        this.memoizedTarget.val = ValueObjects_1.Vector3.FromArray(targetVals);
     }
     get direction() {
         const yLength = -Math.sin(this.degToRad(this.beta));
@@ -221,8 +221,8 @@ class FocusCameraImp {
         return new ValueObjects_1.Vector3(xLength, yLength, zLength);
     }
     get cameraPosition() {
-        const localOffset = ValueObjects_1.Vector3.newVectorOfLength(this.direction, -this.radius);
-        return ValueObjects_1.Vector3.add(this.target, localOffset);
+        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
+        return ValueObjects_1.Vector3.Add(this.target, localOffset);
     }
     degToRad(degrees) {
         return (degrees * Math.PI) / 180;

package/lib/Entities/MemoizedVector2.js

@@ -11,7 +11,7 @@ class MemoizedVector2 {
         return this._val;
     }
     set val(v) {
-        if (ValueObjects_1.Vector2.equal(v, this._val))
+        if (ValueObjects_1.Vector2.Equal(v, this._val))
             return;
         this._val = v;
         this.onChangeCallback();

package/lib/Entities/MemoizedVector3.js

@@ -11,7 +11,7 @@ class MemoizedVector3 {
         return this._val;
     }
     set val(v) {
-        if (Vector3_1.Vector3.equal(v, this._val))
+        if (Vector3_1.Vector3.Equal(v, this._val))
             return;
         this._val = v;
         this.onChangeCallback();

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.js

@@ -26,10 +26,10 @@ class BumpDollyFocusCamera {
             this.focusCamera.radius = this.initialRadius + range * percent;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             if (nomralizedTime >= 1 && this.interval) {

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -14,10 +14,10 @@ class PinchDollyFocusCamera {
             this.focusCamera.radius = currentRadius - deltaRadius;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             this.previousDistanceBetweenTouches = distanceBetweenTouches;

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -14,10 +14,10 @@ class PixelDollyFocusCamera {
             this.focusCamera.radius = currentRadius - deltaRadius;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             this.previousPixelPosition = pixelPosition;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -10,7 +10,7 @@ class PixelOrbitFocusCamera {
             if (!this.previousPixelPos) {
                 throw new Error("[PixelOrbitFocusCamera] You must initialize first!");
             }
-            const pixelChange = ValueObjects_1.Vector2.subtract(pixelPosition, this.previousPixelPos);
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
             this.focusCamera.alpha += pixelChange.x * this.sensitivity;
             this.focusCamera.beta += pixelChange.y * this.sensitivity;
             this.previousPixelPos = pixelPosition;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -16,7 +16,7 @@ class PixelPlanePanFocusCamera {
             const p2 = this.plane.intersectLine(finalRay);
             if (!p1 || !p2)
                 return;
-            const delta = ValueObjects_1.Vector3.subtract(p2, p1);
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
             const currentTarget = this.focusCamera.target;
             const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
             this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);

package/lib/ValueObjects/Angle.d.ts

@@ -1,6 +1,6 @@
 export declare class Angle {
-    static fromDegrees(degrees: number): Angle;
-    static fromRadians(radians: number): Angle;
+    static FromDegrees(degrees: number): Angle;
+    static FromRadians(radians: number): Angle;
     private _degrees;
     get degrees(): number;
     get radians(): number;

package/lib/ValueObjects/Angle.js

@@ -6,10 +6,10 @@ class Angle {
         this._degrees = 0;
         this._degrees = degrees;
     }
-    static fromDegrees(degrees) {
+    static FromDegrees(degrees) {
         return new Angle(degrees);
     }
-    static fromRadians(radians) {
+    static FromRadians(radians) {
         return new Angle(radians * 180 / Math.PI);
     }
     get degrees() {

package/lib/ValueObjects/Color.d.ts

@@ -5,14 +5,10 @@ export declare class Color {
     static Hex(hex: string): Color;
     static X11(name: string): Color;
     static Equal(a: Color, b: Color): boolean;
-    private _r;
-    private _g;
-    private _b;
-    private _a;
-    get r(): number;
-    get g(): number;
-    get b(): number;
-    get a(): number;
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
     get rPercent(): number;
     get gPercent(): number;
     get bPercent(): number;

package/lib/ValueObjects/Color.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Color = void 0;
 class Color {
     constructor(r, g, b, a) {
-        this._r = this.clampVal(r);
-        this._g = this.clampVal(g);
-        this._b = this.clampVal(b);
-        this._a = this.clampVal(a);
+        this.r = this.clampVal(r);
+        this.g = this.clampVal(g);
+        this.b = this.clampVal(b);
+        this.a = this.clampVal(a);
     }
     static RGBA(r, g, b, a) {
         return new Color(r, g, b, a);
@@ -51,32 +51,20 @@ class Color {
             return false;
         return true;
     }
-    get r() {
-        return this._r;
-    }
-    get g() {
-        return this._g;
-    }
-    get b() {
-        return this._b;
-    }
-    get a() {
-        return this._a;
-    }
     get rPercent() {
-        return this._r / 255;
+        return this.r / 255;
     }
     get gPercent() {
-        return this._g / 255;
+        return this.g / 255;
     }
     get bPercent() {
-        return this._b / 255;
+        return this.b / 255;
     }
     get aPercent() {
-        return this._a / 255;
+        return this.a / 255;
     }
     get array() {
-        return [this._r, this._g, this._b, this._a];
+        return [this.r, this.g, this.b, this.a];
     }
     clampVal(val) {
         if (val > 255)

package/lib/ValueObjects/LineSegment2D.d.ts

@@ -1,12 +1,10 @@
 import { Vector2 } from "./Vector2";
 export declare class LineSegment2D {
-    private _start;
-    get start(): Vector2;
-    private _end;
-    get end(): Vector2;
+    static GetPositionAtPercent(line: LineSegment2D, percent: number): Vector2;
+    static Intersect(a: LineSegment2D, b: LineSegment2D, tolerance?: number): Vector2 | undefined;
+    readonly start: Vector2;
+    readonly end: Vector2;
     get length(): number;
     get direction(): Vector2;
-    getPositionAtPercent(percent: number): Vector2;
-    intersect(otherLine: LineSegment2D, tolerance?: number): Vector2 | undefined;
     constructor(start: Vector2, end: Vector2);
 }

package/lib/ValueObjects/LineSegment2D.js

@@ -4,55 +4,49 @@ exports.LineSegment2D = void 0;
 const Vector2_1 = require("./Vector2");
 class LineSegment2D {
     constructor(start, end) {
-        this._start = start;
-        this._end = end;
+        this.start = start;
+        this.end = end;
     }
-    get start() {
-        return this._start;
+    static GetPositionAtPercent(line, percent) {
+        const dir = line.direction;
+        const length = percent * line.length;
+        const localPos = Vector2_1.Vector2.NewVectorOfLength(dir, length);
+        return Vector2_1.Vector2.Add(line.start, localPos);
     }
-    get end() {
-        return this._end;
-    }
-    get length() {
-        return Vector2_1.Vector2.subtract(this._start, this._end).magnitued;
-    }
-    get direction() {
-        return Vector2_1.Vector2.subtract(this._end, this._start).unit;
-    }
-    getPositionAtPercent(percent) {
-        const dir = this.direction;
-        const length = percent * this.length;
-        const localPos = Vector2_1.Vector2.newVectorOfLength(dir, length);
-        return Vector2_1.Vector2.add(this._start, localPos);
-    }
-    intersect(otherLine, tolerance = 0) {
+    static Intersect(a, b, tolerance = 0) {
         // See https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
-        const x1 = this.start.x;
-        const y1 = this.start.y;
-        const x2 = this.end.x;
-        const y2 = this.end.y;
-        const x3 = otherLine.start.x;
-        const y3 = otherLine.start.y;
-        const x4 = otherLine.end.x;
-        const y4 = otherLine.end.y;
+        const x1 = a.start.x;
+        const y1 = a.start.y;
+        const x2 = a.end.x;
+        const y2 = a.end.y;
+        const x3 = b.start.x;
+        const y3 = b.start.y;
+        const x4 = b.end.x;
+        const y4 = b.end.y;
         const denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
         if (denominator === 0) {
             return undefined;
         }
         const tNumerator = (x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4);
         const t = tNumerator / denominator;
-        const tTolearnce = tolerance / this.length;
+        const tTolearnce = tolerance / a.length;
         if (t < -tTolearnce || t > 1 + tTolearnce) {
             return undefined;
         }
         const uNumerator = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
         const u = uNumerator / denominator;
-        const uTolearnce = tolerance / otherLine.length;
+        const uTolearnce = tolerance / b.length;
         if (u < -uTolearnce || u > 1 + uTolearnce)
             return undefined;
         const px = x1 + t * (x2 - x1);
         const py = y1 + t * (y2 - y1);
         return new Vector2_1.Vector2(px, py);
     }
+    get length() {
+        return Vector2_1.Vector2.Subtract(this.start, this.end).magnitued;
+    }
+    get direction() {
+        return Vector2_1.Vector2.Subtract(this.end, this.start).unit;
+    }
 }
 exports.LineSegment2D = LineSegment2D;

package/lib/ValueObjects/ParametricLine.d.ts

@@ -16,7 +16,7 @@ export declare class ParametricLine {
     static Down(): ParametricLine;
     static Left(): ParametricLine;
     static Right(): ParametricLine;
-    static getPointAtDistance(line: ParametricLine, distance: number): Vector3;
+    static GetPointAtDistance(line: ParametricLine, distance: number): Vector3;
     readonly x0: number;
     readonly y0: number;
     readonly z0: number;

package/lib/ValueObjects/ParametricLine.js

@@ -13,7 +13,7 @@ class ParametricLine {
     }
     // See https://planetcalc.com/8253/
     static FromTwoPoint(p1, p2) {
-        const dir = Vector3_1.Vector3.subtract(p2, p1).unit;
+        const dir = Vector3_1.Vector3.Subtract(p2, p1).unit;
         return this.FromPointDirection(p1, dir);
     }
     static FromPointDirection(point, direction) {
@@ -27,36 +27,36 @@ class ParametricLine {
         });
     }
     static Forward() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(0, 0, 1);
         return this.FromPointDirection(p, d);
     }
     static Backward() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(0, 0, -1);
         return this.FromPointDirection(p, d);
     }
     static Up() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(0, 1, 0);
         return this.FromPointDirection(p, d);
     }
     static Down() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(0, -1, 0);
         return this.FromPointDirection(p, d);
     }
     static Left() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(-1, 0, 0);
         return this.FromPointDirection(p, d);
     }
     static Right() {
-        const p = Vector3_1.Vector3.zero();
+        const p = Vector3_1.Vector3.Zero();
         const d = new Vector3_1.Vector3(1, 0, 0);
         return this.FromPointDirection(p, d);
     }
-    static getPointAtDistance(line, distance) {
+    static GetPointAtDistance(line, distance) {
         const x = line.x0 + line.a * distance;
         const y = line.y0 + line.b * distance;
         const z = line.z0 + line.c * distance;

package/lib/ValueObjects/ParametricPlane.d.ts

@@ -14,7 +14,7 @@ export declare class ParametricPlane {
     static XY(): ParametricPlane;
     static ZX(): ParametricPlane;
     static YZ(): ParametricPlane;
-    getParameters(): PlaneParameters;
+    GetParameters(): PlaneParameters;
     intersectLine(line: ParametricLine): Vector3 | undefined;
     constructor(point: Vector3, normal: Vector3);
 }

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.15.1",
+  "version": "2.15.2",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",