@nu-art/build-and-install 0.204.91 → 0.204.93

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

@@ -6,11 +6,11 @@ const params_1 = require("../../../core/params/params");
 const ts_common_1 = require("@nu-art/ts-common");
 const fs_1 = require("fs");
 const consts_1 = require("../../../core/consts");
-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 tools_1 = require("@nu-art/commando/shell/tools");
 const runner_dispatchers_1 = require("../runner-dispatchers");
+const nvm_1 = require("@nu-art/commando/shell/plugins/nvm");
+const basic_1 = require("@nu-art/commando/shell/plugins/basic");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     constructor(config) {
@@ -18,6 +18,11 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         this.addToClassStack(Unit_FirebaseHostingApp);
         runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
     }
+    async init(setInitialized = true) {
+        await super.init(setInitialized);
+        if (!this.config.firebaseConfig.hostingPort)
+            throw new ts_common_1.BadImplementationException(`Unit ${this.config.label} missing hosting port in firebaseConfig`);
+    }
     //######################### Phase Implementations #########################
     async resolveConfigs() {
         await this.resolveHostingRC();
@@ -25,17 +30,15 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         await this.resolveHostingRuntimeConfig();
     }
     async compile() {
-        this.setStatus('Compile');
+        this.setStatus('Compiling', 'start');
         await this.resolveTSConfig();
         await this.clearOutputDir();
         await this.createAppVersionFile();
         await this.compileImpl();
-        this.setStatus('Compiled');
+        this.setStatus('Compiled', 'end');
     }
     async launch() {
         this.setStatus('Launching');
-        await this.initLaunch();
-        await this.clearPorts();
         await this.runApp();
     }
     async deployFrontend() {
@@ -93,11 +96,10 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     }
     //######################### Compile Logic #########################
     async compileImpl() {
-        await nvm_1.NVM
-            .createInteractiveCommando(basic_1.Cli_Basic)
+        const commando = this.allocateCommando(nvm_1.Commando_NVM, basic_1.Commando_Basic).applyNVM()
             .cd(this.runtime.pathTo.pkg)
-            .append(`ENV=${params_1.RuntimeParams.environment} npm run build`)
-            .execute();
+            .append(`ENV=${params_1.RuntimeParams.environment} npm run build`);
+        await this.executeAsyncCommando(commando);
     }
     async createAppVersionFile() {
         //Writing the file to the package source instead of the output is fine,
@@ -108,39 +110,22 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
     }
     //######################### Launch Logic #########################
-    async initLaunch() {
-        if (!this.config.firebaseConfig.hostingPort)
-            throw new ts_common_1.BadImplementationException(`Unit ${this.config.label} missing hosting port in firebaseConfig`);
-        this.launchCommando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
+    async runApp() {
+        const commando = this.allocateCommando(nvm_1.Commando_NVM).applyNVM()
             .setUID(this.config.key)
-            .cd(this.runtime.pathTo.pkg);
-    }
-    async clearPorts() {
-        await this.launchCommando
+            .cd(this.runtime.pathTo.pkg)
             .append(`array=($(lsof -ti:${[this.config.firebaseConfig.hostingPort].join(',')}))`)
             .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
             .append('echo ')
-            .execute();
-    }
-    async runApp() {
-        await this.launchCommando
-            .append('npm run start')
-            .executeAsync(pid => this.hostingPid = pid);
-    }
-    async kill() {
-        var _a;
-        if (!this.launchCommando)
-            return;
-        this.logWarning(`Killing unit - ${this.config.label}`);
-        await ((_a = this.launchCommando) === null || _a === void 0 ? void 0 : _a.gracefullyKill(this.hostingPid));
-        this.logWarning(`Unit killed - ${this.config.label}`);
+            .append('npm run start');
+        return this.executeAsyncCommando(commando);
     }
     //######################### Deploy Logic #########################
     async deployImpl() {
-        await nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
+        const commando = this.allocateCommando(nvm_1.Commando_NVM).applyNVM()
             .cd(this.runtime.pathTo.pkg)
-            .append(`firebase --debug deploy --only hosting`)
-            .execute();
+            .append(`firebase --debug deploy --only hosting`);
+        return this.executeAsyncCommando(commando);
     }
 }
 exports.Unit_FirebaseHostingApp = Unit_FirebaseHostingApp;

package/v2/unit/tools/tools.d.ts

