@nu-art/build-and-install 0.204.78 → 0.204.80

package/build-and-install.js

@@ -4,10 +4,13 @@ const ts_common_1 = require("@nu-art/ts-common");
 const params_1 = require("./core/params/params");
 const PhaseRunner_1 = require("./v2/phase-runner/PhaseRunner");
 const thunderstorm_1 = require("./v2/unit/thunderstorm");
+// @ts-ignore
 const BAIScreen_UnitList_1 = require("./v2/screens/BAIScreen_UnitList");
 ts_common_1.DebugFlag.DefaultLogLevel = params_1.RuntimeParams.debug ? ts_common_1.LogLevel.Debug : ts_common_1.LogLevel.Info;
 const runner = new PhaseRunner_1.PhaseRunner('./.config/project-config-v2.ts');
 const screen = new BAIScreen_UnitList_1.BAIScreen_UnitList();
+// const screen = new BAIScreen_Launch();
+// screen.setWithRunningLogs(true);
 screen.setOnKillCallback(async () => await runner.killRunner());
 runner.setScreen(screen);
 if (params_1.RuntimeParams.runWithThunderstorm)

package/package.json

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

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

@@ -25,14 +25,7 @@ export declare class PhaseRunner extends BaseUnit implements UnitPhaseImplemento
     private executeImpl;
     registerUnits(units: BaseUnit | BaseUnit[]): void;
     private getUnitsForPhase;
-    getUnits(): BaseUnit<{}, {}, {
-        key: string;
-        label: string;
-        filter?: (() => boolean | Promise<boolean>) | undefined;
-    }, {
-        dependencyName: string;
-        unitDependencyNames: string[];
-    }>[];
+    getUnits(): BaseUnit<import("../unit/core").BaseUnit_Config, import("../unit/core").BaseUnit_RuntimeConfig>[];
     /**
      * Determines whether to run the phase.</br>
      * returns true if phase ran, false otherwise

package/v2/phase-runner/PhaseRunner.js

@@ -63,6 +63,7 @@ class PhaseRunner extends core_1.BaseUnit {
                 return dependencyKeys.includes(phase.key);
             }
         };
+        this.addToClassStack(PhaseRunner);
         this.phases = [];
         this.units = [this];
         this.project = { path: (0, tools_1.convertToFullPath)(projectPath), config: {} };

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

@@ -16,23 +16,9 @@ export declare const dispatcher_PhaseChange: PhaseRunnerDispatcher<PhaseRunner_O
 export interface PhaseRunner_OnUnitStatusChange {
     __onUnitStatusChange: (data: BaseUnit) => void;
 }
-export declare const dispatcher_UnitStatusChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitStatusChange, "__onUnitStatusChange", [data: BaseUnit<{}, {}, {
-    key: string;
-    label: string;
-    filter?: (() => boolean | Promise<boolean>) | undefined;
-}, {
-    dependencyName: string;
-    unitDependencyNames: string[];
-}>]>;
+export declare const dispatcher_UnitStatusChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitStatusChange, "__onUnitStatusChange", [data: BaseUnit<import("../unit/core").BaseUnit_Config, import("../unit/core").BaseUnit_RuntimeConfig>]>;
 export interface PhaseRunner_OnUnitsChange {
     __onUnitsChange: (data: BaseUnit[]) => void;
 }
-export declare const dispatcher_UnitChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitsChange, "__onUnitsChange", [data: BaseUnit<{}, {}, {
-    key: string;
-    label: string;
-    filter?: (() => boolean | Promise<boolean>) | undefined;
-}, {
-    dependencyName: string;
-    unitDependencyNames: string[];
-}>[]]>;
+export declare const dispatcher_UnitChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitsChange, "__onUnitsChange", [data: BaseUnit<import("../unit/core").BaseUnit_Config, import("../unit/core").BaseUnit_RuntimeConfig>[]]>;
 export {};

package/v2/phase-runner/PhaseRunnerDispatcher.js

@@ -9,6 +9,8 @@ class PhaseRunnerDispatcher {
     }
     //######################### Listeners Logic #########################
     addListener(listener) {
+        if (this.listeners.includes(listener))
+            return;
         this.listeners.push(listener);
     }
     removeListener(listener) {

package/v2/screens/BAIScreen.d.ts

@@ -9,7 +9,7 @@ export declare abstract class BAIScreen<State extends {} = {}> extends ConsoleCo
      * @param {Widgets.IScreenOptions} [props] - The properties to apply to the screen widget.
      * @param {ScreenKeyBinding[]} [keyBinding] - An array of key bindings for the screen widget.
      */
