@unisphere/nx 1.13.0 → 1.19.0

package/dist/generators/add-runtime/schema.json

@@ -10,24 +10,59 @@
       "pattern": "^[a-zA-Z][a-zA-Z0-9\\-\\s]*$",
       "x-prompt": "What's the runtime name? (letters, numbers, dashes and spaces allowed)"
     },
-    "usage": {
-      "type": "string",
-      "description": "How will this runtime be used?",    
+    "standalone": {
+      "type": "boolean",
+      "description": "Is this experience being loaded by the host application, or by another experience (not this one)?",
       "x-prompt": {
-        "message": "How will this runtime be used?",
+        "message": "Is this experience being loaded by the host application, or by another experience (not this one)?",
         "type": "list",
         "items": [
           {
-            "value": "loadedByExternalHost",
-            "label": "Independent experience used as an entry point (loaded by host or another experience)"
+            "value": true,
+            "label": "Yes -loaded by host application"
+          },
+          {
+            "value": false,
+            "label": "No - loaded by another experience"
+          }
+        ]
+      }
+    },
+    "dependencies": {
+      "type": "array",
+      "description": "Select packages to install (use space to select, enter to confirm)",
+      "items": {
+        "type": "string",
+        "enum": [
+          "react",
+          "ds",
+          "mui"
+        ]
+      },
+      "default": [],
+      "x-prompt": {
+        "message": "Select dependencies to install (use space to select, enter to confirm):",
+        "type": "list",
+        "multiselect": true,
+        "items": [
+          {
+            "value": "react",
+            "label": "React - UI library for building components"
+          },
+          {
+            "value": "ds",
+            "label": "Kaltura DS - Design System (requires GIT_TOKEN)"
           },
           {
-            "value": "composedIntoAnotherRuntime",
-            "label": "Composed into another runtime of this experience (not used as an entry point)"
-          }         
+            "value": "mui",
+            "label": "Material UI - Component library"
+          }
         ]
       }
     }
   },
-  "required": ["name", "usage"]
-}
+  "required": [
+    "name",
+    "standalone"
+  ]
+}

package/dist/generators/add-runtime/templates/core-templates/__runtimeName__-runtime/runtime-types.ts.template

@@ -1,11 +1,11 @@
 import { ValidatorSchema } from '@unisphere/core';
 import { UnisphereRuntimeBaseType } from '@unisphere/runtime';
-import { WidgetName } from '../widget-types';
+import { widgetName } from '../widget-types';
 
 export const <%= runtimeName__pascalCase %>RuntimeName = '<%= runtimeName__lowerDashCase %>' as const;
 
 export type <%= runtimeName__pascalCase %>Runtime = UnisphereRuntimeBaseType<<%= runtimeName__pascalCase %>RuntimeSettings> & {
-  readonly widgetName: typeof WidgetName;
+  readonly widgetName: typeof widgetName;
   readonly runtimeName: typeof <%= runtimeName__pascalCase %>RuntimeName; 
 };
 

package/dist/generators/add-runtime/templates/new-runtime/src/lib/create-factory.tsx.template

@@ -1,21 +1,22 @@
-import { Root } from 'react-dom/client';
-import { Runtime } from './runtime';
-import { <%= runtimeName__pascalCase %>RuntimeSettings } from '<%= coreAlias %>'
 import {
-  CreateElementOptions,
   UnisphereElementBase,
   UnisphereElementFactory,
+  CreateElementOptions,
 } from '@unisphere/runtime-js';
+import { Root } from 'react-dom/client';
+import { Runtime } from './runtime';
 
