@angular/compiler-cli 17.2.0-next.0 → 17.2.0-rc.0

package/index.d.ts

@@ -1,4 +1,5 @@
 export { VERSION } from './src/version';
+export * from './src/transformers/jit_transforms';
 export * from './src/transformers/api';
 export * from './src/transformers/entry_points';
 export * from './src/perform_compile';

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,8 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "17.2.0-next.0";
+export declare const PLACEHOLDER_VERSION = "17.2.0-rc.0";
+export declare const SHOULD_USE_TEMPLATE_PIPELINE_FOR_LINKER = false;
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "17.2.0-next.0",
+  "version": "17.2.0-rc.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -43,7 +43,7 @@
     }
   },
   "dependencies": {
-    "@babel/core": "7.23.2",
+    "@babel/core": "7.23.9",
     "@jridgewell/sourcemap-codec": "^1.4.14",
     "reflect-metadata": "^0.2.0",
     "chokidar": "^3.0.0",
@@ -53,7 +53,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "17.2.0-next.0",
+    "@angular/compiler": "17.2.0-rc.0",
     "typescript": ">=5.2 <5.4"
   },
   "repository": {

package/private/tooling.d.ts

@@ -26,26 +26,9 @@ export declare const GLOBAL_DEFS_FOR_TERSER_WITH_AOT: {
     ngI18nClosureMode: boolean;
 };
 /**
- * JIT transform for Angular applications. Used by the Angular CLI for unit tests and
- * explicit JIT applications.
+ * JIT transform used by the Angular CLI.
  *
- * The transforms include:
- *
- *  - A transform for downleveling Angular decorators and Angular-decorated class constructor
- *    parameters for dependency injection. This transform can be used by the CLI for JIT-mode
- *    compilation where constructor parameters and associated Angular decorators should be
- *    downleveled so that apps are not exposed to the ES2015 temporal dead zone limitation
- *    in TypeScript. See https://github.com/angular/angular-cli/pull/14473 for more details.
- *
- *  - A transform for adding `@Input` to signal inputs. Signal inputs cannot be recognized
- *    at runtime using reflection. That is because the class would need to be instantiated-
- *    but is not possible before creation. To fix this for JIT, a decorator is automatically
- *    added that will declare the input as a signal input while also capturing the necessary
- *    metadata
- */
-export declare function angularJitApplicationTransform(program: ts.Program, isCore?: boolean): ts.TransformerFactory<ts.SourceFile>;
-/**
- * Re-export for backwards compatibility.
- * The Angular CLI relies on this name for the transform.
+ * NOTE: Signature is explicitly captured here to highlight the
+ * contract various Angular CLI versions are relying on.
  */
-export declare const constructorParametersDownlevelTransform: typeof angularJitApplicationTransform;
+export declare const constructorParametersDownlevelTransform: (program: ts.Program, isCore?: boolean) => ts.TransformerFactory<ts.SourceFile>;

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

@@ -13,6 +13,7 @@ import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
 import { ClassDeclaration, ReflectionHost } from '../../../reflection';
 import { DeclarationData, LocalModuleScopeRegistry } from '../../../scope';
 import { InjectableClassRegistry } from './injectable_registry';
+import { CompilationMode } from '../../../transform';
 /**
  * Create a `ts.Diagnostic` which indicates the given class is part of the declarations of two or
  * more NgModules.
@@ -49,4 +50,14 @@ interface ClassWithCtor {
     isDecorated: boolean;
 }
 export declare function findInheritedCtor(node: ClassDeclaration, injectableRegistry: InjectableClassRegistry, reflector: ReflectionHost, evaluator: PartialEvaluator): ClassWithCtor | null;
+/**
+ * Throws `FatalDiagnosticError` with error code `LOCAL_COMPILATION_UNRESOLVED_CONST`
+ * if the compilation mode is local and the value is not resolved due to being imported
+ * from external files. This is a common scenario for errors in local compilation mode,
+ * and so this helper can be used to quickly generate the relevant errors.
+ *
+ * @param nodeToHighlight Node to be highlighted in teh error message.
+ * Will default to value.node if not provided.
+ */
+export declare function assertLocalCompilationUnresolvedConst(compilationMode: CompilationMode, value: ResolvedValue, nodeToHighlight: ts.Node | null, errorMessage: string): void;
 export {};

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

@@ -8,7 +8,7 @@
 import { ConstantPool } from '@angular/compiler';
 import ts from 'typescript';
 import { CycleAnalyzer, CycleHandlingStrategy } from '../../../cycles';
-import { DeferredSymbolTracker, ModuleResolver, ReferenceEmitter } from '../../../imports';
+import { DeferredSymbolTracker, LocalCompilationExtraImportsTracker, ModuleResolver, ReferenceEmitter } from '../../../imports';
 import { DependencyTracker } from '../../../incremental/api';
 import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
 import { IndexingContext } from '../../../indexer';
@@ -62,7 +62,9 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private readonly deferredSymbolTracker;
     private readonly forbidOrphanRendering;
     private readonly enableBlockSyntax;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, 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, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean);
