@nu-art/build-and-install 0.401.0 → 0.401.1

package/v3/units/ProjectUnit.d.ts

@@ -1,18 +0,0 @@
-import { StringMap } from '@nu-art/ts-common';
-import { BaseUnit, BaseUnit_Config, UnitRuntimeContext } from './BaseUnit.js';
-export type Config_ProjectUnit = BaseUnit_Config & {
-    relativePath: string;
-    fullPath: string;
-    dependencies: StringMap;
-};
-export type ProjectUnit_RuntimeContext = UnitRuntimeContext & {
-    parentUnit: ProjectUnit<any>;
-    childUnits: ProjectUnit[];
-};
-/**
- * Abstract class representing a Unit within a Project.
- * Extends the BaseUnit to provide additional project-specific preparation logic.
- */
-export declare abstract class ProjectUnit<C extends Config_ProjectUnit = Config_ProjectUnit> extends BaseUnit<C, ProjectUnit_RuntimeContext> {
-    constructor(config: C);
-}

package/v3/units/ProjectUnit.js

@@ -1,11 +0,0 @@
-import { BaseUnit } from './BaseUnit.js';
-/**
- * Abstract class representing a Unit within a Project.
- * Extends the BaseUnit to provide additional project-specific preparation logic.
- */
-export class ProjectUnit extends BaseUnit {
-    constructor(config) {
-        super(config);
-        this.addToClassStack(ProjectUnit);
-    }
-}

package/v3/units/Unit_NodeProject.d.ts

@@ -1,30 +0,0 @@
-import { UnitPhaseImplementor } from '../core/types.js';
-import { StringMap } from '@nu-art/ts-common/utils/types';
-import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
-import { ProjectUnit } from './ProjectUnit.js';
-import { Phase_Install, Phase_PostPublish, Phase_Watch } from '../phase/index.js';
-type Unit_TypescriptProject_Config = Unit_PackageJson_Config & {
-    globalPackages?: StringMap;
-    isRoot: true;
-};
-export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch, Phase_PostPublish]> {
-    private watcher?;
-    readonly innerUnits: Unit_PackageJson[];
-    private readonly suffixesToWatch;
-    constructor(config: Unit_NodeProject<C>['config']);
-    protected deriveDistDependencies(): StringMap;
-    assignUnit(units: ProjectUnit[]): void;
-    /**
-     * Resolve all paths to watch in all project libs
-     * @private
-     * @returns string[]
-     */
-    private prepareWatchPaths;
-    stopWatch(): Promise<void | undefined>;
-    private findUnit;
-    install(): Promise<void>;
-    watch(timeout?: number, maxTimeout?: number): Promise<void>;
-    purge(): Promise<void>;
-    postPublish(): Promise<void>;
-}
-export {};

package/v3/units/Unit_PackageJson.d.ts

@@ -1,17 +0,0 @@
-import { StringMap } from '@nu-art/ts-common';
-import { UnitPhaseImplementor } from '../core/types.js';
-import { Config_ProjectUnit, ProjectUnit } from './ProjectUnit.js';
-import { TS_PackageJSON } from '../UnitsMapper/types.js';
-import { Phase_Prepare, Phase_Purge } from '../phase/index.js';
-export type Unit_PackageJson_Config = Config_ProjectUnit & {
-    packageJson: TS_PackageJSON;
-};
-export declare class Unit_PackageJson<C extends Unit_PackageJson_Config = Unit_PackageJson_Config> extends ProjectUnit<C> implements UnitPhaseImplementor<[Phase_Purge, Phase_Prepare]> {
-    constructor(config: C);
-    protected npmCommand(command: string): string;
-    protected deriveDistDependencies(): StringMap;
-    protected deriveLibDependencies(): StringMap;
-    prepare(): Promise<void>;
-    purge(): Promise<void>;
-    protected releasePorts(allPorts: string[]): Promise<void>;
-}

package/v3/units/firebase/Unit_FirebaseFunctionsApp.d.ts

