@vived/host 3.0.0

package/lib/Entities/DialogSpinner.d.ts

@@ -0,0 +1,15 @@
+import { DialogBase } from "./DialogBase";
+export declare const spinnerDialogType = "SPINNER";
+export declare class DialogSpinner extends DialogBase {
+    readonly type = "SPINNER";
+    readonly mininumuLifespan = 2000;
+    readonly title: string;
+    private createdAt?;
+    private memoizedMessage;
+    get message(): string;
+    set message(val: string);
+    set isOpen(open: boolean);
+    get isOpen(): boolean;
+    close: () => void;
+    constructor(title: string, message: string);
+}

package/lib/Entities/DialogSpinner.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogSpinner = exports.spinnerDialogType = void 0;
+const DialogBase_1 = require("./DialogBase");
+const MemoizedString_1 = require("./MemoizedString");
+exports.spinnerDialogType = "SPINNER";
+class DialogSpinner extends DialogBase_1.DialogBase {
+    constructor(title, message) {
+        super(exports.spinnerDialogType);
+        this.type = exports.spinnerDialogType;
+        this.mininumuLifespan = 2000;
+        this.close = () => {
+            if (this.createdAt === undefined) {
+                this.isOpen = false;
+                return;
+            }
+            const timeAlive = Date.now() - this.createdAt;
+            const timeleft = this.mininumuLifespan - timeAlive;
+            if (timeleft <= 0) {
+                this.isOpen = false;
+            }
+            else {
+                setTimeout(() => {
+                    this.isOpen = false;
+                }, timeleft);
+            }
+        };
+        this.memoizedMessage = new MemoizedString_1.MemoizedString(message, this.notify);
+        this.title = title;
+    }
+    get message() {
+        return this.memoizedMessage.val;
+    }
+    set message(val) {
+        this.memoizedMessage.val = val;
+    }
+    set isOpen(open) {
+        if (open && this.createdAt === undefined) {
+            this.createdAt = Date.now();
+        }
+        this.memoizedOpen.val = open;
+    }
+    get isOpen() {
+        return this.memoizedOpen.val;
+    }
+}
+exports.DialogSpinner = DialogSpinner;

package/lib/Entities/HostBoundary.d.ts

@@ -0,0 +1,10 @@
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}
+export interface VIVEDApp_3 {
+    mount(hostRequestHandler: Handler): Handler;
+    mountDev(container: HTMLElement): void;
+}

package/lib/Entities/HostBoundary.js

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

package/lib/Entities/HostDispatcher.d.ts

@@ -0,0 +1,16 @@
+import { Handler, Request } from "../Types";
+export declare abstract class HostDispatcher {
+    abstract registerAppHandler: (appHandler: Handler) => void;
+    abstract dispatch: (request: Request) => void;
+    abstract showBabylonInspector: (show: boolean) => void;
+    abstract setIsAuthoring: (isAuthoring: boolean) => void;
+    abstract disposeApp: () => void;
+    abstract stopApp: () => void;
+    abstract startApp: (container: HTMLElement) => void;
+    abstract setState: (finalState: string, duration?: number) => void;
+    abstract setDevicePreview: (x: number, y: number) => void;
+    abstract startZSpace: (session: any, emulate: boolean) => void;
+    abstract stopZSpace: () => void;
+    abstract setThemeColors: (colors: object) => void;
+}
+export declare function makeHostDispatcher(): HostDispatcher;

