@nu-art/build-and-install 0.400.5 → 0.400.7

package/v3/UnitsMapper/UnitsMapper.js

@@ -57,4 +57,3 @@ export class UnitsMapper extends Logger {
         }
     }
 }
-//# sourceMappingURL=UnitsMapper.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_Base.js

@@ -14,4 +14,3 @@ export class UnitMapper_Base extends Logger {
         this.baiConfig = config;
     }
 }
-//# sourceMappingURL=UnitMapper_Base.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_FirebaseFunction.js

@@ -53,4 +53,3 @@ export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
     }
 }
 export const UnitMapper_FirebaseFunction = new UnitMapper_FirebaseFunction_Class();
-//# sourceMappingURL=UnitMapper_FirebaseFunction.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_FirebaseHosting.js

@@ -23,8 +23,10 @@ export class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node {
         const outputDir = context.packageJson.publishConfig?.directory;
         const env = this.runtimeParams[BaiParam_SetEnv.keyName];
         const envUnitConfig = context.packageJson.unitConfig.envs[env];
-        if (!envUnitConfig)
+        if (!envUnitConfig) {
+            this.logWarning('Package Json config:', context.packageJson.unitConfig);
             throw new ImplementationMissingException(`Missing configuration for env: ${env}`);
+        }
         const envConfig = {
             config: envUnitConfig.config,
             projectId: envUnitConfig.projectId,
@@ -46,4 +48,3 @@ export class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node {
     }
 }
 export const UnitMapper_FirebaseHosting = new UnitMapper_FirebaseHosting_Class();
-//# sourceMappingURL=UnitMapper_FirebaseHosting.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_Node.js

@@ -19,41 +19,47 @@ export class UnitMapper_Node extends UnitMapper_Base {
         const pathToFile = `${path}/__package.json`;
         if (!await FileSystemUtils.file.exists(pathToFile))
             return;
-        let packageJson = await FilesCache.load.json(pathToFile);
-        if (!packageJson)
-            return;
-        if (!packageJson.unitConfig) {
-            this.logWarning(`Found a package.json without unitConfig at: ${pathToFile}`);
-            UnitMapper_Node.invalidPaths.push(path);
-            return;
+        let packageJson;
+        try {
+            packageJson = await FilesCache.load.json(pathToFile);
+            if (!packageJson)
+                return;
+            if (!packageJson.unitConfig) {
+                this.logWarning(`Found a package.json without unitConfig at: ${pathToFile}`);
+                UnitMapper_Node.invalidPaths.push(path);
+                return;
+            }
+            if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
+                return; // not the expected type for this mapper
+            packageJson = deepClone(packageJson);
+            tsValidate(packageJson.unitConfig, this.validator);
+            const dependencies = packageJson.dependencies;
+            if (dependencies)
+                packageJson.dependencies = _keys(dependencies).reduce((acc, key) => {
+                    acc[key] = dependencies[key] === '?' ? `{{${key}}}` : dependencies[key];
+                    return acc;
+                }, {});
+            const devDependencies = packageJson.devDependencies;
+            if (devDependencies)
+                packageJson.devDependencies = _keys(devDependencies).reduce((acc, key) => {
+                    acc[key] = devDependencies[key] === '?' ? `{{${key}}}` : devDependencies[key];
+                    return acc;
+                }, {});
+            Object.freeze(packageJson);
+            const baseConfig = {
+                key: packageJson.name,
+                fullPath: path,
+                relativePath: path.replace(root, '.'),
+                label: packageJson.unitConfig.label ?? packageJson.name,
+                dependencies: { ...dependencies, ...packageJson.devDependencies },
+            };
+            const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
+            const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
+            return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+        }
+        catch (e) {
+            this.logError(`Failed to load package.json at: ${pathToFile}`, e);
+            throw e;
         }
-        if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
-            return; // not the expected type for this mapper
-        packageJson = deepClone(packageJson);
-        tsValidate(packageJson.unitConfig, this.validator);
-        const dependencies = packageJson.dependencies;
-        if (dependencies)
-            packageJson.dependencies = _keys(dependencies).reduce((acc, key) => {
-                acc[key] = dependencies[key] === '?' ? `{{${key}}}` : dependencies[key];
-                return acc;
-            }, {});
-        const devDependencies = packageJson.devDependencies;
-        if (devDependencies)
-            packageJson.devDependencies = _keys(devDependencies).reduce((acc, key) => {
-                acc[key] = devDependencies[key] === '?' ? `{{${key}}}` : devDependencies[key];
-                return acc;
-            }, {});
-        Object.freeze(packageJson);
-        const baseConfig = {
-            key: packageJson.name,
-            fullPath: path,
-            relativePath: path.replace(root, '.'),
-            label: packageJson.unitConfig.label ?? packageJson.name,
-            dependencies: { ...dependencies, ...packageJson.devDependencies },
-        };
-        const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
-        const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
-        return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
     }
 }
-//# sourceMappingURL=UnitMapper_Node.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_NodeLib.js

@@ -26,4 +26,3 @@ export class UnitMapper_NodeLib_Class extends UnitMapper_Node {
     }
 }
 export const UnitMapper_NodeLib = new UnitMapper_NodeLib_Class();
