@vived/app 2.6.0 → 2.8.1

package/README.md

@@ -1,151 +1 @@
-# VIVED App
-This package is intended to hold all the common logic used by VIVED Slide Apps. 
-
-## Use Case
-You will need to instantiate the baseAppUC by calling makeBaseAppUC(). Typically this is done in your Main script when everything is starting up.
-
-### Functions
-#### getIsAuthoring():boolean
-Gets the flag to see if the app is currently in an authoring state
-
-#### setIsAuthoring(isAuthoring:boolean):void
-Sets the is authoring flag. If there is a change this will notify all observers
-
-#### getShowBabylonInspector():boolean
-Gets the flag to see if the babylon inspector should be show
-
-#### setShowBabylonInspector(showInspector: boolean):void
-Sets if the Babylon Inspector should be shown. If there is a change this will notify all observers.
-
-#### addObserver(observer: BaseAppStateObserver): void;
-Adds an observer to the Use Case. The observer will be notified if anything in the use case changes
-
-#### removeObserver(observer: BaseAppStateObserver): void;
-Removes an observer so it will no longer be notified of changes in the Use Case
-
-#### getSerializedState(): SerializedStates;
-Get the current serialized state of the App. See the Serilization section below
-
-#### setSerializedState(state: SerializedStates): void;
-Sets the state of the app to a Serialized State. See the Serilization section below
-
-#### registerSerializableSystem(serializedSystem: SerializableSystem):void;
-Registers a Serializable System. This is likely a system in your App which has states that need to be saved and applied. See the Serilization section below
-
-#### setHostHandler(handler: Handler):void;
-When an App is mounted it is passed the Host Handler. This is the Handler to which the Use Case will dispatch all requests. This needs to be set when the app Main is constructed. See the App - Host Communication section below
-
-#### hasHostHandler():boolean;
-This checks to see if a host handler has been set. This is useful for avoiding nasty errors
-
-#### dispatchOnStateChange(stateObject: object):void;
-When authoring the Host should be notified whenever something in the serializable state has changed. Calling this will let the host know that the state has changed and pass along the new state.
-
-#### dispatchOnStateComplete():void
-Calling this will let the Host know that the user has completed their required task and the Host can move on to the next state. 
-
-#### dispatchSubmitResults(results:object):void;
-If a user has completed a task and there are results to submit the app can pass these results to the Host via this call.
-
-#### dispatchGetAppAssetsURL():string
-Many Apps require Assets such as GLBs or images. These are expected to be stored in the public/assets folder (assuming the app was built with Create React App). However once the App has been published, the path to this folder will be different. The Host should know this path so calling this will ask the host for the path to the assets folder.
-
-#### setDevicePreview(x: number, y: number): void;
-At some point the User may opt to view the Activity in a way the previews a specific hardware device. This decision is handled by the host but the App will be notified. This function is used to set the desired x and y resolution
-
-#### clearDevicePreview():void;
-Calling this will clear any preview device resoltions.
-
-#### getUseDevicePreview(): boolean;
-This will return a true if the Host has set a device resolution to preview. Otherwise it will return false
-
-#### getDevicePreviewSize(): {x: number, y:number}
-This will return the requested preview device x and y resolution. If no device has been set or the previewed device has been cleared, these will both be -1.
-
-### Observers
-If you want to be notified when something changes in the Use Case you will need to create an observer class the implements BaseAppStateObserver and then registers itself with the use case via addObserver. If you observer is getting destroyed it needs to call removeObserver on the Use Case
-
-### Serilization
-The Serilization system is designed to handle all the heavy lifting of serializing and desrializing the state of your app.
-
-#### Serializable System
-You app will likey have one or my systems that have data which needs to be stored in the state. For each of these systems you are expected to write a class that implements SerializableSystem and then register this class with the Base App Use Case by calling registerSerializableSystem. 
-
-This implementation requires your class to setup four items:
-##### Name
-This is the name of your system. Not this name must be unique across all the serialized systems in your App. In other words you cannot register two different Serializable Systems with the same name. Also, this name should not be modified down the road is it is how the Use Case will determine what Class to send stored activity data to. This name will never be seen by a user.
-
-##### Serilization Version
-This is an integer that is stored with the data and written into an activity file. This is intended to allow the system state data to be changed over time while giving developers the opportunity to be backwards compatable. For example, lets say after a few months the system is improved to include another statable variable. The devloper would iterate the serilizationVersion from 1 to 2. From now on, any new saved states will be saved with version number 2. When the System is asked to apply some saved state data it can check to see if this state data was version 1 or 2 and handle it appropriatetly.
-
-##### getSerializedObject():object
-The Serilization Use Case will trigger this function when it needs to store the current state. The Class is expected to form up an object however they see fit and return it as a vanilla object.
-
-##### applySerializedObject(state: object, version: number):void
-This function will be called when the Serilization Use Case want to apply a state to a system. It will pass in a vanilla object as well as the serilization version that was set when this object was formed. The Class is expected to handle the versions and apply the object appropriatetly.
-
-### App - Host Communication
-The boundary between the Host and the App has been intentionally designed to allow the the host and the apps to be completely independent of each other while allowing communication between the two. 
-
-#### Request
-All messages passed between the Host and the App are called requests. All Requests are strongly typed and versioned in the @vived/app-host-boundary package.
-
-#### Dispatcher
-When an App needs to send a request to the Host all it needs to do is trigger a dispatch action in the Use Case. This package will take care of correctly forming the Request and sending it to the Host.
-
-#### Handler
-When the Host sends a request to the App it must be handled, which is the responsibility of the App Handler. You app is expected to provide a list of AppHandlerFunctions when it creates the App Handler during the construction of the App. This allows allows the App to unpack the request and then call one of these functions, allowing your App to handle it however it wants.
-
-## Presenter Models
-Presenter Models are intented to update a view whenenver a something specific changes in the Use Case. The Presenter Model will either pass the View a specific parameter or a View Model of parameters. Ideally the View will be able to just consume the View Model or the parameter without needing any logic or refactoring.
-
-To use Presenter Model your View (or Hook) will need to instantiate the Presenter Model, passing in the baseAppUC and a callback function. The callback function will be triggered when the Presenter Moder is initiated and then whenever an update is available. It is important to call Dispose on the Presetner Model if your view or hook is being destroyed in order to remove it's observer from the Use Case.
-
-### DevicePreviewPM
-This PM will update it's view whenever something with the Device Preview changes. It returns a View Model with the following parameters
-- isPreviewingDevice: a boolean letting you know if the render canvas should be scaled
-- x: is the pixel width to scale to if isPreviewingDevice. This will be -1 if there is no device to preview
-- y: is the pixel height to scale to if isPreviewingDevice. This will be -1 if there is no device
-
-### IsAuthoringPM
-This PM will update the view whenever the Is Authoring flag changes, passing back the current isAuthor value.
-
-### ShowBabylonInspectorPM
-This PM will update the view whenever the Show Babylon Inspector flag changes, passing back the current value.
-
-## Controllers
-### defaultAppHandlerFunctions
-The function creates all the default app handler functions. These include:
-- showBabylonInspector: (show: boolean) => void;
-- setIsAuthoring: (isAuthoring: boolean) => void;
-- disposeApp: () => void;
-- stopApp: () => void;
-- startApp: (container: HTMLElement) => void;
-- setState: (finalState: string, duration?: number) => void;
-- setDevicePreview: (x: number, y: number) => void;
-
-Your App will likely need to handle one or more of these functions differently so the intent is that you use this function to create all the default functions and then replace the appropriate functions with your custom function before creating the App Handler
-
-### dispatchStateChange()
-This function is created with the factory makeDispatchStateChange. It first gets the latest serialized state and then dispatches that state to the Host
-
-### makeAppHandler(functions: AppHandlerFunctions): Handler
-This function is used to create the App Handler. It takes in the App Handler Functions and returns a generic Handler, which is passed to the Host. The host can then dispatch a request to this Handler. The App Handler is responsible for reading the request and triggering the appropriate App Handler Function
-
-### setDevicePreview(x: number, y: number)
-This function is created with the makeSetDevicePreview factory. If either x or y are negative this function will clear the selected device in the baseAppUC. Otherwise it will set the x and y value of the selected device in the Use Case.
-
-### setIsAuthoring(isAuthoring: boolean)
-This function is created with the makeSetIsAuthoring factory and will apply the isAuthoring flag to the use case. It will also dispatch a state change if the is Authorin is set to true. This allows the Host to know the initial state when the user start authoring.
-
-### setState(state: string, duration?: number)
-This function is created with the makeSetState facory. It is responsible for recieving a desired state from the Host and applying it locally. You will note that the setState function in this package does not use the duration parameter. This function simply sets the state hard, without any transition. You App will probably what to implement it's own setState function that support nice interpolations for your systems.
-
-### showBabylonInspector(showInspector:boolean)
-This function is created with the makeShowBabylonInspector factory. It will set the show babylon inspector flag in the Use Case. 
-
-### startApp(container: HTMLElement)
-This function is created with the makeStartApp factory. It is reponsible for starting up all the renderings of the App. This could include the App's react components as well as the Babylon Engine.
-
-### stopApp()
-This function is created with the makeStopApp factory. It is reponsible for stopping up all the renderings of the App. This could include the App's react components as well as the Babylon Engine. It also ensures that the isAuthoring flag is set to false.
+//Todo

