@vived/app 3.9.2 → 4.0.0

package/lib/Components/Dispatcher/UC/IsAssetFetchedUC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetFetched = exports.makeIsAssetFetchedUC = exports.IsAssetFetchedUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class IsAssetFetchedUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ASSET_FILE_FETCHED";
+    }
+}
+exports.IsAssetFetchedUC = IsAssetFetchedUC;
+IsAssetFetchedUC.type = "IsAssetFetchedUC";
+IsAssetFetchedUC.get = (appObjects) => AppObject_1.getSingletonComponent(IsAssetFetchedUC.type, appObjects);
+function makeIsAssetFetchedUC(appObject) {
+    return new GetAppAssetsURLUCImp(appObject);
+}
+exports.makeIsAssetFetchedUC = makeIsAssetFetchedUC;
+function isAssetFetched(assetID, appObjects) {
+    const uc = IsAssetFetchedUC.get(appObjects);
+    if (uc) {
+        return uc.doDispatch(assetID);
+    }
+    else {
+        appObjects.submitWarning("isAssetFetched", "Can't find IsAssetFetchedUC");
+        return Promise.reject();
+    }
+}
+exports.isAssetFetched = isAssetFetched;
+class GetAppAssetsURLUCImp extends IsAssetFetchedUC {
+    constructor(appObject) {
+        super(appObject, IsAssetFetchedUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("IsAssetFetchedUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch(assetID) {
+        return new Promise((resolve, reject) => {
+            const callback = (isFetched) => {
+                resolve(isFetched);
+            };
+            const payload = {
+                assetID,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/Components/Dispatcher/UC/IsZSpaceAvailableUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class IsZSpaceAvailableUC extends AppObjectUC {
+    static readonly type = "IsZSpaceAvailableUC";
+    readonly requestType = "IS_ZSPACE_AVAILABLE";
+    abstract doDispatch(): Promise<boolean>;
+    static get: (appObjects: AppObjectRepo) => IsZSpaceAvailableUC | undefined;
+}
+export declare function makeIsZSpaceAvailableUC(appObject: AppObject): IsZSpaceAvailableUC;

package/lib/Components/Dispatcher/UC/IsZSpaceAvailableUC.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsZSpaceAvailableUC = exports.IsZSpaceAvailableUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class IsZSpaceAvailableUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ZSPACE_AVAILABLE";
+    }
+}
+exports.IsZSpaceAvailableUC = IsZSpaceAvailableUC;
+IsZSpaceAvailableUC.type = "IsZSpaceAvailableUC";
+IsZSpaceAvailableUC.get = (appObjects) => AppObject_1.getSingletonComponent(IsZSpaceAvailableUC.type, appObjects);
+function makeIsZSpaceAvailableUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeIsZSpaceAvailableUC = makeIsZSpaceAvailableUC;
+class DispatchStateChangeUCImp extends IsZSpaceAvailableUC {
+    constructor(appObject) {
+        super(appObject, IsZSpaceAvailableUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("IsZSpaceAvailableUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (IsZSpaceAvailable) => {
+                resolve(IsZSpaceAvailable);
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/Components/Dispatcher/UC/LogUC.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class LogUC extends AppObjectUC {
+    static readonly type = "LogUC";
+    readonly requestType = "SUBMIT_LOG";
+    abstract dispatchLog(sender: string, message: string): void;
+    abstract dispatchWarn(sender: string, message: string): void;
+    abstract dispatchError(sender: string, message: string): void;
+    abstract dispatchFatal(sender: string, message: string): void;
+    static get: (appObjects: AppObjectRepo) => LogUC | undefined;
+}
+export declare function makeLogUC(appObject: AppObject): LogUC;

package/lib/Components/Dispatcher/UC/LogUC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLogUC = exports.LogUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class LogUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SUBMIT_LOG";
+    }
+}
+exports.LogUC = LogUC;
+LogUC.type = "LogUC";
+LogUC.get = (appObjects) => AppObject_1.getSingletonComponent(LogUC.type, appObjects);
+function makeLogUC(appObject) {
+    return new LogUCImp(appObject);
+}
+exports.makeLogUC = makeLogUC;
+class LogUCImp extends LogUC {
+    constructor(appObject) {
+        super(appObject, LogUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${LogUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+        }
+    }
+    dispatchLog(sender, message) {
+        this.doDispatch(sender, message, "LOG");
+    }
+    dispatchWarn(sender, message) {
+        this.doDispatch(sender, message, "WARNING");
+    }
+    dispatchError(sender, message) {
+        this.doDispatch(sender, message, "ERROR");
+    }
+    dispatchFatal(sender, message) {
+        this.doDispatch(sender, message, "FATAL");
+    }
+    doDispatch(sender, message, severity) {
+        if (!this.appDispatcher)
+            return;
+        const payload = {
+            sender,
+            severity,
+            message,
+        };
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UC/RegisterExternalStylesheetsUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class RegisterExternalStylesheetsUC extends AppObjectUC {
+    static readonly type = "RegisterExternalStylesheetsUC";
+    readonly requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+    abstract doDispatch(stylesheets: string[]): void;
+    static get: (appObjects: AppObjectRepo) => RegisterExternalStylesheetsUC | undefined;
+}
+export declare function makeRegisterExternalStylesheetsUC(appObject: AppObject): RegisterExternalStylesheetsUC;
+export declare function registerExternalStylesheets(stylesheets: string[], appObjects: AppObjectRepo): void;

package/lib/Components/Dispatcher/UC/RegisterExternalStylesheetsUC.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExternalStylesheets = exports.makeRegisterExternalStylesheetsUC = exports.RegisterExternalStylesheetsUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class RegisterExternalStylesheetsUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+    }
+}
+exports.RegisterExternalStylesheetsUC = RegisterExternalStylesheetsUC;
+RegisterExternalStylesheetsUC.type = "RegisterExternalStylesheetsUC";
+RegisterExternalStylesheetsUC.get = (appObjects) => AppObject_1.getSingletonComponent(RegisterExternalStylesheetsUC.type, appObjects);
+function makeRegisterExternalStylesheetsUC(appObject) {
+    return new RegisterExternalStylesheetsUCImp(appObject);
+}
+exports.makeRegisterExternalStylesheetsUC = makeRegisterExternalStylesheetsUC;
+function registerExternalStylesheets(stylesheets, appObjects) {
+    const dispatchUC = RegisterExternalStylesheetsUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.doDispatch(stylesheets);
+    }
+    else {
+        appObjects.submitWarning("registerExternalStylesheets", "Can't find DispatchStateChangeUC");
+    }
+}
+exports.registerExternalStylesheets = registerExternalStylesheets;
+class RegisterExternalStylesheetsUCImp extends RegisterExternalStylesheetsUC {
+    constructor(appObject) {
+        super(appObject, RegisterExternalStylesheetsUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("DispatchStateChangeUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch(stylesheets) {
+        var _a;
+        const payload = {
+            stylesheets,
+        };
+        (_a = this.appDispatcher) === null || _a === void 0 ? void 0 : _a.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UC/ShowAlertUC.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export interface ShowAlertDTO {
+    title: string;
+    message: string;
+    closeButtonLabel: string;
+    closeCallback: () => void;
+}
+export declare abstract class ShowAlertUC extends AppObjectUC {
+    static readonly type = "ShowAlertUC";
+    readonly requestType = "SHOW_ALERT";
+    abstract showAlert(data: ShowAlertDTO): void;
+    static get: (appObjects: AppObjectRepo) => ShowAlertUC | undefined;
+}
+export declare function makeShowAlertUC(appObject: AppObject): ShowAlertUC;

package/lib/Components/Dispatcher/UC/ShowAlertUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowAlertUC = exports.ShowAlertUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class ShowAlertUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_ALERT";
+    }
+}
+exports.ShowAlertUC = ShowAlertUC;
+ShowAlertUC.type = "ShowAlertUC";
+ShowAlertUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowAlertUC.type, appObjects);
+function makeShowAlertUC(appObject) {
+    return new ShowAlertUCImp(appObject);
+}
+exports.makeShowAlertUC = makeShowAlertUC;
+class ShowAlertUCImp extends ShowAlertUC {
+    constructor(appObject) {
+        super(appObject, ShowAlertUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${ShowAlertUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+    showAlert(data) {
+        if (!this.appDispatcher)
+            return;
+        const payload = {
+            title: data.title,
+            message: data.message,
+            closeButtonLabel: data.closeButtonLabel,
+            closeCallback: data.closeCallback,
+        };
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UC/ShowConfirmUC.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export interface ShowConfirmDTO {
+    title: string;
+    message: string;
+    confirmButtonLabel: string;
+    cancelButtonLabel: string;
+    confirmCallback: () => void;
+    cancelCallback: () => void;
+}
+export declare abstract class ShowConfirmUC extends AppObjectUC {
+    static readonly type = "ShowConfirmUC";
+    readonly requestType = "SHOW_CONFIRM";
+    abstract showConfirm(data: ShowConfirmDTO): void;
+    static get: (appObjects: AppObjectRepo) => ShowConfirmUC | undefined;
+}
+export declare function makeShowConfirmUC(appObject: AppObject): ShowConfirmUC;

package/lib/Components/Dispatcher/UC/ShowConfirmUC.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowConfirmUC = exports.ShowConfirmUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class ShowConfirmUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_CONFIRM";
+    }
+}
+exports.ShowConfirmUC = ShowConfirmUC;
+ShowConfirmUC.type = "ShowConfirmUC";
+ShowConfirmUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowConfirmUC.type, appObjects);
+function makeShowConfirmUC(appObject) {
+    return new ShowAlertUCImp(appObject);
+}
+exports.makeShowConfirmUC = makeShowConfirmUC;
+class ShowAlertUCImp extends ShowConfirmUC {
+    constructor(appObject) {
+        super(appObject, ShowConfirmUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${ShowConfirmUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+    showConfirm(data) {
+        if (!this.appDispatcher)
+            return;
+        const payload = {
+            title: data.title,
+            message: data.message,
+            confirmCallback: data.confirmCallback,
+            cancelButtonLabel: data.cancelButtonLabel,
+            cancelCallback: data.cancelCallback,
+            confirmButtonLabel: data.confirmButtonLabel,
+        };
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UC/ShowMarkdownEditorUC.d.ts

@@ -0,0 +1,15 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export interface ShowMarkDownEditorDTO {
+    initialText: string;
+    submitCallback: (text: string) => void;
+    validateString?: (text: string) => string | null;
+}
+export declare abstract class ShowMarkdownEditorUC extends AppObjectUC {
+    static readonly type = "ShowMarkdownEditorUC";
+    readonly requestType = "SHOW_MARKDOWN_EDITOR";
+    abstract showMarkdownEditor(data: ShowMarkDownEditorDTO): void;
+    static get: (appObjects: AppObjectRepo) => ShowMarkdownEditorUC | undefined;
+}
+export declare function makeShowMarkdownEditorUC(appObject: AppObject): ShowMarkdownEditorUC;

package/lib/Components/Dispatcher/UC/ShowMarkdownEditorUC.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowMarkdownEditorUC = exports.ShowMarkdownEditorUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class ShowMarkdownEditorUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_MARKDOWN_EDITOR";
+    }
+}
+exports.ShowMarkdownEditorUC = ShowMarkdownEditorUC;
+ShowMarkdownEditorUC.type = "ShowMarkdownEditorUC";
+ShowMarkdownEditorUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowMarkdownEditorUC.type, appObjects);
+function makeShowMarkdownEditorUC(appObject) {
+    return new ShowMarkdownEditorUCImp(appObject);
+}
+exports.makeShowMarkdownEditorUC = makeShowMarkdownEditorUC;
+class ShowMarkdownEditorUCImp extends ShowMarkdownEditorUC {
+    constructor(appObject) {
+        super(appObject, ShowMarkdownEditorUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn(`${ShowMarkdownEditorUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+    showMarkdownEditor(data) {
+        var _a;
+        if (!this.appDispatcher)
+            return;
+        const payload = {
+            initialText: (_a = data.initialText) !== null && _a !== void 0 ? _a : "",
+            submitCallback: data.submitCallback,
+        };
+        if (data.validateString) {
+            payload.validateString = data.validateString;
+        }
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UC/ShowSelectModelUC.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class ShowSelectModelUC extends AppObjectUC {
+    static readonly type = "ShowSelectModelUC";
+    readonly requestType = "SHOW_SELECT_MODEL";
+    abstract doDispatch(): Promise<{
+        modelId: string;
+        dataId: string;
+    }>;
+    static get: (appObjects: AppObjectRepo) => ShowSelectModelUC | undefined;
+}
+export declare function makeShowSelectModelUC(appObject: AppObject): ShowSelectModelUC;

package/lib/Components/Dispatcher/UC/ShowSelectModelUC.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowSelectModelUC = exports.ShowSelectModelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class ShowSelectModelUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_SELECT_MODEL";
+    }
+}
+exports.ShowSelectModelUC = ShowSelectModelUC;
+ShowSelectModelUC.type = "ShowSelectModelUC";
+ShowSelectModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowSelectModelUC.type, appObjects);
+function makeShowSelectModelUC(appObject) {
+    return new ShowSelectModelUCImp(appObject);
+}
+exports.makeShowSelectModelUC = makeShowSelectModelUC;
+class ShowSelectModelUCImp extends ShowSelectModelUC {
+    constructor(appObject) {
+        super(appObject, ShowSelectModelUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${ShowSelectModelUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (modelId, dataId) => {
+                resolve({ modelId, dataId });
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/Components/Dispatcher/UC/ShowSpinnerUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class ShowSpinnerUC extends AppObjectUC {
+    static readonly type = "ShowSpinnerUC";
+    readonly requestType = "SHOW_SPINNER";
+    abstract showSpinner(title: string, message: string): Promise<() => void>;
+    static get: (appObjects: AppObjectRepo) => ShowSpinnerUC | undefined;
+}
+export declare function makeShowSpinnerUC(appObject: AppObject): ShowSpinnerUC;

package/lib/Components/Dispatcher/UC/ShowSpinnerUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowSpinnerUC = exports.ShowSpinnerUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class ShowSpinnerUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_SPINNER";
+    }
+}
+exports.ShowSpinnerUC = ShowSpinnerUC;
+ShowSpinnerUC.type = "ShowSpinnerUC";
+ShowSpinnerUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowSpinnerUC.type, appObjects);
+function makeShowSpinnerUC(appObject) {
+    return new ShowSpinnerUCImp(appObject);
+}
+exports.makeShowSpinnerUC = makeShowSpinnerUC;
+class ShowSpinnerUCImp extends ShowSpinnerUC {
+    constructor(appObject) {
+        super(appObject, ShowSpinnerUC.type);
+        this.requestVersion = 1;
+        this.showSpinner = (title, message) => {
+            return new Promise((resolve, reject) => {
+                const closeCallback = (closeSpinner) => {
+                    resolve(closeSpinner);
+                };
+                const payload = {
+                    message,
+                    title,
+                    closeCallback,
+                };
+                if (!this.appDispatcher) {
+                    reject(new Error("No App Dispatcher"));
+                }
+                else {
+                    this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+                }
+            });
+        };
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${ShowSpinnerUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+}

package/lib/Components/Dispatcher/UC/StateHasChangedUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class StateHasChangedUC extends AppObjectUC {
+    static readonly type = "StateHasChangedUC";
+    readonly requestType = "ON_STATE_CHANGE";
+    abstract stateHasChanged(stateObject: object, assets: string[], validationErrorMessage?: string | undefined): void;
+    static get: (appObjects: AppObjectRepo) => StateHasChangedUC | undefined;
+}
+export declare function makeStateHasChangedUC(appObject: AppObject): StateHasChangedUC;

package/lib/Components/Dispatcher/UC/StateHasChangedUC.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStateHasChangedUC = exports.StateHasChangedUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class StateHasChangedUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "ON_STATE_CHANGE";
+    }
+}
+exports.StateHasChangedUC = StateHasChangedUC;
+StateHasChangedUC.type = "StateHasChangedUC";
+StateHasChangedUC.get = (appObjects) => AppObject_1.getSingletonComponent(StateHasChangedUC.type, appObjects);
+function makeStateHasChangedUC(appObject) {
+    return new StateHasChangedUCImp(appObject);
+}
+exports.makeStateHasChangedUC = makeStateHasChangedUC;
+class StateHasChangedUCImp extends StateHasChangedUC {
+    constructor(appObject) {
+        super(appObject, StateHasChangedUC.type);
+        this.requestVersion = 3;
+        this.stateHasChanged = (stateObject, assets, validationErrorMessage) => {
+            if (!this.appDispatcher)
+                return;
+            const payload = {
+                stateObject,
+                assets,
+                validationErrorMessage,
+            };
+            this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+        };
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn(`${StateHasChangedUC.type} has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first`);
+            this.dispose();
+        }
+    }
+}

package/lib/Components/Dispatcher/UC/StateIsCompleteUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class StateIsCompleteUC extends AppObjectUC {
+    static readonly type = "StateIsCompleteUC";
+    readonly requestType = "ON_STATE_COMPLETED";
+    abstract doDispatch(): void;
+    static get: (appObjects: AppObjectRepo) => StateIsCompleteUC | undefined;
+}
+export declare function makeStateIsCompleteUC(appObject: AppObject): StateIsCompleteUC;
+export declare function stateIsComplete(appObjects: AppObjectRepo): void;

package/lib/Components/Dispatcher/UC/StateIsCompleteUC.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateIsComplete = exports.makeStateIsCompleteUC = exports.StateIsCompleteUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class StateIsCompleteUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "ON_STATE_COMPLETED";
+    }
+}
+exports.StateIsCompleteUC = StateIsCompleteUC;
+StateIsCompleteUC.type = "StateIsCompleteUC";
+StateIsCompleteUC.get = (appObjects) => AppObject_1.getSingletonComponent(StateIsCompleteUC.type, appObjects);
+function makeStateIsCompleteUC(appObject) {
+    return new StateIsCompleteUCImp(appObject);
+}
+exports.makeStateIsCompleteUC = makeStateIsCompleteUC;
+function stateIsComplete(appObjects) {
+    const uc = StateIsCompleteUC.get(appObjects);
+    if (uc) {
+        uc.doDispatch();
+    }
+    else {
+        appObjects.submitWarning("stateIsComplete", "Can't find StateIsCompleteUC");
+    }
+}
+exports.stateIsComplete = stateIsComplete;
+class StateIsCompleteUCImp extends StateIsCompleteUC {
+    constructor(appObject) {
+        super(appObject, StateIsCompleteUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("GoToNextStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}