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

package/v2/unit/core/Unit_TypescriptLib.js

@@ -27,13 +27,34 @@ exports.Unit_TypescriptLib = void 0;
 const nvm_1 = require("@nu-art/commando/cli/nvm");
 const Unit_Typescript_1 = require("./Unit_Typescript");
 const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
 const basic_1 = require("@nu-art/commando/cli/basic");
 const ts_common_1 = require("@nu-art/ts-common");
-const fs_1 = require("fs");
+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 extensionsToLint = ['.ts', '.tsx'];
+const assetExtensions = [
+    'json',
+    'scss',
+    'svg',
+    'png',
+    'jpg',
+    'jpeg',
+    'rules',
+    '_ts'
+];
 class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
+    async init(setInitialized = true) {
+        await super.init(false);
+        this.runtime.pathTo.output = this.runtime.pathTo.pkg + `/${this.config.output}`;
+        if (setInitialized)
+            this.setStatus('Initialized');
+    }
     //######################### Internal Logic #########################
     async resolveTSConfig() {
-        const pathToUnitTSConfig = `${this.config.pathToPackage}/src/main/tsconfig.json`;
+        const pathToUnitTSConfig = `${this.runtime.pathTo.pkg}/src/main/tsconfig.json`;
         // const pathToProjectTSConfig = '';
         //If set to use a custom ts config
         if (this.config.customTSConfig) {
@@ -43,7 +64,7 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
             return;
         }
         //Copy project ts config file into the unit main folder
-        const pathToProjectConfig = this.getRunnerParam('configPath');
+        const pathToProjectConfig = this.getRunnerParam(RunnerParams_1.RunnerParamKey_ConfigPath);
         if (!pathToProjectConfig)
             throw new ts_common_1.BadImplementationException('Could not get config path from runner params');
         //Make sure a project ts config file exists
@@ -53,17 +74,90 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
         //Copy the file into the unit
         await fs_1.promises.copyFile(pathToProjectTSConfig, pathToUnitTSConfig);
     }
