@vived/host 3.0.0

package/lib/Entities/Asset.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAsset = exports.Asset = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class Asset extends ObservableEntity_1.ObservableEntity {
+}
+exports.Asset = Asset;
+function makeAsset(id) {
+    return new AssetImp(id);
+}
+exports.makeAsset = makeAsset;
+class AssetImp extends Asset {
+    constructor(id) {
+        super();
+        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedArchived = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this._memoizedFilename = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedFileURL = new MemoizedString_1.MemoizedString("", this.notify);
+        this._file = undefined;
+        this._blobURL = undefined;
+        this._linkedAssets = [];
+        this._memoizedIsFetchingFile = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this._fetchError = undefined;
+        this.id = id;
+    }
+    get name() {
+        return this._memoizedName.val;
+    }
+    set name(name) {
+        this._memoizedName.val = name;
+    }
+    get description() {
+        return this._memoizedDescription.val;
+    }
+    set description(description) {
+        this._memoizedDescription.val = description;
+    }
+    get archived() {
+        return this._memoizedArchived.val;
+    }
+    set archived(archived) {
+        this._memoizedArchived.val = archived;
+    }
+    get filename() {
+        return this._memoizedFilename.val;
+    }
+    set filename(name) {
+        this._memoizedFilename.val = name;
+    }
+    get fileURL() {
+        return this._memoizedFileURL.val;
+    }
+    set fileURL(name) {
+        this._memoizedFileURL.val = name;
+    }
+    setFile(file) {
+        this._file = file;
+        this._blobURL = URL.createObjectURL(file);
+        this.notify();
+    }
+    get file() {
+        return this._file;
+    }
+    get blobURL() {
+        return this._blobURL;
+    }
+    get linkedAssets() {
+        return [...this._linkedAssets];
+    }
+    addLinkedAsset(type, id) {
+        const existingAsset = this._linkedAssets.find(asset => {
+            return asset.id === id;
+        });
+        if (existingAsset === undefined) {
+            this._linkedAssets.push({
+                id,
+                type
+            });
+            this.notify();
+        }
+    }
+    removeLinkedAsset(type, id) {
+        let foundAsset = false;
+        this._linkedAssets.forEach(asset => {
+            if (asset.type === type && asset.id === id) {
+                foundAsset = true;
+            }
+        });
+        if (foundAsset) {
+            this._linkedAssets = this._linkedAssets.filter(asset => asset.id !== id);
+            this.notify();
+        }
+    }
+    getLinkedAssetByType(type) {
+        const rVal = [];
+        this._linkedAssets.forEach(asset => {
+            if (asset.type === type) {
+                rVal.push(asset.id);
+            }
+        });
+        return rVal;
+    }
+    get isFetchingFile() {
+        return this._memoizedIsFetchingFile.val;
+    }
+    set isFetchingFile(archived) {
+        this._memoizedIsFetchingFile.val = archived;
+    }
+    get fetchError() {
+        return this._fetchError;
+    }
+    set fetchError(fetchError) {
+        if (fetchError === undefined && this.fetchError === undefined)
+            return;
+        if (fetchError !== undefined && this.fetchError !== undefined &&
+            fetchError.message === this.fetchError.message)
+            return;
+        this._fetchError = fetchError;
+        this.notify();
+    }
+    dispose() {
+        if (this._blobURL !== undefined) {
+            URL.revokeObjectURL(this._blobURL);
+            this._blobURL = undefined;
+            this.notify();
+        }
+    }
+}

package/lib/Entities/AssetRepo.d.ts

@@ -0,0 +1,10 @@
+import { Asset } from "./Asset";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class AssetRepo extends ObservableEntity {
+    abstract get assets(): Asset[];
+    abstract addAsset(asset: Asset): void;
+    abstract removeAsset(id: string): void;
+    abstract hasAsset(id: string): boolean;
+    abstract getAssetByID(id: string): Asset | undefined;
+}
+export declare function makeAssetRepo(): AssetRepo;

