@unisphere/nx 2.2.2 → 3.2.4

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('');

package/dist/generators/utils.d.ts

@@ -2,6 +2,10 @@ import { Tree } from '@nx/devkit';
 export interface UnisphereConfig {
     company: string;
     name: string;
+    runtimes: Record<string, {
+        sourceRoot: string;
+        visuals: string[];
+    }>;
 }
 export declare function validateUnisphereConfig(tree: Tree): UnisphereConfig;
 export declare function updateTsConfigPaths(tree: Tree, pathKey: string, pathValue: string): void;
@@ -16,7 +20,7 @@ export declare function findTypesPackageAlias(tree: Tree): string | null;
 export interface TypesPackageInfo {
     /** The tsconfig alias for the package (e.g., "@mycompany/types" or "@mycompany/core") */
     alias: string;
-    /** The base path to the package (e.g., "unisphere/packages/types" or "unisphere/packages/core") */
+    /** The base path to the package (e.g., "unisphere/packages/types" or "unisphere/packages/public/core") */
     basePath: string;
     /** Whether the types package exists (true) or falling back to core (false) */
     hasTypesPackage: boolean;
@@ -32,5 +36,30 @@ type NameTransformations<Prefix extends string> = {
 export declare function createNameTransforms<Prefix extends string>(baseName: string, prefix: Prefix): NameTransformations<Prefix>;
 export declare function isPackageInstalled(tree: Tree, packageName: string): string | false;
 export declare function checkIfRuntimeExists(tree: Tree, runtimeName: string): boolean;
+/**
+ * Maps package scope to subdirectory name
+ * @param scope - The package scope ('public', 'internal', 'none')
+ * @returns The subdirectory name ('unisphere', 'kaltura-corp', 'local')
+ */
+export declare function getSubdirectoryFromScope(scope: 'public' | 'internal' | 'none' | 'kaltura-ai'): string;
+/**
+ * Extracts the subdirectory from a package sourceRoot path
+ * @param sourceRoot - The sourceRoot path (e.g., "unisphere/packages/kaltura-corp/shared")
+ * @returns The subdirectory name ('unisphere', 'kaltura-corp', 'local') or null if flat structure
+ */
+export declare function extractSubdirectoryFromSourceRoot(sourceRoot: string): string | null;
+/**
+ * Extracts the package name from a package sourceRoot path
+ * @param sourceRoot - The sourceRoot path (e.g., "unisphere/packages/corp/shared" or "unisphere/packages/shared")
+ * @returns The package name
+ */
+export declare function extractPackageNameFromSourceRoot(sourceRoot: string): string;
+/**
+ * Adds a script to the root package.json
+ * @param tree - The file system tree
+ * @param scriptName - The name of the script (e.g., "dev:my-app")
+ * @param scriptCommand - The command to run (e.g., "npx unisphere application serve my-app --port 4002")
+ */
+export declare function addScriptToRootPackageJson(tree: Tree, scriptName: string, scriptCommand: string): void;
 export {};
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,CAmDnE;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QA4BjF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,EACrD,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QA2BnC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6C7E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA8BvD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAuB/D;AAED,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,KAAK,EAAE,MAAM,CAAC;IACd,mGAAmG;IACnG,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAkBvE;AAGD,KAAK,mBAAmB,CAAC,MAAM,SAAS,MAAM,IAAI;KAC/C,CAAC,IACE,GAAG,MAAM,EAAE,GACX,GAAG,MAAM,iBAAiB,GAC1B,GAAG,MAAM,aAAa,GACtB,GAAG,MAAM,cAAc,GACvB,GAAG,MAAM,gBAAgB,GACzB,GAAG,MAAM,iBAAiB,GAAG,MAAM;CACxC,CAAC;AAKF,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAczH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAwBlF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAgB7E"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC,CAAC;CACJ;AA+FD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,CAkEnE;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QA2BjF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,EACrD,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QA0BnC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA4C7E;AA0BD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA6BvD;AAsBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAuB/D;AAED,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,KAAK,EAAE,MAAM,CAAC;IACd,0GAA0G;IAC1G,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAgCD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CA8BvE;AAGD,KAAK,mBAAmB,CAAC,MAAM,SAAS,MAAM,IAAI;KAC/C,CAAC,IACA,GAAG,MAAM,EAAE,GACX,GAAG,MAAM,iBAAiB,GAC1B,GAAG,MAAM,aAAa,GACtB,GAAG,MAAM,cAAc,GACvB,GAAG,MAAM,gBAAgB,GACzB,GAAG,MAAM,iBAAiB,GAAG,MAAM;CACtC,CAAC;AAKF,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAwBzH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAwBlF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAgB7E;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,MAAM,CAQrG;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWnF;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,GACpB,IAAI,CAyBN"}

package/dist/generators/utils.js

@@ -10,7 +10,90 @@ exports.findTypesOrCorePackageInfo = findTypesOrCorePackageInfo;
 exports.createNameTransforms = createNameTransforms;
 exports.isPackageInstalled = isPackageInstalled;
 exports.checkIfRuntimeExists = checkIfRuntimeExists;
+exports.getSubdirectoryFromScope = getSubdirectoryFromScope;
+exports.extractSubdirectoryFromSourceRoot = extractSubdirectoryFromSourceRoot;
+exports.extractPackageNameFromSourceRoot = extractPackageNameFromSourceRoot;
+exports.addScriptToRootPackageJson = addScriptToRootPackageJson;
 const devkit_1 = require("@nx/devkit");
+/**
+ * Extracts visual type names from a runtime.tsx file
+ * Looks for visualTypes object in the constructor's super() call
+ * Returns empty array if file doesn't exist or parsing fails
+ */
+function extractVisualTypesFromRuntime(tree, runtimeSourceRoot) {
+    const runtimeFilePath = `${runtimeSourceRoot}/src/lib/runtime.tsx`;
+    // Check if runtime.tsx exists
+    if (!tree.exists(runtimeFilePath)) {
+        return [];
+    }
+    try {
+        // Read the file content
+        const content = tree.read(runtimeFilePath, 'utf-8');
+        if (!content) {
+            return [];
+        }
+        // Find the start of visualTypes
+        const visualTypesStart = content.indexOf('visualTypes:');
+        if (visualTypesStart === -1) {
+            return [];
+        }
+        // Find the opening brace after visualTypes
+        const openBraceIndex = content.indexOf('{', visualTypesStart);
+        if (openBraceIndex === -1) {
+            return [];
+        }
+        // Count braces to find the matching closing brace
+        let braceCount = 1;
+        let currentIndex = openBraceIndex + 1;
+        let closeBraceIndex = -1;
+        while (currentIndex < content.length && braceCount > 0) {
+            if (content[currentIndex] === '{') {
+                braceCount++;
+            }
+            else if (content[currentIndex] === '}') {
+                braceCount--;
+                if (braceCount === 0) {
+                    closeBraceIndex = currentIndex;
+                    break;
+                }
+            }
+            currentIndex++;
+        }
+        if (closeBraceIndex === -1) {
+            return [];
+        }
+        // Extract the content between the braces
+        const visualTypesContent = content.substring(openBraceIndex + 1, closeBraceIndex);
+        // Find the minimum indentation level (first-level properties)
+        const lines = visualTypesContent.split('\n');
+        const indentations = [];
+        for (const line of lines) {
+            const match = line.match(/^(\s*)(\w+)\s*:/);
+            if (match) {
+                indentations.push(match[1].length);
+            }
+        }
+        // If no properties found, return empty array
+        if (indentations.length === 0) {
+            return [];
+        }
+        // Find minimum indentation (first-level properties)
+        const minIndent = Math.min(...indentations);
+        // Extract visual names (only first-level properties with minimum indentation)
+        const visuals = [];
+        for (const line of lines) {
+            const match = line.match(/^(\s*)(\w+)\s*:/);
+            if (match && match[1].length === minIndent) {
+                visuals.push(match[2]);
+            }
+        }
+        return visuals;
+    }
+    catch (error) {
+        // If any error occurs during parsing, return empty array
+        return [];
+    }
+}
 function validateUnisphereConfig(tree) {
     // Check if file exists
     if (!tree.exists('.unisphere')) {
@@ -45,9 +128,24 @@ function validateUnisphereConfig(tree) {
             '  "name": "your-experience-name"\n' +
             '}');
     }
+    // Extract runtimes with their visual types
+    const runtimes = {};
+    if (config.elements?.runtimes) {
+        for (const [runtimeName, runtimeConfig] of Object.entries(config.elements.runtimes)) {
+            const sourceRoot = runtimeConfig.sourceRoot;
+            if (sourceRoot && typeof sourceRoot === 'string') {
+                const visuals = extractVisualTypesFromRuntime(tree, sourceRoot);
+                runtimes[runtimeName] = {
+                    sourceRoot,
+                    visuals,
+                };
+            }
+        }
+    }
     return {
         company: config.company,
         name: config.name,
+        runtimes,
     };
 }
 function updateTsConfigPaths(tree, pathKey, pathValue) {
@@ -124,6 +222,28 @@ function validateRuntimeExists(tree, runtimeName) {
     }
     return runtimeConfig.sourceRoot;
 }
+/**
+ * Checks if a path matches the core package pattern
+ * Supports both old (unisphere/packages/core) and new (unisphere/packages/<visibility>/core) patterns
+ */
+function isCorePackagePath(pathValue) {
+    // Old pattern: unisphere/packages/core/src/index.ts
+    // New patterns with subdirectories
+    const corePatterns = [
+        'unisphere/packages/local/core/src/index.ts',
+        'unisphere/packages/kaltura-corp/core/src/index.ts',
+        'unisphere/packages/unisphere/core/src/index.ts',
+        'unisphere/packages/kaltura-ai/core/src/index.ts',
+    ];
+    return corePatterns.includes(pathValue);
+}
+/**
+ * Extracts the base path from a tsconfig path value
+ * e.g., "unisphere/packages/public/core/src/index.ts" -> "unisphere/packages/public/core"
+ */
+function extractBasePath(pathValue) {
+    return pathValue.replace('/src/index.ts', '');
+}
 function findCorePackageAlias(tree) {
     if (!tree.exists('tsconfig.base.json')) {
         throw new Error('tsconfig.base.json not found in the project root.');
@@ -133,19 +253,38 @@ function findCorePackageAlias(tree) {
         if (!tsconfigBase.compilerOptions?.paths) {
             throw new Error('No paths found in tsconfig.base.json compilerOptions.');
         }
-        // Find the key that has the value "unisphere/packages/core/src/index.ts"
+        // Find the key that has a core package path (supports both old and new patterns)
         for (const [key, paths] of Object.entries(tsconfigBase.compilerOptions.paths)) {
-            if (Array.isArray(paths) && paths.includes('unisphere/packages/core/src/index.ts')) {
+            if (Array.isArray(paths) && paths.some(p => isCorePackagePath(p))) {
                 return key;
             }
         }
         throw new Error('Core package not found in tsconfig.base.json paths. ' +
-            'Expected to find a key with value "unisphere/packages/core/src/index.ts"');
+            'Expected to find a key with value matching "unisphere/packages/[<visibility>/]core/src/index.ts"');
     }
     catch (error) {
         throw new Error(`Failed to read tsconfig.base.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+/**
+ * Checks if a path matches the types package pattern
+ * Supports both old (unisphere/packages/types) and new (unisphere/packages/<visibility>/types) patterns
+ */
+function isTypesPackagePath(pathValue) {
+    const typesPatterns = [
+        'unisphere/packages/types/src/index.ts',
+        // Old subdirectory names (for backwards compatibility)
+        'unisphere/packages/private/types/src/index.ts',
+        'unisphere/packages/corp/types/src/index.ts',
+        'unisphere/packages/public/types/src/index.ts',
+        // New subdirectory names (v3 migration)
+        'unisphere/packages/local/types/src/index.ts',
+        'unisphere/packages/kaltura-corp/types/src/index.ts',
+        'unisphere/packages/unisphere/types/src/index.ts',
+        'unisphere/packages/kaltura-ai/types/src/index.ts',
+    ];
+    return typesPatterns.includes(pathValue);
+}
 /**
  * Tries to find the types package alias in tsconfig.base.json
  * Returns null if types package is not found
@@ -159,9 +298,9 @@ function findTypesPackageAlias(tree) {
         if (!tsconfigBase.compilerOptions?.paths) {
             return null;
         }
-        // Find the key that has the value "unisphere/packages/types/src/index.ts"
+        // Find the key that has a types package path (supports both old and new patterns)
         for (const [key, paths] of Object.entries(tsconfigBase.compilerOptions.paths)) {
-            if (Array.isArray(paths) && paths.includes('unisphere/packages/types/src/index.ts')) {
+            if (Array.isArray(paths) && paths.some(p => isTypesPackagePath(p))) {
                 return key;
             }
         }
@@ -171,6 +310,32 @@ function findTypesPackageAlias(tree) {
         return null;
     }
 }
+/**
+ * Finds the actual base path for a package from tsconfig.base.json
+ */
+function findPackageBasePath(tree, pathMatcher) {
+    if (!tree.exists('tsconfig.base.json')) {
+        return null;
+    }
+    try {
+        const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+        if (!tsconfigBase.compilerOptions?.paths) {
+            return null;
+        }
+        for (const [, paths] of Object.entries(tsconfigBase.compilerOptions.paths)) {
+            if (Array.isArray(paths)) {
+                const matchingPath = paths.find(p => pathMatcher(p));
+                if (matchingPath) {
+                    return extractBasePath(matchingPath);
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Finds the types package if it exists, otherwise falls back to core package.
  * Returns info about which package to use for runtime types.
@@ -178,21 +343,39 @@ function findTypesPackageAlias(tree) {
 function findTypesOrCorePackageInfo(tree) {
     const typesAlias = findTypesPackageAlias(tree);
     if (typesAlias) {
+        const basePath = findPackageBasePath(tree, isTypesPackagePath);
+        if (!basePath) {
+            throw new Error('Types package base path not found');
+        }
         return {
             alias: typesAlias,
-            basePath: 'unisphere/packages/types',
+            basePath,
             hasTypesPackage: true,
         };
     }
     // Fallback to core package
     const coreAlias = findCorePackageAlias(tree);
+    const basePath = findPackageBasePath(tree, isCorePackagePath);
+    if (!basePath) {
+        throw new Error('Core package base path not found');
+    }
     return {
         alias: coreAlias,
-        basePath: 'unisphere/packages/core',
+        basePath,
         hasTypesPackage: false,
     };
 }
 function createNameTransforms(baseName, prefix) {
+    if (!baseName) {
+        return {
+            [`${prefix}`]: '',
+            [`${prefix}__lowerDashCase`]: '',
+            [`${prefix}__camelCase`]: '',
+            [`${prefix}__pascalCase`]: '',
+            [`${prefix}__constantCase`]: '',
+            [`${prefix}__humanReadable`]: '',
+        }; // Type assertion to match the defined type
+    }
     const nameVariants = (0, devkit_1.names)(baseName); // Assuming 'names' function is available and returns NameVariants
     const humanReadable = baseName
         .replace(/[-_]/g, ' ')
@@ -244,3 +427,71 @@ function checkIfRuntimeExists(tree, runtimeName) {
         return false;
     }
 }
+/**
+ * Maps package scope to subdirectory name
+ * @param scope - The package scope ('public', 'internal', 'none')
+ * @returns The subdirectory name ('unisphere', 'kaltura-corp', 'local')
+ */
+function getSubdirectoryFromScope(scope) {
+    const scopeToSubdirectory = {
+        'public': 'unisphere',
+        'internal': 'kaltura-corp',
+        'none': 'local',
+        'kaltura-ai': 'kaltura-ai',
+    };
+    return scopeToSubdirectory[scope];
+}
+/**
+ * Extracts the subdirectory from a package sourceRoot path
+ * @param sourceRoot - The sourceRoot path (e.g., "unisphere/packages/kaltura-corp/shared")
+ * @returns The subdirectory name ('unisphere', 'kaltura-corp', 'local') or null if flat structure
+ */
+function extractSubdirectoryFromSourceRoot(sourceRoot) {
+    const parts = sourceRoot.split('/');
+    // Expected format: unisphere/packages/<subdirectory>/<packageName>
+    // Or old format: unisphere/packages/<packageName>
+    if (parts.length === 4 && parts[0] === 'unisphere' && parts[1] === 'packages') {
+        const subdirectory = parts[2];
+        if (['local', 'kaltura-corp', 'unisphere', 'kaltura-ai'].includes(subdirectory)) {
+            return subdirectory;
+        }
+    }
+    return null; // Flat structure
+}
+/**
+ * Extracts the package name from a package sourceRoot path
+ * @param sourceRoot - The sourceRoot path (e.g., "unisphere/packages/corp/shared" or "unisphere/packages/shared")
+ * @returns The package name
+ */
+function extractPackageNameFromSourceRoot(sourceRoot) {
+    const parts = sourceRoot.split('/');
+    // Return the last part of the path
+    return parts[parts.length - 1];
+}
+/**
+ * Adds a script to the root package.json
+ * @param tree - The file system tree
+ * @param scriptName - The name of the script (e.g., "dev:my-app")
+ * @param scriptCommand - The command to run (e.g., "npx unisphere application serve my-app --port 4002")
+ */
+function addScriptToRootPackageJson(tree, scriptName, scriptCommand) {
+    if (!tree.exists('package.json')) {
+        devkit_1.logger.warn('⚠️ package.json not found in root directory, cannot add script');
+        return;
+    }
+    try {
+        const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+        // Ensure scripts object exists
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        // Only add if script doesn't already exist
+        if (!packageJson.scripts[scriptName]) {
+            packageJson.scripts[scriptName] = scriptCommand;
+            (0, devkit_1.writeJson)(tree, 'package.json', packageJson);
+        }
+    }
+    catch (error) {
+        devkit_1.logger.warn(`⚠️ Failed to add script to package.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}