@nu-art/build-and-install 0.204.67 → 0.204.69

package/v2/phase-runner/PhaseRunner.js

@@ -1,57 +1,417 @@
 "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.PhaseRunner = void 0;
 const ts_common_1 = require("@nu-art/ts-common");
-const BaseUnit_1 = require("../unit/core/BaseUnit");
-class PhaseRunner extends BaseUnit_1.BaseUnit {
-    constructor(phases) {
+const RunnerParams_1 = require("./RunnerParams");
+const core_1 = require("../unit/core");
+const params_1 = require("../../core/params/params");
+const MemStorage_1 = require("@nu-art/ts-common/mem-storage/MemStorage");
+const fs_1 = __importStar(require("fs"));
+const tools_1 = require("@nu-art/commando/core/tools");
+const thunderstorm_1 = require("../unit/thunderstorm");
+const consts_1 = require("../../defaults/consts");
+const nvm_1 = require("@nu-art/commando/cli/nvm");
+const basic_1 = require("@nu-art/commando/cli/basic");
+const PhaseRunnerDispatcher_1 = require("./PhaseRunnerDispatcher");
+const consts_2 = require("./consts");
+const types_1 = require("./types");
+class PhaseRunner extends core_1.BaseUnit {
+    constructor(projectPath) {
         super({ label: 'Phase Runner', key: 'phase-runner' });
-        this.units = [];
-        this.runnerParams = {};
-        this._getRunnerParam = (runnerParamKey) => this.runnerParams[runnerParamKey];
-        this.phases = phases;
+        //######################### Internal Logic #########################
+        this.phaseFilters = {
+            [types_1.PhaseRunnerMode_Normal]: async (phase) => {
+                return !(0, ts_common_1.exists)(phase.filter) || (await phase.filter());
+            },
+            [types_1.PhaseRunnerMode_Continue]: async (phase) => {
+                const currentPhaseIndex = this.phases.findIndex(phase => phase.key === this.runningStatus.phaseKey);
+                const phaseIndex = this.phases.indexOf(phase);
+                //True if the phase index is larger equals the index of the first phase that will run in continue
+                if (phaseIndex >= currentPhaseIndex)
+                    return true;
+                //Check if phase should run as a dependency
+                const allPhasesThatWillRun = [];
+                for (const phase of this.phases) {
+                    const index = this.phases.indexOf(phase);
+                    if (index >= currentPhaseIndex && await this.phaseFilters[types_1.PhaseRunnerMode_Normal](phase))
+                        allPhasesThatWillRun.push(phase);
+                }
+                const dependencyKeys = (0, ts_common_1.flatArray)(allPhasesThatWillRun.map(phase => { var _a; return (_a = phase.dependencyPhaseKeys) !== null && _a !== void 0 ? _a : []; }));
+                return dependencyKeys.includes(phase.key);
+            }
+        };
+        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 #########################
     async init() {
-        this.runnerParams['rootPath'] = process.cwd();
-        this.runnerParams['configPath'] = this.runnerParams['rootPath'] + '/.config';
+        // await super.init(false);
+        //Set phase runner to MemKey, so it can be referenced in the runtime
+        consts_2.MemKey_PhaseRunner.set(this);
+        //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 = {
+            rootPath: process.cwd(),
+            configPath: process.cwd() + '/.config',
+        };
+        RunnerParams_1.MemKey_RunnerParams.set(runnerParams);
+        //Set Project Params
+        const projectParams = this.prepareProjectParams();
+        RunnerParams_1.MemKey_ProjectConfig.set(Object.assign(Object.assign({}, this.project.config), { params: projectParams }));
+        //Set Default File Routes
+        const defaultFileRoutes = this.prepareDefaultFileRouts();
+        consts_1.MemKey_DefaultFiles.set(defaultFileRoutes);
+        //Load running status
+        await this.loadRunningStatus();
+        //Print init results
+        this.printInit();
+        this.setStatus('Initialized');
+        const units = this.units.filter(unit => unit !== this);
+        await Promise.all(units.map(unit => {
+            // @ts-ignore
+            return unit.init();
+        }));
+    }
+    filterUnits() {
+        const useUnits = params_1.RuntimeParams.usePackage;
+        if (!useUnits || !useUnits.length)
+            return;
+        const unitsToRemove = [];
+        for (const unit of this.units) {
+            if (unit === this)
+                continue;
+            if (!useUnits.includes(unit.config.key))
+                unitsToRemove.push(unit);
+        }
+        unitsToRemove.forEach(unit => (0, ts_common_1.removeItemFromArray)(this.units, unit));
+    }
+    async loadProject() {
+        if (!fs_1.default.existsSync(this.project.path))
+            throw new ts_common_1.ImplementationMissingException(`Missing project config file, could not find in path: ${this.project.path}`);
+        const projectConfigCB = require(this.project.path).default;
+        if (typeof projectConfigCB !== 'function')
+            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 : {};
+        params[consts_2.CONST_ThunderstormVersionKey] = this.project.config.thunderstormVersion;
+        params[consts_2.CONST_ThunderstormDependencyKey] = this.project.config.thunderstormVersion;
+        params[consts_2.CONST_ProjectVersionKey] = this.project.config.projectVersion;
+        params[consts_2.CONST_ProjectDependencyKey] = this.project.config.projectVersion;
+        return params;
+    }
+    prepareDefaultFileRouts() {
+        const defaultFileRoutes = (0, ts_common_1.deepClone)(consts_1.Default_Files);
+        const projectDefaultFileRoutes = RunnerParams_1.MemKey_ProjectConfig.get().defaultFileRoutes;
+        return (0, ts_common_1.merge)(defaultFileRoutes, projectDefaultFileRoutes);
+    }
+    buildUnitDependencyTree() {
+        const units = [...this.units];
+        const allDependencies = units.map(unit => unit.runtime.dependencyName);
+        const resolvedUnitNames = [];
+        const dependencyTree = [];
+        while (units.length) {
+            if (!resolvedUnitNames.length) {
+                //First run - get all units that don't have other units as dependencies
+                const nonDependantUnits = units.filter(unit => {
+                    return !(0, ts_common_1.arrayIncludesAny)(unit.runtime.unitDependencyNames, allDependencies);
+                });
+                //Remove gathered units from the list of units to resolve
+                nonDependantUnits.forEach(unit => (0, ts_common_1.removeItemFromArray)(units, unit));
+                //Add resolved unit names to the array
+                resolvedUnitNames.push(...nonDependantUnits.map(unit => unit.runtime.dependencyName));
+                //Add resolved units as a layer in the dependency tree
+                dependencyTree.push(nonDependantUnits);
+                continue;
+            }
+            //Not first run - get all units where their dependencies are already resolved.
+            const resolvingUnits = units.filter(unit => {
+                const dependencyUnitPackageNames = unit.runtime.unitDependencyNames.filter(dependency => allDependencies.includes(dependency));
+                return dependencyUnitPackageNames.every(dependency => resolvedUnitNames.includes(dependency));
+            });
+            //Remove gathered units from the list of units to resolve
+            resolvingUnits.forEach(unit => (0, ts_common_1.removeItemFromArray)(units, unit));
+            //Add resolved unit names to the array
+            resolvedUnitNames.push(...resolvingUnits.map(unit => unit.runtime.dependencyName));
+            //Add resolved units as a layer in the dependency tree
+            dependencyTree.push(resolvingUnits);
+        }
+        this.unitDependencyTree = dependencyTree;
+        const toPrint = dependencyTree.map(row => row.map(unit => unit.config.label));
+        this.logDebug('Unit Dependency Tree:', toPrint);
+    }
+    printInit() {
+        this.logDebug('Runner Params:', RunnerParams_1.MemKey_RunnerParams.get());
+        this.logDebug('Project Config:', RunnerParams_1.MemKey_ProjectConfig.get());
+        this.logDebug('Default File Routes:', consts_1.MemKey_DefaultFiles.get());
+    }
+    async executeImpl() {
+        for (const phase of this.phases) {
+            const phaseDidRun = await this.executePhase(phase);
+            //If phase is terminating
+            if (phaseDidRun && phase.terminateAfterPhase)
+                break;
+        }
     }
     //######################### Unit Logic #########################
     registerUnits(units) {
-        (0, ts_common_1.asArray)(units).forEach(unit => this.units.push(unit));
+        this.units.push(...(0, ts_common_1.asArray)(units));
+        (0, ts_common_1.sortArray)(this.units, unit => {
+            //Phase runner is first
+            if (unit === this)
+                return 0;
+            //Second priority for project units
+            if (unit instanceof core_1.Unit_TypescriptProject)
+                return 1;
+            //TS units after project units, but before the rest
+            return thunderstorm_1.allTSUnits.includes(unit) ? 2 : 3;
+        });
     }
     getUnitsForPhase(phase) {
-        return this.units.filter(unit => (0, ts_common_1.exists)(unit[phase.method]));
-    }
-    async initUnits() {
-        return Promise.all(this.units.map(unit => {
-            unit.setGetRunnerParamCaller(this._getRunnerParam);
-            // @ts-ignore
-            unit.init();
+        return (0, ts_common_1.filterInstances)(this.unitDependencyTree.map(row => {
+            const filteredRow = row.filter(unit => {
+                if ((0, ts_common_1.exists)(unit.config.filter) && !unit.config.filter())
+                    return false;
+                return (0, ts_common_1.exists)(unit[phase.method]);
+            });
+            return filteredRow.length ? filteredRow : undefined;
         }));
     }
+    getUnits() {
+        return this.units;
+    }
     //######################### Phase Logic #########################
+    /**
+     * Determines whether to run the phase.</br>
+     * returns true if phase ran, false otherwise
+     * @param phase
+     * @private
+     */
     async executePhase(phase) {
-        const willExecutePhase = (0, ts_common_1.exists)(phase.filter) && !phase.filter();
-        if (!willExecutePhase)
-            return this.logInfo(`Will not execute phase: ${phase.name}, did not pass filter`);
+        var _a;
+        const willExecutePhase = await this.phaseFilter(phase);
+        if (!willExecutePhase) {
+            this.logDebug(`Will not execute phase: ${phase.name}, did not pass filter`);
+            return false;
+        }
         const units = this.getUnitsForPhase(phase);
-        if (!units.length)
-            return this.logInfo(`Will not execute phase: ${phase.name}, no units to execute`);
-        this.logInfo(`Executing phase: ${phase.name} for ${units.length} units`);
-        for (const unit of units) {
-            await unit[phase.method]();
+        if (!units.length) {
+            this.logDebug(`Will not execute phase: ${phase.name}, no units to execute`);
+            return false;
+        }
+        this.logDebug(`Executing phase: ${phase.name}`);
+        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.dispatch(phase);
+        const phaseIndex = this.phases.indexOf(phase);
+        let runningPhaseIndex = this.phases.findIndex(phase => phase.key === this.runningStatus.phaseKey);
+        const inContinueMode = this.phaseFilter === this.phaseFilters[types_1.PhaseRunnerMode_Continue];
+        //Run all units at the same time
+        if (!phase.runUnitsInDependency) {
+            //The current phase is (or is after) the running status phase
+            if (phaseIndex >= runningPhaseIndex) {
+                this.runningStatus = { phaseKey: phase.key, packageDependencyIndex: 0 };
+                await this.setRunningStatus();
+                //Return to normal mode, if in continue
+                if (inContinueMode)
+                    this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
+            }
+            const unitsToRun = (0, ts_common_1.flatArray)(units);
+            await Promise.all(unitsToRun.map(unit => unit[phase.method]()));
+            return true;
+        }
+        //Run units according to dependency tree
+        for (const row of units) {
+            const index = units.indexOf(row);
+            const runningStatusRowIndex = (_a = this.runningStatus.packageDependencyIndex) !== null && _a !== void 0 ? _a : 0;
+            //Skip running status holds a larger index for the same phase
+            if ((phaseIndex === runningPhaseIndex) && index < runningStatusRowIndex)
+                continue;
+            this.logWarning(`Phase Index ${phaseIndex}, Row Index ${index}`);
+            this.logWarning(`RunningStatus Phase Index: ${runningPhaseIndex}, RunningStatus Row Index: ${runningStatusRowIndex}`);
+            if (phaseIndex > runningPhaseIndex) {
+                //Index of the current phase is larger, update the running status
+                this.runningStatus = { phaseKey: phase.key, packageDependencyIndex: 0 };
+                runningPhaseIndex = phaseIndex;
+                await this.setRunningStatus();
+                //Return to normal mode, if in continue
+                if (inContinueMode)
+                    this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
+            }
+            else if (phaseIndex === runningPhaseIndex && index >= runningStatusRowIndex) {
+                //Index of the row is larger for the same phase, update running status
+                this.runningStatus = { phaseKey: phase.key, packageDependencyIndex: index };
+                await this.setRunningStatus();
+                //Return to normal mode, if in continue
+                if (inContinueMode)
+                    this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
+            }
+            await Promise.all(row.map(unit => unit[phase.method]()));
+        }
+        return true;
+    }
+    prependPhase(phase, beforePhase) {
+        if (!beforePhase) {
+            this.phases.unshift(phase);
+            return;
+        }
+        const index = this.phases.indexOf(beforePhase);
+        //If the beforePhase isn't in this.phases or is the first item
+        if (index === -1 || index === 0)
+            return this.prependPhase(phase);
+        (0, ts_common_1.addItemToArrayAtIndex)(this.phases, phase, index - 1);
+    }
+    appendPhase(phase, afterPhase) {
+        if (!afterPhase) {
+            this.phases.push(phase);
+            return;
+        }
+        const index = this.phases.indexOf(afterPhase);
+        //If the afterPhase isn't in this.phases or is the last item
+        if (index === -1 || index === this.phases.length - 1)
+            return this.appendPhase(phase);
+        (0, ts_common_1.addItemToArrayAtIndex)(this.phases, phase, index + 1);
+    }
+    //######################### Running Status #########################
+    async setRunningStatus() {
+        this.logDebug('Setting Running Status', this.runningStatus);
+        if (!fs_1.default.existsSync(consts_1.Default_OutputFiles.output))
+            await fs_1.promises.mkdir(consts_1.Default_OutputFiles.output, { recursive: true });
+        await fs_1.promises.writeFile(consts_1.Default_OutputFiles.runningStatus, (0, ts_common_1.__stringify)(this.runningStatus, true));
+    }
+    async loadRunningStatus() {
+        const setDefaultRunningStatus = () => {
+            this.runningStatus = {
+                phaseKey: this.phases[0].key,
+                packageDependencyIndex: 0,
+            };
+            this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
+        };
+        if (!params_1.RuntimeParams.continue) {
+            setDefaultRunningStatus();
+            return;
+        }
+        //If the dir exists, try to read the file
+        if (fs_1.default.existsSync(consts_1.Default_OutputFiles.output)) {
+            try {
+                this.runningStatus = JSON.parse(await fs_1.promises.readFile(consts_1.Default_OutputFiles.runningStatus, { encoding: 'utf-8' }));
+                this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Continue];
+            }
+            catch (e) {
+                this.logError('Failed reading running status');
+                setDefaultRunningStatus();
+                return;
+            }
         }
+        else
+            setDefaultRunningStatus();
     }
     //######################### Public Functions #########################
     async execute() {
-        await this.init();
-        await this.initUnits();
-        await this.executeImpl();
+        return new MemStorage_1.MemStorage().init(async () => {
+            await this.init();
+            this.buildUnitDependencyTree();
+            await this.executeImpl();
+        });
     }
-    async executeImpl() {
-        for (const phase of this.phases) {
-            await this.executePhase(phase);
-        }
+    async killRunner() {
+        await Promise.all(this.units.map(unit => unit.kill()));
+        await this.setRunningStatus();
+    }
+    setScreen(screen) {
+        this.screen = screen;
+    }
+    //######################### Phase Implementation #########################
+    async printHelp() {
+        this.logInfo('Build and install parameters:');
+        const noGroupConst = 'No Group';
+        //Resolve all params by group
+        const paramsByGroup = (0, ts_common_1.reduceToMap)(params_1.AllBaiParams, param => { var _a; return (_a = param.group) !== null && _a !== void 0 ? _a : noGroupConst; }, (item, index, mapper) => {
+            var _a, _b, _c, _d;
+            mapper[(_a = item.group) !== null && _a !== void 0 ? _a : noGroupConst] = [...(_c = mapper[(_b = item.group) !== null && _b !== void 0 ? _b : noGroupConst]) !== null && _c !== void 0 ? _c : [], item];
+            return mapper[(_d = item.group) !== null && _d !== void 0 ? _d : noGroupConst];
+        });
+        (0, ts_common_1._keys)(paramsByGroup).map(paramGroup => {
+            this.logWarningBold(`${paramGroup}: \n`);
+            // commando.append(`echo "${paramGroup}:" \n`);
+            paramsByGroup[paramGroup].map(param => {
+                const paramKeys = param.keys.join(' | ');
+                const paramDescription = param.description.trim().split('\n').join('\n\t\t');
+                this.logInfo(`${paramKeys} \n\t\t ${paramDescription} \n`);
+                // commando.append(`echo "\n	${param.keys.join(' | ')} \n \t\t${param.description.trim().split('\n').join('\n\t\t')} \n"`);
+            });
+        });
+    }
+    async printEnv() {
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .append('npm -g list typescript eslint firebase-tools sort-package-json --depth=0')
+            .append('echo "npm version:"; npm -v')
+            .append('echo "node version:"; node -v')
+            .append('echo "base version:"; bash --version')
+            .execute();
+    }
+    async debug() {
+        // const configs = this.units.map(unit => unit.config);
+        // this.logInfo(JSON.stringify(configs, null, 2));
+        const dependencyTree = this.unitDependencyTree.map(row => row.map(unit => unit.config.label));
+        this.logInfo(dependencyTree);
     }
 }
 exports.PhaseRunner = PhaseRunner;

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

@@ -0,0 +1,25 @@
+import { FunctionKeys, ParamResolver } from '@nu-art/ts-common';
+import { Phase } from '../phase/types';
+import { BaseUnit } from '../unit/core';
+export interface PhaseRunnerEventListener {
+    __onPhaseChange: (data: Phase<string>) => void;
+    __onUnitStatusChange: (data: BaseUnit) => void;
+}
+declare class PhaseRunnerDispatcher<K extends FunctionKeys<PhaseRunnerEventListener>, P extends ParamResolver<PhaseRunnerEventListener, K> = ParamResolver<PhaseRunnerEventListener, K>> {
+    private readonly method;
+    constructor(method: K);
+    private listeners;
+    addListener(listener: any): void;
+    removeListener(listener: any): void;
+    dispatch(...data: P): void;
+}
+export declare const dispatcher_PhaseChange: PhaseRunnerDispatcher<"__onPhaseChange", [data: Phase<string>]>;
+export declare const dispatcher_UnitStatusChange: PhaseRunnerDispatcher<"__onUnitStatusChange", [data: BaseUnit<{}, {}, {
+    key: string;
+    label: string;
+    filter?: (() => boolean | Promise<boolean>) | undefined;
+}, {
+    dependencyName: string;
+    unitDependencyNames: string[];
+}>]>;
+export {};

package/v2/phase-runner/PhaseRunnerDispatcher.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatcher_UnitStatusChange = exports.dispatcher_PhaseChange = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+class PhaseRunnerDispatcher {
+    constructor(method) {
+        this.listeners = [];
+        this.method = method;
+    }
+    //######################### Listeners Logic #########################
+    addListener(listener) {
+        this.listeners.push(listener);
+    }
+    removeListener(listener) {
+        (0, ts_common_1.removeItemFromArray)(this.listeners, listener);
+    }
+    dispatch(...data) {
+        this.listeners.forEach(listener => {
+            var _a;
+            // @ts-ignore
+            (_a = listener[this.method]) === null || _a === void 0 ? void 0 : _a.call(listener, ...data);
+        });
+    }
+}
+exports.dispatcher_PhaseChange = new PhaseRunnerDispatcher('__onPhaseChange');
+exports.dispatcher_UnitStatusChange = new PhaseRunnerDispatcher('__onUnitStatusChange');

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

@@ -0,0 +1,12 @@
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { ProjectConfigV2 } from '../project/types';
+export declare const MemKey_ProjectConfig: MemKey<ProjectConfigV2>;
+export type RunnerParamKey = typeof RunnerParamKeys[number];
+export type RunnerParams = {
+    [K in RunnerParamKey]?: string;
+};
+export declare const MemKey_RunnerParams: MemKey<RunnerParams>;
+export declare const RunnerParamKey_RootPath: "rootPath";
+export declare const RunnerParamKey_ConfigPath: "configPath";
+declare const RunnerParamKeys: readonly ["rootPath", "configPath"];
+export {};

package/v2/phase-runner/RunnerParams.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerParamKey_ConfigPath = exports.RunnerParamKey_RootPath = exports.MemKey_RunnerParams = exports.MemKey_ProjectConfig = void 0;
+const MemStorage_1 = require("@nu-art/ts-common/mem-storage/MemStorage");
+exports.MemKey_ProjectConfig = new MemStorage_1.MemKey('project-config');
+exports.MemKey_RunnerParams = new MemStorage_1.MemKey('runner-params');
+exports.RunnerParamKey_RootPath = 'rootPath';
+exports.RunnerParamKey_ConfigPath = 'configPath';
+const RunnerParamKeys = [exports.RunnerParamKey_RootPath, exports.RunnerParamKey_ConfigPath];

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

@@ -0,0 +1,7 @@
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { PhaseRunner } from './PhaseRunner';
+export declare const CONST_ThunderstormVersionKey = "THUNDERSTORM_SDK_VERSION";
+export declare const CONST_ThunderstormDependencyKey = "THUNDERSTORM_DEPENDENCY_VERSION";
+export declare const CONST_ProjectVersionKey = "APP_VERSION";
+export declare const CONST_ProjectDependencyKey = "APP_VERSION_DEPENDENCY";
+export declare const MemKey_PhaseRunner: MemKey<PhaseRunner>;

package/v2/phase-runner/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemKey_PhaseRunner = exports.CONST_ProjectDependencyKey = exports.CONST_ProjectVersionKey = exports.CONST_ThunderstormDependencyKey = exports.CONST_ThunderstormVersionKey = void 0;
+const MemStorage_1 = require("@nu-art/ts-common/mem-storage/MemStorage");
+exports.CONST_ThunderstormVersionKey = 'THUNDERSTORM_SDK_VERSION';
+exports.CONST_ThunderstormDependencyKey = 'THUNDERSTORM_DEPENDENCY_VERSION';
+exports.CONST_ProjectVersionKey = 'APP_VERSION';
+exports.CONST_ProjectDependencyKey = 'APP_VERSION_DEPENDENCY';
+exports.MemKey_PhaseRunner = new MemStorage_1.MemKey('phase-runner');

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

@@ -1,16 +1,13 @@
 import { AsyncVoidFunction } from '@nu-art/ts-common';
-export type Phase<PhaseMethod extends string> = {
-    name: string;
-    method: PhaseMethod;
-    filter?: () => (Promise<boolean> | boolean);
-};
+import { Phase } from '../phase/types';
 export type PhaseImplementor<P extends Phase<string>[]> = {
     [K in P[number]['method']]: AsyncVoidFunction;
 };
 export type PhasesImplementor<Phases extends Phase<string>[]> = {
     [K in Phases[number]['method']]?: AsyncVoidFunction;
 };
-export type RunnerParamKeys = 'rootPath' | 'configPath';
-export type RunnerParams = {
-    [K in RunnerParamKeys]: string;
-};
+export declare const PhaseRunnerMode_Normal = "normal";
+export declare const PhaseRunnerMode_Continue = "continue";
+declare const PhaseRunnerModes: readonly ["normal", "continue"];
+export type PhaseRunnerMode = typeof PhaseRunnerModes[number];
+export {};

package/v2/phase-runner/types.js

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhaseRunnerMode_Continue = exports.PhaseRunnerMode_Normal = void 0;
+exports.PhaseRunnerMode_Normal = 'normal';
+exports.PhaseRunnerMode_Continue = 'continue';
+const PhaseRunnerModes = [exports.PhaseRunnerMode_Normal, exports.PhaseRunnerMode_Continue];

package/v2/project/types.d.ts

@@ -0,0 +1,8 @@
+import { StringMap } from '@nu-art/ts-common';
+import { ProjectConfig_DefaultFileRoutes } from '../../defaults/consts';
+export type ProjectConfigV2 = {
+    params: StringMap;
+    defaultFileRoutes?: ProjectConfig_DefaultFileRoutes;
+    projectVersion: string;
+    thunderstormVersion: string;
+};

package/v2/project/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/v2/screens/list-screen.d.ts

@@ -0,0 +1,47 @@
+import { ConsoleContainer } from '@nu-art/commando/console/ConsoleContainer';
+import { Widgets } from 'blessed';
+import { PhaseRunnerEventListener } from '../phase-runner/PhaseRunnerDispatcher';
+import { Phase } from '../phase';
+import { BaseUnit } from '../unit/core';
+import { AsyncVoidFunction } from '@nu-art/ts-common';
+type ScreenKeyBinding = {
+    keys: string[];
+    callback: VoidFunction;
+};
+type State = {
+    currentPhaseName?: string;
+    selectedUnit?: BaseUnit;
+};
+export declare class BAI_ListScreen extends ConsoleContainer<'screen', State> implements PhaseRunnerEventListener {
+    private units;
+    private logClient;
+    private onKillCB?;
+    private unitWrapperWidget;
+    private unitWidgets;
+    private logWidget;
+    private phaseWidget;
+    __onPhaseChange(phase: Phase<string>): void;
+    __onUnitStatusChange(unit: BaseUnit): void;
+    /**
+     * Creates an instance of ConsoleScreen.
+     *
+     * @param units - The units this screen should keep track of
+     * @param {Widgets.IScreenOptions} [props] - The properties to apply to the screen widget.
+     * @param {ScreenKeyBinding[]} [keyBinding] - An array of key bindings for the screen widget.
+     */
+    constructor(units: BaseUnit[], props?: Widgets.IScreenOptions, keyBinding?: ScreenKeyBinding[]);
+    private initLogger;
+    create(): this;
+    protected createContent(): void;
+    private createPhaseWidget;
+    private createUnitListWidget;
+    private createUnitItemWidget;
+    private createLogWidget;
+    protected render(): void;
+    private renderPhase;
+    private renderUnitList;
+    private renderLogs;
+    setKillCB(cb: AsyncVoidFunction): void;
+    private onUnitSelect;
+}
+export {};