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

package/schematics/bundles/signal-queries-migration.js

@@ -1,36 +1,29 @@
 '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 checker = require('./checker-BHb19MHt.js');
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
-var program = require('./program-a449f9bf.js');
+require('os');
+var index$1 = require('./index-I8VbxQcO.js');
 require('path');
-var apply_import_manager = require('./apply_import_manager-e2a7fe5b.js');
-var migrate_ts_type_references = require('./migrate_ts_type_references-2a3e9e6b.js');
+var run_in_devkit = require('./run_in_devkit-C0JPtK2u.js');
+var apply_import_manager = require('./apply_import_manager-BXQEjo09.js');
+var migrate_ts_type_references = require('./migrate_ts_type_references-KlOTWeDl.js');
 var assert = require('assert');
-var index = require('./index-1bef3025.js');
+var index = require('./index-BL9kAIe5.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
-require('./leading_space-f8944434.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
+require('./leading_space-D9nQ8UQC.js');
 
 /**
  * Phase that migrates Angular host binding references to
@@ -64,7 +57,7 @@ function migrateHostBindings(host, references, info) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new project_paths.Replacement(project_paths.projectFile(bindingField.getSourceFile(), info), new project_paths.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
+        host.replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(bindingField.getSourceFile(), info), new run_in_devkit.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
     }
 }
 
@@ -93,7 +86,7 @@ function migrateTemplateReferences(host, references) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new project_paths.Replacement(reference.from.templateFile, new project_paths.TextUpdate({
+        host.replacements.push(new run_in_devkit.Replacement(reference.from.templateFile, new run_in_devkit.TextUpdate({
             position: reference.from.read.sourceSpan.end,
             end: reference.from.read.sourceSpan.end,
             toInsert: appendText,
@@ -106,14 +99,14 @@ function migrateTemplateReferences(host, references) {
  */
 function extractQueryListType(node) {
     // Initializer variant of `new QueryList<T>()`.
-    if (ts__default["default"].isNewExpression(node) &&
-        ts__default["default"].isIdentifier(node.expression) &&
+    if (ts.isNewExpression(node) &&
+        ts.isIdentifier(node.expression) &&
         node.expression.text === 'QueryList') {
         return node.typeArguments?.[0];
     }
     // Type variant of `: QueryList<T>`.
-    if (ts__default["default"].isTypeReferenceNode(node) &&
-        ts__default["default"].isIdentifier(node.typeName) &&
+    if (ts.isTypeReferenceNode(node) &&
+        ts.isIdentifier(node.typeName) &&
         node.typeName.text === 'QueryList') {
         return node.typeArguments?.[0];
     }
@@ -166,14 +159,14 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
         }
     }
     if (metadata.queryInfo.read !== null) {
-        assert__default["default"](metadata.queryInfo.read instanceof checker.WrappedNodeExpr);
-        optionProperties.push(ts__default["default"].factory.createPropertyAssignment('read', metadata.queryInfo.read.node));
+        assert(metadata.queryInfo.read instanceof checker.WrappedNodeExpr);
+        optionProperties.push(ts.factory.createPropertyAssignment('read', metadata.queryInfo.read.node));
     }
     if (metadata.queryInfo.descendants !== defaultDescendants) {
-        optionProperties.push(ts__default["default"].factory.createPropertyAssignment('descendants', metadata.queryInfo.descendants ? ts__default["default"].factory.createTrue() : ts__default["default"].factory.createFalse()));
+        optionProperties.push(ts.factory.createPropertyAssignment('descendants', metadata.queryInfo.descendants ? ts.factory.createTrue() : ts.factory.createFalse()));
     }
     if (optionProperties.length > 0) {
-        args.push(ts__default["default"].factory.createObjectLiteralExpression(optionProperties));
+        args.push(ts.factory.createObjectLiteralExpression(optionProperties));
     }
     const strictNullChecksEnabled = options.strict === true || options.strictNullChecks === true;
     const strictPropertyInitialization = options.strict === true || options.strictPropertyInitialization === true;
@@ -196,12 +189,12 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
     if (isRequired && metadata.queryInfo.first) {
         // If the query is required already via some indicators, and this is a "single"
         // query, use the available `.required` method.
-        newQueryFn = ts__default["default"].factory.createPropertyAccessExpression(newQueryFn, 'required');
+        newQueryFn = ts.factory.createPropertyAccessExpression(newQueryFn, 'required');
     }
     // If this query is still nullable (i.e. not required), attempt to remove
     // explicit `undefined` types if possible.
-    if (!isRequired && type !== undefined && ts__default["default"].isUnionTypeNode(type)) {
-        type = migrate_ts_type_references.removeFromUnionIfPossible(type, (v) => v.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
+    if (!isRequired && type !== undefined && ts.isUnionTypeNode(type)) {
+        type = migrate_ts_type_references.removeFromUnionIfPossible(type, (v) => v.kind !== ts.SyntaxKind.UndefinedKeyword);
     }
     let locatorType = Array.isArray(metadata.queryInfo.predicate)
         ? null
@@ -211,23 +204,23 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
     // on the TS inference, instead of repeating types, like in `viewChild<Button>(Button)`.
     if (type !== undefined &&
         resolvedReadType instanceof checker.WrappedNodeExpr &&
-        ts__default["default"].isIdentifier(resolvedReadType.node) &&
-        ts__default["default"].isTypeReferenceNode(type) &&
-        ts__default["default"].isIdentifier(type.typeName) &&
+        ts.isIdentifier(resolvedReadType.node) &&
+        ts.isTypeReferenceNode(type) &&
+        ts.isIdentifier(type.typeName) &&
         type.typeName.text === resolvedReadType.node.text) {
         locatorType = null;
     }
-    const call = ts__default["default"].factory.createCallExpression(newQueryFn, 
+    const call = ts.factory.createCallExpression(newQueryFn, 
     // If there is no resolved `ReadT` (e.g. string predicate), we use the
     // original type explicitly as generic. Otherwise, query API is smart
     // enough to always infer.
     resolvedReadType === null && type !== undefined ? [type] : undefined, args);
-    const updated = ts__default["default"].factory.createPropertyDeclaration([ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword)], node.name, undefined, undefined, call);
+    const updated = ts.factory.createPropertyDeclaration([ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)], node.name, undefined, undefined, call);
     return [
-        new project_paths.Replacement(project_paths.projectFile(node.getSourceFile(), info), new project_paths.TextUpdate({
+        new run_in_devkit.Replacement(run_in_devkit.projectFile(node.getSourceFile(), info), new run_in_devkit.TextUpdate({
             position: node.getStart(),
             end: node.getEnd(),
-            toInsert: printer.printNode(ts__default["default"].EmitHint.Unspecified, updated, sf),
+            toInsert: printer.printNode(ts.EmitHint.Unspecified, updated, sf),
         })),
     ];
 }
@@ -238,7 +231,7 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
  */
 function getClassFieldDescriptorForSymbol(symbol, info) {
     if (symbol?.valueDeclaration === undefined ||
-        !ts__default["default"].isPropertyDeclaration(symbol.valueDeclaration)) {
+        !ts.isPropertyDeclaration(symbol.valueDeclaration)) {
         return null;
     }
     const key = getUniqueIDForClassProperty(symbol.valueDeclaration, info);
@@ -259,13 +252,13 @@ function getClassFieldDescriptorForSymbol(symbol, info) {
  * would then match identity.
  */
 function getUniqueIDForClassProperty(property, info) {
-    if (!ts__default["default"].isClassDeclaration(property.parent) || property.parent.name === undefined) {
+    if (!ts.isClassDeclaration(property.parent) || property.parent.name === undefined) {
         return null;
     }
     if (property.name === undefined) {
         return null;
     }
-    const id = project_paths.projectFile(property.getSourceFile(), info).id.replace(/\.d\.ts$/, '.ts');
+    const id = run_in_devkit.projectFile(property.getSourceFile(), info).id.replace(/\.d\.ts$/, '.ts');
     // Note: If a class is nested, there could be an ID clash.
     // This is highly unlikely though, and this is not a problem because
     // in such cases, there is even less chance there are any references to
@@ -279,14 +272,14 @@ function getUniqueIDForClassProperty(property, info) {
  * returns its resolved metadata if possible.
  */
 function extractSourceQueryDefinition(node, reflector, evaluator, info) {
-    if ((!ts__default["default"].isPropertyDeclaration(node) && !ts__default["default"].isAccessor(node)) ||
-        !ts__default["default"].isClassDeclaration(node.parent) ||
+    if ((!ts.isPropertyDeclaration(node) && !ts.isAccessor(node)) ||
+        !ts.isClassDeclaration(node.parent) ||
         node.parent.name === undefined ||
-        !ts__default["default"].isIdentifier(node.name)) {
+        !ts.isIdentifier(node.name)) {
         return null;
     }
     const decorators = reflector.getDecoratorsOfDeclaration(node) ?? [];
-    const ngDecorators = checker.getAngularDecorators(decorators, program.queryDecoratorNames, /* isCore */ false);
+    const ngDecorators = checker.getAngularDecorators(decorators, checker.queryDecoratorNames, /* isCore */ false);
     if (ngDecorators.length === 0) {
         return null;
     }
@@ -313,7 +306,7 @@ function extractSourceQueryDefinition(node, reflector, evaluator, info) {
     }
     let queryInfo = null;
     try {
-        queryInfo = program.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
+        queryInfo = checker.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
     }
     catch (e) {
         if (!(e instanceof checker.FatalDiagnosticError)) {
@@ -389,7 +382,7 @@ class KnownQueries {
         });
         this.knownQueryIDs.set(id, { key: id, node: queryField });
         const descriptor = { key: id, node: queryField };
-        const file = project_paths.projectFile(queryField.getSourceFile(), this.info);
+        const file = run_in_devkit.projectFile(queryField.getSourceFile(), this.info);
         if (this.config.shouldMigrateQuery !== undefined &&
             !this.config.shouldMigrateQuery(descriptor, file)) {
             this.markFieldIncompatible(descriptor, {
@@ -412,7 +405,7 @@ class KnownQueries {
         return this.classToQueryFields.get(clazz);
     }
     getAllClassesWithQueries() {
-        return Array.from(this.classToQueryFields.keys()).filter((c) => ts__default["default"].isClassDeclaration(c));
+        return Array.from(this.classToQueryFields.keys()).filter((c) => ts.isClassDeclaration(c));
     }
     captureKnownFieldInheritanceRelationship(derived, parent) {
         // Note: The edge problematic pattern recognition is not as good as the one
@@ -505,8 +498,8 @@ function queryFunctionNameToDecorator(name) {
 function checkTsReferenceAccessesField(ref, fieldName) {
     const accessNode = index.traverseAccess(ref.from.node);
     // Check if the reference is part of a property access.
-    if (!ts__default["default"].isPropertyAccessExpression(accessNode.parent) ||
-        !ts__default["default"].isIdentifier(accessNode.parent.name)) {
+    if (!ts.isPropertyAccessExpression(accessNode.parent) ||
+        !ts.isIdentifier(accessNode.parent.name)) {
         return null;
     }
     // Check if the reference is refers to the given field name.
@@ -543,7 +536,7 @@ function checkTsReferenceCallsField(ref, fieldName) {
     if (propertyAccess === null) {
         return null;
     }
-    if (ts__default["default"].isCallExpression(propertyAccess.parent) &&
+    if (ts.isCallExpression(propertyAccess.parent) &&
         propertyAccess.parent.expression === propertyAccess) {
         return propertyAccess.parent;
     }
@@ -588,7 +581,7 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, rep
             return;
         }
         const toArrayExpr = toArrayCallExpr.expression;
-        replacements.push(new project_paths.Replacement(project_paths.projectFile(toArrayExpr.getSourceFile(), info), new project_paths.TextUpdate({
+        replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(toArrayExpr.getSourceFile(), info), new run_in_devkit.TextUpdate({
             // Delete from expression end to call end. E.g. `.toArray(<..>)`.
             position: toArrayExpr.expression.getEnd(),
             end: toArrayCallExpr.getEnd(),
@@ -603,7 +596,7 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, rep
     }
     const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
     const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
+    replacements.push(new run_in_devkit.Replacement(file, new run_in_devkit.TextUpdate({
         // Delete from expression end to call end. E.g. `.toArray(<..>)`.
         position: offset + callExpr.receiver.receiver.sourceSpan.end,
         end: offset + callExpr.sourceSpan.end,
@@ -627,7 +620,7 @@ function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replac
             return;
         }
         const getExpr = getCallExpr.expression;
-        replacements.push(new project_paths.Replacement(project_paths.projectFile(getExpr.getSourceFile(), info), new project_paths.TextUpdate({
+        replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(getExpr.getSourceFile(), info), new run_in_devkit.TextUpdate({
             position: getExpr.name.getStart(),
             end: getExpr.name.getEnd(),
             toInsert: 'at',
@@ -641,7 +634,7 @@ function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replac
     }
     const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
     const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
+    replacements.push(new run_in_devkit.Replacement(file, new run_in_devkit.TextUpdate({
         position: offset + callExpr.receiver.nameSpan.start,
         end: offset + callExpr.receiver.nameSpan.end,
         toInsert: 'at',
@@ -696,7 +689,7 @@ function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, known
         if (expr === null) {
             return;
         }
-        replacements.push(new project_paths.Replacement(project_paths.projectFile(expr.getSourceFile(), info), new project_paths.TextUpdate({
+        replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(expr.getSourceFile(), info), new run_in_devkit.TextUpdate({
             position: expr.name.getStart(),
             end: expr.name.getEnd(),
             toInsert: mapping.get(expr.name.text),
@@ -710,14 +703,14 @@ function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, known
     }
     const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
     const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
+    replacements.push(new run_in_devkit.Replacement(file, new run_in_devkit.TextUpdate({
         position: offset + expr.nameSpan.start,
         end: offset + expr.nameSpan.end,
         toInsert: mapping.get(expr.name),
     })));
 }
 
-class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
+class SignalQueriesMigration extends run_in_devkit.TsurgeComplexMigration {
     config;
     constructor(config = {}) {
         super();
@@ -733,10 +726,10 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
         if (templateTypeChecker !== null) {
             templateTypeChecker.generateAllTypeCheckBlocks();
         }
-        const { sourceFiles, program: program$1 } = info;
-        const checker$1 = program$1.getTypeChecker();
+        const { sourceFiles, program } = info;
+        const checker$1 = program.getTypeChecker();
         const reflector = new checker.TypeScriptReflectionHost(checker$1);
-        const evaluator = new program.PartialEvaluator(reflector, checker$1, null);
+        const evaluator = new index$1.PartialEvaluator(reflector, checker$1, null);
         const res = {
             knownQueryFields: {},
             potentialProblematicQueries: {},
@@ -755,7 +748,7 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                     key: extractedQuery.id,
                     node: queryNode,
                 };
-                const containingFile = project_paths.projectFile(queryNode.getSourceFile(), info);
+                const containingFile = run_in_devkit.projectFile(queryNode.getSourceFile(), info);
                 // If we have a config filter function, use it here for later
                 // perf-boosted reference lookups. Useful in non-batch mode.
                 if (this.config.shouldMigrateQuery === undefined ||
@@ -769,17 +762,17 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                     fieldName: extractedQuery.queryInfo.propertyName,
                     isMulti: extractedQuery.queryInfo.first === false,
                 };
-                if (ts__default["default"].isAccessor(queryNode)) {
+                if (ts.isAccessor(queryNode)) {
                     markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.Accessor);
                 }
                 // Detect queries with union types that are uncommon to be
                 // automatically migrate-able. E.g. `refs: ElementRef|null`,
                 // or `ElementRef|SomeOtherType`.
                 if (queryNode.type !== undefined &&
-                    ts__default["default"].isUnionTypeNode(queryNode.type) &&
+                    ts.isUnionTypeNode(queryNode.type) &&
                     // Either too large union, or doesn't match `T|undefined`.
                     (queryNode.type.types.length > 2 ||
-                        !queryNode.type.types.some((t) => t.kind === ts__default["default"].SyntaxKind.UndefinedKeyword))) {
+                        !queryNode.type.types.some((t) => t.kind === ts.SyntaxKind.UndefinedKeyword))) {
                     markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__IncompatibleMultiUnionType);
                 }
                 // Migrating fields with `@HostBinding` is incompatible as
@@ -859,7 +852,7 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
         if (this.config.assumeNonBatch) {
             res.reusableAnalysisReferences = referenceResult.references;
         }
-        return project_paths.confirmAsSerializable(res);
+        return run_in_devkit.confirmAsSerializable(res);
     }
     async combine(unitA, unitB) {
         const combined = {
@@ -899,7 +892,7 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                 }
             }
         }
-        return project_paths.confirmAsSerializable(combined);
+        return run_in_devkit.confirmAsSerializable(combined);
     }
     async globalMeta(combinedData) {
         const globalUnitData = {
@@ -912,7 +905,7 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                 markFieldIncompatibleInMetadata(globalUnitData.problematicQueries, id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed);
             }
         }
-        return project_paths.confirmAsSerializable(globalUnitData);
+        return run_in_devkit.confirmAsSerializable(globalUnitData);
     }
     async migrate(globalMetadata, info) {
         // Pre-Analyze the program and get access to the template type checker.
@@ -921,13 +914,13 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
             metaReader: null,
         };
         const resourceLoader = info.ngCompiler?.['resourceManager'] ?? null;
-        const { program: program$1, sourceFiles } = info;
-        const checker$1 = program$1.getTypeChecker();
+        const { program, sourceFiles } = info;
+        const checker$1 = program.getTypeChecker();
         const reflector = new checker.TypeScriptReflectionHost(checker$1);
-        const evaluator = new program.PartialEvaluator(reflector, checker$1, null);
+        const evaluator = new index$1.PartialEvaluator(reflector, checker$1, null);
         const replacements = [];
         const importManager = new checker.ImportManager();
-        const printer = ts__default["default"].createPrinter();
+        const printer = ts.createPrinter();
         const filesWithSourceQueries = new Map();
         const filesWithIncompleteMigration = new Map();
         const filesWithQueryListOutsideOfDeclarations = new WeakSet();
@@ -944,8 +937,8 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                 return;
             }
             // Detect OTHER queries, inside `.d.ts`. Needed for reference resolution below.
-            if (ts__default["default"].isPropertyDeclaration(node) ||
-                (ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent))) {
+            if (ts.isPropertyDeclaration(node) ||
+                (ts.isAccessor(node) && ts.isClassDeclaration(node.parent))) {
                 const classFieldID = getUniqueIDForClassProperty(node, info);
                 if (classFieldID !== null && globalMetadata.knownQueryFields[classFieldID] !== undefined) {
                     knownQueries.registerQueryField(node, classFieldID);
@@ -954,15 +947,15 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
             }
             // Detect potential usages of `QueryList` outside of queries or imports.
             // Those prevent us from removing the import later.
-            if (ts__default["default"].isIdentifier(node) &&
+            if (ts.isIdentifier(node) &&
                 node.text === 'QueryList' &&
-                ts__default["default"].findAncestor(node, ts__default["default"].isImportDeclaration) === undefined) {
+                ts.findAncestor(node, ts.isImportDeclaration) === undefined) {
                 filesWithQueryListOutsideOfDeclarations.add(node.getSourceFile());
             }
-            ts__default["default"].forEachChild(node, queryWholeProgramVisitor);
+            ts.forEachChild(node, queryWholeProgramVisitor);
         };
         for (const sf of info.fullProgramSourceFiles) {
-            ts__default["default"].forEachChild(sf, queryWholeProgramVisitor);
+            ts.forEachChild(sf, queryWholeProgramVisitor);
         }
         // Set of all queries in the program. Useful for speeding up reference
         // lookups below.
@@ -1113,84 +1106,56 @@ function updateFileState(stateMap, node, queryType) {
 
 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 signal queries migration.');
-        }
-        const fs = new project_paths.DevkitMigrationFilesystem(tree);
-        checker.setFileSystem(fs);
-        const migration = new SignalQueriesMigration({
-            bestEffortMode: options.bestEffortMode,
-            insertTodosForSkippedFields: options.insertTodos,
-            shouldMigrateQuery: (_query, file) => {
-                return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
-                    !/(^|\/)node_modules\//.test(file.rootRelativePath));
+        await run_in_devkit.runMigrationInDevkit({
+            tree,
+            getMigration: (fs) => new SignalQueriesMigration({
+                bestEffortMode: options.bestEffortMode,
+                insertTodosForSkippedFields: options.insertTodos,
+                shouldMigrateQuery: (_query, file) => {
+                    return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
+                        !/(^|\/)node_modules\//.test(file.rootRelativePath));
+                },
+            }),
+            beforeProgramCreation: (tsconfigPath) => {
+                context.logger.info(`Preparing analysis for: ${tsconfigPath}...`);
             },
-        });
-        const analysisPath = fs.resolve(options.analysisDir);
-        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);
-            // Support restricting the analysis to subfolders for larger projects.
-            if (analysisPath !== '/') {
-                info.sourceFiles = info.sourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
-                info.fullProgramSourceFiles = info.fullProgramSourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
-            }
-            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 queries: ${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 { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Migrating: ${tsconfigPath}..`);
-            const { replacements } = await migration.migrate(globalMeta, info);
-            const changesPerFile = project_paths.groupReplacementsByFile(replacements);
-            for (const [file, changes] of changesPerFile) {
-                if (!replacementsPerFile.has(file)) {
-                    replacementsPerFile.set(file, changes);
+            afterProgramCreation: (info, fs) => {
+                const analysisPath = fs.resolve(options.analysisDir);
+                // Support restricting the analysis to subfolders for larger projects.
+                if (analysisPath !== '/') {
+                    info.sourceFiles = info.sourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
+                    info.fullProgramSourceFiles = info.fullProgramSourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
                 }
-            }
-        }
-        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);
-        }
-        context.logger.info('');
-        context.logger.info(`Successfully migrated to signal queries 🎉`);
-        const { counters: { queriesCount, incompatibleQueries, multiQueries }, } = await migration.stats(globalMeta);
-        const migratedQueries = queriesCount - incompatibleQueries;
-        context.logger.info('');
-        context.logger.info(`Successfully migrated to signal queries 🎉`);
-        context.logger.info(`  -> Migrated ${migratedQueries}/${queriesCount} queries.`);
-        if (incompatibleQueries > 0 && !options.insertTodos) {
-            context.logger.warn(`To see why ${incompatibleQueries} queries couldn't be migrated`);
-            context.logger.warn(`consider re-running with "--insert-todos" or "--best-effort-mode".`);
-        }
-        if (options.bestEffortMode) {
-            context.logger.warn(`You ran with best effort mode. Manually verify all code ` +
-                `works as intended, and fix where necessary.`);
-        }
+            },
+            beforeUnitAnalysis: (tsconfigPath) => {
+                context.logger.info(`Scanning for queries: ${tsconfigPath}...`);
+            },
+            afterAnalysisFailure: () => {
+                context.logger.error('Migration failed unexpectedly with no analysis data');
+            },
+            afterAllAnalyzed: () => {
+                context.logger.info(``);
+                context.logger.info(`Processing analysis data between targets...`);
+                context.logger.info(``);
+            },
+            whenDone: ({ counters }) => {
+                context.logger.info('');
+                context.logger.info(`Successfully migrated to signal queries 🎉`);
+                const { queriesCount, incompatibleQueries } = counters;
+                const migratedQueries = queriesCount - incompatibleQueries;
+                context.logger.info('');
+                context.logger.info(`Successfully migrated to signal queries 🎉`);
+                context.logger.info(`  -> Migrated ${migratedQueries}/${queriesCount} queries.`);
+                if (incompatibleQueries > 0 && !options.insertTodos) {
+                    context.logger.warn(`To see why ${incompatibleQueries} queries couldn't be migrated`);
+                    context.logger.warn(`consider re-running with "--insert-todos" or "--best-effort-mode".`);
+                }
+                if (options.bestEffortMode) {
+                    context.logger.warn(`You ran with best effort mode. Manually verify all code ` +
+                        `works as intended, and fix where necessary.`);
+                }
+            },
+        });
     };
 }
 

package/schematics/bundles/signals.js

@@ -1,34 +1,32 @@
 '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 signalQueriesMigration = require('./signal-queries-migration.js');
 var signalInputMigration = require('./signal-input-migration.js');
 var outputMigration = require('./output-migration.js');
-require('./project_tsconfig_paths-b558633b.js');
-require('@angular-devkit/core');
-require('./project_paths-17dc204d.js');
-require('node:path/posix');
-require('os');
+require('./checker-BHb19MHt.js');
 require('typescript');
-require('./checker-af521da6.js');
+require('os');
 require('fs');
 require('module');
 require('path');
 require('url');
-require('./program-a449f9bf.js');
-require('./apply_import_manager-e2a7fe5b.js');
-require('./migrate_ts_type_references-2a3e9e6b.js');
+require('./index-I8VbxQcO.js');
+require('./run_in_devkit-C0JPtK2u.js');
+require('@angular-devkit/core');
+require('node:path/posix');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
+require('./apply_import_manager-BXQEjo09.js');
+require('./migrate_ts_type_references-KlOTWeDl.js');
 require('assert');
-require('./index-1bef3025.js');
-require('./leading_space-f8944434.js');
+require('./index-BL9kAIe5.js');
+require('./leading_space-D9nQ8UQC.js');
 
 function migrate(options) {
     // The migrations are independent so we can run them in any order, but we sort them here