@vived/host 3.0.0

package/lib/Entities/ObserverList.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObserverList = void 0;
+class ObserverList {
+    constructor() {
+        this.observers = [];
+        this.notify = (msg) => {
+            this.observers.forEach((obs) => {
+                obs(msg);
+            });
+        };
+        this.add = (obs) => {
+            this.observers.push(obs);
+        };
+        this.remove = (obs) => {
+            const index = this.observers.indexOf(obs);
+            if (index >= 0) {
+                this.observers.splice(index, 1);
+            }
+        };
+        this.clear = () => {
+            this.observers = [];
+        };
+    }
+}
+exports.ObserverList = ObserverList;

package/lib/Entities/SnackbarRepo.d.ts

@@ -0,0 +1,20 @@
+import { Result } from '../ValueObjects/Result';
+export interface Snackbar {
+    message: string;
+    durationInSeconds: number;
+    snackbarAction?: SnackbarAction;
+}
+export interface SnackbarAction {
+    actionButtonText: string;
+    action: () => void;
+}
+export declare type SnackbarObserver = (snackbar: Snackbar | undefined) => void;
+export interface SnackbarRepo {
+    makeSnackbar: (message: string, snackbarAction?: SnackbarAction, durationInSeconds?: number) => Result<null, Error>;
+    getCurrentSnackbar: () => Snackbar | undefined;
+    dismissActiveSnackbar: () => void;
+    callActiveSnackbarAction: () => void;
+    addObserver: (observer: SnackbarObserver) => void;
+    removeObserver: (observer: SnackbarObserver) => void;
+}
+export declare function makeSnackbarRepo(): SnackbarRepo;

package/lib/Entities/SnackbarRepo.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSnackbarRepo = void 0;
+const Result_1 = require("../ValueObjects/Result");
+const ObserverList_1 = require("./ObserverList");
+function makeSnackbarRepo() {
+    return new SnackbarRepoImp();
+}
+exports.makeSnackbarRepo = makeSnackbarRepo;
+class SnackbarRepoImp {
+    constructor(defaultDurationInSeconds = 4) {
+        this.monitoringSnackbarTime = false;
+        this.observers = new ObserverList_1.ObserverList();
+        this.makeSnackbar = (message, snackbarAction, durationInSeconds) => {
+            if (message.trim().length === 0) {
+                const err = new Error('Snackbar must have a message');
+                return Result_1.reject(err);
+            }
+            if (snackbarAction && snackbarAction.actionButtonText.trim().length === 0) {
+                const err = new Error('If a Snackbar has an action then the action button text cannot be empty');
+                return Result_1.reject(err);
+            }
+            const duration = durationInSeconds !== null && durationInSeconds !== void 0 ? durationInSeconds : this.defaultDurationInSeconds;
+            if (duration <= 0) {
+                const err = new Error(`${duration} is an invalid duration for a Snackbar`);
+                return Result_1.reject(err);
+            }
+            const snackbar = {
+                message,
+                durationInSeconds: duration,
+                snackbarAction,
+            };
+            this.snackbarQueue.push(snackbar);
+            this.observers.notify(this.getCurrentSnackbar());
+            this.monitorSnackbarTime();
+            return Result_1.resolve(null);
+        };
+        this.getCurrentSnackbar = () => {
+            return this.snackbarQueue.length > 0 ? this.snackbarQueue[0] : undefined;
+        };
+        this.dismissActiveSnackbar = () => {
+            if (this.snackbarQueue.length > 0) {
+                this.snackbarQueue.splice(0, 1);
+                this.observers.notify(this.getCurrentSnackbar());
+            }
+        };
+        this.callActiveSnackbarAction = () => {
+            const currentSnackbar = this.getCurrentSnackbar();
+            if (currentSnackbar) {
+                if (currentSnackbar.snackbarAction) {
+                    currentSnackbar.snackbarAction.action();
+                    this.dismissActiveSnackbar();
+                }
+            }
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+        this.snackbarQueue = [];
+        this.defaultDurationInSeconds = defaultDurationInSeconds;
+    }
+    monitorSnackbarTime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.monitoringSnackbarTime) {
+                return;
+            }
+            const loopFrequencyInSeconds = 0.1;
+            this.monitoringSnackbarTime = true;
+            while (this.snackbarQueue.length > 0) {
+                const currentSnackbar = this.getCurrentSnackbar();
+                if (currentSnackbar) {
+                    let currentTimeout = currentSnackbar.durationInSeconds;
+                    while (this.getCurrentSnackbar() === currentSnackbar && currentTimeout > 0) {
+                        // tslint:disable-next-line:no-shadowed-variable
+                        yield new Promise((resolve) => setTimeout(resolve, loopFrequencyInSeconds * 1000));
+                        currentTimeout -= loopFrequencyInSeconds;
+                    }
+                    if (this.getCurrentSnackbar() === currentSnackbar && currentTimeout <= 0) {
+                        this.dismissActiveSnackbar();
+                    }
+                }
+            }
+            this.monitoringSnackbarTime = false;
+        });
+    }
+}

