@vived/host 3.0.0

package/lib/UseCases/Handlers/SubmitLogBase.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type Severity = "LOG" | "WARNING" | "ERROR" | "FATAL";
+export declare type SubmitLogAction = (sender: string, severity: Severity, message: string) => void;
+export declare class SubmitLogBase implements RequestHandler {
+    readonly requestType = "SUBMIT_LOG";
+    action: SubmitLogAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/SubmitLogBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmitLogBase = void 0;
+const Components_1 = require("../../Components");
+class SubmitLogBase {
+    constructor(hostHandler) {
+        this.requestType = "SUBMIT_LOG";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { sender, message, severity } = this.castPayloadV1(payload);
+                this.action(sender, severity, message);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.sender === undefined ||
+            castPayload.severity === undefined ||
+            castPayload.message === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SubmitLogBase = SubmitLogBase;

package/lib/UseCases/Handlers/SubmitResultBase.d.ts

@@ -0,0 +1,32 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type ResultType = "HIT_V1" | "MULTIHIT_V1" | "QUALITY_V1" | "SCORE_V1" | "PROGRESS_V1";
+export declare type Results = HitResultV1 | MultiHitResultV1 | QualityResultV1 | ScoreResultV1 | ProgressResultV1;
+export declare type HitResultV1 = {
+    success: boolean;
+};
+export declare type MultiHitResultV1 = {
+    hits: number;
+    misses: number;
+    unanswered: number;
+};
+export declare type QualityResultV1 = {
+    stars: number;
+    maxStars: number;
+};
+export declare type ScoreResultV1 = {
+    score: number;
+    maxScore: number;
+};
+export declare type ProgressResultV1 = {
+    progress: number;
+};
+export declare type SubmitResultAction = (type: ResultType, result: Results, description: string) => void;
+export declare class SubmitResultBase implements RequestHandler {
+    readonly requestType = "SUBMIT_RESULTS";
+    action: SubmitResultAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV2;
+    private castPayloadV3;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/SubmitResultBase.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmitResultBase = void 0;
+const Components_1 = require("../../Components");
+class SubmitResultBase {
+    constructor(hostHandler) {
+        this.requestType = "SUBMIT_RESULTS";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 2) {
+                const { description, result, resultType } = this.castPayloadV2(payload);
+                this.action(resultType, result, description);
+            }
+            else if (version === 3) {
+                const { description, result, resultType } = this.castPayloadV3(payload);
+                this.action(resultType, result, description);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.result === undefined ||
+            castPayload.resultType === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+    castPayloadV3(payload) {
+        const castPayload = payload;
+        if (castPayload.result === undefined ||
+            castPayload.resultType === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 2, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SubmitResultBase = SubmitResultBase;

package/lib/UseCases/Handlers/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../../Components/Handler/UCs/StartZSpaceHandler";
+export * from "../../Components/Handler/UCs/StopZSpaceHandler";
+export * from "../../Components/Handler/UCs/SubmitLogHandler";
+export * from "../../Components/Handler/UCs/SubmitResultHandler";
+export * from "../../Components/Handler/UCs/ShowSpinnerHandler";
+export * from "../../Components/Handler/UCs/SubmitActivityAssetHandler";

package/lib/UseCases/Handlers/index.js

@@ -0,0 +1,18 @@
+"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("../../Components/Handler/UCs/StartZSpaceHandler"), exports);
+__exportStar(require("../../Components/Handler/UCs/StopZSpaceHandler"), exports);
+__exportStar(require("../../Components/Handler/UCs/SubmitLogHandler"), exports);
+__exportStar(require("../../Components/Handler/UCs/SubmitResultHandler"), exports);
+__exportStar(require("../../Components/Handler/UCs/ShowSpinnerHandler"), exports);
+__exportStar(require("../../Components/Handler/UCs/SubmitActivityAssetHandler"), exports);

package/lib/UseCases/index.d.ts

@@ -0,0 +1 @@
+export * from "./Handlers";

package/lib/UseCases/index.js

@@ -0,0 +1,13 @@
+"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("./Handlers"), exports);

package/lib/Utilities/generateUniqueID.d.ts

@@ -0,0 +1 @@
+export declare function generateUniqueID(): string;

package/lib/Utilities/generateUniqueID.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUniqueID = void 0;
+const uuid_1 = require("uuid");
+function generateUniqueID() {
+    return uuid_1.v4();
+}
+exports.generateUniqueID = generateUniqueID;

package/lib/Utilities/index.d.ts

@@ -0,0 +1 @@
+export * from "./generateUniqueID";

package/lib/Utilities/index.js

@@ -0,0 +1,13 @@
+"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("./generateUniqueID"), exports);

package/lib/ValueObjects/Result.d.ts

@@ -0,0 +1,30 @@
+export declare type Result<T, E> = Resolved<T, E> | Rejected<T, E>;
+export declare const resolve: <T, E = never>(value: T) => Resolved<T, E>;
+export declare const reject: <T = never, E = unknown>(err: E) => Rejected<T, E>;
+interface IResult<T, E> {
+    isResolved: boolean;
+    isRejected: boolean;
+    value?: T;
+    error?: E;
+    then<A>(f: (t: T) => A): Result<A, E>;
+    catch<U>(f: (e: E) => U): Result<T, U>;
+}
+export declare class Rejected<T, E> implements IResult<T, E> {
+    readonly error: E;
+    readonly value: undefined;
+    get isResolved(): boolean;
+    get isRejected(): boolean;
+    then<A>(_f: (t: T) => A): Result<A, E>;
+    catch<U>(f: (e: E) => U): Result<T, U>;
+    constructor(error: E);
+}
+export declare class Resolved<T, E> implements IResult<T, E> {
+    readonly value: T;
+    readonly error: undefined;
+    get isResolved(): boolean;
+    get isRejected(): boolean;
+    then<A>(f: (t: T) => A): Result<A, E>;
+    catch<U>(_f: (e: E) => U): Result<T, U>;
+    constructor(value: T);
+}
+export {};

package/lib/ValueObjects/Result.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolved = exports.Rejected = exports.reject = exports.resolve = void 0;
+const resolve = (value) => new Resolved(value);
+exports.resolve = resolve;
+const reject = (err) => new Rejected(err);
+exports.reject = reject;
+class Rejected {
+    constructor(error) {
+        this.value = undefined;
+        this.error = error;
+    }
+    get isResolved() {
+        return false;
+    }
+    get isRejected() {
+        return true;
+    }
+    then(_f) {
+        return exports.reject(this.error);
+    }
+    catch(f) {
+        return exports.reject(f(this.error));
+    }
+}
+exports.Rejected = Rejected;
+class Resolved {
+    constructor(value) {
+        this.error = undefined;
+        this.value = value;
+    }
+    get isResolved() {
+        return true;
+    }
+    get isRejected() {
+        return false;
+    }
+    then(f) {
+        return exports.resolve(f(this.value));
+    }
+    catch(_f) {
+        return exports.resolve(this.value);
+    }
+}
+exports.Resolved = Resolved;

package/lib/ValueObjects/Version.d.ts

@@ -0,0 +1,22 @@
+export declare enum VersionStage {
+    RELEASED = "released",
+    BETA = "beta",
+    ALPHA = "alpha"
+}
+export declare class Version {
+    static GetLatest(versions: Version[]): Version | undefined;
+    static GetLatestWithMajor(versions: Version[], major: number): Version | undefined;
+    static GetLatestWithMajorMinor(versions: Version[], major: number, minor: number): Version | undefined;
+    static FromString(versionString: string): Version;
+    private static stringToStage;
+    static AreEqual(v1: Version, v2: Version): boolean;
+    static IsNewerVersion(a: Version, b: Version): boolean;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly stage: VersionStage;
+    readonly label?: string;
+    readonly displayString: string;
+    readonly baseVersionString: string;
+    constructor(major: number, minor: number, patch: number, stage: VersionStage, label?: string);
+}

package/lib/ValueObjects/Version.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = exports.VersionStage = void 0;
+var VersionStage;
+(function (VersionStage) {
+    VersionStage["RELEASED"] = "released";
+    VersionStage["BETA"] = "beta";
+    VersionStage["ALPHA"] = "alpha";
+})(VersionStage = exports.VersionStage || (exports.VersionStage = {}));
+class Version {
+    constructor(major, minor, patch, stage, label) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.stage = stage;
+        this.label = label;
+        this.baseVersionString = `${major}.${minor}.${patch}`;
+        let displayString = this.baseVersionString;
+        if (stage === VersionStage.ALPHA) {
+            displayString = displayString + '-alpha';
+        }
+        else if (this.stage === VersionStage.BETA) {
+            displayString = displayString + '-beta';
+        }
+        if (this.label) {
+            displayString = displayString + `-${label}`;
+        }
+        this.displayString = displayString;
+    }
+    static GetLatest(versions) {
+        let latest;
+        for (const v of versions) {
+            if (latest === undefined) {
+                latest = v;
+                continue;
+            }
+            if (v.major > latest.major) {
+                latest = v;
+            }
+            else if (v.major === latest.major) {
+                if (v.minor > latest.minor) {
+                    latest = v;
+                }
+                else if (v.minor === latest.minor) {
+                    if (v.patch > latest.patch) {
+                        latest = v;
+                    }
+                }
+            }
+        }
+        return latest;
+    }
+    static GetLatestWithMajor(versions, major) {
+        let latest;
+        for (const v of versions) {
+            if (v.major !== major)
+                continue;
+            if (latest === undefined) {
+                latest = v;
+                continue;
+            }
+            if (v.minor > latest.minor) {
+                latest = v;
+            }
+            else if (v.minor === latest.minor) {
+                if (v.patch > latest.patch) {
+                    latest = v;
+                }
+            }
+        }
+        return latest;
+    }
+    static GetLatestWithMajorMinor(versions, major, minor) {
+        let latest;
+        for (const v of versions) {
+            if (v.major !== major)
+                continue;
+            if (v.minor !== minor)
+                continue;
+            if (latest === undefined) {
+                latest = v;
+                continue;
+            }
+            if (v.patch > latest.patch) {
+                latest = v;
+            }
+        }
+        return latest;
+    }
+    static FromString(versionString) {
+        const stringSplit = versionString.split('.');
+        if (stringSplit.length !== 3) {
+            throw new Error(`Unable to parse version string: ${versionString} because it could not be split into 3 parts`);
+        }
+        const major = parseInt(stringSplit[0], 10);
+        const minor = parseInt(stringSplit[1], 10);
+        const patchStageLabel = stringSplit[2];
+        let patch = NaN;
+        let stageLabel;
+        const indexOfDash = patchStageLabel.indexOf('-');
+        if (indexOfDash > 0) {
+            const patchStr = patchStageLabel.substring(0, indexOfDash);
+            patch = parseInt(patchStr, 10);
+            stageLabel = patchStageLabel.substring(indexOfDash + 1);
+        }
+        else {
+            patch = parseInt(patchStageLabel, 10);
+        }
+        if (isNaN(major)) {
+            throw new Error(`Unable to parse version string: ${versionString} because Major is not a number`);
+        }
+        if (isNaN(minor)) {
+            throw new Error(`Unable to parse version string: ${versionString} because Minor is not a number`);
+        }
+        if (isNaN(patch)) {
+            throw new Error(`Unable to parse version string: ${versionString} because Patch is not a number`);
+        }
+        let stage = VersionStage.RELEASED;
+        let label;
+        if (stageLabel) {
+            const stageLabelSplit = stageLabel.split('-');
+            if (stageLabelSplit.length > 0) {
+                const stringAsStage = this.stringToStage(stageLabelSplit[0]);
+                if (stringAsStage === undefined) {
+                    label = stageLabel;
+                }
+                else {
+                    stage = stringAsStage;
+                    if (stageLabelSplit.length > 1) {
+                        label = stageLabel.replace(`${stageLabelSplit[0]}-`, '');
+                    }
+                }
+            }
+        }
+        const version = new Version(major, minor, patch, stage, label);
+        return version;
+    }
+    static stringToStage(str) {
+        if (str === VersionStage.ALPHA) {
+            return VersionStage.ALPHA;
+        }
+        else if (str === VersionStage.BETA) {
+            return VersionStage.BETA;
+        }
+        return undefined;
+    }
+    static AreEqual(v1, v2) {
+        if (v1.major !== v2.major)
+            return false;
+        if (v1.minor !== v2.minor)
+            return false;
+        if (v1.patch !== v2.patch)
+            return false;
+        if (v1.stage !== v2.stage)
+            return false;
+        if (v1.label !== v2.label)
+            return false;
+        return true;
+    }
+    static IsNewerVersion(a, b) {
+        if (a.major < b.major)
+            return true;
+        if (a.minor < b.minor)
+            return true;
+        if (a.patch < b.patch)
+            return true;
+        return false;
+    }
+}
+exports.Version = Version;

package/lib/ValueObjects/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Result";
+export * from './Version';

package/lib/ValueObjects/index.js

@@ -0,0 +1,14 @@
+"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("./Result"), exports);
+__exportStar(require("./Version"), exports);

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Components';
+export * from './HostAppObject';
+export * from './Entities';
+export * from './PresentationManagers';
+export * from './Types';
+export * from './Utilities';
+export * from './ValueObjects';

package/lib/index.js

@@ -0,0 +1,19 @@
+"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("./Components"), exports);
+__exportStar(require("./HostAppObject"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./PresentationManagers"), exports);
+__exportStar(require("./Types"), exports);
+__exportStar(require("./Utilities"), exports);
+__exportStar(require("./ValueObjects"), exports);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@vived/host",
+  "version": "3.0.0",
+  "description": "Public Host package for the VIVED Learning App system",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest --watchAll --config jestconfig.json",
+    "testOnce": "jest --config jestconfig.json",
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run testOnce && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://amospatrick@bitbucket.org/cyberscience3d/vivedlearning_host.git"
+  },
+  "keywords": [
+    "VIVED"
+  ],
+  "author": "Amos Patrick",
+  "license": "ISC",
+  "homepage": "https://bitbucket.org/cyberscience3d/vivedlearning_host#readme",
+  "devDependencies": {
+    "@types/jest": "^26.0.22",
+    "jest": "^26.6.3",
+    "prettier": "^2.2.1",
+    "ts-jest": "^26.5.4",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.2.3"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/uuid": "^9.0.8",
+    "@types/webxr": "^0.5.19",
+    "uuid": "^9.0.1"
+  }
+}