@angular/compiler-cli 14.0.0-next.13 → 14.0.0-next.16

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.13";
+export declare const NGCC_VERSION = "14.0.0-next.16";
 /**
  * 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.13",
+  "version": "14.0.0-next.16",
   "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.13",
-    "typescript": ">=4.6.2 <4.7"
+    "@angular/compiler": "14.0.0-next.16",
+    "typescript": ">=4.6.2 <4.8"
   },
   "repository": {
     "type": "git",

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,13 +20,14 @@ 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;
@@ -74,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`.
      */
@@ -114,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/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;

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

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

@@ -8,20 +8,13 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/scope/src/api" />
 import { SchemaMetadata } from '@angular/compiler';
 import { Reexport, Reference } from '../../imports';
-import { DirectiveMeta, PipeMeta } from '../../metadata';
+import { DirectiveMeta, NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 /**
  * Data for one of a given NgModule's scopes (either compilation scope or export scopes).
  */
 export interface ScopeData {
-    /**
-     * Directives in the exported scope of the module.
-     */
-    directives: DirectiveMeta[];
-    /**
-     * Pipes in the exported scope of the module.
-     */
-    pipes: PipeMeta[];
+    dependencies: Array<DirectiveMeta | PipeMeta>;
     /**
      * Whether some module or component in this scope contains errors and is thus semantically
      * unreliable.
@@ -52,17 +45,30 @@ export interface RemoteScope {
      */
     pipes: Reference[];
 }
+export declare enum ComponentScopeKind {
+    NgModule = 0,
+    Standalone = 1
+}
 export interface LocalModuleScope extends ExportScope {
+    kind: ComponentScopeKind.NgModule;
     ngModule: ClassDeclaration;
     compilation: ScopeData;
     reexports: Reexport[] | null;
     schemas: SchemaMetadata[];
 }
+export interface StandaloneScope {
+    kind: ComponentScopeKind.Standalone;
+    dependencies: Array<DirectiveMeta | PipeMeta | NgModuleMeta>;
+    component: ClassDeclaration;
+    schemas: SchemaMetadata[];
+    isPoisoned: boolean;
+}
+export declare type ComponentScope = LocalModuleScope | StandaloneScope;
 /**
  * Read information about the compilation scope of components.
  */
 export interface ComponentScopeReader {
-    getScopeForComponent(clazz: ClassDeclaration): LocalModuleScope | null;
+    getScopeForComponent(clazz: ClassDeclaration): ComponentScope | null;
     /**
      * Get the `RemoteScope` required for this component, if any.
      *

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

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { ClassDeclaration } from '../../reflection';
-import { ComponentScopeReader, LocalModuleScope, RemoteScope } from './api';
+import { ComponentScope, ComponentScopeReader, RemoteScope } from './api';
 /**
  * A `ComponentScopeReader` that reads from an ordered set of child readers until it obtains the
  * requested scope.
@@ -18,6 +18,6 @@ import { ComponentScopeReader, LocalModuleScope, RemoteScope } from './api';
 export declare class CompoundComponentScopeReader implements ComponentScopeReader {
     private readers;
     constructor(readers: ComponentScopeReader[]);
-    getScopeForComponent(clazz: ClassDeclaration): LocalModuleScope | null;
+    getScopeForComponent(clazz: ClassDeclaration): ComponentScope | null;
     getRemoteScope(clazz: ClassDeclaration): RemoteScope | null;
 }

package/src/ngtsc/scope/src/standalone.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/scope/src/standalone" />
+import { MetadataReader } from '../../metadata';
+import { ClassDeclaration } from '../../reflection';
+import { ComponentScopeReader, StandaloneScope } from './api';
+import { DtsModuleScopeResolver } from './dependency';
+import { LocalModuleScopeRegistry } from './local';
+/**
+ * Computes scopes for standalone components based on their `imports`, expanding imported NgModule
+ * scopes where necessary.
+ */
+export declare class StandaloneComponentScopeReader implements ComponentScopeReader {
+    private metaReader;
+    private localModuleReader;
+    private dtsModuleReader;
+    private cache;
+    constructor(metaReader: MetadataReader, localModuleReader: LocalModuleScopeRegistry, dtsModuleReader: DtsModuleScopeResolver);
+    getScopeForComponent(clazz: ClassDeclaration): StandaloneScope | null;
+    getRemoteScope(): null;
+}

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

@@ -12,3 +12,4 @@ import { ClassDeclaration } from '../../reflection';
 import { ComponentScopeReader } from './api';
 export declare function getDiagnosticNode(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null): ts.Expression;
 export declare function makeNotStandaloneDiagnostic(scopeReader: ComponentScopeReader, ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null, kind: 'component' | 'directive' | 'pipe'): ts.Diagnostic;
+export declare function makeUnknownComponentImportDiagnostic(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression): ts.DiagnosticWithLocation;

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

@@ -45,6 +45,13 @@ export declare function tsCreateVariable(id: ts.Identifier, initializer: ts.Expr
  * Construct a `ts.CallExpression` that calls a method on a receiver.
  */
 export declare function tsCallMethod(receiver: ts.Expression, methodName: string, args?: ts.Expression[]): ts.CallExpression;
+/**
+ * Updates a `ts.TypeParameter` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.7.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare function tsUpdateTypeParameterDeclaration(node: ts.TypeParameterDeclaration, name: ts.Identifier, constraint: ts.TypeNode | undefined, defaultType: ts.TypeNode | undefined): ts.TypeParameterDeclaration;
 export declare function checkIfClassIsExported(node: ClassDeclaration): boolean;
 export declare function checkIfGenericTypesAreUnbound(node: ClassDeclaration<ts.ClassDeclaration>): boolean;
 export declare function isAccessExpression(node: ts.Node): node is ts.ElementAccessExpression | ts.PropertyAccessExpression;