+    private readonly useTemplatePipeline;
+    private readonly localCompilationExtraImportsTracker;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, 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, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, useTemplatePipeline: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null);
     private literalCache;
     private elementSchemaRegistry;
     /**

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

@@ -60,7 +60,10 @@ export interface ComponentAnalysisData {
     /**
      * Map of symbol name -> import path for types from `@Component.deferredImports` field.
      */
-    explicitlyDeferredTypes: Map<string, string> | null;
+    explicitlyDeferredTypes: Map<string, {
+        importPath: string;
+        isDefaultImport: boolean;
+    }> | null;
     schemas: SchemaMetadata[] | null;
     decorator: ts.Decorator | null;
     /** Additional directives applied to the component host. */

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

@@ -9,3 +9,6 @@ export { DirectiveDecoratorHandler } from './src/handler';
 export { DirectiveSymbol } from './src/symbol';
 export * from './src/shared';
 export * from './src/input_function';
+export * from './src/output_function';
+export * from './src/query_functions';
+export * from './src/model_function';

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

@@ -47,7 +47,9 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     private perf;
     private includeClassMetadata;
     private readonly compilationMode;
-    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, includeClassMetadata: boolean, compilationMode: CompilationMode);
+    private readonly useTemplatePipeline;
+    private readonly generateExtraImportsInLocalMode;
+    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, includeClassMetadata: boolean, compilationMode: CompilationMode, useTemplatePipeline: boolean, generateExtraImportsInLocalMode: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "DirectiveDecoratorHandler";
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;

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

@@ -18,7 +18,7 @@ import { ClassMember, ReflectionHost } from '../../../reflection';
  * Similarly, signal-based queries follow the same pattern and are also
  * declared through initializer APIs.
  */
-export type InitializerApiFunction = 'input' | 'viewChild' | 'viewChildren' | 'contentChild' | 'contentChildren';
+export type InitializerApiFunction = 'input' | 'model' | 'ɵoutput' | 'output' | 'viewChild' | 'viewChildren' | 'contentChild' | 'contentChildren';
 /**
  * Metadata describing an Angular class member that was recognized through
  * a function initializer. Like `input`, `input.required` or `viewChild`.

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

@@ -0,0 +1,18 @@
+/**
+ * @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.io/license
+ */
+import ts from 'typescript';
+/**
+ * Parses and validates input and output initializer function options.
+ *
+ * This currently only parses the `alias` option and returns it. The other
+ * options for signal inputs are runtime constructs that aren't relevant at
+ * compile time.
+ */
+export declare function parseAndValidateInputAndOutputOptions(optionsNode: ts.Expression): {
+    alias: string | undefined;
+};

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

@@ -0,0 +1,13 @@
+/**
+ * @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.io/license
+ */
+import { ModelMapping } from '../../../metadata';
+import { ClassMember, ReflectionHost } from '../../../reflection';
+/**
+ * Attempts to parse a model class member. Returns the parsed model mapping if possible.
+ */
+export declare function tryParseSignalModelMapping(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, isCore: boolean): ModelMapping | null;

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

