@angular/compiler-cli 14.0.0-next.0 → 14.0.0-next.11

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,26 @@
+/**
+ * @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 { ForeignFunctionResolver, 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 isAngularAnimationsReference(reference: Reference, symbolName: string): boolean;
+export declare const animationTriggerResolver: ForeignFunctionResolver;
+export declare function validateAndFlattenComponentImports(imports: ResolvedValue, expr: ts.Expression): {
+    imports: Reference<ClassDeclaration>[];
+    diagnostics: ts.Diagnostic[];
+};

package/src/ngtsc/annotations/directive/index.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.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/directive" />
+export { DirectiveDecoratorHandler } from './src/handler';
+export { DirectiveSymbol } from './src/symbol';
+export * from './src/shared';

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

@@ -0,0 +1,59 @@
+/**
+ * @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/directive/src/handler" />
+import { ConstantPool, R3ClassMetadata, R3DirectiveMetadata } from '@angular/compiler';
+import { Reference } from '../../../imports';
+import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta, InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { PartialEvaluator } from '../../../partial_evaluator';
+import { PerfRecorder } from '../../../perf';
+import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
+import { LocalModuleScopeRegistry } from '../../../scope';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence, ResolveResult } from '../../../transform';
+import { DirectiveSymbol } from './symbol';
+export interface DirectiveHandlerData {
+    baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
+    typeCheckMeta: DirectiveTypeCheckMeta;
+    meta: R3DirectiveMetadata;
+    classMetadata: R3ClassMetadata | null;
+    providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
+    inputs: ClassPropertyMapping;
+    outputs: ClassPropertyMapping;
+    isPoisoned: boolean;
+    isStructural: boolean;
+}
+export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decorator | null, DirectiveHandlerData, DirectiveSymbol, unknown> {
+    private reflector;
+    private evaluator;
+    private metaRegistry;
+    private scopeRegistry;
+    private metaReader;
+    private injectableRegistry;
+    private isCore;
+    private semanticDepGraphUpdater;
+    private annotateForClosureCompiler;
+    private compileUndecoratedClassesWithAngularFeatures;
+    private perf;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, isCore: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, compileUndecoratedClassesWithAngularFeatures: boolean, perf: PerfRecorder);
+    readonly precedence = HandlerPrecedence.PRIMARY;
+    readonly name: string;
+    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
+    analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>, flags?: HandlerFlags): AnalysisOutput<DirectiveHandlerData>;
+    symbol(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): DirectiveSymbol;
+    register(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): void;
+    resolve(node: ClassDeclaration, analysis: DirectiveHandlerData, symbol: DirectiveSymbol): ResolveResult<unknown>;
+    compileFull(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[];
+    compilePartial(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>): CompileResult[];
+    /**
+     * Checks if a given class uses Angular features and returns the TypeScript node
+     * that indicated the usage. Classes are considered using Angular features if they
+     * contain class members that are either decorated with a known Angular decorator,
+     * or if they correspond to a known Angular lifecycle hook.
+     */
+    private findClassFieldWithAngularFeatures;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * @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/directive/src/shared" />
+import { ParsedHostBindings, R3DirectiveMetadata, R3QueryMetadata } from '@angular/compiler';
+import ts from 'typescript';
+import { ClassPropertyMapping } from '../../../metadata';
+import { PartialEvaluator } from '../../../partial_evaluator';
+import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../../reflection';
+import { HandlerFlags } from '../../../transform';
+/**
+ * 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 | null>, reflector: ReflectionHost, evaluator: PartialEvaluator, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
+    decorator: Map<string, ts.Expression>;
+    metadata: R3DirectiveMetadata;
+    inputs: ClassPropertyMapping;
+    outputs: ClassPropertyMapping;
+    isStructural: boolean;
+} | undefined;
+export declare function extractQueryMetadata(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 parseFieldArrayValue(directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null | string[];

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

@@ -0,0 +1,27 @@
+/**
+ * @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/directive/src/symbol" />
+import { SemanticSymbol, SemanticTypeParameter } from '../../../incremental/semantic_graph';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta } from '../../../metadata';
+import { ClassDeclaration } from '../../../reflection';
+/**
+ * Represents an Angular directive. Components are represented by `ComponentSymbol`, which inherits
+ * from this symbol.
+ */
+export declare class DirectiveSymbol extends SemanticSymbol {
+    readonly selector: string | null;
+    readonly inputs: ClassPropertyMapping;
+    readonly outputs: ClassPropertyMapping;
+    readonly exportAs: string[] | null;
+    readonly typeCheckMeta: DirectiveTypeCheckMeta;
+    readonly typeParameters: SemanticTypeParameter[] | null;
+    baseClass: SemanticSymbol | null;
+    constructor(decl: ClassDeclaration, selector: string | null, inputs: ClassPropertyMapping, outputs: ClassPropertyMapping, exportAs: string[] | null, typeCheckMeta: DirectiveTypeCheckMeta, typeParameters: SemanticTypeParameter[] | null);
+    isPublicApiAffected(previousSymbol: SemanticSymbol): boolean;
+    isTypeCheckApiAffected(previousSymbol: SemanticSymbol): boolean;
+}

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

