@vived/app 2.11.2 → 2.15.1

package/lib/ValueObjects/LineSegment2D.d.ts

@@ -0,0 +1,12 @@
+import { Vector2 } from "./Vector2";
+export declare class LineSegment2D {
+    private _start;
+    get start(): Vector2;
+    private _end;
+    get 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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineSegment2D = void 0;
+const Vector2_1 = require("./Vector2");
+class LineSegment2D {
+    constructor(start, end) {
+        this._start = start;
+        this._end = end;
+    }
+    get start() {
+        return this._start;
+    }
+    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) {
+        // 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 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;
+        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;
+        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);
+    }
+}
+exports.LineSegment2D = LineSegment2D;

package/lib/ValueObjects/ParametricLine.d.ts

@@ -0,0 +1,27 @@
+import { Vector3 } from "../ValueObjects/Vector3";
+export interface LineParameters {
+    x0: number;
+    y0: number;
+    z0: number;
+    a: number;
+    b: number;
+    c: number;
+}
+export declare class ParametricLine {
+    static FromTwoPoint(p1: Vector3, p2: Vector3): ParametricLine;
+    static FromPointDirection(point: Vector3, direction: Vector3): ParametricLine;
+    static Forward(): ParametricLine;
+    static Backward(): ParametricLine;
+    static Up(): ParametricLine;
+    static Down(): ParametricLine;
+    static Left(): ParametricLine;
+    static Right(): ParametricLine;
+    static getPointAtDistance(line: ParametricLine, distance: number): Vector3;
+    readonly x0: number;
+    readonly y0: number;
+    readonly z0: number;
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    constructor(parameters: LineParameters);
+}

package/lib/ValueObjects/ParametricLine.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametricLine = void 0;
+const Vector3_1 = require("../ValueObjects/Vector3");
+class ParametricLine {
+    constructor(parameters) {
+        this.x0 = parameters.x0;
+        this.y0 = parameters.y0;
+        this.z0 = parameters.z0;
+        this.a = parameters.a;
+        this.b = parameters.b;
+        this.c = parameters.c;
+    }
+    // See https://planetcalc.com/8253/
+    static FromTwoPoint(p1, p2) {
+        const dir = Vector3_1.Vector3.subtract(p2, p1).unit;
+        return this.FromPointDirection(p1, dir);
+    }
+    static FromPointDirection(point, direction) {
+        return new ParametricLine({
+            x0: point.x,
+            y0: point.y,
+            z0: point.z,
+            a: direction.x,
+            b: direction.y,
+            c: direction.z,
+        });
+    }
+    static Forward() {
+        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 d = new Vector3_1.Vector3(0, 0, -1);
+        return this.FromPointDirection(p, d);
+    }
+    static Up() {
+        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 d = new Vector3_1.Vector3(0, -1, 0);
+        return this.FromPointDirection(p, d);
+    }
+    static Left() {
+        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 d = new Vector3_1.Vector3(1, 0, 0);
+        return this.FromPointDirection(p, d);
+    }
+    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;
+        return new Vector3_1.Vector3(x, y, z);
+    }
+}
+exports.ParametricLine = ParametricLine;

package/lib/ValueObjects/ParametricPlane.d.ts

@@ -0,0 +1,20 @@
+import { ParametricLine } from "./ParametricLine";
+import { Vector3 } from "../ValueObjects/Vector3";
+export interface PlaneParameters {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}
+export declare class ParametricPlane {
+    private point;
+    private normal;
+    static FromPointNormal(point: Vector3, normal: Vector3): ParametricPlane;
+    static FromThreePoints(A: Vector3, B: Vector3, C: Vector3): ParametricPlane;
+    static XY(): ParametricPlane;
+    static ZX(): ParametricPlane;
+    static YZ(): ParametricPlane;
+    getParameters(): PlaneParameters;
+    intersectLine(line: ParametricLine): Vector3 | undefined;
+    constructor(point: Vector3, normal: Vector3);
+}

package/lib/ValueObjects/ParametricPlane.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametricPlane = void 0;
+const ParametricLine_1 = require("./ParametricLine");
+const Vector3_1 = require("../ValueObjects/Vector3");
+class ParametricPlane {
+    constructor(point, normal) {
+        this.point = point;
+        this.normal = normal;
+    }
+    static FromPointNormal(point, normal) {
+        return new ParametricPlane(point, normal);
+    }
+    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);
+        return new ParametricPlane(point, normal);
+    }
+    static XY() {
+        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 n = new Vector3_1.Vector3(0, 1, 0);
+        return new ParametricPlane(p, n);
+    }
+    static YZ() {
+        const p = Vector3_1.Vector3.zero();
+        const n = new Vector3_1.Vector3(1, 0, 0);
+        return new ParametricPlane(p, n);
+    }
+    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);
+        if (d !== 0) {
+            d *= -1;
+        }
+        return {
+            a,
+            b,
+            c,
+            d,
+        };
+    }
+    intersectLine(line) {
+        const { x0, y0, z0, a, b, c } = line;
+        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);
+        return intersect;
+    }
+}
+exports.ParametricPlane = ParametricPlane;

