@angular/compiler-cli 21.0.0-next.0 → 21.0.0-next.10

package/src/ngtsc/annotations/common/src/metadata.d.ts

@@ -5,9 +5,11 @@
  * 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
  */
-import { R3ClassMetadata } from '@angular/compiler';
+import { LiteralArrayExpr, R3ClassMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+import { ClassMember, DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+/** Function that extracts metadata from an undercorated class member. */
+export type UndecoratedMetadataExtractor = (member: ClassMember) => LiteralArrayExpr | null;
 /**
  * Given a class declaration, generate a call to `setClassMetadata` with the Angular metadata
  * present on the class or its member fields. An ngDevMode guard is used to allow the call to be
@@ -16,7 +18,7 @@ import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection'
  * If no such metadata is present, this function returns `null`. Otherwise, the call is returned
  * as a `Statement` for inclusion along with the class.
  */
-export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator): R3ClassMetadata | null;
+export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator, undecoratedMetadataExtractor?: UndecoratedMetadataExtractor): R3ClassMetadata | null;
 /**
  * Recursively recreates all of the `Identifier` descendant nodes with a particular name inside
  * of an AST node, thus removing any references to them. Useful if a particular node has to be

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -79,6 +79,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, enableLetSyntax: boolean, externalRuntimeStyles: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, jitDeclarationRegistry: JitDeclarationRegistry, i18nPreserveSignificantWhitespace: boolean, strictStandalone: boolean, enableHmr: boolean, implicitStandaloneValue: boolean, typeCheckHostBindings: boolean, enableSelectorless: boolean, emitDeclarationOnly: boolean);
     private literalCache;
     private elementSchemaRegistry;
+    private readonly undecoratedMetadataExtractor;
     /**
      * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
      * any potential <link> tags which might need to be loaded. This cache ensures that work is not

package/src/ngtsc/annotations/component/src/metadata.d.ts

@@ -9,7 +9,7 @@ import { LegacyAnimationTriggerNames, DeclarationListEmitMode, DeferBlockDepsEmi
 import ts from 'typescript';
 import { Reference } from '../../../imports';
 import { ClassPropertyMapping, DirectiveResources, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping } from '../../../metadata';
-import { ClassDeclaration } from '../../../reflection';
+import { ClassDeclaration, Import } from '../../../reflection';
 import { SubsetOfKeys } from '../../../util/src/typescript';
 import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
 import { HostBindingNodes } from '../../directive';
@@ -84,10 +84,11 @@ export interface ComponentResolutionData {
     declarationListEmitMode: DeclarationListEmitMode;
     /**
      * Map of all types that can be defer loaded (ts.ClassDeclaration) ->
-     * corresponding import declaration (ts.ImportDeclaration) within
-     * the current source file.
+     * corresponding import information (reflection `Import`) within
+     * the current source file. The `Import` preserves the exported name
+     * as seen by the importing module so aliasing is handled correctly.
      */
-    deferrableDeclToImportDecl: Map<ClassDeclaration, ts.ImportDeclaration>;
+    deferrableDeclToImportDecl: Map<ClassDeclaration, Import>;
     /**
      * Map of `@defer` blocks -> their corresponding dependencies.
      * Required to compile the defer resolver function in `PerBlock` mode.

package/src/ngtsc/annotations/component/src/resources.d.ts

@@ -5,7 +5,7 @@
  * 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
  */
