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

package/schematics/bundles/{project_paths-17dc204d.js → run_in_devkit-C0JPtK2u.js}

@@ -1,23 +1,22 @@
 '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';
 
-var core = require('@angular-devkit/core');
-var posixPath = require('node:path/posix');
 var os = require('os');
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
-var program = require('./program-a449f9bf.js');
+var checker = require('./checker-BHb19MHt.js');
+var index = require('./index-I8VbxQcO.js');
+var schematics = require('@angular-devkit/schematics');
+var core = require('@angular-devkit/core');
+var posixPath = require('node:path/posix');
 require('path');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
         Object.keys(e).forEach(function (k) {
@@ -30,13 +29,12 @@ function _interopNamespace(e) {
             }
         });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
 }
 
-var posixPath__namespace = /*#__PURE__*/_interopNamespace(posixPath);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+var posixPath__namespace = /*#__PURE__*/_interopNamespaceDefault(posixPath);
 
 /// <reference types="node" />
 class NgtscCompilerHost {
@@ -49,11 +47,11 @@ class NgtscCompilerHost {
     getSourceFile(fileName, languageVersion) {
         const text = this.readFile(fileName);
         return text !== undefined
-            ? ts__default["default"].createSourceFile(fileName, text, languageVersion, true)
+            ? ts.createSourceFile(fileName, text, languageVersion, true)
             : undefined;
     }
     getDefaultLibFileName(options) {
-        return this.fs.join(this.getDefaultLibLocation(), ts__default["default"].getDefaultLibFileName(options));
+        return this.fs.join(this.getDefaultLibLocation(), ts.getDefaultLibFileName(options));
     }
     getDefaultLibLocation() {
         return this.fs.getDefaultLibLocation();
@@ -74,9 +72,9 @@ class NgtscCompilerHost {
     }
     getNewLine() {
         switch (this.options.newLine) {
-            case ts__default["default"].NewLineKind.CarriageReturnLineFeed:
+            case ts.NewLineKind.CarriageReturnLineFeed:
                 return '\r\n';
-            case ts__default["default"].NewLineKind.LineFeed:
+            case ts.NewLineKind.LineFeed:
                 return '\n';
             default:
                 return os__namespace.EOL;
@@ -99,17 +97,23 @@ class NgtscCompilerHost {
 }
 
 // We use TypeScript's native `ts.matchFiles` utility for the virtual file systems
+// and their TypeScript compiler host `readDirectory` implementation. TypeScript's
+// function implements complex logic for matching files with respect to root
+// directory, extensions, excludes, includes etc. The function is currently
+// internal but we can use it as the API most likely will not change any time soon,
+// nor does it seem like this is being made public any time soon.
+// Related issue for tracking: https://github.com/microsoft/TypeScript/issues/13793.
 /**
  * Creates a {@link ts.CompilerHost#readDirectory} implementation function,
  * that leverages the specified file system (that may be e.g. virtual).
  */
 function createFileSystemTsReadDirectoryFn(fs) {
-    if (ts__default["default"].matchFiles === undefined) {
+    if (ts.matchFiles === undefined) {
         throw Error('Unable to read directory in configured file system. This means that ' +
             'TypeScript changed its file matching internals.\n\nPlease consider downgrading your ' +
             'TypeScript version, and report an issue in the Angular framework repository.');
     }
-    const matchFilesFn = ts__default["default"].matchFiles.bind(ts__default["default"]);
+    const matchFilesFn = ts.matchFiles.bind(ts);
     return (rootDir, extensions, excludes, includes, depth) => {
         const directoryExists = (p) => {
             const resolvedPath = fs.resolve(p);
@@ -148,7 +152,7 @@ function calcProjectFileAndBasePath(project, host = checker.getFileSystem()) {
 function readConfiguration(project, existingOptions, host = checker.getFileSystem()) {
     try {
         const fs = checker.getFileSystem();
-        const readConfigFile = (configFile) => ts__default["default"].readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
+        const readConfigFile = (configFile) => ts.readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
         const readAngularCompilerOptions = (configFile, parentOptions = {}) => {
             const { config, error } = readConfigFile(configFile);
             if (error) {
@@ -185,7 +189,7 @@ function readConfiguration(project, existingOptions, host = checker.getFileSyste
                 errors: [error],
                 rootNames: [],
                 options: {},
-                emitFlags: program.EmitFlags.Default,
+                emitFlags: index.EmitFlags.Default,
             };
         }
         const existingCompilerOptions = {
@@ -195,29 +199,29 @@ function readConfiguration(project, existingOptions, host = checker.getFileSyste
             ...existingOptions,
         };
         const parseConfigHost = createParseConfigHost(host, fs);
-        const { options, errors, fileNames: rootNames, projectReferences, } = ts__default["default"].parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
-        let emitFlags = program.EmitFlags.Default;
+        const { options, errors, fileNames: rootNames, projectReferences, } = ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
+        let emitFlags = index.EmitFlags.Default;
         if (!(options['skipMetadataEmit'] || options['flatModuleOutFile'])) {
-            emitFlags |= program.EmitFlags.Metadata;
+            emitFlags |= index.EmitFlags.Metadata;
         }
         if (options['skipTemplateCodegen']) {
-            emitFlags = emitFlags & ~program.EmitFlags.Codegen;
+            emitFlags = emitFlags & ~index.EmitFlags.Codegen;
         }
         return { project: projectFile, rootNames, projectReferences, options, errors, emitFlags };
     }
     catch (e) {
         const errors = [
             {
-                category: ts__default["default"].DiagnosticCategory.Error,
+                category: ts.DiagnosticCategory.Error,
                 messageText: e.stack ?? e.message,
                 file: undefined,
                 start: undefined,
                 length: undefined,
                 source: 'angular',
-                code: program.UNKNOWN_ERROR_CODE,
+                code: index.UNKNOWN_ERROR_CODE,
             },
         ];
-        return { project: '', errors, rootNames: [], options: {}, emitFlags: program.EmitFlags.Default };
+        return { project: '', errors, rootNames: [], options: {}, emitFlags: index.EmitFlags.Default };
     }
 }
 function createParseConfigHost(host, fs = checker.getFileSystem()) {
@@ -248,7 +252,7 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
     else {
         const parseConfigHost = createParseConfigHost(host, fs);
         // Path isn't a rooted or relative path, resolve like a module.
-        const { resolvedModule } = ts__default["default"].nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts__default["default"].ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
+        const { resolvedModule } = ts.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts.ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
         if (resolvedModule) {
             return checker.absoluteFrom(resolvedModule.resolvedFileName);
         }
@@ -256,187 +260,6 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
     return null;
 }
 
-/**
- * Angular compiler file system implementation that leverages an
- * CLI schematic virtual file tree.
- */
-class DevkitMigrationFilesystem {
-    tree;
-    constructor(tree) {
-        this.tree = tree;
-    }
-    extname(path) {
-        return core.extname(path);
-    }
-    isRoot(path) {
-        return path === core.normalize('/');
-    }
-    isRooted(path) {
-        return this.normalize(path).startsWith('/');
-    }
-    dirname(file) {
-        return this.normalize(core.dirname(file));
-    }
-    join(basePath, ...paths) {
-        return this.normalize(core.join(basePath, ...paths));
-    }
-    relative(from, to) {
-        return this.normalize(core.relative(from, to));
-    }
-    basename(filePath, extension) {
-        return posixPath__namespace.basename(filePath, extension);
-    }
-    normalize(path) {
-        return core.normalize(path);
-    }
-    resolve(...paths) {
-        const normalizedPaths = paths.map((p) => core.normalize(p));
-        // In dev-kit, the NodeJS working directory should never be
-        // considered, so `/` is the last resort over `cwd`.
-        return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
-    }
-    pwd() {
-        return '/';
-    }
-    isCaseSensitive() {
-        return true;
-    }
-    exists(path) {
-        return statPath(this.tree, path) !== null;
-    }
-    readFile(path) {
-        return this.tree.readText(path);
-    }
-    readFileBuffer(path) {
-        const buffer = this.tree.read(path);
-        if (buffer === null) {
-            throw new Error(`File does not exist: ${path}`);
-        }
-        return buffer;
-    }
-    readdir(path) {
-        const dir = this.tree.getDir(path);
-        return [
-            ...dir.subdirs,
-            ...dir.subfiles,
-        ];
-    }
-    lstat(path) {
-        const stat = statPath(this.tree, path);
-        if (stat === null) {
-            throw new Error(`File does not exist for "lstat": ${path}`);
-        }
-        return stat;
-    }
-    stat(path) {
-        const stat = statPath(this.tree, path);
-        if (stat === null) {
-            throw new Error(`File does not exist for "stat": ${path}`);
-        }
-        return stat;
-    }
-    realpath(filePath) {
-        return filePath;
-    }
-    getDefaultLibLocation() {
-        return 'node_modules/typescript/lib';
-    }
-    ensureDir(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#ensureDir is not supported.');
-    }
-    writeFile(path, data) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#writeFile is not supported.');
-    }
-    removeFile(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#removeFile is not supported.');
-    }
-    copyFile(from, to) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#copyFile is not supported.');
-    }
-    moveFile(from, to) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#moveFile is not supported.');
-    }
-    removeDeep(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#removeDeep is not supported.');
-    }
-    chdir(_path) {
-        throw new Error('FileSystem#chdir is not supported.');
-    }
-    symlink() {
-        throw new Error('FileSystem#symlink is not supported.');
-    }
-}
-/** Stats the given path in the virtual tree. */
-function statPath(tree, path) {
-    let fileInfo = null;
-    let dirInfo = null;
-    try {
-        fileInfo = tree.get(path);
-    }
-    catch (e) {
-        if (e.constructor.name === 'PathIsDirectoryException') {
-            dirInfo = tree.getDir(path);
-        }
-        else {
-            throw e;
-        }
-    }
-    if (fileInfo !== null || dirInfo !== null) {
-        return {
-            isDirectory: () => dirInfo !== null,
-            isFile: () => fileInfo !== null,
-            isSymbolicLink: () => false,
-        };
-    }
-    return null;
-}
-
-/**
- * Groups the given replacements per project relative
- * file path.
- *
- * This allows for simple execution of the replacements
- * against a given file. E.g. via {@link applyTextUpdates}.
- */
-function groupReplacementsByFile(replacements) {
-    const result = new Map();
-    for (const { projectFile, update } of replacements) {
-        if (!result.has(projectFile.rootRelativePath)) {
-            result.set(projectFile.rootRelativePath, []);
-        }
-        result.get(projectFile.rootRelativePath).push(update);
-    }
-    return result;
-}
-
-/**
- * Synchronously combines unit data for the given migration.
- *
- * Note: This helper is useful for testing and execution of
- * Tsurge migrations in non-batchable environments. In general,
- * prefer parallel execution of combining via e.g. Beam combiners.
- */
-async function synchronouslyCombineUnitData(migration, unitDatas) {
-    if (unitDatas.length === 0) {
-        return null;
-    }
-    if (unitDatas.length === 1) {
-        return unitDatas[0];
-    }
-    let combined = unitDatas[0];
-    for (let i = 1; i < unitDatas.length; i++) {
-        const other = unitDatas[i];
-        combined = await migration.combine(combined, other);
-    }
-    return combined;
-}
-
 /**
  * By default, Tsurge will always create an Angular compiler program
  * for projects analyzed and migrated. This works perfectly fine in
@@ -464,7 +287,7 @@ const defaultMigrationTsOptions = {
  * Creates an instance of a TypeScript program for the given project.
  */
 function createPlainTsProgram(tsHost, tsconfig, optionOverrides) {
-    const program = ts__default["default"].createProgram({
+    const program = ts.createProgram({
         rootNames: tsconfig.rootNames,
         options: {
             ...tsconfig.options,
@@ -486,14 +309,14 @@ function createPlainTsProgram(tsHost, tsconfig, optionOverrides) {
  * an instance of the Angular compiler for the project.
  */
 function createNgtscProgram(tsHost, tsconfig, optionOverrides) {
-    const ngtscProgram = new program.NgtscProgram(tsconfig.rootNames, {
+    const ngtscProgram = new index.NgtscProgram(tsconfig.rootNames, {
         ...tsconfig.options,
         ...defaultMigrationTsOptions,
         ...optionOverrides,
     }, tsHost);
     // Expose an easy way to debug-print ng semantic diagnostics.
     if (process.env['DEBUG_NG_SEMANTIC_DIAGNOSTICS'] === '1') {
-        console.error(ts__default["default"].formatDiagnosticsWithColorAndContext(ngtscProgram.getNgSemanticDiagnostics(), tsHost));
+        console.error(ts.formatDiagnosticsWithColorAndContext(ngtscProgram.getNgSemanticDiagnostics(), tsHost));
     }
     return {
         ngCompiler: ngtscProgram.compiler,
@@ -666,13 +489,257 @@ function isWithinBasePath(fs, base, path) {
     return checker.isLocalRelativePath(fs.relative(base, path));
 }
 
-exports.DevkitMigrationFilesystem = DevkitMigrationFilesystem;
+/**
+ * Angular compiler file system implementation that leverages an
+ * CLI schematic virtual file tree.
+ */
+class DevkitMigrationFilesystem {
+    tree;
+    constructor(tree) {
+        this.tree = tree;
+    }
+    extname(path) {
+        return core.extname(path);
+    }
+    isRoot(path) {
+        return path === core.normalize('/');
+    }
+    isRooted(path) {
+        return this.normalize(path).startsWith('/');
+    }
+    dirname(file) {
+        return this.normalize(core.dirname(file));
+    }
+    join(basePath, ...paths) {
+        return this.normalize(core.join(basePath, ...paths));
+    }
+    relative(from, to) {
+        return this.normalize(core.relative(from, to));
+    }
+    basename(filePath, extension) {
+        return posixPath__namespace.basename(filePath, extension);
+    }
+    normalize(path) {
+        return core.normalize(path);
+    }
+    resolve(...paths) {
+        const normalizedPaths = paths.map((p) => core.normalize(p));
+        // In dev-kit, the NodeJS working directory should never be
+        // considered, so `/` is the last resort over `cwd`.
+        return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
+    }
+    pwd() {
+        return '/';
+    }
+    isCaseSensitive() {
+        return true;
+    }
+    exists(path) {
+        return statPath(this.tree, path) !== null;
+    }
+    readFile(path) {
+        return this.tree.readText(path);
+    }
+    readFileBuffer(path) {
+        const buffer = this.tree.read(path);
+        if (buffer === null) {
+            throw new Error(`File does not exist: ${path}`);
+        }
+        return buffer;
+    }
+    readdir(path) {
+        const dir = this.tree.getDir(path);
+        return [
+            ...dir.subdirs,
+            ...dir.subfiles,
+        ];
+    }
+    lstat(path) {
+        const stat = statPath(this.tree, path);
+        if (stat === null) {
+            throw new Error(`File does not exist for "lstat": ${path}`);
+        }
+        return stat;
+    }
+    stat(path) {
+        const stat = statPath(this.tree, path);
+        if (stat === null) {
+            throw new Error(`File does not exist for "stat": ${path}`);
+        }
+        return stat;
+    }
+    realpath(filePath) {
+        return filePath;
+    }
+    getDefaultLibLocation() {
+        return 'node_modules/typescript/lib';
+    }
+    ensureDir(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#ensureDir is not supported.');
+    }
+    writeFile(path, data) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#writeFile is not supported.');
+    }
+    removeFile(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#removeFile is not supported.');
+    }
+    copyFile(from, to) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#copyFile is not supported.');
+    }
+    moveFile(from, to) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#moveFile is not supported.');
+    }
+    removeDeep(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#removeDeep is not supported.');
+    }
+    chdir(_path) {
+        throw new Error('FileSystem#chdir is not supported.');
+    }
+    symlink() {
+        throw new Error('FileSystem#symlink is not supported.');
+    }
+}
+/** Stats the given path in the virtual tree. */
+function statPath(tree, path) {
+    let fileInfo = null;
+    let dirInfo = null;
+    try {
+        fileInfo = tree.get(path);
+    }
+    catch (e) {
+        if (e.constructor.name === 'PathIsDirectoryException') {
+            dirInfo = tree.getDir(path);
+        }
+        else {
+            throw e;
+        }
+    }
+    if (fileInfo !== null || dirInfo !== null) {
+        return {
+            isDirectory: () => dirInfo !== null,
+            isFile: () => fileInfo !== null,
+            isSymbolicLink: () => false,
+        };
+    }
+    return null;
+}
+
+/**
+ * Groups the given replacements per project relative
+ * file path.
+ *
+ * This allows for simple execution of the replacements
+ * against a given file. E.g. via {@link applyTextUpdates}.
+ */
+function groupReplacementsByFile(replacements) {
+    const result = new Map();
+    for (const { projectFile, update } of replacements) {
+        if (!result.has(projectFile.rootRelativePath)) {
+            result.set(projectFile.rootRelativePath, []);
+        }
+        result.get(projectFile.rootRelativePath).push(update);
+    }
+    return result;
+}
+
+/**
+ * Synchronously combines unit data for the given migration.
+ *
+ * Note: This helper is useful for testing and execution of
+ * Tsurge migrations in non-batchable environments. In general,
+ * prefer parallel execution of combining via e.g. Beam combiners.
+ */
+async function synchronouslyCombineUnitData(migration, unitDatas) {
+    if (unitDatas.length === 0) {
+        return null;
+    }
+    if (unitDatas.length === 1) {
+        return unitDatas[0];
+    }
+    let combined = unitDatas[0];
+    for (let i = 1; i < unitDatas.length; i++) {
+        const other = unitDatas[i];
+        combined = await migration.combine(combined, other);
+    }
+    return combined;
+}
+
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/** Runs a Tsurge within an Angular Devkit context. */
+async function runMigrationInDevkit(config) {
+    const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(config.tree);
+    if (!buildPaths.length && !testPaths.length) {
+        throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the migration.');
+    }
+    const fs = new DevkitMigrationFilesystem(config.tree);
+    checker.setFileSystem(fs);
+    const migration = config.getMigration(fs);
+    const unitResults = [];
+    const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
+        config.beforeProgramCreation?.(tsconfigPath);
+        const baseInfo = migration.createProgram(tsconfigPath, fs);
+        const info = migration.prepareProgram(baseInfo);
+        config.afterProgramCreation?.(info, fs);
+        return { info, tsconfigPath };
+    });
+    for (const { info, tsconfigPath } of programInfos) {
+        config.beforeUnitAnalysis?.(tsconfigPath);
+        unitResults.push(await migration.analyze(info));
+    }
+    config.afterAllAnalyzed?.();
+    const combined = await synchronouslyCombineUnitData(migration, unitResults);
+    if (combined === null) {
+        config.afterAnalysisFailure?.();
+        return;
+    }
+    const globalMeta = await migration.globalMeta(combined);
+    let replacements;
+    if (migration instanceof TsurgeFunnelMigration) {
+        replacements = (await migration.migrate(globalMeta)).replacements;
+    }
+    else {
+        replacements = [];
+        for (const { info } of programInfos) {
+            const result = await migration.migrate(globalMeta, info);
+            replacements.push(...result.replacements);
+        }
+    }
+    const replacementsPerFile = new Map();
+    const changesPerFile = groupReplacementsByFile(replacements);
+    for (const [file, changes] of changesPerFile) {
+        if (!replacementsPerFile.has(file)) {
+            replacementsPerFile.set(file, changes);
+        }
+    }
+    for (const [file, changes] of replacementsPerFile) {
+        const recorder = config.tree.beginUpdate(file);
+        for (const c of changes) {
+            recorder
+                .remove(c.data.position, c.data.end - c.data.position)
+                .insertRight(c.data.position, c.data.toInsert);
+        }
+        config.tree.commitUpdate(recorder);
+    }
+    config.whenDone?.(await migration.stats(globalMeta));
+}
+
 exports.Replacement = Replacement;
 exports.TextUpdate = TextUpdate;
 exports.TsurgeComplexMigration = TsurgeComplexMigration;
 exports.TsurgeFunnelMigration = TsurgeFunnelMigration;
 exports.confirmAsSerializable = confirmAsSerializable;
 exports.createBaseProgramInfo = createBaseProgramInfo;
-exports.groupReplacementsByFile = groupReplacementsByFile;
 exports.projectFile = projectFile;
-exports.synchronouslyCombineUnitData = synchronouslyCombineUnitData;
+exports.runMigrationInDevkit = runMigrationInDevkit;