@angular/compiler-cli 14.0.0-next.9 → 14.0.0-rc.0

package/ngcc/src/dependencies/module_resolver.d.ts

@@ -65,14 +65,17 @@ export declare class ModuleResolver {
      * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`
      * folders up the tree for a matching `.../node_modules/${moduleName}`.
      *
-     * If a folder is found but the path does not contain a `package.json` then it is marked as a
-     * "deep-import".
+     * If a folder is found but the path is not considered an entry-point (see `isEntryPoint()`) then
+     * it is marked as a "deep-import".
      */
     private resolveAsEntryPoint;
     /**
      * Can we consider the given path as an entry-point to a package?
      *
      * This is achieved by checking for the existence of `${modulePath}/package.json`.
+     * If there is no `package.json`, we check whether this is an APF v14+ secondary entry-point,
+     * which does not have its own `package.json` but has an `exports` entry in the package's primary
+     * `package.json`.
      */
     private isEntryPoint;
     /**

package/ngcc/src/execution/cluster/api.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/execution/cluster/api" />
 import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
-import { JsonObject } from '../../packages/entry_point';
+import { JsonObject } from '../../utils';
 import { PackageJsonChange } from '../../writing/package_json_updater';
 import { Task, TaskProcessingOutcome } from '../tasks/api';
 /** A message reporting that the worker is ready for retrieving tasks. */

package/ngcc/src/execution/cluster/package_json_updater.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/execution/cluster/package_json_updater" />
 import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
-import { JsonObject } from '../../packages/entry_point';
+import { JsonObject } from '../../utils';
 import { PackageJsonChange, PackageJsonUpdate, PackageJsonUpdater } from '../../writing/package_json_updater';
 /**
  * A `PackageJsonUpdater` for cluster workers that will send update changes to the master process so

package/ngcc/src/execution/tasks/api.d.ts

@@ -6,8 +6,8 @@
  * 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 { EntryPoint, EntryPointJsonProperty, JsonObject } from '../../packages/entry_point';
-import { PartiallyOrderedList } from '../../utils';
+import { EntryPoint, EntryPointJsonProperty } from '../../packages/entry_point';
+import { JsonObject, PartiallyOrderedList } from '../../utils';
 /**
  * Represents a unit of work to be undertaken by an `Executor`.
  *

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.9";
+export declare const NGCC_VERSION = "14.0.0-rc.0";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

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

@@ -1,6 +1,7 @@
 /// <amd-module name="@angular/compiler-cli/ngcc/src/packages/entry_point" />
 import { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
 import { Logger } from '../../../src/ngtsc/logging';
+import { JsonObject } from '../utils';
 import { NgccConfiguration } from './configuration';
 /**
  * The possible values for the format of an entry-point.
@@ -35,13 +36,6 @@ export interface EntryPoint extends JsonObject {
     /** Should ngcc generate deep re-exports for this entrypoint? */
     generateDeepReexports: boolean;
 }
-export declare type JsonPrimitive = string | number | boolean | null;
-export declare type JsonValue = JsonPrimitive | JsonArray | JsonObject | undefined;
-export interface JsonArray extends Array<JsonValue> {
-}
-export interface JsonObject {
-    [key: string]: JsonValue;
-}
 export interface PackageJsonFormatPropertiesMap {
     browser?: string;
     fesm2015?: string;

package/ngcc/src/utils.d.ts

@@ -9,6 +9,13 @@
 import ts from 'typescript';
 import { AbsoluteFsPath, ReadonlyFileSystem } from '../../src/ngtsc/file_system';
 import { DeclarationNode, KnownDeclaration } from '../../src/ngtsc/reflection';
+export declare type JsonPrimitive = string | number | boolean | null;
+export declare type JsonValue = JsonPrimitive | JsonArray | JsonObject | undefined;
+export interface JsonArray extends Array<JsonValue> {
+}
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
 /**
  * A list (`Array`) of partially ordered `T` items.
  *
@@ -85,3 +92,22 @@ export declare function getTsHelperFnFromIdentifier(id: ts.Identifier): KnownDec
  */
 export declare function stripDollarSuffix(value: string): string;
 export declare function stripExtension(fileName: string): string;
+/**
+ * Parse the JSON from a `package.json` file.
+ *
+ * @param packageJsonPath The absolute path to the `package.json` file.
+ * @returns JSON from the `package.json` file if it exists and is valid, `null` otherwise.
+ */
+export declare function loadJson<T extends JsonObject = JsonObject>(fs: ReadonlyFileSystem, packageJsonPath: AbsoluteFsPath): T | null;
+/**
+ * Given the parsed JSON of a `package.json` file, try to extract info for a secondary entry-point
+ * from the `exports` property. Such info will only be present for packages following Angular
+ * Package Format v14+.
+ *
+ * @param primaryPackageJson The parsed JSON of the primary `package.json` (or `null` if it failed
+ *     to be loaded).
+ * @param packagePath The absolute path to the containing npm package.
+ * @param entryPointPath The absolute path to the secondary entry-point.
+ * @returns The `exports` info for the specified entry-point if it exists, `null` otherwise.
+ */
+export declare function loadSecondaryEntryPointInfoForApfV14(fs: ReadonlyFileSystem, primaryPackageJson: JsonObject | null, packagePath: AbsoluteFsPath, entryPointPath: AbsoluteFsPath): JsonObject | null;

package/ngcc/src/writing/package_json_updater.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/writing/package_json_updater" />
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
-import { JsonObject, JsonValue } from '../packages/entry_point';
+import { JsonObject, JsonValue } from '../utils';
 export declare type PackageJsonChange = [string[], JsonValue, PackageJsonPropertyPositioning];
 export declare type PackageJsonPropertyPositioning = 'unimportant' | 'alphabetic' | {
     before: string;
@@ -87,6 +87,7 @@ export declare class PackageJsonUpdate {
      */
     writeChanges(packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject): void;
     private ensureNotApplied;
+    private ensureNotSynthesized;
 }
 /** A `PackageJsonUpdater` that writes directly to the file-system. */
 export declare class DirectPackageJsonUpdater implements PackageJsonUpdater {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "14.0.0-next.9",
+  "version": "14.0.0-rc.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -65,8 +65,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "14.0.0-next.9",
-    "typescript": ">=4.6.2 <4.7"
+    "@angular/compiler": "14.0.0-rc.0",
+    "typescript": ">=4.6.2 <4.8"
   },
   "repository": {
     "type": "git",
@@ -84,7 +84,7 @@
   "bugs": {
     "url": "https://github.com/angular/angular/issues"
   },
-  "homepage": "https://github.com/angular/angular/tree/master/packages/compiler-cli",
+  "homepage": "https://github.com/angular/angular/tree/main/packages/compiler-cli",
   "ng-update": {
     "packageGroup": [
       "@angular/core",

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

@@ -13,4 +13,5 @@ export * from './src/evaluation';
 export * from './src/factory';
 export * from './src/metadata';
 export * from './src/references_registry';
+export * from './src/schema';
 export * from './src/util';

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/schema" />
+import { SchemaMetadata } from '@angular/compiler';
+import ts from 'typescript';
+import { PartialEvaluator } from '../../../partial_evaluator';
+export declare function extractSchemas(rawExpr: ts.Expression, evaluator: PartialEvaluator, context: string): SchemaMetadata[];

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

@@ -53,7 +53,7 @@ export declare function tryUnwrapForwardRef(node: ts.Expression, reflector: Refl
  * @param args the arguments to the invocation of the forwardRef expression
  * @returns an unwrapped argument if `ref` pointed to forwardRef, or null otherwise
  */
-export declare function forwardRefResolver(ref: Reference<ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>, args: ReadonlyArray<ts.Expression>): ts.Expression | null;
+export declare const forwardRefResolver: ForeignFunctionResolver;
 /**
  * Combines an array of resolver functions into a one.
  * @param resolvers Resolvers to be combined.

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

@@ -6,7 +6,7 @@
  * 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 { AnimationTriggerNames, R3ClassMetadata, R3ComponentMetadata, R3TemplateDependencyMetadata, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../../imports';
 import { ClassPropertyMapping, ComponentResources, DirectiveTypeCheckMeta } from '../../../metadata';
@@ -19,13 +19,13 @@ import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
  * The `keyof R3ComponentMetadata &` condition ensures that only fields of `R3ComponentMetadata` can
  * be included here.
  */
-export declare type ComponentMetadataResolvedFields = SubsetOfKeys<R3ComponentMetadata, 'directives' | 'pipes' | 'declarationListEmitMode'>;
+export declare type ComponentMetadataResolvedFields = SubsetOfKeys<R3ComponentMetadata<R3TemplateDependencyMetadata>, 'declarations' | 'declarationListEmitMode'>;
 export interface ComponentAnalysisData {
     /**
      * `meta` includes those fields of `R3ComponentMetadata` which are calculated at `analyze` time
      * (not during resolve).
      */
-    meta: Omit<R3ComponentMetadata, ComponentMetadataResolvedFields>;
+    meta: Omit<R3ComponentMetadata<R3TemplateDependencyMetadata>, ComponentMetadataResolvedFields>;
     baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
     typeCheckMeta: DirectiveTypeCheckMeta;
     template: ParsedTemplateWithSource;
@@ -53,9 +53,8 @@ export interface ComponentAnalysisData {
     inlineStyles: string[] | null;
     isPoisoned: boolean;
     animationTriggerNames: AnimationTriggerNames | null;
-    imports: {
-        resolved: Reference<ClassDeclaration>[];
-        raw: ts.Expression;
-    } | null;
+    rawImports: ts.Expression | null;
+    resolvedImports: Reference<ClassDeclaration>[] | null;
+    schemas: SchemaMetadata[] | null;
 }
-export declare type ComponentResolutionData = Pick<R3ComponentMetadata, ComponentMetadataResolvedFields>;
+export declare type ComponentResolutionData = Pick<R3ComponentMetadata<R3TemplateDependencyMetadata>, ComponentMetadataResolvedFields>;

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

@@ -116,7 +116,7 @@ export declare function makeResourceNotFoundError(file: string, nodeForError: ts
  * 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 transformDecoratorResources(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[];

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

@@ -20,14 +20,17 @@ import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerP
 import { ReferencesRegistry } from '../../common';
 export interface NgModuleAnalysis {
     mod: R3NgModuleMetadata;
-    inj: R3InjectorMetadata;
+    inj: Omit<R3InjectorMetadata, 'imports'>;
     fac: R3FactoryMetadata;
     classMetadata: R3ClassMetadata | null;
     declarations: Reference<ClassDeclaration>[];
     rawDeclarations: ts.Expression | null;
     schemas: SchemaMetadata[];
-    imports: Reference<ClassDeclaration>[];
+    imports: TopLevelImportedExpression[];
+    importRefs: Reference<ClassDeclaration>[];
+    rawImports: ts.Expression | null;
     exports: Reference<ClassDeclaration>[];
+    rawExports: ts.Expression | null;
     id: Expression | null;
     factorySymbolName: string;
     providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
@@ -72,11 +75,6 @@ export declare class NgModuleDecoratorHandler implements DecoratorHandler<Decora
     resolve(node: ClassDeclaration, analysis: Readonly<NgModuleAnalysis>): ResolveResult<NgModuleResolution>;
     compileFull(node: ClassDeclaration, { inj, mod, fac, classMetadata, declarations }: Readonly<NgModuleAnalysis>, { injectorImports }: Readonly<NgModuleResolution>): CompileResult[];
     compilePartial(node: ClassDeclaration, { inj, fac, mod, classMetadata }: Readonly<NgModuleAnalysis>, { injectorImports }: Readonly<NgModuleResolution>): CompileResult[];
-    /**
-     *  Merge the injector imports (which are 'exports' that were later found to be NgModules)
-     *  computed during resolution with the ones from analysis.
-     */
-    private mergeInjectorImports;
     /**
      * Add class metadata statements, if provided, to the `ngModuleStatements`.
      */
@@ -112,3 +110,8 @@ export declare class NgModuleDecoratorHandler implements DecoratorHandler<Decora
      */
     private resolveTypeList;
 }
+export interface TopLevelImportedExpression {
+    expression: ts.Expression;
+    resolvedReferences: Array<Reference<ClassDeclaration>>;
+    hasModuleWithProviders: boolean;
+}

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

@@ -23,7 +23,7 @@ export declare type ExtendedCompilerHostMethods = 'getCanonicalFileName' | 'reso
  * which is relied upon by `NgCompiler`. A consumer of `NgCompiler` can therefore use the
  * `NgCompilerHost` or implement `NgCompilerAdapter` itself.
  */
-export interface NgCompilerAdapter extends Omit<ts.ModuleResolutionHost, 'getCurrentDirectory'>, Pick<ExtendedTsCompilerHost, 'getCurrentDirectory' | ExtendedCompilerHostMethods> {
+export interface NgCompilerAdapter extends Omit<ts.ModuleResolutionHost, 'getCurrentDirectory'>, Pick<ExtendedTsCompilerHost, 'getCurrentDirectory' | ExtendedCompilerHostMethods>, SourceFileTypeIdentifier {
     /**
      * A path to a single file which represents the entrypoint of an Angular Package Format library,
      * if the current program is one.
@@ -61,6 +61,8 @@ export interface NgCompilerAdapter extends Omit<ts.ModuleResolutionHost, 'getCur
      * Resolved list of root directories explicitly set in, or inferred from, the tsconfig.
      */
     readonly rootDirs: ReadonlyArray<AbsoluteFsPath>;
+}
+export interface SourceFileTypeIdentifier {
     /**
      * Distinguishes between shim files added by Angular to the compilation process (both those
      * intended for output, like ngfactory files, as well as internal shims like ngtypecheck files)
@@ -70,4 +72,13 @@ export interface NgCompilerAdapter extends Omit<ts.ModuleResolutionHost, 'getCur
      * `true` if a file was written by the user, and `false` if a file was added by the compiler.
      */
     isShim(sf: ts.SourceFile): boolean;
+    /**
+     * Distinguishes between resource files added by Angular to the project and original files in the
+     * user's program.
+     *
+     * This is necessary only for the language service because it adds resource files as root files
+     * when they are read. This is done to indicate to TS Server that these resources are part of the
+     * project and ensures that projects are retained properly when navigating around the workspace.
+     */
+    isResource(sf: ts.SourceFile): boolean;
 }

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

@@ -36,14 +36,14 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     getModifiedResourceFiles: (() => Set<string> | undefined) | undefined;
     getNewLine: () => string;
     getParsedCommandLine: ((fileName: string) => ts.ParsedCommandLine | undefined) | undefined;
-    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
+    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
     readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
     readFile: (fileName: string) => string | undefined;
     readResource: ((fileName: string) => string | Promise<string>) | undefined;
     transformResource: ((data: string, context: import("@angular/compiler-cli/src/ngtsc/core/api/index").ResourceHostContext) => Promise<import("@angular/compiler-cli/src/ngtsc/core/api/index").TransformResourceResult | null>) | undefined;
     realpath: ((path: string) => string) | undefined;
     resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | undefined;
-    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
+    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[] | readonly ts.FileReference[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingFileMode?: ts.ModuleKind.CommonJS | ts.ModuleKind.ESNext | undefined) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
     resourceNameToFileName: ((resourceName: string, containingFilePath: string, fallbackResolve?: ((url: string, fromFile: string) => string | null) | undefined) => string | null) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
@@ -97,6 +97,13 @@ export declare class NgCompilerHost extends DelegatingCompilerHost implements Re
      * If this returns false, the file is user-provided.
      */
     isShim(sf: ts.SourceFile): boolean;
+    /**
+     * Check whether the given `ts.SourceFile` is a resource file.
+     *
+     * This simply returns `false` for the compiler-cli since resource files are not added as root
+     * files to the project.
+     */
+    isResource(sf: ts.SourceFile): boolean;
     getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined): ts.SourceFile | undefined;
     fileExists(fileName: string): boolean;
     get unifiedModulesHost(): UnifiedModulesHost | null;

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

@@ -120,6 +120,10 @@ export declare enum ErrorCode {
      * Raised when a standalone directive/pipe is part of the declarations of an NgModule.
      */
     NGMODULE_DECLARATION_IS_STANDALONE = 6008,
+    /**
+     * Raised when a standalone component is part of the bootstrap list of an NgModule.
+     */
+    NGMODULE_BOOTSTRAP_IS_STANDALONE = 6009,
     /**
      * 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

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

@@ -15,6 +15,7 @@ import { ClassPropertyMapping, ClassPropertyName } from './property_mapping';
  * Metadata collected for an `NgModule`.
  */
 export interface NgModuleMeta {
+    kind: MetaKind.NgModule;
     ref: Reference<ClassDeclaration>;
     declarations: Reference<ClassDeclaration>[];
     imports: Reference<ClassDeclaration>[];
@@ -27,6 +28,20 @@ export interface NgModuleMeta {
      * because the module came from a .d.ts file).
      */
     rawDeclarations: ts.Expression | null;
+    /**
+     * The raw `ts.Expression` which gave rise to `imports`, if one exists.
+     *
+     * If this is `null`, then either no imports exist, or no expression was available (likely
+     * because the module came from a .d.ts file).
+     */
+    rawImports: ts.Expression | null;
+    /**
+     * The raw `ts.Expression` which gave rise to `exports`, if one exists.
+     *
+     * If this is `null`, then either no exports exist, or no expression was available (likely
+     * because the module came from a .d.ts file).
+     */
+    rawExports: ts.Expression | null;
 }
 /**
  * Typing metadata collected for a directive within an NgModule's scope.
@@ -67,15 +82,19 @@ export interface DirectiveTypeCheckMeta {
      */
     isGeneric: boolean;
 }
-export declare enum MetaType {
-    Pipe = 0,
-    Directive = 1
+/**
+ * Disambiguates different kinds of compiler metadata objects.
+ */
+export declare enum MetaKind {
+    Directive = 0,
+    Pipe = 1,
+    NgModule = 2
 }
 /**
  * Metadata collected for a directive within an NgModule's scope.
  */
 export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
-    type: MetaType.Directive;
+    kind: MetaKind.Directive;
     ref: Reference<ClassDeclaration>;
     /**
      * Unparsed selector of the directive, or null if the directive does not have a selector.
@@ -110,6 +129,14 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * Whether the directive is a standalone entity.
      */
     isStandalone: boolean;
+    /**
+     * For standalone components, the list of imported types.
+     */
+    imports: Reference<ClassDeclaration>[] | null;
+    /**
+     * For standalone components, the list of schemas declared.
+     */
+    schemas: SchemaMetadata[] | null;
 }
 /**
  * Metadata that describes a template guard for one of the directive's inputs.
@@ -132,7 +159,7 @@ export interface TemplateGuardMeta {
  * Metadata for a pipe within an NgModule's scope.
  */
 export interface PipeMeta {
-    type: MetaType.Pipe;
+    kind: MetaKind.Pipe;
     ref: Reference<ClassDeclaration>;
     name: string;
     nameExpr: ts.Expression | null;

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

@@ -12,6 +12,7 @@ import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { DirectiveMeta, DirectiveTypeCheckMeta, MetadataReader, NgModuleMeta, PipeMeta } from './api';
 import { ClassPropertyMapping } from './property_mapping';
 export declare function extractReferencesFromType(checker: ts.TypeChecker, def: ts.TypeNode, bestGuessOwningModule: OwningModule | null): Reference<ClassDeclaration>[];
+export declare function readBooleanType(type: ts.TypeNode): boolean | null;
 export declare function readStringType(type: ts.TypeNode): string | null;
 export declare function readStringMapType(type: ts.TypeNode): {
     [key: string]: string;

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

@@ -11,3 +11,4 @@ export { DynamicValue } from './src/dynamic';
 export { ForeignFunctionResolver, PartialEvaluator } from './src/interface';
 export { StaticInterpreter } from './src/interpreter';
 export { EnumValue, KnownFn, ResolvedValue, ResolvedValueArray, ResolvedValueMap } from './src/result';
+export { SyntheticValue } from './src/synthetic';

package/src/ngtsc/partial_evaluator/src/dynamic.d.ts

@@ -9,6 +9,7 @@
 import ts from 'typescript';
 import { Reference } from '../../imports';
 import { FunctionDefinition } from '../../reflection';
+import { SyntheticValue } from './synthetic';
 /**
  * The reason why a value cannot be determined statically.
  */
@@ -67,10 +68,15 @@ export declare const enum DynamicValueReason {
      * 'foo', 'bar' or any arbitrary string, so we evaluate it to a DynamicValue.
      */
     DYNAMIC_TYPE = 7,
+    /**
+     * A value could not be determined because one of the inputs to its evaluation is a synthetically
+     * produced value.
+     */
+    SYNTHETIC_INPUT = 8,
     /**
      * A value could not be determined statically for any reason other the above.
      */
-    UNKNOWN = 8
+    UNKNOWN = 9
 }
 /**
  * Represents a value which cannot be determined statically.
@@ -88,6 +94,7 @@ export declare class DynamicValue<R = unknown> {
     static fromInvalidExpressionType(node: ts.Node, value: unknown): DynamicValue<unknown>;
     static fromComplexFunctionCall(node: ts.Node, fn: FunctionDefinition): DynamicValue<FunctionDefinition>;
     static fromDynamicType(node: ts.TypeNode): DynamicValue;
+    static fromSyntheticInput(node: ts.Node, value: SyntheticValue<unknown>): DynamicValue<SyntheticValue<unknown>>;
     static fromUnknown(node: ts.Node): DynamicValue;
     isFromDynamicInput(this: DynamicValue<R>): this is DynamicValue<DynamicValue>;
     isFromDynamicString(this: DynamicValue<R>): this is DynamicValue;
@@ -109,5 +116,6 @@ export interface DynamicValueVisitor<R> {
     visitInvalidExpressionType(value: DynamicValue): R;
     visitComplexFunctionCall(value: DynamicValue<FunctionDefinition>): R;
     visitDynamicType(value: DynamicValue): R;
+    visitSyntheticInput(value: DynamicValue<SyntheticValue<unknown>>): R;
     visitUnknown(value: DynamicValue): R;
 }

package/src/ngtsc/partial_evaluator/src/interface.d.ts

@@ -10,8 +10,9 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { DependencyTracker } from '../../incremental/api';
 import { ReflectionHost } from '../../reflection';
+import { DynamicValue } from './dynamic';
 import { ResolvedValue } from './result';
-export declare type ForeignFunctionResolver = (node: Reference<ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>, args: ReadonlyArray<ts.Expression>) => ts.Expression | null;
+export declare type ForeignFunctionResolver = (fn: Reference<ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>, callExpr: ts.CallExpression, resolve: (expr: ts.Expression) => ResolvedValue, unresolvable: DynamicValue) => ResolvedValue;
 export declare class PartialEvaluator {
     private host;
     private checker;

package/src/ngtsc/partial_evaluator/src/result.d.ts

@@ -10,6 +10,7 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { Declaration } from '../../reflection';
 import { DynamicValue } from './dynamic';
+import { SyntheticValue } from './synthetic';
 /**
  * A value resulting from static resolution.
  *
@@ -17,7 +18,7 @@ import { DynamicValue } from './dynamic';
  * non-primitive value, or a special `DynamicValue` type which indicates the value was not
  * available statically.
  */
-export declare type ResolvedValue = number | boolean | string | null | undefined | Reference | EnumValue | ResolvedValueArray | ResolvedValueMap | ResolvedModule | KnownFn | DynamicValue<unknown>;
+export declare type ResolvedValue = number | boolean | string | null | undefined | Reference | EnumValue | ResolvedValueArray | ResolvedValueMap | ResolvedModule | KnownFn | SyntheticValue<unknown> | DynamicValue<unknown>;
 /**
  * An array of `ResolvedValue`s.
  *

package/src/ngtsc/partial_evaluator/src/synthetic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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/partial_evaluator/src/synthetic" />
+/**
+ * A value produced which originated in a `ForeignFunctionResolver` and doesn't come from the
+ * template itself.
+ *
+ * Synthetic values cannot be further evaluated, and attempts to do so produce `DynamicValue`s
+ * instead.
+ */
+export declare class SyntheticValue<T> {
+    readonly value: T;
+    constructor(value: T);
+}

package/src/ngtsc/program_driver/src/ts_create_program_driver.d.ts

@@ -32,12 +32,12 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     getEnvironmentVariable: ((name: string) => string | undefined) | undefined;
     getNewLine: () => string;
     getParsedCommandLine: ((fileName: string) => ts.ParsedCommandLine | undefined) | undefined;
-    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
+    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
     readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
     readFile: (fileName: string) => string | undefined;
     realpath: ((path: string) => string) | undefined;
     resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | undefined;
-    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
+    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[] | readonly ts.FileReference[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingFileMode?: ts.ModuleKind.CommonJS | ts.ModuleKind.ESNext | undefined) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
     getModuleResolutionCache: (() => ts.ModuleResolutionCache | undefined) | undefined;

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

@@ -6,8 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/scope" />
-export { ExportScope, ScopeData } from './src/api';
-export { ComponentScopeReader, CompoundComponentScopeReader } from './src/component_scope';
+export { ComponentScopeKind, ComponentScopeReader, ExportScope, LocalModuleScope, ScopeData, StandaloneScope } from './src/api';
+export { CompoundComponentScopeReader } from './src/component_scope';
 export { DtsModuleScopeResolver, MetadataDtsModuleScopeResolver } from './src/dependency';
-export { DeclarationData, LocalModuleScope, LocalModuleScopeRegistry, LocalNgModuleData } from './src/local';
+export { DeclarationData, LocalModuleScopeRegistry, LocalNgModuleData } from './src/local';
 export { TypeCheckScope, TypeCheckScopeRegistry } from './src/typecheck';
+export { makeNotStandaloneDiagnostic, makeUnknownComponentImportDiagnostic } from './src/util';