@unisphere/nx 2.2.1 → 3.2.3

package/dist/generators/internal-dev-runner/generator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = testMigrationGenerator;
+const tslib_1 = require("tslib");
+// Import the migrations to test
+// import addEnvToGitignore from '../../migrations/3-0-0/add-env-to-application-gitignore';
+// import addDefinePluginToWebpack from '../../migrations/3-0-0/add-define-plugin-to-webpack';
+// import upgradeCliToV2 from '../../migrations/3-0-0/upgrade-cli-to-v2';
+// import preCleanupEmptyDirectories from '../../migrations/3-0-0/pre-cleanup-empty-directories';
+// import reorganizePackagesByDistributionChannel from '../../migrations/3-0-0/reorganize-packages-by-distribution-channel';
+// import reorganizeApplicationsByDistributionChannel from '../../migrations/3-0-0/reorganize-applications-by-distribution-channel';
+// import upgradeSchemaTo2 from '../../migrations/3-0-0/upgrade-schema-to-2-0-0';
+// import postCleanupEmptyDirectories from '../../migrations/3-0-0/post-cleanup-empty-directories';
+const remove_private_from_applications_and_runtimes_1 = tslib_1.__importDefault(require("../../migrations/3-0-0/remove-private-from-applications-and-runtimes"));
+async function testMigrationGenerator(tree) {
+    // Collect all callbacks to run after all migrations complete
+    // const callbacks: (() => void)[] = [];
+    // Upgrade CLI to v2 first (needed for other migrations)
+    // const upgradeCliCallback = await upgradeCliToV2(tree);
+    // if (upgradeCliCallback) {
+    //   callbacks.push(upgradeCliCallback);
+    // }
+    // Pre-cleanup: Remove empty directories before reorganization
+    // await preCleanupEmptyDirectories(tree);
+    // Reorganize packages by distribution channel (also handles core->types rename and -react suffix)
+    // await reorganizePackagesByDistributionChannel(tree);
+    // // Reorganize applications by distribution channel
+    // await reorganizeApplicationsByDistributionChannel(tree);
+    // Upgrade schema to 2.0.0 and remove distributionChannel from packages
+    // await upgradeSchemaTo2(tree);
+    // Remove private field from applications, runtimes, and packages
+    await (0, remove_private_from_applications_and_runtimes_1.default)(tree);
+    // Post-cleanup: Remove empty directories after reorganization
+    // const postCleanupCallback = await postCleanupEmptyDirectories(tree);
+    // if (postCleanupCallback) {
+    //   callbacks.push(postCleanupCallback);
+    // }
+    // Run all callbacks at the end
+    // Note: In Nx generators, Tree changes are written when the generator completes.
+    // These callbacks run after all migrations but before the generator finishes.
+    // For file system operations (like npm install), they should work correctly.
+    // for (const callback of callbacks) {
+    //   callback();
+    // }
+}

package/dist/generators/internal-dev-runner/schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "InternalDevRunner",
+  "title": "Internal-dev-runner",
+  "description": "Runs a migration for testing purposes",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/dist/generators/remove/remove.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Remove Generator
+ *
+ * This generator removes a Unisphere element (package, runtime, or application) by:
+ * 1. Validating the element exists in .unisphere configuration
+ * 2. Using Nx's built-in remove generator to delete the project
+ * 3. Performing Unisphere-specific cleanup:
+ *    - Removing from .unisphere configuration
+ *    - For runtimes: removing types from types/core package and updating index.ts exports
+ *    - Updating tsconfig.base.json path mappings
+ *    - Updating package-lock.json
+ *
+ * Usage: nx g @unisphere/nx:remove runtime:admin
+ */
+import { Tree } from '@nx/devkit';
+import { RemoveGeneratorSchema } from './schema';
+export declare function removeGenerator(tree: Tree, options: RemoveGeneratorSchema): Promise<void>;
+export default removeGenerator;
+//# sourceMappingURL=remove.d.ts.map

