@vived/app 2.14.0 → 2.15.3

package/lib/PresentationManagers/QuestionChallenge/QuestionChallengePM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionChallengePM = exports.defaultQuestionChallengeVM = void 0;
+exports.defaultQuestionChallengeVM = {
+    text: "",
+    answers: [],
+    gotItRight: false,
+    tries: 0,
+};
+class QuestionChallengePM {
+    constructor(questionChallengeEntity, updateView) {
+        this.questionChallengeEntity = questionChallengeEntity;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.questionChallengeEntity.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const { tries, text } = this.questionChallengeEntity;
+            const answers = this.questionChallengeEntity
+                .getAllAnswers()
+                .map((ans) => ans.id);
+            const vm = {
+                text,
+                tries,
+                gotItRight: this.questionChallengeEntity.gotItRight,
+                answers,
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+        this.questionChallengeEntity.addObserver(this.doUpdateView);
+    }
+}
+exports.QuestionChallengePM = QuestionChallengePM;

package/lib/PresentationManagers/QuestionChallenge/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./QuestionChallengePM";
+export * from "./QuestionChallengeAnswerPM";
+export * from "./AuthorQuestionChallengeAnswerPM";
+export * from "./AuthorQuestionChallengePM";

package/lib/PresentationManagers/QuestionChallenge/index.js

@@ -0,0 +1,16 @@
+"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("./QuestionChallengePM"), exports);
+__exportStar(require("./QuestionChallengeAnswerPM"), exports);
+__exportStar(require("./AuthorQuestionChallengeAnswerPM"), exports);
+__exportStar(require("./AuthorQuestionChallengePM"), exports);

package/lib/PresentationManagers/index.d.ts

@@ -4,3 +4,4 @@ export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
 export * from "./FocusCameraPM";
+export * from "./QuestionChallenge";

package/lib/PresentationManagers/index.js

@@ -16,3 +16,4 @@ __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./FocusCameraPM"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

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/UseCases/QuestionChallenge/SerializeQuestionChallenge.d.ts

@@ -0,0 +1,25 @@
+import { QuestionChallenge, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeQuestionChallenge implements SerializedSystem {
+    private questionChallenge;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    private applyDataV2;
+    constructor(questionChallenge: QuestionChallenge, stateMachine: StateMachine);
+}
+export interface ChallengeDataV2 {
+    questionText: string;
+    answers: AnswerDataV1[];
+}
+export interface ChallengeDataV1 {
+    answers: AnswerDataV1[];
+}
+export interface AnswerDataV1 {
+    id: string;
+    text: string;
+    feedback: string;
+    isCorrect: boolean;
+}

package/lib/UseCases/QuestionChallenge/SerializeQuestionChallenge.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeQuestionChallenge = void 0;
+const Entities_1 = require("../../Entities");
+class SerializeQuestionChallenge {
+    constructor(questionChallenge, stateMachine) {
+        this.questionChallenge = questionChallenge;
+        this.name = "question";
+        this.seriliziationVersion = 2;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const answers = this.questionChallenge
+            .getAllAnswers()
+            .map((answer) => {
+            return {
+                id: answer.id,
+                feedback: answer.feedbackText,
+                isCorrect: answer.isCorrect,
+                text: answer.text,
+            };
+        });
+        const state = {
+            questionText: this.questionChallenge.text,
+            answers,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else if (state && version === 2) {
+            const castState = state;
+            this.applyDataV2(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.questionChallenge.setDefaultState();
+    }
+    applyDataV1(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = "";
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+    applyDataV2(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = data.questionText;
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+}
+exports.SerializeQuestionChallenge = SerializeQuestionChallenge;

package/lib/UseCases/QuestionChallenge/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./SerializeQuestionChallenge";
+export * from "./setQuesionChallengeAnswerFeedback";
+export * from "./setQuesionChallengeAnswerText";
+export * from "./toggleQuesionChallengeAnswerIsCorrect";

package/lib/UseCases/QuestionChallenge/index.js

@@ -0,0 +1,16 @@
+"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("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./setQuesionChallengeAnswerFeedback"), exports);
+__exportStar(require("./setQuesionChallengeAnswerText"), exports);
+__exportStar(require("./toggleQuesionChallengeAnswerIsCorrect"), exports);

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerFeedback(answerID: string, questionChallenge: QuestionChallenge): (feedback: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerFeedback = void 0;
+function makeSetQuestionChallengeAnswerFeedback(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerFeedback(feedback) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.feedbackText = feedback;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerFeedback] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerFeedback = makeSetQuestionChallengeAnswerFeedback;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerText(answerID: string, questionChallenge: QuestionChallenge): (text: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerText = void 0;
+function makeSetQuestionChallengeAnswerText(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerText(text) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.text = text;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerText] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerText = makeSetQuestionChallengeAnswerText;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeToggleQuesionChallengeAnswerIsCorrect(answerID: string, questionChallenge: QuestionChallenge): () => void;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuesionChallengeAnswerIsCorrect = void 0;
+function makeToggleQuesionChallengeAnswerIsCorrect(answerID, questionChallenge) {
+    return function toggleQuesionChallengeAnswerIsCorrect() {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.isCorrect = !answer.isCorrect;
+        }
+        else {
+            console.warn("[toggleQuesionChallengeAnswerIsCorrect] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeToggleQuesionChallengeAnswerIsCorrect = makeToggleQuesionChallengeAnswerIsCorrect;

package/lib/UseCases/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./setDevicePreview";
 export * from "./FocusCamera";
+export * from "./QuestionChallenge";

package/lib/UseCases/index.js

@@ -12,3 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./FocusCamera"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

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,11 @@
 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;
+    static ClosestPointOnLine(line: LineSegment2D, point: Vector2): Vector2;
+    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,68 @@ 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);
     }
+    static ClosestPointOnLine(line, point) {
+        // see https://monkeyproofsolutions.nl/wordpress/how-to-calculate-the-shortest-distance-between-a-point-and-a-line/
+        let direction = Vector2_1.Vector2.Subtract(line.end, line.start);
+        const pointToStart = Vector2_1.Vector2.Subtract(point, line.start);
+        const tNumerator = Vector2_1.Vector2.Dot(direction, pointToStart);
+        const tDenominator = Vector2_1.Vector2.Dot(direction, direction);
+        const t = tNumerator / tDenominator;
+        if (t < 0) {
+            return line.start;
+        }
+        else if (t > 1) {
+            return line.end;
+        }
+        else {
+            const length = t * direction.magnitued;
+            direction = Vector2_1.Vector2.NewVectorOfLength(direction, length);
+            return Vector2_1.Vector2.Add(line.start, direction);
+        }
+    }
+    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);
 }