+    async clearOutputDir() {
+        if (!params_1.RuntimeParams.clean)
+            return;
+        //Return if output dir doesn't exist
+        if (!fs.existsSync(this.runtime.pathTo.output))
+            return;
+        await fs_1.promises.rm(this.runtime.pathTo.output, { recursive: true, force: true });
+        await fs_1.promises.mkdir(this.runtime.pathTo.output, { recursive: true });
+    }
+    async compileImpl() {
+        const pathToCompile = `${this.runtime.pathTo.pkg}/src/main`;
+        const pathToTSConfig = `${pathToCompile}/tsconfig.json`;
+        await nvm_1.NVM
+            .createCommando(basic_1.Cli_Basic)
+            .setUID(this.config.key)
+            .cd(this.runtime.pathTo.pkg)
+            .append(`tsc -p "${pathToTSConfig}" --rootDir "${pathToCompile}" --outDir "${this.runtime.pathTo.output}"`)
+            .execute();
+    }
+    async copyAssetsToOutput() {
+        const command = `find . \\( -name ${assetExtensions.map(suffix => `'*.${suffix}'`).join(' -o -name ')} \\) | cpio -pdm "${this.runtime.pathTo.output}" > /dev/null`;
+        await cli_1.Commando
+            .create(basic_1.Cli_Basic)
+            .cd(`${this.runtime.pathTo.pkg}/src/main`)
+            .setStdErrorValidator(stderr => {
+            return !stderr.match(/\d+\sblock/);
+        })
+            .append(command)
+            .execute();
+    }
+    async copyPackageJSONToOutput() {
+        const targetPath = `${this.runtime.pathTo.output}/${consts_1.CONST_PackageJSON}`;
+        const fileContent = JSON.stringify(this.packageJson.dist, null, 2);
+        await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+    }
     //######################### Phase Implementations #########################
     async preCompile() {
         if (!fs.existsSync(`${this.config.pathToPackage}/prebuild.sh`))
             return;
+        this.setStatus('Pre-Compile');
         await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
-            .cd(this.config.pathToPackage)
+            .cd(this.runtime.pathTo.pkg)
             .append('bash prebuild.sh')
             .execute();
     }
     async compile() {
+        this.setStatus('Compile');
         await this.resolveTSConfig();
+        await this.clearOutputDir();
+        await this.compileImpl();
+        await this.copyAssetsToOutput();
+        await this.copyPackageJSONToOutput();
+        this.setStatus('Compiled');
+    }
+    async purge() {
+        await fs_1.promises.rm(this.runtime.pathTo.output, { recursive: true, force: true });
+    }
+    async printDependencyTree() {
+        const CONST_RunningRoot = process.cwd();
+        this.logDebug(`Generating Dependency Tree - ${this.config.label}`);
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(this.runtime.pathTo.pkg)
+            .append(`mkdir -p ${CONST_RunningRoot}/.trash/dependencies`)
+            .append(`pnpm list --depth 1000 > "${CONST_RunningRoot}/.trash/dependencies/${this.config.key}.txt"`)
+            .execute();
+    }
+    async checkCyclicImports() {
+        this.logDebug(`Checking Cyclic Imports - ${this.config.label}`);
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(this.runtime.pathTo.pkg)
+            .setStdErrorValidator(stderr => {
+            return !stderr.includes('Finding files') && !stderr.includes('Image created');
+        })
+            .append(`npx madge --no-spinner --image "./imports-${this.config.key}.svg" --circular ${this.runtime.pathTo.output}`)
+            .append('echo $?')
+            .execute();
+    }
+    async lint() {
+        const pathToProjectESLint = RunnerParams_1.MemKey_RunnerParams.get()[RunnerParams_1.RunnerParamKey_ConfigPath] + '/.eslintrc.js';
+        const pathToLint = this.runtime.pathTo.pkg + 'src/main';
+        const extensions = extensionsToLint.map(ext => `--ext ${ext}`).join(' ');
+        await nvm_1.NVM.createCommando()
+            .append(`eslint --config ${pathToProjectESLint} ${extensions} ${pathToLint}`)
+            .execute();
     }
 }
 exports.Unit_TypescriptLib = Unit_TypescriptLib;

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

@@ -1,5 +1,14 @@
+import { UnitPhaseImplementor } from '../types';
 import { Unit_Typescript } from './Unit_Typescript';
-import { Phase_Install, UnitPhaseImplementor } from './types';
-export declare class Unit_TypescriptProject extends Unit_Typescript implements UnitPhaseImplementor<[Phase_Install]> {
+import { Phase_Install } from '../../phase';
+import { StringMap } from '@nu-art/ts-common/utils/types';
+type _Config<Config> = {
+    globalPackages?: StringMap;
+} & Config;
+type _RuntimeConfig<RTC> = {} & RTC;
+export declare class Unit_TypescriptProject<Config extends {} = {}, RuntimeConfig extends {} = {}, C extends _Config<Config> = _Config<Config>, RTC extends _RuntimeConfig<RuntimeConfig> = _RuntimeConfig<RuntimeConfig>> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
+    private installGlobals;
+    private installPackages;
     install(): Promise<void>;
 }
+export {};

package/v2/unit/core/Unit_TypescriptProject.js

@@ -2,8 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unit_TypescriptProject = void 0;
 const Unit_Typescript_1 = require("./Unit_Typescript");
+const params_1 = require("../../../core/params/params");
+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");
 class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
