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

package/v2/screens/list-screen.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BAI_ListScreen = void 0;
+const ConsoleContainer_1 = require("@nu-art/commando/console/ConsoleContainer");
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
+const ts_common_1 = require("@nu-art/ts-common");
+class BAI_ListScreen extends ConsoleContainer_1.ConsoleContainer {
+    //######################### Lifecycle #########################
+    __onPhaseChange(phase) {
+        this.setState({ currentPhaseName: phase.name });
+    }
+    __onUnitStatusChange(unit) {
+        this.renderUnitList();
+        this.container.screen.render();
+    }
+    /**
+     * Creates an instance of ConsoleScreen.
+     *
+     * @param units - The units this screen should keep track of
+     * @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(units, props, keyBinding = []) {
+        super('screen', { smartCSR: true, title: 'Build and Install' }, [{
+                keys: ['escape', 'q', 'C-c'],
+                callback: async () => {
+                    var _a;
+                    this.logInfo('Kill command received');
+                    await ((_a = this.onKillCB) === null || _a === void 0 ? void 0 : _a.call(this));
+                    this.logInfo('Killed!');
+                    return process.exit(1);
+                }
+            }]);
+        this.unitWidgets = [];
+        this.units = units;
+    }
+    initLogger() {
+        this.logClient = new ts_common_1.LogClient_MemBuffer('log-out.txt');
+        ts_common_1.BeLogged.removeConsole(ts_common_1.LogClient_Terminal);
+        ts_common_1.BeLogged.addClient(this.logClient);
+        this.logClient.setForTerminal();
+        this.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)} ${tag}:  `;
+        });
+        this.logClient.setLogAppendedListener(() => {
+            this.renderLogs();
+        });
+    }
+    //######################### Content Creation #########################
+    create() {
+        if (!this.logClient)
+            this.initLogger();
+        super.create();
+        return this;
+    }
+    createContent() {
+        this.createPhaseWidget();
+        this.createUnitListWidget();
+        this.createLogWidget();
+        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
+        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
+    }
+    createPhaseWidget() {
+        const props = {
+            top: 0,
+            left: 0,
+            height: 3,
+            width: '30%',
+            content: 'phases',
+            border: { type: 'line' },
+            tags: true,
+            styles: {
+                border: { fg: 'blue' },
+                fg: 'blue',
+            },
+            align: 'center',
+        };
+        this.phaseWidget = this.createWidget('text', props);
+    }
+    createUnitListWidget() {
+        const props = {
+            top: 3,
+            left: 0,
+            bottom: 0,
+            width: '30%',
+            border: { type: 'line' },
+            align: 'left',
+            style: {
+                border: { fg: 'blue' },
+            },
+        };
+        this.unitWrapperWidget = this.createWidget('list', props);
+        this.units.forEach((unit, i) => this.createUnitItemWidget(unit, i));
+    }
+    createUnitItemWidget(unit, index) {
+        const containerProps = {
+            top: (this.unitWrapperWidget.top + 1) + index,
+            width: '30%-3',
+            left: 2,
+            height: 1,
+        };
+        const labelProps = {
+            width: '50%',
+            height: '100%',
+            left: 0,
+            align: 'left',
+            style: {
+                fg: 'blue',
+            },
+        };
+        const statusProps = {
+            width: '50%',
+            height: '100%',
+            right: 0,
+            align: 'right',
+            style: {
+                fg: 'blue',
+            },
+        };
+        const containerWidget = this.createWidget('box', containerProps);
+        const labelWidget = this.createWidget('text', labelProps);
+        const statusWidget = this.createWidget('text', statusProps);
+        containerWidget.on('mousedown', () => this.onUnitSelect(unit, index));
+        containerWidget.append(labelWidget);
+        containerWidget.append(statusWidget);
+        this.unitWrapperWidget.pushItem(containerWidget);
+        this.unitWidgets.push([containerWidget, labelWidget, statusWidget]);
+    }
+    createLogWidget() {
+        const props = {
+            top: 0,
+            right: 0,
+            bottom: 0,
+            width: '70%',
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'blue' }
+            },
+            valign: 'top',
+            align: 'left',
+            mouse: true,
+        };
+        this.logWidget = this.createWidget('log', props);
+    }
+    //######################### Render #########################
+    render() {
+        this.renderPhase();
+        this.renderUnitList();
+        this.renderLogs();
+    }
+    renderPhase() {
+        var _a;
+        this.phaseWidget.setContent((_a = this.state.currentPhaseName) !== null && _a !== void 0 ? _a : 'Initializing');
+    }
+    renderUnitList() {
+        this.units.forEach((unit, index) => {
+            var _a;
+            const selected = unit === this.state.selectedUnit;
+            const widgets = this.unitWidgets[index];
+            widgets[1].setText(unit.config.label);
+            widgets[2].setText((_a = unit.getStatus()) !== null && _a !== void 0 ? _a : 'N/A');
+            widgets[1].style.bg = selected ? 'blue' : undefined;
+            widgets[1].style.fg = selected ? 'white' : 'blue';
+            widgets[2].style.bg = selected ? 'blue' : undefined;
+            widgets[2].style.fg = selected ? 'white' : 'blue';
+        });
+    }
+    renderLogs() {
+        const scrollPosition = this.logWidget.getScroll();
+        const content = this.state.selectedUnit ? this.state.selectedUnit.getLogs() : this.logClient.buffers[0];
+        this.logWidget.setContent(content);
+        this.logWidget.setScroll(scrollPosition);
+    }
+    //######################### Kill #########################
+    setKillCB(cb) {
+        this.onKillCB = cb;
+        // Remove all listeners to the process kill event
+        // process.listeners('SIGINT').forEach(listener => process.removeListener('SIGINT', listener));
+        //Register a new listener for process kill event
+        // process.on('SIGINT', async () => {
+        // 	await cb();
+        // 	this.dispose();
+        // 	process.exit(0);
+        // });
+    }
+    //######################### Events #########################
+    onUnitSelect(unit, index) {
+        this.state.selectedUnit = unit === this.state.selectedUnit ? undefined : unit;
+        this.renderUnitList();
+        this.renderLogs();
+        this.container.screen.render();
+    }
+}
+exports.BAI_ListScreen = BAI_ListScreen;

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

@@ -1,15 +1,26 @@
 import { Logger } from '@nu-art/ts-common';
-import { RunnerParamKeys } from '../../phase-runner/types';
-type _Config<Config> = {
+import { RunnerParamKey } from '../../phase-runner/RunnerParams';
+type Config<C> = {
     key: string;
     label: string;
-} & Config;
-export declare class BaseUnit<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends Logger {
+    filter?: () => boolean | Promise<boolean>;
+} & C;
+type RuntimeConfig<C> = {
+    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 {
     readonly config: Readonly<C>;
-    protected getRunnerParam: (runnerParamKey: RunnerParamKeys) => string | undefined;
+    readonly runtime: RTC;
+    private unitStatus?;
+    private logger;
     constructor(config: C);
-    protected init(): Promise<void>;
+    protected init(setInitialized?: boolean): Promise<void>;
+    protected getRunnerParam(key: RunnerParamKey): string | undefined;
     private initLogClient;
-    setGetRunnerParamCaller: (caller: (runnerParamKey: RunnerParamKeys) => string) => void;
+    protected setStatus(status?: string): void;
+    getStatus(): string | undefined;
+    kill(): Promise<void>;
+    getLogs(): string;
 }
 export {};

package/v2/unit/core/BaseUnit.js

@@ -2,31 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseUnit = void 0;
 const ts_common_1 = require("@nu-art/ts-common");
+const RunnerParams_1 = require("../../phase-runner/RunnerParams");
+const PhaseRunnerDispatcher_1 = require("../../phase-runner/PhaseRunnerDispatcher");
 class BaseUnit extends ts_common_1.Logger {
     constructor(config) {
         super(config.key);
-        this.setGetRunnerParamCaller = (caller) => {
-            this.getRunnerParam = caller;
-        };
         this.config = Object.freeze(config);
+        this.runtime = {
+            dependencyName: this.config.key,
+            unitDependencyNames: [],
+        };
         this.initLogClient();
     }
-    async init() {
-        //Inheritor classes should define their own init
+    async init(setInitialized = true) {
+        this.setStatus('Initializing');
+        //Register the unit to PhaseRunnerEvent dispatcher
+        PhaseRunnerDispatcher_1.dispatcher_PhaseChange.addListener(this);
+        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.addListener(this);
+        if (setInitialized)
+            this.setStatus('Initialized');
     }
     //######################### Internal Logic #########################
+    getRunnerParam(key) {
+        return RunnerParams_1.MemKey_RunnerParams.get({})[key];
+    }
     initLogClient() {
-        const logClient = new ts_common_1.LogClient_MemBuffer(this.tag);
-        logClient.setForTerminal();
-        logClient.setComposer((tag, level) => {
+        this.logger = new ts_common_1.LogClient_MemBuffer(this.tag);
+        this.logger.setForTerminal();
+        this.logger.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) => {
+        this.logger.setFilter((level, tag) => {
             return tag === this.tag;
         });
-        ts_common_1.BeLogged.addClient(logClient);
+        ts_common_1.BeLogged.addClient(this.logger);
+    }
+    setStatus(status) {
+        this.unitStatus = status;
+        PhaseRunnerDispatcher_1.dispatcher_UnitStatusChange.dispatch(this);
+    }
+    //######################### Public Functions #########################
+    getStatus() {
+        return this.unitStatus;
+    }
+    async kill() {
+        return;
+    }
+    getLogs() {
+        return this.logger.buffers[0];
     }
 }
 exports.BaseUnit = BaseUnit;

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

@@ -1,5 +1,21 @@
+import { Phase_Install } from '../../phase';
+import { UnitPhaseImplementor } from '../types';
 import { BaseUnit } from './BaseUnit';
-import { Phase_Install, UnitPhaseImplementor } from './types';
-export declare class Unit_Python extends BaseUnit implements UnitPhaseImplementor<[Phase_Install]> {
+import { Commando, CommandoInteractive } from '@nu-art/commando/core/cli';
+import { Cli_Basic } from '@nu-art/commando/cli/basic';
+type _Config<C> = {
+    pathToPackage: string;
+} & C;
+type _RuntimeConfig<RTC> = {
+    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]> {
+    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

@@ -3,9 +3,38 @@ 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");
+const tools_1 = require("@nu-art/commando/core/tools");
+const basic_1 = require("@nu-art/commando/cli/basic");
 class Unit_Python extends BaseUnit_1.BaseUnit {
+    constructor(config) {
+        super(config);
+        this.commando = cli_1.CommandoInteractive.create(basic_1.Cli_Basic);
+    }
+    async init() {
+        await super.init();
+        this.runtime.pathTo = {
+            pkg: (0, tools_1.convertToFullPath)(this.config.pathToPackage),
+        };
+        this.logWarning(`Python Path ${this.runtime.pathTo.pkg}`);
+        await this.initCommando();
+    }
+    //######################### Internal Logic #########################
+    async initCommando() {
+        this.commando
+            .setUID(this.config.key)
+            .cd(this.runtime.pathTo.pkg)
+            .debug();
+        //Install & Enter VENV
+        await this.commando
+            .append('python3 -m venv venv')
+            .append('source venv/bin/activate')
+            .execute();
+        //Set Python Path
+        await this.commando.append('export PYTHONPATH=.').execute();
+    }
+    //######################### Phase Implementation #########################
     async install() {
-        await cli_1.Commando.create().append('pip install -r requirements.txt').execute();
+        await this.commando.append('pip install -r requirements.txt').execute();
     }
 }
 exports.Unit_Python = Unit_Python;

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

@@ -1,15 +1,24 @@
 import { BaseUnit } from './BaseUnit';
-import { Phase_CopyPackageJSON, UnitPhaseImplementor } from './types';
 import { PackageJson } from '../../../core/types';
-declare const PackageJsonTargetKeys: readonly ["root", "dist", "dependency"];
+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<Config> = {
-    pathToPackage: string;
-} & Config;
-export declare class Unit_Typescript<Config extends {} = {}, C extends _Config<Config> = _Config<Config>> extends BaseUnit<C> implements UnitPhaseImplementor<[Phase_CopyPackageJSON]> {
+type _Config<C> = {
+    pathToPackage: RelativePath;
+} & C;
+type RTC_Unit_Typescript<RTC> = {
+    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]> {
     readonly packageJson: {
         [k in PackageJsonTargetKey]: PackageJson;
     };
+    protected init(setInitialized?: boolean): Promise<void>;
+    private loadTemplatePackageJSON;
     /**
      * Create a packageJson object for each target key
      * @private
@@ -34,13 +43,6 @@ export declare class Unit_Typescript<Config extends {} = {}, C extends _Config<C
      * @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(): Promise<void>;
 }
 export {};

package/v2/unit/core/Unit_Typescript.js

@@ -31,27 +31,44 @@ const ts_common_1 = require("@nu-art/ts-common");
 const map_project_packages_1 = require("../../../logic/map-project-packages");
 const fs = __importStar(require("fs"));
 const fs_1 = require("fs");
+const RunnerParams_1 = require("../../phase-runner/RunnerParams");
+const PackageJsonTargetKey_Template = 'template';
 const PackageJsonTargetKey_Root = 'root';
 const PackageJsonTargetKey_Dist = 'dist';
-const PackageJsonTargetKey_Dependency = 'dependency';
-const PackageJsonTargetKeys = [PackageJsonTargetKey_Root, PackageJsonTargetKey_Dist, PackageJsonTargetKey_Dependency];
+const PackageJsonTargetKeys = [PackageJsonTargetKey_Template, PackageJsonTargetKey_Root, PackageJsonTargetKey_Dist];
 class Unit_Typescript extends BaseUnit_1.BaseUnit {
     constructor() {
         super(...arguments);
         this.packageJson = {};
     }
+    async init(setInitialized = true) {
+        var _a;
+        await super.init(false);
+        this.runtime.pathTo = {
+            pkg: (0, tools_1.convertToFullPath)(this.config.pathToPackage),
+        };
+        await this.loadTemplatePackageJSON();
+        this.runtime.dependencyName = this.packageJson.template.name;
+        this.runtime.unitDependencyNames = (0, ts_common_1._keys)((_a = this.packageJson.template.dependencies) !== null && _a !== void 0 ? _a : {});
+        if (setInitialized)
+            this.setStatus('Initialized');
+    }
     //######################### Internal Logic #########################
+    async loadTemplatePackageJSON() {
+        const unitRootPath = this.runtime.pathTo.pkg;
+        const templatePath = `${unitRootPath}/${consts_1.CONST_PackageJSONTemplate}`;
+        if (!fs.existsSync(templatePath))
+            throw new ts_common_1.BadImplementationException(`Missing __package.json file in root for unit ${this.config.label}`);
+        this.packageJson.template = JSON.parse(await fs_1.promises.readFile(templatePath, 'utf-8'));
+    }
     /**
      * Create a packageJson object for each target key
      * @private
      */
     async populatePackageJson() {
-        const unitRootPath = (0, tools_1.convertToFullPath)(this.config.pathToPackage);
-        const templatePath = `${unitRootPath}/${consts_1.CONST_PackageJSONTemplate}`;
-        if (!fs.existsSync(templatePath))
-            throw new ts_common_1.BadImplementationException(`Missing __package.json file in root for unit ${this.config.label}`);
-        const template = JSON.parse(await fs_1.promises.readFile(templatePath, 'utf-8'));
-        PackageJsonTargetKeys.forEach(key => this.packageJson[key] = this.convertTemplatePackageJSON(key, template));
+        if (!this.packageJson.template)
+            await this.loadTemplatePackageJSON();
+        PackageJsonTargetKeys.forEach(key => this.packageJson[key] = this.convertTemplatePackageJSON(key, this.packageJson.template));
     }
     /**
      * Execute template to packageJson object conversion based on target key
@@ -61,12 +78,12 @@ class Unit_Typescript extends BaseUnit_1.BaseUnit {
      */
     convertTemplatePackageJSON(targetKey, template) {
         switch (targetKey) {
+            case PackageJsonTargetKey_Template:
+                return template;
             case PackageJsonTargetKey_Root:
                 return this.convertPJForRoot(template);
             case PackageJsonTargetKey_Dist:
                 return this.convertPJForDist(template);
-            case PackageJsonTargetKey_Dependency:
-                return this.convertPJForDependency(template);
             default:
                 throw new ts_common_1.ImplementationMissingException(`No implementation for targetKey ${targetKey}`);
         }
@@ -77,11 +94,15 @@ class Unit_Typescript extends BaseUnit_1.BaseUnit {
      * @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 : {};
+        const projectConfig = RunnerParams_1.MemKey_ProjectConfig.get();
         //Convert template to actual package.json
-        return (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(template, (value, key) => params[key] ? 'workspace:*' : params[value]);
+        const converted = (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(template, (value, key) => projectConfig.params[key] ? 'workspace:*' : projectConfig.params[value]);
+        //Set dynamic params for this pkg
+        projectConfig.params[converted.name] = converted.version;
+        projectConfig.params[`${converted.name}_path`] = `file:.dependencies/${this.config.key}`; //Not sure about this one
+        RunnerParams_1.MemKey_ProjectConfig.set(projectConfig);
+        return converted;
     }
     /**
      * Converts a template __package.json file into a usable package.json for the unit dist
@@ -89,39 +110,22 @@ class Unit_Typescript extends BaseUnit_1.BaseUnit {
      * @private
      */
     convertPJForDist(template) {
-        var _a, _b, _c;
-        //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 = (_c = this.packageJson[PackageJsonTargetKey_Root]) !== null && _c !== void 0 ? _c : 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, _c;
         //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 = (_c = this.packageJson[PackageJsonTargetKey_Root]) !== null && _c !== void 0 ? _c : this.convertPJForRoot(template);
-        params[converted.name] = converted.version;
-        params[`${converted.name}_path`] = `file:.dependencies/${this.config.key}`; //Not sure about this one
+        const params = RunnerParams_1.MemKey_ProjectConfig.get().params;
         //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() {
+        this.setStatus('Resolving PackageJSON');
         //Populate packageJson objects
         await this.populatePackageJson();
         //Get path
-        const unitRootPath = (0, tools_1.convertToFullPath)(this.config.pathToPackage);
+        const unitRootPath = this.runtime.pathTo.pkg;
+        const targetPath = `${unitRootPath}/${consts_1.CONST_PackageJSON}`;
         //Create the package.json file in target location
-        await fs_1.promises.writeFile(unitRootPath, JSON.stringify(this.packageJson.root, null, 2), { encoding: 'utf-8' });
+        await fs_1.promises.writeFile(targetPath, JSON.stringify(this.packageJson.root, null, 2), { encoding: 'utf-8' });
+        this.setStatus('PackageJSON resolved');
     }
 }
 exports.Unit_Typescript = Unit_Typescript;

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

@@ -1,11 +1,35 @@
 import { Unit_Typescript } from './Unit_Typescript';
-import { Phase_Compile, Phase_PreCompile, UnitPhaseImplementor } from './types';
+import { UnitPhaseImplementor } from '../types';
+import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Purge } from '../../phase';
 type _Config<Config> = {
     customTSConfig?: boolean;
+    output: string;
 } & 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;
+type _RuntimeConfig<RTC> = {
+    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<[
+    Phase_PreCompile,
+    Phase_Compile,
+    Phase_PrintDependencyTree,
+    Phase_CheckCyclicImports,
+    Phase_Purge,
+    Phase_Lint
+]> {
+    protected init(setInitialized?: boolean): Promise<void>;
+    protected resolveTSConfig(): Promise<void>;
+    protected clearOutputDir(): Promise<void>;
+    protected compileImpl(): Promise<void>;
+    protected copyAssetsToOutput(): Promise<void>;
+    protected copyPackageJSONToOutput(): Promise<void>;
     preCompile(): Promise<void>;
     compile(): Promise<void>;
+    purge(): Promise<void>;
+    printDependencyTree(): Promise<void>;
+    checkCyclicImports(): Promise<void>;
+    lint(): Promise<void>;
 }
 export {};