@@ -0,0 +1,2 @@
+import { PackageJson } from '../../../core/types';
+export declare function convertPackageJSONTemplateToPackJSON_Value(template: PackageJson, value: (value: string, key?: string) => string): PackageJson;

package/v2/unit/tools/tools.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPackageJSONTemplateToPackJSON_Value = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+function convertPackageJSONTemplateToPackJSON_Value(template, value) {
+    let workspacePackageJsonAsString = (0, ts_common_1.__stringify)(template, true);
+    let match = null;
+    do {
+        match = workspacePackageJsonAsString.match(/"(.*?)": ?"\$([A-Z_]+?)"/);
+        if (match === null || match === void 0 ? void 0 : match[0])
+            workspacePackageJsonAsString = workspacePackageJsonAsString.replace(new RegExp(`\\$${match[2]}`), value(match[2], match[1]));
+    } while (match);
+    const packageJson = JSON.parse(workspacePackageJsonAsString);
+    return packageJson;
+}
+exports.convertPackageJSONTemplateToPackJSON_Value = convertPackageJSONTemplateToPackJSON_Value;

package/logic/ProjectManager.d.ts

@@ -1,49 +0,0 @@
-import { RuntimePackage, RuntimePackage_WithOutput } from '../core/types';
-import { Logger } from '@nu-art/ts-common';
-import { RunningStatus } from '../defaults/consts';
-export declare const PackageBuildPhaseType_Package: "package";
-export declare const PackageBuildPhaseType_PackageWithOutput: "package-with-output";
-export declare const PackageBuildPhaseType_Project: "project";
-type BuildPhase_Base = {
-    name: string;
-    terminatingPhase?: boolean;
-    breakAfterPhase?: boolean;
-    mandatoryPhases?: BuildPhase[];
-    isMandatory?: boolean;
-};
-type BuildPhase_Package = BuildPhase_Base & {
-    type: typeof PackageBuildPhaseType_Package;
-    action: (pkg: RuntimePackage) => Promise<any>;
-    filter?: (pkg: RuntimePackage) => Promise<boolean>;
-};
-type BuildPhase_PackageWithOutput = BuildPhase_Base & {
-    type: typeof PackageBuildPhaseType_PackageWithOutput;
-    action: (pkg: RuntimePackage_WithOutput) => Promise<any>;
-    filter?: (pkg: RuntimePackage_WithOutput) => Promise<boolean>;
-};
-type BuildPhase_Project = BuildPhase_Base & {
-    type: 'project';
-    action: () => Promise<any>;
-    filter?: () => Promise<boolean>;
-};
-export type BuildPhase = BuildPhase_Package | BuildPhase_PackageWithOutput | BuildPhase_Project;
-export declare class ProjectManager extends Logger {
-    private phases;
-    private dryRun;
-    private terminate;
-    private prevRunningStatus?;
-    private readonly projectScreen;
-    private logger?;
-    constructor();
-    clearLogger(): void;
-    showAllLogs(): void;
-    showPrettyLogs(): void;
-    private loadPackage;
-    registerPhase(phase: BuildPhase): void;
-    updateRunningStatus: (runningStatus?: RunningStatus) => Promise<void>;
-    prepare(phases?: BuildPhase[], index?: number): Promise<(() => Promise<void>) | undefined>;
-    private static isAborted;
-    execute(phases?: BuildPhase[], prevRunningStatus?: RunningStatus, signal?: AbortSignal): Promise<void>;
-    executePhase(phaseKey: string, prevRunningStatus?: RunningStatus, signal?: AbortSignal): Promise<void>;
-}
-export {};

package/logic/ProjectManager.js