-//# sourceMappingURL=UnitMapper_NodeLib.js.map

package/v3/UnitsMapper/resolvers/UnitMapper_NodeProject.js

@@ -20,4 +20,3 @@ export class UnitMapper_NodeProject_Class extends UnitMapper_Node {
     }
 }
 export const UnitMapper_NodeProject = new UnitMapper_NodeProject_Class();
-//# sourceMappingURL=UnitMapper_NodeProject.js.map

package/v3/UnitsMapper/resolvers/index.js

@@ -2,4 +2,3 @@ export * from './UnitMapper_NodeLib.js';
 export * from './UnitMapper_NodeProject.js';
 export * from './UnitMapper_FirebaseFunction.js';
 export * from './UnitMapper_FirebaseHosting.js';
-//# sourceMappingURL=index.js.map

package/v3/UnitsMapper/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/v3/core/FilesCache.js

@@ -31,4 +31,3 @@ export const FilesCache = {
         }
     }
 };
-//# sourceMappingURL=FilesCache.js.map

package/v3/core/Unit_HelpPrinter.d.ts

@@ -3,7 +3,7 @@ import { UnitPhaseImplementor } from './types.js';
 import { Phase } from '../phase/index.js';
 import { ProjectUnit } from '../units/index.js';
 export declare const BaiParam_Help: BaseCliParam<'help', boolean>;
-declare const AllBaiParams_Help: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", "patch" | "minor" | "major"> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"help", boolean>)[];
+declare const AllBaiParams_Help: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", "patch" | "minor" | "major"> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"includePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"help", boolean>)[];
 export type Help_BaiParams = CliParams<typeof AllBaiParams_Help>;
 export type Phase_Help = typeof phase_Help;
 export declare const phaseKey_Help = "help";

package/v3/core/Unit_HelpPrinter.js

@@ -45,4 +45,3 @@ class _Unit_HelpPrinter extends ProjectUnit {
     }
 }
 export const Unit_HelpPrinter = new _Unit_HelpPrinter();
-//# sourceMappingURL=Unit_HelpPrinter.js.map

package/v3/core/types.js

@@ -3,4 +3,3 @@ export const WatchEvent_Update = 'update';
 export const WatchEvent_RemoveDir = 'remove_dir';
 export const WatchEvent_RemoveFile = 'remove_file';
 export const WatchEvent_Ready = 'ready';
-//# sourceMappingURL=types.js.map

package/v3/phase/consts.d.ts

@@ -8,6 +8,7 @@ export declare const phase_CheckCyclicImports: Phase<'checkCyclicImports'>;
 export type Phase_ToESM = typeof phase_ToESM;
 export declare const phaseKey_ToESM = "convertToESM";
 export declare const phase_ToESM: Phase<'convertToESM'>;