@@ -0,0 +1,18 @@
+/**
+ * @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.io/license
+ */
+import ts from 'typescript';
+import { InputOrOutput } from '../../../metadata';
+import { ClassMember, ReflectionHost } from '../../../reflection';
+/**
+ * Attempts to parse a signal output class member. Returns the parsed
+ * input mapping if possible.
+ */
+export declare function tryParseInitializerBasedOutput(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, isCore: boolean): {
+    call: ts.CallExpression;
+    metadata: InputOrOutput;
+} | null;

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

@@ -9,7 +9,7 @@ import { R3QueryMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassMember, ReflectionHost } from '../../../reflection';
 /** Possible query initializer API functions. */
-type QueryFunctionName = 'viewChild' | 'contentChild' | 'viewChildren' | 'contentChildren';
+export type QueryFunctionName = 'viewChild' | 'contentChild' | 'viewChildren' | 'contentChildren';
 /**
  * Attempts to detect a possible query definition for the given class member.
  *
@@ -23,4 +23,3 @@ export declare function tryParseSignalQueryFromInitializer(member: Pick<ClassMem
     metadata: R3QueryMetadata;
     call: ts.CallExpression;
 } | null;
-export {};

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

@@ -13,13 +13,15 @@ import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
 import { ReferencesRegistry } from '../../common';
+type QueryDecoratorName = 'ViewChild' | 'ViewChildren' | 'ContentChild' | 'ContentChildren';
+export declare const queryDecoratorNames: QueryDecoratorName[];
 /**
  * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a
  * selector are allowed to be used for abstract base classes. These abstract directives should not
  * appear in the declarations of an `NgModule` and additional verification is done when processing
  * the module.
  */
-export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Readonly<Decorator>, reflector: ReflectionHost, evaluator: PartialEvaluator, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, annotateForClosureCompiler: boolean, compilationMode: CompilationMode, defaultSelector?: string | null): {
+export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Readonly<Decorator>, reflector: ReflectionHost, evaluator: PartialEvaluator, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, annotateForClosureCompiler: boolean, compilationMode: CompilationMode, defaultSelector: string | null, useTemplatePipeline: boolean): {
     decorator: Map<string, ts.Expression>;
     metadata: R3DirectiveMetadata;
     inputs: ClassPropertyMapping<InputMapping>;
@@ -29,7 +31,7 @@ export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decora
     rawHostDirectives: ts.Expression | null;
 } | undefined;
 export declare function extractDecoratorQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
-export declare function extractHostBindings(members: ClassMember[], evaluator: PartialEvaluator, coreModule: string | undefined, metadata?: Map<string, ts.Expression>): ParsedHostBindings;
+export declare function extractHostBindings(members: ClassMember[], evaluator: PartialEvaluator, coreModule: string | undefined, compilationMode: CompilationMode, metadata?: Map<string, ts.Expression>): ParsedHostBindings;
 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[];
 /**
@@ -44,3 +46,4 @@ export declare function parseFieldStringArrayValue(directive: Map<string, ts.Exp
  *
  */
 export declare function parseDecoratorInputTransformFunction(clazz: ClassDeclaration, classPropertyName: string, value: DynamicValue | Reference, reflector: ReflectionHost, refEmitter: ReferenceEmitter, compilationMode: CompilationMode): DecoratorInputTransform;
+export {};

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

@@ -5,9 +5,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export { forwardRefResolver, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext } from './common';
+export { forwardRefResolver, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext } from './common';
 export { ComponentDecoratorHandler } from './component';
-export { DirectiveDecoratorHandler, tryParseSignalInputMapping } from './directive';
+export { DirectiveDecoratorHandler, queryDecoratorNames, QueryFunctionName, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer } from './directive';
 export { NgModuleDecoratorHandler } from './ng_module';
 export { InjectableDecoratorHandler } from './src/injectable';
 export { PipeDecoratorHandler } from './src/pipe';

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