package/lib/Entities/AssetRepo.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAssetRepo = exports.AssetRepo = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+class AssetRepo extends ObservableEntity_1.ObservableEntity {
+}
+exports.AssetRepo = AssetRepo;
+function makeAssetRepo() {
+    return new AssetRepoImp();
+}
+exports.makeAssetRepo = makeAssetRepo;
+class AssetRepoImp extends AssetRepo {
+    constructor() {
+        super();
+        this._assets = [];
+    }
+    get assets() {
+        return [...this._assets];
+    }
+    addAsset(asset) {
+        const newAssets = this._assets.filter(existingAsset => existingAsset.id !== asset.id);
+        newAssets.push(asset);
+        this._assets = [...newAssets];
+        this.notify();
+    }
+    removeAsset(id) {
+        let foundAsset = false;
+        this._assets.forEach(asset => {
+            if (asset.id === id) {
+                foundAsset = true;
+            }
+        });
+        if (foundAsset) {
+            this._assets = this._assets.filter(asset => asset.id !== id);
+            this.notify();
+        }
+    }
+    hasAsset(id) {
+        let hasAsset = false;
+        this._assets.forEach(asset => {
+            if (asset.id === id) {
+                hasAsset = true;
+            }
+        });
+        return hasAsset;
+    }
+    getAssetByID(id) {
+        let foundAsset;
+        this._assets.forEach(asset => {
+            if (asset.id === id) {
+                foundAsset = asset;
+            }
+        });
+        return foundAsset;
+    }
+}

package/lib/Entities/Auth.d.ts

@@ -0,0 +1,7 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class Auth extends ObservableEntity {
+    abstract login(username: string, password: string): Promise<void>;
+    abstract logout(): Promise<void>;
+    abstract refreshAuthenticatedUser(): Promise<void>;
+}
+export declare function makeAuth(): Auth;

package/lib/Entities/Auth.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAuth = exports.Auth = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+class Auth extends ObservableEntity_1.ObservableEntity {
+}
+exports.Auth = Auth;
+function makeAuth() {
+    return new AuthImp();
+}
+exports.makeAuth = makeAuth;
+class AuthImp extends Auth {
+    login(username, password) {
+        return Promise.reject(this.functionNotInjectedError("login"));
+    }
+    logout() {
+        return Promise.reject(this.functionNotInjectedError("logout"));
+    }
+    refreshAuthenticatedUser() {
+        return Promise.reject(this.functionNotInjectedError("getCurrentAuthenticatedUser"));
+    }
+    functionNotInjectedError(functionName) {
+        return new Error(`Auth function ${functionName} has not been injected`);
+    }
+}

package/lib/Entities/ChallengeResults.d.ts

@@ -0,0 +1,40 @@
+export declare type OnChallengeResultsChange = () => void;
+export declare type ChallengeResultType = 'HIT' | 'MULTIHIT' | 'QUALITY' | 'SCORE' | 'PROGRESS';
+export interface ChallengeResult {
+    slideID: string;
+    tries: number;
+    message: string;
+    type: ChallengeResultType;
+    resultData: ChallengeResultHitData | ChallengeResultMultiHitData | ChallengeResultQualityData | ChallengeResultScoreData | ChallengeResultProgressData;
+}
+export interface ChallengeResultHitData {
+    success: boolean;
+}
+export interface ChallengeResultProgressData {
+    maxProgress: number;
+}
+export interface ChallengeResultMultiHitData {
+    hits: number;
+    misses: number;
+    unanswered: number;
+}
+export interface ChallengeResultQualityData {
+    stars: number;
+    maxStars: number;
+}
+export interface ChallengeResultScoreData {
+    score: number;
+    maxScore: number;
+}
+export interface ChallengeResults {
+    results: ChallengeResult[];
+    submitHitResult: (slideID: string, success: boolean, tries: number, message: string) => void;
+    submitMultiHitResult: (slideID: string, hits: number, misses: number, unanswered: number, tries: number, message: string) => void;
+    submitQualityResult: (slideID: string, stars: number, maxStars: number, tries: number, message: string) => void;
+    submitScoreResult: (slideID: string, score: number, maxScore: number, tries: number, message: string) => void;
+    submitProgressResult: (slideID: string, maxProgress: number, message: string) => void;
+    getResultForSlide: (slideID: string) => ChallengeResult | undefined;
+    addObserver: (observer: OnChallengeResultsChange) => void;
+    removeObserver: (observer: OnChallengeResultsChange) => void;
+}
+export declare function makeChallengeResults(): ChallengeResults;