+export declare const phases_Terminating: Phase<string>[][];
 export type Phase_Purge = typeof phase_Purge;
 export declare const phaseKey_Purge = "purge";
 export declare const phase_Purge: Phase<'purge'>;

package/v3/phase/consts.js

@@ -21,6 +21,10 @@ export const phase_ToESM = {
     method: 'convertToESM',
     filter: (baiParams) => baiParams.toESM,
 };
+export const phases_Terminating = [
+    [phase_PrintDependencyTree],
+    [phase_CheckCyclicImports],
+];
 export const phaseKey_Purge = 'purge';
 export const phase_Purge = {
     key: phaseKey_Purge,
@@ -125,4 +129,3 @@ export const phase_Deploy = {
     filter: (baiParams) => !!baiParams.deploy,
 };
 export const phases_Deploy = [[phase_Publish, phase_Deploy], [phase_PostPublish]];
-//# sourceMappingURL=consts.js.map

package/v3/phase/index.js

@@ -1,3 +1,2 @@
 export * from './types.js';
 export * from './consts.js';
-//# sourceMappingURL=index.js.map

package/v3/phase/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/v3/units/BaseUnit.js

@@ -117,4 +117,3 @@ export class BaseUnit extends Logger {
         return this.logger.buffers[0];
     }
 }
-//# sourceMappingURL=BaseUnit.js.map

package/v3/units/ProjectUnit.js

@@ -9,4 +9,3 @@ export class ProjectUnit extends BaseUnit {
         this.addToClassStack(ProjectUnit);
     }
 }
-//# sourceMappingURL=ProjectUnit.js.map

package/v3/units/Unit_NodeProject.js

@@ -241,4 +241,3 @@ export class Unit_NodeProject extends Unit_PackageJson {
     async postPublish() {
     }
 }
-//# sourceMappingURL=Unit_NodeProject.js.map

package/v3/units/Unit_PackageJson.js

@@ -48,4 +48,3 @@ export class Unit_PackageJson extends ProjectUnit {
             .execute();
     }
 }
-//# sourceMappingURL=Unit_PackageJson.js.map

package/v3/units/Unit_TypescriptLib.d.ts

@@ -11,6 +11,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
 export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile, Phase_PrintDependencyTree, Phase_CheckCyclicImports, Phase_Lint, Phase_Test, Phase_Publish, Phase_ToESM]> {
     private TestTypeWorkspaceSetup;
     runTests(): Promise<void>;
+    protected dependencyUnits: Unit_TypescriptLib[];
     constructor(config: Unit_TypescriptLib<C>['config']);
     protected clearOutputDir(): Promise<void>;
     protected clearOutputDirImpl(): Promise<void>;

package/v3/units/Unit_TypescriptLib.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import { copyFileSync, existsSync, promises as _fs, readdirSync, statSync } from 'fs';
-import { __stringify, arrayToMap, BadImplementationException, exists, ImplementationMissingException, LogLevel, NotImplementedYetException } from '@nu-art/ts-common';
+import { __stringify, arrayToMap, BadImplementationException, ImplementationMissingException, LogLevel, NotImplementedYetException } from '@nu-art/ts-common';
 import { CONST_BaiConfig, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON, CONST_PackageJSONTemplate, CONST_TS_CONFIG } from '../../core/consts.js';
 import { CommandoException } from '@nu-art/commando/shell/core/CliError';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
@@ -126,6 +126,7 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             });
         }
     }
+    dependencyUnits;
     constructor(config) {
         super(config);
         this.addToClassStack(Unit_TypescriptLib);
@@ -147,6 +148,8 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             // @ts-ignore
             this.publish = undefined;
         }