+    //######################### Internal Logic #########################
+    async installGlobals() {
+        if ((!params_1.RuntimeParams.install && !params_1.RuntimeParams.installGlobals) || !this.config.globalPackages)
+            return;
+        const packages = (0, ts_common_1._keys)(this.config.globalPackages)
+            .reduce((acc, pkg) => {
+            acc.push(`${pkg}@${this.config.globalPackages[pkg]}`);
+            return acc;
+        }, []);
+        this.logInfo(`Installing Global Packages: ${packages.join(' ')}`);
+        await nvm_1.NVM.createCommando().append(`npm i -g ${packages.join(' ')}`).execute();
+    }
+    async installPackages() {
+        if (!params_1.RuntimeParams.install && !params_1.RuntimeParams.installPackages)
+            return;
+        const runner = consts_1.MemKey_PhaseRunner.get();
+        const units = runner.getUnits().filter(unit => unit instanceof Unit_Typescript_1.Unit_Typescript);
+        const packages = units.map(unit => unit.config.pathToPackage);
+        await pnpm_1.PNPM.createWorkspace(packages);
+        await pnpm_1.PNPM.installPackages(nvm_1.NVM.createCommando());
+    }
+    //######################### Phase Implementation #########################
     async install() {
+        await this.installGlobals();
+        await this.installPackages();
     }
 }
 exports.Unit_TypescriptProject = Unit_TypescriptProject;

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

@@ -1,4 +1,5 @@
-export * from './types';
 export * from './BaseUnit';
 export * from './Unit_Python';
 export * from './Unit_Typescript';
+export * from './Unit_TypescriptLib';
+export * from './Unit_TypescriptProject';

package/v2/unit/core/index.js

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
 __exportStar(require("./BaseUnit"), exports);
 __exportStar(require("./Unit_Python"), exports);
 __exportStar(require("./Unit_Typescript"), exports);
+__exportStar(require("./Unit_TypescriptLib"), exports);
+__exportStar(require("./Unit_TypescriptProject"), exports);

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

