@nu-art/build-and-install 0.204.81 → 0.204.83

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
@@ -20,7 +13,7 @@ runner
     .then(() => {
     ts_common_1.StaticLogger.logInfo('completed');
     //TODO: make it an array of non exit params
-    if (!params_1.RuntimeParams.launch)
+    if (!params_1.RuntimeParams.launch && !params_1.RuntimeParams.watch)
         process.exit(0);
 })
     .catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.204.81",
+  "version": "0.204.83",
   "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/phase-runner/PhaseRunnerDispatcher.d.ts

@@ -1,7 +1,7 @@
 import { FunctionKeys, ParamResolver } from '@nu-art/ts-common';
 import { Phase } from '../phase/types';
 import { BaseUnit } from '../unit/core';
-declare class PhaseRunnerDispatcher<T, K extends FunctionKeys<T> = FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>> {
+export declare class PhaseRunnerDispatcher<T, K extends FunctionKeys<T> = FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>> {
     private readonly method;
     constructor(method: K);
     private listeners;
@@ -21,4 +21,3 @@ export interface PhaseRunner_OnUnitsChange {
     __onUnitsChange: (data: BaseUnit[]) => void;
 }
 export declare const dispatcher_UnitChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitsChange, "__onUnitsChange", [data: BaseUnit<import("../unit/core").BaseUnit_Config, import("../unit/core").BaseUnit_RuntimeConfig>[]]>;
-export {};

package/v2/phase-runner/PhaseRunnerDispatcher.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dispatcher_UnitChange = exports.dispatcher_UnitStatusChange = exports.dispatcher_PhaseChange = void 0;
+exports.dispatcher_UnitChange = exports.dispatcher_UnitStatusChange = exports.dispatcher_PhaseChange = exports.PhaseRunnerDispatcher = void 0;
 const ts_common_1 = require("@nu-art/ts-common");
 class PhaseRunnerDispatcher {
     constructor(method) {
@@ -24,6 +24,7 @@ class PhaseRunnerDispatcher {
         });
     }
 }
+exports.PhaseRunnerDispatcher = PhaseRunnerDispatcher;
 exports.dispatcher_PhaseChange = new PhaseRunnerDispatcher('__onPhaseChange');
 exports.dispatcher_UnitStatusChange = new PhaseRunnerDispatcher('__onUnitStatusChange');
 exports.dispatcher_UnitChange = new PhaseRunnerDispatcher('__onUnitsChange');

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 = {

package/v2/unit/consts.d.ts

@@ -0,0 +1,6 @@
+import { WatchEventType } from './types';
+export declare const WatchEvent_Add: WatchEventType;
+export declare const WatchEvent_Update: WatchEventType;
+export declare const WatchEvent_RemoveDir: WatchEventType;
+export declare const WatchEvent_RemoveFile: WatchEventType;
+export declare const WatchEvent_Ready: WatchEventType;

package/v2/unit/consts.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchEvent_Ready = exports.WatchEvent_RemoveFile = exports.WatchEvent_RemoveDir = exports.WatchEvent_Update = exports.WatchEvent_Add = void 0;
+exports.WatchEvent_Add = 'add';
+exports.WatchEvent_Update = 'update';
+exports.WatchEvent_RemoveDir = 'remove_dir';
+exports.WatchEvent_RemoveFile = 'remove_file';
+exports.WatchEvent_Ready = 'ready';

package/v2/unit/core/Unit_TypescriptLib.d.ts

@@ -1,6 +1,7 @@
 import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
-import { UnitPhaseImplementor } from '../types';
+import { UnitPhaseImplementor, WatchEventType } from '../types';
 import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Purge } from '../../phase';
+import { OnWatchEvent } from '../runner-dispatchers';
 export type Unit_TypescriptLib_Config = Unit_Typescript_Config & {
     customTSConfig?: boolean;
     output: string;
@@ -18,14 +19,22 @@ export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Un
     Phase_CheckCyclicImports,
     Phase_Purge,
     Phase_Lint
-]> {
+]>, OnWatchEvent {
     constructor(config: Unit_TypescriptLib<C, RTC>['config']);
+    __onWatchEvent(type: WatchEventType, path?: string): Promise<void>;
     protected init(setInitialized?: boolean): Promise<void>;
     protected resolveTSConfig(): Promise<void>;
     protected clearOutputDir(): Promise<void>;
     protected compileImpl(): Promise<void>;
     protected copyAssetsToOutput(): Promise<void>;
     protected copyPackageJSONToOutput(): Promise<void>;
+    protected handleWatchChange(path: string, shouldRemoveDist?: boolean): Promise<void>;
+    /**
+     * Remove the deleted file/folder from the dist folder on watch remove file event
+     * @param path The path of the currently removed file/folder
+     * @private
+     */
+    private removeSpecificFileFromDist;
     preCompile(): Promise<void>;
     compile(): Promise<void>;
     purge(): Promise<void>;

package/v2/unit/core/Unit_TypescriptLib.js

@@ -34,6 +34,8 @@ const RunnerParams_1 = require("../../phase-runner/RunnerParams");
 const cli_1 = require("@nu-art/commando/core/cli");
 const consts_1 = require("../../../core/consts");
 const params_1 = require("../../../core/params/params");
+const runner_dispatchers_1 = require("../runner-dispatchers");
+const consts_2 = require("../consts");
 const extensionsToLint = ['.ts', '.tsx'];
 const assetExtensions = [
     'json',
@@ -49,6 +51,12 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
     constructor(config) {
         super(config);
         this.addToClassStack(Unit_TypescriptLib);
+        runner_dispatchers_1.dispatcher_WatchEvent.addListener(this);
+    }
+    async __onWatchEvent(type, path) {
+        if (type === consts_2.WatchEvent_Ready)
+            return this.setStatus('Watching');
+        await this.handleWatchChange(path, [consts_2.WatchEvent_RemoveFile, consts_2.WatchEvent_RemoveDir].includes(type));
     }
     async init(setInitialized = true) {
         await super.init(false);
@@ -113,6 +121,43 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
         const fileContent = JSON.stringify(this.packageJson.dist, null, 2);
         await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
     }
+    async handleWatchChange(path, shouldRemoveDist = false) {
+        // ignore if path doesn't related to unit
+        if (!path.startsWith(this.config.pathToPackage))
+            return;
+        this.setStatus('Compile');
+        // check if dist folder must be cleared
+        if (shouldRemoveDist)
+            await this.removeSpecificFileFromDist(path);
+        // perform all watch actions
+        await this.compileImpl();
+        await this.copyAssetsToOutput();
+        this.setStatus('Watching');
+        // dispatch unit post compile
+        runner_dispatchers_1.dispatcher_UnitWatchCompile.dispatch(this);
+    }
+    /**
+     * Remove the deleted file/folder from the dist folder on watch remove file event
+     * @param path The path of the currently removed file/folder
+     * @private
+     */
+    async removeSpecificFileFromDist(path) {
+        const distPathBase = path.replace('src/main', 'dist').replace(/\.ts$/, '');
+        const pathsToDelete = [
+            `${distPathBase}.js`,
+            `${distPathBase}.d.ts`,
+            `${distPathBase}.js.map`,
+            distPathBase // in case it's a directory
+        ];
+        // try to remove all path options from dist
+        for (const path of pathsToDelete) {
+            if (!fs.existsSync(path)) {
+                this.logDebug(`no file in path ${path}`);
+                continue;
+            }
+            await fs_1.promises.rm(path, { recursive: true, force: true });
+        }
+    }
     //######################### Phase Implementations #########################
     async preCompile() {
         if (!fs.existsSync(`${this.config.pathToPackage}/prebuild.sh`))

package/v2/unit/core/Unit_TypescriptProject.d.ts

@@ -1,15 +1,29 @@
 import { UnitPhaseImplementor } from '../types';
 import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
-import { Phase_Install } from '../../phase';
+import { Phase_Install, Phase_Watch } from '../../phase';
 import { StringMap } from '@nu-art/ts-common/utils/types';
 type Unit_TypescriptProject_Config = Unit_Typescript_Config & {
     globalPackages?: StringMap;
 };
 type Unit_TypescriptProject_RuntimeConfig = Unit_Typescript_RuntimeConfig & {};
-export declare class Unit_TypescriptProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config, RTC extends Unit_TypescriptProject_RuntimeConfig = Unit_TypescriptProject_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
+export declare class Unit_TypescriptProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config, RTC extends Unit_TypescriptProject_RuntimeConfig = Unit_TypescriptProject_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch]> {
+    private readonly suffixesToWatch;
     constructor(config: Unit_TypescriptProject<C>['config']);
     private installGlobals;
     private installPackages;
+    /**
+     * Resolve all paths to watch in all project libs
+     * @private
+     * @returns string[]
+     */
+    private prepareWatchPaths;
+    /**
+     * Init watch events and attach default watch callback with correct params to each of them
+     * @private
+     */
+    private initWatch;
+    private watchImpl;
     install(): Promise<void>;
+    watch(): Promise<void>;
 }
 export {};

package/v2/unit/core/Unit_TypescriptProject.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unit_TypescriptProject = void 0;
 const Unit_Typescript_1 = require("./Unit_Typescript");
@@ -7,9 +30,21 @@ const ts_common_1 = require("@nu-art/ts-common");
 const nvm_1 = require("@nu-art/commando/cli/nvm");
 const pnpm_1 = require("@nu-art/commando/cli/pnpm");
 const consts_1 = require("../../phase-runner/consts");
+const chokidar = __importStar(require("chokidar"));
+const runner_dispatchers_1 = require("../runner-dispatchers");
+const consts_2 = require("../consts");
+const Unit_TypescriptLib_1 = require("./Unit_TypescriptLib");
+const firebase_units_1 = require("../firebase-units");
 class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
     constructor(config) {
         super(config);
+        this.suffixesToWatch = [
+            'ts',
+            'tsx',
+            'scss',
+            'json',
+            'svg'
+        ];
         this.addToClassStack(Unit_TypescriptProject);
     }
     //######################### Internal Logic #########################
@@ -33,10 +68,71 @@ class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
         await pnpm_1.PNPM.createWorkspace(packages);
         await pnpm_1.PNPM.installPackages(nvm_1.NVM.createCommando());
     }
+    /**
+     * Resolve all paths to watch in all project libs
+     * @private
+     * @returns string[]
+     */
+    prepareWatchPaths() {
+        // Using phase runner instance to resolve all project libs to watch
+        const cantBeInstanceOf = [firebase_units_1.Unit_FirebaseHostingApp, firebase_units_1.Unit_FirebaseFunctionsApp];
+        const projectLibs = consts_1.MemKey_PhaseRunner.get()
+            .getUnits().filter(unit => unit.isInstanceOf(Unit_TypescriptLib_1.Unit_TypescriptLib) && cantBeInstanceOf.every(_instance => !unit.isInstanceOf(_instance)));
+        //return all paths to watch
+        return projectLibs.map(lib => {
+            const sourceFolder = `${lib.config.pathToPackage}/src/main`;
+            return { paths: this.suffixesToWatch.map(suffix => `${sourceFolder}/**/*.${suffix}`), unit: lib };
+        });
+    }
+    /**
+     * Init watch events and attach default watch callback with correct params to each of them
+     * @private
+     */
+    initWatch() {
+        const pathDeclarations = this.prepareWatchPaths();
+        const paths = pathDeclarations.flatMap(path => path.paths);
+        const watcher = chokidar.watch(paths);
+        // set all events to watch and handle them
+        return new Promise((resolve, error) => {
+            this.logInfo('Starting the watcher...');
+            watcher
+                .on('error', (error) => {
+                this.logError('Error while watching', error);
+            })
+                .on('ready', () => {
+                this.logInfo('Watching...');
+                runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Ready);
+                watcher
+                    .on('add', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Add, path);
+                })
+                    .on('change', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Update, path);
+                })
+                    .on('unlinkDir', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_RemoveDir, path);
+                })
+                    .on('unlink', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_RemoveFile, path);
+                });
+            });
+            process.on('SIGINT', async (status) => {
+                await watcher.close();
+                process.exit(0);
+                resolve();
+            });
+        });
+    }
+    async watchImpl() {
+        await this.initWatch();
+    }
     //######################### Phase Implementation #########################
     async install() {
         await this.installGlobals();
         await this.installPackages();
     }
