@unisphere/nx 3.20.0 → 3.22.0

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

@@ -1 +1 @@
-{"version":3,"file":"add-application.d.ts","sourceRoot":"","sources":["../../../src/generators/add-application/add-application.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAgD,MAAM,YAAY,CAAC;AAE5G,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAkHzD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,6BAA6B,uBAgKvC;AAED,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"add-application.d.ts","sourceRoot":"","sources":["../../../src/generators/add-application/add-application.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAgD,MAAM,YAAY,CAAC;AAE5G,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAkHzD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,6BAA6B,uBAoLvC;AAED,eAAe,uBAAuB,CAAC"}

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

@@ -79,19 +79,30 @@ async function addApplicationGenerator(tree, options) {
         throw new Error('iframe-with-post-messages serving type is not currently supported. Please choose a different serving type.');
     }
     const isPlayground = options.servingType === 'local-dev-playground';
+    const isAssetsOnly = options.servingType === 'assets-only';
     // Validate and read .unisphere configuration
     const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
-    const promptResult = await promptForRuntimeName(unisphereConfig.runtimes, options.runtimeName || '', options.visualName || '', options.skipDynamicRuntimeVisualPrompt || false);
-    const runtimeName = promptResult.runtimeName;
-    const visualName = promptResult.visualName;
-    if (!isPlayground && !options.htmlPageTitle) {
-        options.htmlPageTitle = options.htmlPageTitle || await promptForHtmlPageTitle();
+    let runtimeName = '';
+    let visualName = '';
+    let selectedDependencies = [];
+    if (isAssetsOnly) {
+        // Assets-only apps don't need runtime, visual, or dependencies
+        options.htmlPageTitle = options.htmlPageTitle || options.name;
+        selectedDependencies = [];
     }
-    if (options.dependencies === undefined) {
-        options.dependencies = await promptForDependencies(isPlayground);
+    else {
+        const promptResult = await promptForRuntimeName(unisphereConfig.runtimes, options.runtimeName || '', options.visualName || '', options.skipDynamicRuntimeVisualPrompt || false);
+        runtimeName = promptResult.runtimeName;
+        visualName = promptResult.visualName;
+        if (!isPlayground && !options.htmlPageTitle) {
+            options.htmlPageTitle = options.htmlPageTitle || await promptForHtmlPageTitle();
+        }
+        if (options.dependencies === undefined) {
+            options.dependencies = await promptForDependencies(isPlayground);
+        }
+        const baseDependencies = ['react'];
+        selectedDependencies = [...baseDependencies, ...(options.dependencies || [])];
     }
-    const baseDependencies = ['react'];
-    const selectedDependencies = [...baseDependencies, ...(options.dependencies || [])];
     // Validate runtime exists if runtimeName is provided
     if (runtimeName) {
         if (!(0, utils_1.checkIfRuntimeExists)(tree, runtimeName)) {
@@ -132,7 +143,7 @@ async function addApplicationGenerator(tree, options) {
             'Please choose a different application name or remove the existing application first.');
     }
     // Choose template based on serving type
-    const templatePath = 'templates/default';
+    const templatePath = isAssetsOnly ? 'templates/assets-only' : 'templates/default';
     // Generate files from templates
     (0, devkit_1.generateFiles)(tree, path.join(__dirname, templatePath), projectRoot, templateVariables);
     // For local-dev-playground apps, generate setup-local-runtimes.ts
@@ -176,14 +187,19 @@ async function addApplicationGenerator(tree, options) {
     const applicationPathValue = `${projectRoot}/src/index.ts`;
     (0, utils_1.updateTsConfigPaths)(tree, applicationPathKey, applicationPathValue);
     const scriptName = `serve:${applicationNameAsLowerDashCase}`;
-    const scriptCommand = runtimeName ?
-        `concurrently "npx unisphere runtime serve ${runtimeName} --port 8400" "npx unisphere application serve ${applicationNameAsLowerDashCase} --port 4002"`
-        : `npx unisphere application serve ${applicationNameAsLowerDashCase} --port 4002`;
-    (0, utils_1.addScriptToRootPackageJson)(tree, scriptName, scriptCommand);
+    if (!isAssetsOnly) {
+        const scriptCommand = runtimeName ?
+            `concurrently "npx unisphere runtime serve ${runtimeName} --port 8400" "npx unisphere application serve ${applicationNameAsLowerDashCase} --port 4002"`
+            : `npx unisphere application serve ${applicationNameAsLowerDashCase} --port 4002`;
+        (0, utils_1.addScriptToRootPackageJson)(tree, scriptName, scriptCommand);
+    }
     await (0, devkit_1.formatFiles)(tree);
     // Return a function that will be executed after all file operations are complete
+    const hasExtraDependencies = selectedDependencies.length > 0;
     return () => {
-        (0, devkit_1.installPackagesTask)(tree, true);
+        if (hasExtraDependencies) {
+            (0, devkit_1.installPackagesTask)(tree, true);
+        }
         devkit_1.logger.info('');
         devkit_1.logger.info('✅ Application generated successfully!');
         devkit_1.logger.info('');
@@ -191,7 +207,12 @@ async function addApplicationGenerator(tree, options) {
         devkit_1.logger.info(`🔧 Serving Type: ${options.servingType}`);
         devkit_1.logger.info(`📁 Location: ${projectRoot}`);
         devkit_1.logger.info('');
-        devkit_1.logger.info(`📜 To run the application locally: npm run ${scriptName}`);
+        if (isAssetsOnly) {
+            devkit_1.logger.info(`📂 Place your assets in: ${projectRoot}/src/assets/`);
+        }
+        else {
+            devkit_1.logger.info(`📜 To run the application locally: npm run ${scriptName}`);
+        }
         devkit_1.logger.info('');
     };
 }

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

@@ -1,7 +1,7 @@
 export interface AddApplicationGeneratorSchema {
   name: string;
   htmlPageTitle?: string;
-  servingType: 'local-dev-playground' | 'self-hosted' | 'iframe-with-post-messages';
+  servingType: 'local-dev-playground' | 'self-hosted' | 'iframe-with-post-messages' | 'assets-only';
   runtimeName?: string;
   visualName?: string;
   skipDynamicRuntimeVisualPrompt?: boolean; // Internal option to skip the dynamic prompt for visual when runtime is selected

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

@@ -33,6 +33,10 @@
           {
             "value": "iframe-with-post-messages",
             "label": "Iframe + Post Messages (suitible to applications that gets required configuration from post messages)"
+          },
+          {
+            "value": "assets-only",
+            "label": "Assets Only (static assets served via CDN, no application logic)"
           }
         ]
       }

package/dist/generators/add-application/templates/assets-only/.babelrc

@@ -0,0 +1,11 @@
+{
+  "presets": [
+    [
+      "@nx/react/babel",
+      {
+        "runtime": "automatic"
+      }
+    ]
+  ],
+  "plugins": []
+}

package/dist/generators/add-application/templates/assets-only/.env-template

@@ -0,0 +1,6 @@
+# Environment variables template
+# Copy this file to .env and fill in the values
+# Do not commit .env to version control
+
+# Example:
+# API_URL=https://api.example.com

package/dist/generators/add-application/templates/assets-only/.eslintrc.json

@@ -0,0 +1,22 @@
+{
+  "extends": ["plugin:@nx/react", "../../../../.eslintrc.json"],
+  "ignorePatterns": [
+    "!**/*",
+    "**/vite.config.*.timestamp*",
+    "**/vitest.config.*.timestamp*"
+  ],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/dist/generators/add-application/templates/assets-only/package.json.template

@@ -0,0 +1,5 @@
+{
+  "name": "unisphere-application-<%= applicationName__lowerDashCase %>",
+  "version": "1.0.0",
+  "dependencies": {}
+}

package/dist/generators/add-application/templates/assets-only/project.json.template

@@ -0,0 +1,9 @@
+{
+  "name": "unisphere-application-<%= applicationName__lowerDashCase %>",
+  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "<%= projectRoot %>/src",
+  "projectType": "application",
+  "tags": [],
+  "// targets": "to see all targets run: nx show project unisphere-application-<%= applicationName__lowerDashCase %> --web",
+  "targets": {}
+}

package/dist/generators/add-application/templates/assets-only/readme.md.template

@@ -0,0 +1,13 @@
+# <%= applicationName__pascalCase %> Application (Assets Only)
+
+This is an assets-only application. Place your static assets in the `src/assets/` directory.
+
+## Assets URL
+
+After publishing, assets are available at:
+
+```
+https://unisphere.nvp1.ovp.kaltura.com/v1/static/applications/{experience name}/<%= applicationName__lowerDashCase %>/{version}/assets/
+```
+
+## Overview section

package/dist/generators/add-application/templates/assets-only/src/assets/README.md

@@ -0,0 +1,20 @@
+# Assets
+
+Place your static assets in this directory. They are bundled automatically during the build process.
+
+## Accessing Assets
+
+Releasing a package will automatically deploy it to nvp1. Assets can be consumed without activating the version using the following URL pattern:
+
+```
+https://unisphere.nvp1.ovp.kaltura.com/v1/static/applications/{experience name}/{app name}/{version}/assets/
+```
+
+For example:
+```
+https://unisphere.nvp1.ovp.kaltura.com/v1/static/applications/vod-avatars/studio/1.1.0/assets/avatars/1X1/adam.png
+```
+
+## Caching
+
+Caching is handled on the assets directly.

package/dist/generators/add-application/templates/assets-only/src/index.html.template

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8" />
+  <title>
+    <%= htmlPageTitle %>
+  </title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+</head>
+
+<body>
+  <div id="root"></div>
+</body>
+
+</html>

package/dist/generators/add-application/templates/assets-only/src/main.tsx.template

@@ -0,0 +1,2 @@
+// Assets-only application — no application logic required.
+// Place your static assets in the ./assets/ directory.

package/dist/generators/add-application/templates/assets-only/tsconfig.app.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "types": [
+      "node"
+    ]
+  },
+  "exclude": [],
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/dist/generators/add-application/templates/assets-only/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "allowJs": false,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    }
+  ],
+  "extends": "../../../../tsconfig.base.json"
+}

package/dist/generators/add-application/templates/assets-only/webpack.config.js.template

@@ -0,0 +1,24 @@
+const { NxAppWebpackPlugin } = require('@nx/webpack/app-plugin');
+const { join } = require('path');
+
+const baseHref = process.env.UNISPHERE_BASE_HREF || '/';
+
+module.exports = {
+  output: {
+    path: join(__dirname, '../../../../dist/<%= projectRoot %>'),
+    publicPath: baseHref
+  },
+  plugins: [
+    new NxAppWebpackPlugin({
+      tsConfig: './tsconfig.app.json',
+      compiler: 'babel',
+      main: './src/main.tsx',
+      index: './src/index.html',
+      baseHref,
+      assets: [{ glob: '**/*', input: './src/assets', output: './assets', ignore: ['**/README.md'] }],
+      styles: [],
+      outputHashing: process.env['NODE_ENV'] === 'production' ? 'all' : 'none',
+      optimization: process.env['NODE_ENV'] === 'production',
+    }),
+  ],
+};

package/dist/generators/change-package-scope/change-package-scope.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Change Package Scope Generator
+ *
+ * Changes a package's npm scope by:
+ * 1. Validating the package exists and target scope is valid
+ * 2. Parsing the package.json name to extract current scope and package name
+ * 3. 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
+ * 4. Performing Unisphere-specific cleanup:
+ *    - Updating .unisphere configuration
+ *    - Ensuring package.json name matches conventions
+ *    - Updating package-lock.json path keys
+ *    - Updating vite.config.ts cache directory paths
+ *    - Updating project.json lintFilePatterns and comments
+ *    - Updating README.md with new package name
+ */
+import { Tree } from '@nx/devkit';
+import { ChangePackageScopeGeneratorSchema } from './schema';
+export declare function changePackageScopeGenerator(tree: Tree, options: ChangePackageScopeGeneratorSchema): Promise<void>;
+export default changePackageScopeGenerator;
+//# sourceMappingURL=change-package-scope.d.ts.map

package/dist/generators/change-package-scope/change-package-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-package-scope.d.ts","sourceRoot":"","sources":["../../../src/generators/change-package-scope/change-package-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,IAAI,EAIL,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,iCAAiC,EAAE,MAAM,UAAU,CAAC;AAiW7D,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,iCAAiC,iBAoH3C;AAED,eAAe,2BAA2B,CAAC"}

package/dist/generators/change-package-scope/change-package-scope.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * Change Package Scope Generator
+ *
+ * Changes a package's npm scope by:
+ * 1. Validating the package exists and target scope is valid
+ * 2. Parsing the package.json name to extract current scope and package name
+ * 3. 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
+ * 4. Performing Unisphere-specific cleanup:
+ *    - Updating .unisphere configuration
+ *    - Ensuring package.json name matches conventions
+ *    - Updating package-lock.json path keys
+ *    - Updating vite.config.ts cache directory paths
+ *    - Updating project.json lintFilePatterns and comments
+ *    - Updating README.md with new package name
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changePackageScopeGenerator = changePackageScopeGenerator;
+const devkit_1 = require("@nx/devkit");
+const generators_1 = require("@nx/workspace/generators");
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+/**
+ * Finds a package in .unisphere config by matching the package.json name.
+ * Extracts package information needed for scope change.
+ */
+function findPackageInUnisphere(tree, packageJsonName, experienceName) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    if (!unisphereConfig.elements?.packages) {
+        throw new Error('No packages found in .unisphere configuration.\n' +
+            'Cannot find package to change scope.');
+    }
+    // Parse the provided package.json name to get package identifier
+    const { packageName } = (0, utils_2.parsePackageJsonName)(packageJsonName, experienceName);
+    // Find the package by identifier in .unisphere
+    const packageConfig = unisphereConfig.elements.packages[packageName];
+    if (!packageConfig) {
+        throw new Error(`Package with identifier "${packageName}" not found in .unisphere configuration.\n` +
+            'Available packages: ' +
+            Object.keys(unisphereConfig.elements.packages).join(', '));
+    }
+    const sourceRoot = packageConfig.sourceRoot;
+    if (!sourceRoot) {
+        throw new Error(`Package "${packageName}" exists but has no sourceRoot configured in .unisphere`);
+    }
+    // Verify the directory exists
+    if (!tree.exists(sourceRoot)) {
+        throw new Error(`Package directory not found at ${sourceRoot}.\n` +
+            'The .unisphere configuration references a package that does not exist.');
+    }
+    // Read the package.json to verify the name matches
+    const packageJsonPath = `${sourceRoot}/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);
+    if (packageJson.name !== packageJsonName) {
+        throw new Error(`Package name mismatch!\n` +
+            `Expected: ${packageJsonName}\n` +
+            `Found in package.json: ${packageJson.name}\n` +
+            `Location: ${packageJsonPath}`);
+    }
+    const subdirectory = (0, utils_1.extractSubdirectoryFromSourceRoot)(sourceRoot);
+    const currentScope = (0, utils_2.extractScopeFromSubdirectory)(subdirectory);
+    return {
+        packageIdentifier: packageName,
+        packageJsonName,
+        currentScope,
+        sourceRoot,
+        subdirectory,
+    };
+}
+/**
+ * Validates that the target scope is different from current scope.
+ */
+function validateDifferentScope(currentScope, newScope) {
+    if (currentScope === newScope) {
+        throw new Error(`Package is already in the target scope "${newScope}".\n` +
+            'No changes needed.');
+    }
+}
+/**
+ * Validates that the target subdirectory doesn't already have a package with this identifier.
+ */
+function validateNoCollision(tree, packageIdentifier, newSubdirectory) {
+    // Check if directory exists on filesystem
+    const newPath = `unisphere/packages/${newSubdirectory}/${packageIdentifier}`;
+    if (tree.exists(newPath)) {
+        throw new Error(`Directory already exists at ${newPath}.\n` +
+            'Please choose a different scope or remove the existing directory first.');
+    }
+}
+/**
+ * Validates special package restrictions (e.g., types package scope rules).
+ */
+function validateSpecialPackageRestrictions(packageIdentifier, newScope) {
+    if (packageIdentifier === 'types') {
+        const allowedScopes = ['@unisphere', '@kaltura-corp'];
+        if (!allowedScopes.includes(newScope)) {
+            throw new Error(`The "types" package can only exist in @unisphere or @kaltura-corp scopes.\n` +
+                `You attempted to move it to ${newScope}.\n` +
+                `Allowed scopes: ${allowedScopes.join(', ')}`);
+        }
+    }
+}
+/**
+ * Update .unisphere configuration with the new sourceRoot.
+ */
+function updateUnisphereConfiguration(tree, packageIdentifier, newSourceRoot) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const oldPackageConfig = unisphereConfig.elements.packages[packageIdentifier];
+    unisphereConfig.elements.packages[packageIdentifier] = {
+        ...oldPackageConfig,
+        sourceRoot: newSourceRoot,
+    };
+    (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, oldPath, newPath) {
+    const packageLockPath = 'package-lock.json';
+    if (!tree.exists(packageLockPath)) {
+        return;
+    }
+    const packageLock = (0, devkit_1.readJson)(tree, packageLockPath);
+    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`);
+    }
+}
+/**
+ * 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, packageIdentifier) {
+    const viteConfigPath = `${newPath}/vite.config.ts`;
+    if (!tree.exists(viteConfigPath)) {
+        return;
+    }
+    let content = tree.read(viteConfigPath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    const pattern = `package-${packageIdentifier}`;
+    // The cache directory already uses the package identifier, so we just verify it's there
+    // No changes needed for scope change
+    if (content.includes(pattern)) {
+        devkit_1.logger.info(`✅ Verified vite.config.ts cache directory`);
+    }
+}
+/**
+ * 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, nxProjectName) {
+    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;
+    }
+    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, oldPackageJsonName, newPackageJsonName) {
+    const readmePath = `${newPath}/README.md`;
+    if (!tree.exists(readmePath)) {
+        return;
+    }
+    let content = tree.read(readmePath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    let updated = false;
+    // Replace old package.json name with new package.json name
+    if (content.includes(oldPackageJsonName)) {
+        content = content.replace(new RegExp(escapeRegExp(oldPackageJsonName), 'g'), newPackageJsonName);
+        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, '\\$&');
+}
+async function changePackageScopeGenerator(tree, options) {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('🔄 Starting package scope change...');
+    devkit_1.logger.info('');
+    // Validate .unisphere exists and get experience name
+    const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
+    const experienceName = unisphereConfig.name;
+    // Convert scope from schema format (without @) to internal format (with @)
+    // Schema provides: "kaltura-sdk", we need: "@kaltura-sdk"
+    const newScope = `@${options.newScope}`;
+    // Find package in .unisphere and validate it exists
+    const packageInfo = findPackageInUnisphere(tree, options.packageJsonName, experienceName);
+    devkit_1.logger.info(`📦 Package: ${packageInfo.packageIdentifier}`);
+    devkit_1.logger.info(`🏷️  Current: ${packageInfo.packageJsonName} (${packageInfo.subdirectory || 'root'}/)`);
+    // Validate target scope is different from current
+    validateDifferentScope(packageInfo.currentScope, newScope);
+    // Calculate new subdirectory and paths
+    const newSubdirectory = (0, utils_2.scopeToSubdirectory)(newScope);
+    // Validate no collision in target subdirectory
+    validateNoCollision(tree, packageInfo.packageIdentifier, newSubdirectory);
+    // Validate special package restrictions
+    validateSpecialPackageRestrictions(packageInfo.packageIdentifier, newScope);
+    // Calculate new package.json name
+    const newPackageJsonName = (0, utils_2.calculateNewPackageJsonName)(packageInfo.packageIdentifier, experienceName, newScope);
+    // Calculate new paths
+    const newPath = `unisphere/packages/${newSubdirectory}/${packageInfo.packageIdentifier}`;
+    const nxProjectName = `unisphere-package-${packageInfo.packageIdentifier}`;
+    devkit_1.logger.info(`🏷️  Target: ${newPackageJsonName} (${newSubdirectory}/)`);
+    devkit_1.logger.info(`📁 Moving: ${packageInfo.sourceRoot} → ${newPath}`);
+    devkit_1.logger.info('');
+    // Run Nx's built-in move generator
+    devkit_1.logger.info('🔧 Running Nx move generator...');
+    try {
+        await (0, generators_1.moveGenerator)(tree, {
+            projectName: nxProjectName,
+            destination: newPath,
+            newProjectName: nxProjectName,
+            importPath: newPackageJsonName,
+            updateImportPath: true,
+            skipFormat: false,
+        });
+        devkit_1.logger.info(`✅ Nx moved project and updated imports`);
+    }
+    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...');
+    // Update .unisphere configuration
+    updateUnisphereConfiguration(tree, packageInfo.packageIdentifier, newPath);
+    // Update package.json to ensure correct naming
+    updatePackageJson(tree, newPath, newPackageJsonName);
+    // Update package-lock.json
+    updatePackageLock(tree, packageInfo.sourceRoot, newPath);
+    // Update vite.config.ts
+    updateViteConfig(tree, newPath, packageInfo.packageIdentifier);
+    // Update project.json
+    updateProjectJson(tree, newPath, packageInfo.sourceRoot, nxProjectName);
+    // Update README.md
+    updateReadme(tree, newPath, packageInfo.packageJsonName, newPackageJsonName);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('✅ Package scope changed successfully!');
+    devkit_1.logger.info('');
+    devkit_1.logger.info('📋 Summary:');
+    devkit_1.logger.info(`  • Package: ${packageInfo.packageIdentifier}`);
+    devkit_1.logger.info(`  • Old scope: ${packageInfo.currentScope || 'none'}`);
+    devkit_1.logger.info(`  • New scope: ${newScope}`);
+    devkit_1.logger.info(`  • Old location: ${packageInfo.sourceRoot}`);
+    devkit_1.logger.info(`  • New location: ${newPath}`);
+    devkit_1.logger.info(`  • Old package.json name: ${packageInfo.packageJsonName}`);
+    devkit_1.logger.info(`  • New package.json name: ${newPackageJsonName}`);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('⚠️  IMPORTANT - Consumers must update:');
+    devkit_1.logger.info('  • Update all import statements from old to new package name');
+    devkit_1.logger.info('  • Update package.json dependencies if they reference this package');
+    devkit_1.logger.info('  • Run npm install to update lock file');
+    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 "Change package scope..."');
+    devkit_1.logger.info('');
+}
+exports.default = changePackageScopeGenerator;

package/dist/generators/change-package-scope/schema.d.ts

@@ -0,0 +1,4 @@
+export interface ChangePackageScopeGeneratorSchema {
+  packageJsonName: string;
+  newScope: 'unisphere' | 'kaltura-corp' | 'kaltura-sdk' | 'kaltura-apps' | 'kaltura-ui' | 'local';
+}

package/dist/generators/change-package-scope/schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "ChangePackageScope",
+  "title": "Change Package Scope Generator",
+  "type": "object",
+  "properties": {
+    "packageJsonName": {
+      "type": "string",
+      "description": "The full package.json name (e.g., @kaltura-corp/unisphere-rtc-avatar)",
+      "pattern": "^@[a-z0-9-]+/[a-z0-9-]+$",
+      "x-prompt": "What is the full package.json name? (from the package's package.json)"
+    },
+    "newScope": {
+      "type": "string",
+      "description": "The target scope for the package",
+      "enum": ["unisphere", "kaltura-corp", "kaltura-sdk", "kaltura-apps", "kaltura-ui", "local"],
+      "x-prompt": "What scope should the package move to?"
+    }
+  },
+  "required": [
+    "packageJsonName",
+    "newScope"
+  ]
+}

package/dist/generators/change-package-scope/utils.d.ts

@@ -0,0 +1,38 @@
+export interface ParsedPackageName {
+    scope: string;
+    packageName: string;
+}
+/**
+ * Parses a full package.json name to extract scope and package name.
+ * Handles the unisphere- prefix rules and tolerates incorrect prefixes.
+ *
+ * @param packageJsonName - Full package name (e.g., "@kaltura-corp/unisphere-rtc-avatar")
+ * @param experienceName - Experience name from .unisphere config (e.g., "rtc")
+ * @returns Parsed scope and package name
+ */
+export declare function parsePackageJsonName(packageJsonName: string, experienceName: string): ParsedPackageName;
+/**
+ * Calculates the new package.json name based on target scope and package name.
+ * Automatically handles unisphere- prefix rules.
+ *
+ * @param packageName - Package identifier (e.g., "avatar", "models")
+ * @param experienceName - Experience name from .unisphere config (e.g., "rtc")
+ * @param newScope - Target scope (e.g., "@kaltura-corp", "@unisphere")
+ * @returns New package.json name
+ */
+export declare function calculateNewPackageJsonName(packageName: string, experienceName: string, newScope: string): string;
+/**
+ * Extracts the scope from a subdirectory name.
+ *
+ * @param subdirectory - Subdirectory name (e.g., "kaltura-corp") or null for flat structure
+ * @returns Scope (e.g., "@kaltura-corp") or null
+ */
+export declare function extractScopeFromSubdirectory(subdirectory: string | null): string | null;
+/**
+ * Converts a scope to a subdirectory name.
+ *
+ * @param scope - Scope (e.g., "@kaltura-corp")
+ * @returns Subdirectory name (e.g., "kaltura-corp")
+ */
+export declare function scopeToSubdirectory(scope: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/generators/change-package-scope/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/generators/change-package-scope/utils.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,iBAAiB,CAkDnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACf,MAAM,CAiCR;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAKvF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWzD"}

package/dist/generators/change-package-scope/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePackageJsonName = parsePackageJsonName;
+exports.calculateNewPackageJsonName = calculateNewPackageJsonName;
+exports.extractScopeFromSubdirectory = extractScopeFromSubdirectory;
+exports.scopeToSubdirectory = scopeToSubdirectory;
+/**
+ * Parses a full package.json name to extract scope and package name.
+ * Handles the unisphere- prefix rules and tolerates incorrect prefixes.
+ *
+ * @param packageJsonName - Full package name (e.g., "@kaltura-corp/unisphere-rtc-avatar")
+ * @param experienceName - Experience name from .unisphere config (e.g., "rtc")
+ * @returns Parsed scope and package name
+ */
+function parsePackageJsonName(packageJsonName, experienceName) {
+    if (!packageJsonName?.trim()) {
+        throw new Error('packageJsonName cannot be empty');
+    }
+    if (!experienceName?.trim()) {
+        throw new Error('experienceName cannot be empty');
+    }
+    // Validate format: must start with @scope/
+    const scopeMatch = packageJsonName.match(/^(@[^/]+)\//);
+    if (!scopeMatch) {
+        throw new Error(`Invalid package.json name format: "${packageJsonName}"\n` +
+            'Expected format: @scope/package-name');
+    }
+    const scope = scopeMatch[1];
+    let nameAfterScope = packageJsonName.substring(scope.length + 1); // +1 for the '/'
+    // Remove unisphere- prefix if present (handle incorrect usage)
+    if (nameAfterScope.startsWith('unisphere-')) {
+        nameAfterScope = nameAfterScope.substring('unisphere-'.length);
+    }
+    // Remove experience prefix
+    if (nameAfterScope === experienceName) {
+        // Special case: package name is same as experience (e.g., "@unisphere/rtc")
+        return { scope, packageName: experienceName };
+    }
+    const expectedPrefix = `${experienceName}-`;
+    if (!nameAfterScope.startsWith(expectedPrefix)) {
+        throw new Error(`Package name "${packageJsonName}" does not follow expected format.\n` +
+            `Expected: ${scope}/${expectedPrefix}package-name or ${scope}/${experienceName}\n` +
+            `Found: ${packageJsonName}`);
+    }
+    const packageName = nameAfterScope.substring(expectedPrefix.length);
+    if (!packageName) {
+        throw new Error(`Package name "${packageJsonName}" results in empty package name.\n` +
+            `Expected: ${scope}/${expectedPrefix}<package-name>`);
+    }
+    return { scope, packageName };
+}
+/**
+ * Calculates the new package.json name based on target scope and package name.
+ * Automatically handles unisphere- prefix rules.
+ *
+ * @param packageName - Package identifier (e.g., "avatar", "models")
+ * @param experienceName - Experience name from .unisphere config (e.g., "rtc")
+ * @param newScope - Target scope (e.g., "@kaltura-corp", "@unisphere")
+ * @returns New package.json name
+ */
+function calculateNewPackageJsonName(packageName, experienceName, newScope) {
+    if (!packageName?.trim()) {
+        throw new Error('packageName cannot be empty');
+    }
+    if (!experienceName?.trim()) {
+        throw new Error('experienceName cannot be empty');
+    }
+    if (!newScope?.trim()) {
+        throw new Error('newScope cannot be empty');
+    }
+    if (!newScope.startsWith('@')) {
+        throw new Error(`Invalid scope format: "${newScope}"\n` +
+            'Expected format: @scope (e.g., @unisphere, @kaltura-corp)');
+    }
+    // Special case: package name equals experience name
+    if (packageName === experienceName) {
+        if (newScope === '@kaltura-corp') {
+            return `@kaltura-corp/unisphere-${experienceName}`;
+        }
+        return `${newScope}/${experienceName}`;
+    }
+    // Regular case: experience-package
+    const baseName = `${experienceName}-${packageName}`;
+    if (newScope === '@kaltura-corp') {
+        return `@kaltura-corp/unisphere-${baseName}`;
+    }
+    return `${newScope}/${baseName}`;
+}
+/**
+ * Extracts the scope from a subdirectory name.
+ *
+ * @param subdirectory - Subdirectory name (e.g., "kaltura-corp") or null for flat structure
+ * @returns Scope (e.g., "@kaltura-corp") or null
+ */
+function extractScopeFromSubdirectory(subdirectory) {
+    if (!subdirectory?.trim()) {
+        return null;
+    }
+    return `@${subdirectory}`;
+}
+/**
+ * Converts a scope to a subdirectory name.
+ *
+ * @param scope - Scope (e.g., "@kaltura-corp")
+ * @returns Subdirectory name (e.g., "kaltura-corp")
+ */
+function scopeToSubdirectory(scope) {
+    if (!scope?.trim()) {
+        throw new Error('scope cannot be empty');
+    }
+    if (!scope.startsWith('@')) {
+        throw new Error(`Invalid scope format: "${scope}"\n` +
+            'Expected format: @scope (e.g., @unisphere, @kaltura-corp)');
+    }
+    return scope.substring(1);
+}

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

@@ -1 +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;AAoQjD,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,iBAqF/B;AAED,eAAe,eAAe,CAAC"}
+{"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;AAiRjD,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,iBAqF/B;AAED,eAAe,eAAe,CAAC"}

package/dist/generators/remove/remove.js

@@ -193,10 +193,20 @@ function removeFromPackageLock(tree, sourceRoot) {
     const packageLock = (0, devkit_1.readJson)(tree, packageLockPath);
     let updated = false;
     if (packageLock.packages) {
+        // Remove the source entry
         if (packageLock.packages[sourceRoot]) {
             delete packageLock.packages[sourceRoot];
             updated = true;
         }
+        // Remove the node_modules symlink entry that points to this sourceRoot
+        for (const key of Object.keys(packageLock.packages)) {
+            if (key.startsWith('node_modules/') &&
+                packageLock.packages[key].resolved === sourceRoot &&
+                packageLock.packages[key].link === true) {
+                delete packageLock.packages[key];
+                updated = true;
+            }
+        }
     }
     if (updated) {
         (0, devkit_1.writeJson)(tree, packageLockPath, packageLock);

package/generators.json

@@ -30,6 +30,11 @@
       "schema": "./dist/generators/rename-package/schema.json",
       "description": "Rename a unisphere package and update all references"
     },
+    "change-package-scope": {
+      "factory": "./dist/generators/change-package-scope/change-package-scope",
+      "schema": "./dist/generators/change-package-scope/schema.json",
+      "description": "Change a package's npm scope by moving it between subdirectories"
+    },
     "remove": {
       "factory": "./dist/generators/remove/remove",
       "schema": "./dist/generators/remove/schema.json",

package/package.json

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