package/dist/generators/remove/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/generators/remove/remove.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAmQjD,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,iBA6E/B;AAED,eAAe,eAAe,CAAC"}

package/dist/generators/remove/remove.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Remove Generator
+ *
+ * This generator removes a Unisphere element (package, runtime, or application) by:
+ * 1. Validating the element exists in .unisphere configuration
+ * 2. Using Nx's built-in remove generator to delete the project
+ * 3. Performing Unisphere-specific cleanup:
+ *    - Removing from .unisphere configuration
+ *    - For runtimes: removing types from types/core package and updating index.ts exports
+ *    - Updating tsconfig.base.json path mappings
+ *    - Updating package-lock.json
+ *
+ * Usage: nx g @unisphere/nx:remove runtime:admin
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeGenerator = removeGenerator;
+const devkit_1 = require("@nx/devkit");
+const generators_1 = require("@nx/workspace/generators");
+const utils_1 = require("../utils");
+const VALID_ELEMENT_TYPES = ['package', 'runtime', 'application'];
+/**
+ * Parse the element string in format "type:name"
+ */
+function parseElement(element) {
+    const parts = element.split(':');
+    if (parts.length !== 2) {
+        throw new Error(`Invalid element format: "${element}"\n` +
+            `Expected format: type:name (e.g., runtime:admin, package:shared, application:my-app)`);
+    }
+    const [type, name] = parts;
+    if (!VALID_ELEMENT_TYPES.includes(type)) {
+        throw new Error(`Invalid element type: "${type}"\n` +
+            `Valid types: ${VALID_ELEMENT_TYPES.join(', ')}`);
+    }
+    if (!name || name.trim() === '') {
+        throw new Error(`Element name is required.\n` +
+            `Expected format: type:name (e.g., runtime:admin)`);
+    }
+    return {
+        elementType: type,
+        name: name.trim(),
+    };
+}
+/**
+ * Get the configuration key for element type in .unisphere
+ */
+function getElementsConfigKey(elementType) {
+    const mapping = {
+        package: 'packages',
+        runtime: 'runtimes',
+        application: 'applications',
+    };
+    return mapping[elementType];
+}
+/**
+ * Get the Nx project name prefix for element type
+ */
+function getNxProjectPrefix(elementType) {
+    const mapping = {
+        package: 'unisphere-package',
+        runtime: 'unisphere-runtime',
+        application: 'unisphere-application',
+    };
+    return mapping[elementType];
+}
+/**
+ * Validates that the element exists in .unisphere configuration
+ */
+function validateElementExists(tree, elementType, elementName) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const normalizedName = (0, devkit_1.names)(elementName).fileName;
+    const configKey = getElementsConfigKey(elementType);
+    const elementConfig = unisphereConfig.elements?.[configKey]?.[normalizedName];
+    if (!elementConfig) {
+        const availableElements = Object.keys(unisphereConfig.elements?.[configKey] || {});
+        throw new Error(`${elementType.charAt(0).toUpperCase() + elementType.slice(1)} "${normalizedName}" not found in .unisphere configuration.\n` +
+            `Available ${configKey}: ${availableElements.length > 0 ? availableElements.join(', ') : '(none)'}`);
+    }
+    if (!elementConfig.sourceRoot) {
+        throw new Error(`${elementType.charAt(0).toUpperCase() + elementType.slice(1)} "${normalizedName}" exists but has no sourceRoot configured in .unisphere`);
+    }
+    return elementConfig.sourceRoot;
+}
+/**
+ * Remove element from .unisphere configuration
+ */
+function removeFromUnisphereConfig(tree, elementType, elementName) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const configKey = getElementsConfigKey(elementType);
+    const normalizedName = (0, devkit_1.names)(elementName).fileName;
+    if (unisphereConfig.elements?.[configKey]?.[normalizedName]) {
+        delete unisphereConfig.elements[configKey][normalizedName];
+        (0, devkit_1.writeJson)(tree, '.unisphere', unisphereConfig);
+        devkit_1.logger.info(`Removed "${normalizedName}" from .unisphere configuration`);
+    }
+}
+/**
+ * Remove runtime types from types/core package
+ */
+function removeRuntimeTypes(tree, runtimeName) {
+    const typesPackageInfo = (0, utils_1.findTypesOrCorePackageInfo)(tree);
+    const normalizedName = (0, devkit_1.names)(runtimeName).fileName;
+    // Remove the runtime types directory
+    const runtimeTypesDir = `${typesPackageInfo.basePath}/src/lib/${normalizedName}-runtime`;
+    if (tree.exists(runtimeTypesDir)) {
+        // Delete all files in the directory
+        tree.children(runtimeTypesDir).forEach(child => {
+            tree.delete(`${runtimeTypesDir}/${child}`);
+        });
+        devkit_1.logger.info(`Removed runtime types directory: ${runtimeTypesDir}`);
+    }
+    // Update the index.ts to remove the export
+    const indexPath = `${typesPackageInfo.basePath}/src/index.ts`;
+    if (tree.exists(indexPath)) {
+        const content = tree.read(indexPath, 'utf-8');
+        if (content) {
+            const exportLine = `export * from './lib/${normalizedName}-runtime';`;
+            const exportLineWithNewline = `\n${exportLine}`;
+            let updatedContent = content;
+            // Remove the export line (handle both with and without leading newline)
+            if (content.includes(exportLineWithNewline)) {
+                updatedContent = content.replace(exportLineWithNewline, '');
+            }
+            else if (content.includes(exportLine)) {
+                updatedContent = content.replace(exportLine + '\n', '');
+                updatedContent = updatedContent.replace(exportLine, '');
+            }
+            if (updatedContent !== content) {
+                tree.write(indexPath, updatedContent);
+                devkit_1.logger.info(`Removed runtime export from ${indexPath}`);
+            }
+        }
+    }
+}
+/**
+ * Remove path mapping from tsconfig.base.json
+ */
+function removeTsConfigPath(tree, elementType, elementName) {
+    const tsconfigPath = 'tsconfig.base.json';
+    if (!tree.exists(tsconfigPath)) {
+        return;
+    }
+    const tsconfig = (0, devkit_1.readJson)(tree, tsconfigPath);
+    const normalizedName = (0, devkit_1.names)(elementName).fileName;
+    if (!tsconfig.compilerOptions?.paths) {
+        return;
+    }
+    // Determine the path key based on element type
+    let pathKeyPattern;
+    switch (elementType) {
+        case 'runtime':
+            pathKeyPattern = `unisphere-runtime-${normalizedName}`;
+            break;
+        case 'package':
+            // Packages may have various path patterns, we'll search for matching paths
+            pathKeyPattern = normalizedName;
+            break;
+        case 'application':
+            pathKeyPattern = `unisphere-application-${normalizedName}`;
+            break;
+    }
+    let removed = false;
+    const pathsToRemove = [];
+    // Find all matching paths
+    for (const [key, paths] of Object.entries(tsconfig.compilerOptions.paths)) {
+        if (Array.isArray(paths)) {
+            const matchesPath = paths.some((p) => p.includes(`/${normalizedName}/`) || p.includes(`/${normalizedName}-`));
+            if (key.includes(pathKeyPattern) || matchesPath) {
+                pathsToRemove.push(key);
+            }
+        }
+    }
+    // Remove the paths
+    for (const key of pathsToRemove) {
+        delete tsconfig.compilerOptions.paths[key];
+        removed = true;
+    }
+    if (removed) {
+        (0, devkit_1.writeJson)(tree, tsconfigPath, tsconfig);
+        devkit_1.logger.info(`Removed path mapping(s) from tsconfig.base.json`);
+    }
+}
+/**
+ * Remove entry from package-lock.json
+ */
+function removeFromPackageLock(tree, sourceRoot) {
+    const packageLockPath = 'package-lock.json';
+    if (!tree.exists(packageLockPath)) {
+        return;
+    }
+    const packageLock = (0, devkit_1.readJson)(tree, packageLockPath);
+    let updated = false;
+    if (packageLock.packages) {
+        if (packageLock.packages[sourceRoot]) {
+            delete packageLock.packages[sourceRoot];
+            updated = true;
+        }
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, packageLockPath, packageLock);
+        devkit_1.logger.info(`Removed entry from package-lock.json`);
+    }
+}
+async function removeGenerator(tree, options) {
+    // Validate .unisphere exists
+    (0, utils_1.validateUnisphereConfig)(tree);
+    // Parse element string (format: "type:name")
+    const { elementType, name } = parseElement(options.element);
+    const normalizedName = (0, devkit_1.names)(name).fileName;
+    // Validate element exists and get sourceRoot
+    const sourceRoot = validateElementExists(tree, elementType, normalizedName);
+    // Verify the directory exists
+    if (!tree.exists(sourceRoot)) {
+        devkit_1.logger.warn(`Directory not found at ${sourceRoot}. The .unisphere configuration may be out of sync.`);
+    }
+    const nxProjectName = `${getNxProjectPrefix(elementType)}-${normalizedName}`;
+    devkit_1.logger.info('');
+    devkit_1.logger.info(`Removing ${elementType}: ${normalizedName}`);
+    devkit_1.logger.info(`  Location: ${sourceRoot}`);
+    devkit_1.logger.info('');
+    // Step 1: For runtimes, remove types first (before directory is deleted)
+    if (elementType === 'runtime') {
+        removeRuntimeTypes(tree, normalizedName);
+    }
+    // Step 2: Run Nx's built-in remove generator
+    try {
+        await (0, generators_1.removeGenerator)(tree, {
+            projectName: nxProjectName,
+            forceRemove: options.forceRemove || false,
+            skipFormat: false,
+        });
+        devkit_1.logger.info(`Removed Nx project "${nxProjectName}"`);
+    }
+    catch (error) {
+        // If Nx remove fails (e.g., project not in project.json), continue with cleanup
+        devkit_1.logger.warn(`Nx remove failed: ${error}`);
+        devkit_1.logger.info('Continuing with Unisphere cleanup...');
+        // Manually delete the directory if it exists
+        if (tree.exists(sourceRoot)) {
+            // Delete all files recursively
+            const deleteRecursively = (dirPath) => {
+                if (tree.isFile(dirPath)) {
+                    tree.delete(dirPath);
+                }
+                else {
+                    tree.children(dirPath).forEach(child => {
+                        deleteRecursively(`${dirPath}/${child}`);
+                    });
+                }
+            };
+            deleteRecursively(sourceRoot);
+            devkit_1.logger.info(`Manually deleted ${sourceRoot}`);
+        }
+    }
+    // Step 3: Remove from .unisphere configuration
+    removeFromUnisphereConfig(tree, elementType, normalizedName);
+    // Step 4: Remove path mapping from tsconfig.base.json
+    removeTsConfigPath(tree, elementType, normalizedName);
+    // Step 5: Remove entry from package-lock.json
+    removeFromPackageLock(tree, sourceRoot);
+    devkit_1.logger.info('');
+    devkit_1.logger.info(`${elementType.charAt(0).toUpperCase() + elementType.slice(1)} "${normalizedName}" removed successfully!`);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('Next steps:');
+    devkit_1.logger.info('  1. Run: npm install');
+    devkit_1.logger.info('  2. Run: npm run build');
+    devkit_1.logger.info('');
+}
+exports.default = removeGenerator;

