@angular/core 21.0.0-next.0 → 21.0.0-next.10

package/schematics/bundles/parse_html-8VLCL37B.cjs

@@ -0,0 +1,132 @@
+'use strict';
+/**
+ * @license Angular v21.0.0-next.10
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var compiler = require('@angular/compiler');
+
+/**
+ * parses the template string into the Html AST
+ */
+function parseTemplate(template) {
+    let parsed;
+    try {
+        // Note: we use the HtmlParser here, instead of the `parseTemplate` function, because the
+        // latter returns an Ivy AST, not an HTML AST. The HTML AST has the advantage of preserving
+        // interpolated text as text nodes containing a mixture of interpolation tokens and text tokens,
+        // rather than turning them into `BoundText` nodes like the Ivy AST does. This allows us to
+        // easily get the text-only ranges without having to reconstruct the original text.
+        parsed = new compiler.HtmlParser().parse(template, '', {
+            // Allows for ICUs to be parsed.
+            tokenizeExpansionForms: true,
+            // Explicitly disable blocks so that their characters are treated as plain text.
+            tokenizeBlocks: true,
+            preserveLineEndings: true,
+        });
+        // Don't migrate invalid templates.
+        if (parsed.errors && parsed.errors.length > 0) {
+            const errors = parsed.errors.map((e) => ({ type: 'parse', error: e }));
+            return { tree: undefined, errors };
+        }
+    }
+    catch (e) {
+        return { tree: undefined, errors: [{ type: 'parse', error: e }] };
+    }
+    return { tree: parsed, errors: [] };
+}
+function pipeMatchRegExpFor(name) {
+    return new RegExp(`\\|\\s*${name}`);
+}
+const commonModulePipes = [
+    'date',
+    'async',
+    'currency',
+    'number',
+    'i18nPlural',
+    'i18nSelect',
+    'json',
+    'keyvalue',
+    'slice',
+    'lowercase',
+    'uppercase',
+    'titlecase',
+    'percent',
+].map((name) => pipeMatchRegExpFor(name));
+function allFormsOf(selector) {
+    return [selector, `*${selector}`, `[${selector}]`];
+}
+const commonModuleDirectives = new Set([
+    ...allFormsOf('ngComponentOutlet'),
+    ...allFormsOf('ngTemplateOutlet'),
+    ...allFormsOf('ngClass'),
+    ...allFormsOf('ngPlural'),
+    ...allFormsOf('ngPluralCase'),
+    ...allFormsOf('ngStyle'),
+    ...allFormsOf('ngTemplateOutlet'),
+    ...allFormsOf('ngComponentOutlet'),
+    '[NgForOf]',
+    '[NgForTrackBy]',
+    '[ngIfElse]',
+    '[ngIfThenElse]',
+    '*ngIf',
+    '*ngSwitch',
+    '*ngFor',
+]);
+/**
+ * determines if the CommonModule can be safely removed from imports
+ */
+function canRemoveCommonModule(template) {
+    const parsed = parseTemplate(template);
+    let removeCommonModule = false;
+    if (parsed.tree !== undefined) {
+        const visitor = new CommonCollector();
+        compiler.visitAll(visitor, parsed.tree.rootNodes);
+        removeCommonModule = visitor.count === 0;
+    }
+    return removeCommonModule;
+}
+/** Finds all non-control flow elements from common module. */
+class CommonCollector extends compiler.RecursiveVisitor {
+    count = 0;
+    visitElement(el) {
+        if (el.attrs.length > 0) {
+            for (const attr of el.attrs) {
+                if (this.hasDirectives(attr.name) || this.hasPipes(attr.value)) {
+                    this.count++;
+                }
+            }
+        }
+        super.visitElement(el, null);
+    }
+    visitBlock(ast) {
+        for (const blockParam of ast.parameters) {
+            if (this.hasPipes(blockParam.expression)) {
+                this.count++;
+            }
+        }
+        super.visitBlock(ast, null);
+    }
+    visitText(ast) {
+        if (this.hasPipes(ast.value)) {
+            this.count++;
+        }
+    }
+    visitLetDeclaration(decl) {
+        if (this.hasPipes(decl.value)) {
+            this.count++;
+        }
+        super.visitLetDeclaration(decl, null);
+    }
+    hasDirectives(input) {
+        return commonModuleDirectives.has(input);
+    }
+    hasPipes(input) {
+        return commonModulePipes.some((regexp) => regexp.test(input));
+    }
+}
+
+exports.canRemoveCommonModule = canRemoveCommonModule;
+exports.parseTemplate = parseTemplate;

