@unisphere/nx 1.1.4 → 1.2.0

package/dist/migrations/update-1-1-5/_update-languages.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const add_package_1 = require("../../generators/add-package/add-package");
+const ts_morph_1 = require("ts-morph");
+function hasDep(pkg, name) {
+    return !!(pkg.dependencies?.[name] || pkg.devDependencies?.[name] || pkg.peerDependencies?.[name]);
+}
+async function update(tree) {
+    devkit_1.logger.info('🔄 Updating languages to @unisphere/ui-i18n-react...');
+    if (!tree.exists('package.json')) {
+        devkit_1.logger.warn('package.json not found, skipping.');
+        return;
+    }
+    const pkg = (0, devkit_1.readJson)(tree, 'package.json');
+    const usesI18next = hasDep(pkg, 'i18next') || hasDep(pkg, 'react-i18next');
+    // Detect local usage of useTranslation from ui-kit-react (custom hook)
+    let usesUiKitUseTranslation = false;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (p) => {
+        if (!p.endsWith('.ts') && !p.endsWith('.tsx'))
+            return;
+        const content = tree.read(p, 'utf-8');
+        if (content && content.includes("from 'ui-kit-react/use-translation'")) {
+            usesUiKitUseTranslation = true;
+        }
+    });
+    if (usesI18next && usesUiKitUseTranslation) {
+        throw new Error('❌ Found both i18next and ui-kit-react/use-translation. Please remove one before migrating.');
+    }
+    if (!usesI18next) {
+        devkit_1.logger.info('ℹ️ i18next not detected. Skipping migration.');
+        return;
+    }
+    // Remove i18next packages
+    ['i18next', 'react-i18next', 'i18next-browser-languagedetector', 'i18next-http-backend']
+        .forEach((dep) => {
+        if (pkg.dependencies?.[dep])
+            delete pkg.dependencies[dep];
+        if (pkg.devDependencies?.[dep])
+            delete pkg.devDependencies[dep];
+        if (pkg.peerDependencies?.[dep])
+            delete pkg.peerDependencies[dep];
+    });
+    // Add @unisphere/ui-i18n-react
+    pkg.dependencies = pkg.dependencies || {};
+    pkg.dependencies['@unisphere/ui-i18n-react'] = 'latest';
+    (0, devkit_1.writeJson)(tree, 'package.json', pkg);
+    // A
+    // Ensure ui-kit-react package exists with same distribution channel as core
+    try {
+        const coreConfigPath = 'unisphere/packages/core/project.json';
+        let distributionChannel = 'github';
+        // Todo get drim unisphere file
+        if (tree.exists(coreConfigPath)) {
+            const coreProjectJson = (0, devkit_1.readJson)(tree, coreConfigPath);
+            distributionChannel = coreProjectJson?.targets?.publish?.options?.distributionChannel || 'github';
+        }
+        if (!tree.exists('unisphere/packages/ui-kit-react')) {
+            await (0, add_package_1.addPackageGenerator)(tree, { packageName: 'ui-kit-react', scope: distributionChannel === 'npm' ? 'public' : distributionChannel === 'none' ? 'none' : 'internal' });
+        }
+    }
+    catch (e) {
+        devkit_1.logger.warn(`Could not auto-create ui-kit-react package: ${e}`);
+    }
+    // Create use-translation.ts in ui-kit-react
+    const useTranslationPath = 'unisphere/packages/ui-kit-react/src/lib/use-translation.ts';
+    if (!tree.exists(useTranslationPath)) {
+        const content = `import en from '../languages/en-US.json';
+import { createUseTranslation } from '@unisphere/ui-i18n-react';
+
+export const useTranslation = createUseTranslation({
+  packageName: '@kaltura/unisphere-media-manager',
+  defaultTranslations: en as any,
+  supportedLanguages: [
+    'de-DE', 'es-ES', 'fi-FI', 'fr-CA', 'fr-FR',
+    'he-IL', 'it-IT', 'ja-JP', 'ko-KR', 'nl-NL',
+    'pt-BR', 'ru-RU', 'zh-CN', 'zh-TW'
+  ]
+});
+`;
+        tree.write(useTranslationPath, content);
+    }
+    // Update imports: react-i18next -> ui-kit-react/use-translation
+    const project = new ts_morph_1.Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        if (!content.includes("from 'react-i18next'") && !content.includes("from \"react-i18next\""))
+            return;
+        const sf = project.createSourceFile(filePath, content, { overwrite: true });
+        let changed = false;
+        sf.getImportDeclarations().forEach((imp) => {
+            const spec = imp.getModuleSpecifierValue();
+            if (spec === 'react-i18next') {
+                const named = imp.getNamedImports().map((n) => n.getName());
+                if (named.includes('useTranslation')) {
+                    imp.remove();
+                    sf.addImportDeclaration({
+                        moduleSpecifier: 'ui-kit-react/use-translation',
+                        namedImports: [{ name: 'useTranslation' }],
+                    });
+                    changed = true;
+                }
+            }
+        });
+        // Remove i18next providers usage patterns (simple pass to remove I18nextProvider/Translation)
+        let text = sf.getFullText();
+        text = text.replace(/<I18nextProvider[\s\S]*?>/g, '');
+        text = text.replace(/<\/I18nextProvider>/g, '');
+        text = text.replace(/<Suspense[\s\S]*?>/g, '<>');
+        text = text.replace(/<\/Suspense>/g, '</>');
+        if (changed || text !== sf.getFullText()) {
+            tree.write(filePath, text);
+        }
+    });
+    // Ensure languages path exists relative to kit and create langs-export.yml
+    const langsYaml = 'unisphere/packages/ui-kit-react/langs-export.yml';
+    if (!tree.exists(langsYaml)) {
+        tree.write(langsYaml, `package: ui-kit-react\nexport:\n  - path: src/lib/languages\n    pattern: '**/*.json'\n`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.warn('═══════════════════════════════════════════════════════════════');
+    devkit_1.logger.warn('✅ Language migration prepared.');
+    devkit_1.logger.warn('Next: npm install && verify app compiles.');
+    devkit_1.logger.warn('═══════════════════════════════════════════════════════════════');
+}

package/dist/migrations/update-1-1-5/check-nx-version.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function checkNxVersion(tree: Tree): void;
+//# sourceMappingURL=check-nx-version.d.ts.map

package/dist/migrations/update-1-1-5/check-nx-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-nx-version.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/check-nx-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,YAAY,CAAC;AAEpD,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAsBvD"}

package/dist/migrations/update-1-1-5/check-nx-version.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkNxVersion;
+const devkit_1 = require("@nx/devkit");
+function checkNxVersion(tree) {
+    devkit_1.logger.info('🔍 Checking Nx version compatibility...');
+    const pkg = (0, devkit_1.readJson)(tree, 'package.json');
+    const nxVersion = pkg.devDependencies?.nx || pkg.dependencies?.nx;
+    if (!nxVersion) {
+        devkit_1.logger.error('❌ No Nx version found in package.json');
+        throw new Error('No Nx version found in package.json. Please install Nx first.');
+    }
+    const majorVersion = parseInt(nxVersion.match(/\d+/)?.[0] ?? '0');
+    if (majorVersion < 22) {
+        const errorMessage = `❌ This migration requires Nx 22 or higher. Current version: ${nxVersion}\n\nPlease upgrade Nx first by running:\n  npx nx migrate nx@22\n  npm install\n  npx nx migrate --run-migrations`;
+        devkit_1.logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+    devkit_1.logger.info(`✅ Nx version check passed (version: ${nxVersion})`);
+}

package/dist/migrations/update-1-1-5/fix-dependency-versions.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=fix-dependency-versions.d.ts.map

package/dist/migrations/update-1-1-5/fix-dependency-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-dependency-versions.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/fix-dependency-versions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAuB,MAAM,YAAY,CAAC;AAEvD,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA8E9D"}

package/dist/migrations/update-1-1-5/fix-dependency-versions.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    devkit_1.logger.info('🔄 Fixing @changesets/cli version in root package.json...');
+    let filesUpdated = 0;
+    const targetPackage = '@changesets/cli';
+    const updatePackageJson = (filePath) => {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        try {
+            const packageJson = JSON.parse(content);
+            let modified = false;
+            // Process dependencies
+            if (packageJson.dependencies && packageJson.dependencies[targetPackage]) {
+                const version = packageJson.dependencies[targetPackage];
+                if (typeof version === 'string' && version.startsWith('^')) {
+                    packageJson.dependencies[targetPackage] = version.substring(1);
+                    modified = true;
+                    devkit_1.logger.info(`  └─ ${targetPackage}: ${version} → ${packageJson.dependencies[targetPackage]}`);
+                }
+            }
+            // Process devDependencies
+            if (packageJson.devDependencies && packageJson.devDependencies[targetPackage]) {
+                const version = packageJson.devDependencies[targetPackage];
+                if (typeof version === 'string' && version.startsWith('^')) {
+                    packageJson.devDependencies[targetPackage] = version.substring(1);
+                    modified = true;
+                    devkit_1.logger.info(`  └─ ${targetPackage}: ${version} → ${packageJson.devDependencies[targetPackage]}`);
+                }
+            }
+            // Process peerDependencies
+            if (packageJson.peerDependencies && packageJson.peerDependencies[targetPackage]) {
+                const version = packageJson.peerDependencies[targetPackage];
+                if (typeof version === 'string' && version.startsWith('^')) {
+                    packageJson.peerDependencies[targetPackage] = version.substring(1);
+                    modified = true;
+                    devkit_1.logger.info(`  └─ ${targetPackage}: ${version} → ${packageJson.peerDependencies[targetPackage]}`);
+                }
+            }
+            // Process optionalDependencies
+            if (packageJson.optionalDependencies && packageJson.optionalDependencies[targetPackage]) {
+                const version = packageJson.optionalDependencies[targetPackage];
+                if (typeof version === 'string' && version.startsWith('^')) {
+                    packageJson.optionalDependencies[targetPackage] = version.substring(1);
+                    modified = true;
+                    devkit_1.logger.info(`  └─ ${targetPackage}: ${version} → ${packageJson.optionalDependencies[targetPackage]}`);
+                }
+            }
+            if (modified) {
+                tree.write(filePath, JSON.stringify(packageJson, null, 2) + '\n');
+                filesUpdated++;
+                devkit_1.logger.info(`✅ Updated ${filePath}`);
+            }
+        }
+        catch (error) {
+            devkit_1.logger.warn(`⚠️ Failed to parse ${filePath}: ${error}`);
+        }
+    };
+    // Update root package.json only
+    if (tree.exists('package.json')) {
+        updatePackageJson('package.json');
+    }
+    else {
+        devkit_1.logger.warn('⚠️ No package.json found in root directory.');
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    if (filesUpdated === 0) {
+        devkit_1.logger.info('ℹ️ No changes needed in package.json.');
+    }
+    else {
+        devkit_1.logger.info(`✅ Fixed dependency versions in package.json.`);
+    }
+}

package/dist/migrations/update-1-1-5/fix-playground-apps.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=fix-playground-apps.d.ts.map

package/dist/migrations/update-1-1-5/fix-playground-apps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-playground-apps.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/fix-playground-apps.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,IAAI,EAIL,MAAM,YAAY,CAAC;AAGpB,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,iBAqG9C"}

package/dist/migrations/update-1-1-5/fix-playground-apps.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const ts_morph_1 = require("ts-morph");
+async function update(tree) {
+    devkit_1.logger.info('🔄 Starting fix playground apps migration...');
+    let filesUpdated = 0;
+    // Create a ts-morph project
+    const project = new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+    });
+    // Find and fix settings-buttons.tsx, configuration-provider.tsx, and playground-configuration-provider.tsx files
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (filePath.endsWith('settings-buttons.tsx') ||
+            filePath.endsWith('configuration-provider.tsx') ||
+            filePath.endsWith('playground-configuration-provider.tsx')) {
+            const content = tree.read(filePath, 'utf-8');
+            if (content) {
+                let hasChanges = false;
+                // Check if the file contains patterns we need to fix
+                const buttonsContainerPattern = /export const ButtonsContainer: React\.FC<{\s*children\?\: React\.ReactChild;\s*}>/;
+                const configProviderPattern = /const getPlaygroundConfigurationFromLocalStorage = \(\s*configurationKey: string\s*\)(?!\s*:)/;
+                const configProviderWithTypePattern = /const getPlaygroundConfigurationFromLocalStorage = \(\s*configurationKey: string\s*\):\s*PlaygroundConfiguration(?!\s*\|)/;
+                if (buttonsContainerPattern.test(content) || configProviderPattern.test(content) || configProviderWithTypePattern.test(content)) {
+                    // Create a source file from the content
+                    const sourceFile = project.createSourceFile(filePath, content, { overwrite: true });
+                    // Replace patterns using regex
+                    let updatedContent = content;
+                    // Fix ButtonsContainer type definition
+                    if (buttonsContainerPattern.test(content)) {
+                        updatedContent = updatedContent.replace(/export const ButtonsContainer: React\.FC<{\s*children\?\: React\.ReactChild;\s*}>/, 'export const ButtonsContainer: React.FC<PropsWithChildren>');
+                    }
+                    // Fix getPlaygroundConfigurationFromLocalStorage return type (no return type)
+                    if (configProviderPattern.test(content)) {
+                        updatedContent = updatedContent.replace(/const getPlaygroundConfigurationFromLocalStorage = \(\s*configurationKey: string\s*\)(?!\s*:)/, 'const getPlaygroundConfigurationFromLocalStorage = (\n  configurationKey: string\n): PlaygroundConfiguration | null');
+                    }
+                    // Fix getPlaygroundConfigurationFromLocalStorage return type (PlaygroundConfiguration -> PlaygroundConfiguration | null)
+                    if (configProviderWithTypePattern.test(content)) {
+                        updatedContent = updatedContent.replace(/const getPlaygroundConfigurationFromLocalStorage = \(\s*configurationKey: string\s*\):\s*PlaygroundConfiguration(?!\s*\|)/, 'const getPlaygroundConfigurationFromLocalStorage = (\n  configurationKey: string\n): PlaygroundConfiguration | null');
+                    }
+                    // Update the source file with the new content
+                    sourceFile.replaceWithText(updatedContent);
+                    // Handle imports with ts-morph (only for settings-buttons.tsx)
+                    if (filePath.endsWith('settings-buttons.tsx') && buttonsContainerPattern.test(content)) {
+                        const reactImport = sourceFile.getImportDeclaration('react');
+                        if (reactImport) {
+                            // Check if PropsWithChildren is already imported
+                            const namedImports = reactImport.getNamedImports();
+                            const hasPropsWithChildren = namedImports.some(imp => imp.getName() === 'PropsWithChildren');
+                            if (!hasPropsWithChildren) {
+                                // Add PropsWithChildren to the existing React import
+                                reactImport.addNamedImport('PropsWithChildren');
+                                hasChanges = true;
+                            }
+                        }
+                        else {
+                            // If no React import exists, create one
+                            sourceFile.addImportDeclaration({
+                                defaultImport: 'React',
+                                namedImports: ['PropsWithChildren'],
+                                moduleSpecifier: 'react'
+                            });
+                            hasChanges = true;
+                        }
+                    }
+                    // Check if any changes were made
+                    if (updatedContent !== content || hasChanges) {
+                        // Write the updated content back to the tree
+                        const finalContent = sourceFile.getFullText();
+                        tree.write(filePath, finalContent);
+                        filesUpdated++;
+                        devkit_1.logger.info(`✅ Updated ${filePath}`);
+                    }
+                }
+            }
+        }
+    });
+    if (filesUpdated > 0) {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ Fix playground apps migration completed. Updated ${filesUpdated} files.`);
+    }
+    else {
+        devkit_1.logger.info('ℹ️ No playground files found to migrate.');
+    }
+}

package/dist/migrations/update-1-1-5/move-runtime-info-to-core.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void | string[]>;
+//# sourceMappingURL=move-runtime-info-to-core.d.ts.map

package/dist/migrations/update-1-1-5/move-runtime-info-to-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-runtime-info-to-core.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/move-runtime-info-to-core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAIL,MAAM,YAAY,CAAC;AAiEpB,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,MAAM,EAAE,CAAC,CA+MzE"}

package/dist/migrations/update-1-1-5/move-runtime-info-to-core.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+// Ensure these are installed in your project: npm install ts-morph --save-dev
+const ts_morph_1 = require("ts-morph");
+const utils_1 = require("../../generators/utils");
+/**
+ * Finds runtimes that have both runtime-information.ts and runtime-settings.ts files
+ * in their src/ or src/lib/ directory.
+ * @param tree The file system tree.
+ * @returns An array of RuntimeInfo objects.
+ */
+function findRuntimesWithInformationAndSettingsFiles(tree) {
+    const runtimes = new Map();
+    const runtimesDir = 'unisphere/runtimes';
+    // Only traverse the runtimes directory
+    (0, devkit_1.visitNotIgnoredFiles)(tree, runtimesDir, (filePath) => {
+        // Look for runtime-information.ts or runtime-settings.ts files in src/ or src/lib/
+        const runtimeMatch = filePath.match(/unisphere\/runtimes\/([^\/]+)\/src(?:\/lib)?\/(runtime-information|runtime-settings)\.ts$/);
+        if (runtimeMatch) {
+            const runtimeName = runtimeMatch[1];
+            const fileType = runtimeMatch[2];
+            if (!runtimes.has(runtimeName)) {
+                runtimes.set(runtimeName, {
+                    name: runtimeName,
+                    path: `unisphere/runtimes/${runtimeName}`,
+                    hasInformation: false,
+                    hasSettings: false,
+                });
+            }
+            const runtime = runtimes.get(runtimeName);
+            if (fileType === 'runtime-information') {
+                runtime.hasInformation = true;
+                runtime.informationPath = filePath;
+            }
+            else if (fileType === 'runtime-settings') {
+                runtime.hasSettings = true;
+                runtime.settingsPath = filePath;
+            }
+        }
+    });
+    let res = Array.from(runtimes.values()).filter((r) => r.hasInformation && r.hasSettings);
+    return res;
+}
+// ------------------------------------------------------------
+async function update(tree) {
+    devkit_1.logger.info('🔄 Starting runtime info migration to core...');
+    const runtimes = findRuntimesWithInformationAndSettingsFiles(tree);
+    if (runtimes.length === 0) {
+        devkit_1.logger.info('ℹ️ No runtimes found with local runtime-information.ts or runtime-settings.ts files.');
+        return;
+    }
+    devkit_1.logger.info(`📦 Found ${runtimes.length} runtime(s) to migrate`);
+    let migratedCount = 0;
+    // Initialize the ts-morph Project once
+    const project = new ts_morph_1.Project({
+        manipulationSettings: {
+            quoteKind: ts_morph_1.QuoteKind.Single,
+        },
+    });
+    for (const runtime of runtimes) {
+        devkit_1.logger.info(`\n🔄 Migrating runtime: ${runtime.name}`);
+        const nameTransforms = (0, utils_1.createNameTransforms)(runtime.name, 'runtimeName');
+        const pascalName = nameTransforms['runtimeName__pascalCase'];
+        const dashName = nameTransforms['runtimeName__lowerDashCase'];
+        const camelName = nameTransforms['runtimeName__camelCase'];
+        const corePath = `unisphere/packages/core/src/lib/${runtime.name}-runtime`;
+        const runtimeTypesPath = `${corePath}/runtime-types.ts`;
+        const indexPath = `${corePath}/index.ts`;
+        // 1. Create core runtime-types.ts file
+        let settingsContentRaw = runtime.settingsPath && tree.exists(runtime.settingsPath)
+            ? tree.read(runtime.settingsPath, 'utf-8') || ''
+            : '';
+        if (settingsContentRaw) {
+            // Rename types in the content to be globally unique
+            settingsContentRaw = settingsContentRaw.replace(/\bRuntimeSettings\b/g, `${pascalName}RuntimeSettings`);
+            settingsContentRaw = settingsContentRaw.replace(/\bruntimeSettingsSchema\b/g, `${camelName}RuntimeSettingsSchema`);
+        }
+        // Export the new RuntimeName
+        const runtimeTypesContent = `${settingsContentRaw}\n\nexport const ${pascalName}RuntimeName = '${dashName}' as const;`;
+        tree.write(runtimeTypesPath, runtimeTypesContent);
+        tree.write(indexPath, `export * from './runtime-types';\n`);
+        devkit_1.logger.info(`  ✅ Created runtime types in ${corePath}`);
+        // 2. Update core index.ts to export the new runtime types
+        const coreIndexPath = 'unisphere/packages/core/src/index.ts';
+        if (tree.exists(coreIndexPath)) {
+            const coreIndexContent = tree.read(coreIndexPath, 'utf-8') || '';
+            const exportLine = `export * from './lib/${runtime.name}-runtime';`;
+            if (!coreIndexContent.includes(exportLine)) {
+                const updatedCoreIndex = coreIndexContent.trimEnd() + '\n' + exportLine + '\n';
+                tree.write(coreIndexPath, updatedCoreIndex);
+                devkit_1.logger.info(`  🔗 Updated core index exports`);
+            }
+        }
+        else {
+            devkit_1.logger.error(`  ⚠️ Core index.ts not found at ${coreIndexPath}`);
+        }
+        // 3. Update runtime.tsx to import from core alias and rename usages (using ts-morph)
+        const runtimeTsxPath = `${runtime.path}/src/lib/runtime.tsx`;
+        if (tree.exists(runtimeTsxPath)) {
+            try {
+                const coreAlias = (0, utils_1.findCorePackageAlias)(tree);
+                const runtimeTsxContent = tree.read(runtimeTsxPath, 'utf-8') || '';
+                // Create a temporary in-memory SourceFile for ts-morph to parse and modify
+                const sourceFile = project.createSourceFile(runtimeTsxPath, runtimeTsxContent, { overwrite: true });
+                // Define the new, standardized names
+                const newWidgetName = `WidgetName`;
+                const newRuntimeName = `${pascalName}RuntimeName`;
+                // Define all named imports we are responsible for consolidating/adding
+                const newNamedImports = [
+                    `${pascalName}RuntimeSettings`,
+                    `${camelName}RuntimeSettingsSchema`,
+                    newRuntimeName,
+                    newWidgetName,
+                ];
+                // --- A. Remove old local imports ---
+                const localImportSpecifiers = [
+                    './runtime-information',
+                    './runtime-settings',
+                    '../runtime-information',
+                    '../runtime-settings',
+                ];
+                sourceFile.getImportDeclarations().forEach(importDeclaration => {
+                    const moduleSpecifier = importDeclaration.getModuleSpecifierValue().replace(/\.ts$/, '');
+                    if (localImportSpecifiers.includes(moduleSpecifier)) {
+                        importDeclaration.remove();
+                    }
+                });
+                // --- B. Rename usages of old identifiers to new, unique names ---
+                const identifierRenames = new Map([
+                    // Base types/schemas 
+                    ['RuntimeSettings', `${pascalName}RuntimeSettings`],
+                    ['runtimeSettingsSchema', `${camelName}RuntimeSettingsSchema`],
+                    // Constants (Original -> New Core Name)
+                    ['unisphereWidgetName', newWidgetName],
+                    ['unisphereRuntimeName', newRuntimeName],
+                ]);
+                // This loop performs the renaming in the file
+                sourceFile.forEachDescendant(node => {
+                    if (node.isKind(ts_morph_1.SyntaxKind.Identifier)) {
+                        const nodeText = node.getText();
+                        const newText = identifierRenames.get(nodeText);
+                        if (newText) {
+                            node.replaceWithText(newText);
+                        }
+                    }
+                });
+                // --- C. Add new core imports (SAFELY) ---
+                let coreImportDeclaration = sourceFile.getImportDeclaration((decl) => decl.getModuleSpecifierValue() === coreAlias);
+                // 1. Remove ONLY the specific named imports we are consolidating from any existing core imports
+                sourceFile.getImportDeclarations().forEach(importDeclaration => {
+                    const specifier = importDeclaration.getModuleSpecifierValue();
+                    // If it's the root core alias, remove only the named imports that we will re-add.
+                    if (specifier === coreAlias) {
+                        importDeclaration.getNamedImports().forEach(namedImport => {
+                            const importName = namedImport.getName();
+                            if (newNamedImports.includes(importName)) {
+                                namedImport.remove();
+                            }
+                        });
+                        // If the declaration is now empty, remove it completely.
+                        if (importDeclaration.getNamedImports().length === 0 && !importDeclaration.getDefaultImport()) {
+                            importDeclaration.remove();
+                        }
+                    }
+                });
+                // 2. Add the new combined import for runtime types and names
+                // If the core import line was removed, we need to recreate it.
+                coreImportDeclaration = sourceFile.getImportDeclaration((decl) => decl.getModuleSpecifierValue() === coreAlias);
+                if (!coreImportDeclaration) {
+                    // If it doesn't exist (i.e., was just deleted or never existed), add a new one.
+                    sourceFile.addImportDeclaration({
+                        moduleSpecifier: `${coreAlias}`,
+                        namedImports: newNamedImports,
+                    });
+                }
+                else {
+                    // If it still exists (meaning it had other imports), just add the new ones to the existing declaration.
+                    coreImportDeclaration.addNamedImports(newNamedImports);
+                }
+                // --- D. Write content back to the Tree ---
+                // Ensure the tree.write gets the updated text after all replacements
+                tree.write(runtimeTsxPath, sourceFile.getFullText());
+                devkit_1.logger.info(`  🔁 Updated imports, runtime, and widget usages using ts-morph in ${runtimeTsxPath}`);
+            }
+            catch (error) {
+                devkit_1.logger.error(`  ❌ Failed to update ${runtimeTsxPath} with ts-morph: ${error}`);
+            }
+        }
+        else {
+            devkit_1.logger.warn(`  ⚠️ Runtime file not found at ${runtimeTsxPath}`);
+        }
+        // 4. Delete old files
+        if (runtime.informationPath && tree.exists(runtime.informationPath)) {
+            tree.delete(runtime.informationPath);
+            devkit_1.logger.info(`  🗑️ Deleted ${runtime.informationPath}`);
+        }
+        if (runtime.settingsPath && tree.exists(runtime.settingsPath)) {
+            tree.delete(runtime.settingsPath);
+            devkit_1.logger.info(`  🗑️ Deleted ${runtime.settingsPath}`);
+        }
+        migratedCount++;
+        devkit_1.logger.info(`  ✅ Successfully migrated ${runtime.name}`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.info('');
+    devkit_1.logger.warn('═══════════════════════════════════════════════════════════════');
+    devkit_1.logger.warn(`✅ Migrated ${migratedCount} runtime(s) to use core package!`);
+    devkit_1.logger.warn('═══════════════════════════════════════════════════════════════');
+    devkit_1.logger.warn('');
+    devkit_1.logger.warn('⚠️ Summary of changes:');
+    devkit_1.logger.warn('  • Runtime settings/information types were moved to core and renamed.');
+    devkit_1.logger.warn('  • **unisphereWidgetName was renamed to WidgetName, imported from core, and usages were fixed.**');
+    devkit_1.logger.warn('');
+    devkit_1.logger.warn('═══════════════════════════════════════════════════════════════');
+}

package/dist/migrations/update-1-1-5/rename-widgetname-to-widgetname.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=rename-widgetname-to-widgetname.d.ts.map

package/dist/migrations/update-1-1-5/rename-widgetname-to-widgetname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-widgetname-to-widgetname.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/rename-widgetname-to-widgetname.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAIL,MAAM,YAAY,CAAC;AAEpB,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,iBAwC9C"}

package/dist/migrations/update-1-1-5/rename-widgetname-to-widgetname.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    devkit_1.logger.info('🔄 Starting WidgetName to widgetName migration...');
+    let filesUpdated = 0;
+    // Update TypeScript and TSX files in the workspace
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        // Only process TypeScript and TSX files in unisphere directories
+        if ((!filePath.endsWith('.ts') && !filePath.endsWith('.tsx')) ||
+            !filePath.includes('unisphere/')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        let hasChanges = false;
+        let updatedContent = content;
+        // Simple global replacement: WidgetName -> widgetName
+        if (content.includes('WidgetName')) {
+            updatedContent = updatedContent.replace(/WidgetName/g, 'widgetName');
+            hasChanges = true;
+        }
+        if (hasChanges) {
+            tree.write(filePath, updatedContent);
+            filesUpdated++;
+            devkit_1.logger.info(`✅ Updated WidgetName references in ${filePath}`);
+        }
+    });
+    if (filesUpdated > 0) {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ WidgetName to widgetName migration completed. Updated ${filesUpdated} files.`);
+    }
+    else {
+        devkit_1.logger.info('ℹ️ No WidgetName references found to migrate.');
+    }
+}

package/dist/migrations/update-1-1-5/sync-package-json-files.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void | string[]>;
+//# sourceMappingURL=sync-package-json-files.d.ts.map

package/dist/migrations/update-1-1-5/sync-package-json-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-package-json-files.d.ts","sourceRoot":"","sources":["../../../src/migrations/update-1-1-5/sync-package-json-files.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,IAAI,EAIL,MAAM,YAAY,CAAC;AAEtB,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,MAAM,EAAE,CAAC,CAsEzE"}