@@ -1,64 +0,0 @@
-import { UnitPhaseImplementor } from '../../core/types.js';
-import { FirebasePackageConfig } from '../../../core/types/index.js';
-import { StringMap } from '@nu-art/ts-common';
-import { Phase_Deploy, Phase_Launch } from '../../phase/index.js';
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
-export declare const firebaseFunctionEmulator_ErrorStrings: string[];
-export declare const firebaseFunctionEmulator_WarningStrings: string[];
-type EnvConfig = {
-    defaultConfig?: string;
-    envConfig?: string;
-    projectId: string;
-    isLocal?: boolean;
-    identityAccount?: string;
-};
-export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
-    firebaseConfig?: FirebasePackageConfig;
-    pathToFirebaseConfig: string;
-    envConfig: EnvConfig;
-    ignore?: string[];
-    debugPort: number;
-    basePort: number;
-    sslKey: string;
-    sslCert: string;
-    pathToEmulatorData: string;
-    sources?: string[];
-};
-export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy]> {
-    functions: StringMap;
-    static staggerCount: number;
-    static DefaultConfig_FirebaseFunction: {
-        pathToFirebaseConfig: string;
-        debugPort: number;
-        basePort: number;
-        sslKey: string;
-        sslCert: string;
-        output: string;
-        pathToEmulatorData: string;
-    };
-    readonly emulatorLogStrings: {
-        error: string[];
-        warning: string[];
-    };
-    constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
-    protected copyPackageJSONToOutput(): Promise<void>;
-    prepare(): Promise<void>;
-    resolveConfigs(): Promise<void>;
-    compile(): Promise<void>;
-    postCompile(): Promise<void>;
-    launch(): Promise<void>;
-    releaseEmulatorPorts(): Promise<void>;
-    deploy(): Promise<void>;
-    private resolveFunctionsRC;
-    private resolveProxyFile;
-    private pathToProxy;
-    private resolveConfigDir;
-    private resolveFunctionsJSON;
-    private resolveFunctionsRuntimeConfig;
-    private createAppVersionFile;
-    protected deriveDistDependencies(): StringMap;
-    private createDependenciesDir;
-    private runProxy;
-    private runEmulator;
-}
-export {};

package/v3/units/firebase/Unit_FirebaseFunctionsApp.js