package/lib/Entities/HostDispatcher.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostDispatcher = exports.HostDispatcher = void 0;
+class HostDispatcher {
+}
+exports.HostDispatcher = HostDispatcher;
+function makeHostDispatcher() {
+    return new HostDistpatcherImp();
+}
+exports.makeHostDispatcher = makeHostDispatcher;
+class HostDistpatcherImp extends HostDispatcher {
+    constructor() {
+        super(...arguments);
+        this.appHandlerVersion = 0;
+        this.appPayloadVersions = new Map();
+        this.registerAppHandler = (appHandler) => {
+            this.appHandler = appHandler;
+            this.getAppHandlerVersion();
+        };
+        this.setupVersion = (version) => {
+            // Apps before app package version 2.27 will not reach this
+            this.appHandlerVersion = version;
+            this.getPayloadVersions();
+        };
+        this.setupPayloadVersions = (payloadVersion) => {
+            this.appPayloadVersions = payloadVersion;
+        };
+        this.dispatch = (request) => {
+            if (!this.appHandler) {
+                console.error('[HostDispatcher] No app handler has been registered');
+                return;
+            }
+            this.appHandler(request);
+        };
+        this.showBabylonInspector = (show) => {
+            var _a;
+            const type = 'SHOW_BABYLON_INSPECTOR';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            const payload = {
+                showBabylonInspector: show,
+            };
+            this.doDispatch(type, version, payload);
+        };
+        this.setIsAuthoring = (isAuthoring) => {
+            var _a;
+            const type = 'SET_IS_AUTHORING';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            const payload = { isAuthoring };
+            this.doDispatch(type, version, payload);
+        };
+        this.disposeApp = () => {
+            var _a;
+            const type = 'DISPOSE_APP';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            this.doDispatch(type, version);
+        };
+        this.stopApp = () => {
+            var _a;
+            const type = 'STOP_APP';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            this.doDispatch(type, version);
+        };
+        this.startApp = (container) => {
+            var _a;
+            const type = 'START_APP';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 2;
+            const payload = {
+                container,
+            };
+            this.doDispatch(type, version, payload);
+        };
+        this.setState = (finalState, duration) => {
+            var _a;
+            const type = 'SET_APP_STATE';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 2;
+            const payload = {
+                finalState,
+                duration,
+            };
+            this.doDispatch(type, version, payload);
+        };
+        this.setDevicePreview = (x, y) => {
+            var _a;
+            const type = 'SET_DEVICE_PREVIEW';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            const request = {
+                type,
+                version,
+                payload: {
+                    x,
+                    y,
+                },
+            };
+            this.dispatch(request);
+        };
+        this.startZSpace = (session, emulate) => {
+            var _a;
+            const type = 'START_ZSPACE';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 3;
+            if (version === 2) {
+                const request = {
+                    type,
+                    version,
+                    payload: {
+                        device: 'INSPIRE',
+                        session,
+                        emulate,
+                    },
+                };
+                this.dispatch(request);
+            }
+            else {
+                const request = {
+                    type,
+                    version,
+                    payload: {
+                        session,
+                        emulate,
+                    },
+                };
+                this.dispatch(request);
+            }
+        };
+        this.stopZSpace = () => {
+            var _a;
+            const type = 'STOP_ZSPACE';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            const request = {
+                type,
+                version,
+            };
+            this.dispatch(request);
+        };
+        this.setThemeColors = (colors) => {
+            var _a;
+            const type = 'SET_THEME_COLORS';
+            const version = (_a = this.appPayloadVersions.get(type)) !== null && _a !== void 0 ? _a : 1;
+            const request = {
+                type,
+                version,
+                payload: {
+                    colors,
+                },
+            };
+            this.dispatch(request);
+        };
+    }
+    getAppHandlerVersion() {
+        const type = 'GET_APP_HANDLER_VERSION';
+        const payload = { callback: this.setupVersion };
+        try {
+            this.doDispatch(type, 1, payload);
+        }
+        catch (_a) {
+            // All good. this is probably an older app
+        }
+    }
+    getPayloadVersions() {
+        const type = 'GET_APP_PAYLOAD_VERSION';
+        const payload = { callback: this.setupPayloadVersions };
+        this.doDispatch(type, 2, payload);
+    }
+    doDispatch(type, version, payload) {
+        const request = {
+            type,
+            version,
+            payload,
+        };
+        this.dispatch(request);
+    }
+}

package/lib/Entities/HostHandler.d.ts

