@vived/app 4.26.2 → 4.27.1

package/lib/Controllers/HoverLabelMouse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelMouse = void 0;
+const trySetHoverLabel_1 = require("../UseCases/HoverLabels/trySetHoverLabel");
+class HoverLabelMouse {
+    constructor(hoverLabels, mouseInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.hoverLabelDelay = 500;
+        this.onMove = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            if (this.currentTimeout) {
+                clearTimeout(this.currentTimeout);
+            }
+            this.currentTimeout = setTimeout(() => {
+                this.tryHoverLabelUC(e.position);
+                this.currentTimeout = undefined;
+            }, this.hoverLabelDelay);
+        };
+        mouseInput.registerController(this);
+        this.tryHoverLabelUC = trySetHoverLabel_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelMouse = HoverLabelMouse;

package/lib/Controllers/HoverLabelTouch.d.ts

@@ -0,0 +1,14 @@
+import { Babylon, HoverLabels, TouchController, TouchInput, TouchInputEvent } from "../Entities";
+import { Vector2 } from "../ValueObjects";
+export declare const touchLabelDragThreshold = 15;
+export declare class HoverLabelTouch implements TouchController {
+    private hoverLabels;
+    private lastPosition;
+    private startPosition;
+    private touchStarted;
+    tryHoverLabelUC: (position: Vector2) => void;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(hoverLabels: HoverLabels, touchInput: TouchInput, babylon: Babylon);
+}

package/lib/Controllers/HoverLabelTouch.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelTouch = exports.touchLabelDragThreshold = void 0;
+const UseCases_1 = require("../UseCases");
+const ValueObjects_1 = require("../ValueObjects");
+exports.touchLabelDragThreshold = 15;
+class HoverLabelTouch {
+    constructor(hoverLabels, touchInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.lastPosition = ValueObjects_1.Vector2.Zero();
+        this.startPosition = ValueObjects_1.Vector2.Zero();
+        this.touchStarted = false;
+        this.onTouchStart = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            this.touchStarted = false;
+            if (e.touchCount !== 1)
+                return;
+            this.startPosition = e.touches[0].position;
+            this.lastPosition = e.touches[0].position;
+            this.touchStarted = true;
+        };
+        this.onTouchMove = (e) => {
+            if (!this.touchStarted)
+                return;
+            this.lastPosition = e.touches[0].position;
+        };
+        this.onTouchEnd = () => {
+            if (!this.touchStarted)
+                return;
+            const xDiff = this.lastPosition.x - this.startPosition.x;
+            const yDiff = this.lastPosition.y - this.startPosition.y;
+            const dist = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+            if (dist < exports.touchLabelDragThreshold) {
+                this.tryHoverLabelUC(this.lastPosition);
+            }
+        };
+        touchInput.registerController(this);
+        this.tryHoverLabelUC = UseCases_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelTouch = HoverLabelTouch;

package/lib/Controllers/ToolHotkeys.d.ts

@@ -0,0 +1,6 @@
+import { KeyboardController, KeyboardInput, ToolRepository } from "../Entities";
+export declare class ToolHotkeys<ToolTypes> implements KeyboardController {
+    private toolRepo;
+    onKeyDown: (e: KeyboardEvent) => void;
+    constructor(toolRepo: ToolRepository<ToolTypes>, keyboardInput: KeyboardInput);
+}

package/lib/Controllers/ToolHotkeys.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolHotkeys = void 0;
+class ToolHotkeys {
+    constructor(toolRepo, keyboardInput) {
+        this.toolRepo = toolRepo;
+        this.onKeyDown = (e) => {
+            if (e.repeat)
+                return;
+            const currentKey = {
+                keyCode: e.code,
+                alt: e.altKey,
+                control: e.ctrlKey,
+                meta: e.metaKey,
+                shift: e.shiftKey,
+            };
+            const tool = this.toolRepo.getToolForHotkey(currentKey);
+            if (!tool)
+                return;
+            this.toolRepo.triggerTool(tool.type);
+        };
+        keyboardInput.registerController(this);
+    }
+}
+exports.ToolHotkeys = ToolHotkeys;

package/lib/Controllers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToolHotkeys";
+export * from "./HoverLabelTouch";
+export * from "./HoverLabelMouse";

package/lib/Controllers/index.js

@@ -0,0 +1,15 @@
+"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("./ToolHotkeys"), exports);
+__exportStar(require("./HoverLabelTouch"), exports);
+__exportStar(require("./HoverLabelMouse"), exports);

package/lib/Entities/AppBoundary.d.ts

@@ -0,0 +1,6 @@
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}

package/lib/Entities/AppBoundary.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Entities/AppDispatcher.d.ts

@@ -0,0 +1,63 @@
+import { Handler, Request } from "./AppBoundary";
+export interface AssetMetaDTO {
+    id: string;
+    name: string;
+    description: string;
+}
+export interface ShowAlertDTO {
+    title: string;
+    message: string;
+    closeButtonLabel: string;
+    closeCallback: () => void;
+}
+export interface ShowConfirmDTO {
+    title: string;
+    message: string;
+    confirmButtonLabel: string;
+    cancelButtonLabel: string;
+    confirmCallback: () => void;
+    cancelCallback: () => void;
+}
+export interface ShowMarkDownEditorDTO {
+    initialText: string;
+    submitCallback: (text: string) => void;
+    validateString?: (text: string) => string | null;
+}
+export interface IsAssetFetchedDTO {
+    assetId: string;
+    callback: (isFetched: boolean) => void;
+}
+export interface SpinnerDTO {
+    message: string;
+    title: string;
+}
+export declare abstract class AppDispatcher {
+    abstract registerHostHandler: (hostHandler: Handler) => void;
+    abstract dispatch: (request: Request) => void;
+    abstract stateHasChanged: (state: object, assets: string[], validationErrorMessage?: string) => void;
+    abstract stateIsCompleted: () => void;
+    abstract getAppAssetsURL: () => Promise<string>;
+    abstract registerExternalStylesheets: (stylesheets: string[]) => void;
+    abstract appIsReady: () => void;
+    abstract log: (sender: string, message: string) => void;
+    abstract logWarnign: (sender: string, message: string) => void;
+    abstract logError: (sender: string, message: string) => void;
+    abstract logFatalError: (sender: string, message: string) => void;
+    abstract submitHitResult: (success: boolean, description: string) => void;
+    abstract submitProgressResult: (progress: number, description: string) => void;
+    abstract submitMultiHitResult: (hits: number, misses: number, unanswered: number, description: string) => void;
+    abstract submitQualityResult: (stars: number, maxStars: number, description: string) => void;
+    abstract submitScoreResult: (score: number, maxScore: number, description: string) => void;
+    abstract getAssetBlobURL: (assetID: string) => Promise<string>;
+    abstract getAssetMeta: (assetID: string) => Promise<AssetMetaDTO>;
+    abstract getLinkedAssets: (assetID: string, type: string) => Promise<AssetMetaDTO[]>;
+    abstract getAssetsForOwner: (ownerID: string) => Promise<AssetMetaDTO[]>;
+    abstract isAssetFetched: (data: IsAssetFetchedDTO) => void;
+    abstract submitNewActivityAsset: (file: File) => Promise<string>;
+    abstract showAlert: (data: ShowAlertDTO) => void;
+    abstract showConfirm: (data: ShowConfirmDTO) => void;
+    abstract showMarkDownEditor: (data: ShowMarkDownEditorDTO) => void;
+    abstract showSelectModel(callback: (modelId: string, dataId: string) => void): void;
+    abstract showSpinner: (data: SpinnerDTO) => Promise<() => void>;
+}
+export declare function makeAppDispatcher(): AppDispatcher;

package/lib/Entities/AppDispatcher.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppDispatcher = exports.AppDispatcher = void 0;
+class AppDispatcher {
+}
+exports.AppDispatcher = AppDispatcher;
+function makeAppDispatcher() {
+    return new AppDistpatcherImp();
+}
+exports.makeAppDispatcher = makeAppDispatcher;
+class AppDistpatcherImp extends AppDispatcher {
+    constructor() {
+        super(...arguments);
+        this.registerHostHandler = (hostHandler) => {
+            this.hostHandler = hostHandler;
+        };
+        this.dispatch = (request) => {
+            if (!this.hostHandler) {
+                console.error("[AppDispatcher] No host handler has been registered");
+                return;
+            }
+            this.hostHandler(request);
+        };
+        this.stateHasChanged = (stateObject, assets, validationErrorMessage) => {
+            const payload = {
+                stateObject,
+                assets,
+                validationErrorMessage,
+            };
+            this.formRequestAndDispatch("ON_STATE_CHANGE", 3, payload);
+        };
+        this.stateIsCompleted = () => {
+            this.formRequestAndDispatch("ON_STATE_COMPLETED", 1);
+        };
+        this.getAppAssetsURL = () => {
+            return new Promise((resolve, reject) => {
+                const callback = (url) => {
+                    if (!url) {
+                        reject(new Error("URL to asset folder is empty"));
+                    }
+                    else {
+                        resolve(url);
+                    }
+                };
+                const payload = {
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_APP_ASSET_URL", 1, payload);
+                }
+            });
+        };
+        this.registerExternalStylesheets = (stylesheets) => {
+            const payload = {
+                stylesheets,
+            };
+            this.formRequestAndDispatch("REGISTER_EXTERNAL_STYLESHEETS", 1, payload);
+        };
+        this.appIsReady = () => {
+            this.formRequestAndDispatch("APP_IS_READY", 1);
+        };
+        this.submitLog = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "LOG",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.log = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "LOG",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logWarnign = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "WARNING",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logError = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "ERROR",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logFatalError = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "FATAL",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.submitHitResult = (success, description) => {
+            const payload = {
+                resultType: "HIT_V1",
+                description,
+                result: {
+                    success,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitProgressResult = (progress, description) => {
+            const payload = {
+                resultType: "PROGRESS_V1",
+                description,
+                result: {
+                    progress,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitMultiHitResult = (hits, misses, unanswered, description) => {
+            const payload = {
+                resultType: "MULTIHIT_V1",
+                description,
+                result: {
+                    hits,
+                    misses,
+                    unanswered,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitQualityResult = (stars, maxStars, description) => {
+            const payload = {
+                resultType: "QUALITY_V1",
+                description,
+                result: {
+                    stars,
+                    maxStars,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitScoreResult = (score, maxScore, description) => {
+            const payload = {
+                resultType: "SCORE_V1",
+                description,
+                result: {
+                    score,
+                    maxScore,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.getAssetBlobURL = (assetID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (blobURL) => {
+                    if (blobURL === undefined) {
+                        reject(new Error("Blob URL is undefined"));
+                    }
+                    else {
+                        resolve(blobURL);
+                    }
+                };
+                const payload = {
+                    assetID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_BLOB", 1, payload);
+                }
+            });
+        };
+        this.getAssetMeta = (assetID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (assetMeta) => {
+                    if (assetMeta === undefined) {
+                        reject(new Error("Meta is undefined"));
+                    }
+                    else {
+                        resolve(assetMeta);
+                    }
+                };
+                const payload = {
+                    assetID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_META", 1, payload);
+                }
+            });
+        };
+        this.getLinkedAssets = (assetID, type) => {
+            return new Promise((resolve, reject) => {
+                const callback = (linkedAssets) => {
+                    if (linkedAssets === undefined) {
+                        reject(new Error("Linked asset list is missing"));
+                    }
+                    else {
+                        resolve(linkedAssets);
+                    }
+                };
+                const payload = {
+                    assetID,
+                    type,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_LINKED_ASSETS", 1, payload);
+                }
+            });
+        };
+        this.getAssetsForOwner = (ownerID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (assetMetas) => {
+                    resolve(assetMetas);
+                };
+                const payload = {
+                    ownerID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_FOR_OWNER", 1, payload);
+                }
+            });
+        };
+        this.submitNewActivityAsset = (file) => {
+            return new Promise((resolve, reject) => {
+                const callback = (assetID) => {
+                    if (assetID) {
+                        resolve(assetID);
+                    }
+                    else {
+                        reject(new Error("Failed to get asset ID"));
+                    }
+                };
+                const payload = {
+                    file,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("NEW_ACTIVITY_ASSET", 1, payload);
+                }
+            });
+        };
+        this.showAlert = (data) => {
+            const payload = {
+                title: data.title,
+                message: data.message,
+                closeButtonLabel: data.closeButtonLabel,
+                closeCallback: data.closeCallback,
+            };
+            this.formRequestAndDispatch("SHOW_ALERT", 1, payload);
+        };
+        this.showConfirm = (data) => {
+            const payload = {
+                title: data.title,
+                message: data.message,
+                confirmCallback: data.confirmCallback,
+                cancelButtonLabel: data.cancelButtonLabel,
+                cancelCallback: data.cancelCallback,
+                confirmButtonLabel: data.confirmButtonLabel,
+            };
+            this.formRequestAndDispatch("SHOW_CONFIRM", 1, payload);
+        };
+        this.showMarkDownEditor = (data) => {
+            var _a;
+            const payload = {
+                initialText: (_a = data.initialText) !== null && _a !== void 0 ? _a : "",
+                submitCallback: data.submitCallback,
+            };
+            if (data.validateString) {
+                payload.validateString = data.validateString;
+            }
+            this.formRequestAndDispatch("SHOW_MARKDOWN_EDITOR", 1, payload);
+        };
+        this.showSelectModel = (callback) => {
+            const payload = {
+                callback,
+            };
+            this.formRequestAndDispatch("SHOW_SELECT_MODEL", 1, payload);
+        };
+        this.isAssetFetched = (data) => {
+            const payload = {
+                assetId: data.assetId,
+                callback: data.callback,
+            };
+            this.formRequestAndDispatch("IS_ASSET_FILE_FETCHED", 1, payload);
+        };
+        this.showSpinner = (data) => {
+            return new Promise((resolve, reject) => {
+                const closeCallback = (closeSpinner) => {
+                    resolve(closeSpinner);
+                };
+                const payload = {
+                    message: data.message,
+                    title: data.title,
+                    closeCallback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("SHOW_SPINNER", 1, payload);
+                }
+            });
+        };
+    }
+    formRequestAndDispatch(type, version, payload) {
+        const request = {
+            type,
+            version,
+            payload,
+        };
+        this.dispatch(request);
+    }
+}

package/lib/Entities/AppHandler.d.ts

@@ -0,0 +1,20 @@
+import { Handler } from "./AppBoundary";
+export declare abstract class RequestHandler {
+    abstract readonly requestType: string;
+    abstract payloadVersion: number;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare abstract class AppHandler {
+    abstract handler: Handler;
+    abstract registerRequestHandler: (requestHandler: RequestHandler) => void;
+}
+export declare function makeAppHandler(): AppHandler;
+export declare class UnsupportedRequestVerion extends Error {
+    constructor(requestType: string, version: number);
+}
+export declare class ActionNotImplemented extends Error {
+    constructor(requestType: string);
+}
+export declare class UnableToParsePayload extends Error {
+    constructor(requestType: string, version: number, payload: string);
+}

package/lib/Entities/AppHandler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnableToParsePayload = exports.ActionNotImplemented = exports.UnsupportedRequestVerion = exports.makeAppHandler = exports.AppHandler = exports.RequestHandler = void 0;
+class RequestHandler {
+}
+exports.RequestHandler = RequestHandler;
+class AppHandler {
+}
+exports.AppHandler = AppHandler;
+function makeAppHandler() {
+    return new RequestHandlerImp();
+}
+exports.makeAppHandler = makeAppHandler;
+class RequestHandlerImp extends AppHandler {
+    constructor() {
+        super(...arguments);
+        this.handlers = new Map();
+        this.getAppPayloadRequest = "GET_APP_PAYLOAD_VERSION";
+        this.getAppHandlerVersionRequest = "GET_APP_HANDLER_VERSION";
+        this.appHandlerVersion = 1;
+        this.handler = (request) => {
+            if (request.type === this.getAppPayloadRequest) {
+                this.handlePayloadVersionRequest(request);
+                return;
+            }
+            if (request.type === this.getAppHandlerVersionRequest) {
+                this.handleAppHandlerVersionRequest(request);
+                return;
+            }
+            const handler = this.handlers.get(request.type);
+            if (!handler) {
+                console.warn(`[AppHandler] Unsupported request type recieved: ${request.type}`);
+                return;
+            }
+            try {
+                handler.handleRequest(request.version, request.payload);
+            }
+            catch (e) {
+                console.warn(`[AppHandler] ${e}`);
+            }
+        };
+        this.registerRequestHandler = (handler) => {
+            if (this.handlers.has(handler.requestType)) {
+                console.warn(`[AppHandler] More than one handler is being registered for ${handler.requestType}. Previous handler is being overwritten`);
+            }
+            this.handlers.set(handler.requestType, handler);
+        };
+    }
+    handlePayloadVersionRequest(request) {
+        if (request.version !== 2) {
+            throw new UnsupportedRequestVerion(request.type, request.version);
+        }
+        const payload = request.payload;
+        if (payload.callback === undefined) {
+            throw new UnableToParsePayload(request.type, request.version, JSON.stringify(payload));
+        }
+        const versionMap = new Map();
+        this.handlers.forEach((handler) => {
+            versionMap.set(handler.requestType, handler.payloadVersion);
+        });
+        payload.callback(versionMap);
+    }
+    handleAppHandlerVersionRequest(request) {
+        if (request.version !== 1) {
+            throw new UnsupportedRequestVerion(request.type, request.version);
+        }
+        const payload = request.payload;
+        if (payload.callback === undefined) {
+            throw new UnableToParsePayload(request.type, request.version, JSON.stringify(payload));
+        }
+        payload.callback(this.appHandlerVersion);
+    }
+}
+class UnsupportedRequestVerion extends Error {
+    constructor(requestType, version) {
+        const msg = `Version ${version} of request type ${requestType} is not supported`;
+        super(msg);
+    }
+}
+exports.UnsupportedRequestVerion = UnsupportedRequestVerion;
+class ActionNotImplemented extends Error {
+    constructor(requestType) {
+        const msg = `Action for request type ${requestType} is not implemented`;
+        super(msg);
+    }
+}
+exports.ActionNotImplemented = ActionNotImplemented;
+class UnableToParsePayload extends Error {
+    constructor(requestType, version, payload) {
+        const msg = `Unable to parse paylod for version ${version} of request type ${requestType}: ${payload}`;
+        super(msg);
+    }
+}
+exports.UnableToParsePayload = UnableToParsePayload;