@nu-art/build-and-install 0.204.42 → 0.204.44

package/build-and-install.js

@@ -19,6 +19,7 @@ projectManager.registerPhase(phases_1.Phase_PrintEnv);
 projectManager.registerPhase(phases_1.Phase_PackagePurge);
 projectManager.registerPhase(phases_1.Phase_InstallGlobals);
 projectManager.registerPhase(phases_1.Phase_InstallPackages);
+projectManager.registerPhase(phases_1.Phase_InstallPythonPackages);
 projectManager.registerPhase(phases_1.Phase_Clean);
 projectManager.registerPhase(phases_1.Phase_Lint);
 projectManager.registerPhase(phases_1.Phase_PrepareCompile);

package/core/params/params.d.ts

@@ -33,5 +33,6 @@ export declare const BaiParam_Debug: BaseCliParam<'debug', boolean>;
 export declare const BaiParam_QuickDeploy: BaseCliParam<'quickDeploy', boolean>;
 export declare const BaiParam_Publish: BaseCliParam<'publish', string>;
 export declare const BaiParam_AllLogs: BaseCliParam<'allLogs', boolean>;
-export declare const AllBaiParams: (BaseCliParam<"help", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"printEnv", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"installPackages", boolean> | BaseCliParam<"installGlobals", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"runWithThunderstorm", boolean> | BaseCliParam<"withCommando", boolean> | BaseCliParam<"noThunderstorm", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"test", string> | BaseCliParam<"launch", string> | BaseCliParam<"launchFrontend", boolean> | BaseCliParam<"launchBackend", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"deployBackend", boolean> | BaseCliParam<"deployFrontend", boolean> | BaseCliParam<"noGit", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"publish", string> | BaseCliParam<"allLogs", boolean>)[];
-export declare const RuntimeParams: import("@nu-art/commando/cli/cli-params").CliParams<(BaseCliParam<"help", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"printEnv", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"installPackages", boolean> | BaseCliParam<"installGlobals", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"runWithThunderstorm", boolean> | BaseCliParam<"withCommando", boolean> | BaseCliParam<"noThunderstorm", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"test", string> | BaseCliParam<"launch", string> | BaseCliParam<"launchFrontend", boolean> | BaseCliParam<"launchBackend", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"deployBackend", boolean> | BaseCliParam<"deployFrontend", boolean> | BaseCliParam<"noGit", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"publish", string> | BaseCliParam<"allLogs", boolean>)[]>;
+export declare const BaiParam_EncounterManager: BaseCliParam<'encounterManager', boolean>;
+export declare const AllBaiParams: (BaseCliParam<"help", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"printEnv", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"installPackages", boolean> | BaseCliParam<"installGlobals", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"runWithThunderstorm", boolean> | BaseCliParam<"withCommando", boolean> | BaseCliParam<"noThunderstorm", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"test", string> | BaseCliParam<"launch", string> | BaseCliParam<"launchFrontend", boolean> | BaseCliParam<"launchBackend", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"deployBackend", boolean> | BaseCliParam<"deployFrontend", boolean> | BaseCliParam<"noGit", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"publish", string> | BaseCliParam<"allLogs", boolean> | BaseCliParam<"encounterManager", boolean>)[];
+export declare const RuntimeParams: import("@nu-art/commando/cli/cli-params").CliParams<(BaseCliParam<"help", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"printEnv", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"installPackages", boolean> | BaseCliParam<"installGlobals", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"runWithThunderstorm", boolean> | BaseCliParam<"withCommando", boolean> | BaseCliParam<"noThunderstorm", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"test", string> | BaseCliParam<"launch", string> | BaseCliParam<"launchFrontend", boolean> | BaseCliParam<"launchBackend", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"deployBackend", boolean> | BaseCliParam<"deployFrontend", boolean> | BaseCliParam<"noGit", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"publish", string> | BaseCliParam<"allLogs", boolean> | BaseCliParam<"encounterManager", boolean>)[]>;