-    constructor();
+    constructor(logClientKey: string);
     private createLogClient;
     startLogClient: () => void;
     stopLogClient: () => void;

package/v2/screens/BAIScreen.js

@@ -11,7 +11,7 @@ class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
      * @param {Widgets.IScreenOptions} [props] - The properties to apply to the screen widget.
      * @param {ScreenKeyBinding[]} [keyBinding] - An array of key bindings for the screen widget.
      */
-    constructor() {
+    constructor(logClientKey) {
         super('screen', { smartCSR: true, title: 'Build and Install' }, [{
                 keys: ['escape', 'q', 'C-c'],
                 callback: async () => await this.onKill(),
@@ -28,11 +28,11 @@ class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
         };
         this.getLogs = () => this.logClient.buffers[0];
         this.setOnKillCallback = (cb) => this.onKillCallback = cb;
-        this.createLogClient();
+        this.createLogClient(logClientKey);
     }
-    createLogClient() {
+    createLogClient(logClientKey) {
         //Create the log client
-        this.logClient = new ts_common_1.LogClient_MemBuffer('log-out.txt');
+        this.logClient = new ts_common_1.LogClient_MemBuffer(`${logClientKey}.txt`);
         //Set for terminal flag
         this.logClient.setForTerminal();
         //Set log composer to print logs with timestamps

package/v2/screens/BAIScreen_Launch.d.ts

@@ -0,0 +1,21 @@
+import { BAIScreen } from './BAIScreen';
+import { BaseUnit } from '../unit/core';
+import { PhaseRunner_OnUnitsChange } from '../phase-runner/PhaseRunnerDispatcher';
+export declare class BAIScreen_Launch extends BAIScreen implements PhaseRunner_OnUnitsChange {
+    private units;
+    private gridDimensions;
+    private withRunningLogs;
+    private gridCellWidgets;
+    constructor();
+    __onUnitsChange: (data: BaseUnit[]) => void;
+    protected onLogUpdated: () => void;
+    private updateUnits;
+    protected createContent(): void;
+    private createGridWidgets;
+    private calculateGridDimensions;
+    private getGridWidgetLabel;
+    protected render(): void;
+    private getContentForWidget;
+    private renderGridWidgets;
+    setWithRunningLogs: (val: boolean) => boolean;
+}

package/v2/screens/BAIScreen_Launch.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BAIScreen_Launch = void 0;
+const BAIScreen_1 = require("./BAIScreen");
+const consts_1 = require("../phase-runner/consts");
+const firebase_units_1 = require("../unit/firebase-units");
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
+class BAIScreen_Launch extends BAIScreen_1.BAIScreen {
+    //######################### Lifecycle #########################
+    constructor() {
+        super('bai-launch');
+        //######################### Properties #########################
+        this.units = [];
+        this.gridDimensions = [[{ width: 1, height: 1 }]];
+        this.withRunningLogs = false;
+        //Widgets
+        this.gridCellWidgets = [];
+        this.__onUnitsChange = (data) => {
+            this.updateUnits();
+            this.createGridWidgets();
+            this.renderGridWidgets();
+            this.container.screen.render();
+        };
+        this.onLogUpdated = () => {
+            this.renderGridWidgets();
+        };
+        this.updateUnits = () => {
+            const runner = consts_1.MemKey_PhaseRunner.get();
+            this.units = runner.getUnits().filter(unit => {
+                return unit.isInstanceOf(firebase_units_1.Unit_FirebaseHostingApp) || unit.isInstanceOf(firebase_units_1.Unit_FirebaseFunctionsApp);
+            });
+        };
+        this.createGridWidgets = () => {
+            this.gridCellWidgets.forEach(widget => widget.destroy());
+            this.calculateGridDimensions();
+            let xPos = 0;
+            let widgetIndex = 0;
+            this.gridDimensions.forEach((col) => {
+                let yPos = 0;
+                col.forEach((cell) => {
+                    const height = cell.height * 100;
+                    const width = cell.width * 100;
+                    const props = {
+                        top: `${yPos}%`,
+                        left: `${xPos}%`,
+                        width: `${width}%`,
+                        height: `${height}%`,
+                        label: this.getGridWidgetLabel(widgetIndex),
+                        border: { type: 'line' },
+                        style: {
+                            border: { fg: 'blue' },
+                        },
+                        valign: 'top',
+                        align: 'left',
+                        mouse: true,
+                    };
+                    this.gridCellWidgets.push(this.createWidget('log', props));
+                    yPos += height; //Assuming all cells in a column have the same height
+                    widgetIndex++;
+                });
+                xPos += col[0].width * 100; //Assuming all Cells have the same width
+            });
+        };
+        this.calculateGridDimensions = () => {
+            let n = this.units.length;
+            //Add 1 more window for running logs
+            if (this.withRunningLogs)
+                n++;
+            const grid = [];
+            const columns = Math.ceil(Math.sqrt(n)); // Calculate number of columns
+            let remainingItems = n;
+            for (let col = 0; col < columns; col++) {
+                const column = [];
+                const itemsInThisColumn = Math.ceil(remainingItems / (columns - col));
+                const height = 1 / itemsInThisColumn;
+                for (let row = 0; row < itemsInThisColumn; row++) {
+                    column.push({ width: 1 / columns, height });
+                }
+                grid.push(column);
+                remainingItems -= itemsInThisColumn;
+            }
+            this.gridDimensions = grid;
+        };
+        this.getGridWidgetLabel = (index) => {
+            if (!this.withRunningLogs)
+                return this.units[index].config.label;
+            return index === this.units.length ? 'Running Logs' : this.units[index].config.label;
+        };
+        this.getContentForWidget = (widgetIndex) => {
+            var _a, _b;
+            if (!this.withRunningLogs) {
+                const unit = this.units[widgetIndex];
+                return (_a = unit.getLogs()) !== null && _a !== void 0 ? _a : `No logs for unit ${unit.config.label}`;
+            }
+            //With running logs, last index should return the running logs
+            if (widgetIndex === this.units.length)
+                return this.getLogs();
+            const unit = this.units[widgetIndex];
+            return (_b = unit.getLogs()) !== null && _b !== void 0 ? _b : `No logs for unit ${unit.config.label}`;
+        };
+        this.renderGridWidgets = () => {
+            this.gridCellWidgets.forEach((widget, index) => {
+                const scrollPosition = widget.getScroll();
+                const content = this.getContentForWidget(index);
+                widget.setContent(content);
+                widget.setScroll(scrollPosition);
+            });
+        };
+        //######################### Options #########################
+        this.setWithRunningLogs = (val) => this.withRunningLogs = val;
+    }
+    //######################### Content Creation #########################
+    createContent() {
+        this.updateUnits();
+        this.createGridWidgets();
+        //Start listening on dispatchers
+        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
+        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
+        PhaseRunnerDispatcher_1.dispatcher_UnitChange.addListener(this);
+        //Start the log client
+        this.startLogClient();
+    }
+    //######################### Render #########################
+    render() {
+        this.renderGridWidgets();
+        this.logInfo('GRID DIMENSIONS', this.gridDimensions);
+        this.logInfo('UNITS', this.units.map(unit => unit.config.label));
+        this.logInfo('RUNNER UNITS', consts_1.MemKey_PhaseRunner.get().getUnits().map(unit => unit.config.label));
+    }
+}
+exports.BAIScreen_Launch = BAIScreen_Launch;

package/v2/screens/BAIScreen_UnitList.d.ts

@@ -8,10 +8,11 @@ type State = {
 };
 export declare class BAIScreen_UnitList extends BAIScreen<State> implements PhaseRunner_OnPhaseChange, PhaseRunner_OnUnitStatusChange, PhaseRunner_OnUnitsChange {
     private units;
-    private unitWrapperWidget;
-    private unitWidgets;
     private logWidget;
     private phaseWidget;
+    private unitWrapperWidget;
+    private unitWidgets;
+    constructor();
     __onPhaseChange(phase: Phase<string>): void;
     __onUnitStatusChange(unit: BaseUnit): void;
     __onUnitsChange(data: BaseUnit[]): void;

package/v2/screens/BAIScreen_UnitList.js

@@ -5,15 +5,16 @@ const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher")
 const BAIScreen_1 = require("./BAIScreen");
 const consts_1 = require("../phase-runner/consts");
 class BAIScreen_UnitList extends BAIScreen_1.BAIScreen {
+    //######################### Lifecycle #########################
     constructor() {
-        super(...arguments);
+        super('bai-unit-list');
+        //######################### Properties #########################
         this.units = [];
         this.unitWidgets = [];
         this.onLogUpdated = () => {
             this.renderLogs();
         };
     }
-    //######################### Lifecycle #########################
     __onPhaseChange(phase) {
         this.setState({ currentPhaseName: phase.name });
     }

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

@@ -1,26 +1,28 @@
 import { Logger } from '@nu-art/ts-common';
 import { RunnerParamKey } from '../../phase-runner/RunnerParams';
-type Config<C> = {
+export type BaseUnit_Config = {
     key: string;
     label: string;
     filter?: () => boolean | Promise<boolean>;
-} & C;
-type RuntimeConfig<C> = {
+};
+export type BaseUnit_RuntimeConfig = {
     dependencyName: string;
     unitDependencyNames: string[];
-} & C;
-export declare class BaseUnit<_Config extends {} = {}, _RuntimeConfig extends {} = {}, C extends Config<_Config> = Config<_Config>, RTC extends RuntimeConfig<_RuntimeConfig> = RuntimeConfig<_RuntimeConfig>> extends Logger {
+};
+export declare class BaseUnit<C extends BaseUnit_Config = BaseUnit_Config, RTC extends BaseUnit_RuntimeConfig = BaseUnit_RuntimeConfig> extends Logger {
     readonly config: Readonly<C>;
     readonly runtime: RTC;
     private unitStatus?;
     private logger;
+    private classStack;
     constructor(config: C);
     protected init(setInitialized?: boolean): Promise<void>;
     protected getRunnerParam(key: RunnerParamKey): string | undefined;
     private initLogClient;
     protected setStatus(status?: string): void;
+    protected addToClassStack: (cls: Function) => void;
+    isInstanceOf: (cls: Function) => boolean;
     getStatus(): string | undefined;
     kill(): Promise<void>;
     getLogs(): string;
 }
-export {};

package/v2/unit/core/BaseUnit.js

@@ -7,11 +7,20 @@ const PhaseRunnerDispatcher_1 = require("../../phase-runner/PhaseRunnerDispatche
 class BaseUnit extends ts_common_1.Logger {
     constructor(config) {
         super(config.key);
+        //######################### Class Stack Logic #########################
+        this.addToClassStack = (cls) => {
+            this.classStack.add(cls.name);
+        };
+        this.isInstanceOf = (cls) => {
+            return this.classStack.has(cls.name);
+        };
         this.config = Object.freeze(config);
         this.runtime = {
             dependencyName: this.config.key,
             unitDependencyNames: [],
         };
+        this.classStack = new Set();
+        this.addToClassStack(BaseUnit);
         this.initLogClient();
     }
     async init(setInitialized = true) {

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

@@ -1,21 +1,20 @@
 import { Phase_Install } from '../../phase';
 import { UnitPhaseImplementor } from '../types';
-import { BaseUnit } from './BaseUnit';
+import { BaseUnit, BaseUnit_Config, BaseUnit_RuntimeConfig } from './BaseUnit';
 import { Commando, CommandoInteractive } from '@nu-art/commando/core/cli';
 import { Cli_Basic } from '@nu-art/commando/cli/basic';
-type _Config<C> = {
+export type Unit_Python_Config = BaseUnit_Config & {
     pathToPackage: string;
-} & C;
-type _RuntimeConfig<RTC> = {
+};
+export type Unit_Python_RuntimeConfig = BaseUnit_RuntimeConfig & {
     pathTo: {
         pkg: string;
     };
-} & RTC;
-export declare class Unit_Python<Config extends {} = {}, RuntimeConfig extends {} = {}, C extends _Config<Config> = _Config<Config>, RTC extends _RuntimeConfig<RuntimeConfig> = _RuntimeConfig<RuntimeConfig>> extends BaseUnit<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
+};
+export declare class Unit_Python<C extends Unit_Python_Config = Unit_Python_Config, RTC extends Unit_Python_RuntimeConfig = Unit_Python_RuntimeConfig> extends BaseUnit<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
     protected commando: CommandoInteractive & Commando & Cli_Basic;
     constructor(config: Unit_Python<C, RTC>['config']);
     protected init(): Promise<void>;
     private initCommando;
     install(): Promise<void>;
 }
-export {};

package/v2/unit/core/Unit_Python.js

@@ -8,6 +8,7 @@ const basic_1 = require("@nu-art/commando/cli/basic");
 class Unit_Python extends BaseUnit_1.BaseUnit {
     constructor(config) {
         super(config);
+        this.addToClassStack(Unit_Python);
         this.commando = cli_1.CommandoInteractive.create(basic_1.Cli_Basic);
     }
     async init() {

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

@@ -1,22 +1,23 @@
-import { BaseUnit } from './BaseUnit';
+import { BaseUnit, BaseUnit_Config, BaseUnit_RuntimeConfig } from './BaseUnit';
 import { PackageJson } from '../../../core/types';
 import { AbsolutePath, RelativePath } from '@nu-art/ts-common';
 import { Phase_CopyPackageJSON } from '../../phase';
 import { UnitPhaseImplementor } from '../types';
 declare const PackageJsonTargetKeys: readonly ["template", "root", "dist"];
 type PackageJsonTargetKey = typeof PackageJsonTargetKeys[number];
-type _Config<C> = {
+export type Unit_Typescript_Config = BaseUnit_Config & {
     pathToPackage: RelativePath;
-} & C;
-type RTC_Unit_Typescript<RTC> = {
+};
+export type Unit_Typescript_RuntimeConfig = BaseUnit_RuntimeConfig & {
     pathTo: {
         pkg: AbsolutePath;
     };
-} & RTC;
-export declare class Unit_Typescript<Config extends {} = {}, RuntimeConfig extends {} = {}, C extends _Config<Config> = _Config<Config>, RTC extends RTC_Unit_Typescript<RuntimeConfig> = RTC_Unit_Typescript<RuntimeConfig>> extends BaseUnit<C, RTC> implements UnitPhaseImplementor<[Phase_CopyPackageJSON]> {
+};
+export declare class Unit_Typescript<C extends Unit_Typescript_Config = Unit_Typescript_Config, RTC extends Unit_Typescript_RuntimeConfig = Unit_Typescript_RuntimeConfig> extends BaseUnit<C, RTC> implements UnitPhaseImplementor<[Phase_CopyPackageJSON]> {
     readonly packageJson: {
         [k in PackageJsonTargetKey]: PackageJson;
     };
+    constructor(config: C);
     protected init(setInitialized?: boolean): Promise<void>;
     private loadTemplatePackageJSON;
     /**

package/v2/unit/core/Unit_Typescript.js

@@ -37,9 +37,10 @@ const PackageJsonTargetKey_Root = 'root';
 const PackageJsonTargetKey_Dist = 'dist';
 const PackageJsonTargetKeys = [PackageJsonTargetKey_Template, PackageJsonTargetKey_Root, PackageJsonTargetKey_Dist];
 class Unit_Typescript extends BaseUnit_1.BaseUnit {
-    constructor() {
-        super(...arguments);
+    constructor(config) {
+        super(config);
         this.packageJson = {};
+        this.addToClassStack(Unit_Typescript);
     }
     async init(setInitialized = true) {
         var _a;
@@ -112,6 +113,12 @@ class Unit_Typescript extends BaseUnit_1.BaseUnit {
     convertPJForDist(template) {
         //Get the package params for replacing in the template package json
         const params = RunnerParams_1.MemKey_ProjectConfig.get().params;
+        //if main prop exists on pkg json clear the dist from its ref
+        if (template.main)
+            template.main = template.main.replace('dist/', '');
+        //if types prop exists on pkg json clear the dist from its ref
+        if (template.types)
+            template.types = template.types.replace('dist/', '');
         //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]; });
     }

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

@@ -1,17 +1,17 @@
-import { Unit_Typescript } from './Unit_Typescript';
+import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
 import { UnitPhaseImplementor } from '../types';
 import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Purge } from '../../phase';
-type _Config<Config> = {
+export type Unit_TypescriptLib_Config = Unit_Typescript_Config & {
     customTSConfig?: boolean;
     output: string;
-} & Config;
-type _RuntimeConfig<RTC> = {
+};
+export type Unit_TypescriptLib_RuntimeConfig = Unit_Typescript_RuntimeConfig & {
     pathTo: {
         pkg: string;
         output: string;
     };
-} & RTC;
-export declare class Unit_TypescriptLib<Config extends {} = {}, RuntimeConfig extends {} = {}, C extends _Config<Config> = _Config<Config>, RTC extends _RuntimeConfig<RuntimeConfig> = _RuntimeConfig<RuntimeConfig>> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[
+};
+export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config, RTC extends Unit_TypescriptLib_RuntimeConfig = Unit_TypescriptLib_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[
     Phase_PreCompile,
     Phase_Compile,
     Phase_PrintDependencyTree,
@@ -19,6 +19,7 @@ export declare class Unit_TypescriptLib<Config extends {} = {}, RuntimeConfig ex
     Phase_Purge,
     Phase_Lint
 ]> {
+    constructor(config: Unit_TypescriptLib<C, RTC>['config']);
     protected init(setInitialized?: boolean): Promise<void>;
     protected resolveTSConfig(): Promise<void>;
     protected clearOutputDir(): Promise<void>;
@@ -32,4 +33,3 @@ export declare class Unit_TypescriptLib<Config extends {} = {}, RuntimeConfig ex
     checkCyclicImports(): Promise<void>;
     lint(): Promise<void>;
 }
-export {};

package/v2/unit/core/Unit_TypescriptLib.js

@@ -46,6 +46,10 @@ const assetExtensions = [
     '_ts'
 ];
 class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
+    constructor(config) {
+        super(config);
+        this.addToClassStack(Unit_TypescriptLib);
+    }
     async init(setInitialized = true) {
         await super.init(false);
         this.runtime.pathTo.output = this.runtime.pathTo.pkg + `/${this.config.output}`;

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

@@ -1,12 +1,13 @@
 import { UnitPhaseImplementor } from '../types';
-import { Unit_Typescript } from './Unit_Typescript';
+import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
 import { Phase_Install } from '../../phase';
 import { StringMap } from '@nu-art/ts-common/utils/types';
-type _Config<Config> = {
+type Unit_TypescriptProject_Config = Unit_Typescript_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]> {
+};
+type Unit_TypescriptProject_RuntimeConfig = Unit_Typescript_RuntimeConfig & {};
+export declare class Unit_TypescriptProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config, RTC extends Unit_TypescriptProject_RuntimeConfig = Unit_TypescriptProject_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
+    constructor(config: Unit_TypescriptProject<C>['config']);
     private installGlobals;
     private installPackages;
     install(): Promise<void>;

package/v2/unit/core/Unit_TypescriptProject.js

@@ -8,6 +8,10 @@ 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 {
+    constructor(config) {
+        super(config);
+        this.addToClassStack(Unit_TypescriptProject);
+    }
     //######################### Internal Logic #########################
     async installGlobals() {
         if ((!params_1.RuntimeParams.install && !params_1.RuntimeParams.installGlobals) || !this.config.globalPackages)

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

@@ -1,12 +1,12 @@
-import { Unit_TypescriptLib } from '../core';
+import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
 import { UnitPhaseImplementor } from '../types';
 import { Phase_DeployBackend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
 import { FirebasePackageConfig } from '../../../core/types';
-type _Config<Config> = {
+export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_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]> {
+};
+export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_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;
@@ -14,6 +14,7 @@ export declare class Unit_FirebaseFunctionsApp<Config extends {} = {}, C extends
     private readonly EMULATOR_KILL_LOG;
     private launchCommandos;
     private listeners;
+    constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
     resolveConfigs(): Promise<void>;
     compile(): Promise<void>;
     launch(): Promise<void>;
@@ -37,4 +38,3 @@ export declare class Unit_FirebaseFunctionsApp<Config extends {} = {}, C extends
     private printFiles;
     private deployImpl;
 }
-export {};

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

@@ -14,12 +14,13 @@ 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);
+    constructor(config) {
+        super(config);
         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.addToClassStack(Unit_FirebaseFunctionsApp);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {
@@ -198,7 +199,7 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
             return;
         const packageJsonConverter = (pj) => {
             var _a;
-            const finalPJ = (0, ts_common_1.deepClone)(this.packageJson.dist);
+            const finalPJ = (0, ts_common_1.deepClone)(pj);
             (_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);

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

@@ -1,16 +1,17 @@
-import { Unit_TypescriptLib } from '../core';
+import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
 import { FirebasePackageConfig } from '../../../core/types';
 import { UnitPhaseImplementor } from '../types';
 import { Phase_DeployFrontend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
-type _Config<Config> = {
+export type Unit_FirebaseHostingApp_Config = Unit_TypescriptLib_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]> {
+};
+export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_Config = Unit_FirebaseHostingApp_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;
+    constructor(config: Unit_FirebaseHostingApp<C>['config']);
     resolveConfigs(): Promise<void>;
     compile(): Promise<void>;
     launch(): Promise<void>;
@@ -29,4 +30,3 @@ export declare class Unit_FirebaseHostingApp<Config extends {} = {}, C extends _
     kill(): Promise<void>;
     private deployImpl;
 }
-export {};

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

@@ -13,10 +13,11 @@ const RunnerParams_1 = require("../../phase-runner/RunnerParams");
 const cli_1 = require("@nu-art/commando/core/cli");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
-    constructor() {
-        super(...arguments);
+    constructor(config) {
+        super(config);
         this.APP_PID_LOG = '_APP_PID_';
         this.APP_KILL_LOG = '_APP_KILLED_';
+        this.addToClassStack(Unit_FirebaseHostingApp);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {

package/v2/unit/thunderstorm.d.ts

@@ -1,291 +1,171 @@
 import { BaseUnit, Unit_TypescriptLib } from './core';
 import { RelativePath } from '@nu-art/ts-common';
-export declare const Unit_TSCommon: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+export declare const Unit_TSCommon: Unit_TypescriptLib<{
+    key: "ts-common";
+    label: "TS/ts-common";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_TSStyles: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_TSStyles: Unit_TypescriptLib<{
+    key: "ts-styles";
+    label: "TS/ts-styles";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_GoogleServices: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_GoogleServices: Unit_TypescriptLib<{
+    key: "google-services";
+    label: "TS/google-services";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Commando: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Commando: Unit_TypescriptLib<{
+    key: "commando";
+    label: "TS/commando";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_BAI: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_BAI: Unit_TypescriptLib<{
+    key: "build-and-install";
+    label: "TS/build-and-install";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Firebase: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Firebase: Unit_TypescriptLib<{
+    key: "firebase";
+    label: "TS/firebase";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Thunderstorm: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Thunderstorm: Unit_TypescriptLib<{
+    key: "thunderstorm";
+    label: "TS/thunderstorm";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_TSPDF: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_TSPDF: Unit_TypescriptLib<{
+    key: "ts-pdf";
+    label: "TS/ts-pdf";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Slack: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Slack: Unit_TypescriptLib<{
+    key: "slack";
+    label: "TS/slack";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_LiveDocs: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_LiveDocs: Unit_TypescriptLib<{
+    key: "live-docs";
+    label: "TS/live-docs";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_UserAccount: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_UserAccount: Unit_TypescriptLib<{
+    key: "user-account";
+    label: "TS/user-account";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Permissions: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Permissions: Unit_TypescriptLib<{
+    key: "permissions";
+    label: "TS/permissions";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_TSShortUrl: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_TSShortUrl: Unit_TypescriptLib<{
+    key: "ts-short-url";
+    label: "TS/short-url";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_DependencyViewer: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_DependencyViewer: Unit_TypescriptLib<{
+    key: "ts-dependency-viewer";
+    label: "TS/dependency-viewer";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_FocusedObject: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_FocusedObject: Unit_TypescriptLib<{
+    key: "ts-focused-object";
+    label: "TS/focused-object";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Messaging: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Messaging: Unit_TypescriptLib<{
+    key: "ts-messaging";
+    label: "TS/messaging";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Workspace: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Workspace: Unit_TypescriptLib<{
+    key: "ts-workspace";
+    label: "TS/workspace";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_PushPubSub: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_PushPubSub: Unit_TypescriptLib<{
+    key: "push-pub-sub";
+    label: "TS/push-pub-sub";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Jira: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Jira: Unit_TypescriptLib<{
+    key: "jira";
+    label: "TS/jira";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_BugReport: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_BugReport: Unit_TypescriptLib<{
+    key: "bug-report";
+    label: "TS/bug-report";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_Github: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_Github: Unit_TypescriptLib<{
+    key: "github";
+    label: "TS/github";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_FileUpload: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_FileUpload: Unit_TypescriptLib<{
+    key: "file-upload";
+    label: "TS/file-upload";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_TSOpenAI: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_TSOpenAI: Unit_TypescriptLib<{
+    key: "ts-openai";
+    label: "TS/openai";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
-export declare const Unit_SchemaToTypes: Unit_TypescriptLib<{}, {}, {
-    key: string;
-    label: string;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
+export declare const Unit_SchemaToTypes: Unit_TypescriptLib<{
+    key: "schema-to-types";
+    label: "TS/schema-to-types";
     pathToPackage: RelativePath;
-    output: string;
+    output: "dist";
     filter: () => NonNullable<boolean | undefined>;
-}, {
-    pathTo: {
-        pkg: string;
-        output: string;
-    };
-}>;
+}, import("./core").Unit_TypescriptLib_RuntimeConfig>;
 export declare const allTSUnits: BaseUnit[];