@vived/app 4.27.0 → 4.27.1

package/lib/{Components/Callouts/Entities → Controllers}/index.js

@@ -10,6 +10,6 @@ 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("./CalloutEntity"), exports);
-__exportStar(require("./CalloutGlobals"), exports);
-__exportStar(require("./CalloutRepo"), exports);
+__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;

package/lib/Entities/Babylon.d.ts

@@ -0,0 +1,48 @@
+import { ParametricLine, Vector2, Vector3 } from "../ValueObjects";
+export declare type OnBabylonChange = () => void;
+export interface ScenePick {
+    mouseRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    normal?: Vector3;
+}
+export interface IScreenshotSize {
+    /**
+     * number in pixels for canvas height
+     */
+    height?: number;
+    /**
+     * multiplier allowing render at a higher or lower resolution
+     * If value is defined then height and width will be ignored and taken from camera
+     */
+    precision?: number;
+    /**
+     * number in pixels for canvas width
+     */
+    width?: number;
+}
+export interface Babylon {
+    engine: unknown;
+    scene: unknown;
+    workingCanvas?: HTMLCanvasElement;
+    showInspector: boolean;
+    renderCanvas?: HTMLCanvasElement;
+    isRendering: boolean;
+    pixelToSceneRay: (pixelPos: Vector2) => ParametricLine;
+    sceneRayPick: (ray: ParametricLine) => ScenePick | undefined;
+    scenePixelPick: (pixelPos: Vector2) => ScenePick | undefined;
+    sceneObjectRayPick: (ray: ParametricLine) => string | undefined;
+    sceneObjectPixelPick: (pixelPos: Vector2) => string | undefined;
+    captureScreenshot: (size: IScreenshotSize | number) => Promise<Blob>;
+    makeSceneObjectMeta: (id: string) => object;
+    updateCanvasSize: () => void;
+    submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    clearRenderCanvas: () => void;
+    registerResizeEnging: (resizeEngine: () => void) => void;
+    registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
+    addObserver: (observer: OnBabylonChange) => void;
+    removeObserver: (observer: OnBabylonChange) => void;
+}
+export declare function makeBabylon(): Babylon;