package/lib/Entities/VivedAPI.d.ts

@@ -0,0 +1,50 @@
+import { ObservableEntity } from './ObservableEntity';
+export interface AssetDTO {
+    id: string;
+    ownerId: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    filename: string;
+    fileURL: string;
+    linkedAssets: {
+        type: string;
+        asset: AssetDTO;
+    }[];
+}
+export interface NewAssetDTO {
+    name: string;
+    description: string;
+    ownerID: string;
+    file: File;
+}
+export interface UpdateAssetDTO {
+    id: string;
+    name?: string;
+    description?: string;
+    archived?: boolean;
+    file?: File;
+}
+export interface AppDTO {
+    interfaceVersion: string;
+    assetFolderURL: string;
+    entrypoints: string[];
+}
+export declare abstract class VivedAPI extends ObservableEntity {
+    abstract baseUrl: string;
+    abstract get userAuthToken(): string | undefined;
+    abstract set userAuthToken(token: string | undefined);
+    abstract clearAuthToken(): void;
+    abstract getEndpointURL(endpoint: string): URL;
+    abstract fetchAssetFile: (assetID: string) => Promise<File>;
+    abstract fetchAssetMeta: (assetID: string) => Promise<AssetDTO>;
+    abstract fetchAssetsForOwner: (ownerID: string) => Promise<AssetDTO[]>;
+    abstract setAssetArchived: (assetID: string, archived: boolean) => Promise<void>;
+    abstract postAssetMeta: (data: AssetDTO) => Promise<void>;
+    abstract createNewAsset: (data: NewAssetDTO) => Promise<string>;
+    abstract postAssetFile: (assetID: string, file: File) => Promise<void>;
+    abstract deleteAsset: (assetID: string) => Promise<string>;
+    abstract fetchApp(appID: string, version: string): Promise<AppDTO>;
+    abstract updateAsset(data: UpdateAssetDTO): Promise<string>;
+}
+export declare function makeVivedAPI(): VivedAPI;

package/lib/Entities/VivedAPI.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeVivedAPI = exports.VivedAPI = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+class VivedAPI extends ObservableEntity_1.ObservableEntity {
+}
+exports.VivedAPI = VivedAPI;
+function makeVivedAPI() {
+    return new VivedAPIImp();
+}
+exports.makeVivedAPI = makeVivedAPI;
+class VivedAPIImp extends VivedAPI {
+    constructor() {
+        super(...arguments);
+        this.baseUrl = 'https://api.vivedlearning.com';
+        this.getEndpointURL = (endpoint) => {
+            return new URL(endpoint, this.baseUrl);
+        };
+        this._userAuthToken = undefined;
+        this.clearAuthToken = () => {
+            if (this._userAuthToken === undefined)
+                return;
+            this._userAuthToken = undefined;
+            this.notify();
+        };
+        this.fetchAssetFile = ( /*assetId: string*/) => {
+            return Promise.reject(this.functionNotInjectedError('fetchAssetFile'));
+        };
+        this.fetchAssetMeta = ( /*assetID: string*/) => {
+            return Promise.reject(this.functionNotInjectedError('fetchAssetMeta'));
+        };
+        this.fetchAssetsForOwner = (ownerID) => {
+            return Promise.reject(this.functionNotInjectedError('fetchAssetsForOwner'));
+        };
+        this.setAssetArchived = (assetID, archived) => {
+            return Promise.reject(this.functionNotInjectedError('setAssetArchived'));
+        };
+        this.postAssetMeta = (data) => {
+            return Promise.reject(this.functionNotInjectedError('postAssetMeta'));
+        };
+        this.createNewAsset = (data) => {
+            return Promise.reject(this.functionNotInjectedError('createNewAsset'));
+        };
+        this.postAssetFile = (assetID, file) => {
+            return Promise.reject(this.functionNotInjectedError('postAssetFile'));
+        };
+        this.deleteAsset = (assetID) => {
+            return Promise.reject(this.functionNotInjectedError('deleteAsset'));
+        };
+    }
+    get userAuthToken() {
+        return this._userAuthToken;
+    }
+    set userAuthToken(token) {
+        if (token === this._userAuthToken)
+            return;
+        this._userAuthToken = token;
+        this.notify();
+    }
+    fetchApp(appID, version) {
+        return Promise.reject(this.functionNotInjectedError('fetchApp'));
+    }
+    updateAsset(data) {
+        return Promise.reject(this.functionNotInjectedError('updateAsset'));
+    }
+    functionNotInjectedError(functionName) {
+        return new Error(`API function ${functionName} has not been injected`);
+    }
+}