@@ -1,306 +0,0 @@
-import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_PackageJSON, CONST_VersionApp } from '../../../core/consts.js';
-import { __stringify, _keys, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, Second, sleep } from '@nu-art/ts-common';
-import { Const_FirebaseConfigKeys, Const_FirebaseDefaultsKeyToFile } from '../../../defaults/consts.js';
-import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
-import { resolve } from 'path';
-import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
-import { Unit_TypescriptLib } from '../Unit_TypescriptLib.js';
-import { CommandoException } from '@nu-art/commando/shell/core/CliError';
-import { deployLogFilter } from './common.js';
-export const firebaseFunctionEmulator_ErrorStrings = [
-    'functions: Failed',
-];
-export const firebaseFunctionEmulator_WarningStrings = [
-    '⚠',
-];
-// const CONST_VersionApp = 'version-app.json';
-export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
-    functions = {};
-    static staggerCount = 0;
-    static DefaultConfig_FirebaseFunction = {
-        pathToFirebaseConfig: '.firebase_config',
-        debugPort: 8100,
-        basePort: 8102,
-        sslKey: '.ssl/key.pem',
-        sslCert: '.ssl/cert.pem',
-        output: 'dist',
-        pathToEmulatorData: '.trash/data',
-    };
-    emulatorLogStrings = {
-        error: firebaseFunctionEmulator_ErrorStrings,
-        warning: firebaseFunctionEmulator_WarningStrings,
-    };
-    constructor(config) {
-        super(config);
-        this.addToClassStack(Unit_FirebaseFunctionsApp);
-        this.logger.setLogTransformer(log => {
-            const prefix = _logger_logPrefixes.find(prefix => log.includes(prefix));
-            if (!prefix)
-                return log;
-            return log.substring(log.indexOf(prefix) + prefix.length);
-        });
-    }
-    //######################### Phase Implementations #########################
-    async copyPackageJSONToOutput() {
-        const targetPath = resolve(this.config.output, CONST_PackageJSON);
-        const packageJson = deepClone(this.config.packageJson);
-        const distDependencies = this.deriveDistDependencies();
-        packageJson.main = 'index.js';
-        packageJson.types = 'index.d.ts';
-        const dependencies = packageJson.dependencies ?? {};
-        // First, update existing dependencies (replace workspace:* with file: paths where applicable)
-        _keys(dependencies).reduce((dependencies, packageName) => {
-            if (distDependencies[packageName])
-                dependencies[packageName] = distDependencies[packageName];
-            return dependencies;
-        }, dependencies);
-        // Then, add ALL dependencyUnits to the dependencies (this includes transitive dependencies)
-        // This ensures the entire dependency tree is referenced in the main package.json
-        this.dependencyUnits.reduce((dependencies, unit) => {
-            dependencies[unit.config.key] = distDependencies[unit.config.key];
-            return dependencies;
-        }, dependencies);
-        packageJson.dependencies = dependencies;
-        await FileSystemUtils.file.template.write(targetPath, __stringify(packageJson, true), this.deriveDistDependencies(), DEFAULT_OLD_TEMPLATE_PATTERN);
-    }
-    async prepare() {
-        if (!this.config.envConfig.projectId.length) {
-            this.logWarning('envConfig: ', this.config.envConfig);
-            throw new ImplementationMissingException(`Missing EnvConfig in unit ${this.config.key}`);
-        }
-        await super.prepare();
-        await FileSystemUtils.folder.list.forEach.folder(this.config.fullPath, async (path) => {
-            if (path.replace(`${this.config.fullPath}/`, '').startsWith('firebase-export-'))
-                return await FileSystemUtils.folder.delete(path);
-        });
-        await FileSystemUtils.folder.create(resolve(this.config.fullPath, this.config.pathToEmulatorData));
-        await FileSystemUtils.file.delete(this.pathToProxy());
-        await this.resolveConfigs();
-    }
-    async resolveConfigs() {
-        await this.resolveFunctionsRC();
-        await this.resolveConfigDir();
-        await this.resolveFunctionsRuntimeConfig();
-        await this.resolveFunctionsJSON();
-    }
-    async compile() {
-        await this.createAppVersionFile();
-        await super.compile();
-    }
-    async postCompile() {
-        await this.createDependenciesDir();
-    }
-    async launch() {
-        await sleep(2 * Second * Unit_FirebaseFunctionsApp.staggerCount++);
-        await this.releaseEmulatorPorts();
-        await Promise.all([
-            this.runProxy(),
-            this.runEmulator(),
-        ]);
-    }
-    async releaseEmulatorPorts() {
-        const allPorts = Array.from({ length: 10 }, (_, i) => `${this.config.basePort + i}`);
-        return this.releasePorts(allPorts);
-    }
-    async deploy() {
-        const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .cd(this.config.output)
-            .ls()
-            .cat('package.json')
-            .cat('index.js')
-            .cd(this.config.fullPath)
-            .setLogLevelFilter(deployLogFilter)
-            // example: Function URL (hello(us-central1)): https://hello-kv65k7yylq-uc.a.run.app
-            .onLog(/.*Function URL.*?\((.*?)\(.*(https:\/\/.*?)$/, match => {
-            this.functions[match[1]] = match[2];
-        });
-        const debug = this.runtimeContext.runtimeParams.verbose ? ' --debug' : '';
-        await this.executeAsyncCommando(commando, `${this.npmCommand('firebase')}${debug} deploy --only functions --force`, (stdout, stderr, exitCode) => {
-            if (exitCode === 0)
-                return;
-            throw new CommandoException(`Failed to deploy function with exit code ${exitCode}`, stdout, stderr, exitCode);
-        });
-        this.logInfo(`Functions: `, this.functions);
-    }
-    //######################### ResolveConfig Logic #########################
-    async resolveFunctionsRC() {
-        const envConfig = this.config.envConfig;
-        const rcConfig = {
-            projects: {
-                default: envConfig.projectId
-            },
-            targets: {
-                [envConfig.projectId]: {
-                    database: {
-                        [envConfig.projectId]: [envConfig.projectId]
-                    }
-                }
-            }
-        };
-        const targetPath = resolve(this.config.fullPath, CONST_FirebaseRC);
-        await FileSystemUtils.file.write.json(targetPath, rcConfig);
-    }
-    async resolveProxyFile() {
-        const envConfig = this.config.envConfig;
-        const targetPath = this.pathToProxy();
-        const path = this.runtimeContext.baiConfig.files?.backend?.proxy;
-        if (!path)
-            return;
-        const params = {
-            PROJECT_ID: `${envConfig.projectId}`,
-            PROXY_PORT: `${this.config.basePort}`,
-            SERVER_PORT: `${this.config.basePort + 1}`,
-            PATH_TO_SSL_KEY: `${this.config.sslKey}`,
-            PATH_TO_SSL_CERTIFICATE: `${this.config.sslCert}`,
-        };
-        await FileSystemUtils.file.template.copy(path, targetPath, params);
-    }
-    pathToProxy() {
-        return resolve(this.config.fullPath, 'src/main/proxy.ts');
-    }
-    async resolveConfigDir() {
-        //Create the dir if it doesn't exist
-        const pathToFirebaseConfigFolder = `${this.config.fullPath}/${this.config.pathToFirebaseConfig}`;
-        await FileSystemUtils.folder.create(pathToFirebaseConfigFolder);
-        //Fill config dir with relevant files for each file that doesn't exist
-        const defaultFiles = this.runtimeContext.baiConfig.files?.firebase;
-        if (!defaultFiles) {
-            this.logError('No defaultFileRoutes in project config');
-            return;
-        }
-        await Promise.all(Const_FirebaseConfigKeys.map(async (firebaseConfigKey) => {
-            const pathToConfigFile = `${pathToFirebaseConfigFolder}/${Const_FirebaseDefaultsKeyToFile[firebaseConfigKey]}`;
-            if (!defaultFiles[firebaseConfigKey])
-                return;
-            const path = resolve(this.runtimeContext.parentUnit.config.fullPath, defaultFiles[firebaseConfigKey]);
-            await FileSystemUtils.file.copy(path, pathToConfigFile);
-        }));
-    }
-    async resolveFunctionsJSON() {
-        const envConfig = this.config.envConfig;
-        const targetPath = `${this.config.fullPath}/${CONST_FirebaseJSON}`;
-        let fileContent;
-        if (envConfig.isLocal) {
-            const port = this.config.basePort;
-            fileContent = {
-                database: [{
-                        target: this.config.envConfig.projectId,
-                        rules: `${this.config.pathToFirebaseConfig}/database.rules.json`
-                    }],
-                firestore: {
-                    rules: `${this.config.pathToFirebaseConfig}/firestore.rules`,
-                    indexes: `${this.config.pathToFirebaseConfig}/firestore.indexes.json`
-                },
-                storage: {
-                    rules: `${this.config.pathToFirebaseConfig}/storage.rules`
-                },
-                remoteconfig: {
-                    template: `${this.config.pathToFirebaseConfig}/remoteconfig.template.json`
-                },
-                functions: {
-                    ignore: this.config.ignore,
-                    source: '.',
-                    predeploy: [
-                        'echo "Thunderstorm - Local environment is not deployable... Aborting..." && exit 2'
-                    ]
-                },
-                emulators: {
-                    singleProjectMode: true,
-                    functions: { port: port + 1 },
-                    database: { port: port + 2 },
-                    firestore: {
-                        port: port + 3,
-                        websocketPort: port + 4
-                    },
-                    pubsub: { port: port + 5 },
-                    storage: { port: port + 6 },
-                    auth: { port: port + 7 },
-                    ui: { port: port + 8, enabled: true },
-                    hub: { port: port + 9 },
-                    logging: { port: port + 10 }
-                }
-            };
-        }
-        else {
-            fileContent = {
-                functions: {
-                    source: this.config.output.replace(`${this.config.fullPath}/`, ''),
-                    ignore: this.config.ignore,
-                    runtime: 'nodejs22',
-                }
-            };
-        }
-        await FileSystemUtils.file.write.json(targetPath, fileContent);
-    }
-    async resolveFunctionsRuntimeConfig() {
-        const envConfig = this.config.envConfig;
-        const targetPath = `${this.config.fullPath}/src/main/config.ts`;
-        const envKey = this.runtimeContext.runtimeParams.environment;
-        const beConfig = {
-            envKey,
-            pathToDefaultConfig: envConfig.defaultConfig ?? `/_config/default`,
-            pathToEnvOverrideConfig: envConfig.defaultConfig ?? `/_config/${envKey}`,
-        };
-        const inLocalIgnoreTLS = `${envConfig.isLocal ? '// @ts-ignore\nprocess.env[\'NODE_TLS_REJECT_UNAUTHORIZED\'] = 0;\n\n' : ''}`;
-        const fileContent = `${inLocalIgnoreTLS}export const Environment = ${JSON.stringify(beConfig)};`;
-        await FileSystemUtils.file.write(targetPath, fileContent);
-    }
-    //######################### Compile Logic #########################
-    async createAppVersionFile() {
-        //Writing the file to the package source instead of the output is fine,
-        //copyAssetsToOutput will move the file to output
-        const targetPath = `${this.config.fullPath}/src/main/${CONST_VersionApp}`;
-        const appVersion = this.runtimeContext.version;
-        await FileSystemUtils.file.write.json(targetPath, { version: appVersion });
-    }
-    deriveDistDependencies() {
-        return this.dependencyUnits.reduce((dependencies, unit) => {
-            dependencies[unit.config.key] = `file:.dependencies/${unit.config.key}`;
-            return dependencies;
-        }, super.deriveDistDependencies());
-    }
-    async createDependenciesDir() {
-        //Gather units that are dependencies of this unit
-        await Promise.all(this.dependencyUnits.map(async (unit) => {
-            //Copy dependency unit output into this units output/.dependency dir
-            const dependencyOutputPath = `${unit.config.output}/`;
-            const targetPath = `${this.config.output}/.dependencies/${unit.config.key}/`;
-            await FileSystemUtils.folder.create(targetPath);
-            await this.allocateCommando()
-                .append(`rsync -a --delete ${dependencyOutputPath} ${targetPath}`)
-                .execute();
-        }));
-    }
-    //######################### Launch Logic #########################
-    async runProxy() {
-        await this.resolveProxyFile();
-        const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `${this.npmCommand('tsx')} src/main/proxy.ts`);
-        this.logWarning('PROXY TERMINATED');
-    }
-    async runEmulator() {
-        let exportGoogleCredentials;
-        if (this.config.envConfig.identityAccount) {
-            const pathToIdentityAccount = resolve(this.config.fullPath, this.config.envConfig.identityAccount);
-            if (!FileSystemUtils.file.exists(pathToIdentityAccount))
-                throw new ImplementationMissingException(`Missing identity file at: ${pathToIdentityAccount}`);
-            exportGoogleCredentials = `export GOOGLE_APPLICATION_CREDENTIALS="${pathToIdentityAccount}"`;
-        }
-        const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .setUID(this.config.key)
-            .cd(this.config.fullPath);
-        if (exportGoogleCredentials)
-            commando.append(exportGoogleCredentials);
-        commando.setLogLevelFilter((log, type) => {
-            if (this.emulatorLogStrings.error.some(errStr => log.includes(errStr)))
-                return LogLevel.Error;
-            if (this.emulatorLogStrings.warning.some(warnStr => log.includes(warnStr)))
-                return LogLevel.Warning;
-        })
-            .onLog(/.*Emulator Hub running.*/, () => this.setStatus('Launch Complete'));
-        await this.executeAsyncCommando(commando, `${this.npmCommand('firebase')} emulators:start --project ${this.config.envConfig.projectId} --export-on-exit --import=${this.config.pathToEmulatorData} ${this.runtimeContext.runtimeParams.debugBackend
-            ? `--inspect-functions ${this.config.debugPort}` : ''}`);
-        this.logWarning('EMULATORS TERMINATED');
-    }
-}

