@nu-art/build-and-install 0.204.80 → 0.204.82

package/build-and-install.js

@@ -4,15 +4,8 @@ const ts_common_1 = require("@nu-art/ts-common");
 const params_1 = require("./core/params/params");
 const PhaseRunner_1 = require("./v2/phase-runner/PhaseRunner");
 const thunderstorm_1 = require("./v2/unit/thunderstorm");
-// @ts-ignore
-const BAIScreen_UnitList_1 = require("./v2/screens/BAIScreen_UnitList");
 ts_common_1.DebugFlag.DefaultLogLevel = params_1.RuntimeParams.debug ? ts_common_1.LogLevel.Debug : ts_common_1.LogLevel.Info;
 const runner = new PhaseRunner_1.PhaseRunner('./.config/project-config-v2.ts');
-const screen = new BAIScreen_UnitList_1.BAIScreen_UnitList();
-// const screen = new BAIScreen_Launch();
-// screen.setWithRunningLogs(true);
-screen.setOnKillCallback(async () => await runner.killRunner());
-runner.setScreen(screen);
 if (params_1.RuntimeParams.runWithThunderstorm)
     runner.registerUnits(thunderstorm_1.allTSUnits);
 runner

package/core/types/package/package.d.ts

@@ -29,7 +29,7 @@ export type FirebaseEnvConfig<Env extends string> = {
                 storageBucket: string;
                 messagingSenderId: string;
                 appId: string;
-                measurementId: string;
+                measurementId?: string;
             };
         };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.204.80",