package/lib/Entities/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Auth';
+export * from './ChallengeResults';
+export * from './Logger';
+export * from './MemoizedBoolean';
+export * from './MemoizedNumber';
+export * from './MemoizedString';
+export * from './ObservableEntity';
+export * from './ObserverList';
+export * from './SnackbarRepo';

package/lib/Entities/index.js

@@ -0,0 +1,21 @@
+"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("./Auth"), exports);
+__exportStar(require("./ChallengeResults"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./MemoizedBoolean"), exports);
+__exportStar(require("./MemoizedNumber"), exports);
+__exportStar(require("./MemoizedString"), exports);
+__exportStar(require("./ObservableEntity"), exports);
+__exportStar(require("./ObserverList"), exports);
+__exportStar(require("./SnackbarRepo"), exports);

package/lib/HostAppObject/HostAppObject.d.ts

@@ -0,0 +1,14 @@
+import { ObservableEntity } from '../Entities';
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+import { HostAppObjectRepo } from './HostAppObjectRepo';
+export declare abstract class HostAppObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract readonly appObjectRepo: HostAppObjectRepo;
+    abstract hasComponent(type: string): boolean;
+    abstract addComponent(component: HostAppObjectComponent): void;
+    abstract getComponent<T extends HostAppObjectComponent>(type: string): T | undefined;
+    abstract removeComponent(type: string): void;
+    abstract allComponents(): HostAppObjectComponent[];
+    abstract dispose(): void;
+}
+export declare function makeAppObject(id: string, repo: HostAppObjectRepo): HostAppObject;

package/lib/HostAppObject/HostAppObject.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppObject = exports.HostAppObject = void 0;
+const Entities_1 = require("../Entities");
+class HostAppObject extends Entities_1.ObservableEntity {
+}
+exports.HostAppObject = HostAppObject;
+function makeAppObject(id, repo) {
+    return new AppObjectImp(id, repo);
+}
+exports.makeAppObject = makeAppObject;
+class AppObjectImp extends HostAppObject {
+    constructor(id, repo) {
+        super();
+        this.componentLookup = new Map();
+        this.dispose = () => {
+            const components = Array.from(this.componentLookup.values());
+            this.componentLookup.clear();
+            components.forEach((c) => c.dispose());
+            if (this.appObjectRepo.has(this.id)) {
+                this.appObjectRepo.remove(this.id);
+            }
+        };
+        this.id = id;
+        this.appObjectRepo = repo;
+        this.appObjectRepo.add(this);
+    }
+    hasComponent(type) {
+        return this.componentLookup.has(type);
+    }
+    addComponent(component) {
+        const currentComponent = this.componentLookup.get(component.type);
+        if (currentComponent) {
+            console.warn(`[AppObject] Component ${component.type} is being replaced on ${this.id}`);
+            currentComponent.dispose();
+        }
+        this.componentLookup.set(component.type, component);
+        this.notify();
+    }
+    getComponent(type) {
+        if (this.componentLookup.has(type)) {
+            return this.componentLookup.get(type);
+        }
+        else {
+            return undefined;
+        }
+    }
+    removeComponent(type) {
+        const component = this.componentLookup.get(type);
+        if (!component)
+            return;
+        this.componentLookup.delete(type);
+        this.notify();
+    }
+    allComponents() {
+        return Array.from(this.componentLookup.values());
+    }
+}

package/lib/HostAppObject/HostAppObjectComponent.d.ts

@@ -0,0 +1,16 @@
+import { HostAppObject } from './HostAppObject';
+import { HostAppObjectRepo } from './HostAppObjectRepo';
+export declare class HostAppObjectComponent {
+    readonly type: string;
+    readonly appObject: HostAppObject;
+    get appObjects(): HostAppObjectRepo;
+    private cachedComponents;
+    getCachedSingleton<T extends HostAppObjectComponent>(type: string): T | undefined;
+    getCachedLocalComponent<T extends HostAppObjectComponent>(type: string): T | undefined;
+    getSingleton<T extends HostAppObjectComponent>(type: string, logType?: 'LOG' | 'WARN' | 'ERROR'): T | undefined;
+    dispose(): void;
+    log(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    constructor(appObject: HostAppObject, type: string);
+}

package/lib/HostAppObject/HostAppObjectComponent.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectComponent = void 0;
+class HostAppObjectComponent {
+    constructor(appObject, type) {
+        this.cachedComponents = new Map();
+        this.appObject = appObject;
+        this.type = type;
+        appObject.addComponent(this);
+    }
+    get appObjects() {
+        return this.appObject.appObjectRepo;
+    }
+    getCachedSingleton(type) {
+        if (!this.cachedComponents.has(type)) {
+            const component = this.appObjects.getSingleton(type);
+            if (!component) {
+                this.warn('Unable to get cached singleton type ' + type);
+            }
+            else {
+                this.cachedComponents.set(type, component);
+            }
+        }
+        return this.cachedComponents.get(type);
+    }
+    getCachedLocalComponent(type) {
+        if (!this.cachedComponents.has(type)) {
+            const component = this.appObject.getComponent(type);
+            if (!component) {
+                this.warn('Unable to get local component of type ' + type);
+            }
+            else {
+                this.cachedComponents.set(type, component);
+            }
+        }
+        return this.cachedComponents.get(type);
+    }
+    getSingleton(type, logType = 'WARN') {
+        const comp = this.appObjects.getSingleton(type);
+        if (!comp) {
+            const msg = 'Unable to get singleton type ' + type;
+            switch (logType) {
+                case 'ERROR':
+                    this.error(msg);
+                    break;
+                case 'LOG':
+                    this.log(msg);
+                    break;
+                case 'WARN':
+                    this.warn(msg);
+                    break;
+            }
+        }
+        return comp;
+    }
+    dispose() {
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+    }
+    log(message) {
+        this.appObjects.submitLog(`${this.appObject.id}/${this.type}`, message);
+    }
+    warn(message) {
+        this.appObjects.submitWarning(`${this.appObject.id}/${this.type}`, message);
+    }
+    error(message) {
+        this.appObjects.submitError(`${this.appObject.id}/${this.type}`, message);
+    }
+}
+exports.HostAppObjectComponent = HostAppObjectComponent;

package/lib/HostAppObject/HostAppObjectController.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare class HostAppObjectController extends HostAppObjectComponent {
+}

package/lib/HostAppObject/HostAppObjectController.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectController = void 0;
+const HostAppObjectComponent_1 = require("./HostAppObjectComponent");
+class HostAppObjectController extends HostAppObjectComponent_1.HostAppObjectComponent {
+}
+exports.HostAppObjectController = HostAppObjectController;

package/lib/HostAppObject/HostAppObjectEntity.d.ts

@@ -0,0 +1,14 @@
+import { HostAppObject } from './HostAppObject';
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare type HostAppObjectEntityObserver = () => void;
+export declare class HostAppObjectEntity extends HostAppObjectComponent {
+    private onDisposeObserverList;
+    addOnDisposeObserver: (observer: HostAppObjectEntityObserver) => void;
+    removeOnDisposeObserver: (observer: HostAppObjectEntityObserver) => void;
+    private onChangeObserverList;
+    addChangeObserver: (observer: HostAppObjectEntityObserver) => void;
+    removeChangeObserver: (observer: HostAppObjectEntityObserver) => void;
+    notifyOnChange: () => void;
+    dispose(): void;
+    constructor(appObject: HostAppObject, type: string);
+}

package/lib/HostAppObject/HostAppObjectEntity.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectEntity = void 0;
+const Entities_1 = require("../Entities");
+const HostAppObjectComponent_1 = require("./HostAppObjectComponent");
+class HostAppObjectEntity extends HostAppObjectComponent_1.HostAppObjectComponent {
+    constructor(appObject, type) {
+        super(appObject, type);
+        this.onDisposeObserverList = new Entities_1.ObserverList();
+        this.addOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.add(observer);
+        };
+        this.removeOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.remove(observer);
+        };
+        this.onChangeObserverList = new Entities_1.ObserverList();
+        this.addChangeObserver = (observer) => {
+            this.onChangeObserverList.add(observer);
+        };
+        this.removeChangeObserver = (observer) => {
+            this.onChangeObserverList.remove(observer);
+        };
+        this.notifyOnChange = () => {
+            this.onChangeObserverList.notify();
+        };
+        this.addChangeObserver(appObject.notify);
+    }
+    dispose() {
+        this.removeChangeObserver(this.appObject.notify);
+        this.onDisposeObserverList.notify();
+        this.onChangeObserverList.clear();
+        this.onDisposeObserverList.clear();
+        super.dispose();
+    }
+}
+exports.HostAppObjectEntity = HostAppObjectEntity;