+        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
+        this.dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
     }
     async compileImpl() {
         const pathToCompile = `${this.config.fullPath}/src/main`;
@@ -228,6 +231,8 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             .execute();
     }
     async compile() {
+        if (!this.dependencyUnits)
+            await this.prepare();
         await this.clearOutputDirImpl();
         await this.compileImpl();
         await this.copyAssetsToOutput();
@@ -259,15 +264,18 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
     }
     async checkCyclicImports() {
         this.logDebug(`Checking Cyclic Imports - ${this.config.label}`);
+        const pathToMain = pathResolve(this.config.fullPath, './src/main');
+        const pathToTsConfig = pathResolve(pathToMain, './tsconfig.json');
         await this.allocateCommando(Commando_Basic)
             .cd(this.config.fullPath)
             // .setStdErrorValidator(stderr => {
             // 	return !stderr.includes('Finding files') && !stderr.includes('Image created');
             // })
-            .append(`npx madge --no-spinner --image "./imports-${this.config.key}.svg" --circular ${this.config.output}`)
+            .append(`npx madge --no-spinner --ts-config ${pathToTsConfig} --image "./imports-${this.config.key}.svg" --extensions ts,tsx,mts,js,mjs --circular ${pathToMain} `)
             .append('echo $?')
             .execute();
     }