@@ -0,0 +1,40 @@
+import { Unit_TypescriptLib } from '../core';
+import { UnitPhaseImplementor } from '../types';
+import { Phase_DeployBackend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
+import { FirebasePackageConfig } from '../../../core/types';
+type _Config<Config> = {
+    firebaseConfig: FirebasePackageConfig;
+    sources?: string[];
+} & Config;
+export declare class Unit_FirebaseFunctionsApp<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]> {
+    static staggerCount: number;
+    private readonly PROXY_PID_LOG;
+    private readonly PROXY_KILL_LOG;
+    private readonly EMULATOR_PID_LOG;
+    private readonly EMULATOR_KILL_LOG;
+    private launchCommandos;
+    private listeners;
+    resolveConfigs(): Promise<void>;
+    compile(): Promise<void>;
+    launch(): Promise<void>;
+    deployBackend(): Promise<void>;
+    private getEnvConfig;
+    private resolveFunctionsRC;
+    private resolveProxyFile;
+    private resolveConfigDir;
+    private resolveFunctionsJSON;
+    private resolveFunctionsRuntimeConfig;
+    private createAppVersionFile;
+    private createDependenciesDir;
+    private initLaunch;
+    private initLaunchListeners;
+    private clearPorts;
+    private runProxy;
+    private runEmulator;
+    private onLaunched;
+    private getPID;
+    kill(): Promise<void>;
+    private printFiles;
+    private deployImpl;
+}
+export {};

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

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit_FirebaseFunctionsApp = void 0;
+const core_1 = require("../core");
+const consts_1 = require("../../../core/consts");
+const fs_1 = require("fs");
+const params_1 = require("../../../core/params/params");
+const ts_common_1 = require("@nu-art/ts-common");
+const consts_2 = require("../../../defaults/consts");
+const RunnerParams_1 = require("../../phase-runner/RunnerParams");
+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 CONST_VersionApp = 'version-app.json';
+class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
+    constructor() {
+        super(...arguments);
+        this.PROXY_PID_LOG = '_PROXY_PID_';
+        this.PROXY_KILL_LOG = '_PROXY_KILLED_';
+        this.EMULATOR_PID_LOG = '_EMULATOR_PID_';
+        this.EMULATOR_KILL_LOG = '_EMULATOR_KILLED_';
+    }
+    //######################### Phase Implementations #########################
+    async resolveConfigs() {
+        await this.resolveFunctionsRC();
+        await this.resolveProxyFile();
+        await this.resolveConfigDir();
+        await this.resolveFunctionsRuntimeConfig();
+        await this.resolveFunctionsJSON();
+    }
+    async compile() {
+        this.setStatus('Compile');
+        await this.resolveTSConfig();
+        await this.clearOutputDir();
+        await this.createAppVersionFile();
+        await this.compileImpl();
+        await this.copyAssetsToOutput();
+        await this.createDependenciesDir();
+        await this.copyPackageJSONToOutput();
+        this.setStatus('Compiled');
+    }
+    async launch() {
+        this.setStatus('Launching');
+        await (0, ts_common_1.sleep)(2 * ts_common_1.Second * Unit_FirebaseFunctionsApp.staggerCount++);
+        await this.initLaunch();
+        await this.initLaunchListeners();
+        await this.clearPorts();
+        await this.runProxy();
+        await this.runEmulator();
+    }
+    async deployBackend() {
+        await this.printFiles();
+        await this.deployImpl();
+    }
+    //######################### ResolveConfig Logic #########################
+    getEnvConfig() {
+        const env = params_1.RuntimeParams.environment;
+        const envConfig = this.config.firebaseConfig.envs.find(_env => _env.env === env);
+        if (!envConfig)
+            throw new ts_common_1.ImplementationMissingException(`Missing EnvConfig for env ${env} in unit ${this.config.label}`);
+        return envConfig;
+    }
+    async resolveFunctionsRC() {
+        const envConfig = this.getEnvConfig();
+        const rcConfig = { projects: { default: envConfig.projectId } };
+        const targetPath = `${this.runtime.pathTo.pkg}/${consts_1.CONST_FirebaseRC}`;
+        await fs_1.promises.writeFile(targetPath, JSON.stringify(rcConfig, null, 2), { encoding: 'utf-8' });
+    }
+    async resolveProxyFile() {
+        var _a, _b, _c;
+        const envConfig = this.getEnvConfig();
+        const defaultFiles = consts_2.MemKey_DefaultFiles.get();
+        const targetPath = `${this.runtime.pathTo.pkg}/src/main/proxy.ts`;
+        const path = (_a = defaultFiles === null || defaultFiles === void 0 ? void 0 : defaultFiles.backend) === null || _a === void 0 ? void 0 : _a.proxy;
+        if (!path)
+            return;
+        let fileContent = await fs_1.promises.readFile(path, { encoding: 'utf-8' });
+        fileContent = fileContent.replace(/PROJECT_ID/g, `${envConfig.projectId}`);
+        fileContent = fileContent.replace(/PROXY_PORT/g, `${this.config.firebaseConfig.basePort}`);
+        fileContent = fileContent.replace(/SERVER_PORT/g, `${this.config.firebaseConfig.basePort + 1}`);
+        fileContent = fileContent.replace(/PATH_TO_SSL_KEY/g, `${(_b = this.config.firebaseConfig.ssl) === null || _b === void 0 ? void 0 : _b.pathToKey}`);
+        fileContent = fileContent.replace(/PATH_TO_SSL_CERTIFICATE/g, `${(_c = this.config.firebaseConfig.ssl) === null || _c === void 0 ? void 0 : _c.pathToCertificate}`);
+        await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+    }
+    async resolveConfigDir() {
+        //Create the dir if it doesn't exist
+        const pathToFirebaseConfigFolder = `${this.runtime.pathTo.pkg}/${this.config.firebaseConfig.pathToFirebaseConfig}`;
+        try {
+            await fs_1.promises.access(pathToFirebaseConfigFolder);
+        }
+        catch (e) {
+            await fs_1.promises.mkdir(pathToFirebaseConfigFolder, { recursive: true });
+        }
+        //Fill config dir with relevant files for each file that doesn't exist
+        const defaultFiles = RunnerParams_1.MemKey_ProjectConfig.get().defaultFileRoutes;
+        if (!defaultFiles) {
+            this.logError('No defaultFileRoutes in project config');
+            return;
+        }
+        await Promise.all(consts_2.Const_FirebaseConfigKeys.map(async (firebaseConfigKey) => {
+            var _a;
+            const pathToConfigFile = `${pathToFirebaseConfigFolder}/${consts_2.Const_FirebaseDefaultsKeyToFile[firebaseConfigKey]}`;
+            try {
+                await fs_1.promises.access(pathToConfigFile);
+            }
+            catch (e) {
+                const path = (_a = defaultFiles.firebaseConfig) === null || _a === void 0 ? void 0 : _a[firebaseConfigKey];
+                if (!path)
+                    return;
+                const defaultFileContent = await fs_1.promises.readFile(path, { encoding: 'utf-8' });
+                await fs_1.promises.writeFile(pathToConfigFile, defaultFileContent, { encoding: 'utf-8' });
+            }
+        }));
+    }
+    async resolveFunctionsJSON() {
+        var _a, _b;
+        const envConfig = this.getEnvConfig();
+        const targetPath = `${this.runtime.pathTo.pkg}/${consts_1.CONST_FirebaseJSON}`;
+        let fileContent;
+        if (envConfig.isLocal) {
+            const port = this.config.firebaseConfig.basePort;
+            fileContent = {
+                database: {
+                    rules: `${this.config.firebaseConfig.pathToFirebaseConfig}/database.rules.json`
+                },
+                firestore: {
+                    rules: `${this.config.firebaseConfig.pathToFirebaseConfig}/firestore.rules`,
+                    indexes: `${this.config.firebaseConfig.pathToFirebaseConfig}/firestore.indexes.json`
+                },
+                storage: {
+                    rules: `${this.config.firebaseConfig.pathToFirebaseConfig}/storage.rules`
+                },
+                remoteconfig: {
+                    template: `${this.config.firebaseConfig.pathToFirebaseConfig}/remoteconfig.template.json`
+                },
+                functions: {
+                    ignore: (_a = this.config.firebaseConfig.functions) === null || _a === void 0 ? void 0 : _a.ignore,
+                    source: '.',
+                    predeploy: [
+                        'echo "Thunderstorm - Local environment is not deployable... Aborting..." && exit 2'
+                    ]
+                },
+                emulators: {
+                    functions: { port: port + 1 },
+                    database: { port: port + 2 },
+                    firestore: {
+                        port: port + 3,
+                        websocketPort: port + 4
+                    },
+                    pubsub: { port: port + 5 },
+                    storage: { port: port + 6 },
+                    auth: { port: port + 7 },
+                    ui: { port: port + 8, enabled: true },
+                    hub: { port: port + 9 },
+                    logging: { port: port + 10 }
+                }
+            };
+        }
+        else {
+            fileContent = {
+                functions: {
+                    source: this.config.output.replace(`${this.config.pathToPackage}/`, ''),
+                    ignore: (_b = this.config.firebaseConfig.functions) === null || _b === void 0 ? void 0 : _b.ignore
+                }
+            };
+        }
+        await fs_1.promises.writeFile(targetPath, JSON.stringify(fileContent, null, 2), { encoding: 'utf-8' });
+    }
+    async resolveFunctionsRuntimeConfig() {
+        const envConfig = this.getEnvConfig();
+        const targetPath = `${this.runtime.pathTo.pkg}/src/main/config.ts`;
+        const beConfig = { name: envConfig.env };
+        const fileContent = `${envConfig.isLocal ? '// @ts-ignore\nprocess.env[\'NODE_TLS_REJECT_UNAUTHORIZED\'] = 0;\n' : ''}
+		export const Environment = ${JSON.stringify(beConfig)};`;
+        await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+    }
+    //######################### Compile Logic #########################
+    async createAppVersionFile() {
+        //Writing the file to the package source instead of the output is fine,
+        //copyAssetsToOutput will move the file to output
+        const targetPath = `${this.runtime.pathTo.pkg}/${CONST_VersionApp}`;
+        const appVersion = RunnerParams_1.MemKey_ProjectConfig.get().projectVersion;
+        const fileContent = JSON.stringify({ version: appVersion }, null, 2);
+        await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+    }
+    async createDependenciesDir() {
+        var _a;
+        //Gather units that are dependencies of this unit
+        const dependencies = (0, ts_common_1._keys)((_a = this.packageJson.root.dependencies) !== null && _a !== void 0 ? _a : {});
+        const runner = consts_3.MemKey_PhaseRunner.get();
+        const tsLibUnits = runner.getUnits().filter(unit => unit instanceof core_1.Unit_TypescriptLib);
+        const dependencyUnits = tsLibUnits.filter(unit => {
+            const unitPJName = unit.packageJson.template.name;
+            return dependencies.includes(unitPJName);
+        });
+        if (!dependencyUnits.length)
+            return;
+        const packageJsonConverter = (pj) => {
+            var _a;
+            const finalPJ = (0, ts_common_1.deepClone)(this.packageJson.dist);
+            (_a = finalPJ.dependencies) !== null && _a !== void 0 ? _a : (finalPJ.dependencies = {});
+            (0, ts_common_1._keys)(finalPJ.dependencies).reduce((acc, packageName) => {
+                const unit = dependencyUnits.find(unit => unit.packageJson.template.name === packageName);
+                if (!unit)
+                    return acc;
+                acc[packageName] = `file:.dependencies/${unit.config.key}`;
+                return acc;
+            }, finalPJ.dependencies);
+            return finalPJ;
+        };
+        await Promise.all(dependencyUnits.map(async (unit) => {
+            //Copy dependency unit output into this units output/.dependency dir
+            const dependencyOutputPath = `${unit.runtime.pathTo.output}/`;
+            const targetPath = `${this.runtime.pathTo.output}/.dependencies/${unit.config.key}/`;
+            const pjTargetPath = `${targetPath}/${consts_1.CONST_PackageJSON}`;
+            await cli_1.Commando.create()
+                .append(`mkdir -p ${targetPath}`)
+                .append(`rsync -a --delete ${dependencyOutputPath} ${targetPath}`)
+                .execute();
+            //Copy units dependency package into newly created dir
+            const dependencyPJ = packageJsonConverter(unit.packageJson.dist);
+            const fileContent = JSON.stringify(dependencyPJ, null, 2);
+            await fs_1.promises.writeFile(pjTargetPath, fileContent, { encoding: 'utf-8' });
+        }));
+        this.packageJson.dist = packageJsonConverter(this.packageJson.dist);
+    }
+    //######################### Launch Logic #########################
+    async initLaunch() {
+        this.launchCommandos = {
+            emulator: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic).setUID(this.config.key).cd(this.runtime.pathTo.pkg),
+            proxy: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic).setUID(this.config.key).cd(this.runtime.pathTo.pkg),
+        };
+    }
+    async initLaunchListeners() {
+        this.listeners = {
+            proxy: {
+                pid: new cli_1.CommandoCLIKeyValueListener(new RegExp(`${this.PROXY_PID_LOG}=(\\d+)`)),
+                kill: new cli_1.CommandoCLIListener(() => this.launchCommandos.proxy.close(), this.PROXY_KILL_LOG),
+            },
+            emulator: {
+                pid: new cli_1.CommandoCLIKeyValueListener(new RegExp(`${this.EMULATOR_PID_LOG}=(\\d+)`)),
+                kill: new cli_1.CommandoCLIListener(() => this.launchCommandos.emulator.close(), this.EMULATOR_KILL_LOG),
+            },
+            onReady: new cli_1.CommandoCLIListener(() => this.onLaunched(), new RegExp('.*Emulator Hub running.*')),
+        };
+        this.listeners.proxy.kill.listen(this.launchCommandos.proxy);
+        this.listeners.proxy.pid.listen(this.launchCommandos.proxy);
+        this.listeners.emulator.kill.listen(this.launchCommandos.emulator);
+        this.listeners.emulator.pid.listen(this.launchCommandos.emulator);
+        this.listeners.onReady.listen(this.launchCommandos.emulator);
+    }
+    async clearPorts() {
+        const allPorts = Array.from({ length: 10 }, (_, i) => `${this.config.firebaseConfig.basePort + i}`);
+        await cli_1.Commando.create(basic_1.Cli_Basic)
+            .debug()
+            .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
+            .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
+            .append('echo ')
+            .execute();
+    }
+    async runProxy() {
+        await this.launchCommandos.proxy
+            .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.launchCommandos.emulator
+            .append(`firebase emulators:start --export-on-exit --import=.trash/data ${params_1.RuntimeParams.debugBackend ? `--inspect-functions ${this.config.firebaseConfig.debugPort}` : ''} &`)
+            .append('pid=$!')
+            .append(`echo "${this.EMULATOR_PID_LOG}=\${pid}"`)
+            .append(`wait \$pid`)
+            .append(`echo "${this.EMULATOR_KILL_LOG} \${pid}"`)
+            .execute();
+    }
+    onLaunched() {
+        this.setStatus('Launch Complete');
+    }
+    getPID(listener) {
+        const pid = Number(listener.getValue());
+        return isNaN(pid) ? undefined : pid;
+    }
+    async kill() {
+        if (!this.launchCommandos)
+            return;
+        const emulatorPid = this.getPID(this.listeners.emulator.pid);
+        const proxyPid = this.getPID(this.listeners.proxy.pid);
+        await this.launchCommandos.emulator.gracefullyKill(emulatorPid);
+        await this.launchCommandos.proxy.gracefullyKill(proxyPid);
+    }
+    //######################### Deploy Logic #########################
+    async printFiles() {
+        await cli_1.Commando.create(basic_1.Cli_Basic)
+            .cd(this.runtime.pathTo.output)
+            .ls()
+            .cat('package.json')
+            .cat('index.js')
+            .execute();
+    }
+    async deployImpl() {
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(this.runtime.pathTo.pkg)
+            .append(`firebase --debug deploy --only functions --force`)
+            .execute();
+    }
+}
+Unit_FirebaseFunctionsApp.staggerCount = 0;
+exports.Unit_FirebaseFunctionsApp = Unit_FirebaseFunctionsApp;

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

@@ -0,0 +1,32 @@
+import { Unit_TypescriptLib } from '../core';
+import { FirebasePackageConfig } from '../../../core/types';
+import { UnitPhaseImplementor } from '../types';
+import { Phase_DeployFrontend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
+type _Config<Config> = {
+    firebaseConfig: FirebasePackageConfig;
+    sources?: string[];
+} & Config;
+export declare class Unit_FirebaseHostingApp<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployFrontend]> {
+    private readonly APP_PID_LOG;
+    private readonly APP_KILL_LOG;
+    private launchCommando;
+    private listeners;
+    resolveConfigs(): Promise<void>;
+    compile(): Promise<void>;
+    launch(): Promise<void>;
+    deployFrontend(): Promise<void>;
+    private getEnvConfig;
+    private resolveHostingRC;
+    private resolveHostingJSON;
+    private resolveHostingRuntimeConfig;
+    protected compileImpl(): Promise<void>;
+    private createAppVersionFile;
+    private initLaunch;
+    private initLaunchListeners;
+    private getPID;
+    private clearPorts;
+    private runApp;
+    kill(): Promise<void>;
+    private deployImpl;
+}
+export {};