package/lib/ValueObjects/Vector2.d.ts

@@ -0,0 +1,22 @@
+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;
+    readonly x: number;
+    readonly y: number;
+    get magnitued(): number;
+    get unit(): Vector2;
+    get theta(): number;
+    get array(): [number, number];
+    constructor(x: number, y: number);
+}

package/lib/ValueObjects/Vector2.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector2 = void 0;
+const _1 = require(".");
+class Vector2 {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    static zero() {
+        return new Vector2(0, 0);
+    }
+    static one() {
+        return new Vector2(1, 1);
+    }
+    static equal(a, b) {
+        if (a.x !== b.x)
+            return false;
+        if (a.y !== b.y)
+            return false;
+        return true;
+    }
+    static add(a, b) {
+        return new Vector2(a.x + b.x, a.y + b.y);
+    }
+    static subtract(a, b) {
+        return new Vector2(a.x - b.x, a.y - b.y);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const magnitude = Math.sqrt(xSqr + ySqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector2.zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        return new Vector2(unitX, unitY);
+    }
+    get theta() {
+        return (Math.atan2(this.y, this.x) * 180) / Math.PI;
+    }
+    get array() {
+        return [this.x, this.y];
+    }
+}
+exports.Vector2 = Vector2;
+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) => {
+    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) => {
+    const x = scale * vector.x;
+    const y = scale * vector.y;
+    return new Vector2(x, y);
+};
+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) => {
+    return a.x * b.x + a.y * b.y;
+};
+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);
+};
+Vector2.cross = (a, b) => {
+    return a.x * b.y - a.y * b.x;
+};

package/lib/ValueObjects/Vector3.d.ts

@@ -0,0 +1,25 @@
+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;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    get magnitued(): number;
+    get unit(): Vector3;
+    get array(): [number, number, number];
+    constructor(x: number, y: number, z: number);
+}

package/lib/ValueObjects/Vector3.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+class Vector3 {
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    static zero() {
+        return new Vector3(0, 0, 0);
+    }
+    static one() {
+        return new Vector3(1, 1, 1);
+    }
+    static right(length = 1) {
+        return new Vector3(length, 0, 0);
+    }
+    static left(length = 1) {
+        return new Vector3(-length, 0, 0);
+    }
+    static up(length = 1) {
+        return new Vector3(0, length, 0);
+    }
+    static down(length = 1) {
+        return new Vector3(0, -length, 0);
+    }
+    static forward(length = 1) {
+        return new Vector3(0, 0, length);
+    }
+    static backward(length = 1) {
+        return new Vector3(0, 0, -length);
+    }
+    static fromArray(values) {
+        return new Vector3(values[0], values[1], values[2]);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const zSqr = this.z * this.z;
+        const magnitude = Math.sqrt(xSqr + ySqr + zSqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector3.zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        const unitZ = this.z / mag;
+        return new Vector3(unitX, unitY, unitZ);
+    }
+    get array() {
+        return [this.x, this.y, this.z];
+    }
+}
+exports.Vector3 = Vector3;
+Vector3.add = (a, b) => {
+    return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
+};
+Vector3.subtract = (a, b) => {
+    return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
+};
+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);
+    const diffMag = diff.magnitued;
+    if (diffMag < tolerance)
+        return true;
+    else
+        return false;
+};
+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) => {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+};
+Vector3.newVectorOfLength = (vec, length) => {
+    const unit = vec.unit;
+    return new Vector3(length * unit.x, length * unit.y, length * unit.z);
+};

package/lib/ValueObjects/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Color";
+export * from "./LineSegment2D";
+export * from "./Vector2";
+export * from "./Angle";
+export * from "./Vector3";
+export * from "./ParametricLine";
+export * from "./ParametricPlane";

package/lib/ValueObjects/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Color"), exports);
+__exportStar(require("./LineSegment2D"), exports);
+__exportStar(require("./Vector2"), exports);
+__exportStar(require("./Angle"), exports);
+__exportStar(require("./Vector3"), exports);
+__exportStar(require("./ParametricLine"), exports);
+__exportStar(require("./ParametricPlane"), exports);

package/lib/index.d.ts

@@ -4,4 +4,6 @@ import * as AppUCs from "./UseCases";
 export { AppUCs };
 import * as AppEntities from "./Entities";
 export { AppEntities };
+import * as AppValueObjects from "./ValueObjects";
+export { AppValueObjects };
 export * from "./Utilities";

package/lib/index.js

@@ -10,11 +10,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppEntities = exports.AppUCs = exports.AppPMs = void 0;
+exports.AppValueObjects = exports.AppEntities = exports.AppUCs = exports.AppPMs = void 0;
 const AppPMs = require("./PresentationManagers");
 exports.AppPMs = AppPMs;
 const AppUCs = require("./UseCases");
 exports.AppUCs = AppUCs;
 const AppEntities = require("./Entities");
 exports.AppEntities = AppEntities;
+const AppValueObjects = require("./ValueObjects");
+exports.AppValueObjects = AppValueObjects;
 __exportStar(require("./Utilities"), exports);

package/package.json

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