@@ -0,0 +1,19 @@
+import { Handler } from "../Types";
+export declare abstract class RequestHandler {
+    abstract readonly requestType: string;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare abstract class HostHandler {
+    abstract handler: Handler;
+    abstract registerRequestHandler: (requestHandler: RequestHandler) => void;
+}
+export declare function makeHostHandler(): HostHandler;
+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/HostHandler.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnableToParsePayload = exports.ActionNotImplemented = exports.UnsupportedRequestVerion = exports.makeHostHandler = exports.HostHandler = exports.RequestHandler = void 0;
+class RequestHandler {
+}
+exports.RequestHandler = RequestHandler;
+class HostHandler {
+}
+exports.HostHandler = HostHandler;
+function makeHostHandler() {
+    return new RequestHandlerImp();
+}
+exports.makeHostHandler = makeHostHandler;
+class RequestHandlerImp extends HostHandler {
+    constructor() {
+        super(...arguments);
+        this.handlers = new Map();
+        this.handler = (request) => {
+            const handler = this.handlers.get(request.type);
+            if (!handler) {
+                console.warn(`[HostHandler] Unsupported request type recieved: ${request.type}`);
+                return;
+            }
+            try {
+                handler.handleRequest(request.version, request.payload);
+            }
+            catch (e) {
+                console.warn(`[HostHandler] ${e}`);
+            }
+        };
+        this.registerRequestHandler = (handler) => {
+            if (this.handlers.has(handler.requestType)) {
+                console.warn(`[HostHandler] More than one handler is being registered for ${handler.requestType}. Previous handler is being overwritten`);
+            }
+            this.handlers.set(handler.requestType, handler);
+        };
+    }
+}
+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/HostHandlerX.d.ts

@@ -0,0 +1,7 @@
+import { RequestHandler } from "../Components";
+import { Handler } from "../Types";
+export declare abstract class HostHandlerX {
+    abstract handler: Handler;
+    abstract registerRequestHandler: (requestHandler: RequestHandler) => void;
+}
+export declare function makeHostHandler(): HostHandlerX;

package/lib/Entities/HostHandlerX.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostHandler = exports.HostHandlerX = void 0;
+class HostHandlerX {
+}
+exports.HostHandlerX = HostHandlerX;
+function makeHostHandler() {
+    return new RequestHandlerImp();
+}
+exports.makeHostHandler = makeHostHandler;
+class RequestHandlerImp extends HostHandlerX {
+    constructor() {
+        super(...arguments);
+        this.handlers = new Map();
+        this.handler = (request) => {
+            const handler = this.handlers.get(request.type);
+            if (!handler) {
+                console.warn(`[HostHandler] Unsupported request type recieved: ${request.type}`);
+                return;
+            }
+            try {
+                handler.handleRequest(request.version, request.payload);
+            }
+            catch (e) {
+                console.warn(`[HostHandler] ${e}`);
+            }
+        };
+        this.registerRequestHandler = (handler) => {
+            if (this.handlers.has(handler.requestType)) {
+                console.warn(`[HostHandler] More than one handler is being registered for ${handler.requestType}. Previous handler is being overwritten`);
+            }
+            this.handlers.set(handler.requestType, handler);
+        };
+    }
+}

package/lib/Entities/Logger.d.ts

@@ -0,0 +1,41 @@
+export declare type LogSeverity = 'LOG' | 'WARNING' | 'ERROR' | 'FATAL';
+export declare type FilterBy = 'sender' | 'severity' | 'message';
+export declare type Log = {
+    sender: string;
+    message: string;
+    severity: LogSeverity;
+};
+export declare type Instructions = 'NOTHING' | 'SHOWLOG' | 'SHOWALL' | 'DOWNLOAD';
+export declare type ObservedLog = {
+    instruction: Instructions;
+    payload: Log | Log[] | DownloadPayload;
+};
+export declare type DownloadPayload = {
+    filename: string;
+    fileData: {
+        filterBy: FilterBy | undefined;
+        filterValue: string | undefined;
+        logs: Log[];
+    };
+};
+export declare type OnLogAdded = (log: Log) => void;
+export declare type OnLogSaved = (observedLog: ObservedLog) => void;
+export interface Logger {
+    addLogSaveObserver: (observer: OnLogSaved) => void;
+    removeLogSavedObserver: (observer: OnLogSaved) => void;
+    addLogAddedObserver: (observer: OnLogAdded) => void;
+    removeLogAddedObserver: (observer: OnLogAdded) => void;
+    log: (sender: string, message: string) => void;
+    warn: (sender: string, message: string) => void;
+    error: (sender: string, message: string) => void;
+    fatal: (sender: string, message: string) => void;
+    clear: () => void;
+    setFilter: (filterBy?: FilterBy, filterValue?: string) => void;
+    clearFilter: () => void;
+    displayAllLogs: () => void;
+    toggleShowLogs: () => void;
+    downloadLogs: () => void;
+    getAllLogs: () => Log[];
+    getFilteredLogs: () => Log[];
+}
+export declare function makeLoggerEntity(): Logger;

package/lib/Entities/Logger.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLoggerEntity = void 0;
+const ObserverList_1 = require("./ObserverList");
+function makeLoggerEntity() {
+    return new LoggerImp();
+}
+exports.makeLoggerEntity = makeLoggerEntity;
+class LoggerImp {
+    constructor() {
+        this.logItems = [];
+        this.showLog = false;
+        this.saveObservers = new ObserverList_1.ObserverList();
+        this.logAddedObservers = new ObserverList_1.ObserverList();
+        this.filterBy = undefined;
+        this.filterValue = undefined;
+        this.addLogSaveObserver = (observer) => {
+            this.saveObservers.add(observer);
+        };
+        this.removeLogSavedObserver = (observer) => {
+            this.saveObservers.remove(observer);
+        };
+        this.addLogAddedObserver = (observer) => {
+            this.logAddedObservers.add(observer);
+        };
+        this.removeLogAddedObserver = (observer) => {
+            this.logAddedObservers.remove(observer);
+        };
+        this.log = (sender, message) => {
+            const log = this.setNewLog(sender, message, 'LOG');
+            this.logAddedObservers.notify(log);
+        };
+        this.warn = (sender, message) => {
+            const log = this.setNewLog(sender, message, 'WARNING');
+            this.logAddedObservers.notify(log);
+        };
+        this.error = (sender, message) => {
+            const log = this.setNewLog(sender, message, 'ERROR');
+            this.logAddedObservers.notify(log);
+        };
+        this.fatal = (sender, message) => {
+            const log = this.setNewLog(sender, message, 'FATAL');
+            this.logAddedObservers.notify(log);
+        };
+        this.clear = () => {
+            this.logItems = [];
+        };
+        this.downloadLogs = () => {
+            const logs = this.getAllLogs();
+            this.saveObservers.notify({
+                instruction: 'DOWNLOAD',
+                payload: {
+                    filename: 'playerLogs.json',
+                    fileData: {
+                        filterBy: this.filterBy,
+                        filterValue: this.filterValue,
+                        logs,
+                    },
+                },
+            });
+        };
+        this.getAllLogs = () => {
+            return [...this.logItems];
+        };
+        this.getFilteredLogs = () => {
+            return this.logItems.filter((item) => this.filterFormula(item));
+        };
+    }
+    displayAllLogs() {
+        const allLogs = this.getFilteredLogs();
+        this.saveObservers.notify({
+            instruction: 'SHOWALL',
+            payload: allLogs,
+        });
+    }
+    toggleShowLogs() {
+        this.showLog = !this.showLog;
+    }
+    setFilter(filterBy, filterValue) {
+        this.filterBy = filterBy;
+        this.filterValue = filterValue;
+    }
+    clearFilter() {
+        this.filterBy = undefined;
+        this.filterValue = undefined;
+    }
+    setNewLog(sender, message, severity) {
+        const log = {
+            sender,
+            message,
+            severity,
+        };
+        this.logItems.push(log);
+        if (this.showLog) {
+            this.saveObservers.notify({
+                instruction: 'SHOWLOG',
+                payload: log,
+            });
+        }
+        return log;
+    }
+    filterFormula(item) {
+        var _a, _b;
+        if (this.filterBy) {
+            const currentValue = item[this.filterBy].toString().toLocaleLowerCase().trim();
+            const desiredValue = (_b = (_a = this.filterValue) === null || _a === void 0 ? void 0 : _a.toString().toLocaleLowerCase().trim()) !== null && _b !== void 0 ? _b : '';
+            const exactMatch = currentValue === desiredValue;
+            const similarMatch = currentValue.includes(desiredValue);
+            if (exactMatch || similarMatch) {
+                return item;
+            }
+        }
+        else {
+            return item;
+        }
+    }
+}

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;

package/lib/Entities/MemoizedNumber.d.ts

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

package/lib/Entities/MemoizedNumber.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedNumber = void 0;
+class MemoizedNumber {
+    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.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedString.d.ts

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

package/lib/Entities/MemoizedString.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedString = void 0;
+class MemoizedString {
+    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.MemoizedString = MemoizedString;

package/lib/Entities/ObservableEntity.d.ts

@@ -0,0 +1,7 @@
+export declare type EntityObserver = () => void;
+export declare abstract class ObservableEntity {
+    private observerList;
+    addObserver: (observer: EntityObserver) => void;
+    removeObserver: (observer: EntityObserver) => void;
+    notify: () => void;
+}

package/lib/Entities/ObservableEntity.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableEntity = void 0;
+const ObserverList_1 = require("./ObserverList");
+class ObservableEntity {
+    constructor() {
+        this.observerList = new ObserverList_1.ObserverList();
+        this.addObserver = (observer) => {
+            this.observerList.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observerList.remove(observer);
+        };
+        this.notify = () => {
+            this.observerList.notify();
+        };
+    }
+}
+exports.ObservableEntity = ObservableEntity;

package/lib/Entities/ObserverList.d.ts

@@ -0,0 +1,7 @@
+export declare class ObserverList<T> {
+    private observers;
+    notify: (msg: T) => void;
+    add: (obs: (msg: T) => void) => void;
+    remove: (obs: (msg: T) => void) => void;
+    clear: () => void;
+}