@@ -7,7 +7,7 @@
  */
 import { Expression, R3ClassMetadata, R3FactoryMetadata, R3InjectorMetadata, R3NgModuleMetadata, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { Reference, ReferenceEmitter } from '../../../imports';
+import { LocalCompilationExtraImportsTracker, Reference, ReferenceEmitter } from '../../../imports';
 import { SemanticDepGraphUpdater, SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
 import { ExportedProviderStatusResolver, MetadataReader, MetadataRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
@@ -83,7 +83,8 @@ export declare class NgModuleDecoratorHandler implements DecoratorHandler<Decora
     private includeClassMetadata;
     private includeSelectorScope;
     private readonly compilationMode;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaReader: MetadataReader, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, referencesRegistry: ReferencesRegistry, exportedProviderStatusResolver: ExportedProviderStatusResolver, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, isCore: boolean, refEmitter: ReferenceEmitter, annotateForClosureCompiler: boolean, onlyPublishPublicTypings: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder, includeClassMetadata: boolean, includeSelectorScope: boolean, compilationMode: CompilationMode);
+    private readonly localCompilationExtraImportsTracker;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaReader: MetadataReader, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, referencesRegistry: ReferencesRegistry, exportedProviderStatusResolver: ExportedProviderStatusResolver, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, isCore: boolean, refEmitter: ReferenceEmitter, annotateForClosureCompiler: boolean, onlyPublishPublicTypings: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder, includeClassMetadata: boolean, includeSelectorScope: boolean, compilationMode: CompilationMode, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "NgModuleDecoratorHandler";
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;

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

@@ -40,7 +40,8 @@ export declare class PipeDecoratorHandler implements DecoratorHandler<Decorator,
     private perf;
     private includeClassMetadata;
     private readonly compilationMode;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, injectableRegistry: InjectableClassRegistry, isCore: boolean, perf: PerfRecorder, includeClassMetadata: boolean, compilationMode: CompilationMode);
+    private readonly generateExtraImportsInLocalMode;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, injectableRegistry: InjectableClassRegistry, isCore: boolean, perf: PerfRecorder, includeClassMetadata: boolean, compilationMode: CompilationMode, generateExtraImportsInLocalMode: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "PipeDecoratorHandler";
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;

package/src/ngtsc/core/api/src/public_options.d.ts

@@ -302,6 +302,12 @@ export interface BazelAndG3Options {
      * `@defer` blocks.
      */
     onlyExplicitDeferDependencyImports?: boolean;
+    /**
+     * Generates extra imports in local compilation mode which imply the extra imports generated in
+     * full mode compilation (e.g., imports for statically resolved component dependencies). These
+     * extra imports are needed for bundling purposes in g3.
+     */
+    generateExtraImportsInLocalMode?: boolean;
 }
 /**
  * Options related to i18n compilation support.
@@ -393,4 +399,8 @@ export interface MiscOptions {
      * another library without option set will not issue error if rendered in orphan way.
      */
     forbidOrphanComponents?: boolean;
+    /**
+     * Whether to use TemplateDefinitionBuilder as the code generator, or Template Pipeline.
+     */
+    useTemplatePipeline?: boolean;
 }

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

@@ -7,12 +7,13 @@
  */
 import ts from 'typescript';
 import { ErrorCode } from './error_code';
