@nu-art/build-and-install 0.300.8 → 0.400.1

package/v2/phase-runner/PhaseRunner.js

@@ -1,472 +0,0 @@
-"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 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 thunderstorm_1 = require("../unit/thunderstorm");
-const consts_1 = require("../../defaults/consts");
-const PhaseRunnerDispatcher_1 = require("./PhaseRunnerDispatcher");
-const tools_1 = require("@nu-art/commando/shell/tools");
-const types_1 = require("./types");
-const BAIScreenManager_1 = require("../screens/BAIScreenManager");
-const consts_2 = require("./consts");
-const basic_1 = require("@nu-art/commando/shell/plugins/basic");
-const CONST_ThunderstormVersionKey = 'THUNDERSTORM_SDK_VERSION';
-const CONST_ThunderstormDependencyKey = 'THUNDERSTORM_DEPENDENCY_VERSION';
-const CONST_ProjectVersionKey = 'APP_VERSION';
-const CONST_ProjectDependencyKey = 'APP_VERSION_DEPENDENCY';
-class PhaseRunner extends core_1.BaseUnit {
-    constructor(projectPath) {
-        super({ label: 'Phase Runner', key: 'phase-runner' });
-        /**
-         * kill counter that will intercept the kill event and if the threshold will be met the main process will be killed as well
-         * @private
-         */
-        this.killCounter = 0;
-        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.willUnitRunForPhase = async (phase, unit) => {
-            var _a, _b;
-            // Unit doesn't implement the phase method
-            if (!(0, ts_common_1.exists)(unit[phase.method]))
-                return false;
-            // If phase implements unit filter whether unit doesn't pass
-            if ((0, ts_common_1.exists)(phase.unitFilter))
-                return (await phase.unitFilter(unit));
-            // Runtime input is stronger than the unit default filter
-            if (params_1.RuntimeParams.usePackage)
-                return (((_a = params_1.RuntimeParams.usePackage) === null || _a === void 0 ? void 0 : _a.includes(unit.config.key)) || ((_b = params_1.RuntimeParams.usePackage) === null || _b === void 0 ? void 0 : _b.includes(unit.config.label)));
-            // Unit filter itself
-            if ((0, ts_common_1.exists)(unit.config.filter) && !await unit.config.filter())
-                return false;
-            return true;
-        };
-        this.getPhases = () => [...this.phases];
-        if ((0, ts_common_1.exists)(PhaseRunner.instance))
-            throw new ts_common_1.MUSTNeverHappenException('phase runner instance must be unique');
-        Error.stackTraceLimit = 50;
-        this.addToClassStack(PhaseRunner);
-        this.screenManager = new BAIScreenManager_1.BAIScreenManager();
-        this.phases = [];
-        this.units = [this];
-        this.projectPath = (0, tools_1.convertToFullPath)(projectPath);
-        this.phaseFilter = this.phaseFilters[types_1.PhaseRunnerMode_Normal];
-        this.setMinLevel(ts_common_1.LogLevel.Info);
-        console.log('RuntimeParams.debug', params_1.RuntimeParams.debug);
-        if (params_1.RuntimeParams.debug)
-            this.setMinLevel(ts_common_1.LogLevel.Debug);
-        if (params_1.RuntimeParams.verbose)
-            this.setMinLevel(ts_common_1.LogLevel.Debug);
-    }
-    //######################### Initialization #########################
-    async init() {
-        var _a;
-        consts_2.MemKey_PhaseRunner.set(this);
-        BAIScreenManager_1.MemKey_BAIScreenManager.set(this.screenManager);
-        const runnerParams = {
-            rootPath: process.cwd(),
-            configPath: process.cwd() + '/.config',
-        };
-        RunnerParams_1.MemKey_RunnerParams.set(runnerParams);
-        if (this.projectConfig) {
-            const projectParams = this.prepareProjectParams();
-            RunnerParams_1.MemKey_ProjectConfig.set(Object.assign(Object.assign({}, this.projectConfig), { params: projectParams }));
-        }
-        if (this.defaultFileRoutes)
-            consts_1.MemKey_DefaultFiles.set(this.defaultFileRoutes);
-        if (PhaseRunner.instance) {
-            return;
-        }
-        PhaseRunner.instance = this;
-        //Load project for use in the phase runner
-        (_a = this.projectConfig) !== null && _a !== void 0 ? _a : (this.projectConfig = await this.loadProject());
-        //Filter specific units
-        // this.filterUnits();
-        this.logDebug('Runtime params:', params_1.RuntimeParams);
-        //Set runner params
-        //Set Project Params
-        const projectParams = this.prepareProjectParams();
-        RunnerParams_1.MemKey_ProjectConfig.set(Object.assign(Object.assign({}, this.projectConfig), { params: projectParams }));
-        //Set Default File Routes
-        this.defaultFileRoutes = this.prepareDefaultFileRouts();
-        consts_1.MemKey_DefaultFiles.set(this.defaultFileRoutes);
-        //Load running status
-        await this.loadRunningStatus();
-        //Print init results
-        this.setStatus('Initialized');
-        const units = this.units.filter(unit => unit !== this);
-        await Promise.all(units.map(unit => {
-            // @ts-ignore
-            return unit.init();
-        }));
-    }
-    // private filterUnits() {
-    // 	const useUnits = RuntimeParams.usePackage;
-    // 	if (!useUnits || !useUnits.length)
-    // 		return;
-    //
-    // 	const unitsToRemove: BaseUnit[] = [];
-    // 	for (const unit of this.units) {
-    // 		if (unit === this)
-    // 			continue;
-    //
-    // 		if (!useUnits.includes(unit.config.key))
-    // 			unitsToRemove.push(unit);
-    // 	}
-    //
-    // 	if (!unitsToRemove.length)
-    // 		return;
-    //
-    // 	unitsToRemove.forEach(unit => removeItemFromArray(this.units, unit));
-    // }
-    async loadProject() {
-        if (!fs_1.default.existsSync(this.projectPath))
-            throw new ts_common_1.ImplementationMissingException(`Missing project config file, could not find in path: ${this.projectPath}`);
-        const projectConfigCB = require(this.projectPath).default;
-        if (typeof projectConfigCB !== 'function')
-            throw new ts_common_1.BadImplementationException('Config file must be an asynchronous function returning a ProjectConfigV2 object');
-        return projectConfigCB();
-    }
-    prepareProjectParams() {
-        var _a;
-        const params = (_a = this.projectConfig.params) !== null && _a !== void 0 ? _a : {};
-        params[CONST_ThunderstormVersionKey] = this.projectConfig.thunderstormVersion;
-        params[CONST_ThunderstormDependencyKey] = this.projectConfig.thunderstormVersion;
-        params[CONST_ProjectVersionKey] = this.projectConfig.projectVersion;
-        params[CONST_ProjectDependencyKey] = this.projectConfig.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);
-    }
-    async buildUnitDependencyTree() {
-        const units = [...this.units];
-        // Filter out units by their filter
-        for (const unit of units) {
-            if ((0, ts_common_1.exists)(unit.config.filter) && !(await unit.config.filter())) {
-                (0, ts_common_1.removeItemFromArray)(units, unit);
-                // @ts-ignore
-                unit.setStatus('Will not run');
-                unit.logInfo('unit will not run, did not pass unit filter');
-            }
-        }
-        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;
-    }
-    async executeImpl() {
-        var _a;
-        const phasesBlocks = [];
-        let phasesBlock = [];
-        let lastPhase;
-        const reversedPhases = [...this.phases].reverse();
-        for (const phase of this.phases) {
-            if (lastPhase === null || lastPhase === void 0 ? void 0 : lastPhase.terminateAfterPhase)
-                continue;
-            try {
-                let willExecutePhase = await this.phaseFilter(phase);
-                for (const _phase of reversedPhases) {
-                    if (await this.phaseFilter(_phase) && ((_a = _phase.dependencyPhaseKeys) === null || _a === void 0 ? void 0 : _a.includes(phase.key))) {
-                        willExecutePhase = true;
-                    }
-                }
-                if (!willExecutePhase) {
-                    this.logDebug(`Will not execute phase: ${phase.name}, did not pass filter`);
-                    lastPhase = undefined;
-                    continue;
-                }
-                lastPhase = phase;
-                this.logVerbose(`Will execute phase: ${phase.name}`);
-                if (phase.breakPhases) {
-                    phasesBlocks.push(phasesBlock);
-                    phasesBlocks.push([phase]);
-                    phasesBlock = [];
-                    continue;
-                }
-                phasesBlock.push(phase);
-                // await this.executePhase(phase);
-            }
-            catch (e) {
-                this.logError(`Error running phase: ${phase.name}`, e);
-            }
-        }
-        if (phasesBlock.length)
-            phasesBlocks.push(phasesBlock);
-        if (params_1.RuntimeParams.debug)
-            this.logDebug('phasesBlock: ', phasesBlock);
-        const executionQueue = phasesBlocks.map((_phasesBlock, index) => {
-            this.logDebug(`Executing phases #${index}: ${_phasesBlock.map(p => p.name).join(', ')}`);
-            return async () => {
-                return (0, ts_common_1.Promise_all_sequentially)(this.unitDependencyTree.map(unitGroup => () => {
-                    return Promise.all(unitGroup.map(unit => (0, ts_common_1.Promise_all_sequentially)(_phasesBlock.map(phase => () => this.executePhase(phase, unit, index)))));
-                }));
-            };
-        });
-        await (0, ts_common_1.Promise_all_sequentially)(executionQueue);
-        this.killed = false;
-    }
-    async executePhase(phase, unit, index) {
-        if (!params_1.RuntimeParams.dryRun)
-            return this.executePhaseImpl(phase, unit, index);
-        return this.executePhaseDryRun(phase, unit, index);
-    }
-    async executePhaseImpl(phase, unit, index) {
-        var _a, _b;
-        if (!await this.willUnitRunForPhase(phase, unit))
-            return;
-        unit.logDebug(`Running phase #${index}: ${phase.name}`);
-        return (_b = (_a = unit)[phase.method]) === null || _b === void 0 ? void 0 : _b.call(_a);
-    }
-    async executePhaseDryRun(phase, unit, index) {
-        if (!(await this.willUnitRunForPhase(phase, unit)))
-            unit.logWarning(`will NOT run phase #${index}: ${phase.name}`);
-        else
-            unit.logWarning(`Running phase #${index}: ${phase.name}`);
-    }
-    //######################### Unit Logic #########################
-    registerUnits(units) {
-        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;
-        });
-        PhaseRunnerDispatcher_1.dispatcher_UnitChange.dispatch(this.units);
-    }
-    getUnits() {
-        return this.units;
-    }
-    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.logVerbose('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() {
-        return new MemStorage_1.MemStorage().init(async () => {
-            process.on('SIGINT', () => {
-                this.killRunner();
-            });
-            try {
-                try {
-                    await this.init();
-                }
-                catch (e) {
-                    this.logError('Error initializing Runner', e);
-                    throw e;
-                }
-                try {
-                    await this.buildUnitDependencyTree();
-                }
-                catch (e) {
-                    this.logError('Error building execution Tree', e);
-                    throw e;
-                }
-                await this.executeImpl();
-                this.killed = true;
-                this.logInfo('Completed successfully');
-                ts_common_1.StaticLogger.logInfo('-----------', '---------------------------------- Process Completed successfully ----------------------------------');
-                if (params_1.RuntimeParams.closeOnExit)
-                    process.exit(0);
-            }
-            catch (e) {
-                if (params_1.RuntimeParams.closeOnExit)
-                    process.exit(1);
-            }
-        });
-    }
-    async killRunner() {
-        this.killCounter++;
-        if (this.killCounter === PhaseRunner.KILL_THRESHOLD)
-            process.exit(1);
-        if (this.killed)
-            process.exit(1);
-        await this.setRunningStatus();
-        this.logDebug('Killing units');
-        await Promise.all(this.units.map(async (unit) => {
-            try {
-                await unit.kill();
-            }
-            catch (e) {
-                unit.logError(`Error killing unit`, e);
-            }
-        }));
-        this.logDebug('Units killed');
-        this.killed = true;
-        if (params_1.RuntimeParams.closeOnExit)
-            process.exit(1);
-    }
-    //######################### 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 this.allocateCommando(basic_1.Commando_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 printDebug() {
-        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());
-        this.logDebug('All Phases:', this.phases.map(phase => phase.name));
-        this.logDebug('Filtered Units:', this.units.map(unit => unit.config.label));
-        const dependencyTree = this.unitDependencyTree.map(row => row.map(unit => unit.config.label));
-        this.logInfo('Unit Dependencies Tree:', dependencyTree);
-        if (params_1.RuntimeParams.debugLifecycle)
-            process.exit(0);
-    }
-}
-exports.PhaseRunner = PhaseRunner;
-PhaseRunner.KILL_THRESHOLD = 5;

