@vived/app 2.12.0 → 2.15.2

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): Vector2 | undefined;
     constructor(start: Vector2, end: Vector2);
 }

package/lib/ValueObjects/LineSegment2D.js

@@ -4,52 +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) {
+    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;
-        if (t < 0 || t > 1)
+        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;
-        if (u < 0 || u > 1)
+        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.12.0",
+  "version": "2.15.2",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",