package/lib/Entities/ChallengeResults.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeChallengeResults = void 0;
+const ObserverList_1 = require("./ObserverList");
+function makeChallengeResults() {
+    return new ChallengeResultsImp();
+}
+exports.makeChallengeResults = makeChallengeResults;
+class ChallengeResultsImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this.resultLookup = new Map();
+        this.submitHitResult = (slideID, success, tries, message) => {
+            const resultData = {
+                success,
+            };
+            const result = {
+                slideID,
+                message,
+                resultData,
+                tries,
+                type: 'HIT',
+            };
+            this.resultLookup.set(slideID, result);
+            this.observers.notify();
+        };
+        this.submitMultiHitResult = (slideID, hits, misses, unanswered, tries, message) => {
+            const resultData = {
+                hits,
+                misses,
+                unanswered,
+            };
+            const result = {
+                slideID,
+                message,
+                resultData,
+                tries,
+                type: 'MULTIHIT',
+            };
+            this.resultLookup.set(slideID, result);
+            this.observers.notify();
+        };
+        this.submitQualityResult = (slideID, stars, maxStars, tries, message) => {
+            const resultData = {
+                stars,
+                maxStars,
+            };
+            const result = {
+                slideID,
+                message,
+                resultData,
+                tries,
+                type: 'QUALITY',
+            };
+            this.resultLookup.set(slideID, result);
+            this.observers.notify();
+        };
+        this.submitScoreResult = (slideID, score, maxScore, tries, message) => {
+            const resultData = {
+                score,
+                maxScore,
+            };
+            const result = {
+                slideID,
+                message,
+                resultData,
+                tries,
+                type: 'SCORE',
+            };
+            this.resultLookup.set(slideID, result);
+            this.observers.notify();
+        };
+        this.getResultForSlide = (slideID) => {
+            return this.resultLookup.get(slideID);
+        };
+        this.submitProgressResult = (slideID, maxProgress, message) => {
+            const currentResult = this.getResultForSlide(slideID);
+            if (currentResult && currentResult.resultData.maxProgress > maxProgress) {
+                return;
+            }
+            const resultData = {
+                maxProgress,
+            };
+            const result = {
+                slideID,
+                message,
+                resultData,
+                tries: 1,
+                type: 'PROGRESS',
+            };
+            this.resultLookup.set(slideID, result);
+            this.observers.notify();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get results() {
+        return Array.from(this.resultLookup.values());
+    }
+}

package/lib/Entities/DevicePreview.d.ts

@@ -0,0 +1,20 @@
+export declare type OnDevicePreviewChange = () => void;
+export interface DeviceInfo {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    pixelDensity: number;
+    category: string;
+}
+export interface DevicePreview {
+    deviceList: DeviceInfo[];
+    selectedDevice?: DeviceInfo;
+    setSelectedDevice(id: string): void;
+    clearSelectedDevice(): void;
+    getCategoryList(): string[];
+    getDevicesInCategory(categoryName: string): DeviceInfo[];
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+}
+export declare function makeDevicePreview(): DevicePreview;