+    async watch() {
+        await this.watchImpl();
+    }
 }
 exports.Unit_TypescriptProject = Unit_TypescriptProject;

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.d.ts

@@ -1,12 +1,13 @@
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
+import { BaseUnit, Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
 import { UnitPhaseImplementor } from '../types';
 import { Phase_DeployBackend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
 import { FirebasePackageConfig } from '../../../core/types';
+import { OnUnitWatchCompiled } from '../runner-dispatchers';
 export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     firebaseConfig: FirebasePackageConfig;
     sources?: string[];
 };
-export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]> {
+export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]>, OnUnitWatchCompiled {
     static staggerCount: number;
     private readonly PROXY_PID_LOG;
     private readonly PROXY_KILL_LOG;
@@ -14,6 +15,7 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     private readonly EMULATOR_KILL_LOG;
     private launchCommandos;
     private listeners;
+    __onUnitWatchCompiled(unit: BaseUnit): Promise<void>;
     constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
     resolveConfigs(): Promise<void>;
     compile(): Promise<void>;

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.js

@@ -12,8 +12,18 @@ const cli_1 = require("@nu-art/commando/core/cli");
 const basic_1 = require("@nu-art/commando/cli/basic");
 const nvm_1 = require("@nu-art/commando/cli/nvm");
 const consts_3 = require("../../phase-runner/consts");
+const runner_dispatchers_1 = require("../runner-dispatchers");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
+    async __onUnitWatchCompiled(unit) {
+        if (this.runtime.unitDependencyNames.includes(unit.runtime.dependencyName)) {
+            this.setStatus('Compile');
+            await this.compileImpl();
+            await this.copyAssetsToOutput();
+            await this.createDependenciesDir();
+            this.setStatus('Compiled');
+        }
+    }
     constructor(config) {
         super(config);
         this.PROXY_PID_LOG = '_PROXY_PID_';
@@ -21,6 +31,8 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
         this.EMULATOR_PID_LOG = '_EMULATOR_PID_';
         this.EMULATOR_KILL_LOG = '_EMULATOR_KILLED_';
         this.addToClassStack(Unit_FirebaseFunctionsApp);
+        runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
+        runner_dispatchers_1.dispatcher_UnitWatchCompile.addListener(this);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {

package/v2/unit/firebase-units/Unit_FirebaseHostingApp.js

@@ -11,6 +11,7 @@ const nvm_1 = require("@nu-art/commando/cli/nvm");
 const basic_1 = require("@nu-art/commando/cli/basic");
 const RunnerParams_1 = require("../../phase-runner/RunnerParams");
 const cli_1 = require("@nu-art/commando/core/cli");
+const runner_dispatchers_1 = require("../runner-dispatchers");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     constructor(config) {
@@ -18,6 +19,7 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         this.APP_PID_LOG = '_APP_PID_';
         this.APP_KILL_LOG = '_APP_KILLED_';
         this.addToClassStack(Unit_FirebaseHostingApp);
+        runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {

package/v2/unit/runner-dispatchers.d.ts

@@ -0,0 +1,11 @@
+import { PhaseRunnerDispatcher } from '../phase-runner/PhaseRunnerDispatcher';
+import { WatchEventType } from './types';
+import { BaseUnit } from './core';
+export interface OnWatchEvent {
+    __onWatchEvent: (type: WatchEventType, path?: string) => void;
+}
+export declare const dispatcher_WatchEvent: PhaseRunnerDispatcher<OnWatchEvent, "__onWatchEvent", [type: WatchEventType, path?: string | undefined]>;
+export interface OnUnitWatchCompiled {
+    __onUnitWatchCompiled: (init: BaseUnit) => void;
+}
+export declare const dispatcher_UnitWatchCompile: PhaseRunnerDispatcher<OnUnitWatchCompiled, "__onUnitWatchCompiled", [init: BaseUnit<import("./core").BaseUnit_Config, import("./core").BaseUnit_RuntimeConfig>]>;

package/v2/unit/runner-dispatchers.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatcher_UnitWatchCompile = exports.dispatcher_WatchEvent = void 0;
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
+exports.dispatcher_WatchEvent = new PhaseRunnerDispatcher_1.PhaseRunnerDispatcher('__onWatchEvent');
+exports.dispatcher_UnitWatchCompile = new PhaseRunnerDispatcher_1.PhaseRunnerDispatcher('__onUnitWatchCompiled');

package/v2/unit/types.d.ts

@@ -5,3 +5,4 @@ export type Unit<P extends Phase<string>[]> = BaseUnit & UnitPhaseImplementor<P>
 export type UnitPhaseImplementor<P extends Phase<string>[]> = {
     [K in P[number]['method']]: AsyncVoidFunction;
 };
+export type WatchEventType = 'update' | 'add' | 'remove_file' | 'remove_dir' | 'ready';