package/core/params/params.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeParams = exports.AllBaiParams = exports.BaiParam_AllLogs = exports.BaiParam_Publish = exports.BaiParam_QuickDeploy = exports.BaiParam_Debug = exports.BaiParam_NoGit = exports.BaiParam_DeployFrontend = exports.BaiParam_DeployBackend = exports.BaiParam_Deploy = exports.BaiParam_DebugBackend = exports.BaiParam_LaunchBackend = exports.BaiParam_LaunchFrontend = exports.BaiParam_Launch = exports.BaiParam_Test = exports.BaiParam_Watch = exports.BaiParam_Lint = exports.BaiParam_NoThunderstorm = exports.BaiParam_WithCommando = exports.BaiParam_RunWithThunderstorm = exports.BaiParam_DryRun = exports.BaiParam_NoBuild = exports.BaiParam_GenerateDocs = exports.BaiParam_Generate = exports.BaiParam_Purge = exports.BaiParam_Clean = exports.BaiParam_InstallGlobals = exports.BaiParam_InstallPackages = exports.BaiParam_Install = exports.BaiParam_Setup = exports.BaiParam_SetEnv = exports.BaiParam_continue = exports.BaiParam_PrintEnv = exports.BaiParam_CheckCyclicImports = exports.BaiParam_DependencyTree = exports.BaiParam_Help = void 0;
+exports.RuntimeParams = exports.AllBaiParams = exports.BaiParam_EncounterManager = exports.BaiParam_AllLogs = exports.BaiParam_Publish = exports.BaiParam_QuickDeploy = exports.BaiParam_Debug = exports.BaiParam_NoGit = exports.BaiParam_DeployFrontend = exports.BaiParam_DeployBackend = exports.BaiParam_Deploy = exports.BaiParam_DebugBackend = exports.BaiParam_LaunchBackend = exports.BaiParam_LaunchFrontend = exports.BaiParam_Launch = exports.BaiParam_Test = exports.BaiParam_Watch = exports.BaiParam_Lint = exports.BaiParam_NoThunderstorm = exports.BaiParam_WithCommando = exports.BaiParam_RunWithThunderstorm = exports.BaiParam_DryRun = exports.BaiParam_NoBuild = exports.BaiParam_GenerateDocs = exports.BaiParam_Generate = exports.BaiParam_Purge = exports.BaiParam_Clean = exports.BaiParam_InstallGlobals = exports.BaiParam_InstallPackages = exports.BaiParam_Install = exports.BaiParam_Setup = exports.BaiParam_SetEnv = exports.BaiParam_continue = exports.BaiParam_PrintEnv = exports.BaiParam_CheckCyclicImports = exports.BaiParam_DependencyTree = exports.BaiParam_Help = void 0;
 const cli_params_1 = require("@nu-art/commando/cli/cli-params");
 exports.BaiParam_Help = {
     keys: ['--help', '-h'],
@@ -246,6 +246,13 @@ exports.BaiParam_AllLogs = {
     group: 'Other',
     description: 'will disable ui and show verbose logs for bai run',
 };
+exports.BaiParam_EncounterManager = {
+    keys: ['-em', '--encounter-manager'],
+    keyName: 'encounterManager',
+    type: 'boolean',
+    group: 'Other',
+    description: 'Will install encounter manager shit',
+};
 exports.AllBaiParams = [
     exports.BaiParam_Help,
     exports.BaiParam_DependencyTree,
@@ -279,7 +286,8 @@ exports.AllBaiParams = [
     exports.BaiParam_NoGit,
     exports.BaiParam_Debug,
     exports.BaiParam_Publish,
-    exports.BaiParam_AllLogs
+    exports.BaiParam_AllLogs,
+    exports.BaiParam_EncounterManager
 ];
 const params = cli_params_1.CLIParams_Resolver.create(...exports.AllBaiParams).resolveParamValue();
 exports.RuntimeParams = params;

package/core/types/package/package.d.ts

@@ -4,7 +4,8 @@ export declare const PackageType_FirebaseHostingApp: "firebase-hosting-app";
 export declare const PackageType_FirebaseHostingAndFunctionApp: "firebase-app";
 export declare const PackageType_FirebaseFunctionsApp: "firebase-functions-app";
 export declare const PackageType_Sourceless: "sourceless";
-export declare const PackageTypes: readonly ["infra-lib", "project-lib", "firebase-hosting-app", "firebase-functions-app", "sourceless"];
+export declare const PackageType_Python: "python";
+export declare const PackageTypes: readonly ["infra-lib", "project-lib", "firebase-hosting-app", "firebase-functions-app", "sourceless", "python"];
 export declare const PackageTypesWithOutput: ("infra-lib" | "project-lib" | "firebase-hosting-app" | "firebase-functions-app")[];
 export type PackageType = typeof PackageTypes[number];
 export type FirebaseEnvConfig<Env extends string> = {
@@ -62,6 +63,10 @@ export type Package_Base = {
 export type Package_Sourceless = Package_Base & {
     type: typeof PackageType_Sourceless;
 };
+export type Package_Python = Package_Base & {
+    type: typeof PackageType_Python;
+    path: string;
+};
 export type Package_WithSources = Package_Base & {
     output: string;
     customTsConfig?: boolean;
@@ -85,4 +90,4 @@ export type Package_InfraLib = Package_WithSources & {
 export type Package_ProjectLib = Package_WithSources & {
     type: typeof PackageType_ProjectLib;
 };
-export type Package = Package_Sourceless | Package_FirebaseHostingApp | Package_FirebaseFunctionsApp | Package_InfraLib | Package_ProjectLib;
+export type Package = Package_Sourceless | Package_FirebaseHostingApp | Package_FirebaseFunctionsApp | Package_InfraLib | Package_ProjectLib | Package_Python;

package/core/types/package/package.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackageTypesWithOutput = exports.PackageTypes = exports.PackageType_Sourceless = exports.PackageType_FirebaseFunctionsApp = exports.PackageType_FirebaseHostingAndFunctionApp = exports.PackageType_FirebaseHostingApp = exports.PackageType_ProjectLib = exports.PackageType_InfraLib = void 0;
+exports.PackageTypesWithOutput = exports.PackageTypes = exports.PackageType_Python = exports.PackageType_Sourceless = exports.PackageType_FirebaseFunctionsApp = exports.PackageType_FirebaseHostingAndFunctionApp = exports.PackageType_FirebaseHostingApp = exports.PackageType_ProjectLib = exports.PackageType_InfraLib = void 0;
 exports.PackageType_InfraLib = 'infra-lib';
 exports.PackageType_ProjectLib = 'project-lib';
 exports.PackageType_FirebaseHostingApp = 'firebase-hosting-app';
 exports.PackageType_FirebaseHostingAndFunctionApp = 'firebase-app';
 exports.PackageType_FirebaseFunctionsApp = 'firebase-functions-app';
 exports.PackageType_Sourceless = 'sourceless';
-exports.PackageTypes = [exports.PackageType_InfraLib, exports.PackageType_ProjectLib, exports.PackageType_FirebaseHostingApp, exports.PackageType_FirebaseFunctionsApp, exports.PackageType_Sourceless];
+exports.PackageType_Python = 'python';
+exports.PackageTypes = [exports.PackageType_InfraLib, exports.PackageType_ProjectLib, exports.PackageType_FirebaseHostingApp, exports.PackageType_FirebaseFunctionsApp, exports.PackageType_Sourceless, exports.PackageType_Python];
 exports.PackageTypesWithOutput = [exports.PackageType_InfraLib, exports.PackageType_ProjectLib, exports.PackageType_FirebaseHostingApp, exports.PackageType_FirebaseFunctionsApp];

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

@@ -1,4 +1,5 @@
 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;
@@ -9,13 +10,17 @@ export declare class CommandExecutor_FirebaseFunction {
     private readonly commandos;
     private listeners;
     private debugMode?;
+    private onReadyCallbacks;
     constructor(pkg: Package_FirebaseFunctionsApp);
     private initListeners;
     private clearPorts;
     private runProxy;
     private runEmulator;
     private getPID;
+    private onReady;
     execute(): Promise<this>;
     kill(): Promise<void>;
     setDebug(debug: boolean): void;
+    addOnReadyCallback(cb: OnReadyCallback): void;
 }
+export {};

package/logic/command-executors/CommandExecutor_FirebaseFunction.js

@@ -11,6 +11,7 @@ class CommandExecutor_FirebaseFunction {
         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),
@@ -28,12 +29,14 @@ class CommandExecutor_FirebaseFunction {
             emulator: {
                 pid: new cli_1.CommandoCLIKeyValueListener(new RegExp(`${this.EMULATOR_PID_LOG}=(\\d+)`)),
                 kill: new cli_1.CommandoCLIListener(() => this.commandos.emulator.close(), this.EMULATOR_KILL_LOG),
-            }
+            },
+            onReady: new cli_1.CommandoCLIListener(() => this.onReady(), new RegExp('.*Emulator Hub running.*')),
         };
         this.listeners.proxy.kill.listen(this.commandos.proxy);
         this.listeners.proxy.pid.listen(this.commandos.proxy);
         this.listeners.emulator.kill.listen(this.commandos.emulator);
         this.listeners.emulator.pid.listen(this.commandos.emulator);
+        this.listeners.onReady.listen(this.commandos.emulator);
     }
     async clearPorts() {
         const allPorts = Array.from({ length: 10 }, (_, i) => `${this.pkg.envConfig.basePort + i}`);
@@ -71,9 +74,12 @@ class CommandExecutor_FirebaseFunction {
         const pid = Number(listener.getValue());
         return isNaN(pid) ? undefined : pid;
     }
+    async onReady() {
+        await Promise.all(this.onReadyCallbacks.map(cb => cb(this.pkg)));
+    }
     //######################### Functions #########################
     async execute() {
-        await (0, ts_common_1.sleep)(ts_common_1.Second * CommandExecutor_FirebaseFunction.staggerCount++);
+        await (0, ts_common_1.sleep)(2 * ts_common_1.Second * CommandExecutor_FirebaseFunction.staggerCount++);
         await this.clearPorts();
         await this.runProxy();
         await this.runEmulator();
@@ -88,6 +94,9 @@ class CommandExecutor_FirebaseFunction {
     setDebug(debug) {
         this.debugMode = debug;
     }
+    addOnReadyCallback(cb) {
+        this.onReadyCallbacks.push(cb);
+    }
 }
 CommandExecutor_FirebaseFunction.staggerCount = 0;
 exports.CommandExecutor_FirebaseFunction = CommandExecutor_FirebaseFunction;

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

@@ -0,0 +1,17 @@
+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;
+    private listeners;
+    constructor(pkg: Package_Python);
+    private initListeners;
+    private getPID;
+    private enterVenv;
+    private setPythonPath;
+    private runApp;
+    private clearPorts;
+    execute(): Promise<void>;
+    kill(): Promise<void>;
+}

package/logic/command-executors/CommandExecutor_Python.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutor_Python = void 0;
+const cli_1 = require("@nu-art/commando/core/cli");
+const basic_1 = require("@nu-art/commando/cli/basic");
+const tools_1 = require("@nu-art/commando/core/tools");
+class CommandExecutor_Python {
+    constructor(pkg) {
+        this.APP_PID_LOG = '_APP_PID_';
+        this.APP_KILL_LOG = '_APP_KILLED_';
+        this.pkg = pkg;
+        this.commando = cli_1.CommandoInteractive.create(basic_1.Cli_Basic)
+            .setUID(this.pkg.name)
+            .cd((0, tools_1.convertToFullPath)(this.pkg.path))
+            .debug();
+        this.initListeners();
+    }
+    //######################### Inner Logic #########################
+    initListeners() {
+        this.listeners = {
+            pid: new cli_1.CommandoCLIKeyValueListener(new RegExp(`${this.APP_PID_LOG}=(\\d+)`)),
+            kill: new cli_1.CommandoCLIListener(() => this.commando.close(), this.APP_KILL_LOG),
+        };
+        this.listeners.pid.listen(this.commando);
+        this.listeners.kill.listen(this.commando);
+    }
+    getPID() {
+        const pid = Number(this.listeners.pid.getValue());
+        return isNaN(pid) ? undefined : pid;
+    }
+    async enterVenv() {
+        await this.commando.append('source venv/bin/activate').execute();
+    }
+    async setPythonPath() {
+        await this.commando.append('export PYTHONPATH=.').execute();
+    }
+    async runApp() {
+        await this.commando
+            .append('python3 app/src/run.py --env=local &')
+            .append('pid=$!')
+            .append(`echo "${this.APP_PID_LOG}=\${pid}"`)
+            .append(`wait \$pid`)
+            .append(`echo "${this.APP_KILL_LOG} \${pid}"`)
+            .execute();
+    }
+    async clearPorts() {
+        const emPort = 4450;
+        await this.commando
+            .append(`array=($(lsof -ti:${[emPort].join(',')}))`)
+            .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
+            .append('echo ')
+            .execute();
+    }
+    //######################### Functions #########################
+    async execute() {
+        await this.clearPorts();
+        await this.enterVenv();
+        await this.setPythonPath();
+        await this.runApp();
+    }
+    async kill() {
+        const appPid = this.getPID();
+        await this.commando.gracefullyKill(appPid);
+    }
+}
+exports.CommandExecutor_Python = CommandExecutor_Python;

package/logic/map-project-packages.js

@@ -48,6 +48,8 @@ function getRuntimePackageBaseDetails(basePackage) {
         case types_1.PackageType_FirebaseFunctionsApp:
         case types_1.PackageType_FirebaseHostingApp:
             return getRuntimePackageBaseDetails_Firebase(basePackage);
+        default:
+            throw new ts_common_1.ImplementationMissingException(`Missin runtime package converter for package of type ${basePackage.type}`);
     }
 }
 function convertPackageJSONTemplateToPackJSON_Value(template, value) {
@@ -72,10 +74,11 @@ function convertToRuntimePackage(basePackage, project) {
 }
 exports.convertToRuntimePackage = convertToRuntimePackage;
 function mapProjectPackages(projectConfig) {
-    const packages = projectConfig.packages.map(basePackage => convertToRuntimePackage(basePackage, projectConfig));
+    const packages = projectConfig.packages.filter(pkg => pkg.type !== types_1.PackageType_Python).map(basePackage => convertToRuntimePackage(basePackage, projectConfig));
+    const pythonPackages = projectConfig.packages.filter(pkg => pkg.type === types_1.PackageType_Python);
     const packagesDependency = groupPackagesByDependencyLevel(packages);
-    return Object.assign(Object.assign({}, projectConfig), { packages,
-        packagesDependency, packageMap: (0, ts_common_1.arrayToMap)(packages, p => p.packageJsonTemplate.name) });
+    packagesDependency.push(pythonPackages);
+    return Object.assign(Object.assign({}, projectConfig), { packages: [...packages, ...pythonPackages], packagesDependency, packageMap: (0, ts_common_1.arrayToMap)(packages, p => p.packageJsonTemplate.name) });
 }
 exports.mapProjectPackages = mapProjectPackages;
 function groupPackagesByDependencyLevel(packages) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.204.42",
+  "version": "0.204.44",
   "description": "",
   "keywords": [
     "TacB0sS",

package/phases/phases.d.ts

@@ -12,6 +12,7 @@ export declare const Phase_PrintEnv: BuildPhase;
 export declare const Phase_PackagePurge: BuildPhase;
 export declare const Phase_InstallGlobals: BuildPhase;
 export declare const Phase_InstallPackages: BuildPhase;
+export declare const Phase_InstallPythonPackages: BuildPhase;
 export declare const Phase_Clean: BuildPhase;
 export declare const Phase_Lint: BuildPhase;
 export declare const Phase_Debug: BuildPhase;

package/phases/phases.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Phase_DeployBackend = exports.Phase_DeployFrontend = exports.Phase_Launch = exports.Phase_CompileWatch = exports.Phase_Compile = exports.Phase_PreCompile = exports.Phase_PrepareCompile = exports.Phase_Debug = exports.Phase_Lint = exports.Phase_Clean = exports.Phase_InstallPackages = exports.Phase_InstallGlobals = exports.Phase_PackagePurge = exports.Phase_PrintEnv = exports.Phase_CheckCyclicImports = exports.Phase_PrintDependencyTree = exports.Phase_ResolvePackages = exports.Phase_ResolveEnv = exports.Phase_ResolveTemplate = exports.Phase_PrepareParams = exports.Phase_SetupProject = exports.Phase_SetWithThunderstorm = exports.Phase_PrintHelp = void 0;
+exports.Phase_DeployBackend = exports.Phase_DeployFrontend = exports.Phase_Launch = exports.Phase_CompileWatch = exports.Phase_Compile = exports.Phase_PreCompile = exports.Phase_PrepareCompile = exports.Phase_Debug = exports.Phase_Lint = exports.Phase_Clean = exports.Phase_InstallPythonPackages = exports.Phase_InstallPackages = exports.Phase_InstallGlobals = exports.Phase_PackagePurge = exports.Phase_PrintEnv = exports.Phase_CheckCyclicImports = exports.Phase_PrintDependencyTree = exports.Phase_ResolvePackages = exports.Phase_ResolveEnv = exports.Phase_ResolveTemplate = exports.Phase_PrepareParams = exports.Phase_SetupProject = exports.Phase_SetWithThunderstorm = exports.Phase_PrintHelp = void 0;
 const ProjectManager_1 = require("../logic/ProjectManager");
 const map_project_packages_1 = require("../logic/map-project-packages");
 const fs = __importStar(require("fs"));
@@ -44,6 +44,7 @@ const ProjectScreen_1 = require("../screen/ProjectScreen");
 const cli_1 = require("@nu-art/commando/core/cli");
 const RunningProcessLogs_1 = require("../screen/RunningProcessLogs");
 const command_executors_1 = require("../logic/command-executors");
+const CommandExecutor_Python_1 = require("../logic/command-executors/CommandExecutor_Python");
 const CONST_ThunderstormVersionKey = 'THUNDERSTORM_SDK_VERSION';
 const CONST_ThunderstormDependencyKey = 'THUNDERSTORM_DEPENDENCY_VERSION';
 const CONST_ProjectVersionKey = 'APP_VERSION';
@@ -117,6 +118,7 @@ exports.Phase_PrepareParams = {
     isMandatory: true,
     breakAfterPhase: true,
     mandatoryPhases: [exports.Phase_SetupProject, exports.Phase_SetWithThunderstorm],
+    filter: async (pkg) => pkg.type !== types_1.PackageType_Python,
     action: async (pkg) => {
         const packages = consts_1.MemKey_Packages.get();
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
@@ -138,6 +140,8 @@ exports.Phase_ResolveTemplate = {
     isMandatory: true,
     mandatoryPhases: [exports.Phase_PrepareParams, exports.Phase_SetupProject, exports.Phase_SetWithThunderstorm],
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         const packages = consts_1.MemKey_Packages.get();
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
         projectScreen.updateOrCreatePackage(pkg.name, 'Resolving Templates');
@@ -253,6 +257,8 @@ exports.Phase_CheckCyclicImports = {
     mandatoryPhases: [exports.Phase_ResolveEnv],
     filter: async (pkg) => params_1.RuntimeParams.checkCyclicImports,
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         if (!pkg.output)
             return;
         return nvm_1.NVM.createCommando(basic_1.Cli_Basic)
@@ -280,8 +286,10 @@ exports.Phase_PackagePurge = {
     type: ProjectManager_1.PackageBuildPhaseType_PackageWithOutput,
     name: 'package-purge',
     mandatoryPhases: [exports.Phase_ResolveEnv],
-    filter: async (pkg) => fs.existsSync(pkg.output) && params_1.RuntimeParams.purge,
+    filter: async (pkg) => pkg.type !== types_1.PackageType_Python && fs.existsSync(pkg.output) && params_1.RuntimeParams.purge,
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
         //Update cli ui
         projectScreen.updateOrCreatePackage(pkg.name, 'Purging');
@@ -320,12 +328,30 @@ exports.Phase_InstallPackages = {
         await pnpm_1.PNPM.installPackages(nvm_1.NVM.createCommando());
     }
 };
+exports.Phase_InstallPythonPackages = {
+    type: 'package',
+    name: 'install-python-packages',
+    filter: async (pkg) => params_1.RuntimeParams.encounterManager && pkg.type === types_1.PackageType_Python,
+    action: async (pkg) => {
+        if (pkg.type !== types_1.PackageType_Python)
+            return;
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd((0, tools_1.convertToFullPath)(pkg.path))
+            .append('echo installing python')
+            .append('python3 -m venv venv')
+            .append('source venv/bin/activate')
+            .append('pip3 install -r requirements.txt')
+            .execute();
+    }
+};
 exports.Phase_Clean = {
     type: ProjectManager_1.PackageBuildPhaseType_PackageWithOutput,
     name: 'clean',
     mandatoryPhases: [exports.Phase_ResolveEnv],
     filter: async (pkg) => params_1.RuntimeParams.clean,
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
         projectScreen.updateOrCreatePackage(pkg.name, 'Cleaning');
         if (!fs.existsSync(pkg.output))
@@ -339,6 +365,8 @@ exports.Phase_Lint = {
     mandatoryPhases: [exports.Phase_ResolveEnv],
     filter: async (pkg) => params_1.RuntimeParams.lint && pkg.type !== 'sourceless',
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
         projectScreen.updateOrCreatePackage(pkg.name, 'Linting');
         const folder = 'main';
@@ -370,9 +398,9 @@ exports.Phase_PrepareCompile = {
     name: 'prepare-compile',
     isMandatory: true,
     mandatoryPhases: [exports.Phase_ResolveEnv],
-    filter: async (pkg) => pkg.type !== 'sourceless' && !params_1.RuntimeParams.noBuild,
+    filter: async (pkg) => pkg.type !== 'sourceless' && pkg.type !== types_1.PackageType_Python && !params_1.RuntimeParams.noBuild,
     action: async (pkg) => {
-        if (pkg.type === 'sourceless')
+        if (pkg.type === 'sourceless' || pkg.type === types_1.PackageType_Python)
             return;
         const folder = 'main';
         const sourceFolder = `${pkg.path}/src/${folder}`;
@@ -433,6 +461,8 @@ exports.Phase_PreCompile = {
         return fs.existsSync(`${pkg.path}/prebuild.sh`);
     },
     action: async (pkg) => {
+        if (pkg.type === types_1.PackageType_Python)
+            return;
         return nvm_1.NVM.createCommando(basic_1.Cli_Basic)
             .cd(pkg.path)
             .append(`bash ${pkg.path}/prebuild.sh`).execute();
@@ -446,7 +476,7 @@ exports.Phase_Compile = {
     action: async (pkg) => {
         var _a;
         const packages = consts_1.MemKey_Packages.get();
-        if (pkg.type === 'sourceless')
+        if (pkg.type === 'sourceless' || pkg.type === types_1.PackageType_Python)
             return;
         const folder = 'main';
         const sourceFolder = `${pkg.path}/src/${folder}`;
@@ -481,11 +511,15 @@ exports.Phase_Compile = {
             }), __pkg => __pkg.name);
             if (runTimePackages) {
                 for (const rtPack of runTimePackages) {
+                    if (rtPack.type === types_1.PackageType_Python)
+                        return;
+                    // @ts-ignore
                     if (!rtPack.output)
                         continue;
                     const pkgOutputFolderAsDependency = `${pkg.output}/.dependencies/${rtPack.name}/`;
                     await nvm_1.NVM.createCommando()
                         .append(`mkdir -p ${pkgOutputFolderAsDependency}`)
+                        // @ts-ignore
                         .append(`rsync -a --delete ${rtPack.output}/ ${pkg.output}/.dependencies/${rtPack.name}/`)
                         .execute();
                     await fs_1.promises.writeFile(`${pkgOutputFolderAsDependency}/${consts_1.CONST_PackageJSON}`, JSON.stringify(rtPack.packageJsonRuntime, null, 2), { encoding: 'utf-8' });
@@ -518,12 +552,12 @@ exports.Phase_CompileWatch = {
                 return console.error(`couldn't find lib to run for path: ${libPath}...\nListening on: ${(0, ts_common_1.__stringify)(sourcesPaths, true)}`);
             const rtPackages = consts_1.MemKey_Packages.get();
             const pkg = (0, ts_common_1.flatArray)(rtPackages.packagesDependency).find(pkg => {
-                return path.startsWith(pkg.path) && pkg.type !== 'sourceless';
+                return path.startsWith(pkg.path) && pkg.type !== 'sourceless' && pkg.type !== types_1.PackageType_Python;
             });
             if (deleteDist && pkg && 'output' in pkg)
                 await fs_1.promises.rmdir(pkg.output);
             const packageIndex = rtPackages.packagesDependency.findIndex(packages => {
-                return packages.some(pkg => path.startsWith(pkg.path) && pkg.type !== 'sourceless');
+                return packages.some(pkg => path.startsWith(pkg.path) && pkg.type !== 'sourceless' && pkg.type !== types_1.PackageType_Python);
             });
             try {
                 if (controller)
@@ -582,13 +616,14 @@ exports.Phase_CompileWatch = {
         });
     }
 };
+const executorMap = {};
 let runningAppsLogs;
 exports.Phase_Launch = {
     type: 'package',
     name: 'launch',
     terminatingPhase: true,
     mandatoryPhases: [exports.Phase_ResolveEnv],
-    filter: async (pkg) => { var _a; return !!((_a = pkg.name.match(new RegExp(params_1.RuntimeParams.launch))) === null || _a === void 0 ? void 0 : _a[0]) && (pkg.type === 'firebase-functions-app' || pkg.type === 'firebase-hosting-app'); },
+    filter: async (pkg) => { var _a; return !!((_a = pkg.name.match(new RegExp(params_1.RuntimeParams.launch))) === null || _a === void 0 ? void 0 : _a[0]) && (pkg.type === 'firebase-functions-app' || pkg.type === 'firebase-hosting-app' || pkg.type === types_1.PackageType_Python); },
     action: async (pkg) => {
         const projectManager = project_manager_1.MemKey_ProjectManager.get();
         const projectScreen = ProjectScreen_1.MemKey_ProjectScreen.get();
@@ -611,20 +646,54 @@ exports.Phase_Launch = {
         ts_common_1.BeLogged.addClient(logClient);
         projectScreen.updateOrCreatePackage(pkg.name, 'Launching...');
         if (pkg.type === 'firebase-functions-app') {
-            runningAppsLogs.registerApp(pkg.name, logClient);
+            runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.registerApp(pkg.name, logClient);
             const executor = await new command_executors_1.CommandExecutor_FirebaseFunction(pkg).execute();
-            runningAppsLogs.addOnTerminateCallback(async () => {
+            executorMap[pkg.name] = executor;
+            runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.addOnTerminateCallback(async () => {
                 await executor.kill();
-                runningAppsLogs.unregisterApp(pkg.name);
+                runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.unregisterApp(pkg.name);
             });
             return;
         }
         if (pkg.type === 'firebase-hosting-app') {
-            runningAppsLogs.registerApp(pkg.name, logClient);
+            runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.registerApp(pkg.name, logClient);
             const executor = await new command_executors_1.CommandExecutor_FirebaseHosting(pkg).execute();
-            runningAppsLogs.addOnTerminateCallback(async () => {
+            runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.addOnTerminateCallback(async () => {
                 await executor.kill();
-                runningAppsLogs.unregisterApp(pkg.name);
+                runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.unregisterApp(pkg.name);
+            });
+        }
+        if (pkg.type === types_1.PackageType_Python) {
+            runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.registerApp(pkg.name, logClient);
+            logClient.log(pkg.name, ts_common_1.LogLevel.Info, true, ['Awaiting Advisor & KM BE launch']);
+            const advisorExecutor = executorMap['advisor-backend'];
+            const kmExecutor = executorMap['km-backend'];
+            if (!advisorExecutor)
+                logClient.log(pkg.name, ts_common_1.LogLevel.Error, true, ['Advisor BE executor not registered yet']);
+            if (!kmExecutor)
+                logClient.log(pkg.name, ts_common_1.LogLevel.Error, true, ['KM BE executor not registered yet']);
+            let advisorUp = false;
+            let kmUp = false;
+            const startPython = async () => {
+                logClient.log(pkg.name, ts_common_1.LogLevel.Info, true, ['Advisor & KM BE launched, Starting!']);
+                const executor = new CommandExecutor_Python_1.CommandExecutor_Python(pkg);
+                runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.addOnTerminateCallback(async () => {
+                    await executor.kill();
+                    runningAppsLogs === null || runningAppsLogs === void 0 ? void 0 : runningAppsLogs.unregisterApp(pkg.name);
+                });
+                await executor.execute();
+            };
+            advisorExecutor === null || advisorExecutor === void 0 ? void 0 : advisorExecutor.addOnReadyCallback(async () => {
+                advisorUp = true;
+                if (!kmUp)
+                    return logClient.log(pkg.name, ts_common_1.LogLevel.Info, true, ['Advisor launched, waiting for KM']);
+                await startPython();
+            });
+            kmExecutor === null || kmExecutor === void 0 ? void 0 : kmExecutor.addOnReadyCallback(async () => {
+                kmUp = true;
+                if (!advisorUp)
+                    return logClient.log(pkg.name, ts_common_1.LogLevel.Info, true, ['KM launched, waiting for Advisor']);
+                await startPython();
             });
         }
         projectScreen.updateOrCreatePackage(pkg.name, 'Died');

package/v2/ProjectManagerV2.d.ts

@@ -1,12 +1,4 @@
-import { AsyncVoidFunction } from '@nu-art/ts-common';
-export type PhasesImplementor<Phases extends Phase<string>[]> = {
-    [K in Phases[number]['method']]?: AsyncVoidFunction;
-};
-export type Phase<PhaseMethod extends string> = {
-    name?: string;
-    method: PhaseMethod;
-    filter?: () => Promise<boolean>;
-};
+import { Phase, PhasesImplementor } from "./phase-runner/types";
 export declare class ProjectManagerV2<Phases extends Phase<string>[]> {
     private manageables;
     phases: Phase<string>[];

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

@@ -0,0 +1,16 @@
+import { Phase } from './types';
+import { UnitPhaseImplementor } from '../unit/core/types';
+import { BaseUnit } from '../unit/core/BaseUnit';
+type Unit<P extends Phase<string>[]> = BaseUnit & UnitPhaseImplementor<P>;
+export declare class PhaseRunner<P extends Phase<string>[]> extends BaseUnit {
+    private readonly phases;
+    private units;
+    constructor(phases: P);
+    registerUnits(units: Unit<P> | Unit<P>[]): void;
+    private getUnitsForPhase;
+    private initUnits;
+    private executePhase;
+    execute(): Promise<void>;
+    private executeImpl;
+}
+export {};

package/v2/phase-runner/PhaseRunner.js

@@ -0,0 +1,49 @@
+"use strict";
+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) {
+        super({ label: 'Phase Runner', key: 'phase-runner' });
+        this.units = [];
+        this.phases = phases;
+    }
+    //######################### Unit Logic #########################
+    registerUnits(units) {
+        (0, ts_common_1.asArray)(units).forEach(unit => this.units.push(unit));
+    }
+    getUnitsForPhase(phase) {
+        return this.units.filter(unit => (0, ts_common_1.exists)(unit[phase.method]));
+    }
+    async initUnits() {
+        return Promise.all(this.units.map(unit => {
+            // @ts-ignore
+            unit.init();
+        }));
+    }
+    //######################### Phase Logic #########################
+    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`);
+        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]();
+        }
+    }
+    //######################### Public Functions #########################
+    async execute() {
+        await this.initUnits();
+        await this.executeImpl();
+    }
+    async executeImpl() {
+        for (const phase of this.phases) {
+            await this.executePhase(phase);
+        }
+    }
+}
+exports.PhaseRunner = PhaseRunner;

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

@@ -0,0 +1,12 @@
+import { AsyncVoidFunction } from '@nu-art/ts-common';
+export type Phase<PhaseMethod extends string> = {
+    name: string;
+    method: PhaseMethod;
+    filter?: () => (Promise<boolean> | boolean);
+};
+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;
+};

package/v2/phase-runner/types.js

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

package/v2/test/test.d.ts

@@ -1,15 +1,11 @@
-import { Phase } from '../ProjectManagerV2';
 import { BasePackage } from '../BasePackage';
-import { AsyncVoidFunction } from '@nu-art/ts-common';
+import { Phase, PhaseImplementor } from '../phase-runner/types';
 declare const Phase_I: Phase<'install'>;
 declare const Phase_C: Phase<'copyPackageJson'>;
-type PhaseImplementor<P extends Phase<string>> = {
-    [K in P['method']]: AsyncVoidFunction;
-};
-export declare abstract class Package_Python extends BasePackage implements PhaseImplementor<typeof Phase_I> {
+export declare abstract class Package_Python extends BasePackage implements PhaseImplementor<[typeof Phase_I]> {
     install(): Promise<void>;
 }
-declare abstract class Package_Typescript extends BasePackage implements PhaseImplementor<typeof Phase_C> {
+declare abstract class Package_Typescript extends BasePackage implements PhaseImplementor<[typeof Phase_C]> {
     copyPackageJson(): Promise<void>;
 }
 export declare class Package_Root extends Package_Typescript {

package/v2/test/test.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Package_Root = exports.Package_Python = void 0;
-const ProjectManagerV2_1 = require("../ProjectManagerV2");
 const BasePackage_1 = require("../BasePackage");
 const params_1 = require("../../core/params/params");
 const cli_1 = require("@nu-art/commando/core/cli");
+const ProjectManagerV2_1 = require("../ProjectManagerV2");
 const Phase_A = {
     name: 'Compile',
     method: 'compile',
@@ -13,7 +13,7 @@ const Phase_A = {
 const Phase_I = {
     name: 'Compile',
     method: 'install',
-    filter: async () => !params_1.RuntimeParams.install
+    filter: async () => params_1.RuntimeParams.install
 };
 const Phase_C = {
     name: 'Copy Package Json',

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

@@ -0,0 +1,12 @@
+import { Logger } from '@nu-art/ts-common';
+type _Config<Config> = {
+    key: string;
+    label: string;
+} & Config;
+export declare class BaseUnit<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends Logger {
+    readonly config: Readonly<C>;
+    constructor(config: C);
+    protected init(): Promise<void>;
+    private initLogClient;
+}
+export {};

package/v2/unit/core/BaseUnit.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseUnit = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+class BaseUnit extends ts_common_1.Logger {
+    constructor(config) {
+        super(config.key);
+        this.config = Object.freeze(config);
+        this.initLogClient();
+    }
+    async init() {
+        //Inheritor classes should define their own init
+    }
+    //######################### Internal Logic #########################
+    initLogClient() {
+        const logClient = new ts_common_1.LogClient_MemBuffer(this.tag);
+        logClient.setForTerminal();
+        logClient.setComposer((tag, level) => {
+            ts_common_1._logger_finalDate.setTime(Date.now() - ts_common_1._logger_timezoneOffset);
+            const date = ts_common_1._logger_finalDate.toISOString().replace(/T/, '_').replace(/Z/, '').substring(0, 23).split('_')[1];
+            return `${date} ${(0, ts_common_1._logger_getPrefix)(level)}:  `;
+        });
+        logClient.setFilter((level, tag) => {
+            return tag === this.tag;
+        });
+        ts_common_1.BeLogged.addClient(logClient);
+    }
+}
+exports.BaseUnit = BaseUnit;

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

@@ -0,0 +1,5 @@
+import { BaseUnit } from './BaseUnit';
+import { Phase_Install, UnitPhaseImplementor } from './types';
+export declare class Unit_Python extends BaseUnit implements UnitPhaseImplementor<[Phase_Install]> {
+    install(): Promise<void>;
+}

package/v2/unit/core/Unit_Python.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit_Python = void 0;
+const BaseUnit_1 = require("./BaseUnit");
+const cli_1 = require("@nu-art/commando/core/cli");
+class Unit_Python extends BaseUnit_1.BaseUnit {
+    async install() {
+        await cli_1.Commando.create().append('pip install -r requirements.txt').execute();
+    }
+}
+exports.Unit_Python = Unit_Python;

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

@@ -0,0 +1,30 @@
+import { BaseUnit } from './BaseUnit';
+import { Phase_CopyPackageJSON, UnitPhaseImplementor } from './types';
+type PackageJSONTargetKey = 'root' | 'dist' | 'dependency';
+type _Config<Config> = {
+    pathToPackage: string;
+} & Config;
+export declare class Unit_Typescript<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends BaseUnit<C> implements UnitPhaseImplementor<[Phase_CopyPackageJSON]> {
+    private convertTemplatePackageJSON;
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit root
+     * @param template
+     * @private
+     */
+    private convertPJForRoot;
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit dist
+     * @param template
+     * @private
+     */
+    private convertPJForDist;
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit
+     * as it will be in a .dependencies of a deployable unit
+     * @param template
+     * @private
+     */
+    private convertPJForDependency;
+    copyPackageJson(targetKey?: PackageJSONTargetKey): Promise<void>;
+}
+export {};

package/v2/unit/core/Unit_Typescript.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit_Typescript = void 0;
+const BaseUnit_1 = require("./BaseUnit");
+const tools_1 = require("@nu-art/commando/core/tools");
+const consts_1 = require("../../../core/consts");
+const ts_common_1 = require("@nu-art/ts-common");
+const map_project_packages_1 = require("../../../logic/map-project-packages");
+const fs_1 = require("fs");
+const targetKeyPathMap = {
+    'root': '',
+    'dist': '/dist',
+    'dependency': '', //TODO: Fill this in
+};
+class Unit_Typescript extends BaseUnit_1.BaseUnit {
+    //######################### Internal Logic #########################
+    convertTemplatePackageJSON(targetKey, template) {
+        switch (targetKey) {
+            case 'root':
+                return this.convertPJForRoot(template);
+            case 'dist':
+                return this.convertPJForDist(template);
+            case 'dependency':
+                return this.convertPJForDependency(template);
+            default:
+                throw new ts_common_1.ImplementationMissingException(`No implementation for targetKey ${targetKey}`);
+        }
+    }
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit root
+     * @param template
+     * @private
+     */
+    convertPJForRoot(template) {
+        var _a, _b;
+        //Get the package params for replacing in the template package json
+        const params = (_b = (_a = consts_1.MemKey_Packages.get()) === null || _a === void 0 ? void 0 : _a.params) !== null && _b !== void 0 ? _b : {};
+        //Convert template to actual package.json
+        return (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(template, (value, key) => params[key] ? 'workspace:*' : params[value]);
+    }
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit dist
+     * @param template
+     * @private
+     */
+    convertPJForDist(template) {
+        var _a, _b;
+        //Get the package params for replacing in the template package json
+        const params = (_b = (_a = consts_1.MemKey_Packages.get()) === null || _a === void 0 ? void 0 : _a.params) !== null && _b !== void 0 ? _b : {};
+        const converted = this.convertPJForRoot(template);
+        params[converted.name] = converted.version;
+        params[`${converted.name}_path`] = `file:.dependencies/${this.config.key}`; //Not sure about this one
+        //Convert template to actual package.json
+        return (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(template, (value, key) => { var _a; return (_a = params[key]) !== null && _a !== void 0 ? _a : params[value]; });
+    }
+    /**
+     * Converts a template __package.json file into a usable package.json for the unit
+     * as it will be in a .dependencies of a deployable unit
+     * @param template
+     * @private
+     */
+    convertPJForDependency(template) {
+        var _a, _b;
+        //Get the package params for replacing in the template package json
+        const params = (_b = (_a = consts_1.MemKey_Packages.get()) === null || _a === void 0 ? void 0 : _a.params) !== null && _b !== void 0 ? _b : {};
+        const converted = this.convertPJForRoot(template);
+        params[converted.name] = converted.version;
+        params[`${converted.name}_path`] = `file:.dependencies/${this.config.key}`; //Not sure about this one
+        //Convert template to actual package.json
+        return (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(template, (value, key) => { var _a; return (_a = params[key]) !== null && _a !== void 0 ? _a : params[value]; });
+    }
+    //######################### Phase Implementations #########################
+    async copyPackageJson(targetKey = 'root') {
+        //Find paths
+        const unitRootPath = (0, tools_1.convertToFullPath)(this.config.pathToPackage);
+        const templatePath = `${unitRootPath}/${consts_1.CONST_PackageJSONTemplate}`;
+        const targetPath = `${unitRootPath + targetKeyPathMap[targetKey]}/${consts_1.CONST_PackageJSON}`;
+        //Get the template __package.json file
+        const template = JSON.parse(await fs_1.promises.readFile(templatePath, 'utf-8'));
+        //Get converted package.json content
+        const packageJSON = this.convertTemplatePackageJSON(targetKey, template);
+        //Create the package.json file in target location
+        await fs_1.promises.writeFile(targetPath, JSON.stringify(packageJSON, null, 2), { encoding: 'utf-8' });
+    }
+}
+exports.Unit_Typescript = Unit_Typescript;

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

@@ -0,0 +1,11 @@
+import { Unit_Typescript } from './Unit_Typescript';
+import { Phase_Compile, Phase_PreCompile, UnitPhaseImplementor } from './types';
+type _Config<Config> = {
+    customTSConfig?: boolean;
+} & Config;
+export declare class Unit_TypescriptLib<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends Unit_Typescript<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile]> {
+    private resolveTSConfig;
+    preCompile(): Promise<void>;
+    compile(): Promise<void>;
+}
+export {};

package/v2/unit/core/Unit_TypescriptLib.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit_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 basic_1 = require("@nu-art/commando/cli/basic");
+const ts_common_1 = require("@nu-art/ts-common");
+class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
+    //######################### Internal Logic #########################
+    async resolveTSConfig() {
+        const pathToUnitTSConfig = `${this.config.pathToPackage}/src/main/tsconfig.json`;
+        // const pathToProjectTSConfig = '';
+        //If set to use a custom ts config
+        if (this.config.customTSConfig) {
+            //If ts config file does not exist in the main folder
+            if (!fs.existsSync(pathToUnitTSConfig))
+                throw new ts_common_1.BadImplementationException(`Unit ${this.config.label} missing tsconfig.json file in /src/main`);
+            return;
+        }
+        //Copy project ts config file into the unit main folder
+    }
+    //######################### Phase Implementations #########################
+    async preCompile() {
+        if (!fs.existsSync(`${this.config.pathToPackage}/prebuild.sh`))
+            return;
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(this.config.pathToPackage)
+            .append('bash prebuild.sh')
+            .execute();
+    }
+    async compile() {
+        await this.resolveTSConfig();
+    }
+}
+exports.Unit_TypescriptLib = Unit_TypescriptLib;

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

@@ -0,0 +1,5 @@
+import { Unit_Typescript } from './Unit_Typescript';
+import { Phase_Install, UnitPhaseImplementor } from './types';
+export declare class Unit_TypescriptProject extends Unit_Typescript implements UnitPhaseImplementor<[Phase_Install]> {
+    install(): Promise<void>;
+}

package/v2/unit/core/Unit_TypescriptProject.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit_TypescriptProject = void 0;
+const Unit_Typescript_1 = require("./Unit_Typescript");
+class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
+    async install() {
+    }
+}
+exports.Unit_TypescriptProject = Unit_TypescriptProject;

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

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

package/v2/unit/core/index.js

@@ -0,0 +1,20 @@
+"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 __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);

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

@@ -0,0 +1,13 @@
+import { AsyncVoidFunction } from '@nu-art/ts-common';
+import { Phase } from '../../phase-runner/types';
+export type UnitPhaseImplementor<P extends Phase<string>[]> = {
+    [K in P[number]['method']]: AsyncVoidFunction;
+};
+export type Phase_Install = typeof phase_Install;
+export declare const phase_Install: Phase<'install'>;
+export type Phase_CopyPackageJSON = typeof phase_CopyPackageJSON;
+export declare const phase_CopyPackageJSON: Phase<'copyPackageJson'>;
+export type Phase_PreCompile = typeof phase_PreCompile;
+export declare const phase_PreCompile: Phase<'preCompile'>;
+export type Phase_Compile = typeof phase_Compile;
+export declare const phase_Compile: Phase<'compile'>;

package/v2/unit/core/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phase_Compile = exports.phase_PreCompile = exports.phase_CopyPackageJSON = exports.phase_Install = void 0;
+const params_1 = require("../../../core/params/params");
+exports.phase_Install = {
+    name: 'Install',
+    method: 'install',
+    filter: () => params_1.RuntimeParams.install,
+};
+exports.phase_CopyPackageJSON = {
+    name: 'Copy Package JSON',
+    method: 'copyPackageJson',
+};
+exports.phase_PreCompile = {
+    name: 'Pre Compile',
+    method: 'preCompile',
+    filter: () => !params_1.RuntimeParams.noBuild,
+};
+exports.phase_Compile = {
+    name: 'Compile',
+    method: 'compile',
+    filter: () => !params_1.RuntimeParams.noBuild,
+};