package/schematics/bundles/{project_paths-DcaODbky.cjs → project_paths-DvD50ouC.cjs}

@@ -1,20 +1,19 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.0
+ * @license Angular v21.0.0-next.10
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var index = require('./index-esqfDjNB.cjs');
+var compilerCli = require('@angular/compiler-cli');
 var schematics = require('@angular-devkit/schematics');
 var core = require('@angular-devkit/core');
 var posixPath = require('node:path/posix');
-var os = require('os');
+var migrations = require('@angular/compiler-cli/private/migrations');
 var ts = require('typescript');
-var project_tsconfig_paths = require('./project_tsconfig_paths-CS-eSeHC.cjs');
-require('path');
 var path = require('node:path');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -34,233 +33,8 @@ function _interopNamespaceDefault(e) {
 }
 
 var posixPath__namespace = /*#__PURE__*/_interopNamespaceDefault(posixPath);
-var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
-/// <reference types="node" />
-class NgtscCompilerHost {
-    fs;
-    options;
-    constructor(fs, options = {}) {
-        this.fs = fs;
-        this.options = options;
-    }
-    getSourceFile(fileName, languageVersion) {
-        const text = this.readFile(fileName);
-        return text !== undefined
-            ? ts.createSourceFile(fileName, text, languageVersion, true)
-            : undefined;
-    }
-    getDefaultLibFileName(options) {
-        return this.fs.join(this.getDefaultLibLocation(), ts.getDefaultLibFileName(options));
-    }
-    getDefaultLibLocation() {
-        return this.fs.getDefaultLibLocation();
-    }
-    writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles) {
-        const path = project_tsconfig_paths.absoluteFrom(fileName);
-        this.fs.ensureDir(this.fs.dirname(path));
-        this.fs.writeFile(path, data);
-    }
-    getCurrentDirectory() {
-        return this.fs.pwd();
-    }
-    getCanonicalFileName(fileName) {
-        return this.useCaseSensitiveFileNames() ? fileName : fileName.toLowerCase();
-    }
-    useCaseSensitiveFileNames() {
-        return this.fs.isCaseSensitive();
-    }
-    getNewLine() {
-        switch (this.options.newLine) {
-            case ts.NewLineKind.CarriageReturnLineFeed:
-                return '\r\n';
-            case ts.NewLineKind.LineFeed:
-                return '\n';
-            default:
-                return os__namespace.EOL;
-        }
-    }
-    fileExists(fileName) {
-        const absPath = this.fs.resolve(fileName);
-        return this.fs.exists(absPath) && this.fs.stat(absPath).isFile();
-    }
-    readFile(fileName) {
-        const absPath = this.fs.resolve(fileName);
-        if (!this.fileExists(absPath)) {
-            return undefined;
-        }
-        return this.fs.readFile(absPath);
-    }
-    realpath(path) {
-        return this.fs.realpath(this.fs.resolve(path));
-    }
-}
-
-// 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.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.matchFiles.bind(ts);
-    return (rootDir, extensions, excludes, includes, depth) => {
-        const directoryExists = (p) => {
-            const resolvedPath = fs.resolve(p);
-            return fs.exists(resolvedPath) && fs.stat(resolvedPath).isDirectory();
-        };
-        return matchFilesFn(rootDir, extensions, excludes, includes, fs.isCaseSensitive(), fs.pwd(), depth, (p) => {
-            const resolvedPath = fs.resolve(p);
-            // TS also gracefully returns an empty file set.
-            if (!directoryExists(resolvedPath)) {
-                return { directories: [], files: [] };
-            }
-            const children = fs.readdir(resolvedPath);
-            const files = [];
-            const directories = [];
-            for (const child of children) {
-                if (fs.stat(fs.join(resolvedPath, child))?.isDirectory()) {
-                    directories.push(child);
-                }
-                else {
-                    files.push(child);
-                }
-            }
-            return { files, directories };
-        }, (p) => fs.resolve(p), (p) => directoryExists(p));
-    };
-}
-
-function calcProjectFileAndBasePath(project, host = project_tsconfig_paths.getFileSystem()) {
-    const absProject = host.resolve(project);
-    const projectIsDir = host.lstat(absProject).isDirectory();
-    const projectFile = projectIsDir ? host.join(absProject, 'tsconfig.json') : absProject;
-    const projectDir = projectIsDir ? absProject : host.dirname(absProject);
-    const basePath = host.resolve(projectDir);
-    return { projectFile, basePath };
-}
-function readConfiguration(project, existingOptions, host = project_tsconfig_paths.getFileSystem()) {
-    try {
-        const fs = project_tsconfig_paths.getFileSystem();
-        const readConfigFile = (configFile) => ts.readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
-        const readAngularCompilerOptions = (configFile, parentOptions = {}) => {
-            const { config, error } = readConfigFile(configFile);
-            if (error) {
-                // Errors are handled later on by 'parseJsonConfigFileContent'
-                return parentOptions;
-            }
-            // Note: In Google, `angularCompilerOptions` are stored in `bazelOptions`.
-            // This function typically doesn't run for actual Angular compilations, but
-            // tooling like Tsurge, or schematics may leverage this helper, so we account
-            // for this here.
-            const angularCompilerOptions = config.angularCompilerOptions ?? config.bazelOptions?.angularCompilerOptions;
-            // we are only interested into merging 'angularCompilerOptions' as
-            // other options like 'compilerOptions' are merged by TS
-            let existingNgCompilerOptions = { ...angularCompilerOptions, ...parentOptions };
-            if (!config.extends) {
-                return existingNgCompilerOptions;
-            }
-            const extendsPaths = typeof config.extends === 'string' ? [config.extends] : config.extends;
-            // Call readAngularCompilerOptions recursively to merge NG Compiler options
-            // Reverse the array so the overrides happen from right to left.
-            return [...extendsPaths].reverse().reduce((prevOptions, extendsPath) => {
-                const extendedConfigPath = getExtendedConfigPath(configFile, extendsPath, host, fs);
-                return extendedConfigPath === null
-                    ? prevOptions
-                    : readAngularCompilerOptions(extendedConfigPath, prevOptions);
-            }, existingNgCompilerOptions);
-        };
-        const { projectFile, basePath } = calcProjectFileAndBasePath(project, host);
-        const configFileName = host.resolve(host.pwd(), projectFile);
-        const { config, error } = readConfigFile(projectFile);
-        if (error) {
-            return {
-                project,
-                errors: [error],
-                rootNames: [],
-                options: {},
-                emitFlags: index.EmitFlags.Default,
-            };
-        }
-        const existingCompilerOptions = {
-            genDir: basePath,
-            basePath,
-            ...readAngularCompilerOptions(configFileName),
-            ...existingOptions,
-        };
-        const parseConfigHost = createParseConfigHost(host, fs);
-        const { options, errors, fileNames: rootNames, projectReferences, } = ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
-        let emitFlags = index.EmitFlags.Default;
-        if (!(options['skipMetadataEmit'] || options['flatModuleOutFile'])) {
-            emitFlags |= index.EmitFlags.Metadata;
-        }
-        if (options['skipTemplateCodegen']) {
-            emitFlags = emitFlags & ~index.EmitFlags.Codegen;
-        }
-        return { project: projectFile, rootNames, projectReferences, options, errors, emitFlags };
-    }
-    catch (e) {
-        const errors = [
-            {
-                category: ts.DiagnosticCategory.Error,
-                messageText: e.stack ?? e.message,
-                file: undefined,
-                start: undefined,
-                length: undefined,
-                source: 'angular',
-                code: index.UNKNOWN_ERROR_CODE,
-            },
-        ];
-        return { project: '', errors, rootNames: [], options: {}, emitFlags: index.EmitFlags.Default };
-    }
-}
-function createParseConfigHost(host, fs = project_tsconfig_paths.getFileSystem()) {
-    return {
-        fileExists: host.exists.bind(host),
-        readDirectory: createFileSystemTsReadDirectoryFn(fs),
-        readFile: host.readFile.bind(host),
-        useCaseSensitiveFileNames: fs.isCaseSensitive(),
-    };
-}
-function getExtendedConfigPath(configFile, extendsValue, host, fs) {
-    const result = getExtendedConfigPathWorker(configFile, extendsValue, host, fs);
-    if (result !== null) {
-        return result;
-    }
-    // Try to resolve the paths with a json extension append a json extension to the file in case if
-    // it is missing and the resolution failed. This is to replicate TypeScript behaviour, see:
-    // https://github.com/microsoft/TypeScript/blob/294a5a7d784a5a95a8048ee990400979a6bc3a1c/src/compiler/commandLineParser.ts#L2806
-    return getExtendedConfigPathWorker(configFile, `${extendsValue}.json`, host, fs);
-}
-function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
-    if (extendsValue.startsWith('.') || fs.isRooted(extendsValue)) {
-        const extendedConfigPath = host.resolve(host.dirname(configFile), extendsValue);
-        if (host.exists(extendedConfigPath)) {
-            return extendedConfigPath;
-        }
-    }
-    else {
-        const parseConfigHost = createParseConfigHost(host, fs);
-        // Path isn't a rooted or relative path, resolve like a module.
-        const { resolvedModule } = ts.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts.ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
-        if (resolvedModule) {
-            return project_tsconfig_paths.absoluteFrom(resolvedModule.resolvedFileName);
-        }
-    }
-    return null;
-}
-
 /**
  * Angular compiler file system implementation that leverages an
  * CLI schematic virtual file tree.
@@ -495,7 +269,7 @@ function createPlainTsProgram(tsHost, tsconfig, optionOverrides) {
  * an instance of the Angular compiler for the project.
  */
 function createNgtscProgram(tsHost, tsconfig, optionOverrides) {
-    const ngtscProgram = new index.NgtscProgram(tsconfig.rootNames, {
+    const ngtscProgram = new compilerCli.NgtscProgram(tsconfig.rootNames, {
         ...tsconfig.options,
         ...defaultMigrationTsOptions,
         ...optionOverrides,
@@ -517,7 +291,7 @@ function createNgtscProgram(tsHost, tsconfig, optionOverrides) {
 const NO_INPUTS_ERROR_CODE = 18003;
 /** Parses the given tsconfig file, supporting Angular compiler options. */
 function parseTsconfigOrDie(absoluteTsconfigPath, fs) {
-    const tsconfig = readConfiguration(absoluteTsconfigPath, {}, fs);
+    const tsconfig = compilerCli.readConfiguration(absoluteTsconfigPath, {}, fs);
     // Skip the "No inputs found..." error since we don't want to interrupt the migration if a
     // tsconfig doesn't match a file. This will result in an empty `Program` which is still valid.
     const errors = tsconfig.errors.filter((diag) => diag.code !== NO_INPUTS_ERROR_CODE);
@@ -555,9 +329,9 @@ function createBaseProgramInfo(absoluteTsconfigPath, fs, optionOverrides = {}) {
     // Make sure the FS becomes globally available. Some code paths
     // of the Angular compiler, or tsconfig parsing aren't leveraging
     // the specified file system.
-    project_tsconfig_paths.setFileSystem(fs);
+    compilerCli.setFileSystem(fs);
     const tsconfig = parseTsconfigOrDie(absoluteTsconfigPath, fs);
-    const tsHost = new NgtscCompilerHost(fs, tsconfig.options);
+    const tsHost = new compilerCli.NgtscCompilerHost(fs, tsconfig.options);
     // When enabled, use a plain TS program if we are sure it's not
     // an Angular project based on the `tsconfig.json`.
     if (google3UsePlainTsProgramIfNoKnownAngularOption() &&
@@ -584,14 +358,14 @@ function getProgramInfoFromBaseInfo(baseInfo) {
     const fullProgramSourceFiles = [...baseInfo.program.getSourceFiles()];
     const sourceFiles = fullProgramSourceFiles.filter((f) => !f.isDeclarationFile &&
         // Note `isShim` will work for the initial program, but for TCB programs, the shims are no longer annotated.
-        !project_tsconfig_paths.isShim(f) &&
+        !migrations.isShim(f) &&
         !f.fileName.endsWith('.ngtypecheck.ts'));
     // Sort it by length in reverse order (longest first). This speeds up lookups,
     // since there's no need to keep going through the array once a match is found.
-    const sortedRootDirs = project_tsconfig_paths.getRootDirs(baseInfo.host, baseInfo.userOptions).sort((a, b) => b.length - a.length);
+    const sortedRootDirs = migrations.getRootDirs(baseInfo.host, baseInfo.userOptions).sort((a, b) => b.length - a.length);
     // TODO: Consider also following TS's logic here, finding the common source root.
     // See: Program#getCommonSourceDirectory.
-    const primaryRoot = project_tsconfig_paths.absoluteFrom(baseInfo.userOptions.rootDir ?? sortedRootDirs.at(-1) ?? baseInfo.program.getCurrentDirectory());
+    const primaryRoot = compilerCli.absoluteFrom(baseInfo.userOptions.rootDir ?? sortedRootDirs.at(-1) ?? baseInfo.program.getCurrentDirectory());
     return {
         ...baseInfo,
         sourceFiles,
@@ -648,13 +422,6 @@ class TsurgeFunnelMigration extends TsurgeBaseMigration {
 class TsurgeComplexMigration extends TsurgeBaseMigration {
 }
 
-/*!
- * @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
- */
 exports.MigrationStage = void 0;
 (function (MigrationStage) {
     /** The migration is analyzing an entrypoint */
@@ -670,7 +437,7 @@ async function runMigrationInDevkit(config) {
     }
     const tsconfigPaths = [...buildPaths, ...testPaths];
     const fs = new DevkitMigrationFilesystem(config.tree);
-    project_tsconfig_paths.setFileSystem(fs);
+    compilerCli.setFileSystem(fs);
     const migration = config.getMigration(fs);
     const unitResults = [];
     const isFunnelMigration = migration instanceof TsurgeFunnelMigration;
@@ -780,7 +547,7 @@ function confirmAsSerializable(data) {
  * See {@link ProjectFile}.
  */
 function projectFile(file, { sortedRootDirs, projectRoot }) {
-    const fs = project_tsconfig_paths.getFileSystem();
+    const fs = compilerCli.getFileSystem();
     const filePath = fs.resolve(typeof file === 'string' ? file : file.fileName);
     // Sorted root directories are sorted longest to shortest. First match
     // is the appropriate root directory for ID computation.
@@ -807,7 +574,7 @@ function projectFile(file, { sortedRootDirs, projectRoot }) {
  * E.g. `a/b/c` is within `a/b` but not within `a/x`.
  */
 function isWithinBasePath(fs, base, path) {
-    return project_tsconfig_paths.isLocalRelativePath(fs.relative(base, path));
+    return compilerCli.isLocalRelativePath(fs.relative(base, path));
 }
 
 exports.Replacement = Replacement;

package/schematics/bundles/project_tsconfig_paths-CDVxT6Ov.cjs

@@ -0,0 +1,90 @@
+'use strict';
+/**
+ * @license Angular v21.0.0-next.10
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var core = require('@angular-devkit/core');
+
+/**
+ * Gets all tsconfig paths from a CLI project by reading the workspace configuration
+ * and looking for common tsconfig locations.
+ */
+async function getProjectTsConfigPaths(tree) {
+    // Start with some tsconfig paths that are generally used within CLI projects. Note
+    // that we are not interested in IDE-specific tsconfig files (e.g. /tsconfig.json)
+    const buildPaths = new Set();
+    const testPaths = new Set();
+    const workspace = await getWorkspace(tree);
+    for (const [, project] of workspace.projects) {
+        for (const [name, target] of project.targets) {
+            if (name !== 'build' && name !== 'test') {
+                continue;
+            }
+            for (const [, options] of allTargetOptions(target)) {
+                const tsConfig = options['tsConfig'];
+                // Filter out tsconfig files that don't exist in the CLI project.
+                if (typeof tsConfig !== 'string' || !tree.exists(tsConfig)) {
+                    continue;
+                }
+                if (name === 'build') {
+                    buildPaths.add(core.normalize(tsConfig));
+                }
+                else {
+                    testPaths.add(core.normalize(tsConfig));
+                }
+            }
+        }
+    }
+    return {
+        buildPaths: [...buildPaths],
+        testPaths: [...testPaths],
+    };
+}
+/** Get options for all configurations for the passed builder target. */
+function* allTargetOptions(target) {
+    if (target.options) {
+        yield [undefined, target.options];
+    }
+    if (!target.configurations) {
+        return;
+    }
+    for (const [name, options] of Object.entries(target.configurations)) {
+        if (options) {
+            yield [name, options];
+        }
+    }
+}
+function createHost(tree) {
+    return {
+        async readFile(path) {
+            const data = tree.read(path);
+            if (!data) {
+                throw new Error('File not found.');
+            }
+            return core.virtualFs.fileBufferToString(data);
+        },
+        async writeFile(path, data) {
+            return tree.overwrite(path, data);
+        },
+        async isDirectory(path) {
+            // Approximate a directory check.
+            // We don't need to consider empty directories and hence this is a good enough approach.
+            // This is also per documentation, see:
+            // https://angular.dev/tools/cli/schematics-for-libraries#get-the-project-configuration
+            return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
+        },
+        async isFile(path) {
+            return tree.exists(path);
+        },
+    };
+}
+async function getWorkspace(tree) {
+    const host = createHost(tree);
+    const { workspace } = await core.workspaces.readWorkspace('/', host);
+    return workspace;
+}
+
+exports.getProjectTsConfigPaths = getProjectTsConfigPaths;

package/schematics/bundles/property_name-BBwFuqMe.cjs

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.0
+ * @license Angular v21.0.0-next.10
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */