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

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[];
+};

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;

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,10 @@ 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,
     /**
      * 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.

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

@@ -39,7 +39,20 @@ export declare enum ImportFlags {
      * declaration that is not retained during emit. Including this flag allows to emit references to
      * type-only declarations as used in e.g. template type-checking.
      */
-    AllowTypeImports = 4
+    AllowTypeImports = 4,
+    /**
+     * Indicates that importing from a declaration file using a relative import path is allowed.
+     *
+     * The generated imports should normally use module specifiers that are valid for use in
+     * production code, where arbitrary relative imports into e.g. node_modules are not allowed. For
+     * template type-checking code it is however acceptable to use relative imports, as such files are
+     * never emitted to JS code.
+     *
+     * Non-declaration files have to be contained within a configured `rootDir` so using relative
+     * paths may not be possible for those, hence this flag only applies when importing from a
+     * declaration file.
+     */
+    AllowRelativeDtsImports = 8
 }
 /**
  * An emitter strategy has the ability to indicate which `ts.SourceFile` is being imported by the
@@ -191,8 +204,9 @@ export declare class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
 export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
     private reflector;
     private logicalFs;
+    private relativePathStrategy;
     constructor(reflector: ReflectionHost, logicalFs: LogicalFileSystem);
-    emit(ref: Reference, context: ts.SourceFile): ReferenceEmitResult | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): ReferenceEmitResult | null;
 }
 /**
  * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.

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

@@ -120,5 +120,6 @@ export interface IndexedComponent {
         isInline: boolean;
         file: ParseSourceFile;
     };
+    errors: Error[];
 }
 export {};

package/src/ngtsc/indexer/src/template.d.ts

@@ -15,4 +15,7 @@ import { ComponentMeta } from './context';
  * @param boundTemplate bound template target, which can be used for querying expression targets.
  * @return identifiers in template
  */
-export declare function getTemplateIdentifiers(boundTemplate: BoundTarget<ComponentMeta>): Set<TopLevelIdentifier>;
+export declare function getTemplateIdentifiers(boundTemplate: BoundTarget<ComponentMeta>): {
+    identifiers: Set<TopLevelIdentifier>;
+    errors: Error[];
+};

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

@@ -106,6 +106,10 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * Whether the directive is likely a structural directive (injects `TemplateRef`).
      */
     isStructural: boolean;
+    /**
+     * Whether the directive is a standalone entity.
+     */
+    isStandalone: boolean;
 }
 /**
  * Metadata that describes a template guard for one of the directive's inputs.
@@ -132,6 +136,7 @@ export interface PipeMeta {
     ref: Reference<ClassDeclaration>;
     name: string;
     nameExpr: ts.Expression | null;
+    isStandalone: boolean;
 }
 /**
  * Reads metadata for directives, pipes, and modules from a particular source, such as .d.ts files