package/dist/generators/remove/schema.d.ts

@@ -0,0 +1,4 @@
+export interface RemoveGeneratorSchema {
+  element: string; // format: "type:name" e.g., "runtime:admin"
+  forceRemove?: boolean;
+}

package/dist/generators/remove/schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "Remove",
+  "title": "Remove Unisphere Element",
+  "description": "Remove a Unisphere element (package, runtime, or application) from the workspace",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @unisphere/nx:remove package:my-package",
+      "description": "Remove a package named 'my-package'"
+    },
+    {
+      "command": "nx g @unisphere/nx:remove runtime:my-runtime",
+      "description": "Remove a runtime named 'my-runtime'"
+    },
+    {
+      "command": "nx g @unisphere/nx:remove application:my-app",
+      "description": "Remove an application named 'my-app'"
+    }
+  ],
+  "properties": {
+    "element": {
+      "type": "string",
+      "description": "The element to remove in format 'type:name' (e.g., runtime:admin, package:shared, application:my-app)",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Enter element to remove (format: type:name, e.g., runtime:admin):"
+    },
+    "forceRemove": {
+      "type": "boolean",
+      "description": "Force removal even if the element is still in use",
+      "default": false
+    }
+  },
+  "required": ["element"]
+}

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

@@ -10,6 +10,9 @@
  *    - Updating .unisphere configuration
  *    - Ensuring package.json name matches Unisphere conventions
  *    - Updating package-lock.json path keys (Nx doesn't handle this)
+ *    - Updating vite.config.ts cache directory paths
+ *    - Updating project.json lintFilePatterns and comments (Nx updates root/sourceRoot but not options strings)
+ *    - Updating README.md with new package name
  */
 import { Tree } from '@nx/devkit';
 import { RenamePackageGeneratorSchema } from './schema';

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

@@ -1 +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"}
+{"version":3,"file":"rename-package.d.ts","sourceRoot":"","sources":["../../../src/generators/rename-package/rename-package.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAgZxD,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,4BAA4B,uBAmHtC;AAED,eAAe,sBAAsB,CAAC"}

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

@@ -11,6 +11,9 @@
  *    - Updating .unisphere configuration
  *    - Ensuring package.json name matches Unisphere conventions
  *    - Updating package-lock.json path keys (Nx doesn't handle this)
+ *    - Updating vite.config.ts cache directory paths
+ *    - Updating project.json lintFilePatterns and comments (Nx updates root/sourceRoot but not options strings)
+ *    - Updating README.md with new package name
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renamePackageGenerator = renamePackageGenerator;
@@ -30,7 +33,13 @@ function validateOldPackageExists(tree, oldPackageName) {
             Object.keys(unisphereConfig.elements?.packages || {}).join(', '));
     }
     const packageConfig = unisphereConfig.elements.packages[normalizedOldName];
-    const oldPath = `unisphere/packages/${normalizedOldName}`;
+    // Use the actual sourceRoot from .unisphere (supports both old and new directory structures)
+    const sourceRoot = packageConfig.sourceRoot;
+    if (!sourceRoot) {
+        throw new Error(`Package "${normalizedOldName}" exists but has no sourceRoot configured in .unisphere`);
+    }
+    const oldPath = sourceRoot;
+    const subdirectory = (0, utils_1.extractSubdirectoryFromSourceRoot)(sourceRoot);
     // Verify the directory exists
     if (!tree.exists(oldPath)) {
         throw new Error(`Package directory not found at ${oldPath}.\n` +
@@ -46,24 +55,27 @@ function validateOldPackageExists(tree, oldPackageName) {
     const packageJsonName = packageJson.name;
     return {
         packageJsonName,
-        distributionChannel: packageConfig.distributionChannel || 'none',
         scope: packageConfig.scope || 'widget',
-        sourceRoot: packageConfig.sourceRoot,
+        sourceRoot,
+        subdirectory,
         oldPath,
-        newPath: `unisphere/packages/${normalizedOldName}`,
     };
 }
 /**
  * Validates that the new package name doesn't already exist
+ * Checks in the same subdirectory as the old package (rename keeps the package in the same location)
  */
-function validateNewPackageDoesNotExist(tree, newPackageName) {
+function validateNewPackageDoesNotExist(tree, newPackageName, subdirectory) {
     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}`;
+    // Build the new path using the same subdirectory as the old package
+    const newPath = subdirectory
+        ? `unisphere/packages/${subdirectory}/${normalizedNewName}`
+        : `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.');
@@ -77,15 +89,22 @@ function calculateNewPackageJsonName(tree, newPackageName, oldPackageJsonName) {
     const experienceName = unisphereConfig.name;
     const normalizedNewName = (0, devkit_1.names)(newPackageName).fileName;
     // Determine the prefix from the old package name
+    // Order matters - check more specific prefixes first
     let prefix;
-    if (oldPackageJsonName.startsWith('@unisphere/')) {
+    if (oldPackageJsonName.startsWith('@unisphere-corp/')) {
+        prefix = '@unisphere-corp/';
+    }
+    else if (oldPackageJsonName.startsWith('@local/')) {
+        prefix = '@local/';
+    }
+    else if (oldPackageJsonName.startsWith('@unisphere/')) {
         prefix = '@unisphere/';
     }
     else if (oldPackageJsonName.startsWith('@kaltura/unisphere-')) {
         prefix = '@kaltura/unisphere-';
     }
     else {
-        // Private package, no prefix
+        // Truly private package with no standard prefix
         return normalizedNewName;
     }
     // Calculate new package name
@@ -100,6 +119,7 @@ function calculateNewPackageJsonName(tree, newPackageName, oldPackageJsonName) {
 }
 /**
  * Update .unisphere configuration
+ * Preserves the subdirectory structure (package stays in same subdirectory after rename)
  */
 function updateUnisphereConfiguration(tree, oldPackageName, newPackageName, packageInfo) {
     const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
@@ -107,8 +127,10 @@ function updateUnisphereConfiguration(tree, oldPackageName, newPackageName, pack
     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}`;
+    // Build new sourceRoot preserving the subdirectory structure
+    const newSourceRoot = packageInfo.subdirectory
+        ? `unisphere/packages/${packageInfo.subdirectory}/${normalizedNewName}`
+        : `unisphere/packages/${normalizedNewName}`;
     // Preserve package order by rebuilding the packages object
     const newPackages = {};
     Object.keys(unisphereConfig.elements.packages).forEach((key) => {
@@ -145,20 +167,108 @@ function updatePackageJson(tree, packagePath, newPackageJsonName) {
         devkit_1.logger.info(`✅ Updated package.json name to "${newPackageJsonName}"`);
     }
 }
+/**
+ * Update vite.config.ts to rename cache directory paths
+ * Nx's move generator doesn't update arbitrary string literals in code files
+ */
+function updateViteConfig(tree, newPath, oldNormalizedName, newNormalizedName) {
+    const viteConfigPath = `${newPath}/vite.config.ts`;
+    if (!tree.exists(viteConfigPath)) {
+        return;
+    }
+    let content = tree.read(viteConfigPath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    const oldPattern = `package-${oldNormalizedName}`;
+    const newPattern = `package-${newNormalizedName}`;
+    if (content.includes(oldPattern)) {
+        content = content.replace(new RegExp(oldPattern, 'g'), newPattern);
+        tree.write(viteConfigPath, content);
+        devkit_1.logger.info(`✅ Updated vite.config.ts cache directories`);
+    }
+}
+/**
+ * Update project.json to fix lintFilePatterns and comments
+ * Nx's move generator updates root/sourceRoot but not arbitrary strings in options
+ */
+function updateProjectJson(tree, newPath, oldPath, oldNxProjectName, newNxProjectName) {
+    const projectJsonPath = `${newPath}/project.json`;
+    if (!tree.exists(projectJsonPath)) {
+        return;
+    }
+    let content = tree.read(projectJsonPath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    let updated = false;
+    // Update lintFilePatterns that still reference the old path
+    if (content.includes(oldPath)) {
+        content = content.replace(new RegExp(escapeRegExp(oldPath), 'g'), newPath);
+        updated = true;
+    }
+    // Update the "// targets" comment that contains the old project name
+    if (content.includes(oldNxProjectName)) {
+        content = content.replace(new RegExp(escapeRegExp(oldNxProjectName), 'g'), newNxProjectName);
+        updated = true;
+    }
+    if (updated) {
+        tree.write(projectJsonPath, content);
+        devkit_1.logger.info(`✅ Updated project.json paths and comments`);
+    }
+}
+/**
+ * Update README.md to reflect the new package name
+ * Nx's move generator doesn't update documentation files
+ */
+function updateReadme(tree, newPath, oldNormalizedName, newNormalizedName) {
+    const readmePath = `${newPath}/README.md`;
+    if (!tree.exists(readmePath)) {
+        return;
+    }
+    let content = tree.read(readmePath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    let updated = false;
+    // Convert to human readable format (capitalize first letter of each word)
+    const toHumanReadable = (name) => name
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, (l) => l.toUpperCase());
+    const oldHumanReadable = toHumanReadable(oldNormalizedName);
+    const newHumanReadable = toHumanReadable(newNormalizedName);
+    // Update human readable name (e.g., "Package My Package" -> "Package New Name")
+    if (content.includes(oldHumanReadable)) {
+        content = content.replace(new RegExp(escapeRegExp(oldHumanReadable), 'g'), newHumanReadable);
+        updated = true;
+    }
+    // Update kebab-case name references
+    if (content.includes(oldNormalizedName)) {
+        content = content.replace(new RegExp(escapeRegExp(oldNormalizedName), 'g'), newNormalizedName);
+        updated = true;
+    }
+    if (updated) {
+        tree.write(readmePath, content);
+        devkit_1.logger.info(`✅ Updated README.md`);
+    }
+}
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 /**
  * Update package-lock.json to rename the package path keys
  * Nx's move generator doesn't handle package-lock.json updates
+ * Uses actual paths from packageInfo to support subdirectories
  */
-function updatePackageLock(tree, oldPackageName, newPackageName) {
+function updatePackageLock(tree, oldPath, newPath) {
     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);
@@ -203,13 +313,16 @@ async function renamePackageGenerator(tree, options) {
     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);
+    // Validate new package doesn't exist (checks in same subdirectory)
+    validateNewPackageDoesNotExist(tree, normalizedNewName, packageInfo.subdirectory);
     // 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}`;
+    // Build new path preserving subdirectory structure
+    const newPath = packageInfo.subdirectory
+        ? `unisphere/packages/${packageInfo.subdirectory}/${normalizedNewName}`
+        : `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}`);
@@ -240,14 +353,20 @@ async function renamePackageGenerator(tree, options) {
     // 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);
+    updatePackageLock(tree, packageInfo.oldPath, newPath);
+    // Step 5: Update vite.config.ts cache directories (Nx doesn't handle this)
+    updateViteConfig(tree, newPath, normalizedOldName, normalizedNewName);
+    // Step 6: Update project.json lintFilePatterns and comments (Nx doesn't handle these)
+    updateProjectJson(tree, newPath, packageInfo.oldPath, oldNxProjectName, newNxProjectName);
+    // Step 7: Update README.md (Nx doesn't handle documentation)
+    updateReadme(tree, newPath, 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(`  • Old location: ${packageInfo.sourceRoot}`);
     devkit_1.logger.info(`  • New location: ${newPath}`);
     devkit_1.logger.info(`  • Package.json name: ${newPackageJsonName}`);
     devkit_1.logger.info('');