-export declare class FatalDiagnosticError {
+export declare class FatalDiagnosticError extends Error {
     readonly code: ErrorCode;
     readonly node: ts.Node;
-    readonly message: string | ts.DiagnosticMessageChain;
+    readonly diagnosticMessage: string | ts.DiagnosticMessageChain;
     readonly relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined;
-    constructor(code: ErrorCode, node: ts.Node, message: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined);
+    constructor(code: ErrorCode, node: ts.Node, diagnosticMessage: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined);
+    message: never;
     toDiagnostic(): ts.DiagnosticWithLocation;
 }
 export declare function makeDiagnostic(code: ErrorCode, node: ts.Node, messageText: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[]): ts.DiagnosticWithLocation;

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

@@ -32,6 +32,11 @@ export declare enum ErrorCode {
      * e.g. a signal input is also declared in the `@Directive` `inputs` array.
      */
     INITIALIZER_API_DECORATOR_METADATA_COLLISION = 1051,
+    /**
+     * Raised whenever an initializer API does not support the `.required`
+     * function, but is still detected unexpectedly.
+     */
+    INITIALIZER_API_NO_REQUIRED_FUNCTION = 1052,
     /**
      * An Angular feature, like inputs, outputs or queries is incorrectly
      * declared on a static member.
@@ -408,18 +413,11 @@ export declare enum ErrorCode {
      */
     SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,
     /**
-     * A string is imported from another file to be used as template string for a component in local
-     * compilation mode.
-     */
-    LOCAL_COMPILATION_IMPORTED_TEMPLATE_STRING = 11001,
-    /**
-     * A string is imported from another file to be used as styles string for a component in local
-     * compilation mode.
+     * In local compilation mode a const is required to be resolved statically but cannot be so since it is imported from a file outside of the compilation unit. This usually happens with const being used as Angular decorators parameters such as `@Component.template`, `@HostListener.eventName`, etc.
      */
-    LOCAL_COMPILATION_IMPORTED_STYLES_STRING = 11002,
+    LOCAL_COMPILATION_UNRESOLVED_CONST = 11001,
     /**
-     * Raised when the compiler wasn't able to resolve the metadata of a host directive in local
-     * compilation mode.
+     * In local compilation mode some element in the hostDirective array is an expression (e.g., a forward ref function). This is not supported in local compilation mode as it is not a very common use case.
      */
-    LOCAL_COMPILATION_HOST_DIRECTIVE_INVALID = 11003
+    LOCAL_COMPILATION_EXPRESSION_FOR_HOST_DIRECTIVE = 11003
 }

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

@@ -101,6 +101,7 @@ export interface FunctionEntry extends DocEntry {
     params: ParameterEntry[];
     returnType: string;
     generics: GenericEntry[];
+    isNewType: boolean;
 }
 /** Sub-entry for a single class or enum member. */
 export interface MemberEntry {

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

@@ -7,11 +7,12 @@
  */
 import ts from 'typescript';
 import { FunctionEntry } from './entities';
-export type FunctionLike = ts.FunctionDeclaration | ts.MethodDeclaration | ts.MethodSignature;
+export type FunctionLike = ts.FunctionDeclaration | ts.MethodDeclaration | ts.MethodSignature | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration;
 export declare class FunctionExtractor {
+    private name;
     private declaration;
     private typeChecker;
-    constructor(declaration: FunctionLike, typeChecker: ts.TypeChecker);
+    constructor(name: string, declaration: FunctionLike, typeChecker: ts.TypeChecker);
     extract(): FunctionEntry;
     private extractAllParams;
     /** Gets all overloads for the function (excluding this extractor's FunctionDeclaration). */

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

@@ -10,6 +10,7 @@ export { ImportRewriter, NoopImportRewriter, R3SymbolsImportRewriter, validateAn
 export { DefaultImportTracker } from './src/default';
 export { DeferredSymbolTracker } from './src/deferred_symbol_tracker';
 export { AbsoluteModuleStrategy, assertSuccessfulReferenceEmit, EmittedReference, FailedEmitResult, ImportedFile, ImportFlags, LocalIdentifierStrategy, LogicalProjectStrategy, ReferenceEmitKind, ReferenceEmitResult, ReferenceEmitStrategy, ReferenceEmitter, RelativePathStrategy, UnifiedModulesStrategy } from './src/emitter';
+export { LocalCompilationExtraImportsTracker } from './src/local_compilation_extra_imports_tracker';
 export { isAliasImportDeclaration, loadIsReferencedAliasDeclarationPatch } from './src/patch_alias_reference_resolution';
 export { Reexport } from './src/reexport';
 export { OwningModule, Reference } from './src/references';

package/src/ngtsc/imports/src/local_compilation_extra_imports_tracker.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @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.io/license
+ */
+import ts from 'typescript';
+/**
+ * A tool to track extra imports to be added to the generated files in the local compilation mode.
+ *
+ * This is needed for g3 bundling mechanism which requires dev files (= locally compiled) to have
+ * imports resemble those generated for prod files (= full compilation mode). In full compilation
+ * mode Angular compiler generates extra imports for statically analyzed component dependencies. We
+ * need similar imports in local compilation as well.
+ *
+ * The tool offers API for adding local imports (to be added to a specific file) and global imports
+ * (to be added to all the files in the local compilation). For more details on how these extra
+ * imports are determined see this design doc:
+ * https://docs.google.com/document/d/1dOWoSDvOY9ozlMmyCnxoFLEzGgHmTFVRAOVdVU-bxlI/edit?tab=t.0#heading=h.5n3k516r57g5
+ *
+ * An instance of this class will be passed to each annotation handler so that they can register the
+ * extra imports that they see fit. Later on, the instance is passed to the Ivy transformer ({@link
+ * ivyTransformFactory}) and it is used to add the extra imports registered by the handlers to the
+ * import manager ({@link ImportManager}) in order to have these imports generated.
+ *
+ * The extra imports are all side effect imports, and so they are identified by a single string
+ * containing the module name.
+ *
+ */
+export declare class LocalCompilationExtraImportsTracker {
+    private readonly typeChecker;
+    private readonly localImportsMap;
+    private readonly globalImportsSet;
+    constructor(typeChecker: ts.TypeChecker);
+    /**
+     * Adds an extra import to be added to the generated file of a specific source file.
+     */
+    addImportForFile(sf: ts.SourceFile, moduleName: string): void;
+    /**
+     * If the given node is an imported identifier, this method adds the module from which it is
+     * imported as an extra import to the generated file of each source file in the compilation unit,
+     * otherwise the method is noop.
+     *
+     * Adding an extra import to all files is not optimal though. There are rooms to optimize and a
+     * add the import to a subset of files (e.g., exclude all the non Angular files as they don't need
+     * any extra import). However for this first version of this feature we go by this mechanism for
+     * simplicity. There will be on-going work to further optimize this method to add the extra import
+     * to smallest possible candidate files instead of all files.
+     */
+    addGlobalImportFromIdentifier(node: ts.Node): void;
+    /**
+     * Returns the list of all module names that the given file should include as its extra imports.
+     */
+    getImportsForFile(sf: ts.SourceFile): string[];
+}

package/src/ngtsc/metadata/src/api.d.ts

@@ -128,6 +128,15 @@ export type InputMapping = InputOrOutput & {
      */
     transform: DecoratorInputTransform | null;
 };
+/** Metadata for a model mapping. */
+export interface ModelMapping {
+    /** Node defining the model mapping. */
+    call: ts.CallExpression;
+    /** Information about the input declared by the model. */
+    input: InputMapping;
+    /** Information about the output implicitly declared by the model. */
+    output: InputOrOutput;
+}
 /** Metadata for an `@Input()` transform function. */
 export interface DecoratorInputTransform {
     /**

package/src/ngtsc/reflection/src/typescript.d.ts

@@ -72,7 +72,6 @@ export declare function filterToMembersWithDecorator(members: ClassMember[], nam
 export declare function findMember(members: ClassMember[], name: string, isStatic?: boolean): ClassMember | null;
 export declare function reflectObjectLiteral(node: ts.ObjectLiteralExpression): Map<string, ts.Expression>;
 /**
- * Return the ImportDeclaration for the given `node` if it is either an `ImportSpecifier` or a
- * `NamespaceImport`. If not return `null`.
+ * Gets the closest ancestor `ImportDeclaration` to a node.
  */
 export declare function getContainingImportDeclaration(node: ts.Node): ts.ImportDeclaration | null;

package/src/ngtsc/transform/src/transform.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { DefaultImportTracker, ImportRewriter } from '../../imports';
+import { DefaultImportTracker, ImportRewriter, LocalCompilationExtraImportsTracker } from '../../imports';
 import { PerfRecorder } from '../../perf';
 import { ReflectionHost } from '../../reflection';
 import { TraitCompiler } from './compilation';
-export declare function ivyTransformFactory(compilation: TraitCompiler, reflector: ReflectionHost, importRewriter: ImportRewriter, defaultImportTracker: DefaultImportTracker, perf: PerfRecorder, isCore: boolean, isClosureCompilerEnabled: boolean): ts.TransformerFactory<ts.SourceFile>;
+export declare function ivyTransformFactory(compilation: TraitCompiler, reflector: ReflectionHost, importRewriter: ImportRewriter, defaultImportTracker: DefaultImportTracker, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, perf: PerfRecorder, isCore: boolean, isClosureCompilerEnabled: boolean): ts.TransformerFactory<ts.SourceFile>;

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

@@ -8,7 +8,7 @@
 export { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapLocation, SourceMapRange, TemplateElement, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './src/api/ast_factory';
 export { ImportGenerator, NamedImport } from './src/api/import_generator';
 export { Context } from './src/context';
-export { Import, ImportManager } from './src/import_manager';
+export { Import, ImportManager, NamespaceImport, SideEffectImport } from './src/import_manager';
 export { ExpressionTranslatorVisitor, RecordWrappedNodeFn, TranslatorOptions } from './src/translator';
 export { canEmitType, TypeEmitter, TypeReferenceTranslator } from './src/type_emitter';
 export { translateType } from './src/type_translator';

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

@@ -9,14 +9,30 @@ import ts from 'typescript';
 import { ImportRewriter } from '../../imports';
 import { ImportGenerator, NamedImport } from './api/import_generator';
 /**
- * Information about an import that has been added to a module.
+ * Information about a namespace import that has been added to a module.
  */
-export interface Import {
+export interface NamespaceImport {
     /** The name of the module that has been imported. */
     specifier: string;
     /** The `ts.Identifier` by which the imported module is known. */
     qualifier: ts.Identifier;
 }
+/**
+ * Information about a side effect import that has been added to a module.
+ */
+export interface SideEffectImport {
+    /** The name of the module that has been imported. */
+    specifier: string;
+    /**
+     * The qualifier of a side effect import is always non-existent, and that can be used to check
+     * whether the import is side effect or not.
+     */
+    qualifier: null;
+}
+/**
+ * Information about an import that has been added to a module.
+ */
+export type Import = NamespaceImport | SideEffectImport;
 export declare class ImportManager implements ImportGenerator<ts.Identifier> {
     protected rewriter: ImportRewriter;
     private prefix;
@@ -26,5 +42,6 @@ export declare class ImportManager implements ImportGenerator<ts.Identifier> {
     constructor(rewriter?: ImportRewriter, prefix?: string, factory?: ts.NodeFactory);
     generateNamespaceImport(moduleName: string): ts.Identifier;
     generateNamedImport(moduleName: string, originalSymbol: string): NamedImport<ts.Identifier>;
+    generateSideEffectImport(moduleName: string): void;
     getAllImports(contextPath: string): Import[];
 }

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

@@ -23,7 +23,8 @@ export declare enum CommentTriviaType {
 export declare enum ExpressionIdentifier {
     DIRECTIVE = "DIR",
     COMPONENT_COMPLETION = "COMPCOMP",
-    EVENT_PARAMETER = "EP"
+    EVENT_PARAMETER = "EP",
+    VARIABLE_AS_EXPRESSION = "VAE"
 }
 /** Tags the node with the given expression identifier. */
 export declare function addExpressionIdentifier(node: ts.Node, identifier: ExpressionIdentifier): void;

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

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
+import { Import } from '../../translator';
 export declare function tsCastToAny(expr: ts.Expression): ts.Expression;
 /**
  * Create an expression which instantiates an element by its HTML tagName.
@@ -48,3 +49,4 @@ export declare function isAccessExpression(node: ts.Node): node is ts.ElementAcc
  * Creates a TypeScript node representing a numeric value.
  */
 export declare function tsNumericExpression(value: number): ts.NumericLiteral | ts.PrefixUnaryExpression;
+export declare function getImportString(imp: Import): string;