@angular/compiler-cli 14.0.0-next.1 → 14.0.0-next.2

package/ngcc/src/packages/build_marker.d.ts

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "14.0.0-next.1";
+export declare const NGCC_VERSION = "14.0.0-next.2";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "14.0.0-next.1",
+  "version": "14.0.0-next.2",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -65,7 +65,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "14.0.0-next.1",
+    "@angular/compiler": "14.0.0-next.2",
     "typescript": ">=4.4.2 <4.6"
   },
   "repository": {

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

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common" />
+export * from './src/api';
+export * from './src/di';
+export * from './src/diagnostics';
+export * from './src/evaluation';
+export * from './src/factory';
+export * from './src/metadata';
+export * from './src/references_registry';
+export * from './src/util';

package/src/ngtsc/annotations/{src → common/src}/api.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.io/license
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/api" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/api" />
 /**
  * Resolves and loads resource files that are referenced in Angular metadata.
  *

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

@@ -0,0 +1,38 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/di" />
+import { R3DependencyMetadata } from '@angular/compiler';
+import { ClassDeclaration, CtorParameter, ReflectionHost, UnavailableValue } from '../../../reflection';
+export declare type ConstructorDeps = {
+    deps: R3DependencyMetadata[];
+} | {
+    deps: null;
+    errors: ConstructorDepError[];
+};
+export interface ConstructorDepError {
+    index: number;
+    param: CtorParameter;
+    reason: UnavailableValue;
+}
+export declare function getConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): ConstructorDeps | null;
+/**
+ * Convert `ConstructorDeps` into the `R3DependencyMetadata` array for those deps if they're valid,
+ * or into an `'invalid'` signal if they're not.
+ *
+ * This is a companion function to `validateConstructorDependencies` which accepts invalid deps.
+ */
+export declare function unwrapConstructorDependencies(deps: ConstructorDeps | null): R3DependencyMetadata[] | 'invalid' | null;
+export declare function getValidConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[] | null;
+/**
+ * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
+ * `R3DependencyMetadata` array if so, or raise a diagnostic if some deps are invalid.
+ *
+ * This is a companion function to `unwrapConstructorDependencies` which does not accept invalid
+ * deps.
+ */
+export declare function validateConstructorDependencies(clazz: ClassDeclaration, deps: ConstructorDeps | null): R3DependencyMetadata[] | null;

package/src/ngtsc/annotations/{src → common/src}/diagnostics.d.ts

@@ -5,14 +5,22 @@
  * 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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/diagnostics" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/diagnostics" />
 import ts from 'typescript';
-import { FatalDiagnosticError } from '../../diagnostics';
-import { Reference } from '../../imports';
-import { InjectableClassRegistry, MetadataReader } from '../../metadata';
-import { PartialEvaluator, ResolvedValue } from '../../partial_evaluator';
-import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { LocalModuleScopeRegistry } from '../../scope';
+import { FatalDiagnosticError } from '../../../diagnostics';
+import { Reference } from '../../../imports';
+import { InjectableClassRegistry, MetadataReader } from '../../../metadata';
+import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
+import { ClassDeclaration, ReflectionHost } from '../../../reflection';
+import { DeclarationData, LocalModuleScopeRegistry } from '../../../scope';
+/**
+ * Create a `ts.Diagnostic` which indicates the given class is part of the declarations of two or
+ * more NgModules.
+ *
+ * The resulting `ts.Diagnostic` will have a context entry for each NgModule showing the point where
+ * the directive/pipe exists in its `declarations` (if possible).
+ */
+export declare function makeDuplicateDeclarationError(node: ClassDeclaration, data: DeclarationData[], kind: string): ts.Diagnostic;
 /**
  * Creates a `FatalDiagnosticError` for a node that did not evaluate to the expected type. The
  * diagnostic that is created will include details on why the value is incorrect, i.e. it includes

package/src/ngtsc/annotations/common/src/evaluation.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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/evaluation" />
+import ts from 'typescript';
+import { Reference } from '../../../imports';
+import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
+import { ClassDeclaration, Decorator } from '../../../reflection';
+export declare function resolveEnumValue(evaluator: PartialEvaluator, metadata: Map<string, ts.Expression>, field: string, enumSymbolName: string): number | null;
+/** Determines if the result of an evaluation is a string array. */
+export declare function isStringArray(resolvedValue: ResolvedValue): resolvedValue is string[];
+export declare function isClassReferenceArray(resolvedValue: ResolvedValue): resolvedValue is Reference<ClassDeclaration>[];
+export declare function isArray(value: ResolvedValue): value is Array<ResolvedValue>;
+export declare function resolveLiteral(decorator: Decorator, literalCache: Map<Decorator, ts.ObjectLiteralExpression>): ts.ObjectLiteralExpression;

package/src/ngtsc/annotations/{src → common/src}/factory.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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/factory" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/factory" />
 import { R3FactoryMetadata } from '@angular/compiler';
-import { CompileResult } from '../../transform';
+import { CompileResult } from '../../../transform';
 export declare type CompileFactoryFn = (metadata: R3FactoryMetadata) => CompileResult;
 export declare function compileNgFactoryDefField(metadata: R3FactoryMetadata): CompileResult;
 export declare function compileDeclareFactory(metadata: R3FactoryMetadata): CompileResult;

package/src/ngtsc/annotations/{src → common/src}/metadata.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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/metadata" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/metadata" />
 import { R3ClassMetadata } from '@angular/compiler';
-import { DeclarationNode, Decorator, ReflectionHost } from '../../reflection';
+import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
 /**
  * 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

package/src/ngtsc/annotations/{src → common/src}/references_registry.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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/references_registry" />
-import { Reference } from '../../imports';
-import { DeclarationNode } from '../../reflection';
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/references_registry" />
+import { Reference } from '../../../imports';
+import { DeclarationNode } from '../../../reflection';
 /**
  * Implement this interface if you want DecoratorHandlers to register
  * references that they find in their analysis of the code.

package/src/ngtsc/annotations/{src → common/src}/util.d.ts

@@ -5,26 +5,13 @@
  * 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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/util" />
-import { Expression, FactoryTarget, ParseSourceSpan, R3CompiledExpression, R3DependencyMetadata, R3FactoryMetadata, R3Reference, Statement, WrappedNodeExpr } from '@angular/compiler';
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/util" />
+import { Expression, FactoryTarget, ParseSourceSpan, R3CompiledExpression, R3FactoryMetadata, R3Reference, Statement, WrappedNodeExpr } from '@angular/compiler';
 import ts from 'typescript';
-import { Reference, ReferenceEmitter } from '../../imports';
-import { ForeignFunctionResolver, PartialEvaluator } from '../../partial_evaluator';
-import { ClassDeclaration, CtorParameter, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference, UnavailableValue } from '../../reflection';
-import { DeclarationData } from '../../scope';
-import { CompileResult } from '../../transform';
-export declare type ConstructorDeps = {
-    deps: R3DependencyMetadata[];
-} | {
-    deps: null;
-    errors: ConstructorDepError[];
-};
-export interface ConstructorDepError {
-    index: number;
-    param: CtorParameter;
-    reason: UnavailableValue;
-}
-export declare function getConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): ConstructorDeps | null;
+import { ImportedFile, ModuleResolver, Reference, ReferenceEmitter } from '../../../imports';
+import { ForeignFunctionResolver, PartialEvaluator } from '../../../partial_evaluator';
+import { ClassDeclaration, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference } from '../../../reflection';
+import { CompileResult } from '../../../transform';
 /**
  * Convert a `TypeValueReference` to an `Expression` which refers to the type as a value.
  *
@@ -34,22 +21,6 @@ export declare function getConstructorDependencies(clazz: ClassDeclaration, refl
  */
 export declare function valueReferenceToExpression(valueRef: LocalTypeValueReference | ImportedTypeValueReference): Expression;
 export declare function valueReferenceToExpression(valueRef: TypeValueReference): Expression | null;
-/**
- * Convert `ConstructorDeps` into the `R3DependencyMetadata` array for those deps if they're valid,
- * or into an `'invalid'` signal if they're not.
- *
- * This is a companion function to `validateConstructorDependencies` which accepts invalid deps.
- */
-export declare function unwrapConstructorDependencies(deps: ConstructorDeps | null): R3DependencyMetadata[] | 'invalid' | null;
-export declare function getValidConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[] | null;
-/**
- * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
- * `R3DependencyMetadata` array if so, or raise a diagnostic if some deps are invalid.
- *
- * This is a companion function to `unwrapConstructorDependencies` which does not accept invalid
- * deps.
- */
-export declare function validateConstructorDependencies(clazz: ClassDeclaration, deps: ConstructorDeps | null): R3DependencyMetadata[] | null;
 export declare function toR3Reference(origin: ts.Node, valueRef: Reference, typeRef: Reference, valueContext: ts.SourceFile, typeContext: ts.SourceFile, refEmitter: ReferenceEmitter): R3Reference;
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
@@ -102,14 +73,6 @@ export declare function readBaseClass(node: ClassDeclaration, reflector: Reflect
  * @param expression Expression where functions should be wrapped in parentheses
  */
 export declare function wrapFunctionExpressionsInParens(expression: ts.Expression): ts.Expression;
-/**
- * Create a `ts.Diagnostic` which indicates the given class is part of the declarations of two or
- * more NgModules.
- *
- * The resulting `ts.Diagnostic` will have a context entry for each NgModule showing the point where
- * the directive/pipe exists in its `declarations` (if possible).
- */
-export declare function makeDuplicateDeclarationError(node: ClassDeclaration, data: DeclarationData[], kind: string): ts.Diagnostic;
 /**
  * Resolves the given `rawProviders` into `ClassDeclarations` and returns
  * a set containing those that are known to require a factory definition.
@@ -130,3 +93,4 @@ export declare function createSourceSpan(node: ts.Node): ParseSourceSpan;
  */
 export declare function compileResults(fac: CompileResult, def: R3CompiledExpression, metadataStmt: Statement | null, propName: string): CompileResult[];
 export declare function toFactoryMetadata(meta: Omit<R3FactoryMetadata, 'target'>, target: FactoryTarget): R3FactoryMetadata;
+export declare function resolveImportedFile(moduleResolver: ModuleResolver, importedFile: ImportedFile, expr: Expression, origin: ts.SourceFile): ts.SourceFile | null;

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

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component" />
+export { ComponentDecoratorHandler } from './src/handler';

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

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/diagnostics" />
+import ts from 'typescript';
+import { Cycle } from '../../../cycles';
+import { Reference } from '../../../imports';
+/**
+ * Generate a diagnostic related information object that describes a potential cyclic import path.
+ */
+export declare function makeCyclicImportInfo(ref: Reference, type: string, cycle: Cycle): ts.DiagnosticRelatedInformation;
+/**
+ * Checks whether a selector is a valid custom element tag name.
+ * Based loosely on https://github.com/sindresorhus/validate-element-name.
+ */
+export declare function checkCustomElementSelectorForErrors(selector: string): string | null;

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

@@ -0,0 +1,92 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/handler" />
+import { ConstantPool } from '@angular/compiler';
+import ts from 'typescript';
+import { CycleAnalyzer, CycleHandlingStrategy } from '../../../cycles';
+import { ModuleResolver, ReferenceEmitter } from '../../../imports';
+import { DependencyTracker } from '../../../incremental/api';
+import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
+import { IndexingContext } from '../../../indexer';
+import { InjectableClassRegistry, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
+import { PartialEvaluator } from '../../../partial_evaluator';
+import { PerfRecorder } from '../../../perf';
+import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
+import { ComponentScopeReader, DtsModuleScopeResolver, LocalModuleScopeRegistry, TypeCheckScopeRegistry } from '../../../scope';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence, ResolveResult } from '../../../transform';
+import { TypeCheckContext } from '../../../typecheck/api';
+import { ExtendedTemplateChecker } from '../../../typecheck/extended/api';
+import { Xi18nContext } from '../../../xi18n';
+import { ResourceLoader } from '../../common';
+import { ComponentAnalysisData, ComponentResolutionData } from './metadata';
+import { ComponentSymbol } from './symbol';
+/**
+ * `DecoratorHandler` which handles the `@Component` annotation.
+ */
+export declare class ComponentDecoratorHandler implements DecoratorHandler<Decorator, ComponentAnalysisData, ComponentSymbol, ComponentResolutionData> {
+    private reflector;
+    private evaluator;
+    private metaRegistry;
+    private metaReader;
+    private scopeReader;
+    private dtsScopeReader;
+    private scopeRegistry;
+    private typeCheckScopeRegistry;
+    private resourceRegistry;
+    private isCore;
+    private resourceLoader;
+    private rootDirs;
+    private defaultPreserveWhitespaces;
+    private i18nUseExternalIds;
+    private enableI18nLegacyMessageIdFormat;
+    private usePoisonedData;
+    private i18nNormalizeLineEndingsInICUs;
+    private moduleResolver;
+    private cycleAnalyzer;
+    private cycleHandlingStrategy;
+    private refEmitter;
+    private depTracker;
+    private injectableRegistry;
+    private semanticDepGraphUpdater;
+    private annotateForClosureCompiler;
+    private perf;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder);
+    private literalCache;
+    private elementSchemaRegistry;
+    /**
+     * 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
+     * thrown away, and the parsed template is reused during the analyze phase.
+     */
+    private preanalyzeTemplateCache;
+    private preanalyzeStylesCache;
+    private extractTemplateOptions;
+    readonly precedence = HandlerPrecedence.PRIMARY;
+    readonly name: string;
+    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;
+    preanalyze(node: ClassDeclaration, decorator: Readonly<Decorator>): Promise<void> | undefined;
+    analyze(node: ClassDeclaration, decorator: Readonly<Decorator>, flags?: HandlerFlags): AnalysisOutput<ComponentAnalysisData>;
+    symbol(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>): ComponentSymbol;
+    register(node: ClassDeclaration, analysis: ComponentAnalysisData): void;
+    index(context: IndexingContext, node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>): null | undefined;
+    typeCheck(ctx: TypeCheckContext, node: ClassDeclaration, meta: Readonly<ComponentAnalysisData>): void;
+    extendedTemplateCheck(component: ts.ClassDeclaration, extendedTemplateChecker: ExtendedTemplateChecker): ts.Diagnostic[];
+    resolve(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, symbol: ComponentSymbol): ResolveResult<ComponentResolutionData>;
+    xi18n(ctx: Xi18nContext, node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>): void;
+    updateResources(node: ClassDeclaration, analysis: ComponentAnalysisData): void;
+    compileFull(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, resolution: Readonly<ComponentResolutionData>, pool: ConstantPool): CompileResult[];
+    compilePartial(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, resolution: Readonly<ComponentResolutionData>): CompileResult[];
+    /**
+     * Check whether adding an import from `origin` to the source-file corresponding to `expr` would
+     * create a cyclic import.
+     *
+     * @returns a `Cycle` object if a cycle would be created, otherwise `null`.
+     */
+    private _checkForCyclicImport;
+    private _recordSyntheticImport;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/metadata" />
+import { AnimationTriggerNames, R3ClassMetadata, R3ComponentMetadata } from '@angular/compiler';
+import ts from 'typescript';
+import { Reference } from '../../../imports';
+import { ClassPropertyMapping, ComponentResources, DirectiveTypeCheckMeta } from '../../../metadata';
+import { ClassDeclaration } from '../../../reflection';
+import { SubsetOfKeys } from '../../../util/src/typescript';
+import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
+/**
+ * These fields of `R3ComponentMetadata` are updated in the `resolve` phase.
+ *
+ * The `keyof R3ComponentMetadata &` condition ensures that only fields of `R3ComponentMetadata` can
+ * be included here.
+ */
+export declare type ComponentMetadataResolvedFields = SubsetOfKeys<R3ComponentMetadata, 'directives' | 'pipes' | 'declarationListEmitMode'>;
+export interface ComponentAnalysisData {
+    /**
+     * `meta` includes those fields of `R3ComponentMetadata` which are calculated at `analyze` time
+     * (not during resolve).
+     */
+    meta: Omit<R3ComponentMetadata, ComponentMetadataResolvedFields>;
+    baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
+    typeCheckMeta: DirectiveTypeCheckMeta;
+    template: ParsedTemplateWithSource;
+    classMetadata: R3ClassMetadata | null;
+    inputs: ClassPropertyMapping;
+    outputs: ClassPropertyMapping;
+    /**
+     * Providers extracted from the `providers` field of the component annotation which will require
+     * an Angular factory definition at runtime.
+     */
+    providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
+    /**
+     * Providers extracted from the `viewProviders` field of the component annotation which will
+     * require an Angular factory definition at runtime.
+     */
+    viewProvidersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
+    resources: ComponentResources;
+    /**
+     * `styleUrls` extracted from the decorator, if present.
+     */
+    styleUrls: StyleUrlMeta[] | null;
+    /**
+     * Inline stylesheets extracted from the decorator, if present.
+     */
+    inlineStyles: string[] | null;
+    isPoisoned: boolean;
+    animationTriggerNames: AnimationTriggerNames | null;
+    imports: {
+        resolved: Reference<ClassDeclaration>[];
+        raw: ts.Expression;
+    } | null;
+}
+export declare type ComponentResolutionData = Pick<R3ComponentMetadata, ComponentMetadataResolvedFields>;

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

@@ -0,0 +1,123 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/resources" />
+import { InterpolationConfig, ParsedTemplate, ParseSourceFile, TmplAstNode } from '@angular/compiler';
+import ts from 'typescript';
+import { FatalDiagnosticError } from '../../../diagnostics';
+import { DependencyTracker } from '../../../incremental/api';
+import { Resource } from '../../../metadata';
+import { PartialEvaluator } from '../../../partial_evaluator';
+import { ClassDeclaration, DeclarationNode, Decorator } from '../../../reflection';
+import { TemplateSourceMapping } from '../../../typecheck/api';
+import { ResourceLoader } from '../../common';
+/**
+ * The literal style url extracted from the decorator, along with metadata for diagnostics.
+ */
+export interface StyleUrlMeta {
+    url: string;
+    nodeForError: ts.Node;
+    source: ResourceTypeForDiagnostics.StylesheetFromTemplate | ResourceTypeForDiagnostics.StylesheetFromDecorator;
+}
+/**
+ * Information about the origin of a resource in the application code. This is used for creating
+ * diagnostics, so we can point to the root cause of an error in the application code.
+ *
+ * A template resource comes from the `templateUrl` property on the component decorator.
+ *
+ * Stylesheets resources can come from either the `styleUrls` property on the component decorator,
+ * or from inline `style` tags and style links on the external template.
+ */
+export declare const enum ResourceTypeForDiagnostics {
+    Template = 0,
+    StylesheetFromTemplate = 1,
+    StylesheetFromDecorator = 2
+}
+/**
+ * Information about the template which was extracted during parsing.
+ *
+ * This contains the actual parsed template as well as any metadata collected during its parsing,
+ * some of which might be useful for re-parsing the template with different options.
+ */
+export interface ParsedComponentTemplate extends ParsedTemplate {
+    /**
+     * The template AST, parsed in a manner which preserves source map information for diagnostics.
+     *
+     * Not useful for emit.
+     */
+    diagNodes: TmplAstNode[];
+    /**
+     * The `ParseSourceFile` for the template.
+     */
+    file: ParseSourceFile;
+}
+export interface ParsedTemplateWithSource extends ParsedComponentTemplate {
+    /** The string contents of the template. */
+    content: string;
+    sourceMapping: TemplateSourceMapping;
+    declaration: TemplateDeclaration;
+}
+/**
+ * Common fields extracted from the declaration of a template.
+ */
+interface CommonTemplateDeclaration {
+    preserveWhitespaces: boolean;
+    interpolationConfig: InterpolationConfig;
+    templateUrl: string;
+    resolvedTemplateUrl: string;
+}
+/**
+ * Information extracted from the declaration of an inline template.
+ */
+export interface InlineTemplateDeclaration extends CommonTemplateDeclaration {
+    isInline: true;
+    expression: ts.Expression;
+}
+/**
+ * Information extracted from the declaration of an external template.
+ */
+export interface ExternalTemplateDeclaration extends CommonTemplateDeclaration {
+    isInline: false;
+    templateUrlExpression: ts.Expression;
+}
+/**
+ * The declaration of a template extracted from a component decorator.
+ *
+ * This data is extracted and stored separately to facilitate re-interpreting the template
+ * declaration whenever the compiler is notified of a change to a template file. With this
+ * information, `ComponentDecoratorHandler` is able to re-read the template and update the component
+ * record without needing to parse the original decorator again.
+ */
+export declare type TemplateDeclaration = InlineTemplateDeclaration | ExternalTemplateDeclaration;
+/** Determines the node to use for debugging purposes for the given TemplateDeclaration. */
+export declare function getTemplateDeclarationNodeForError(declaration: TemplateDeclaration): ts.Node;
+export interface ExtractTemplateOptions {
+    usePoisonedData: boolean;
+    enableI18nLegacyMessageIdFormat: boolean;
+    i18nNormalizeLineEndingsInICUs: boolean;
+}
+export declare function extractTemplate(node: ClassDeclaration, template: TemplateDeclaration, evaluator: PartialEvaluator, depTracker: DependencyTracker | null, resourceLoader: ResourceLoader, options: ExtractTemplateOptions): ParsedTemplateWithSource;
+export declare function parseTemplateDeclaration(decorator: Decorator, component: Map<string, ts.Expression>, containingFile: string, evaluator: PartialEvaluator, resourceLoader: ResourceLoader, defaultPreserveWhitespaces: boolean): TemplateDeclaration;
+export declare function preloadAndParseTemplate(evaluator: PartialEvaluator, resourceLoader: ResourceLoader, depTracker: DependencyTracker | null, preanalyzeTemplateCache: Map<DeclarationNode, ParsedTemplateWithSource>, node: ClassDeclaration, decorator: Decorator, component: Map<string, ts.Expression>, containingFile: string, defaultPreserveWhitespaces: boolean, options: ExtractTemplateOptions): Promise<ParsedTemplateWithSource | null>;
+export declare function makeResourceNotFoundError(file: string, nodeForError: ts.Node, resourceType: ResourceTypeForDiagnostics): FatalDiagnosticError;
+/**
+ * Transforms the given decorator to inline external resources. i.e. if the decorator
+ * resolves to `@Component`, the `templateUrl` and `styleUrls` metadata fields will be
+ * transformed to their semantically-equivalent inline variants.
+ *
+ * This method is used for serializing decorators into the class metadata. The emitted
+ * class metadata should not refer to external resources as this would be inconsistent
+ * with the component definitions/declarations which already inline external resources.
+ *
+ * Additionally, the references to external resources would require libraries to ship
+ * external resources exclusively for the class metadata.
+ */
+export declare function transformDecoratorToInlineResources(dec: Decorator, component: Map<string, ts.Expression>, styles: string[], template: ParsedTemplateWithSource): Decorator;
+export declare function extractComponentStyleUrls(evaluator: PartialEvaluator, component: Map<string, ts.Expression>): StyleUrlMeta[];
+export declare function extractStyleResources(resourceLoader: ResourceLoader, component: Map<string, ts.Expression>, containingFile: string): ReadonlySet<Resource>;
+export declare function _extractTemplateStyleUrls(template: ParsedTemplateWithSource): StyleUrlMeta[];
+export {};

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

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/scope" />
+import ts from 'typescript';
+import { DirectiveMeta, MetadataReader, PipeMeta } from '../../../metadata';
+import { ClassDeclaration } from '../../../reflection';
+import { ComponentScopeReader, DtsModuleScopeResolver, LocalModuleScopeRegistry } from '../../../scope';
+import { ComponentAnalysisData } from './metadata';
+export interface ScopeTemplateResult {
+    directives: DirectiveMeta[];
+    pipes: PipeMeta[];
+    diagnostics: ts.Diagnostic[];
+    ngModule: ClassDeclaration | null;
+}
+export declare function scopeTemplate(scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, usePoisonedData: boolean): ScopeTemplateResult | null;

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

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/symbol" />
+import { SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
+import { DirectiveSymbol } from '../../directive';
+/**
+ * Represents an Angular component.
+ */
+export declare class ComponentSymbol extends DirectiveSymbol {
+    usedDirectives: SemanticReference[];
+    usedPipes: SemanticReference[];
+    isRemotelyScoped: boolean;
+    isEmitAffected(previousSymbol: SemanticSymbol, publicApiAffected: Set<SemanticSymbol>): boolean;
+    isTypeCheckBlockAffected(previousSymbol: SemanticSymbol, typeCheckApiAffected: Set<SemanticSymbol>): boolean;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/component/src/util" />
+import { AnimationTriggerNames } from '@angular/compiler';
+import ts from 'typescript';
+import { Reference } from '../../../imports';
+import { ResolvedValue } from '../../../partial_evaluator';
+import { ClassDeclaration } from '../../../reflection';
+/**
+ * Collect the animation names from the static evaluation result.
+ * @param value the static evaluation result of the animations
+ * @param animationTriggerNames the animation names collected and whether some names could not be
+ *     statically evaluated.
+ */
+export declare function collectAnimationNames(value: ResolvedValue, animationTriggerNames: AnimationTriggerNames): void;
+export declare function validateAndFlattenComponentImports(imports: ResolvedValue, expr: ts.Expression): {
+    imports: Reference<ClassDeclaration>[];
+    diagnostics: ts.Diagnostic[];
+};