package/lib/HostAppObject/HostAppObjectEntityRepo.d.ts

@@ -0,0 +1,15 @@
+import { HostAppObjectEntity } from './HostAppObjectEntity';
+export declare class HostAppObjectEntityRepo<T extends HostAppObjectEntity> extends HostAppObjectEntity {
+    private entityLookup;
+    private onEntityAddedObservers;
+    addEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    removeEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    private onEntityRemovedObservers;
+    addEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    removeEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    hasForAppObject: (appObjectID: string) => boolean;
+    add(entity: T): void;
+    removeForAppObject: (id: string) => void;
+    getForAppObject: (appObjectID: string) => T | undefined;
+    getAll: () => T[];
+}

package/lib/HostAppObject/HostAppObjectEntityRepo.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectEntityRepo = void 0;
+const Entities_1 = require("../Entities");
+const HostAppObjectEntity_1 = require("./HostAppObjectEntity");
+class HostAppObjectEntityRepo extends HostAppObjectEntity_1.HostAppObjectEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.onEntityAddedObservers = new Entities_1.ObserverList();
+        this.addEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.add(observer);
+        };
+        this.removeEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.remove(observer);
+        };
+        this.onEntityRemovedObservers = new Entities_1.ObserverList();
+        this.addEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.add(observer);
+        };
+        this.removeEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.remove(observer);
+        };
+        this.hasForAppObject = (appObjectID) => {
+            return this.entityLookup.has(appObjectID);
+        };
+        this.removeForAppObject = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeChangeObserver(this.notifyOnChange);
+            this.notifyOnChange();
+            this.onEntityRemovedObservers.notify(existing);
+        };
+        this.getForAppObject = (appObjectID) => {
+            return this.entityLookup.get(appObjectID);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+    }
+    add(entity) {
+        const existing = this.entityLookup.get(entity.appObject.id);
+        if (existing) {
+            existing.removeChangeObserver(this.notifyOnChange);
+        }
+        this.entityLookup.set(entity.appObject.id, entity);
+        entity.addChangeObserver(this.notifyOnChange);
+        this.notifyOnChange();
+        this.onEntityAddedObservers.notify(entity);
+    }
+}
+exports.HostAppObjectEntityRepo = HostAppObjectEntityRepo;