@@ -6,11 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations" />
-export { ResourceLoader, ResourceLoaderContext } from './src/api';
-export { ComponentDecoratorHandler } from './src/component';
-export { DirectiveDecoratorHandler } from './src/directive';
+export { forwardRefResolver, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext } from './common';
+export { ComponentDecoratorHandler } from './component';
+export { DirectiveDecoratorHandler } from './directive';
+export { NgModuleDecoratorHandler } from './ng_module';
 export { InjectableDecoratorHandler } from './src/injectable';
-export { NgModuleDecoratorHandler } from './src/ng_module';
 export { PipeDecoratorHandler } from './src/pipe';
-export { NoopReferencesRegistry, ReferencesRegistry } from './src/references_registry';
-export { forwardRefResolver } from './src/util';

package/src/ngtsc/annotations/ng_module/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/ng_module" />
+export { NgModuleDecoratorHandler, NgModuleSymbol } from './src/handler';

package/src/ngtsc/annotations/{src/ng_module.d.ts → ng_module/src/handler.d.ts}

@@ -5,19 +5,19 @@
  * 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/ng_module" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/ng_module/src/handler" />
 import { Expression, R3ClassMetadata, R3FactoryMetadata, R3InjectorMetadata, R3NgModuleMetadata, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { Reference, ReferenceEmitter } from '../../imports';
-import { SemanticReference, SemanticSymbol } from '../../incremental/semantic_graph';
-import { InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../metadata';
-import { PartialEvaluator } from '../../partial_evaluator';
-import { PerfRecorder } from '../../perf';
-import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
-import { LocalModuleScopeRegistry } from '../../scope';
-import { FactoryTracker } from '../../shims/api';
-import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../transform';
-import { ReferencesRegistry } from './references_registry';
+import { Reference, ReferenceEmitter } from '../../../imports';
+import { SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
+import { InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { PartialEvaluator } from '../../../partial_evaluator';
+import { PerfRecorder } from '../../../perf';
+import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
+import { LocalModuleScopeRegistry } from '../../../scope';
+import { FactoryTracker } from '../../../shims/api';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../../transform';
+import { ReferencesRegistry } from '../../common';
 export interface NgModuleAnalysis {
     mod: R3NgModuleMetadata;
     inj: R3InjectorMetadata;
@@ -27,7 +27,9 @@ export interface NgModuleAnalysis {
     rawDeclarations: ts.Expression | null;
     schemas: SchemaMetadata[];
     imports: Reference<ClassDeclaration>[];
+    rawImports: ts.Expression | null;
     exports: Reference<ClassDeclaration>[];
+    rawExports: ts.Expression | null;
     id: Expression | null;
     factorySymbolName: string;
     providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;

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

@@ -26,10 +26,6 @@ export interface TestOnlyOptions {
  * Internal only options for compiler.
  */
 export interface InternalOptions {
-    /**
-     * Whether to run all template checks and generate extended template diagnostics.
-     */
-    _extendedTemplateDiagnostics?: boolean;
 }
 /**
  * A merged interface of all of the various Angular compiler options, as well as the standard

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

@@ -47,6 +47,19 @@ export declare enum ErrorCode {
      * does not match the shadow DOM tag name requirements.
      */
     COMPONENT_INVALID_SHADOW_DOM_SELECTOR = 2009,
+    /**
+     * Raised when a component has `imports` but is not marked as `standalone: true`.
+     */
+    COMPONENT_NOT_STANDALONE = 2010,
+    /**
+     * Raised when a type in the `imports` of a component is a directive or pipe, but is not
+     * standalone.
+     */
+    COMPONENT_IMPORT_NOT_STANDALONE = 2011,
+    /**
+     * Raised when a type in the `imports` of a component is not a directive, pipe, or NgModule.
+     */
+    COMPONENT_UNKNOWN_IMPORT = 2012,
     SYMBOL_NOT_EXPORTED = 3001,
     SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,
     /**
@@ -103,6 +116,16 @@ export declare enum ErrorCode {
      * Raised when a directive/pipe is part of the declarations of two or more NgModules.
      */
     NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
+    /**
+     * Raised when a standalone directive/pipe is part of the declarations of an NgModule.
+     */
+    NGMODULE_DECLARATION_IS_STANDALONE = 6008,
+    /**
+     * Indicates that an NgModule is declared with `id: module.id`. This is an anti-pattern that is
+     * disabled explicitly in the compiler, that was originally based on a misunderstanding of
+     * `NgModule.id`.
+     */
+    WARN_NGMODULE_ID_UNNECESSARY = 6100,
     /**
      * Not actually raised by the compiler, but reserved for documentation of a View Engine error when
      * a View Engine build depends on an Ivy-compiled NgModule.