package/v2/phase-runner/PhaseRunnerDispatcher.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        this.listeners = [];
-        this.method = method;
-    }
-    //######################### Listeners Logic #########################
-    addListener(listener) {
-        if (this.listeners.includes(listener))
-            return;
-        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);
-        });
-    }
-    async dispatchAsync(...data) {
-        await Promise.all(this.listeners.map(async (listener) => {
-            var _a;
-            // @ts-ignore
-            return (_a = listener[this.method]) === null || _a === void 0 ? void 0 : _a.call(listener, ...data);
-        }));
-    }
-}
-exports.PhaseRunnerDispatcher = PhaseRunnerDispatcher;
-exports.dispatcher_PhaseChange = new PhaseRunnerDispatcher('__onPhaseChange');
-exports.dispatcher_UnitStatusChange = new PhaseRunnerDispatcher('__onUnitStatusChange');
-exports.dispatcher_UnitChange = new PhaseRunnerDispatcher('__onUnitsChange');

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

@@ -1,12 +0,0 @@
-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

@@ -1,9 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,9 +0,0 @@
-"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/kaki.js

@@ -1 +0,0 @@
-"use strict";

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

@@ -1,13 +0,0 @@
-import { AsyncVoidFunction } from '@nu-art/ts-common';
-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 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,6 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

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

package/v2/screens/BAIScreen.d.ts

@@ -1,22 +0,0 @@
-import { AsyncVoidFunction } from '@nu-art/ts-common';
-import { ConsoleScreen } from '@nu-art/commando/console/ConsoleScreen';
-export declare abstract class BAIScreen<State extends {} = {}> extends ConsoleScreen<State> {
-    private onKillCallback?;
-    private logClient;
-    /**
-     * Creates an instance of ConsoleScreen.
-     *
-     * @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(logClientKey: string);
-    private createLogClient;
-    protected abstract scrollLog(direction: number): void;
-    protected abstract onLogUpdated: () => void;
-    protected getLogs: () => string;
-    startScreen: () => void;
-    stopScreen: () => void;
-    protected abstract destroyContent(): void;
-    protected onKill(): Promise<void>;
-    setOnKillCallback: (cb: AsyncVoidFunction) => AsyncVoidFunction;
-}