package/lib/HostAppObject/HostAppObjectPM.d.ts

@@ -0,0 +1,11 @@
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare abstract class HostAppObjectPM<T> extends HostAppObjectComponent {
+    abstract vmsAreEqual(a: T, b: T): boolean;
+    private _lastVM?;
+    get lastVM(): T | undefined;
+    private observerList;
+    addView(updateView: (vm: T) => void): void;
+    removeView(updateView: (vm: T) => void): void;
+    doUpdateView(vm: T): void;
+    dispose(): void;
+}

package/lib/HostAppObject/HostAppObjectPM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectPM = void 0;
+const Entities_1 = require("../Entities");
+const HostAppObjectComponent_1 = require("./HostAppObjectComponent");
+class HostAppObjectPM extends HostAppObjectComponent_1.HostAppObjectComponent {
+    constructor() {
+        super(...arguments);
+        this.observerList = new Entities_1.ObserverList();
+    }
+    get lastVM() {
+        return this._lastVM;
+    }
+    addView(updateView) {
+        this.observerList.add(updateView);
+        if (this._lastVM !== undefined) {
+            updateView(this._lastVM);
+        }
+    }
+    removeView(updateView) {
+        this.observerList.remove(updateView);
+    }
+    doUpdateView(vm) {
+        if (this._lastVM && this.vmsAreEqual(this._lastVM, vm)) {
+            return;
+        }
+        this._lastVM = vm;
+        this.observerList.notify(vm);
+    }
+    dispose() {
+        this.observerList.clear();
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+        super.dispose();
+    }
+}
+exports.HostAppObjectPM = HostAppObjectPM;