@@ -1,271 +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.ProjectManager = exports.PackageBuildPhaseType_Project = exports.PackageBuildPhaseType_PackageWithOutput = exports.PackageBuildPhaseType_Package = void 0;
-const ts_common_1 = require("@nu-art/ts-common");
-const params_1 = require("../core/params/params");
-const tools_1 = require("@nu-art/commando/shell/tools");
-const map_project_packages_1 = require("./map-project-packages");
-const consts_1 = require("../core/consts");
-const fs = __importStar(require("fs"));
-const fs_1 = require("fs");
-const consts_2 = require("../defaults/consts");
-const MemStorage_1 = require("@nu-art/ts-common/mem-storage/MemStorage");
-const project_manager_1 = require("../project-manager");
-const ProjectScreen_1 = require("../screen/ProjectScreen");
-exports.PackageBuildPhaseType_Package = 'package';
-exports.PackageBuildPhaseType_PackageWithOutput = 'package-with-output';
-exports.PackageBuildPhaseType_Project = 'project';
-const mapToName = (item) => item.name;
-function resolveAllMandatoryPhases(phase) {
-    let result = [phase];
-    if (phase.mandatoryPhases) {
-        for (const childPhase of phase.mandatoryPhases) {
-            result = result.concat(resolveAllMandatoryPhases(childPhase));
-        }
-    }
-    return (0, ts_common_1.filterDuplicates)(result, result => result.name);
-}
-ts_common_1.DebugFlag.DefaultLogLevel = ts_common_1.LogLevel.Verbose;
-class ProjectManager extends ts_common_1.Logger {
-    constructor() {
-        super();
-        this.phases = [];
-        this.dryRun = params_1.RuntimeParams.dryRun;
-        this.terminate = false;
-        this.updateRunningStatus = async (runningStatus = consts_2.MemKey_RunningStatus.get(undefined)) => {
-            if (!runningStatus)
-                return;
-            if (!fs.existsSync(consts_2.Default_OutputFiles.output))
-                await fs_1.promises.mkdir(consts_2.Default_OutputFiles.output, { recursive: true });
-            await fs_1.promises.writeFile(consts_2.Default_OutputFiles.runningStatus, (0, ts_common_1.__stringify)(runningStatus, true));
-        };
-        this.projectScreen = new ProjectScreen_1.ProjectScreen([]);
-        params_1.RuntimeParams.allLogs ? this.showAllLogs() : this.showPrettyLogs();
-        this.setMinLevel(ts_common_1.LogLevel.Verbose);
-        this.logInfo('Runtime params:', params_1.RuntimeParams);
-    }
-    clearLogger() {
-        if (this.logger)
-            ts_common_1.BeLogged.removeConsole(this.logger);
-    }
-    showAllLogs() {
-        var _a;
-        this.clearLogger();
-        (_a = this.projectScreen) === null || _a === void 0 ? void 0 : _a.dispose();
-        ts_common_1.BeLogged.addClient(this.logger = ts_common_1.LogClient_Terminal);
-    }
-    showPrettyLogs() {
-        this.clearLogger();
-        this.projectScreen.create();
-        ts_common_1.BeLogged.addClient(this.logger = this.projectScreen.logClient);
-    }
-    loadPackage() {
-        const pathToConfig = (0, tools_1.convertToFullPath)('./.config/project-config.ts');
-        if (!fs.existsSync(pathToConfig))
-            throw new ts_common_1.ImplementationMissingException(`Missing ./.config/project-config.ts file, could not find in path: ${pathToConfig}`);
-        const projectConfig = require(pathToConfig).default;
-        const packages = (0, map_project_packages_1.mapProjectPackages)(projectConfig);
-        consts_1.MemKey_Packages.set(packages);
-    }
-    registerPhase(phase) {
-        this.phases.push(phase);
-    }
-    async prepare(phases = this.phases, index = 0) {
-        var _a;
-        const phasesToRun = [];
-        let i = index;
-        for (; i < phases.length; i++) {
-            const phase = phases[i];
-            const isNotSamePackageType = phasesToRun[0] && phase.type !== phasesToRun[0].type;
-            const isNextPhaseANoneValidProjectPackage = phase.type === 'project' && (phase.filter && !(await phase.filter()));
-            if (isNotSamePackageType) {
-                if (isNextPhaseANoneValidProjectPackage)
-                    continue;
-                else
-                    break;
-            }
-            if (phase.type !== 'project' || (!phase.filter || await ((_a = phase.filter) === null || _a === void 0 ? void 0 : _a.call(phase))))
-                phasesToRun.push(phase);
-            if ((phasesToRun.length > 0 && phase.terminatingPhase) || phase.breakAfterPhase) {
-                i++;
-                break;
-            }
-        }
-        if (!phasesToRun.length)
-            return;
-        const nextAction = await this.prepare(phases, i);
-        this.logDebug('Scheduling phases: ', phasesToRun.map(mapToName));
-        if (phasesToRun[0].type === 'project')
-            return async () => {
-                var _a;
-                if (this.terminate)
-                    return this.logInfo(`Skipping project phases:`, phasesToRun.map(mapToName));
-                let didRun = false;
-                for (const phase of phasesToRun) {
-                    if (ProjectManager.isAborted())
-                        return;
-                    // if there's a previous running status and the current phase is the one to continue from clean
-                    if (this.prevRunningStatus && this.prevRunningStatus.phaseKey === phase.name)
-                        delete this.prevRunningStatus;
-                    // keep the current running status updated
-                    if (!this.prevRunningStatus && !phase.terminatingPhase)
-                        consts_2.MemKey_RunningStatus.set({ phaseKey: phase.name });
-                    this.logInfo(`Running project phase: ${phase.name}`);
-                    // if prev running status still exists skip execution
-                    if (this.prevRunningStatus && !phase.isMandatory) {
-                        this.logVerbose('Skipping duo continue');
-                        continue;
-                    }
-                    //Update project screen
-                    (_a = this.projectScreen) === null || _a === void 0 ? void 0 : _a.updateRunningPhase(phase.name);
-                    if (this.dryRun) {
-                        await (0, ts_common_1.sleep)(200);
-                    }
-                    else
-                        await phase.action();
-                    didRun = true;
-                }
-                if (didRun && (0, ts_common_1.lastElement)(phasesToRun).terminatingPhase)
-                    this.terminate = true;
-                await (nextAction === null || nextAction === void 0 ? void 0 : nextAction());
-            };
-        return async () => {
-            let didRun = false;
-            let didPrintPhase = false;
-            const phasesRan = [];
-            const toRunPackages = consts_1.MemKey_Packages.get().packagesDependency.map((packages, i) => {
-                return async () => {
-                    var _a;
-                    // if there's a previous running status and the current phase is the one to continue from clean
-                    if (phasesToRun.find(phase => { var _a; return phase.name === ((_a = this.prevRunningStatus) === null || _a === void 0 ? void 0 : _a.phaseKey); }) && i === ((_a = this.prevRunningStatus) === null || _a === void 0 ? void 0 : _a.packageDependencyIndex))
-                        delete this.prevRunningStatus;
-                    let didPrintPackages = false;
-                    const values = (0, ts_common_1.flatArray)(packages.map(async (pkg) => {
-                        var _a;
-                        for (const phase of phasesToRun) {
-                            if (ProjectManager.isAborted())
-                                return;
-                            if (!(!phase.filter || await phase.filter(pkg)))
-                                continue;
-                            // keep the current running status updated
-                            if (!this.prevRunningStatus && !phase.terminatingPhase)
-                                consts_2.MemKey_RunningStatus.set({ phaseKey: phase.name, packageDependencyIndex: i });
-                            if (!didPrintPhase) {
-                                // will only be called once per phase
-                                phasesRan.push(phase);
-                                this.logInfo(`Running package phase: ${(0, ts_common_1.__stringify)(phasesToRun.map(mapToName))}`);
-                                didPrintPhase = true;
-                            }
-                            if (!didPrintPackages) {
-                                this.logDebug(` - on packages: ${(0, ts_common_1.__stringify)(packages.map(mapToName))}`);
-                                didPrintPackages = true;
-                            }
-                            didRun = true;
-                            this.logDebug(`   - ${pkg.name}:${phase.name}`);
-                            //Update project screen
-                            (_a = this.projectScreen) === null || _a === void 0 ? void 0 : _a.updateRunningPhase(phase.name);
-                            // if prev running status still exists skip execution
-                            if (this.prevRunningStatus && !phase.isMandatory) {
-                                this.logVerbose('Skipping duo continue');
-                                continue;
-                            }
-                            if (this.dryRun) {
-                                await (0, ts_common_1.sleep)(200);
-                            }
-                            else
-                                await phase.action(pkg);
-                        }
-                    }));
-                    await Promise.all(values);
-                };
-            });
-            if (this.terminate)
-                return this.logInfo(`Skipping packages phases:`, phasesToRun.map(mapToName));
-            for (const toRunPackage of toRunPackages) {
-                await toRunPackage();
-            }
-            if (didRun && (0, ts_common_1.lastElement)(phasesRan).terminatingPhase)
-                this.terminate = true;
-            await (nextAction === null || nextAction === void 0 ? void 0 : nextAction());
-        };
-    }
-    static isAborted() {
-        try {
-            return project_manager_1.MemKey_AbortSignal.get().aborted;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    async execute(phases = this.phases, prevRunningStatus, signal) {
-        return new MemStorage_1.MemStorage().init(async () => {
-            //Update the project manager mem key to be used elsewhere in the project
-            project_manager_1.MemKey_ProjectManager.set(this);
-            consts_2.MemKey_DefaultFiles.set(consts_2.Default_Files);
-            // Set default value to memKey
-            consts_2.MemKey_RunningStatus.set({ phaseKey: '' });
-            //Set project screen
-            ProjectScreen_1.MemKey_ProjectScreen.set(this.projectScreen);
-            const listener = async (status) => {
-                this.logDebug('SIGINT - running status:', status);
-                await this.updateRunningStatus();
-                process.exit(0);
-            };
-            process.on('SIGINT', listener);
-            try {
-                if (params_1.RuntimeParams.continue)
-                    this.prevRunningStatus = JSON.parse(await fs_1.promises.readFile(consts_2.Default_OutputFiles.runningStatus, { encoding: 'utf-8' }));
-            }
-            catch (e) {
-                this.logError('Failed reading running status', e);
-            }
-            this.loadPackage();
-            if (signal)
-                project_manager_1.MemKey_AbortSignal.set(signal);
-            // update prev running status if passed
-            if (prevRunningStatus) {
-                this.logWarning('Setting prev running status: ', prevRunningStatus);
-                this.prevRunningStatus = prevRunningStatus;
-            }
-            try {
-                await (await this.prepare(phases))();
-            }
-            catch (e) {
-                this.logError(e);
-            }
-            process.off('SIGINT', listener);
-            await this.updateRunningStatus();
-        });
-    }
-    async executePhase(phaseKey, prevRunningStatus, signal) {
-        const phase = this.phases.find(phase => phase.name === phaseKey);
-        if (!phase)
-            throw new ts_common_1.BadImplementationException(`No Such Phase: ${phaseKey}`);
-        const finalPhasesToRun = resolveAllMandatoryPhases(phase).reverse();
-        return this.execute(finalPhasesToRun, prevRunningStatus, signal);
-    }
-}
-exports.ProjectManager = ProjectManager;

package/logic/command-executors/CommandExecutor_FirebaseFunction.d.ts

@@ -1,21 +0,0 @@
-import { Package_FirebaseFunctionsApp } from '../../core/types';
-type OnReadyCallback = (pkg: Package_FirebaseFunctionsApp) => Promise<void>;
-export declare class CommandExecutor_FirebaseFunction {
-    static staggerCount: number;
-    private readonly PROXY_PID_LOG;
-    private readonly PROXY_KILL_LOG;
-    private readonly EMULATOR_PID_LOG;
-    private readonly EMULATOR_KILL_LOG;
-    private readonly pkg;
-    private readonly commandos;
-    private onReadyCallbacks;
-    constructor(pkg: Package_FirebaseFunctionsApp);
-    private initListeners;
-    private clearPorts;
-    private runProxy;
-    private runEmulator;
-    execute(): Promise<this>;
-    kill(): Promise<void>;
-    addOnReadyCallback(cb: OnReadyCallback): void;
-}
-export {};

package/logic/command-executors/CommandExecutor_FirebaseFunction.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandExecutor_FirebaseFunction = void 0;
-const nvm_1 = require("@nu-art/commando/cli/nvm");
-const basic_1 = require("@nu-art/commando/cli/basic");
-const ts_common_1 = require("@nu-art/ts-common");
-const params_1 = require("../../core/params/params");
-class CommandExecutor_FirebaseFunction {
-    constructor(pkg) {
-        this.PROXY_PID_LOG = '_PROXY_PID_';
-        this.PROXY_KILL_LOG = '_PROXY_KILLED_';
-        this.EMULATOR_PID_LOG = '_EMULATOR_PID_';
-        this.EMULATOR_KILL_LOG = '_EMULATOR_KILLED_';
-        this.onReadyCallbacks = [];
-        this.pkg = pkg;
-        this.commandos = {
-            emulator: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic),
-            proxy: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic),
-        };
-        this.initListeners();
-    }
-    //######################### Inner Logic #########################
-    initListeners() {
-    }
-    async clearPorts() {
-        const allPorts = Array.from({ length: 10 }, (_, i) => `${this.pkg.envConfig.basePort + i}`);
-        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
-            .setUID(this.pkg.name)
-            .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
-            .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
-            .append('echo ')
-            .execute();
-    }
-    async runProxy() {
-        await this.commandos.proxy
-            .setUID(this.pkg.name)
-            .cd(this.pkg.path)
-            .append('ts-node src/main/proxy.ts &')
-            .append('pid=$!')
-            .append(`echo "${this.PROXY_PID_LOG}=\${pid}"`)
-            .append(`wait \$pid`)
-            .append(`echo "${this.PROXY_KILL_LOG} \${pid}"`)
-            .execute();
-    }
-    async runEmulator() {
-        await this.commandos.emulator
-            .setUID(this.pkg.name)
-            .cd(this.pkg.path)
-            .append(`firebase emulators:start --export-on-exit --import=.trash/data ${params_1.RuntimeParams.debugBackend ? `--inspect-functions ${this.pkg.envConfig.debugPort}` : ''} &`)
-            .append('pid=$!')
-            .append(`echo "${this.EMULATOR_PID_LOG}=\${pid}"`)
-            .append(`wait \$pid`)
-            .append(`echo "${this.EMULATOR_KILL_LOG} \${pid}"`)
-            .execute();
-    }
-    //######################### Functions #########################
-    async execute() {
-        await (0, ts_common_1.sleep)(2 * ts_common_1.Second * CommandExecutor_FirebaseFunction.staggerCount++);
-        await this.clearPorts();
-        await this.runProxy();
-        await this.runEmulator();
-        return this;
-    }
-    async kill() {
-    }
-    addOnReadyCallback(cb) {
-        this.onReadyCallbacks.push(cb);
-    }
-}
-CommandExecutor_FirebaseFunction.staggerCount = 0;
-exports.CommandExecutor_FirebaseFunction = CommandExecutor_FirebaseFunction;