package/v3/units/firebase/Unit_FirebaseHostingApp.d.ts

@@ -1,49 +0,0 @@
-import { FirebasePackageConfig } from '../../../core/types/index.js';
-import { UnitPhaseImplementor } from '../../core/types.js';
-import { StringMap, TS_Object, TypedMap } from '@nu-art/ts-common';
-import { UnitConfigJSON_Node } from '../../UnitsMapper/resolvers/UnitMapper_Node.js';
-import { Phase_Deploy, Phase_Launch } from '../../phase/index.js';
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
-export type FirebaseHostingConfig = {
-    public: string;
-    rewrites: {
-        source: string;
-        destination: string;
-    }[];
-};
-export type FirebaseHosting_EnvConfig = {
-    config: TS_Object;
-    projectId: string;
-    isLocal?: boolean;
-};
-export type UnitConfigJSON_FirebaseHosting = UnitConfigJSON_Node & {
-    servingPort?: number;
-    hostingConfig?: FirebaseHostingConfig;
-    envs: TypedMap<FirebaseHosting_EnvConfig>;
-};
-export type Unit_FirebaseHostingApp_Config = Unit_TypescriptLib_Config & {
-    firebaseConfig?: FirebasePackageConfig;
-    servingPort: number;
-    hostingConfig?: FirebaseHostingConfig;
-    envConfig: FirebaseHosting_EnvConfig;
-    sources?: string[];
-};
-export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_Config = Unit_FirebaseHostingApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy]> {
-    hosting: StringMap;
-    static DefaultConfig_FirebaseHosting: {
-        servingPort: number;
-        output: string;
-    };
-    constructor(config: Unit_FirebaseHostingApp<C>['config']);
-    prepare(): Promise<void>;
-    compile(): Promise<void>;
-    launch(): Promise<void>;
-    releaseWebpackPorts(): Promise<void>;
-    deploy(): Promise<void>;
-    private resolveHostingRC;
-    private resolveHostingJSON;
-    private resolveHostingRuntimeConfig;
-    protected compileImpl(): Promise<void>;
-    private createAppVersionFile;
-    private runApp;
-}

package/v3/units/firebase/Unit_FirebaseHostingApp.js

@@ -1,118 +0,0 @@
-import { ImplementationMissingException, LogLevel } from '@nu-art/ts-common';
-import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_VersionApp } from '../../../core/consts.js';
-import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
-import { Commando_Basic } from '@nu-art/commando/shell/plugins/basic';
-import { resolve } from 'path';
-import { Unit_TypescriptLib } from '../Unit_TypescriptLib.js';
-import { CommandoException } from '@nu-art/commando/shell/core/CliError';
-import { deployLogFilter } from './common.js';
-import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
-export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
-    hosting = {};
-    static DefaultConfig_FirebaseHosting = {
-        servingPort: 8100,
-        output: 'dist',
-    };
-    constructor(config) {
-        super(config);
-        this.addToClassStack(Unit_FirebaseHostingApp);
-    }
-    //######################### Phase Implementations #########################
-    async prepare() {
-        if (!this.config.envConfig.projectId.length) {
-            this.logWarning('envConfig: ', this.config.envConfig);
-            throw new ImplementationMissingException(`Missing EnvConfig in unit ${this.config.key}`);
-        }
-        await super.prepare();
-        await this.resolveHostingRC();
-        await this.resolveHostingJSON();
-        await this.resolveHostingRuntimeConfig();
-    }
-    async compile() {
-        await this.resolveTSConfig(resolve(this.config.fullPath, './src'), 'main', { compilerOptions: { declaration: false } });
-        await this.clearOutputDir();
-        await this.createAppVersionFile();
-        await this.compileImpl();
-    }
-    async launch() {
-        this.setStatus('Launching');
-        await this.releaseWebpackPorts();
-        await this.runApp();
-    }
-    async releaseWebpackPorts() {
-        return this.releasePorts([`${this.config.servingPort}`]);
-    }
-    async deploy() {
-        const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .cd(this.config.fullPath)
-            .setLogLevelFilter(deployLogFilter)
-            // example: Function URL (hello(us-central1)): https://hello-kv65k7yylq-uc.a.run.app
-            .onLog(/.*Hosting URL.*(https:\/\/.*?)$/, match => {
-            this.hosting[match[1]] = match[2];
-        });
-        const debug = this.runtimeContext.runtimeParams.verbose ? ' --debug' : '';
-        await this.executeAsyncCommando(commando, `${this.npmCommand('firebase')}${debug} deploy --only hosting`, (stdout, stderr, exitCode) => {
-            if (exitCode === 0)
-                return;
-            throw new CommandoException(`Failed to deploy hosting with exit code ${exitCode}`, stdout, stderr, exitCode);
-        });
-    }
-    //######################### ResolveConfig Logic #########################
-    async resolveHostingRC() {
-        const envConfig = this.config.envConfig;
-        const rcConfig = { projects: { default: envConfig.projectId } };
-        const targetPath = `${this.config.fullPath}/${CONST_FirebaseRC}`;
-        await FileSystemUtils.file.write.json(targetPath, rcConfig);
-    }
-    async resolveHostingJSON() {
-        const envConfig = this.config.envConfig;
-        const targetPath = `${this.config.fullPath}/${CONST_FirebaseJSON}`;
-        let fileContent;
-        if (envConfig.isLocal)
-            fileContent = {};
-        else
-            fileContent = {
-                hosting: this.config.hostingConfig ?? {
-                    'public': 'dist',
-                    'rewrites': [
-                        { 'source': '**', 'destination': '/index.html' }
-                    ]
-                }
-            };
-        await FileSystemUtils.file.write.json(targetPath, fileContent);
-    }
-    async resolveHostingRuntimeConfig() {
-        const envConfig = this.config.envConfig.config;
-        const targetPath = resolve(this.config.fullPath, `./src/main/config.ts`);
-        const fileContent = `export const config = ${JSON.stringify(envConfig, null, 2)};`;
-        await FileSystemUtils.file.write(targetPath, fileContent);
-    }
-    //######################### Compile Logic #########################
-    async compileImpl() {
-        const commando = this.allocateCommando(Commando_NVM, Commando_Basic).applyNVM()
-            .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `ENV=${this.runtimeContext.runtimeParams.environment} npm run build`, (stdout, stderr, exitCode) => {
-            if (exitCode > 0)
-                throw new CommandoException(`Error compiling`, stdout, stderr, exitCode);
-        });
-    }
-    async createAppVersionFile() {
-        //Writing the file to the package source instead of the output is fine,
-        //Webpack bundles files into the output automatically!
-        const targetPath = `${this.config.fullPath}/src/main/${CONST_VersionApp}`;
-        const appVersion = this.runtimeContext.version;
-        await FileSystemUtils.file.write.json(targetPath, { version: appVersion });
-    }
-    //######################### Launch Logic #########################
-    async runApp() {
-        const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .setUID(this.config.key)
-            .cd(this.config.fullPath)
-            .setLogLevelFilter((log, type) => {
-            if (log.toLowerCase().includes('<i>'))
-                return LogLevel.Info;
-        });
-        await this.executeAsyncCommando(commando, 'npm run start');
-        this.logWarning('HOSTING TERMINATED');
-    }
-}