+    // npx madge --circular --ts-config ./tsconfig.json --extensions ts,tsx,mts,js,mjs ./src/main
     async lint() {
         // need to move the copy of the default eslint rules to here
         const pathToLint = pathResolve(this.config.fullPath, `src/main`);
@@ -383,55 +391,88 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         const specificFiles = [CONST_PackageJSONTemplate];
         const fileExtensions = ['.ts', '.tsx', '.mts', '.js', '.jsx', '.mjs'];
         const units = arrayToMap(this.runtimeContext.childUnits, unit => unit.config.key);
-        const toESM = async (pathTofile, importPath) => {
-            importPath = importPath.replace(/\/+/g, '/');
-            if (importPath.endsWith('.js'))
-                return importPath;
+        const toESM = async (pathTofile, originImportPath) => {
+            originImportPath = originImportPath.replace(/\/+/g, '/');
+            if (originImportPath.endsWith('.js'))
+                return originImportPath;
+            if (originImportPath.endsWith('.json'))
+                return originImportPath;
             for (const extension of fileExtensions) {
-                if (!importPath.endsWith(extension))
+                if (!originImportPath.endsWith(extension))
                     continue;
-                importPath = importPath.replace(extension, '');
+                originImportPath = originImportPath.replace(extension, '');
                 break;
             }
-            let initialPath;
-            let relativePathToFile;
-            let extension = '';
-            if (importPath.startsWith('.') || importPath.startsWith('/')) {
-                initialPath = path.dirname(pathTofile);
-                relativePathToFile = importPath;
-                extension = '.js';
-            }
-            else {
-                const [part1, part2, ...relativePathParts] = importPath.split('/');
-                const unit = units[part1] ?? units[`${part1}/${part2}`];
-                if (unit) {
-                    initialPath = `${unit.config.fullPath}/src/main`;
-                    relativePathToFile = relativePathParts.join('/');
-                }
+            // this can be ./path/to/folder => ./path/to/folder/index.js
+            // this can be ./path/to/file   => ./path/to/file.js
+            if (originImportPath.startsWith('.') || originImportPath.startsWith('/')) {
+                const initialPath = path.dirname(pathTofile);
+                let relativePathToFile = originImportPath;
+                const fullPath = path.resolve(initialPath, relativePathToFile);
+                if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
+                    relativePathToFile = `${relativePathToFile}/index`;
+                // either way we need to add a .js
+                relativePathToFile += '.js';
+                relativePathToFile = relativePathToFile.replace(/\/+/g, '/');
+                return relativePathToFile;
             }
-            if (!exists(initialPath) || !exists(relativePathToFile))
+            const resolveImportPathFromUnit = async (packageName, relativePathToFile) => {
+                const unit = units[packageName];
+                if (!unit)
+                    return;
+                let initialPath = `${unit.config.fullPath}/src/main`;
+                const fullPath = path.resolve(initialPath, relativePathToFile);
+                if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
+                    relativePathToFile = `${relativePathToFile}/index`;
+                const importPath = `${packageName}/${relativePathToFile}`.replace(/\/+/g, '/');
+                if (importPath === `${packageName}/index`)
+                    return `${packageName}`;
                 return importPath;
-            const fullPath = path.resolve(initialPath, relativePathToFile);
-            if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
-                relativePathToFile = `${relativePathToFile}/index`;
-            // throw new BadImplementationException(`Expected file to exist: ${fullPath}`);
-            relativePathToFile += extension;
-            relativePathToFile = relativePathToFile.replace(/\/+/g, '/');
-            return relativePathToFile;
+            };
+            // this can be {{libName}}/path/to/file   => {{libName}}/path/to/file
+            let [libName1, ...rest1] = originImportPath.split('/');
+            let esmImportPath = await resolveImportPathFromUnit(libName1, rest1.join('/'));
+            if (esmImportPath)
+                return esmImportPath;
+            let [libOrg, libName2, ...rest2] = originImportPath.split('/');
+            esmImportPath = await resolveImportPathFromUnit(`${libOrg}/${libName2}`, rest2.join('/'));
+            if (esmImportPath)
+                return esmImportPath;
+            return originImportPath;
         };
         const importMatchers = [
             {
-                regex: /from\s+["']([^"']+)["']/g,
+                regex: /from\s+"(\S+)?"/g,
                 replacer: async (pathTofile, importPath) => `from "${await toESM(pathTofile, importPath)}"`
             },
             {
-                regex: /require\(\s*["']([^"']+)["']\s*\)/g,
-                replacer: async (pathTofile, importPath) => `await import("${await toESM(pathTofile, importPath)}")`
+                regex: /from\s+'(\S+)?'/g,
+                replacer: async (pathTofile, importPath) => `from '${await toESM(pathTofile, importPath)}'`
+            },
+            {
+                regex: /\srequire\((\S+)?\)/g,
+                replacer: async (pathTofile, importPath) => ` await import("${await toESM(pathTofile, importPath)}")`
             },
             {
-                regex: /import\(\s*["']([^"']+)["']\s*\)/g,
+                regex: /\srequire\((\S+)?\)/g,
+                replacer: async (pathTofile, importPath) => ` await import('${await toESM(pathTofile, importPath)}')`
+            },
+            {
+                regex: /\srequire\(\s*"(\S+)?"\s*\)/g,
+                replacer: async (pathTofile, importPath) => ` await import("${await toESM(pathTofile, importPath)}")`
+            },
+            {
+                regex: /\srequire\(\s*'(\S+)?'\s*\)/g,
+                replacer: async (pathTofile, importPath) => ` await import('${await toESM(pathTofile, importPath)}')`
+            },
+            {
+                regex: /import\(\s*"(\S+)?"\s*\)/g,
                 replacer: async (pathTofile, importPath) => `import("${await toESM(pathTofile, importPath)}")`
             },
+            {
+                regex: /import\(\s*'(\S+)?'\s*\)/g,
+                replacer: async (pathTofile, importPath) => `import('${await toESM(pathTofile, importPath)}')`
+            },
         ];
         const updateImports = async (pathToEntry) => {
             let content = await FileSystemUtils.file.read(pathToEntry);
@@ -499,4 +540,3 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
     }
     ;
 }
-//# sourceMappingURL=Unit_TypescriptLib.js.map

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

@@ -1,7 +1,8 @@
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../index.js';
 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 = {
@@ -23,6 +24,7 @@ export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     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;
@@ -48,11 +50,12 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     private getEnvConfig;
     private resolveFunctionsRC;
     private resolveProxyFile;
+    private pathToProxy;
     private resolveConfigDir;
     private resolveFunctionsJSON;
     private resolveFunctionsRuntimeConfig;
     private createAppVersionFile;
-    protected deriveDistDependencies(): import("@nu-art/ts-common").StringMap;
+    protected deriveDistDependencies(): StringMap;
     private createDependenciesDir;
     private runProxy;
     private runEmulator;

package/v3/units/firebase/Unit_FirebaseFunctionsApp.js

@@ -1,11 +1,13 @@
-import { Unit_TypescriptLib } from '../index.js';
-import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_PackageJSON } from '../../../core/consts.js';
+import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON } from '../../../core/consts.js';
 import { promises as _fs } from 'fs';
-import { __stringify, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, reduceObject, Second, sleep } from '@nu-art/ts-common';
+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',
 ];
@@ -14,6 +16,7 @@ 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',
@@ -45,11 +48,20 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         const distDependencies = this.deriveDistDependencies();
         packageJson.main = 'index.js';
         packageJson.types = 'index.d.ts';
-        if (packageJson.dependencies)
-            packageJson.dependencies = reduceObject(packageJson.dependencies, packageJson.dependencies, (acc, key, value) => {
-                acc[key] = distDependencies[key] ?? value;
-                return acc;
-            });
+        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() {
@@ -59,6 +71,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 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() {
@@ -89,8 +102,19 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
             .ls()
             .cat('package.json')
             .cat('index.js')
-            .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `firebase --debug deploy --only functions --force`);
+            .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, `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 #########################
     getEnvConfig() {
@@ -118,7 +142,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     }
     async resolveProxyFile() {
         const envConfig = this.getEnvConfig();
-        const targetPath = `${this.config.fullPath}/src/main/proxy.ts`;
+        const targetPath = this.pathToProxy();
         const path = this.runtimeContext.baiConfig.files?.backend?.proxy;
         if (!path)
             return;
@@ -131,15 +155,13 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         };
         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}`;
-        try {
-            await _fs.access(pathToFirebaseConfigFolder);
-        }
-        catch (e) {
-            await _fs.mkdir(pathToFirebaseConfigFolder, { recursive: true });
-        }
+        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) {
@@ -148,11 +170,10 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         }
         await Promise.all(Const_FirebaseConfigKeys.map(async (firebaseConfigKey) => {
             const pathToConfigFile = `${pathToFirebaseConfigFolder}/${Const_FirebaseDefaultsKeyToFile[firebaseConfigKey]}`;
-            const path = defaultFiles[firebaseConfigKey];
-            if (!path)
+            if (!defaultFiles[firebaseConfigKey])
                 return;
-            const defaultFileContent = await _fs.readFile(path, { encoding: 'utf-8' });
-            await _fs.writeFile(pathToConfigFile, defaultFileContent, { encoding: 'utf-8' });
+            const path = resolve(this.runtimeContext.parentUnit.config.fullPath, defaultFiles[firebaseConfigKey]);
+            await FileSystemUtils.file.copy(path, pathToConfigFile);
         }));
     }
     async resolveFunctionsJSON() {
@@ -205,6 +226,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 functions: {
                     source: this.config.output.replace(`${this.config.fullPath}/`, ''),
                     ignore: this.config.ignore,
+                    runtime: 'nodejs22',
                 }
             };
         }
@@ -233,18 +255,14 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         // await _fs.writeFile(targetPath, fileContent, {encoding: 'utf-8'});
     }
     deriveDistDependencies() {
-        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
-        const dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
-        return dependencyUnits.reduce((dependencies, unit) => {
+        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
-        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
-        const dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
-        await Promise.all(dependencyUnits.map(async (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}/`;
@@ -259,7 +277,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         await this.resolveProxyFile();
         const commando = this.allocateCommando(Commando_NVM).applyNVM()
             .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, 'tsx src/main/proxy.ts');
+        const command = `${this.runtimeContext.parentUnit.config.fullPath}/${CONST_NodeModules}/.bin/tsx`;
+        await this.executeAsyncCommando(commando, `${command} src/main/proxy.ts`);
         this.logWarning('PROXY TERMINATED');
     }
     async runEmulator() {
@@ -278,4 +297,3 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         this.logWarning('EMULATORS TERMINATED');
     }
 }
-//# sourceMappingURL=Unit_FirebaseFunctionsApp.js.map