@unisphere/nx 1.22.8 → 2.1.0

package/dist/migrations/2-0-0/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/2-0-0/patches/@nx+rollup+22.1.3.patch

@@ -0,0 +1,27 @@
+diff --git a/node_modules/@nx/rollup/src/plugins/with-nx/with-nx.js b/node_modules/@nx/rollup/src/plugins/with-nx/with-nx.js
+index 1135bba..4762053 100644
+--- a/node_modules/@nx/rollup/src/plugins/with-nx/with-nx.js
++++ b/node_modules/@nx/rollup/src/plugins/with-nx/with-nx.js
+@@ -149,7 +149,13 @@ dependencies) {
+         else {
+             options.generatePackageJson ??= true;
+         }
+-        const compilerOptions = createTsCompilerOptions(projectRoot, tsConfig, options, dependencies);
++        let compilerOptionsInterceptor = ((config) => config);
++        if (rollupConfig.unisphere?.interceptors?.compilerOptions) {
++            console.log(`[unisphere.nx.rollup] using monkey patched interceptor for TS compiler options`);
++            compilerOptionsInterceptor = rollupConfig.unisphere?.interceptors?.compilerOptions;
++        }
++
++        const compilerOptions = compilerOptionsInterceptor(createTsCompilerOptions(projectRoot, tsConfig, options, dependencies));
+         compilerOptions.outDir = Array.isArray(finalConfig.output)
+             ? finalConfig.output[0].dir
+             : finalConfig.output.dir;
+@@ -170,6 +176,7 @@ dependencies) {
+                     return require('rollup-plugin-typescript2')({
+                         check: !options.skipTypeCheck,
+                         tsconfig: tsConfigPath,
++                        exclude: ['**/*.stories.ts', '**/*.stories.tsx'],
+                         tsconfigOverride: {
+                             compilerOptions,
+                         },

package/dist/migrations/2-0-0/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/2-0-0/rename-widgetname-to-widgetname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-widgetname-to-widgetname.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-0-0/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/2-0-0/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/{1-22-7/update-git-ignore.d.ts → 2-0-0/replace-patches.d.ts}

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

package/dist/migrations/2-0-0/replace-patches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-patches.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-0-0/replace-patches.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAmC,MAAM,YAAY,CAAC;AAQnE,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAwD9D"}

package/dist/migrations/2-0-0/replace-patches.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const removePatchList = ['nx+rollup+'];
+const forcePatchVersions = {
+    '@nx/rollup': '22.1.3'
+};
+async function update(tree) {
+    devkit_1.logger.info('🔄 Creating patches');
+    try {
+        // Check @nx/rollup version
+        if (Object.keys(forcePatchVersions).length !== 0) {
+            devkit_1.logger.info('removing patches of older versions');
+            const pkg = (0, devkit_1.readJson)(tree, 'package.json');
+            Object.keys(forcePatchVersions).forEach(key => {
+                const version = pkg.devDependencies?.[key] || pkg.dependencies?.[key];
+                if (version !== forcePatchVersions[key]) {
+                    devkit_1.logger.error(`❌ ${key} version must be exactly ${forcePatchVersions[key]}`);
+                    throw new Error(`${key} version must be exactly ${forcePatchVersions[key]}. did you migrate nx to other version?`);
+                }
+            });
+        }
+        // Create patches
+        const patchesPath = 'patches';
+        const patchesTemplatePath = (0, path_1.join)(__dirname, 'patches');
+        // Delete existing patches folder content if it exists
+        if (tree.exists(patchesPath)) {
+            const existingFiles = tree.children(patchesPath);
+            for (const file of existingFiles) {
+                if (removePatchList.some(patch => file.includes(patch))) {
+                    devkit_1.logger.info(`🗑️ Removing existing patch: ${file}`);
+                    tree.delete((0, path_1.join)(patchesPath, file));
+                }
+                else {
+                    devkit_1.logger.info(`✅ Patch: ${file} is up to date`);
+                }
+            }
+            devkit_1.logger.info(`🧹 Cleaned up existing patches folder`);
+        }
+        // Copy all patch files using generateFiles
+        (0, devkit_1.generateFiles)(tree, patchesTemplatePath, `./${patchesPath}`, {});
+        // Log created patches
+        const createdPatches = tree.children(patchesPath);
+        for (const patchFile of createdPatches) {
+            devkit_1.logger.info(`✅ Created patch: ${patchFile}`);
+        }
+        // Always log that patches were created
+        devkit_1.logger.info(`✅ All patches created successfully`);
+    }
+    catch (error) {
+        devkit_1.logger.error(`❌ Failed to create patches: ${error?.message || 'Unknown error'}`);
+        throw error;
+    }
+}

package/dist/migrations/2-0-0/summary.d.ts

@@ -0,0 +1,2 @@
+export default function (): Promise<void>;
+//# sourceMappingURL=summary.d.ts.map

package/dist/migrations/2-0-0/summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-0-0/summary.ts"],"names":[],"mappings":"AAEA,0CAOC"}

package/dist/migrations/2-0-0/summary.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+async function default_1() {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('🎉 Migration to @unisphere/nx 2.0.0 finished successfully!');
+    devkit_1.logger.info('');
+    devkit_1.logger.info('📋 Full details:');
+    devkit_1.logger.info('https://unisphere.kaltura.com/docs/create/changelog/2-0-0-changelog');
+    devkit_1.logger.info('');
+}

package/dist/migrations/2-0-0/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/2-0-0/sync-package-json-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-package-json-files.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-0-0/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"}

package/dist/migrations/2-0-0/sync-package-json-files.js

@@ -0,0 +1,68 @@
+"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('🔄 Sync package json files deps...');
+    let filesUpdated = 0;
+    // Read the root package.json to get the target versions
+    const rootPackageJson = tree.read('package.json', 'utf-8');
+    if (!rootPackageJson) {
+        devkit_1.logger.error('❌ Could not read root package.json');
+        return;
+    }
+    const rootPackage = JSON.parse(rootPackageJson);
+    const targetVersions = {
+        ...rootPackage.dependencies,
+        ...rootPackage.devDependencies
+    };
+    devkit_1.logger.info(`📦 Found ${Object.keys(targetVersions).length} dependencies to sync`);
+    // Find all package.json files in packages directory
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (filePath.endsWith('package.json')) {
+            const content = tree.read(filePath, 'utf-8');
+            if (content) {
+                try {
+                    const packageJson = JSON.parse(content);
+                    let hasChanges = false;
+                    // Sync dependencies
+                    if (packageJson.dependencies) {
+                        for (const [depName, currentVersion] of Object.entries(packageJson.dependencies)) {
+                            if (targetVersions[depName] && currentVersion !== targetVersions[depName]) {
+                                devkit_1.logger.info(`🔄 Updating ${depName} from ${currentVersion} to ${targetVersions[depName]} in ${filePath}`);
+                                packageJson.dependencies[depName] = targetVersions[depName];
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                    // Sync devDependencies
+                    if (packageJson.devDependencies) {
+                        for (const [depName, currentVersion] of Object.entries(packageJson.devDependencies)) {
+                            if (targetVersions[depName] && currentVersion !== targetVersions[depName]) {
+                                devkit_1.logger.info(`🔄 Updating ${depName} from ${currentVersion} to ${targetVersions[depName]} in ${filePath}`);
+                                packageJson.devDependencies[depName] = targetVersions[depName];
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                    if (hasChanges) {
+                        // Write the updated package.json back
+                        const updatedContent = JSON.stringify(packageJson, null, 2) + '\n';
+                        tree.write(filePath, updatedContent);
+                        filesUpdated++;
+                        devkit_1.logger.info(`✅ Updated ${filePath}`);
+                    }
+                }
+                catch (error) {
+                    devkit_1.logger.error(`❌ Error parsing ${filePath}: ${error}`);
+                }
+            }
+        }
+    });
+    if (filesUpdated > 0) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    else {
+        devkit_1.logger.info('ℹ️ No package.json files needed updating.');
+    }
+}

package/dist/migrations/2-0-0/update-npmrc.d.ts

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

package/dist/migrations/2-0-0/update-npmrc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-npmrc.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-0-0/update-npmrc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA6C,MAAM,YAAY,CAAC;AAE7E,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,MAAM,EAAE,CAAC,CAgDzE"}

package/dist/migrations/2-0-0/update-npmrc.js

@@ -0,0 +1,48 @@
+"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('🔄 Checking .npmrc for legacy-peer-deps=true...');
+    let filesScanned = 0;
+    let filesUpdated = 0;
+    const updateContent = (content) => {
+        const re = /(\blegacy-peer-deps\b\s*=\s*)true(\b|\s*)/gi;
+        if (re.test(content)) {
+            // Replace only the value while preserving whitespace and formatting
+            const replaced = content.replace(re, '$1false$2');
+            return replaced;
+        }
+        return null;
+    };
+    // Prefer root .npmrc, but scan workspace to be safe
+    const tryUpdateFile = (filePath) => {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        filesScanned++;
+        const updated = updateContent(content);
+        if (updated && updated !== content) {
+            tree.write(filePath, updated);
+            filesUpdated++;
+            devkit_1.logger.info(`✅ Updated ${filePath}: legacy-peer-deps=false`);
+        }
+    };
+    if (tree.exists('.npmrc')) {
+        tryUpdateFile('.npmrc');
+    }
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (p) => {
+        if (p.endsWith('/.npmrc') || p === '.npmrc') {
+            if (p !== '.npmrc') {
+                tryUpdateFile(p);
+            }
+        }
+    });
+    await (0, devkit_1.formatFiles)(tree);
+    if (filesUpdated === 0) {
+        devkit_1.logger.info('ℹ️ No .npmrc files required changes.');
+    }
+    else {
+        devkit_1.logger.warn(`✅ Updated ${filesUpdated} .npmrc file(s).`);
+    }
+}

package/dist/migrations/2-0-0/update-nvmrc.d.ts

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

package/dist/migrations/2-0-0/update-nvmrc.d.ts.map

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

package/dist/migrations/2-0-0/update-nvmrc.js

@@ -0,0 +1,26 @@
+"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('🔄 Updating .nvmrc to Node 24...');
+    const nvmrcPath = '.nvmrc';
+    const targetNodeVersion = '24';
+    if (tree.exists(nvmrcPath)) {
+        const currentContent = tree.read(nvmrcPath, 'utf-8');
+        if (currentContent) {
+            const currentVersion = currentContent.trim();
+            if (currentVersion === targetNodeVersion) {
+                devkit_1.logger.info('ℹ️ .nvmrc already set to Node 24.');
+                return;
+            }
+            tree.write(nvmrcPath, targetNodeVersion);
+            devkit_1.logger.info(`✅ Updated .nvmrc from ${currentVersion} to ${targetNodeVersion}`);
+        }
+    }
+    else {
+        tree.write(nvmrcPath, targetNodeVersion);
+        devkit_1.logger.info(`✅ Created .nvmrc with Node ${targetNodeVersion}`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/migrations/2-1-0/remove-react-overrides.d.ts

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

package/dist/migrations/2-1-0/remove-react-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-react-overrides.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-1-0/remove-react-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAsB,MAAM,YAAY,CAAC;AAEtD,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA+D9D"}

package/dist/migrations/2-1-0/remove-react-overrides.js

@@ -0,0 +1,59 @@
+"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('🔄 Removing React overrides from package.json...');
+    const packageJsonPath = 'package.json';
+    if (!tree.exists(packageJsonPath)) {
+        devkit_1.logger.warn('⚠️ package.json not found');
+        throw new Error('package.json not found');
+    }
+    try {
+        (0, devkit_1.updateJson)(tree, packageJsonPath, (packageJson) => {
+            let overridesRemoved = 0;
+            if (packageJson.overrides) {
+                // Find overrides that contain React-related dependencies
+                const overridesToRemove = Object.keys(packageJson.overrides).filter(key => {
+                    const override = packageJson.overrides[key];
+                    // Check if the override contains React-related dependencies
+                    if (typeof override === 'object' && override !== null) {
+                        return Object.entries(override).some(([dep, version]) => (dep === 'react' ||
+                            dep.startsWith('react-') ||
+                            dep.startsWith('@types/react')) && (typeof version === 'string' && (version.startsWith('18') || version.startsWith('^18'))));
+                    }
+                    // Check if the key itself is React-related
+                    return key === 'react' ||
+                        key.startsWith('react-') ||
+                        key.startsWith('@types/react');
+                });
+                // Remove the identified overrides
+                overridesToRemove.forEach(key => {
+                    delete packageJson.overrides[key];
+                    overridesRemoved++;
+                });
+                // If overrides object is now empty, remove it entirely
+                if (Object.keys(packageJson.overrides).length === 0) {
+                    delete packageJson.overrides;
+                    devkit_1.logger.info('📦 Removed empty overrides object');
+                }
+                if (overridesRemoved > 0) {
+                    devkit_1.logger.info(`📦 Removed ${overridesRemoved} React-related overrides from package.json`);
+                }
+                else {
+                    devkit_1.logger.info('ℹ️ No React-related overrides found to remove');
+                }
+            }
+            else {
+                devkit_1.logger.info('ℹ️ No overrides section found in package.json');
+            }
+            return packageJson;
+        });
+        devkit_1.logger.info('✅ Successfully processed React overrides removal');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        devkit_1.logger.error(`❌ Could not update package.json: ${errorMessage}`);
+        throw new Error(`Could not update package.json: ${errorMessage}`);
+    }
+}

package/dist/migrations/2-1-0/remove-rollup-plugin-node-builtins.d.ts

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

package/dist/migrations/2-1-0/remove-rollup-plugin-node-builtins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-rollup-plugin-node-builtins.d.ts","sourceRoot":"","sources":["../../../src/migrations/2-1-0/remove-rollup-plugin-node-builtins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAsB,MAAM,YAAY,CAAC;AAEtD,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAwD9D"}