-import { InterpolationConfig, ParsedTemplate, ParseSourceFile, TmplAstNode } from '@angular/compiler';
+import { ParsedTemplate, ParseSourceFile, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
 import { FatalDiagnosticError } from '../../../diagnostics';
 import { DependencyTracker } from '../../../incremental/api';
@@ -66,7 +66,6 @@ export interface ParsedTemplateWithSource extends ParsedComponentTemplate {
  */
 interface CommonTemplateDeclaration {
     preserveWhitespaces: boolean;
-    interpolationConfig: InterpolationConfig;
     templateUrl: string;
     resolvedTemplateUrl: string;
 }

package/src/ngtsc/annotations/directive/src/handler.d.ts

@@ -65,6 +65,7 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, typeCheckScopeRegistry: TypeCheckScopeRegistry, compilationMode: CompilationMode, jitDeclarationRegistry: JitDeclarationRegistry, resourceRegistry: ResourceRegistry, strictStandalone: boolean, implicitStandaloneValue: boolean, usePoisonedData: boolean, typeCheckHostBindings: boolean, emitDeclarationOnly: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "DirectiveDecoratorHandler";
+    private readonly undecoratedMetadataExtractor;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>): AnalysisOutput<DirectiveHandlerData>;
     symbol(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): DirectiveSymbol;

package/src/ngtsc/annotations/directive/src/shared.d.ts

@@ -12,7 +12,7 @@ import { ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, Input
 import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
-import { ReferencesRegistry } from '../../common';
+import { ReferencesRegistry, UndecoratedMetadataExtractor } from '../../common';
 type QueryDecoratorName = 'ViewChild' | 'ViewChildren' | 'ContentChild' | 'ContentChildren';
 export declare const queryDecoratorNames: QueryDecoratorName[];
 export interface HostBindingNodes {
@@ -43,6 +43,11 @@ export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decora
 export declare function extractDecoratorQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
 export declare function parseDirectiveStyles(directive: Map<string, ts.Expression>, evaluator: PartialEvaluator, compilationMode: CompilationMode): null | string[];
 export declare function parseFieldStringArrayValue(directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null | string[];
+/**
+ * Returns a function that can be used to extract data for the `setClassMetadata`
+ * calls from undecorated directive class members.
+ */
+export declare function getDirectiveUndecoratedMetadataExtractor(reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): UndecoratedMetadataExtractor;
 /**
  * Parses the `transform` function and its type for a decorator `@Input`.
  *

package/src/ngtsc/annotations/index.d.ts

@@ -5,9 +5,10 @@
  * 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
  */
-export { createForwardRefResolver, findAngularDecorator, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext, JitDeclarationRegistry, } from './common';
+export { createForwardRefResolver, findAngularDecorator, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext, JitDeclarationRegistry, unwrapExpression, } from './common';
 export { ComponentDecoratorHandler } from './component';
-export { DirectiveDecoratorHandler, InitializerApiFunction, INPUT_INITIALIZER_FN, MODEL_INITIALIZER_FN, OUTPUT_INITIALIZER_FNS, QUERY_INITIALIZER_FNS, queryDecoratorNames, QueryFunctionName, tryParseInitializerApi, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer, } from './directive';
+export { extractTemplate, ExternalTemplateDeclaration, InlineTemplateDeclaration, } from './component/src/resources';
+export { DirectiveDecoratorHandler, InitializerApiFunction, INPUT_INITIALIZER_FN, MODEL_INITIALIZER_FN, OUTPUT_INITIALIZER_FNS, QUERY_INITIALIZER_FNS, queryDecoratorNames, QueryFunctionName, tryParseInitializerApi, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer, extractDecoratorQueryMetadata, parseDecoratorInputTransformFunction, } from './directive';
 export { NgModuleDecoratorHandler } from './ng_module';
 export { InjectableDecoratorHandler } from './src/injectable';
 export { PipeDecoratorHandler } from './src/pipe';

package/src/ngtsc/core/index.d.ts

@@ -7,3 +7,4 @@
  */
 export * from './src/compiler';
 export { NgCompilerHost } from './src/host';
+export { UnifiedModulesHost, NgCompilerOptions, DiagnosticCategoryLabel } from './api';

package/src/ngtsc/diagnostics/src/error_code.d.ts

@@ -145,6 +145,11 @@ export declare enum ErrorCode {
      * Raised for `@Component` fields that aren't supported in a selectorless context.
      */
     UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD = 2026,
+    /**
+     * A component is using both the `animations` property and `animate.enter` or `animate.leave`
+     * in the template.
+     */
+    COMPONENT_ANIMATIONS_CONFLICT = 2027,
     SYMBOL_NOT_EXPORTED = 3001,
     /**
      * Raised when a relationship between directives and/or pipes would cause a cyclic import to be
@@ -354,6 +359,12 @@ export declare enum ErrorCode {
      * ```
      */
     DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER = 8020,
+    /**
+     * Raised when an `@defer` block defines unreachable or redundant triggers.
+     * Examples: multiple main triggers, 'on immediate' together with other mains or any prefetch,
+     * prefetch timer delay that is not earlier than the main timer, or an identical prefetch
+     */
+    DEFER_TRIGGER_MISCONFIGURATION = 8021,
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:
@@ -526,6 +537,21 @@ export declare enum ErrorCode {
      * ```
      */
     UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = 8117,
+    /**
+     * A required initializer is being invoked in a forbidden context such as a property initializer
+     * or a constructor.
+     *
+     * For example:
+     * ```ts
+     * class MyComponent {
+     *  myInput = input.required();
+     *  somValue = this.myInput(); // Error
+     *
+     *  constructor() {
+     *    this.myInput(); // Error
+     *  }
+     */
+    FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION = 8118,
     /**
      * The template type-checking engine would need to generate an inline type check block for a
      * component, but the current type-checking environment doesn't support it.

package/src/ngtsc/diagnostics/src/error_details_base_url.d.ts

@@ -12,4 +12,4 @@
  *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
  *  - packages/core/src/error_details_base_url.ts
  */
-export declare const ERROR_DETAILS_PAGE_BASE_URL = "https://angular.dev/errors";
+export declare const ERROR_DETAILS_PAGE_BASE_URL: string;

package/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.d.ts

@@ -31,5 +31,6 @@ export declare enum ExtendedTemplateDiagnosticName {
     UNINVOKED_TRACK_FUNCTION = "uninvokedTrackFunction",
     UNUSED_STANDALONE_IMPORTS = "unusedStandaloneImports",
     UNPARENTHESIZED_NULLISH_COALESCING = "unparenthesizedNullishCoalescing",
-    UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = "uninvokedFunctionInTextInterpolation"
+    UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = "uninvokedFunctionInTextInterpolation",
+    DEFER_TRIGGER_MISCONFIGURATION = "deferTriggerMisconfiguration"
 }

package/src/ngtsc/docs/src/class_extractor.d.ts

@@ -7,9 +7,8 @@
  */
 import ts from 'typescript';
 import { MetadataReader } from '../../metadata';
-import { ClassDeclaration } from '../../reflection';
-import { ClassEntry, InterfaceEntry } from './entities';
+import { ClassEntry } from './entities';
 /** Extracts documentation info for a class, potentially including Angular-specific info.  */
-export declare function extractClass(classDeclaration: ClassDeclaration & ts.ClassDeclaration, metadataReader: MetadataReader, typeChecker: ts.TypeChecker): ClassEntry;
-/** Extracts documentation info for an interface. */
-export declare function extractInterface(declaration: ts.InterfaceDeclaration, typeChecker: ts.TypeChecker): InterfaceEntry;
+export declare function extractClass(classDeclaration: {
+    name: ts.Identifier;
+} & ts.ClassDeclaration, metadataReader: MetadataReader, typeChecker: ts.TypeChecker): ClassEntry;

package/src/ngtsc/docs/src/entities.d.ts

@@ -94,12 +94,17 @@ export interface TypeAliasEntry extends ConstantEntry {
 export interface ClassEntry extends DocEntry {
     isAbstract: boolean;
     members: MemberEntry[];
-    extends?: string;
     generics: GenericEntry[];
+    extends?: string;
     implements: string[];
 }
 /** Documentation entity for a TypeScript interface. */
-export type InterfaceEntry = ClassEntry;
+export interface InterfaceEntry extends DocEntry {
+    members: MemberEntry[];
+    generics: GenericEntry[];
+    extends: string[];
+    implements: string[];
+}
 /** Documentation entity for a TypeScript enum. */
 export interface EnumEntry extends DocEntry {
     members: EnumMemberEntry[];

package/src/ngtsc/docs/src/interface_extractor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+import ts from 'typescript';
+import { InterfaceEntry } from './entities';
+/** Extracts documentation info for an interface. */
+export declare function extractInterface(declaration: ts.InterfaceDeclaration, typeChecker: ts.TypeChecker): InterfaceEntry;

package/src/ngtsc/docs/src/properties_extractor.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @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
+ */
+import ts from 'typescript';
+import { ClassDeclaration } from '../../reflection';
+import { MemberEntry, MemberTags, MethodEntry, PropertyEntry } from './entities';
+/** A class member declaration that is *like* a property (including accessors) */
+type PropertyDeclarationLike = ts.PropertyDeclaration | ts.AccessorDeclaration;
+/** Type representing either a class declaration ro an interface declaration. */
+export type ClassDeclarationLike = ts.ClassDeclaration | ts.InterfaceDeclaration;
+/** Type representing either a class or interface member. */
+type MemberElement = ts.ClassElement | ts.TypeElement;
+/** Type representing a signature element of an interface. */
+type SignatureElement = ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration;
+/**
+ * Type representing either:
+ */
+type MethodLike = ts.MethodDeclaration | ts.MethodSignature;
+/**
+ * Type representing either a class property declaration or an interface property signature.
+ */
+type PropertyLike = PropertyDeclarationLike | ts.PropertySignature;
+/** Extractor to pull info for API reference documentation for a TypeScript class or interface. */
+export declare abstract class PropertiesExtractor {
+    protected declaration: {
+        name: ts.Identifier;
+    } & ClassDeclarationLike;
+    protected typeChecker: ts.TypeChecker;
+    constructor(declaration: {
+        name: ts.Identifier;
+    } & ClassDeclarationLike, typeChecker: ts.TypeChecker);
+    /** Extract docs info specific to classes. */
+    extract(): {
+        members: MemberEntry[];
+        generics: import("./entities").GenericEntry[];
+    };
+    /** Extracts doc info for a class's members. */
+    protected extractAllClassMembers(): MemberEntry[];
+    /** Extract docs for a class's members (methods and properties).  */
+    protected extractClassMember(memberDeclaration: MemberElement): MemberEntry | undefined;
+    /** Extract docs for all call signatures in the current class/interface. */
+    protected extractSignatures(): MemberEntry[];
+    /** Extracts docs for a class method. */
+    protected extractMethod(methodDeclaration: MethodLike): MethodEntry;
+    /** Extracts docs for a signature element (usually inside an interface). */
+    protected extractSignature(signature: SignatureElement): MethodEntry;
+    /** Extracts doc info for a property declaration. */
+    protected extractClassProperty(propertyDeclaration: PropertyLike): PropertyEntry;
+    /** Extracts doc info for an accessor member (getter/setter). */
+    protected extractGetterSetter(accessor: ts.AccessorDeclaration): PropertyEntry;
+    protected extractConstructor(constructorDeclaration: ts.ConstructorDeclaration): MethodEntry;
+    protected extractInterfaceConformance(declaration: ClassDeclaration & ClassDeclarationLike): string[];
+    /** Gets the tags for a member (protected, readonly, static, etc.) */
+    protected getMemberTags(member: MethodLike | PropertyLike | ts.ConstructorDeclaration): MemberTags[];
+    /** Computes all signature declarations of the class/interface. */
+    private computeAllSignatureDeclarations;
+    /** Gets all member declarations, including inherited members. */
+    private getMemberDeclarations;
+    /** The result only contains properties, method implementations and abstracts */
+    private filterMethodOverloads;
+    /** Get the tags for a member that come from the declaration modifiers. */
+    private getMemberTagsFromModifiers;
+    /** Gets the doc tag corresponding to a class member modifier (readonly, protected, etc.). */
+    private getTagForMemberModifier;
+    /**
+     * Gets whether a given class member should be excluded from public API docs.
+     * This is the case if:
+     *  - The member does not have a name
+     *  - The member is neither a method nor property
+     *  - The member is private
+     *  - The member has a name that marks it as Angular-internal.
+     *  - The member is marked as internal via JSDoc.
+     */
+    private isMemberExcluded;
+    /** Gets whether a class member is a method, property, or accessor. */
+    private isDocumentableMember;
+    /** Check if the parameter is a constructor parameter with a public modifier */
+    private isPublicConstructorParameterProperty;
+    /** Gets whether a member is a property. */
+    private isProperty;
+    /** Gets whether a member is a method. */
+    private isMethod;
+    /** Gets whether the given signature declaration is documentable. */
+    private isDocumentableSignature;
+    /**
+     * Check wether a member has a private computed property name like [ɵWRITABLE_SIGNAL]
+     *
+     * This will prevent exposing private computed properties in the docs.
+     */
+    private hasPrivateComputedProperty;
+}
+export {};

package/src/ngtsc/file_system/testing/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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
+ */
+export { Folder, MockFileSystem } from './src/mock_file_system';
+export { MockFileSystemNative } from './src/mock_file_system_native';
+export { MockFileSystemPosix } from './src/mock_file_system_posix';
+export { MockFileSystemWindows } from './src/mock_file_system_windows';
+export { initMockFileSystem, runInEachFileSystem, TestFile } from './src/test_helper';

package/src/ngtsc/file_system/testing/src/mock_file_system.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @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
+ */
+import { AbsoluteFsPath, FileStats, FileSystem, PathSegment, PathString } from '../../src/types';
+/**
+ * An in-memory file system that can be used in unit tests.
+ */
+export declare abstract class MockFileSystem implements FileSystem {
+    private _isCaseSensitive;
+    private _fileTree;
+    private _cwd;
+    constructor(_isCaseSensitive?: boolean, cwd?: AbsoluteFsPath);
+    isCaseSensitive(): boolean;
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    readFileBuffer(path: AbsoluteFsPath): Uint8Array;
+    writeFile(path: AbsoluteFsPath, data: string | Uint8Array, exclusive?: boolean): void;
+    removeFile(path: AbsoluteFsPath): void;
+    symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    lstat(path: AbsoluteFsPath): FileStats;
+    stat(path: AbsoluteFsPath): FileStats;
+    copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    ensureDir(path: AbsoluteFsPath): Folder;
+    removeDeep(path: AbsoluteFsPath): void;
+    isRoot(path: AbsoluteFsPath): boolean;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    realpath(filePath: AbsoluteFsPath): AbsoluteFsPath;
+    pwd(): AbsoluteFsPath;
+    chdir(path: AbsoluteFsPath): void;
+    getDefaultLibLocation(): AbsoluteFsPath;
+    abstract resolve(...paths: string[]): AbsoluteFsPath;
+    abstract dirname<T extends string>(file: T): T;
+    abstract join<T extends string>(basePath: T, ...paths: string[]): T;
+    abstract relative<T extends PathString>(from: T, to: T): PathSegment | AbsoluteFsPath;
+    abstract basename(filePath: string, extension?: string): PathSegment;
+    abstract isRooted(path: string): boolean;
+    abstract normalize<T extends PathString>(path: T): T;
+    protected abstract splitPath<T extends PathString>(path: T): string[];
+    dump(): Folder;
+    init(folder: Folder): void;
+    mount(path: AbsoluteFsPath, folder: Folder): void;
+    private cloneFolder;
+    private copyInto;
+    protected findFromPath(path: AbsoluteFsPath, options?: {
+        followSymLinks: boolean;
+    }): FindResult;
+    protected splitIntoFolderAndFile(path: AbsoluteFsPath): [AbsoluteFsPath, string];
+    protected getCanonicalPath<T extends string>(p: T): T;
+}
+export interface FindResult {
+    path: AbsoluteFsPath;
+    entity: Entity | null;
+}
+export type Entity = Folder | File | SymLink;
+export interface Folder {
+    [pathSegments: string]: Entity;
+}
+export type File = string | Uint8Array;
+export declare class SymLink {
+    path: AbsoluteFsPath;
+    constructor(path: AbsoluteFsPath);
+}
+export declare function isFile(item: Entity | null): item is File;
+export declare function isSymLink(item: Entity | null): item is SymLink;
+export declare function isFolder(item: Entity | null): item is Folder;

package/src/ngtsc/file_system/testing/src/mock_file_system_native.d.ts

@@ -0,0 +1,15 @@
+import { AbsoluteFsPath, PathSegment, PathString } from '../../src/types';
+import { MockFileSystem } from './mock_file_system';
+export declare class MockFileSystemNative extends MockFileSystem {
+    constructor(cwd?: AbsoluteFsPath);
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends string>(file: T): T;
+    join<T extends string>(basePath: T, ...paths: string[]): T;
+    relative<T extends PathString>(from: T, to: T): PathSegment | AbsoluteFsPath;
+    basename(filePath: string, extension?: string): PathSegment;
+    isCaseSensitive(): boolean;
+    isRooted(path: string): boolean;
+    isRoot(path: AbsoluteFsPath): boolean;
+    normalize<T extends PathString>(path: T): T;
+    protected splitPath<T>(path: string): string[];
+}

package/src/ngtsc/file_system/testing/src/mock_file_system_posix.d.ts

@@ -0,0 +1,12 @@
+import { AbsoluteFsPath, PathSegment, PathString } from '../../src/types';
+import { MockFileSystem } from './mock_file_system';
+export declare class MockFileSystemPosix extends MockFileSystem {
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends string>(file: T): T;
+    join<T extends string>(basePath: T, ...paths: string[]): T;
+    relative<T extends PathString>(from: T, to: T): PathSegment | AbsoluteFsPath;
+    basename(filePath: string, extension?: string): PathSegment;
+    isRooted(path: string): boolean;
+    protected splitPath<T extends PathString>(path: T): string[];
+    normalize<T extends PathString>(path: T): T;
+}

package/src/ngtsc/file_system/testing/src/mock_file_system_windows.d.ts

@@ -0,0 +1,12 @@
+import { AbsoluteFsPath, PathSegment, PathString } from '../../src/types';
+import { MockFileSystem } from './mock_file_system';
+export declare class MockFileSystemWindows extends MockFileSystem {
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends string>(path: T): T;
+    join<T extends string>(basePath: T, ...paths: string[]): T;
+    relative<T extends PathString>(from: T, to: T): PathSegment | AbsoluteFsPath;
+    basename(filePath: string, extension?: string): PathSegment;
+    isRooted(path: string): boolean;
+    protected splitPath<T extends PathString>(path: T): string[];
+    normalize<T extends PathString>(path: T): T;
+}

package/src/ngtsc/file_system/testing/src/test_helper.d.ts

@@ -0,0 +1,16 @@
+import { AbsoluteFsPath } from '../../src/types';
+import { MockFileSystem } from './mock_file_system';
+export interface TestFile {
+    name: AbsoluteFsPath;
+    contents: string;
+    isRoot?: boolean | undefined;
+}
+export interface RunInEachFileSystemFn {
+    (callback: (os: string) => void): void;
+    windows(callback: (os: string) => void): void;
+    unix(callback: (os: string) => void): void;
+    native(callback: (os: string) => void): void;
+    osX(callback: (os: string) => void): void;
+}
+export declare const runInEachFileSystem: RunInEachFileSystemFn;
+export declare function initMockFileSystem(os: string, cwd?: AbsoluteFsPath): MockFileSystem;

package/src/ngtsc/translator/src/api/ast_factory.d.ts

@@ -219,6 +219,13 @@ export interface AstFactory<TStatement, TExpression> {
      * @param type whether this variable should be declared as `var`, `let` or `const`.
      */
     createVariableDeclaration(variableName: string, initializer: TExpression | null, type: VariableDeclarationType): TStatement;
+    /**
+     * Create a regular expression literal (e.g. `/\d+/g`).
+     *
+     * @param body Body of the regex.
+     * @param flags Flags of the regex, if any.
+     */
+    createRegularExpressionLiteral(body: string, flags: string | null): TExpression;
     /**
      * Attach a source map range to the given node.
      *

package/src/ngtsc/translator/src/translator.d.ts

@@ -35,6 +35,7 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     visitTemplateLiteralExpr(ast: o.TemplateLiteralExpr, context: Context): TExpression;
     visitInstantiateExpr(ast: o.InstantiateExpr, context: Context): TExpression;
     visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
+    visitRegularExpressionLiteral(ast: o.outputAst.RegularExpressionLiteral, context: any): TExpression;
     visitLocalizedString(ast: o.LocalizedString, context: Context): TExpression;
     private createTaggedTemplateExpression;
     /**

package/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -45,6 +45,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createVoidExpression: (expression: ts.Expression) => ts.VoidExpression;
     createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
     createVariableDeclaration(variableName: string, initializer: ts.Expression | null, type: VariableDeclarationType): ts.Statement;
+    createRegularExpressionLiteral(body: string, flags: string | null): ts.Expression;
     setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
 }
 export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;

package/src/ngtsc/typecheck/api/checker.d.ts

@@ -204,6 +204,10 @@ export interface TemplateTypeChecker {
      * Retrieve the type checking engine's metadata for the given pipe class, if available.
      */
     getPipeMetadata(pipe: ts.ClassDeclaration): PipeMeta | null;
+    /**
+     * Gets the directives that apply to the given template node in a component's template.
+     */
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     /**
      * Gets the directives that have been used in a component's template.
      */

package/src/ngtsc/typecheck/extended/api/api.d.ts

@@ -55,16 +55,6 @@ export interface TemplateCheckFactory<Code extends ErrorCode, Name extends Exten
  * This abstract class provides a base implementation for the run method.
  */
 export declare abstract class TemplateCheckWithVisitor<Code extends ErrorCode> implements TemplateCheck<Code> {
-    /**
-     * When extended diagnostics were first introduced, the visitor wasn't implemented correctly
-     * which meant that it wasn't visiting the `templateAttrs` of structural directives (e.g.
-     * the expression of `*ngIf`). Fixing the issue causes a lot of internal breakages and will likely
-     * need to be done in a major version to avoid external breakages. This flag is used to opt out
-     * pre-existing diagnostics from the correct behavior until the breakages have been fixed while
-     * ensuring that newly-written diagnostics are correct from the beginning.
-     * TODO(crisbeto): remove this flag and fix the internal brekages.
-     */
-    readonly canVisitStructuralAttributes: boolean;
     abstract code: Code;
     /**
      * Base implementation for run function, visits all nodes in template and calls

package/src/ngtsc/typecheck/extended/checks/defer_trigger_misconfiguration/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.DEFER_TRIGGER_MISCONFIGURATION, ExtendedTemplateDiagnosticName.DEFER_TRIGGER_MISCONFIGURATION>;

package/src/ngtsc/typecheck/src/checker.d.ts

@@ -78,6 +78,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, ngModuleIndex: NgModuleIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
     getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     getUsedDirectives(component: ts.ClassDeclaration): TypeCheckableDirectiveMeta[] | null;
     getUsedPipes(component: ts.ClassDeclaration): string[] | null;
     private getLatestComponentState;

package/src/ngtsc/validation/src/rules/forbidden_required_initializer_invocation_rule.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * @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
+ */
+import ts from 'typescript';
+import { ImportedSymbolsTracker } from '../../../imports';
+import { ReflectionHost } from '../../../reflection';
+import { SourceFileValidatorRule } from './api';
+/**
+ * Rule that flags forbidden invocations of required initializers in property initializers and constructors.
+ */
+export declare class ForbiddenRequiredInitializersInvocationRule implements SourceFileValidatorRule {
+    private reflector;
+    private importedSymbolsTracker;
+    constructor(reflector: ReflectionHost, importedSymbolsTracker: ImportedSymbolsTracker);
+    shouldCheck(sourceFile: ts.SourceFile): boolean;
+    checkNode(node: ts.Node): ts.Diagnostic[] | null;
+    private isPropDeclarationARequiredInitializer;
+}

package/src/ngtsc/xi18n/src/context.d.ts

@@ -5,7 +5,6 @@
  * 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
  */
-import { InterpolationConfig } from '@angular/compiler';
 /**
  * Captures template information intended for extraction of i18n messages from a template.
  *
@@ -21,5 +20,5 @@ export interface Xi18nContext {
      * the return type is declared as `void` for simplicity, since any parse errors would be reported
      * as diagnostics anyway.
      */
-    updateFromTemplate(html: string, url: string, interpolationConfig: InterpolationConfig): void;
+    updateFromTemplate(html: string, url: string): void;
 }