@nu-art/build-and-install 0.400.3 → 0.400.4

package/build-and-install-v3.js

@@ -9,10 +9,10 @@ import { PhaseManager } from './v3/PhaseManager.js';
 import { Unit_NodeProject } from './v3/units/index.js';
 import { resolve } from 'path';
 import { CONST_BaiConfig, CONST_NodeModules } from './core/consts.js';
-import { FileSystemUtils } from './v3/core/FileSystemUtils.js';
 import { UnitMapper_FirebaseFunction, UnitMapper_FirebaseHosting, UnitMapper_NodeLib, UnitMapper_NodeProject } from './v3/UnitsMapper/resolvers/index.js';
 import { CLIParamsResolver } from '@nu-art/commando/cli-params/CLIParamsResolver';
 import { RunningStatusHandler } from './v3/RunningStatusHandler.js';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export const DefaultPhases = [
     ...phases_Build,
     ...phases_Launch,

package/core/params/params.d.ts

@@ -32,8 +32,9 @@ export declare const BaiParam_Verbose: BaseCliParam<'verbose', boolean>;
 export declare const BaiParam_QuickDeploy: BaseCliParam<'quickDeploy', boolean>;
 type PromoteType = 'patch' | 'minor' | 'major';
 export declare const BaiParam_Publish: BaseCliParam<'publish', PromoteType>;
-export declare const BaiParam_PublishDryRun: BaseCliParam<'publishDryRun', boolean>;
 export declare const BaiParam_UsePackage: BaseCliParam<'usePackage', string[]>;
-export declare const AllBaiParams: (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", PromoteType> | BaseCliParam<"publishDryRun", boolean> | BaseCliParam<"usePackage", string[]>)[];
+export declare const BaiParam_ToESM: BaseCliParam<'toESM', boolean>;
+export declare const BaiParam_Simulate: BaseCliParam<'simulation', boolean>;
+export declare const AllBaiParams: (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", PromoteType> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean>)[];
 export type BaiParams = CliParams<typeof AllBaiParams>;
 export {};

package/core/params/params.js

@@ -226,13 +226,6 @@ export const BaiParam_Publish = {
     description: 'Will publish to NPM any package that is not marked as private in its __package.json   \nenum options: patch | minor | major \nDefault Param: patch',
     process: (part) => part ?? 'patch'
 };
-export const BaiParam_PublishDryRun = {
-    keys: ['--publish-dry-run'],
-    keyName: 'publishDryRun',
-    type: 'boolean',
-    group: 'Other',
-    description: 'Will pack and prepare a package for publish, but will NOT publish to NPM any package',
-};
 export const BaiParam_UsePackage = {
     keys: ['-up', '--use-packages'],
     keyName: 'usePackage',
@@ -246,6 +239,22 @@ export const BaiParam_UsePackage = {
     },
     dependencies: [{ param: BaiParam_AllUnits, value: true }]
 };
+export const BaiParam_ToESM = {
+    keys: ['-tesm', '--to-esm'],
+    keyName: 'toESM',
+    type: 'boolean',
+    group: 'Other',
+    description: 'Will migrate existing CJS code to ESM',
+    dependencies: [{ param: BaiParam_AllUnits, value: true }]
+};
+export const BaiParam_Simulate = {
+    keys: ['--simulate', '-sim'],
+    keyName: 'simulation',
+    type: 'boolean',
+    group: 'Other',
+    description: 'In combination with other params, will not perform the outbound operation, but instead simulate it',
+    dependencies: [{ param: BaiParam_AllUnits, value: true }]
+};
 export const AllBaiParams = [
     BaiParam_AllUnits,
     BaiParam_DependencyTree,
@@ -274,8 +283,9 @@ export const AllBaiParams = [
     BaiParam_DebugBackend,
     BaiParam_Debug,
     BaiParam_Verbose,
-    BaiParam_PublishDryRun,
     BaiParam_Publish,
     BaiParam_UsePackage,
+    BaiParam_ToESM,
+    BaiParam_Simulate,
     BaiParam_DebugLifecycle
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.400.3",
+  "version": "0.400.4",
   "description": "",
   "type": "module",
   "keywords": [
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/ts-common": "0.400.3",
-    "@nu-art/commando": "0.400.3"
+    "@nu-art/ts-common": "0.400.4",
+    "@nu-art/commando": "0.400.4"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/v3/UnitsDependencyMapper/UnitsDependencyMapper.js

@@ -1,5 +1,5 @@
 import { __stringify, _keys, _values, BadImplementationException, DateTimeFormat_yyyyMMDDTHHmmss, deepClone, Logger, reduceObject, sortArray } from '@nu-art/ts-common';
-import { FileSystemUtils } from '../core/FileSystemUtils.js';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 import { resolve } from 'path';
 /**
  * Maps unit dependencies and provides tools to analyze and operate on the dependency graph.

package/v3/UnitsMapper/resolvers/UnitMapper_Node.js

@@ -1,7 +1,7 @@
 import { _keys, deepClone, tsValidate, tsValidateBoolean, tsValidateOptionalAnyString, tsValidateResult } from '@nu-art/ts-common';
 import { FilesCache } from '../../core/FilesCache.js';
 import { UnitMapper_Base } from './UnitMapper_Base.js';
-import { FileSystemUtils } from '../../core/FileSystemUtils.js';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export class UnitMapper_Node extends UnitMapper_Base {
     static invalidPaths = [];
     static tsValidator_Node = {

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<"publishDryRun", boolean> | BaseCliParam<"usePackage", string[]> | 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>)[];
 export type Help_BaiParams = CliParams<typeof AllBaiParams_Help>;
 export type Phase_Help = typeof phase_Help;
 export declare const phaseKey_Help = "help";

package/v3/phase/consts.d.ts

@@ -5,6 +5,9 @@ export declare const phase_PrintDependencyTree: Phase<'printDependencyTree'>;
 export type Phase_CheckCyclicImports = typeof phase_CheckCyclicImports;
 export declare const phaseKey_CheckCyclicImports = "check-cyclic-imports";
 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 type Phase_Purge = typeof phase_Purge;
 export declare const phaseKey_Purge = "purge";
 export declare const phase_Purge: Phase<'purge'>;
@@ -37,9 +40,6 @@ export type Phase_Launch = typeof phase_Launch;
 export declare const phaseKey_Launch = "launch";
 export declare const phase_Launch: Phase<'launch'>;
 export declare const phases_Launch: Phase<string>[][];
-export type Phase_PublishDryRun = typeof phase_PublishDryRun;
-export declare const phaseKey_PublishDryRun = "publishDryRun";
-export declare const phase_PublishDryRun: Phase<'publishDryRun'>;
 export type Phase_Publish = typeof phase_Publish;
 export declare const phaseKey_Publish = "publish";
 export declare const phase_Publish: Phase<'publish'>;

package/v3/phase/consts.js

@@ -14,6 +14,13 @@ export const phase_CheckCyclicImports = {
     filter: (baiParams) => baiParams.checkCyclicImports,
     terminateAfterPhase: true,
 };
+export const phaseKey_ToESM = 'convertToESM';
+export const phase_ToESM = {
+    key: phaseKey_ToESM,
+    name: 'ToESM',
+    method: 'convertToESM',
+    filter: (baiParams) => !baiParams.noBuild,
+};
 export const phaseKey_Purge = 'purge';
 export const phase_Purge = {
     key: phaseKey_Purge,
@@ -95,13 +102,6 @@ export const phase_Launch = {
 export const phases_Launch = [[
         phase_Launch,
     ]];
-export const phaseKey_PublishDryRun = 'publishDryRun';
-export const phase_PublishDryRun = {
-    key: phaseKey_PublishDryRun,
-    name: 'PublishDryRun',
-    method: 'publishDryRun',
-    filter: (baiParams) => baiParams.publishDryRun,
-};
 export const phaseKey_Publish = 'publish';
 export const phase_Publish = {
     key: phaseKey_Publish,
@@ -123,4 +123,4 @@ export const phase_Deploy = {
     method: 'deploy',
     filter: (baiParams) => !!baiParams.deploy,
 };
-export const phases_Deploy = [[phase_PublishDryRun, phase_Publish, phase_Deploy], [phase_PostPublish]];
+export const phases_Deploy = [[phase_Publish, phase_Deploy], [phase_PostPublish]];

package/v3/units/Unit_NodeProject.js

@@ -6,13 +6,13 @@ import { Commando_PNPM } from '@nu-art/commando/shell/plugins/pnpm';
 import { PNPM } from '@nu-art/commando/shell/services/pnpm';
 import { Unit_PackageJson } from './Unit_PackageJson.js';
 import { resolve } from 'path';
-import { FileSystemUtils } from '../core/FileSystemUtils.js';
 import { PhaseManager } from '../PhaseManager.js';
 import { phase_CompileWatch } from '../phase/index.js';
 import { UnitsDependencyMapper } from '../UnitsDependencyMapper/UnitsDependencyMapper.js';
 import { CommandoException } from '@nu-art/commando/shell/core/CliError';
 import { CONST_PNPM_LOCK, CONST_PNPM_WORKSPACE } from '../../core/consts.js';
 import { RunningStatusHandler } from '../RunningStatusHandler.js';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export class Unit_NodeProject extends Unit_PackageJson {
     watcher;
     innerUnits = [];

package/v3/units/Unit_PackageJson.js

@@ -2,8 +2,8 @@ import { CONST_NodeModules, CONST_PackageJSON } from '../../core/consts.js';
 import { __stringify } from '@nu-art/ts-common';
 import { ProjectUnit } from './ProjectUnit.js';
 import { resolve } from 'path';
-import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '../core/FileSystemUtils.js';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
+import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export class Unit_PackageJson extends ProjectUnit {
     constructor(config) {
         super(config);

package/v3/units/Unit_TypescriptLib.d.ts

@@ -1,14 +1,14 @@
 import { TypedMap } from '@nu-art/ts-common';
 import { UnitPhaseImplementor } from '../core/types.js';
 import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
-import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_PublishDryRun, Phase_Test } from '../phase/index.js';
+import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_Test, Phase_ToESM } from '../phase/index.js';
 export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
     customESLintConfig: boolean;
     customTSConfig: boolean;
     hasSelfHotReload: boolean;
     output: string;
 };
-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_PublishDryRun]> {
+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>;
     constructor(config: Unit_TypescriptLib<C>['config']);
@@ -40,6 +40,6 @@ export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Un
     private resolveESLintConfig;
     protected deriveTSConfigPaths(): TypedMap<string[]>;
     protected resolveTSConfig(srcFolder: string, sourceFolderType: string): Promise<void>;
-    publishDryRun(): Promise<void>;
     publish(): Promise<void>;
+    convertToESM(): Promise<void>;
 }

package/v3/units/Unit_TypescriptLib.js

@@ -1,15 +1,16 @@
 import * as fs from 'fs';
 import { copyFileSync, existsSync, promises as _fs, readdirSync, statSync } from 'fs';
-import { __stringify, BadImplementationException, ImplementationMissingException, LogLevel, NotImplementedYetException } from '@nu-art/ts-common';
-import { CONST_BaiConfig, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON, CONST_TS_CONFIG } from '../../core/consts.js';
+import { __stringify, arrayToMap, BadImplementationException, exists, 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';
 import { Commando_Basic } from '@nu-art/commando/shell/plugins/basic';
 import { resolve, resolve as pathResolve } from 'path';
 import { Unit_PackageJson } from './Unit_PackageJson.js';
-import { DEFAULT_OLD_TEMPLATE_PATTERN, DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '../core/FileSystemUtils.js';
 import { glob } from 'node:fs/promises';
 import { TestTypes } from '../../core/params/params.js';
+import { DEFAULT_OLD_TEMPLATE_PATTERN, DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import path from 'node:path';
 const assetExtensions = [
     'json',
     'scss',
@@ -145,8 +146,6 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         if (this.config.packageJson.private) {
             // @ts-ignore
             this.publish = undefined;
-            // @ts-ignore
-            this.publishDryRun = undefined;
         }
     }
     async compileImpl() {
@@ -355,27 +354,148 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         this.logError(`Missing tsconfig templates for source folder: ${sourceFolderType}`);
         throw new ImplementationMissingException(`Missing tsconfig template for source folder: ${sourceFolderType}`);
     }
-    async publishDryRun() {
-        if (this.config.packageJson.private)
-            return this.logWarning(`Not publishing a private package`);
-        this.logDebug(`Creating NPM Package`);
-        await this.allocateCommando(Commando_Basic)
-            .cd(this.config.output)
-            .append('npm pack --pack-destination ./..')
-            .execute();
-        this.logDebug(`Publishing Dry Run`);
-        await this.allocateCommando(Commando_Basic)
-            .cd(this.config.output)
-            .append('npm publish --dry-run')
-            .execute();
-    }
     async publish() {
         if (this.config.packageJson.private)
             return this.logInfo(`Not publishing a private package`);
+        if (this.runtimeContext.runtimeParams.simulation) {
+            this.logWarning(` ===> Publish Simulation -STARTED <=== `);
+            this.logDebug(`Creating NPM Package`);
+            await this.allocateCommando(Commando_Basic)
+                .cd(this.config.output)
+                .append('npm pack --pack-destination ./..')
+                .execute();
+            this.logDebug(`Publishing Dry Run`);
+            await this.allocateCommando(Commando_Basic)
+                .cd(this.config.output)
+                .append('npm publish --dry-run')
+                .execute();
+            this.logWarning(` ===> Publish Simulation - ENDED <=== `);
+            return;
+        }
         this.logDebug(`Publishing Package - For REAL`);
         await this.allocateCommando(Commando_Basic)
             .cd(this.config.output)
             .append('npm publish --access public')
             .execute();
     }
+    async convertToESM() {
+        const ignore = ['node_modules', '.git', 'dist', '.gitignore', 'build'];
+        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;
+            for (const extension of fileExtensions) {
+                if (!importPath.endsWith(extension))
+                    continue;
+                importPath = importPath.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('/');
+                }
+            }
+            if (!exists(initialPath) || !exists(relativePathToFile))
+                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;
+        };
+        const importMatchers = [
+            {
+                regex: /from\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: /import\(\s*["']([^"']+)["']\s*\)/g,
+                replacer: async (pathTofile, importPath) => `import("${await toESM(pathTofile, importPath)}")`
+            },
+        ];
+        const updateImports = async (pathToEntry) => {
+            let content = await FileSystemUtils.file.read(pathToEntry);
+            this.logDebug('Processing file: ', pathToEntry);
+            for (const { regex, replacer } of importMatchers) {
+                const matches = [];
+                let match;
+                regex.lastIndex = 0;
+                while ((match = regex.exec(content))) {
+                    matches.push({ original: match[0], path: match[1], index: match.index });
+                    regex.lastIndex = match.index + match[0].length;
+                }
+                for (const { original, path } of matches) {
+                    const replacement = await replacer(pathToEntry, path);
+                    // Replace all exact original strings globally
+                    content = content.split(original).join(replacement);
+                }
+            }
+            if (!this.runtimeContext.runtimeParams.simulation)
+                await FileSystemUtils.file.write(pathToEntry, content);
+        };
+        const migratePackageJSON = async (pathToEntry) => {
+            const packageJson = JSON.parse(await FileSystemUtils.file.read(pathToEntry));
+            if (!packageJson.name.startsWith('@nu-art/'))
+                packageJson.private = packageJson.private ?? true;
+            packageJson.type = packageJson.type ?? 'module';
+            packageJson.exports = packageJson.exports ?? {
+                '.': {
+                    'types': './index.d.ts',
+                    'import': './index.js'
+                },
+                './*': {
+                    'types': './*.d.ts',
+                    'import': './*.js'
+                }
+            };
+            if (!this.runtimeContext.runtimeParams.simulation)
+                await FileSystemUtils.file.write(pathToEntry, __stringify(packageJson, true));
+        };
+        await FileSystemUtils.folder.iterate(this.config.fullPath, {
+            filter: async (pathToEntry) => {
+                const name = path.basename(pathToEntry);
+                if (ignore.includes(name))
+                    return false;
+                if (await FileSystemUtils.folder.isFolder(pathToEntry))
+                    return true;
+                if (!await FileSystemUtils.file.isFile(pathToEntry)) {
+                    this.logWarning(`NOT a file or folder: ${pathToEntry}`);
+                    return false;
+                }
+                if (specificFiles.includes(name))
+                    return true;
+                const fileExtension = path.extname(pathToEntry);
+                return fileExtensions.includes(fileExtension.toLowerCase());
+            },
+            processor: async (pathToEntry) => {
+                const name = path.basename(pathToEntry);
+                const fileExtension = path.extname(pathToEntry);
+                if (name === CONST_PackageJSONTemplate)
+                    return await migratePackageJSON(pathToEntry);
+                if (fileExtensions.includes(fileExtension.toLowerCase()))
+                    return await updateImports(pathToEntry);
+            },
+        });
+    }
+    ;
 }

package/v3/units/firebase/Unit_FirebaseFunctionsApp.js

@@ -4,8 +4,8 @@ import { promises as _fs } from 'fs';
 import { __stringify, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, reduceObject, 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 { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '../../core/FileSystemUtils.js';
 import { resolve } from 'path';
+import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export const firebaseFunctionEmulator_ErrorStrings = [
     'functions: Failed',
 ];

package/v3/core/FileSystemUtils.d.ts

@@ -1,34 +0,0 @@
-import { StringMap } from '@nu-art/ts-common';
-export declare const DEFAULT_TEMPLATE_PATTERN: RegExp;
-export declare const DEFAULT_OLD_TEMPLATE_PATTERN: RegExp;
-export declare const FileSystemUtils: {
-    file: {
-        exists: (pathToFile: string) => Promise<boolean>;
-        delete: (pathToFile: string, mustExist?: boolean) => Promise<void>;
-        write: (pathToFile: string, content: string) => Promise<void>;
-        read: (pathToFile: string) => Promise<string>;
-        copy: (sourcePath: string, targetPath: string) => Promise<void>;
-        template: {
-            read: (pathToFile: string, params: StringMap, pattern?: RegExp) => Promise<string>;
-            transform: (input: string, params: StringMap, pattern?: RegExp) => string;
-            write: (pathToFile: string, content: string, params: StringMap, pattern?: RegExp) => Promise<void>;
-            copy: (sourcePath: string, targetPath: string, params: StringMap, pattern?: RegExp) => Promise<void>;
-        };
-    };
-    folder: {
-        delete: (pathToFolder: string, mustExist?: boolean) => Promise<void>;
-        empty: (pathToFolder: string, mustExist?: boolean) => Promise<void>;
-        create: (pathToFolder: string) => Promise<string | void>;
-        list: ((pathToFolder: string) => Promise<string[]>) & {
-            forEach: ((pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>) & {
-                file: (pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>;
-                folder: (pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>;
-            };
-        };
-    };
-    symlink: {
-        create: (targetPath: string, linkPath: string) => Promise<void>;
-        delete: (pathToLink: string, mustExist?: boolean) => Promise<void>;
-        read: (pathToLink: string) => Promise<string>;
-    };
-};

package/v3/core/FileSystemUtils.js

@@ -1,151 +0,0 @@
-import { promises as _fs } from 'fs';
-import { resolve } from 'path';
-import { BadImplementationException, exists } from '@nu-art/ts-common';
-async function isFile(path) {
-    return (await _fs.stat(path)).isFile();
-}
-async function isFolder(path) {
-    return (await _fs.stat(path)).isDirectory();
-}
-async function assertFile(path) {
-    if (!(await isFile(path)))
-        throw new BadImplementationException(`Expected file but found directory or non-file: ${path}`);
-}
-async function assertFolder(path) {
-    if (!(await isFolder(path)))
-        throw new BadImplementationException(`Expected folder but found file or non-directory: ${path}`);
-}
-async function fileExists(path) {
-    try {
-        await _fs.access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertExists(path, mustExist, type) {
-    const doesExist = await fileExists(path);
-    if (!doesExist) {
-        if (mustExist)
-            throw new BadImplementationException(`${type} does not exist: ${path}`);
-        return false;
-    }
-    return true;
-}
-const escapeRegExp = (string) => string.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-export const DEFAULT_TEMPLATE_PATTERN = new RegExp(`\{\{(\\S*?)\}\}`);
-export const DEFAULT_OLD_TEMPLATE_PATTERN = new RegExp(`(?<!\\\\)\\$([a-zA-Z]\\w{2,})`);
-export const FileSystemUtils = {
-    file: {
-        exists: async (pathToFile) => {
-            return await fileExists(pathToFile);
-        },
-        delete: async (pathToFile, mustExist = false) => {
-            if (!await assertExists(pathToFile, mustExist, 'File'))
-                return;
-            await assertFile(pathToFile);
-            return _fs.rm(pathToFile);
-        },
-        write: async (pathToFile, content) => {
-            await FileSystemUtils.folder.create(resolve(pathToFile, '..'));
-            return _fs.writeFile(pathToFile, content, 'utf-8');
-        },
-        read: async (pathToFile) => {
-            await assertFile(pathToFile);
-            return _fs.readFile(pathToFile, 'utf-8');
-        },
-        copy: async (sourcePath, targetPath) => {
-            await assertExists(targetPath, false, 'File');
-            await assertFile(sourcePath);
-            await FileSystemUtils.folder.create(resolve(targetPath, '..'));
-            return _fs.copyFile(sourcePath, targetPath);
-        },
-        template: {
-            read: async (pathToFile, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const content = await FileSystemUtils.file.read(pathToFile);
-                return FileSystemUtils.file.template.transform(content, params, pattern);
-            },
-            transform: (input, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                let match;
-                while (match = input.match(pattern)) {
-                    const value = params[match[1]];
-                    if (!exists(value))
-                        throw new BadImplementationException(`Missing template param: ${match[1]}`);
-                    const fullMatchRegex = new RegExp(escapeRegExp(match[0]), 'g');
-                    input = input.replace(fullMatchRegex, value);
-                }
-                return input;
-            },
-            write: async (pathToFile, content, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const transformedContent = FileSystemUtils.file.template.transform(content, params, pattern);
-                return FileSystemUtils.file.write(pathToFile, transformedContent);
-            },
-            copy: async (sourcePath, targetPath, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const content = await FileSystemUtils.file.read(sourcePath);
-                const transformedContent = FileSystemUtils.file.template.transform(content, params, pattern);
-                return FileSystemUtils.file.write(targetPath, transformedContent);
-            }
-        },
-    },
-    folder: {
-        delete: async (pathToFolder, mustExist = false) => {
-            if (!await assertExists(pathToFolder, mustExist, 'Folder'))
-                return;
-            await assertFolder(pathToFolder);
-            return _fs.rm(pathToFolder, { recursive: true, force: true });
-        },
-        empty: async (pathToFolder, mustExist = true) => {
-            if (!await assertExists(pathToFolder, mustExist, 'Folder'))
-                return;
-            await assertFolder(pathToFolder);
-            const entries = await _fs.readdir(pathToFolder);
-            await Promise.all(entries.map(entry => _fs.rm(resolve(pathToFolder, entry), { recursive: true, force: true })));
-        },
-        create: async (pathToFolder) => {
-            if (await fileExists(pathToFolder))
-                return assertFolder(pathToFolder);
-            return _fs.mkdir(pathToFolder, { recursive: true });
-        },
-        list: Object.assign(async (pathToFolder) => {
-            return await _fs.readdir(pathToFolder);
-        }, {
-            forEach: Object.assign(async (pathToFolder, callback) => {
-                const entries = await _fs.readdir(pathToFolder);
-                for (const entry of entries)
-                    await callback(resolve(pathToFolder, entry));
-            }, {
-                file: async (pathToFolder, callback) => {
-                    await FileSystemUtils.folder.list.forEach(pathToFolder, async (entry) => {
-                        if (!await isFile(entry))
-                            return;
-                        await callback(entry);
-                    });
-                },
-                folder: async (pathToFolder, callback) => {
-                    await FileSystemUtils.folder.list.forEach(pathToFolder, async (entry) => {
-                        if (!await isFolder(entry))
-                            return;
-                        await callback(entry);
-                    });
-                }
-            })
-        })
-    },
-    symlink: {
-        create: async (targetPath, linkPath) => {
-            return _fs.symlink(targetPath, linkPath);
-        },
-        delete: async (pathToLink, mustExist = false) => {
-            if (!await assertExists(pathToLink, mustExist, 'Symlink'))
-                return;
-            const stat = await _fs.lstat(pathToLink);
-            if (!stat.isSymbolicLink())
-                throw new BadImplementationException(`Expected symlink but found something else: ${pathToLink}`);
-            return _fs.unlink(pathToLink);
-        },
-        read: async (pathToLink) => {
-            return _fs.readlink(pathToLink);
-        }
-    }
-};