@unisphere/nx 1.13.0 → 1.18.0

package/dist/generators/add-package/add-package.js

@@ -113,7 +113,7 @@ export const ${demoName} = () => {
 `;
     }
     else {
-        content = `export const ${demoName} = () => {}`;
+        content = `export const ${demoName} = {}`;
     }
     tree.write(targetPath, content);
 }

package/dist/generators/add-runtime/add-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAiB,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAyCrD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,uBAsHnC;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAiB,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAwCrD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,uBAqHnC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/generators/add-runtime/add-runtime.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const path = tslib_1.__importStar(require("path"));
 const utils_1 = require("../utils");
-const add_package_1 = require("../add-package/add-package");
 const add_application_1 = require("../add-application/add-application");
 function updateCoreIndexExport(tree, runtimeName) {
     const coreIndexPath = 'unisphere/packages/core/src/index.ts';
@@ -69,17 +68,17 @@ async function addRuntimeGenerator(tree, options) {
     const runtimePathKey = `unisphere-runtime-${userInputRuntimeName}`;
     const runtimePathValue = `unisphere/runtimes/${userInputRuntimeName}/src/index.ts`;
     (0, utils_1.updateTsConfigPaths)(tree, runtimePathKey, runtimePathValue);
-    // Create a package with the same name as the runtime and distribution set to none
-    const packageResult = await (0, add_package_1.addPackageGenerator)(tree, {
-        packageName: userInputRuntimeName,
-        scope: 'none',
-    });
-    // Execute the package generation callback if it exists
-    if (packageResult && typeof packageResult === 'function') {
-        packageResult();
-    }
+    // // Create a package with the same name as the runtime and distribution set to none
+    // const packageResult = await addPackageGenerator(tree, {
+    //   packageName: userInputRuntimeName,
+    //   scope: 'none',
+    // });
+    // // Execute the package generation callback if it exists
+    // if (packageResult && typeof packageResult === 'function') {
+    //   packageResult();
+    // }
     // Handle loadedByExternalHost usage - create package and expo application
-    if (options.usage === 'loadedByExternalHost') {
+    if (options.standalone === true) {
         // Create an expo application without prompts
         const applicationResult = await (0, add_application_1.addApplicationGenerator)(tree, {
             name: `${userInputRuntimeName}-expo`,
@@ -99,11 +98,10 @@ async function addRuntimeGenerator(tree, options) {
         devkit_1.logger.info('');
         devkit_1.logger.info(`🚀 Runtime Name: ${userInputRuntimeName}`);
         devkit_1.logger.info(`📁 Location: ${projectRoot}`);
-        devkit_1.logger.info(`🔧 Usage: ${options.usage}`);
-        if (options.usage === 'loadedByExternalHost') {
+        devkit_1.logger.info(`🔧 Standalone: ${options.standalone ? 'Yes' : 'No'}`);
+        if (options.standalone === true) {
             devkit_1.logger.info('');
             devkit_1.logger.info('📦 Additional components created:');
-            devkit_1.logger.info(`   • Package: ${userInputRuntimeName} (scope: none)`);
             devkit_1.logger.info(`   • Expo Application: ${userInputRuntimeName}-expo`);
         }
         devkit_1.logger.info('');

package/dist/generators/add-runtime/schema.d.ts

@@ -1,4 +1,4 @@
 export interface AddRuntimeGeneratorSchema {
   name: string;
-  usage: 'loadedByExternalHost' | 'composedIntoAnotherRuntime';
+  standalone: boolean;
 }

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

@@ -10,24 +10,17 @@
       "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?",
-        "type": "list",
-        "items": [
-          {
-            "value": "loadedByExternalHost",
-            "label": "Independent experience used as an entry point (loaded by host or another experience)"
-          },
-          {
-            "value": "composedIntoAnotherRuntime",
-            "label": "Composed into another runtime of this experience (not used as an entry point)"
-          }         
-        ]
+        "message": "Is this experience being loaded by the host application, or by another experience (not this one)?",
+        "type": "confirmation"
       }
     }
   },
-  "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/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/generators.json

@@ -25,6 +25,11 @@
       "schema": "./dist/generators/unisphere-migrate/schema.json",
       "description": "Manually run all Unisphere migrations from migrations.json",
       "hidden": false
+    },
+    "rename-package": {
+      "factory": "./dist/generators/rename-package/rename-package",
+      "schema": "./dist/generators/rename-package/schema.json",
+      "description": "Rename a unisphere package and update all references"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unisphere/nx",
-  "version": "1.13.0",
+  "version": "1.18.0",
   "private": false,
   "main": "./dist/index.js",
   "module": "./dist/index.js",