package/v3/units/firebase/common.d.ts

@@ -1,3 +0,0 @@
-import { LogTypes } from '@nu-art/commando/shell/types';
-import { LogLevel } from '@nu-art/ts-common';
-export declare const deployLogFilter: (log: string, std: LogTypes) => LogLevel.Debug | LogLevel.Info | LogLevel.Warning | LogLevel.Error;

package/v3/units/firebase/common.js

@@ -1,13 +0,0 @@
-import { LogLevel } from '@nu-art/ts-common';
-const warn = ['missing required API'];
-const info = ['=== Deploying', 'functions: Successfully deployed function'];
-const infoStartsWith = ['✔ ', 'i '];
-export const deployLogFilter = (log, std) => {
-    if (log.startsWith('⚠ ') || warn.find(str => log.includes(str)))
-        return LogLevel.Warning;
-    if (infoStartsWith.find(str => log.startsWith(str)) || info.find(str => log.includes(str)))
-        return LogLevel.Info;
-    if (log.includes('Error:'))
-        return LogLevel.Error;
-    return LogLevel.Debug;
-};

package/v3/units/index.d.ts

@@ -1,6 +0,0 @@
-export * from './BaseUnit.js';
-export * from './ProjectUnit.js';
-export * from './Unit_TypescriptLib.js';
-export * from './Unit_PackageJson.js';
-export * from './Unit_NodeProject.js';
-export * from './types.js';

package/v3/units/index.js

@@ -1,6 +0,0 @@
-export * from './BaseUnit.js';
-export * from './ProjectUnit.js';
-export * from './Unit_TypescriptLib.js';
-export * from './Unit_PackageJson.js';
-export * from './Unit_NodeProject.js';
-export * from './types.js';