@unisphere/nx 2.2.2 → 3.2.3

package/dist/migrations/3-0-0/add-define-plugin-to-webpack.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const dotenv_1 = require("dotenv");
+const DEFINE_PLUGIN_IMPORT = "const { DefinePlugin } = require('webpack');";
+/**
+ * Detect the type of an env value
+ */
+function detectType(value) {
+    if (value === 'true' || value === 'false') {
+        return 'boolean';
+    }
+    if (!isNaN(Number(value)) && value !== '') {
+        return 'number';
+    }
+    return 'string';
+}
+/**
+ * Parse .env file content using dotenv and add type detection
+ */
+function parseEnvFile(content) {
+    const parsed = (0, dotenv_1.parse)(Buffer.from(content));
+    return Object.entries(parsed).map(([key, value]) => ({
+        key,
+        value: value || '',
+        type: detectType(value || ''),
+    }));
+}
+/**
+ * Generate DefinePlugin block with env variables
+ */
+function generateDefinePluginBlock(envVars) {
+    if (envVars.length === 0) {
+        return `new DefinePlugin({
+      // Add your environment variables here
+      // Example: 'process.env.API_URL': JSON.stringify(process.env.API_URL),
+    }),`;
+    }
+    const entries = envVars.map(({ key, type }) => {
+        if (type === 'boolean') {
+            return `      'process.env.${key}': process.env.${key} === 'true',`;
+        }
+        else if (type === 'number') {
+            return `      'process.env.${key}': Number(process.env.${key}),`;
+        }
+        else {
+            return `      'process.env.${key}': JSON.stringify(process.env.${key}),`;
+        }
+    });
+    return `new DefinePlugin({
+${entries.join('\n')}
+    }),`;
+}
+/**
+ * Generate .env-template content from parsed env variables
+ */
+function generateEnvTemplate(envVars) {
+    const header = `# Environment variables template
+# Copy this file to .env and fill in the values
+# Do not commit .env to version control
+
+`;
+    if (envVars.length === 0) {
+        return header + `# Example:
+# API_URL=https://api.example.com
+`;
+    }
+    const entries = envVars.map(({ key, value, type }) => {
+        const typeComment = type !== 'string' ? ` # ${type}` : '';
+        return `${key}=${value}${typeComment}`;
+    });
+    return header + entries.join('\n') + '\n';
+}
+/**
+ * Merge env variables from two sources, preferring values from the first source
+ */
+function mergeEnvVars(primary, secondary) {
+    const merged = new Map();
+    // Add secondary first (will be overwritten by primary)
+    for (const envVar of secondary) {
+        merged.set(envVar.key, envVar);
+    }
+    // Add primary (overwrites secondary)
+    for (const envVar of primary) {
+        merged.set(envVar.key, envVar);
+    }
+    return Array.from(merged.values());
+}
+async function update(tree) {
+    devkit_1.logger.info('🔄 Adding DefinePlugin to application webpack configs');
+    try {
+        // Read .unisphere config
+        if (!tree.exists('.unisphere')) {
+            devkit_1.logger.warn('⚠️ No .unisphere file found, skipping');
+            return;
+        }
+        const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+        const applications = unisphereConfig.elements?.applications;
+        if (!applications || Object.keys(applications).length === 0) {
+            devkit_1.logger.info('ℹ️ No applications found, skipping');
+            return;
+        }
+        let webpackUpdatedCount = 0;
+        let envTemplateCreatedCount = 0;
+        for (const [appName, appConfig] of Object.entries(applications)) {
+            const appPath = appConfig.sourceRoot;
+            const webpackPath = (0, path_1.join)(appPath, 'webpack.config.js');
+            const envPath = (0, path_1.join)(appPath, '.env');
+            const envTemplatePath = (0, path_1.join)(appPath, '.env-template');
+            // Skip if neither .env nor .env-template exists - don't touch anything
+            const hasEnv = tree.exists(envPath);
+            const hasEnvTemplate = tree.exists(envTemplatePath);
+            if (!hasEnv && !hasEnvTemplate) {
+                devkit_1.logger.info(`ℹ️ ${appName}: No .env or .env-template found, skipping`);
+                continue;
+            }
+            // Parse env files and merge (template values take priority)
+            let envVars = [];
+            let envVarsFromEnv = [];
+            let envVarsFromTemplate = [];
+            if (hasEnv) {
+                const envContent = tree.read(envPath, 'utf-8') || '';
+                envVarsFromEnv = parseEnvFile(envContent);
+                devkit_1.logger.info(`ℹ️ ${appName}: Found ${envVarsFromEnv.length} env variable(s) in .env`);
+            }
+            if (hasEnvTemplate) {
+                const templateContent = tree.read(envTemplatePath, 'utf-8') || '';
+                envVarsFromTemplate = parseEnvFile(templateContent);
+                devkit_1.logger.info(`ℹ️ ${appName}: Found ${envVarsFromTemplate.length} env variable(s) in .env-template`);
+            }
+            // Merge: .env-template values take priority over .env values
+            envVars = mergeEnvVars(envVarsFromTemplate, envVarsFromEnv);
+            devkit_1.logger.info(`ℹ️ ${appName}: Using ${envVars.length} merged env variable(s)`);
+            // Handle webpack.config.js
+            if (tree.exists(webpackPath)) {
+                let webpackContent = tree.read(webpackPath, 'utf-8') || '';
+                let updated = false;
+                // Check if DefinePlugin is already imported
+                if (!webpackContent.includes('DefinePlugin')) {
+                    // Add DefinePlugin import after NxReactWebpackPlugin import
+                    if (webpackContent.includes("require('@nx/react/webpack-plugin')")) {
+                        webpackContent = webpackContent.replace("require('@nx/react/webpack-plugin');", `require('@nx/react/webpack-plugin');\n${DEFINE_PLUGIN_IMPORT}`);
+                    }
+                    else if (webpackContent.includes("require('@nx/webpack/app-plugin')")) {
+                        // Fallback: add after NxAppWebpackPlugin import
+                        webpackContent = webpackContent.replace("require('@nx/webpack/app-plugin');", `require('@nx/webpack/app-plugin');\n${DEFINE_PLUGIN_IMPORT}`);
+                    }
+                    // Add DefinePlugin to plugins array with env variables
+                    const definePluginBlock = generateDefinePluginBlock(envVars);
+                    if (webpackContent.includes('plugins: [')) {
+                        webpackContent = webpackContent.replace('plugins: [', `plugins: [\n    ${definePluginBlock}`);
+                    }
+                    updated = true;
+                    devkit_1.logger.info(`✅ ${appName}: Added DefinePlugin to webpack.config.js with ${envVars.length} variable(s)`);
+                }
+                else {
+                    // DefinePlugin exists - replace it entirely with variables from .env
+                    // Find the DefinePlugin block - match opening and find balanced closing
+                    const defineStartMatch = webpackContent.match(/new DefinePlugin\(\{/);
+                    if (defineStartMatch && defineStartMatch.index !== undefined) {
+                        const startIndex = defineStartMatch.index;
+                        let braceCount = 0;
+                        let endIndex = startIndex;
+                        let foundStart = false;
+                        // Find the balanced closing })
+                        for (let i = startIndex; i < webpackContent.length; i++) {
+                            const char = webpackContent[i];
+                            if (char === '{') {
+                                braceCount++;
+                                foundStart = true;
+                            }
+                            else if (char === '}') {
+                                braceCount--;
+                                if (foundStart && braceCount === 0) {
+                                    // Found the closing }, now check for )
+                                    if (webpackContent[i + 1] === ')') {
+                                        endIndex = i + 2; // Include the )
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        const existingBlock = webpackContent.substring(startIndex, endIndex);
+                        // Generate new DefinePlugin block from env vars
+                        const newBlock = generateDefinePluginBlock(envVars);
+                        // Remove trailing comma from generateDefinePluginBlock output
+                        const newBlockWithoutComma = newBlock.replace(/,\s*$/, '');
+                        webpackContent = webpackContent.replace(existingBlock, newBlockWithoutComma);
+                        updated = true;
+                        devkit_1.logger.info(`✅ ${appName}: Replaced DefinePlugin with ${envVars.length} variable(s) from .env`);
+                    }
+                    else {
+                        devkit_1.logger.warn(`⚠️ ${appName}: Could not find DefinePlugin block to update`);
+                    }
+                }
+                if (updated) {
+                    tree.write(webpackPath, webpackContent);
+                    webpackUpdatedCount++;
+                }
+            }
+            else {
+                devkit_1.logger.info(`ℹ️ ${appName}: No webpack.config.js found, skipping`);
+            }
+            // Create or update .env-template with merged variables
+            const templateKeys = new Set(envVarsFromTemplate.map((v) => v.key));
+            const hasNewVarsFromEnv = envVarsFromEnv.some((v) => !templateKeys.has(v.key));
+            if (!hasEnvTemplate) {
+                // Create new .env-template from .env variables
+                const envTemplateContent = generateEnvTemplate(envVars);
+                tree.write(envTemplatePath, envTemplateContent);
+                devkit_1.logger.info(`✅ ${appName}: Created .env-template`);
+                envTemplateCreatedCount++;
+            }
+            else if (hasEnv && hasNewVarsFromEnv) {
+                // Update .env-template with merged variables (new vars from .env)
+                const envTemplateContent = generateEnvTemplate(envVars);
+                tree.write(envTemplatePath, envTemplateContent);
+                devkit_1.logger.info(`✅ ${appName}: Updated .env-template with new variables from .env`);
+                envTemplateCreatedCount++;
+            }
+            else {
+                devkit_1.logger.info(`✅ ${appName}: .env-template already up to date`);
+            }
+        }
+        devkit_1.logger.info(`\n✅ Done: ${webpackUpdatedCount} webpack configs updated, ${envTemplateCreatedCount} .env-template files created`);
+    }
+    catch (error) {
+        devkit_1.logger.error(`❌ Failed to update webpack configs: ${error?.message || 'Unknown error'}`);
+        throw error;
+    }
+}

package/dist/migrations/3-0-0/add-env-to-application-gitignore.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=add-env-to-application-gitignore.d.ts.map

package/dist/migrations/3-0-0/add-env-to-application-gitignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-env-to-application-gitignore.d.ts","sourceRoot":"","sources":["../../../src/migrations/3-0-0/add-env-to-application-gitignore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,YAAY,CAAC;AAsDpD,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAkF9D"}

package/dist/migrations/3-0-0/add-env-to-application-gitignore.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ENV_GITIGNORE_ENTRIES = `.env`;
+/**
+ * Add .env entries to .gitignore for a given element
+ * Returns: 'updated' | 'created' | 'skipped'
+ */
+function addEnvToGitignore(tree, elementName, elementPath) {
+    const gitignorePath = (0, path_1.join)(elementPath, '.gitignore');
+    if (tree.exists(gitignorePath)) {
+        // Read existing .gitignore
+        const existingContent = tree.read(gitignorePath, 'utf-8') || '';
+        // Check if .env is already in gitignore
+        if (existingContent.includes('.env')) {
+            devkit_1.logger.info(`  ✅ ${elementName}: .gitignore already contains .env`);
+            return 'skipped';
+        }
+        // Append .env entries to existing .gitignore
+        const newContent = existingContent.trimEnd() + '\n\n# Environment files\n' + ENV_GITIGNORE_ENTRIES + '\n';
+        tree.write(gitignorePath, newContent);
+        devkit_1.logger.info(`  ✅ ${elementName}: Added .env to existing .gitignore`);
+        return 'updated';
+    }
+    else {
+        // Create new .gitignore with .env entries
+        const newContent = '# Environment files\n' + ENV_GITIGNORE_ENTRIES + '\n';
+        tree.write(gitignorePath, newContent);
+        devkit_1.logger.info(`  ✅ ${elementName}: Created .gitignore with .env`);
+        return 'created';
+    }
+}
+async function update(tree) {
+    devkit_1.logger.info('🔄 Adding .env to .gitignore files for all elements');
+    try {
+        // Read .unisphere config
+        if (!tree.exists('.unisphere')) {
+            devkit_1.logger.warn('⚠️ No .unisphere file found, skipping');
+            return;
+        }
+        const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+        const elements = unisphereConfig.elements;
+        if (!elements) {
+            devkit_1.logger.info('ℹ️ No elements found, skipping');
+            return;
+        }
+        let totalUpdated = 0;
+        let totalCreated = 0;
+        // Process applications
+        const applications = elements.applications || {};
+        if (Object.keys(applications).length > 0) {
+            devkit_1.logger.info('\n📦 Processing applications...');
+            for (const [name, config] of Object.entries(applications)) {
+                const result = addEnvToGitignore(tree, name, config.sourceRoot);
+                if (result === 'updated')
+                    totalUpdated++;
+                if (result === 'created')
+                    totalCreated++;
+            }
+        }
+        // Process packages
+        const packages = elements.packages || {};
+        if (Object.keys(packages).length > 0) {
+            devkit_1.logger.info('\n📦 Processing packages...');
+            for (const [name, config] of Object.entries(packages)) {
+                const result = addEnvToGitignore(tree, name, config.sourceRoot);
+                if (result === 'updated')
+                    totalUpdated++;
+                if (result === 'created')
+                    totalCreated++;
+            }
+        }
+        // Process runtimes
+        const runtimes = elements.runtimes || {};
+        if (Object.keys(runtimes).length > 0) {
+            devkit_1.logger.info('\n📦 Processing runtimes...');
+            for (const [name, config] of Object.entries(runtimes)) {
+                const result = addEnvToGitignore(tree, name, config.sourceRoot);
+                if (result === 'updated')
+                    totalUpdated++;
+                if (result === 'created')
+                    totalCreated++;
+            }
+        }
+        // Process workspace elements
+        const workspace = elements.workspace || {};
+        if (Object.keys(workspace).length > 0) {
+            devkit_1.logger.info('\n📦 Processing workspace elements...');
+            for (const [name, config] of Object.entries(workspace)) {
+                const result = addEnvToGitignore(tree, name, config.sourceRoot);
+                if (result === 'updated')
+                    totalUpdated++;
+                if (result === 'created')
+                    totalCreated++;
+            }
+        }
+        // Process loader elements
+        const loader = elements.loader || {};
+        if (Object.keys(loader).length > 0) {
+            devkit_1.logger.info('\n📦 Processing loader elements...');
+            for (const [name, config] of Object.entries(loader)) {
+                const result = addEnvToGitignore(tree, name, config.sourceRoot);
+                if (result === 'updated')
+                    totalUpdated++;
+                if (result === 'created')
+                    totalCreated++;
+            }
+        }
+        devkit_1.logger.info(`\n✅ Done: ${totalUpdated} updated, ${totalCreated} created`);
+    }
+    catch (error) {
+        devkit_1.logger.error(`❌ Failed to update .gitignore files: ${error?.message || 'Unknown error'}`);
+        throw error;
+    }
+}

package/dist/migrations/3-0-0/fix-vite-config-cache-paths.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: Fix vite.config.ts cache directory paths
+ *
+ * This migration ensures that vite.config.ts cache directory paths
+ * match the package name. This fixes any packages that were renamed
+ * before the rename-package generator was updated to handle vite configs.
+ */
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=fix-vite-config-cache-paths.d.ts.map

package/dist/migrations/3-0-0/fix-vite-config-cache-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-vite-config-cache-paths.d.ts","sourceRoot":"","sources":["../../../src/migrations/3-0-0/fix-vite-config-cache-paths.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,IAAI,EAAoB,MAAM,YAAY,CAAC;AAYpD,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAgE9D"}

package/dist/migrations/3-0-0/fix-vite-config-cache-paths.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Migration: Fix vite.config.ts cache directory paths
+ *
+ * This migration ensures that vite.config.ts cache directory paths
+ * match the package name. This fixes any packages that were renamed
+ * before the rename-package generator was updated to handle vite configs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('🔄 Fixing vite.config.ts cache directory paths...');
+    devkit_1.logger.info('');
+    if (!tree.exists('.unisphere')) {
+        devkit_1.logger.info('No .unisphere file found, skipping migration');
+        return;
+    }
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const packagesConfig = unisphereConfig.elements?.packages || {};
+    let updatedCount = 0;
+    for (const [packageName, config] of Object.entries(packagesConfig)) {
+        const sourceRoot = config.sourceRoot;
+        if (!sourceRoot) {
+            continue;
+        }
+        const viteConfigPath = `${sourceRoot}/vite.config.ts`;
+        if (!tree.exists(viteConfigPath)) {
+            continue;
+        }
+        let content = tree.read(viteConfigPath, 'utf-8');
+        if (!content) {
+            continue;
+        }
+        // Check if vite config has cache paths that don't match the package name
+        const expectedPattern = `package-${packageName}`;
+        // Match any package-{name} pattern in cache paths
+        const cachePathRegex = /package-([a-z0-9-]+)/g;
+        const matches = content.match(cachePathRegex);
+        if (matches) {
+            let needsUpdate = false;
+            for (const match of matches) {
+                if (match !== expectedPattern) {
+                    needsUpdate = true;
+                    break;
+                }
+            }
+            if (needsUpdate) {
+                // Replace all package-{oldName} with package-{packageName}
+                content = content.replace(cachePathRegex, expectedPattern);
+                tree.write(viteConfigPath, content);
+                devkit_1.logger.info(`✅ Fixed vite.config.ts for package "${packageName}"`);
+                updatedCount++;
+            }
+        }
+    }
+    if (updatedCount === 0) {
+        devkit_1.logger.info('All vite.config.ts files have correct cache paths');
+    }
+    else {
+        devkit_1.logger.info('');
+        devkit_1.logger.info(`✅ Fixed ${updatedCount} vite.config.ts file(s)`);
+    }
+    devkit_1.logger.info('');
+}

package/dist/migrations/3-0-0/patches/@changesets+cli+2.29.7.patch

@@ -0,0 +1,88 @@
+diff --git a/node_modules/@changesets/cli/dist/changesets-cli.cjs.js b/node_modules/@changesets/cli/dist/changesets-cli.cjs.js
+index 53fc925..8ee486e 100644
+--- a/node_modules/@changesets/cli/dist/changesets-cli.cjs.js
++++ b/node_modules/@changesets/cli/dist/changesets-cli.cjs.js
+@@ -310,22 +310,23 @@ async function createChangeset(changedPackages, allPackages) {
+     const packagesToRelease = await getPackagesToRelease(changedPackages, allPackages);
+     let pkgJsonsByName = getPkgJsonsByName(allPackages);
+     let pkgsLeftToGetBumpTypeFor = new Set(packagesToRelease);
+-    let pkgsThatShouldBeMajorBumped = (await askCheckboxPlus(bold(`Which packages should have a ${red("major")} bump?`), [{
+-      name: "all packages",
+-      choices: packagesToRelease.map(pkgName => {
+-        return {
+-          name: pkgName,
+-          message: formatPkgNameAndVersion(pkgName, pkgJsonsByName.get(pkgName).version)
+-        };
+-      })
+-    }], x => {
+-      // this removes changed packages and unchanged packages from the list
+-      // of packages shown after selection
+-      if (Array.isArray(x)) {
+-        return x.filter(x => x !== "all packages").map(x => cyan(x)).join(", ");
+-      }
+-      return x;
+-    })).filter(x => x !== "all packages");
++    let nonRuntimePackages = packagesToRelease.filter(pkgName => !pkgName.includes('unisphere-runtime-'));
++    let pkgsThatShouldBeMajorBumped = nonRuntimePackages.length > 0 ? (await askCheckboxPlus(bold(`Which packages should have a ${red("major")} bump?`), [{
++      name: "all packages",
++      choices: nonRuntimePackages.map(pkgName => {
++        return {
++          name: pkgName,
++          message: formatPkgNameAndVersion(pkgName, pkgJsonsByName.get(pkgName).version)
++        };
++      })
++    }], x => {
++      // this removes changed packages and unchanged packages from the list
++      // of packages shown after selection
++      if (Array.isArray(x)) {
++        return x.filter(x => x !== "all packages").map(x => cyan(x)).join(", ");
++      }
++      return x;
++    })).filter(x => x !== "all packages") : [];
+     for (const pkgName of pkgsThatShouldBeMajorBumped) {
+       // for packages that are under v1, we want to make sure major releases are intended,
+       // as some repo-wide sweeping changes have mistakenly release first majors
+diff --git a/node_modules/@changesets/cli/dist/changesets-cli.esm.js b/node_modules/@changesets/cli/dist/changesets-cli.esm.js
+index 6c363c0..40aad33 100644
+--- a/node_modules/@changesets/cli/dist/changesets-cli.esm.js
++++ b/node_modules/@changesets/cli/dist/changesets-cli.esm.js
+@@ -272,22 +272,23 @@ async function createChangeset(changedPackages, allPackages) {
+     const packagesToRelease = await getPackagesToRelease(changedPackages, allPackages);
+     let pkgJsonsByName = getPkgJsonsByName(allPackages);
+     let pkgsLeftToGetBumpTypeFor = new Set(packagesToRelease);
+-    let pkgsThatShouldBeMajorBumped = (await askCheckboxPlus(bold(`Which packages should have a ${red("major")} bump?`), [{
+-      name: "all packages",
+-      choices: packagesToRelease.map(pkgName => {
+-        return {
+-          name: pkgName,
+-          message: formatPkgNameAndVersion(pkgName, pkgJsonsByName.get(pkgName).version)
+-        };
+-      })
+-    }], x => {
+-      // this removes changed packages and unchanged packages from the list
+-      // of packages shown after selection
+-      if (Array.isArray(x)) {
+-        return x.filter(x => x !== "all packages").map(x => cyan(x)).join(", ");
+-      }
+-      return x;
+-    })).filter(x => x !== "all packages");
++    let nonRuntimePackages = packagesToRelease.filter(pkgName => !pkgName.includes('unisphere-runtime-'));
++    let pkgsThatShouldBeMajorBumped = nonRuntimePackages.length > 0 ? (await askCheckboxPlus(bold(`Which packages should have a ${red("major")} bump?`), [{
++      name: "all packages",
++      choices: nonRuntimePackages.map(pkgName => {
++        return {
++          name: pkgName,
++          message: formatPkgNameAndVersion(pkgName, pkgJsonsByName.get(pkgName).version)
++        };
++      })
++    }], x => {
++      // this removes changed packages and unchanged packages from the list
++      // of packages shown after selection
++      if (Array.isArray(x)) {
++        return x.filter(x => x !== "all packages").map(x => cyan(x)).join(", ");
++      }
++      return x;
++    })).filter(x => x !== "all packages") : [];
+     for (const pkgName of pkgsThatShouldBeMajorBumped) {
+       // for packages that are under v1, we want to make sure major releases are intended,
+       // as some repo-wide sweeping changes have mistakenly release first majors

package/dist/migrations/3-0-0/post-cleanup-empty-directories.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Migration: Post-cleanup Empty Directories
+ *
+ * This migration runs after all reorganize migrations to clean up any
+ * empty directories left behind after moving packages/applications.
+ */
+import { Tree } from '@nx/devkit';
+/**
+ * Main migration function
+ */
+export default function update(tree: Tree): Promise<() => void>;
+//# sourceMappingURL=post-cleanup-empty-directories.d.ts.map

package/dist/migrations/3-0-0/post-cleanup-empty-directories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-cleanup-empty-directories.d.ts","sourceRoot":"","sources":["../../../src/migrations/3-0-0/post-cleanup-empty-directories.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAAU,MAAM,YAAY,CAAC;AA8C1C;;GAEG;AACH,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAYpE"}

package/dist/migrations/3-0-0/post-cleanup-empty-directories.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Migration: Post-cleanup Empty Directories
+ *
+ * This migration runs after all reorganize migrations to clean up any
+ * empty directories left behind after moving packages/applications.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+/**
+ * Clean up empty directories in unisphere folder
+ */
+function cleanupEmptyDirectories() {
+    const foldersToClean = [
+        'unisphere/packages',
+        'unisphere/applications',
+        'unisphere/runtimes',
+    ];
+    let cleaned = false;
+    for (const folder of foldersToClean) {
+        try {
+            const result = (0, child_process_1.execSync)(`find ${folder} -type d -empty 2>/dev/null | head -20 || true`, { stdio: 'pipe', encoding: 'utf-8' });
+            if (result.trim()) {
+                devkit_1.logger.info(`  Found empty directories in ${folder}:`);
+                result
+                    .trim()
+                    .split('\n')
+                    .forEach((dir) => {
+                    if (dir)
+                        devkit_1.logger.info(`    - ${dir}`);
+                });
+            }
+            (0, child_process_1.execSync)(`find ${folder} -type d -empty -delete 2>/dev/null || true`, {
+                stdio: 'pipe',
+            });
+            cleaned = true;
+        }
+        catch {
+            // Ignore errors - folder might not exist
+        }
+    }
+    if (cleaned) {
+        devkit_1.logger.info('  Empty directories removed');
+    }
+}
+/**
+ * Main migration function
+ */
+async function update(tree) {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('Post-cleanup: Removing empty directories after reorganization...');
+    devkit_1.logger.info('');
+    // Return callback to run after Tree changes are written
+    return () => {
+        cleanupEmptyDirectories();
+        devkit_1.logger.info('');
+        devkit_1.logger.info('Post-cleanup completed');
+        devkit_1.logger.info('');
+    };
+}

package/dist/migrations/3-0-0/pre-cleanup-empty-directories.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Migration: Pre-cleanup Empty Directories
+ *
+ * This migration runs before the reorganize migrations to:
+ * 1. Check Nx version is 22 or higher
+ * 2. Reset Nx cache to ensure fresh project graph
+ * 3. Clean up any existing empty directories that might block the migration flow
+ */
+import { Tree } from '@nx/devkit';
+/**
+ * Main migration function
+ */
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=pre-cleanup-empty-directories.d.ts.map

package/dist/migrations/3-0-0/pre-cleanup-empty-directories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-cleanup-empty-directories.d.ts","sourceRoot":"","sources":["../../../src/migrations/3-0-0/pre-cleanup-empty-directories.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAoB,MAAM,YAAY,CAAC;AAqFpD;;GAEG;AACH,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB9D"}