package/logic/command-executors/CommandExecutor_FirebaseHosting.d.ts

@@ -1,13 +0,0 @@
-import { Package_FirebaseHostingApp } from '../../core/types';
-export declare class CommandExecutor_FirebaseHosting {
-    private readonly APP_PID_LOG;
-    private readonly APP_KILL_LOG;
-    private readonly pkg;
-    private readonly commando;
-    constructor(pkg: Package_FirebaseHostingApp);
-    private initListeners;
-    private clearPorts;
-    private runApp;
-    execute(): Promise<this>;
-    kill(): Promise<void>;
-}

package/logic/command-executors/CommandExecutor_FirebaseHosting.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandExecutor_FirebaseHosting = void 0;
-const nvm_1 = require("@nu-art/commando/cli/nvm");
-const ts_common_1 = require("@nu-art/ts-common");
-const basic_1 = require("@nu-art/commando/cli/basic");
-class CommandExecutor_FirebaseHosting {
-    constructor(pkg) {
-        this.APP_PID_LOG = '_APP_PID_';
-        this.APP_KILL_LOG = '_APP_KILLED_';
-        if (!pkg.envConfig.hostingPort)
-            throw new ts_common_1.BadImplementationException(`Package ${pkg.name} missing hosting port in envConfig`);
-        this.pkg = pkg;
-        this.commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
-        this.initListeners();
-    }
-    //######################### Inner Logic #########################
-    initListeners() {
-    }
-    async clearPorts() {
-        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
-            .setUID(this.pkg.name)
-            .append(`array=($(lsof -ti:${[this.pkg.envConfig.hostingPort].join(',')}))`)
-            .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
-            .append('echo ')
-            .execute();
-    }
-    async runApp() {
-        await this.commando
-            .setUID(this.pkg.name)
-            .cd(this.pkg.path)
-            .append(`npm run start &`)
-            .append('pid=$!')
-            .append(`echo "${this.APP_PID_LOG}=\${pid}"`)
-            .append(`wait \$pid`)
-            .append(`echo "${this.APP_KILL_LOG} \${pid}"`)
-            .execute();
-    }
-    //######################### Functions #########################
-    async execute() {
-        await this.clearPorts();
-        await this.runApp();
-        return this;
-    }
-    async kill() {
-    }
-}
-exports.CommandExecutor_FirebaseHosting = CommandExecutor_FirebaseHosting;

package/logic/command-executors/CommandExecutor_Python.d.ts

@@ -1,15 +0,0 @@
-import { Package_Python } from '../../core/types';
-export declare class CommandExecutor_Python {
-    private readonly APP_PID_LOG;
-    private readonly APP_KILL_LOG;
-    private readonly pkg;
-    private readonly commando;
-    constructor(pkg: Package_Python);
-    private initListeners;
-    private enterVenv;
-    private setPythonPath;
-    private runApp;
-    private clearPorts;
-    execute(): Promise<void>;
-    kill(): Promise<void>;
-}