package/lib/Core/BaseApp/UseCase.js

@@ -214,7 +214,7 @@ class BaseAppUCImp {
             this.appState.isTransitioning = true;
             const durationInMS = duration * 1000;
             let chrono = 0;
-            const transitionDelta = 100;
+            const transitionDelta = 10;
             this.currentInterval = setInterval(() => {
                 chrono = chrono + transitionDelta;
                 let normalizedTime = chrono / durationInMS;

package/lib/Entities/Babylon.d.ts

@@ -0,0 +1,31 @@
+import { ParametricLine, Vector3 } from ".";
+import { Vector2 } from "./Vector2";
+export declare type OnBabylonChange = () => void;
+export interface ScenePick {
+    mouseRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+}
+export declare type ScenePicker = (pixelPos: Vector2) => ScenePick;
+export declare type SceneRayer = (pixelPos: Vector2) => ParametricLine;
+export interface Babylon {
+    engine: unknown;
+    scene: unknown;
+    workingCanvas?: HTMLCanvasElement;
+    showInspector: boolean;
+    renderCanvas?: HTMLCanvasElement;
+    scenePick: (pixelPos: Vector2) => ScenePick;
+    sceneRay: (pixelPos: Vector2) => ParametricLine;
+    updateCanvasSize: () => void;
+    submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    clearRenderCanvas: () => void;
+    registerResizeEnging: (resizeEngine: () => void) => void;
+    registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerScenePicker: (picker: ScenePicker) => void;
+    registerSceneRayer: (rayer: SceneRayer) => void;
+    addObserver: (observer: OnBabylonChange) => void;
+    removeObserver: (observer: OnBabylonChange) => void;
+}
+export declare function makeBabylon(): Babylon;

package/lib/Entities/Babylon.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylon = void 0;
+const _1 = require(".");
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedVector2_1 = require("./MemoizedVector2");
+const ObserverList_1 = require("./ObserverList");
+const Vector2_1 = require("./Vector2");
+function makeBabylon() {
+    return new BabylonImp();
+}
+exports.makeBabylon = makeBabylon;
+class BabylonImp {
+    constructor() {
+        this.scenePick = () => {
+            console.warn("orignal scene picker");
+            return {
+                mouseRay: _1.ParametricLine.Forward(),
+                hit: false,
+            };
+        };
+        this.sceneRay = () => {
+            console.warn("orignal scene ray");
+            return _1.ParametricLine.Forward();
+        };
+        this.observers = new ObserverList_1.ObserverList();
+        this.updateCanvasSize = () => {
+            if (!this.workingCanvas)
+                return;
+            if (!this._renderCanvas)
+                return;
+            if (this.resizeEngine) {
+                this.resizeEngine();
+            }
+            this.workingCanvas.height = this._renderCanvas.height;
+            this.workingCanvas.width = this._renderCanvas.width;
+        };
+        this.submitRenderCanvas = (canvas) => {
+            if (canvas === this._renderCanvas)
+                return;
+            if (this._renderCanvas && this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = canvas;
+            this.updateCanvasSize();
+            if (this.startRendering) {
+                this.startRendering(canvas);
+            }
+            this.observers.notify();
+        };
+        this.clearRenderCanvas = () => {
+            if (!this._renderCanvas)
+                return;
+            if (this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = undefined;
+            this.observers.notify();
+        };
+        this.registerResizeEnging = (resizeEngine) => {
+            this.resizeEngine = resizeEngine;
+        };
+        this.registerStartRendering = (startRendering) => {
+            this.startRendering = startRendering;
+        };
+        this.registerStopRendering = (stopRendering) => {
+            this.stopRendering = stopRendering;
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+        this.registerScenePicker = (picker) => {
+            this.scenePick = picker;
+        };
+        this.registerSceneRayer = (rayer) => {
+            this.sceneRay = rayer;
+        };
+        this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(Vector2_1.Vector2.One(), this.observers.notify);
+    }
+    get showInspector() {
+        return this.memoizedShowInspector.val;
+    }
+    set showInspector(val) {
+        this.memoizedShowInspector.val = val;
+    }
+    get renderCanvas() {
+        return this._renderCanvas;
+    }
+    get canvasSize() {
+        return this.memoizedCanvasSize.getVector();
+    }
+    set canvasSize(val) {
+        this.memoizedCanvasSize.setVector(val);
+    }
+}

package/lib/Entities/BaseApp.d.ts

@@ -0,0 +1,7 @@
+export declare type OnBaseAppChange = () => void;
+export interface BaseApp {
+    isAuthoring: boolean;
+    addObserver(observer: OnBaseAppChange): void;
+    removeObserver(observer: OnBaseAppChange): void;
+}
+export declare function makeBaseApp(): BaseApp;

package/lib/Entities/BaseApp.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseApp = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const ObserverList_1 = require("./ObserverList");
+function makeBaseApp() {
+    return new BaseAppImp();
+}
+exports.makeBaseApp = makeBaseApp;
+class BaseAppImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this.memoizedIsAuthoring = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get isAuthoring() {
+        return this.memoizedIsAuthoring.val;
+    }
+    set isAuthoring(val) {
+        this.memoizedIsAuthoring.val = val;
+    }
+}

package/lib/Entities/Color.d.ts

@@ -0,0 +1,20 @@
+export declare class Color {
+    static White(): Color;
+    static Black(): Color;
+    static Red(): Color;
+    static Green(): Color;
+    static Blue(): Color;
+    static Yellow(): Color;
+    static Gray(): Color;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    get rPercent(): number;
+    get gPercent(): number;
+    get bPercent(): number;
+    get aPercent(): number;
+    equal: (otherColor: Color) => boolean;
+    copy: () => Color;
+    constructor(r: number, g: number, b: number, a?: number);
+}

package/lib/Entities/Color.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+class Color {
+    constructor(r, g, b, a = 255) {
+        this.equal = (otherColor) => {
+            if (otherColor.r === this.r &&
+                otherColor.g === this.g &&
+                otherColor.b === this.b &&
+                otherColor.a === this.a) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.copy = () => {
+            return new Color(this.r, this.g, this.b, this.a);
+        };
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+    static White() {
+        return new Color(255, 255, 255, 255);
+    }
+    static Black() {
+        return new Color(0, 0, 0, 255);
+    }
+    static Red() {
+        return new Color(255, 0, 0, 255);
+    }
+    static Green() {
+        return new Color(0, 255, 0, 255);
+    }
+    static Blue() {
+        return new Color(0, 0, 255, 255);
+    }
+    static Yellow() {
+        return new Color(255, 0, 255, 255);
+    }
+    static Gray() {
+        return new Color(192, 192, 192, 255);
+    }
+    get rPercent() {
+        return this.r / 255;
+    }
+    get gPercent() {
+        return this.g / 255;
+    }
+    get bPercent() {
+        return this.b / 255;
+    }
+    get aPercent() {
+        return this.a / 255;
+    }
+}
+exports.Color = Color;

package/lib/Entities/DevicePreview.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from ".";
+export declare type OnDevicePreviewChange = () => void;
+export interface DevicePreview {
+    useDevicePreview: boolean;
+    previewSize: Vector2;
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+}
+export declare function makeDevicePreview(): DevicePreview;

package/lib/Entities/DevicePreview.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDevicePreview = void 0;
+const _1 = require(".");
+function makeDevicePreview() {
+    return new DevicePreviewImp();
+}
+exports.makeDevicePreview = makeDevicePreview;
+class DevicePreviewImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this._usePreview = false;
+        this._previewSize = _1.Vector2.Zero();
+        this.setDevicePreview = (x, y) => {
+            if (this._usePreview &&
+                this._previewSize.x === x &&
+                this._previewSize.y === y)
+                return;
+            this._usePreview = true;
+            this._previewSize.x = x;
+            this._previewSize.y = y;
+            this.observers.notify();
+        };
+        this.clearDevicePreview = () => {
+            if (!this._usePreview)
+                return;
+            this._previewSize = _1.Vector2.Zero();
+            this._usePreview = false;
+            this.observers.notify();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get useDevicePreview() {
+        return this._usePreview;
+    }
+    get previewSize() {
+        return this._previewSize.copy();
+    }
+}

package/lib/Entities/KeyboardInput.d.ts

@@ -0,0 +1,14 @@
+export declare type OnKeyDown = (key: string) => void;
+export declare type OnKeyUp = (key: string) => void;
+export interface KeyboardInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    removeEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    isKeyPressed: (key: string) => boolean;
+    addKeyDownObserver: (observer: OnKeyDown) => void;
+    removeKeyDownObserver: (observer: OnKeyDown) => void;
+    addKeyUpObserver: (observer: OnKeyUp) => void;
+    removeKeyUpObserver: (observer: OnKeyUp) => void;
+}
+export declare function makeKeyboardInput(): KeyboardInput;

package/lib/Entities/KeyboardInput.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyboardInput = void 0;
+const _1 = require(".");
+function makeKeyboardInput() {
+    return new KeyboardInputImp();
+}
+exports.makeKeyboardInput = makeKeyboardInput;
+class KeyboardInputImp {
+    constructor() {
+        this._eventElement = undefined;
+        this.setEventElement = (element) => {
+            if (this._eventElement) {
+                this._eventElement.onkeydown = null;
+                this._eventElement.onkeyup = null;
+            }
+            element.onkeydown = (e) => {
+                this.submitKeyDown(e.code);
+            };
+            element.onkeyup = (e) => {
+                this.submitKeyUp(e.code);
+            };
+            this._eventElement = element;
+        };
+        this.removeEventElement = (eventElement) => {
+            if (this._eventElement !== eventElement)
+                return;
+            this._eventElement.onkeydown = null;
+            this._eventElement.onkeyup = null;
+            this._eventElement = undefined;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.onkeydown = null;
+            this._eventElement.onkeyup = null;
+            this._eventElement = undefined;
+        };
+        this.downObservers = new _1.ObserverList();
+        this.upObservers = new _1.ObserverList();
+        this.pressedKeys = [];
+        this.submitKeyDown = (key) => {
+            if (this.pressedKeys.includes(key))
+                return;
+            this.pressedKeys.push(key);
+            this.downObservers.notify(key);
+        };
+        this.submitKeyUp = (key) => {
+            if (!this.pressedKeys.includes(key))
+                return;
+            const index = this.pressedKeys.indexOf(key);
+            if (index >= 0) {
+                this.pressedKeys.splice(index, 1);
+            }
+            this.upObservers.notify(key);
+        };
+        this.isKeyPressed = (key) => {
+            return this.pressedKeys.includes(key);
+        };
+        this.addKeyDownObserver = (observer) => {
+            this.downObservers.add(observer);
+        };
+        this.removeKeyDownObserver = (observer) => {
+            this.downObservers.remove(observer);
+        };
+        this.addKeyUpObserver = (observer) => {
+            this.upObservers.add(observer);
+        };
+        this.removeKeyUpObserver = (observer) => {
+            this.upObservers.remove(observer);
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/LineSegment2D.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from "./Vector2";
+export declare class LineSegment2D {
+    start: Vector2;
+    end: Vector2;
+    get length(): number;
+    get direction(): Vector2;
+    getPositionAtPercent(percent: number): Vector2;
+    closestPointOnLine(point: Vector2): Vector2;
+    intersect(otherLine: LineSegment2D, tolerance?: number): Vector2 | undefined;
+    constructor(start: Vector2, end: Vector2);
+}

package/lib/Entities/LineSegment2D.js

@@ -0,0 +1,70 @@
+"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 length() {
+        return this.end.subtract(this.start).magnitued;
+    }
+    get direction() {
+        return this.end.subtract(this.start).unit;
+    }
+    getPositionAtPercent(percent) {
+        const dir = this.direction;
+        const length = percent * this.length;
+        dir.setLength(length);
+        return this.start.add(dir);
+    }
+    closestPointOnLine(point) {
+        // see https://monkeyproofsolutions.nl/wordpress/how-to-calculate-the-shortest-distance-between-a-point-and-a-line/
+        const direction = this.end.subtract(this.start);
+        const tNumerator = direction.dot(point.subtract(this.start));
+        const tDenominator = direction.dot(direction);
+        const t = tNumerator / tDenominator;
+        if (t < 0) {
+            return this.start.copy();
+        }
+        else if (t > 1) {
+            return this.end.copy();
+        }
+        else {
+            const length = t * direction.magnitued;
+            direction.setLength(length);
+            return this.start.add(direction);
+        }
+    }
+    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/Entities/MemoizedBoolean.d.ts

@@ -0,0 +1,7 @@
+export declare class MemoizedBoolean {
+    private _val;
+    get val(): boolean;
+    set val(b: boolean);
+    private onChangeCallback;
+    constructor(initialValue: boolean, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedBoolean.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedBoolean = void 0;
+class MemoizedBoolean {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedBoolean = MemoizedBoolean;