-class ContextFactory extends UnisphereElementFactory<
-  <%= runtimeName__pascalCase %>RuntimeSettings,
-  Root
-> {
-  create(
-    options: CreateElementOptions<<%= runtimeName__pascalCase %>RuntimeSettings>
-  ): UnisphereElementBase<<%= runtimeName__pascalCase %>RuntimeSettings, Root> {
-    return new Runtime(options);
+class ContextFactory extends UnisphereElementFactory<Record<string, any>, Root> {
+  create<T extends Record<string, any>>(
+    options: CreateElementOptions<T>
+  ): UnisphereElementBase<T, Root> {
+    switch (options.flavor) {
+      default:
+        return new Runtime(options) as any;
+    }
   }
 }
 
 export const createFactory = () => new ContextFactory();
+
+

package/dist/generators/dependency-config.d.ts

@@ -0,0 +1,23 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Dependency version mappings with default versions from workspace
+ */
+export declare const DEPENDENCY_MAP: Record<string, {
+    packages: string[];
+    defaultVersions?: Record<string, string>;
+}>;
+/**
+ * Validates that GIT_TOKEN environment variable exists when Kaltura DS is selected
+ * @throws Error if GIT_TOKEN is not found
+ */
+export declare function validateGitToken(selectedDependencies: string[]): void;
+/**
+ * Validates and auto-corrects package/runtime name to include -react suffix
+ * when React or Kaltura DS dependencies are selected
+ */
+export declare function validateReactNaming(name: string, selectedDependencies: string[]): string;
+/**
+ * Installs selected dependencies, skipping those already installed
+ */
+export declare function installSelectedDependencies(tree: Tree, selectedDependencies: string[]): void;
+//# sourceMappingURL=dependency-config.d.ts.map

package/dist/generators/dependency-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-config.d.ts","sourceRoot":"","sources":["../../src/generators/dependency-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAU,MAAM,YAAY,CAAC;AAI1C;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,MAAM,EACN;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAgDjE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,oBAAoB,EAAE,MAAM,EAAE,GAAG,IAAI,CAkBrE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,oBAAoB,EAAE,MAAM,EAAE,GAC7B,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,EACV,oBAAoB,EAAE,MAAM,EAAE,GAC7B,IAAI,CA0CN"}

package/dist/generators/dependency-config.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPENDENCY_MAP = void 0;
+exports.validateGitToken = validateGitToken;
+exports.validateReactNaming = validateReactNaming;
+exports.installSelectedDependencies = installSelectedDependencies;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const utils_1 = require("./utils");
+/**
+ * Dependency version mappings with default versions from workspace
+ */
+exports.DEPENDENCY_MAP = {
+    react: {
+        packages: ['react', 'react-dom'],
+        defaultVersions: {
+            'react': '^19.0.0',
+            'react-dom': '^19.0.0',
+        },
+    },
+    ds: {
+        packages: [
+            '@kaltura/ds-react-bits',
+            '@kaltura/ds-react-icons',
+            '@kaltura/ds-react-theme',
+            '@kaltura/ds-react-utils',
+            '@mui/material',
+            '@mui/icons-material',
+            '@emotion/react',
+            '@emotion/styled',
+        ],
+        defaultVersions: {
+            '@kaltura/ds-react-bits': '^12.2.0',
+            '@kaltura/ds-react-icons': '^12.2.0',
+            '@kaltura/ds-react-theme': '^12.2.0',
+            '@kaltura/ds-react-utils': '^12.2.0',
+            '@mui/material': '^7.3.4',
+            '@mui/icons-material': '^7.3.4',
+            '@emotion/react': '11.14.0',
+            '@emotion/styled': '11.14.1',
+        },
+    },
+    mui: {
+        packages: ['@mui/material', '@mui/icons-material', '@emotion/react', '@emotion/styled'],
+        defaultVersions: {
+            '@mui/material': '^7.3.4',
+            '@mui/icons-material': '^7.3.4',
+            '@emotion/react': '11.14.0',
+            '@emotion/styled': '11.14.1',
+        },
+    },
+    'react-hook-form': {
+        packages: ['react-hook-form', 'react', 'react-dom'],
+        defaultVersions: {
+            'react-hook-form': '^7.52.0',
+            'react': '^19.0.0',
+            'react-dom': '^19.0.0',
+        },
+    },
+};
+/**
+ * Validates that GIT_TOKEN environment variable exists when Kaltura DS is selected
+ * @throws Error if GIT_TOKEN is not found
+ */
+function validateGitToken(selectedDependencies) {
+    if (selectedDependencies.includes('ds')) {
+        const gitToken = process.env.GIT_TOKEN;
+        if (!gitToken) {
+            devkit_1.logger.error('');
+            devkit_1.logger.error('❌ Error: Kaltura DS requires GIT_TOKEN environment variable');
+            devkit_1.logger.error('');
+            devkit_1.logger.error('Please set up your GitHub token to access Kaltura packages.');
+            devkit_1.logger.error('Documentation: https://unisphere.kaltura.com/docs/create/overview');
+            devkit_1.logger.error('');
+            throw new Error('GIT_TOKEN environment variable is required for Kaltura DS');
+        }
+    }
+}
+/**
+ * Validates and auto-corrects package/runtime name to include -react suffix
+ * when React or Kaltura DS dependencies are selected
+ */
+function validateReactNaming(name, selectedDependencies) {
+    const needsReactSuffix = selectedDependencies.includes('react') ||
+        selectedDependencies.includes('ds');
+    if (needsReactSuffix && !name.endsWith('-react')) {
+        const suggestedName = `${name}-react`;
+        devkit_1.logger.warn('');
+        devkit_1.logger.warn(`⚠️  Package/Runtime name should end with '-react' when using React or Kaltura DS`);
+        devkit_1.logger.info(`   Renaming to: ${suggestedName}`);
+        devkit_1.logger.warn('');
+        return suggestedName;
+    }
+    return name;
+}
+/**
+ * Installs selected dependencies, skipping those already installed
+ */
+function installSelectedDependencies(tree, selectedDependencies) {
+    if (!selectedDependencies || selectedDependencies.length === 0) {
+        return;
+    }
+    devkit_1.logger.info('');
+    devkit_1.logger.info('📦 Installing selected dependencies...');
+    for (const dep of selectedDependencies) {
+        const depConfig = exports.DEPENDENCY_MAP[dep];
+        if (!depConfig) {
+            devkit_1.logger.warn(`⚠️  Unknown dependency: ${dep}`);
+            continue;
+        }
+        for (const packageName of depConfig.packages) {
+            const installedVersion = (0, utils_1.isPackageInstalled)(tree, packageName);
+            if (installedVersion) {
+                devkit_1.logger.info(`✅ ${packageName}@${installedVersion} already installed`);
+                continue;
+            }
+            // Determine version to install from defaultVersions map or fallback
+            const version = depConfig.defaultVersions?.[packageName] || '^1.0.0';
+            const installCommand = `npm install ${packageName}@${version}`;
+            devkit_1.logger.info(`   Installing ${packageName}@${version}...`);
+            try {
+                (0, child_process_1.execSync)(installCommand, {
+                    cwd: process.cwd(),
+                    stdio: 'inherit',
+                });
+                devkit_1.logger.info(`✅ ${packageName}@${version} installed successfully`);
+            }
+            catch (error) {
+                devkit_1.logger.error(`❌ Failed to install ${packageName}: ${error}`);
+            }
+        }
+    }
+    devkit_1.logger.info('');
+}

package/dist/generators/rename-package/rename-package.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rename Package Generator
+ *
+ * This generator renames a Unisphere package by:
+ * 1. Using Nx's built-in move generator to handle:
+ *    - Directory and file moves
+ *    - Import statement updates across the workspace
+ *    - TypeScript path mappings in tsconfig.base.json
+ * 2. Performing Unisphere-specific cleanup:
+ *    - Updating .unisphere configuration
+ *    - Ensuring package.json name matches Unisphere conventions
+ *    - Updating package-lock.json path keys (Nx doesn't handle this)
+ */
+import { Tree } from '@nx/devkit';
+import { RenamePackageGeneratorSchema } from './schema';
+export declare function renamePackageGenerator(tree: Tree, options: RenamePackageGeneratorSchema): Promise<() => void>;
+export default renamePackageGenerator;
+//# sourceMappingURL=rename-package.d.ts.map

package/dist/generators/rename-package/rename-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-package.d.ts","sourceRoot":"","sources":["../../../src/generators/rename-package/rename-package.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAyPxD,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,4BAA4B,uBAsGtC;AAED,eAAe,sBAAsB,CAAC"}

package/dist/generators/rename-package/rename-package.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Rename Package Generator
+ *
+ * This generator renames a Unisphere package by:
+ * 1. Using Nx's built-in move generator to handle:
+ *    - Directory and file moves
+ *    - Import statement updates across the workspace
+ *    - TypeScript path mappings in tsconfig.base.json
+ * 2. Performing Unisphere-specific cleanup:
+ *    - Updating .unisphere configuration
+ *    - Ensuring package.json name matches Unisphere conventions
+ *    - Updating package-lock.json path keys (Nx doesn't handle this)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renamePackageGenerator = renamePackageGenerator;
+const devkit_1 = require("@nx/devkit");
+const generators_1 = require("@nx/workspace/generators");
+const child_process_1 = require("child_process");
+const utils_1 = require("../utils");
+/**
+ * Validates that the old package exists in .unisphere configuration
+ */
+function validateOldPackageExists(tree, oldPackageName) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const normalizedOldName = (0, devkit_1.names)(oldPackageName).fileName;
+    if (!unisphereConfig.elements?.packages?.[normalizedOldName]) {
+        throw new Error(`Package "${normalizedOldName}" not found in .unisphere configuration.\n` +
+            'Available packages: ' +
+            Object.keys(unisphereConfig.elements?.packages || {}).join(', '));
+    }
+    const packageConfig = unisphereConfig.elements.packages[normalizedOldName];
+    const oldPath = `unisphere/packages/${normalizedOldName}`;
+    // Verify the directory exists
+    if (!tree.exists(oldPath)) {
+        throw new Error(`Package directory not found at ${oldPath}.\n` +
+            'The .unisphere configuration references a package that does not exist.');
+    }
+    // Read the package.json to get the current package name
+    const packageJsonPath = `${oldPath}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        throw new Error(`package.json not found at ${packageJsonPath}.\n` +
+            'The package directory exists but is missing package.json.');
+    }
+    const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    const packageJsonName = packageJson.name;
+    return {
+        packageJsonName,
+        distributionChannel: packageConfig.distributionChannel || 'none',
+        scope: packageConfig.scope || 'widget',
+        sourceRoot: packageConfig.sourceRoot,
+        oldPath,
+        newPath: `unisphere/packages/${normalizedOldName}`,
+    };
+}
+/**
+ * Validates that the new package name doesn't already exist
+ */
+function validateNewPackageDoesNotExist(tree, newPackageName) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const normalizedNewName = (0, devkit_1.names)(newPackageName).fileName;
+    if (unisphereConfig.elements?.packages?.[normalizedNewName]) {
+        throw new Error(`Package "${normalizedNewName}" already exists in .unisphere configuration.\n` +
+            'Please choose a different package name.');
+    }
+    const newPath = `unisphere/packages/${normalizedNewName}`;
+    if (tree.exists(newPath)) {
+        throw new Error(`Package directory already exists at ${newPath}.\n` +
+            'Please choose a different package name or remove the existing directory.');
+    }
+}
+/**
+ * Calculate the new package.json name based on scope and experience name
+ */
+function calculateNewPackageJsonName(tree, newPackageName, oldPackageJsonName) {
+    const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
+    const experienceName = unisphereConfig.name;
+    const normalizedNewName = (0, devkit_1.names)(newPackageName).fileName;
+    // Determine the prefix from the old package name
+    let prefix;
+    if (oldPackageJsonName.startsWith('@unisphere/')) {
+        prefix = '@unisphere/';
+    }
+    else if (oldPackageJsonName.startsWith('@kaltura/unisphere-')) {
+        prefix = '@kaltura/unisphere-';
+    }
+    else {
+        // Private package, no prefix
+        return normalizedNewName;
+    }
+    // Calculate new package name
+    let packageJsonName;
+    if (experienceName === normalizedNewName) {
+        packageJsonName = normalizedNewName;
+    }
+    else {
+        packageJsonName = `${experienceName}-${normalizedNewName}`;
+    }
+    return prefix + packageJsonName;
+}
+/**
+ * Update .unisphere configuration
+ */
+function updateUnisphereConfiguration(tree, oldPackageName, newPackageName, packageInfo) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const normalizedNewName = (0, devkit_1.names)(newPackageName).fileName;
+    const normalizedOldName = (0, devkit_1.names)(oldPackageName).fileName;
+    // Get the old package config
+    const oldPackageConfig = unisphereConfig.elements.packages[normalizedOldName];
+    // Update sourceRoot
+    const newSourceRoot = `unisphere/packages/${normalizedNewName}`;
+    // Preserve package order by rebuilding the packages object
+    const newPackages = {};
+    Object.keys(unisphereConfig.elements.packages).forEach((key) => {
+        if (key === normalizedOldName) {
+            // Replace old package with new one at the same position
+            newPackages[normalizedNewName] = {
+                ...oldPackageConfig,
+                sourceRoot: newSourceRoot,
+            };
+        }
+        else {
+            newPackages[key] = unisphereConfig.elements.packages[key];
+        }
+    });
+    unisphereConfig.elements.packages = newPackages;
+    (0, devkit_1.writeJson)(tree, '.unisphere', unisphereConfig);
+    devkit_1.logger.info(`✅ Updated .unisphere configuration`);
+}
+/**
+ * Update package.json name to ensure it matches Unisphere naming conventions
+ * Nx move generator sets the package name, but we verify it matches our conventions
+ */
+function updatePackageJson(tree, packagePath, newPackageJsonName) {
+    const packageJsonPath = `${packagePath}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        devkit_1.logger.warn(`⚠️  package.json not found at ${packageJsonPath}`);
+        return;
+    }
+    const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    // Only update if Nx didn't set it to our expected name
+    if (packageJson.name !== newPackageJsonName) {
+        packageJson.name = newPackageJsonName;
+        (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
+        devkit_1.logger.info(`✅ Updated package.json name to "${newPackageJsonName}"`);
+    }
+}
+/**
+ * Update package-lock.json to rename the package path keys
+ * Nx's move generator doesn't handle package-lock.json updates
+ */
+function updatePackageLock(tree, oldPackageName, newPackageName) {
+    const packageLockPath = 'package-lock.json';
+    if (!tree.exists(packageLockPath)) {
+        return;
+    }
+    const packageLock = (0, devkit_1.readJson)(tree, packageLockPath);
+    const normalizedOldName = (0, devkit_1.names)(oldPackageName).fileName;
+    const normalizedNewName = (0, devkit_1.names)(newPackageName).fileName;
+    const oldPath = `unisphere/packages/${normalizedOldName}`;
+    const newPath = `unisphere/packages/${normalizedNewName}`;
+    let updated = false;
+    if (packageLock.packages) {
+        const packagesEntries = Object.entries(packageLock.packages);
+        const newPackages = {};
+        for (const [key, value] of packagesEntries) {
+            // Check if this key is exactly the old package path
+            if (key === oldPath) {
+                newPackages[newPath] = value;
+                updated = true;
+            }
+            else {
+                newPackages[key] = value;
+            }
+        }
+        packageLock.packages = newPackages;
+    }
+    // Update resolved paths if they exist
+    if (packageLock.packages) {
+        for (const [, value] of Object.entries(packageLock.packages)) {
+            if (value && typeof value === 'object' && 'resolved' in value) {
+                const pkg = value;
+                if (pkg.resolved === oldPath) {
+                    pkg.resolved = newPath;
+                    updated = true;
+                }
+            }
+        }
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, packageLockPath, packageLock);
+        devkit_1.logger.info(`✅ Updated package-lock.json path keys`);
+    }
+}
+async function renamePackageGenerator(tree, options) {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('🔄 Starting package rename...');
+    devkit_1.logger.info('');
+    // Validate .unisphere exists
+    (0, utils_1.validateUnisphereConfig)(tree);
+    // Normalize package names
+    const normalizedOldName = (0, devkit_1.names)(options.oldPackageName).fileName;
+    const normalizedNewName = (0, devkit_1.names)(options.newPackageName).fileName;
+    // Validate old package exists
+    const packageInfo = validateOldPackageExists(tree, normalizedOldName);
+    // Validate new package doesn't exist
+    validateNewPackageDoesNotExist(tree, normalizedNewName);
+    // Calculate new package.json name
+    const newPackageJsonName = calculateNewPackageJsonName(tree, normalizedNewName, packageInfo.packageJsonName);
+    const oldNxProjectName = `unisphere-package-${normalizedOldName}`;
+    const newNxProjectName = `unisphere-package-${normalizedNewName}`;
+    const newPath = `unisphere/packages/${normalizedNewName}`;
+    devkit_1.logger.info(`📦 Old package name: ${normalizedOldName}`);
+    devkit_1.logger.info(`📦 New package name: ${normalizedNewName}`);
+    devkit_1.logger.info(`🏷️  Old package.json name: ${packageInfo.packageJsonName}`);
+    devkit_1.logger.info(`🏷️  New package.json name: ${newPackageJsonName}`);
+    devkit_1.logger.info(`🏷️  Nx project name: ${oldNxProjectName} → ${newNxProjectName}`);
+    devkit_1.logger.info('');
+    // Step 1: Run Nx's built-in move generator
+    devkit_1.logger.info('🔧 Running Nx move generator...');
+    try {
+        await (0, generators_1.moveGenerator)(tree, {
+            projectName: oldNxProjectName,
+            destination: newPath,
+            newProjectName: newNxProjectName,
+            importPath: newPackageJsonName,
+            updateImportPath: true,
+            skipFormat: false,
+        });
+        devkit_1.logger.info(`✅ Nx moved project from ${packageInfo.oldPath} to ${newPath}`);
+    }
+    catch (error) {
+        devkit_1.logger.error(`❌ Failed to move project with Nx: ${error}`);
+        throw error;
+    }
+    devkit_1.logger.info('');
+    devkit_1.logger.info('🧹 Performing Unisphere-specific cleanup...');
+    // Step 2: Update .unisphere configuration (Unisphere-specific)
+    updateUnisphereConfiguration(tree, normalizedOldName, normalizedNewName, packageInfo);
+    // Step 3: Update package.json name to match Unisphere conventions
+    updatePackageJson(tree, newPath, newPackageJsonName);
+    // Step 4: Update package-lock.json path keys (Nx doesn't handle this)
+    updatePackageLock(tree, normalizedOldName, normalizedNewName);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('✅ Package renamed successfully!');
+    devkit_1.logger.info('');
+    devkit_1.logger.info('📋 Summary:');
+    devkit_1.logger.info(`  • Old name: ${normalizedOldName}`);
+    devkit_1.logger.info(`  • New name: ${normalizedNewName}`);
+    devkit_1.logger.info(`  • Old location: ${packageInfo.oldPath}`);
+    devkit_1.logger.info(`  • New location: ${newPath}`);
+    devkit_1.logger.info(`  • Package.json name: ${newPackageJsonName}`);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('📝 Next steps:');
+    devkit_1.logger.info('  1. Review the changes: git status');
+    devkit_1.logger.info('  2. Stage all changes: git add -A');
+    devkit_1.logger.info('     Git will detect the directory move as a rename (preserving history)');
+    devkit_1.logger.info('  3. Run: npm install (to update package-lock.json)');
+    devkit_1.logger.info('  4. Run: npm run build (to verify everything builds)');
+    devkit_1.logger.info('  5. Commit the changes: git commit -m "Rename package..."');
+    devkit_1.logger.info('');
+    return () => {
+        // This function runs after all changes are applied
+        try {
+            // Auto-stage changes to help Git detect renames
+            (0, child_process_1.execSync)('git add -A', { stdio: 'ignore' });
+            devkit_1.logger.info('✅ Automatically staged changes to help Git detect renames');
+        }
+        catch (e) {
+            // Ignore errors if git is not available or not a git repo
+        }
+    };
+}
+exports.default = renamePackageGenerator;

package/dist/generators/rename-package/schema.d.ts

@@ -0,0 +1,4 @@
+export interface RenamePackageGeneratorSchema {
+  oldPackageName: string;
+  newPackageName: string;
+}

package/dist/generators/rename-package/schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RenamePackage",
+  "title": "Rename Package Generator",
+  "type": "object",
+  "properties": {
+    "oldPackageName": {
+      "type": "string",
+      "description": "The current name of the package to rename",
+      "x-prompt": "What is the current package name?"
+    },
+    "newPackageName": {
+      "type": "string",
+      "description": "The new name for the package",
+      "pattern": "^[a-zA-Z][a-zA-Z0-9\\-\\s]*$",
+      "x-prompt": "What should the new package name be? (alphanumeric with dashes and spaces allowed)"
+    }
+  },
+  "required": [
+    "oldPackageName",
+    "newPackageName"
+  ]
+}

package/dist/generators/unisphere-migrate/run-locally.md

@@ -15,4 +15,7 @@ npx nx g {path}/unisphere-nx-workspace-plugin/packages/nx:unisphere-migrate
 This will run ALL migrations defined in migrations.json manually.
 
 
-npx nx g /home/tokomeno/kaltura/unisphere/pl/unisphere-nx-workspace-plugin/packages/nx:unisphere-migrate
+npx nx g /home/tokomeno/kaltura/unisphere/unisphere-nx-workspace-plugin/packages/nx:unisphere-migrate
+
+
+npx nx g /home/tokomeno/kaltura/unisphere/unisphere-nx-workspace-plugin/packages/nx:add-application

package/dist/generators/unisphere-migrate/upgrade-guide.md

@@ -1,3 +1,25 @@
+
+### Unisphere-migrate
+
+**Purpose:** A comprehensive migration guide and generator for upgrading Unisphere workspaces to the latest tech stack.
+
+**What It Does:**
+- Guides developers through a major version upgrade of their Unisphere workspace
+- Automates code transformations for breaking changes across:
+  - React 18 → 19 (breaking changes in types and patterns)
+  - MUI v5/v6 → v7 (breaking API changes)
+  - Node.js version upgrades
+  - All @unisphere and @kaltura packages
+- Sequences upgrade steps in the correct order (Nx first, then Unisphere)
+- Provides safety measures (git commits, clean installs, verification steps)
+
+**Key Features:**
+- User-facing documentation for manual steps (environment setup, Node.js switching)
+- Automated migration generator for code transformations
+- Handles dependencies across multiple major version bumps
+- Verification steps to ensure successful upgrade
+
+
 # Unisphere Nx Workspace Upgrade Guide
 
 This guide walks you through upgrading your Unisphere workspace to the latest version with Nx 22, React 19, MUI v7, and Node.js 24.
@@ -84,9 +106,3 @@ If you encounter React 19 compatibility issues, you may need to:
 npm run check
 ```
 
-## What Changed
-
-- **React**: Upgraded to v19
-- **MUI**: Upgraded to v7
-- **Node.js**: Updated to v24
-- **All @unisphere and @kaltura packages**: Updated to latest versions