@angular/core 20.0.0-next.1 → 20.0.0-next.3

package/schematics/bundles/self-closing-tags-migration.js

@@ -1,33 +1,27 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var schematics = require('@angular-devkit/schematics');
-var project_tsconfig_paths = require('./project_tsconfig_paths-b558633b.js');
-var project_paths = require('./project_paths-17dc204d.js');
-require('os');
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
-require('./program-a449f9bf.js');
+require('os');
+var checker = require('./checker-BHb19MHt.js');
+require('./index-I8VbxQcO.js');
 require('path');
-var ng_decorators = require('./ng_decorators-b0d8b324.js');
-var property_name = require('./property_name-ac18447e.js');
+var run_in_devkit = require('./run_in_devkit-C0JPtK2u.js');
+var ng_decorators = require('./ng_decorators-DznZ5jMl.js');
+var property_name = require('./property_name-BBwFuqMe.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
-require('./imports-047fbbc8.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
+require('./imports-CIX-JgAN.js');
 
 /**
  * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
@@ -35,7 +29,7 @@ var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
  * TypeScript node referring to the inner expression. e.g "exp".
  */
 function unwrapExpression(node) {
-    if (ts__default["default"].isParenthesizedExpression(node) || ts__default["default"].isAsExpression(node)) {
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node)) {
         return unwrapExpression(node.expression);
     }
     else {
@@ -45,7 +39,7 @@ function unwrapExpression(node) {
 
 /** Extracts `@Directive` or `@Component` metadata from the given class. */
 function extractAngularClassMetadata(typeChecker, node) {
-    const decorators = ts__default["default"].getDecorators(node);
+    const decorators = ts.getDecorators(node);
     if (!decorators || !decorators.length) {
         return null;
     }
@@ -64,7 +58,7 @@ function extractAngularClassMetadata(typeChecker, node) {
     }
     const metadata = unwrapExpression(decoratorCall.arguments[0]);
     // Ensure that the metadata is an object literal expression.
-    if (!ts__default["default"].isObjectLiteralExpression(metadata)) {
+    if (!ts.isObjectLiteralExpression(metadata)) {
         return null;
     }
     return {
@@ -138,10 +132,10 @@ class NgComponentTemplateVisitor {
         this.typeChecker = typeChecker;
     }
     visitNode(node) {
-        if (node.kind === ts__default["default"].SyntaxKind.ClassDeclaration) {
+        if (node.kind === ts.SyntaxKind.ClassDeclaration) {
             this.visitClassDeclaration(node);
         }
-        ts__default["default"].forEachChild(node, (n) => this.visitNode(n));
+        ts.forEachChild(node, (n) => this.visitNode(n));
     }
     visitClassDeclaration(node) {
         const metadata = extractAngularClassMetadata(this.typeChecker, node);
@@ -153,13 +147,13 @@ class NgComponentTemplateVisitor {
         // Walk through all component metadata properties and determine the referenced
         // HTML templates (either external or inline)
         metadata.node.properties.forEach((property) => {
-            if (!ts__default["default"].isPropertyAssignment(property)) {
+            if (!ts.isPropertyAssignment(property)) {
                 return;
             }
             const propertyName = property_name.getPropertyNameText(property.name);
             // In case there is an inline template specified, ensure that the value is statically
             // analyzable by checking if the initializer is a string literal-like node.
-            if (propertyName === 'template' && ts__default["default"].isStringLiteralLike(property.initializer)) {
+            if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {
                 // Need to add an offset of one to the start because the template quotes are
                 // not part of the template content.
                 // The `getText()` method gives us the original raw text.
@@ -177,10 +171,10 @@ class NgComponentTemplateVisitor {
                     content,
                     inline: true,
                     start: start,
-                    getCharacterAndLineOfPosition: (pos) => ts__default["default"].getLineAndCharacterOfPosition(sourceFile, pos + start),
+                    getCharacterAndLineOfPosition: (pos) => ts.getLineAndCharacterOfPosition(sourceFile, pos + start),
                 });
             }
-            if (propertyName === 'templateUrl' && ts__default["default"].isStringLiteralLike(property.initializer)) {
+            if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
                 const absolutePath = this.fs.resolve(this.fs.dirname(sourceFileName), property.initializer.text);
                 if (!this.fs.exists(absolutePath)) {
                     return;
@@ -303,7 +297,7 @@ class AngularElementCollector extends checker.RecursiveVisitor {
     }
 }
 
-class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
+class SelfClosingTagsMigration extends run_in_devkit.TsurgeFunnelMigration {
     config;
     constructor(config = {}) {
         super();
@@ -314,12 +308,12 @@ class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
         const typeChecker = program.getTypeChecker();
         const tagReplacements = [];
         for (const sf of sourceFiles) {
-            ts__default["default"].forEachChild(sf, (node) => {
+            ts.forEachChild(sf, (node) => {
                 // Skipping any non component declarations
-                if (!ts__default["default"].isClassDeclaration(node)) {
+                if (!ts.isClassDeclaration(node)) {
                     return;
                 }
-                const file = project_paths.projectFile(node.getSourceFile(), info);
+                const file = run_in_devkit.projectFile(node.getSourceFile(), info);
                 if (this.config.shouldMigrate && this.config.shouldMigrate(file) === false) {
                     return;
                 }
@@ -332,7 +326,7 @@ class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
                     }
                     const fileToMigrate = template.inline
                         ? file
-                        : project_paths.projectFile(template.filePath, info);
+                        : run_in_devkit.projectFile(template.filePath, info);
                     const end = template.start + template.content.length;
                     const replacements = [
                         prepareTextReplacement(fileToMigrate, migrated, template.start, end),
@@ -348,20 +342,20 @@ class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
                 });
             });
         }
-        return project_paths.confirmAsSerializable({ tagReplacements });
+        return run_in_devkit.confirmAsSerializable({ tagReplacements });
     }
     async combine(unitA, unitB) {
         const uniqueReplacements = removeDuplicateReplacements([
             ...unitA.tagReplacements,
             ...unitB.tagReplacements,
         ]);
-        return project_paths.confirmAsSerializable({ tagReplacements: uniqueReplacements });
+        return run_in_devkit.confirmAsSerializable({ tagReplacements: uniqueReplacements });
     }
     async globalMeta(combinedData) {
         const globalMeta = {
             tagReplacements: combinedData.tagReplacements,
         };
-        return project_paths.confirmAsSerializable(globalMeta);
+        return run_in_devkit.confirmAsSerializable(globalMeta);
     }
     async stats(globalMetadata) {
         const touchedFilesCount = globalMetadata.tagReplacements.length;
@@ -378,7 +372,7 @@ class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
     }
 }
 function prepareTextReplacement(file, replacement, start, end) {
-    return new project_paths.Replacement(file, new project_paths.TextUpdate({
+    return new run_in_devkit.Replacement(file, new run_in_devkit.TextUpdate({
         position: start,
         end: end,
         toInsert: replacement,
@@ -399,65 +393,35 @@ function removeDuplicateReplacements(replacements) {
 
 function migrate(options) {
     return async (tree, context) => {
-        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
-        if (!buildPaths.length && !testPaths.length) {
-            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run self-closing tags migration.');
-        }
-        const fs = new project_paths.DevkitMigrationFilesystem(tree);
-        checker.setFileSystem(fs);
-        const migration = new SelfClosingTagsMigration({
-            shouldMigrate: (file) => {
-                return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
-                    !/(^|\/)node_modules\//.test(file.rootRelativePath));
+        await run_in_devkit.runMigrationInDevkit({
+            tree,
+            getMigration: (fs) => new SelfClosingTagsMigration({
+                shouldMigrate: (file) => {
+                    return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
+                        !/(^|\/)node_modules\//.test(file.rootRelativePath));
+                },
+            }),
+            beforeProgramCreation: (tsconfigPath) => {
+                context.logger.info(`Preparing analysis for: ${tsconfigPath}...`);
+            },
+            beforeUnitAnalysis: (tsconfigPath) => {
+                context.logger.info(`Scanning for component tags: ${tsconfigPath}...`);
+            },
+            afterAllAnalyzed: () => {
+                context.logger.info(``);
+                context.logger.info(`Processing analysis data between targets...`);
+                context.logger.info(``);
+            },
+            afterAnalysisFailure: () => {
+                context.logger.error('Migration failed unexpectedly with no analysis data');
+            },
+            whenDone: ({ counters }) => {
+                const { touchedFilesCount, replacementCount } = counters;
+                context.logger.info('');
+                context.logger.info(`Successfully migrated to self-closing tags 🎉`);
+                context.logger.info(`  -> Migrated ${replacementCount} components to self-closing tags in ${touchedFilesCount} component files.`);
             },
         });
-        const unitResults = [];
-        const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
-            context.logger.info(`Preparing analysis for: ${tsconfigPath}..`);
-            const baseInfo = migration.createProgram(tsconfigPath, fs);
-            const info = migration.prepareProgram(baseInfo);
-            return { info, tsconfigPath };
-        });
-        // Analyze phase. Treat all projects as compilation units as
-        // this allows us to support references between those.
-        for (const { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Scanning for component tags: ${tsconfigPath}..`);
-            unitResults.push(await migration.analyze(info));
-        }
-        context.logger.info(``);
-        context.logger.info(`Processing analysis data between targets..`);
-        context.logger.info(``);
-        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
-        if (combined === null) {
-            context.logger.error('Migration failed unexpectedly with no analysis data');
-            return;
-        }
-        const globalMeta = await migration.globalMeta(combined);
-        const replacementsPerFile = new Map();
-        for (const { tsconfigPath } of programInfos) {
-            context.logger.info(`Migrating: ${tsconfigPath}..`);
-            const { replacements } = await migration.migrate(globalMeta);
-            const changesPerFile = project_paths.groupReplacementsByFile(replacements);
-            for (const [file, changes] of changesPerFile) {
-                if (!replacementsPerFile.has(file)) {
-                    replacementsPerFile.set(file, changes);
-                }
-            }
-        }
-        context.logger.info(`Applying changes..`);
-        for (const [file, changes] of replacementsPerFile) {
-            const recorder = tree.beginUpdate(file);
-            for (const c of changes) {
-                recorder
-                    .remove(c.data.position, c.data.end - c.data.position)
-                    .insertLeft(c.data.position, c.data.toInsert);
-            }
-            tree.commitUpdate(recorder);
-        }
-        const { counters: { touchedFilesCount, replacementCount }, } = await migration.stats(globalMeta);
-        context.logger.info('');
-        context.logger.info(`Successfully migrated to self-closing tags 🎉`);
-        context.logger.info(`  -> Migrated ${replacementCount} components to self-closing tags in ${touchedFilesCount} component files.`);
     };
 }