+  "version": "0.204.82",
   "description": "",
   "keywords": [
     "TacB0sS",

package/v2/phase-runner/PhaseRunner.d.ts

@@ -2,21 +2,17 @@ import { RelativePath } from '@nu-art/ts-common';
 import { Phase, Phase_Debug, Phase_Help, Phase_PrintEnv } from '../phase';
 import { UnitPhaseImplementor } from '../unit/types';
 import { BaseUnit } from '../unit/core';
-import { BAIScreen } from '../screens/BAIScreen';
 export declare class PhaseRunner extends BaseUnit implements UnitPhaseImplementor<[Phase_Help, Phase_PrintEnv, Phase_Debug]> {
     private readonly phases;
     private readonly units;
     private unitDependencyTree;
     private readonly project;
     private runningStatus;
-    private screen?;
     private phaseFilter;
     constructor(projectPath: RelativePath);
     protected init(): Promise<void>;
     private filterUnits;
     private loadProject;
-    private showAllLogs;
-    private showScreenLogs;
     private prepareProjectParams;
     private prepareDefaultFileRouts;
     private buildUnitDependencyTree;
@@ -57,11 +53,11 @@ export declare class PhaseRunner extends BaseUnit implements UnitPhaseImplemento
      * @param afterPhase
      */
     appendPhase(phase: Phase<string>, afterPhase: Phase<string>): void;
+    getPhases: () => Phase<string>[];
     private setRunningStatus;
     private loadRunningStatus;
     execute(): Promise<void>;
     killRunner(): Promise<void>;
-    setScreen(screen: BAIScreen): void;
     printHelp(): Promise<void>;
     printEnv(): Promise<void>;
     debug(): Promise<void>;

package/v2/phase-runner/PhaseRunner.js

@@ -38,6 +38,7 @@ const basic_1 = require("@nu-art/commando/cli/basic");
 const PhaseRunnerDispatcher_1 = require("./PhaseRunnerDispatcher");
 const consts_2 = require("./consts");
 const types_1 = require("./types");
+const BAIScreenManager_1 = require("../screens/BAIScreenManager");
 class PhaseRunner extends core_1.BaseUnit {
     constructor(projectPath) {
         super({ label: 'Phase Runner', key: 'phase-runner' });
@@ -63,12 +64,12 @@ class PhaseRunner extends core_1.BaseUnit {
                 return dependencyKeys.includes(phase.key);
             }
         };
+        this.getPhases = () => [...this.phases];
         this.addToClassStack(PhaseRunner);
         this.phases = [];
         this.units = [this];
         this.project = { path: (0, tools_1.convertToFullPath)(projectPath), config: {} };
         this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
-        this.showAllLogs();
         this.setMinLevel(ts_common_1.LogLevel.Verbose);
     }
     //######################### Initialization #########################
@@ -76,17 +77,12 @@ class PhaseRunner extends core_1.BaseUnit {
         // await super.init(false);
         //Set phase runner to MemKey, so it can be referenced in the runtime
         consts_2.MemKey_PhaseRunner.set(this);
+        //Init screen manager
+        new BAIScreenManager_1.BAIScreenManager();
         //Load project for use in the phase runner
         await this.loadProject();
         //Filter specific units
         this.filterUnits();
-        //Set Logger if one is not already set, or if the allLogs flag is set
-        if (!this.screen || params_1.RuntimeParams.allLogs) {
-            this.showAllLogs();
-        }
-        else {
-            this.showScreenLogs();
-        }
         this.logDebug('Runtime params:', params_1.RuntimeParams);
         //Set runner params
         const runnerParams = {
@@ -135,25 +131,6 @@ class PhaseRunner extends core_1.BaseUnit {
             throw new ts_common_1.BadImplementationException('Config file must be an asynchronous function returning a ProjectConfigV2 object');
         this.project.config = await projectConfigCB();
     }
-    showAllLogs() {
-        if (this.screen)
-            // @ts-ignore
-            ts_common_1.BeLogged.removeClient(this.screen.logClient);
-        ts_common_1.BeLogged.addClient(ts_common_1.LogClient_Terminal);
-        //If no screen is set, PhaseRunner should be responsible to listening to kill command
-        //Listen on kill signal
-        process.on('SIGINT', async () => {
-            this.logInfo('Kill command received, killing units!');
-            await this.killRunner();
-            this.logInfo('Killed');
-            process.exit(0);
-        });
-    }
-    showScreenLogs() {
-        if (!this.screen)
-            throw new ts_common_1.ThisShouldNotHappenException('Calling showScreenLogs without a screen set!');
-        this.screen.create();
-    }
     prepareProjectParams() {
         var _a;
         const params = (_a = this.project.config.params) !== null && _a !== void 0 ? _a : {};
@@ -398,9 +375,6 @@ class PhaseRunner extends core_1.BaseUnit {
         this.logDebug('Units killed');
         await this.setRunningStatus();
     }
-    setScreen(screen) {
-        this.screen = screen;
-    }
     //######################### Phase Implementation #########################
     async printHelp() {
         this.logInfo('Build and install parameters:');

package/v2/screens/BAIScreen.d.ts

@@ -11,10 +11,11 @@ export declare abstract class BAIScreen<State extends {} = {}> extends ConsoleCo
      */
     constructor(logClientKey: string);
     private createLogClient;
-    startLogClient: () => void;
-    stopLogClient: () => void;
     protected abstract onLogUpdated: () => void;
     protected getLogs: () => string;
+    startScreen: () => void;
+    stopScreen: () => void;
+    protected abstract destroyContent(): void;
     protected onKill(): Promise<never>;
     setOnKillCallback: (cb: AsyncVoidFunction) => AsyncVoidFunction;
 }

package/v2/screens/BAIScreen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BAIScreen = void 0;
 const ConsoleContainer_1 = require("@nu-art/commando/console/ConsoleContainer");
 const ts_common_1 = require("@nu-art/ts-common");
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
 class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
     //######################### Initialization #########################
     /**
@@ -16,17 +17,26 @@ class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
                 keys: ['escape', 'q', 'C-c'],
                 callback: async () => await this.onKill(),
             }]);
-        //######################### Log Client Interaction #########################
-        this.startLogClient = () => {
-            //Remove terminal from BeLogged
-            ts_common_1.BeLogged.removeConsole(ts_common_1.LogClient_Terminal);
+        this.getLogs = () => this.logClient.buffers[0];
+        this.startScreen = () => {
+            //Start listening on dispatchers
+            PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
+            PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
+            PhaseRunnerDispatcher_1.dispatcher_UnitChange.addListener(this);
             //Add this log client to BeLogged
             ts_common_1.BeLogged.addClient(this.logClient);
+            this.create();
         };
-        this.stopLogClient = () => {
+        this.stopScreen = () => {
+            //Stop listening on dispatchers
+            PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.removeListener(this);
+            PhaseRunnerDispatcher_1.dispatcher_PhaseChange.removeListener(this);
+            PhaseRunnerDispatcher_1.dispatcher_UnitChange.removeListener(this);
+            //Remove this log client to BeLogged
             ts_common_1.BeLogged.removeClient(this.logClient);
+            this.destroyContent();
+            this.container.destroy();
         };
-        this.getLogs = () => this.logClient.buffers[0];
         this.setOnKillCallback = (cb) => this.onKillCallback = cb;
         this.createLogClient(logClientKey);
     }

package/v2/screens/BAIScreenManager.d.ts

@@ -0,0 +1,27 @@
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { BAIScreen } from './BAIScreen';
+import { Phase } from '../phase';
+import { PhaseRunner_OnPhaseChange } from '../phase-runner/PhaseRunnerDispatcher';
+export declare const MemKey_BAIScreenManager: MemKey<BAIScreenManager>;
+type BAIScreenConditions = {
+    startOnPhase?: Phase<string>;
+    stopOnPhase?: Phase<string>;
+};
+type BAIScreenOption = {
+    screen: BAIScreen;
+    conditions: BAIScreenConditions;
+};
+export declare class BAIScreenManager implements PhaseRunner_OnPhaseChange {
+    readonly screens: BAIScreenOption[];
+    private currentPhase?;
+    private currentScreen?;
+    constructor();
+    __onPhaseChange: (phase: Phase<string>) => void;
+    addScreen: (screen: BAIScreen, conditions: BAIScreenConditions) => void;
+    removeScreen: (screen: BAIScreen) => void;
+    private getScreenOption;
+    private reAssignScreen;
+    private assignTerminal;
+    private assignScreenOption;
+}
+export {};

package/v2/screens/BAIScreenManager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BAIScreenManager = exports.MemKey_BAIScreenManager = void 0;
+const MemStorage_1 = require("@nu-art/ts-common/mem-storage/MemStorage");
+const ts_common_1 = require("@nu-art/ts-common");
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
+const consts_1 = require("../phase-runner/consts");
+exports.MemKey_BAIScreenManager = new MemStorage_1.MemKey('bai-screen-manager');
+class BAIScreenManager {
+    constructor() {
+        this.screens = [];
+        this.__onPhaseChange = (phase) => {
+            this.currentPhase = phase;
+            this.reAssignScreen();
+        };
+        // ######################### Screens #########################
+        this.addScreen = (screen, conditions) => {
+            if (this.screens.find(op => op.screen === screen))
+                return;
+            this.screens.push({ screen, conditions });
+        };
+        this.removeScreen = (screen) => {
+            const index = this.screens.findIndex(op => op.screen === screen);
+            if (index === -1)
+                return;
+            (0, ts_common_1.removeFromArrayByIndex)(this.screens, index);
+        };
+        exports.MemKey_BAIScreenManager.set(this);
+        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
+        this.assignTerminal();
+    }
+    // ######################### Screen Transition Logic #########################
+    getScreenOption() {
+        const phases = consts_1.MemKey_PhaseRunner.get().getPhases();
+        const currentPhaseIndex = this.currentPhase ? phases.indexOf(this.currentPhase) : -1;
+        return this.screens.find(screenOption => {
+            //Fail fast if current phase is on or past the stopOnPhase
+            if (screenOption.conditions.stopOnPhase) {
+                const index = phases.indexOf(screenOption.conditions.stopOnPhase);
+                if (currentPhaseIndex >= index)
+                    return false;
+            }
+            //Fail fast if current phase is before the startOnPhase
+            if (screenOption.conditions.startOnPhase) {
+                const index = phases.indexOf(screenOption.conditions.startOnPhase);
+                if (currentPhaseIndex < index)
+                    return false;
+            }
+            return true;
+        });
+    }
+    reAssignScreen() {
+        const screenToAssign = this.getScreenOption();
+        //No screen conditions pass
+        if (!screenToAssign)
+            return this.assignTerminal();
+        this.assignScreenOption(screenToAssign);
+    }
+    assignTerminal() {
+        //Un assign current screen
+        if (this.currentScreen) {
+            this.currentScreen.screen.stopScreen();
+        }
+        ts_common_1.BeLogged.addClient(ts_common_1.LogClient_Terminal);
+    }
+    assignScreenOption(screen) {
+        //No need to do anything if same screen
+        if (this.currentScreen === screen)
+            return;
+        //Un assign current screen
+        if (this.currentScreen) {
+            this.currentScreen.screen.stopScreen();
+        }
+        else {
+            //Remove terminal from the BeLogged
+            ts_common_1.BeLogged.removeClient(ts_common_1.LogClient_Terminal);
+        }
+        //Assign given screen
+        this.currentScreen = screen;
+        this.currentScreen.screen.startScreen();
+    }
+}
+exports.BAIScreenManager = BAIScreenManager;

package/v2/screens/BAIScreen_Launch.d.ts

@@ -14,6 +14,8 @@ export declare class BAIScreen_Launch extends BAIScreen implements PhaseRunner_O
     private createGridWidgets;
     private calculateGridDimensions;
     private getGridWidgetLabel;
+    protected destroyContent(): void;
+    private destroyGridWidgets;
     protected render(): void;
     private getContentForWidget;
     private renderGridWidgets;

package/v2/screens/BAIScreen_Launch.js

@@ -4,7 +4,6 @@ exports.BAIScreen_Launch = void 0;
 const BAIScreen_1 = require("./BAIScreen");
 const consts_1 = require("../phase-runner/consts");
 const firebase_units_1 = require("../unit/firebase-units");
-const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
 class BAIScreen_Launch extends BAIScreen_1.BAIScreen {
     //######################### Lifecycle #########################
     constructor() {
@@ -31,7 +30,7 @@ class BAIScreen_Launch extends BAIScreen_1.BAIScreen {
             });
         };
         this.createGridWidgets = () => {
-            this.gridCellWidgets.forEach(widget => widget.destroy());
+            this.destroyGridWidgets();
             this.calculateGridDimensions();
             let xPos = 0;
             let widgetIndex = 0;
@@ -86,6 +85,9 @@ class BAIScreen_Launch extends BAIScreen_1.BAIScreen {
                 return this.units[index].config.label;
             return index === this.units.length ? 'Running Logs' : this.units[index].config.label;
         };
+        this.destroyGridWidgets = () => {
+            this.gridCellWidgets.forEach(widget => widget.destroy());
+        };
         this.getContentForWidget = (widgetIndex) => {
             var _a, _b;
             if (!this.withRunningLogs) {
@@ -113,12 +115,10 @@ class BAIScreen_Launch extends BAIScreen_1.BAIScreen {
     createContent() {
         this.updateUnits();
         this.createGridWidgets();
-        //Start listening on dispatchers
-        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
-        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
-        PhaseRunnerDispatcher_1.dispatcher_UnitChange.addListener(this);
-        //Start the log client
-        this.startLogClient();
+    }
+    //######################### Content Destruction #########################
+    destroyContent() {
+        this.destroyGridWidgets();
     }
     //######################### Render #########################
     render() {

package/v2/screens/BAIScreen_UnitList.d.ts

@@ -17,7 +17,10 @@ export declare class BAIScreen_UnitList extends BAIScreen<State> implements Phas
     __onUnitStatusChange(unit: BaseUnit): void;
     __onUnitsChange(data: BaseUnit[]): void;
     protected onLogUpdated: () => void;
+    protected destroyContent(): void;
+    private destroyPhaseWidget;
     private destroyUnitListWidget;
+    private destroyLogWidget;
     protected createContent(): void;
     private createPhaseWidget;
     private createUnitListWidget;

package/v2/screens/BAIScreen_UnitList.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BAIScreen_UnitList = void 0;
-const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
 const BAIScreen_1 = require("./BAIScreen");
 const consts_1 = require("../phase-runner/consts");
 class BAIScreen_UnitList extends BAIScreen_1.BAIScreen {
@@ -27,23 +26,30 @@ class BAIScreen_UnitList extends BAIScreen_1.BAIScreen {
         this.renderUnitList();
     }
     //######################### Content Destruction #########################
+    destroyContent() {
+        this.destroyPhaseWidget();
+        this.destroyUnitListWidget();
+        this.destroyLogWidget();
+    }
+    destroyPhaseWidget() {
+        var _a;
+        (_a = this.phaseWidget) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
     destroyUnitListWidget() {
         var _a, _b;
         (_a = this.unitWrapperWidget) === null || _a === void 0 ? void 0 : _a.destroy();
         (_b = this.unitWidgets) === null || _b === void 0 ? void 0 : _b.forEach(group => group.forEach(widget => widget.destroy()));
     }
+    destroyLogWidget() {
+        var _a;
+        (_a = this.logWidget) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
     //######################### Content Creation #########################
     createContent() {
         //Create widgets
         this.createPhaseWidget();
         this.createUnitListWidget();
         this.createLogWidget();
-        //Start listening on dispatchers
-        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
-        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
-        PhaseRunnerDispatcher_1.dispatcher_UnitChange.addListener(this);
-        //Start the log client
-        this.startLogClient();
     }
     createPhaseWidget() {
         const props = {