package/lib/Entities/DevicePreview.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDevicePreview = void 0;
+const ObserverList_1 = require("./ObserverList");
+function makeDevicePreview() {
+    return new DevicePreviewImp();
+}
+exports.makeDevicePreview = makeDevicePreview;
+class DevicePreviewImp {
+    constructor() {
+        this._deviceLookup = new Map();
+        this.observers = new ObserverList_1.ObserverList();
+        this.setSelectedDevice = (id) => {
+            var _a;
+            const device = this._deviceLookup.get(id);
+            if (!device) {
+                console.warn(`[DevicePreview] Unable to find device by id ${id}`);
+                return;
+            }
+            if (((_a = this._selectedDevice) === null || _a === void 0 ? void 0 : _a.id) === device.id)
+                return;
+            this._selectedDevice = device;
+            this.observers.notify();
+        };
+        this.clearSelectedDevice = () => {
+            if (this._selectedDevice === undefined)
+                return;
+            this._selectedDevice = undefined;
+            this.observers.notify();
+        };
+        this.getCategoryList = () => {
+            const categories = [];
+            this._deviceLookup.forEach((device) => {
+                if (!categories.includes(device.category)) {
+                    categories.push(device.category);
+                }
+            });
+            return categories;
+        };
+        this.getDevicesInCategory = (categoryName) => {
+            const devices = [];
+            this._deviceLookup.forEach((device) => {
+                if (device.category === categoryName) {
+                    devices.push(device);
+                }
+            });
+            return devices;
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get deviceList() {
+        return Array.from(this._deviceLookup.values());
+    }
+    set deviceList(list) {
+        this._deviceLookup.clear();
+        list.forEach((device) => this._deviceLookup.set(device.id, device));
+        this.observers.notify();
+    }
+    get selectedDevice() {
+        return this._selectedDevice;
+    }
+}

package/lib/Entities/DialogAlert.d.ts

@@ -0,0 +1,18 @@
+import { DialogBase } from "./DialogBase";
+export interface DialogAlertDTO {
+    message: string;
+    title: string;
+    buttonLabel: string;
+    onClose?: () => void;
+    preventOutsideDismiss?: boolean;
+}
+export declare const alertDialogType = "ALERT";
+export declare class DialogAlert extends DialogBase {
+    readonly type = "ALERT";
+    readonly title: string;
+    readonly message: string;
+    readonly buttonLabel: string;
+    private postClose?;
+    close: () => void;
+    constructor(data: DialogAlertDTO);
+}

package/lib/Entities/DialogAlert.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogAlert = exports.alertDialogType = void 0;
+const DialogBase_1 = require("./DialogBase");
+exports.alertDialogType = "ALERT";
+class DialogAlert extends DialogBase_1.DialogBase {
+    constructor(data) {
+        super(exports.alertDialogType);
+        this.type = exports.alertDialogType;
+        this.close = () => {
+            this.isOpen = false;
+            if (this.postClose) {
+                this.postClose();
+            }
+        };
+        this.buttonLabel = data.buttonLabel;
+        this.message = data.message;
+        this.title = data.title;
+        this.postClose = data.onClose;
+        if (data.preventOutsideDismiss !== undefined) {
+            this.preventOutsideDismiss = data.preventOutsideDismiss;
+        }
+    }
+}
+exports.DialogAlert = DialogAlert;

package/lib/Entities/DialogBase.d.ts

@@ -0,0 +1,10 @@
+import { MemoizedBoolean } from "./MemoizedBoolean";
+import { ObservableEntity } from "./ObservableEntity";
+export declare class DialogBase extends ObservableEntity {
+    readonly type: string;
+    preventOutsideDismiss: boolean;
+    protected memoizedOpen: MemoizedBoolean;
+    get isOpen(): boolean;
+    set isOpen(open: boolean);
+    constructor(type: string);
+}

package/lib/Entities/DialogBase.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogBase = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const ObservableEntity_1 = require("./ObservableEntity");
+class DialogBase extends ObservableEntity_1.ObservableEntity {
+    constructor(type) {
+        super();
+        this.preventOutsideDismiss = true;
+        this.memoizedOpen = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.type = type;
+    }
+    get isOpen() {
+        return this.memoizedOpen.val;
+    }
+    set isOpen(open) {
+        this.memoizedOpen.val = open;
+    }
+}
+exports.DialogBase = DialogBase;

package/lib/Entities/DialogConfirm.d.ts

@@ -0,0 +1,22 @@
+import { DialogBase } from "./DialogBase";
+export interface DialogConfirmDTO {
+    message: string;
+    title: string;
+    confirmButtonLabel: string;
+    cancelButtonLabel: string;
+    onCancel?: () => void;
+    onConfirm?: () => void;
+}
+export declare const confirmDialogType = "CONFIRM";
+export declare class DialogConfirm extends DialogBase {
+    readonly type = "CONFIRM";
+    readonly title: string;
+    readonly message: string;
+    readonly confirmButtonLabel: string;
+    readonly cancelButtonLabel: string;
+    private postCancel?;
+    cancel: () => void;
+    private postConfirm?;
+    confirm: () => void;
+    constructor(data: DialogConfirmDTO);
+}

package/lib/Entities/DialogConfirm.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogConfirm = exports.confirmDialogType = void 0;
+const DialogBase_1 = require("./DialogBase");
+exports.confirmDialogType = "CONFIRM";
+class DialogConfirm extends DialogBase_1.DialogBase {
+    constructor(data) {
+        super(exports.confirmDialogType);
+        this.type = exports.confirmDialogType;
+        this.cancel = () => {
+            this.isOpen = false;
+            if (this.postCancel) {
+                this.postCancel();
+            }
+        };
+        this.confirm = () => {
+            this.isOpen = false;
+            if (this.postConfirm) {
+                this.postConfirm();
+            }
+        };
+        this.confirmButtonLabel = data.confirmButtonLabel;
+        this.cancelButtonLabel = data.cancelButtonLabel;
+        this.message = data.message;
+        this.title = data.title;
+        this.postCancel = data.onCancel;
+        this.postConfirm = data.onConfirm;
+    }
+}
+exports.DialogConfirm = DialogConfirm;

package/lib/Entities/DialogMarkDownEditor.d.ts

@@ -0,0 +1,14 @@
+import { DialogBase } from './DialogBase';
+export interface DialogMarkDownEditorDTO {
+    initialText: string;
+    onConfirm: (text: string) => void;
+}
+export declare const markDownEditorDialogType = "MARKDOWN_EDITOR";
+export declare class DialogMarkDownEditor extends DialogBase {
+    readonly type = "MARKDOWN_EDITOR";
+    readonly initialText: string;
+    cancel: () => void;
+    private postConfirm;
+    confirm: (text: string) => void;
+    constructor(data: DialogMarkDownEditorDTO);
+}

package/lib/Entities/DialogMarkDownEditor.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogMarkDownEditor = exports.markDownEditorDialogType = void 0;
+const DialogBase_1 = require("./DialogBase");
+exports.markDownEditorDialogType = 'MARKDOWN_EDITOR';
+class DialogMarkDownEditor extends DialogBase_1.DialogBase {
+    constructor(data) {
+        super(exports.markDownEditorDialogType);
+        this.type = exports.markDownEditorDialogType;
+        this.cancel = () => {
+            this.isOpen = false;
+        };
+        this.confirm = (text) => {
+            this.isOpen = false;
+            this.postConfirm(text);
+        };
+        this.initialText = data.initialText;
+        this.postConfirm = data.onConfirm;
+    }
+}
+exports.DialogMarkDownEditor = DialogMarkDownEditor;

package/lib/Entities/DialogRepo.d.ts

@@ -0,0 +1,8 @@
+import { DialogBase } from "./DialogBase";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class DialogRepo extends ObservableEntity {
+    abstract get activeDialog(): DialogBase | null;
+    abstract submitDialog(dialog: DialogBase): void;
+    abstract activeDialogHasClosed(): void;
+}
+export declare function makeDialogRepo(): DialogRepo;

package/lib/Entities/DialogRepo.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDialogRepo = exports.DialogRepo = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+class DialogRepo extends ObservableEntity_1.ObservableEntity {
+}
+exports.DialogRepo = DialogRepo;
+function makeDialogRepo() {
+    return new DialogRepoImp();
+}
+exports.makeDialogRepo = makeDialogRepo;
+class DialogRepoImp extends DialogRepo {
+    constructor() {
+        super(...arguments);
+        this.dialogQueue = [];
+    }
+    get activeDialog() {
+        return this.dialogQueue.length > 0 ? this.dialogQueue[0] : null;
+    }
+    submitDialog(dialog) {
+        this.dialogQueue.push(dialog);
+        if (this.activeDialog === dialog) {
+            dialog.isOpen = true;
+        }
+        this.notify();
+    }
+    activeDialogHasClosed() {
+        const activeDialog = this.activeDialog;
+        if (activeDialog !== null) {
+            this.dialogQueue.splice(0, 1);
+            const newActiveDialog = this.activeDialog;
+            if (newActiveDialog !== null) {
+                newActiveDialog.isOpen = true;
+            }
+            this.notify();
+        }
+    }
+}