@angular/core 14.0.0-next.11 → 14.0.0-next.14

package/core.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.0.0-next.11
+ * @license Angular v14.0.0-next.14
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -400,12 +400,17 @@ export declare class ApplicationRef {
     private _zone;
     private _injector;
     private _exceptionHandler;
-    private _componentFactoryResolver;
     private _initStatus;
     private _views;
     private _runningTick;
     private _stable;
     private _onMicrotaskEmptySubscription;
+    private _destroyed;
+    private _destroyListeners;
+    /**
+     * Indicates whether this instance was destroyed.
+     */
+    get destroyed(): boolean;
     /**
      * Get a list of component types registered to this application.
      * This list is populated even before the component is created.
@@ -522,10 +527,12 @@ export declare class ApplicationRef {
      */
     detachView(viewRef: ViewRef): void;
     private _loadComponent;
+    destroy(): void;
     /**
      * Returns the number of attached views.
      */
     get viewCount(): number;
+    private warnIfDestroyed;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationRef, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationRef>;
 }
@@ -1226,7 +1233,7 @@ declare abstract class ComponentFactory<C> {
     /**
      * Creates a new component.
      */
-    abstract create(injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string | any, ngModule?: NgModuleRef<any>): ComponentRef<C>;
+    abstract create(injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string | any, environmentInjector?: EnvironmentInjector | NgModuleRef<any>): ComponentRef<C>;
 }
 export { ComponentFactory }
 export { ComponentFactory as ɵComponentFactory }
@@ -1596,6 +1603,13 @@ declare interface CreateComponentOptions {
     scheduler?: (work: () => void) => void;
 }
 
+/**
+ * Create a new environment injector.
+ *
+ * @publicApi
+ */
+export declare function createEnvironmentInjector(providers: Provider[], parent?: EnvironmentInjector | null, debugName?: string | null): EnvironmentInjector;
+
 /**
  * Returns a new NgModuleRef instance based on the NgModule class and parent injector provided.
  * @param ngModule NgModule class.
@@ -1987,6 +2001,8 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
  */
 export declare const defineInjectable: typeof ɵɵdefineInjectable;
 
+declare type DependencyTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>)[];
+
 /**
  * Array of destroy hooks that should be executed for a view and their directive indices.
  *
@@ -2314,10 +2330,6 @@ declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDef
 
 declare type DirectiveInstance = {};
 
-declare type DirectiveTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | Type<any>)[];
-
-declare type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;
-
 /**
  * @description
  * Hook for manual bootstrapping of the application instead of using `bootstrap` array in @NgModule
@@ -2510,6 +2522,25 @@ export declare abstract class EmbeddedViewRef<C> extends ViewRef {
  */
 export declare function enableProdMode(): void;
 
+/**
+ * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
+ * component tree.
+ */
+export declare abstract class EnvironmentInjector implements Injector {
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    /**
+     * @deprecated from v4.0.0 use ProviderToken<T>
+     * @suppress {duplicate}
+     */
+    abstract get(token: any, notFoundValue?: any): any;
+    abstract destroy(): void;
+}
+
 
 /**
  * Provides a hook for centralized exception handling.
@@ -3694,6 +3725,16 @@ export declare abstract class Injector {
 
 declare const INJECTOR_2 = 9;
 
+/**
+ * A multi-provider token for initialization functions that will run upon construction of a
+ * non-view injector.
+ *
+ * @publicApi
+ */
+export declare const INJECTOR_INITIALIZER: InjectionToken<() => void>;
+
+declare type InjectorScope = 'root' | 'platform' | 'environment';
+
 /**
  * A type which has an `InjectorDef` static field.
  *
@@ -5027,7 +5068,7 @@ export declare abstract class NgModuleRef<T> {
     /**
      * The injector that contains all of the providers of the `NgModule`.
      */
-    abstract get injector(): Injector;
+    abstract get injector(): EnvironmentInjector;
     /**
      * The resolver that can retrieve component factories in a context of this module.
      *
@@ -5559,10 +5600,6 @@ declare interface PipeType<T> extends Type<T> {
     ɵpipe: unknown;
 }
 
-declare type PipeTypeList = (PipeType<any> | Type<any>)[];
-
-declare type PipeTypesOrFactory = (() => PipeTypeList) | PipeTypeList;
-
 /**
  * A token that indicates an opaque platform ID.
  * @publicApi
@@ -5635,6 +5672,9 @@ export declare class PlatformRef {
      * Destroys all modules and listeners registered with the platform.
      */
     destroy(): void;
+    /**
+     * Indicates whether this instance was destroyed.
+     */
     get destroyed(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<PlatformRef, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PlatformRef>;
@@ -5962,8 +6002,9 @@ declare interface R3DeclareComponentFacade extends R3DeclareDirectiveFacade {
     template: string;
     isInline?: boolean;
     styles?: string[];
-    components?: R3DeclareUsedDirectiveFacade[];
-    directives?: R3DeclareUsedDirectiveFacade[];
+    dependencies?: R3DeclareTemplateDependencyFacade[];
+    components?: R3DeclareDirectiveDependencyFacade[];
+    directives?: R3DeclareDirectiveDependencyFacade[];
     pipes?: {
         [pipeName: string]: OpaqueValue | (() => OpaqueValue);
     };
@@ -5984,6 +6025,15 @@ declare interface R3DeclareDependencyMetadataFacade {
     skipSelf?: boolean;
 }
 
+declare interface R3DeclareDirectiveDependencyFacade {
+    kind?: 'directive' | 'component';
+    selector: string;
+    type: OpaqueValue | (() => OpaqueValue);
+    inputs?: string[];
+    outputs?: string[];
+    exportAs?: string[];
+}
+
 declare interface R3DeclareDirectiveFacade {
     selector?: string;
     type: Type_2;
@@ -6037,6 +6087,11 @@ declare interface R3DeclareInjectorFacade {
     providers?: OpaqueValue[];
 }
 
+declare interface R3DeclareNgModuleDependencyFacade {
+    kind: 'ngmodule';
+    type: OpaqueValue | (() => OpaqueValue);
+}
+
 declare interface R3DeclareNgModuleFacade {
     type: Type_2;
     bootstrap?: OpaqueValue[] | (() => OpaqueValue[]);
@@ -6047,10 +6102,17 @@ declare interface R3DeclareNgModuleFacade {
     id?: OpaqueValue;
 }
 
+declare interface R3DeclarePipeDependencyFacade {
+    kind?: 'pipe';
+    name: string;
+    type: OpaqueValue | (() => OpaqueValue);
+}
+
 declare interface R3DeclarePipeFacade {
     type: Type_2;
     name: string;
     pure?: boolean;
+    isStandalone?: boolean;
 }
 
 declare interface R3DeclareQueryMetadataFacade {
@@ -6063,42 +6125,32 @@ declare interface R3DeclareQueryMetadataFacade {
     emitDistinctChangesOnly?: boolean;
 }
 
-declare interface R3DeclareUsedDirectiveFacade {
-    selector: string;
-    type: OpaqueValue | (() => OpaqueValue);
-    inputs?: string[];
-    outputs?: string[];
-    exportAs?: string[];
-}
+declare type R3DeclareTemplateDependencyFacade = {
+    kind: string;
+} & (R3DeclareDirectiveDependencyFacade | R3DeclarePipeDependencyFacade | R3DeclareNgModuleDependencyFacade);
 
-declare class R3Injector {
+declare class R3Injector extends EnvironmentInjector {
     readonly parent: Injector;
+    readonly source: string | null;
+    readonly scopes: Set<InjectorScope>;
     /**
      * Map of tokens to records which contain the instances of those tokens.
      * - `null` value implies that we don't have the record. Used by tree-shakable injectors
      * to prevent further searches.
      */
     private records;
-    /**
-     * The transitive set of `InjectorType`s which define this injector.
-     */
-    private injectorDefTypes;
     /**
      * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
      */
-    private onDestroy;
-    /**
-     * Flag indicating this injector provides the APP_ROOT_SCOPE token, and thus counts as the
-     * root scope.
-     */
-    private readonly scope;
-    readonly source: string | null;
+    private _ngOnDestroyHooks;
+    private _onDestroyHooks;
     /**
      * Flag indicating that this injector was previously destroyed.
      */
     get destroyed(): boolean;
     private _destroyed;
-    constructor(def: InjectorType<any>, additionalProviders: StaticProvider[] | null, parent: Injector, source?: string | null);
+    private injectorDefTypes;
+    constructor(providers: Provider[], parent: Injector, source: string | null, scopes: Set<InjectorScope>);
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -6106,19 +6158,10 @@ declare class R3Injector {
      * hook was found.
      */
     destroy(): void;
+    onDestroy(callback: () => void): void;
     get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags): T;
     toString(): string;
     private assertNotDestroyed;
-    /**
-     * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers
-     * to this injector.
-     *
-     * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
-     * the function will return "true" to indicate that the providers of the type definition need
-     * to be processed. This allows us to process providers of injector types after all imports of
-     * an injector definition are processed. (following View Engine semantics: see FW-1349)
-     */
-    private processInjectorType;
     /**
      * Process a `SingleProvider` and add it.
      */
@@ -6901,8 +6944,9 @@ declare const enum RuntimeErrorCode {
     PLATFORM_NOT_FOUND = 401,
     ERROR_HANDLER_NOT_FOUND = 402,
     BOOTSTRAP_COMPONENTS_NOT_FOUND = 403,
-    ALREADY_DESTROYED_PLATFORM = 404,
+    PLATFORM_ALREADY_DESTROYED = 404,
     ASYNC_INITIALIZERS_STILL_RUNNING = 405,
+    APPLICATION_REF_ALREADY_DESTROYED = 406,
     INVALID_I18N_STRUCTURE = 700,
     INVALID_DIFFER_INPUT = 900,
     NO_SUPPORTING_DIFFER_FACTORY = 901,
@@ -8709,6 +8753,8 @@ export declare interface TypeDecorator {
     (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
 }
 
+declare type TypeOrFactory<T> = T | (() => T);
+
 /**
  * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.
  *
@@ -9040,6 +9086,10 @@ export declare abstract class ViewContainerRef {
      *  * ngModuleRef: an NgModuleRef of the component's NgModule, you should almost always provide
      *                 this to ensure that all expected providers are available for the component
      *                 instantiation.
+     *  * environmentInjector: an EnvironmentInjector which will provide the component's environment.
+     *                 you should almost always provide this to ensure that all expected providers
+     *                 are available for the component instantiation. This option is intended to
+     *                 replace the `ngModuleRef` parameter.
      *  * projectableNodes: list of DOM nodes that should be projected through
      *                      [`<ng-content>`](api/core/ng-content) of the new component instance.
      *
@@ -9049,6 +9099,7 @@ export declare abstract class ViewContainerRef {
         index?: number;
         injector?: Injector;
         ngModuleRef?: NgModuleRef<unknown>;
+        environmentInjector?: EnvironmentInjector | NgModuleRef<unknown>;
         projectableNodes?: Node[][];
     }): ComponentRef<C>;
     /**
@@ -9069,7 +9120,7 @@ export declare abstract class ViewContainerRef {
      *     Use different signature of the `createComponent` method, which allows passing
      *     Component class directly.
      */
-    abstract createComponent<C>(componentFactory: ComponentFactory<C>, index?: number, injector?: Injector, projectableNodes?: any[][], ngModuleRef?: NgModuleRef<any>): ComponentRef<C>;
+    abstract createComponent<C>(componentFactory: ComponentFactory<C>, index?: number, injector?: Injector, projectableNodes?: any[][], environmentInjector?: EnvironmentInjector | NgModuleRef<any>): ComponentRef<C>;
     /**
      * Inserts a view into this container.
      * @param viewRef The view to insert.
@@ -9204,6 +9255,10 @@ export declare function ɵ_sanitizeHtml(defaultDoc: any, unsafeHtmlInput: string
 
 export declare function ɵ_sanitizeUrl(url: string): string;
 
+/**
+ * Internal token to indicate whether having multiple bootstrapped platform should be allowed (only
+ * one bootstrapped platform is allowed by default). This token helps to support SSR scenarios.
+ */
 export declare const ɵALLOW_MULTIPLE_PLATFORMS: InjectionToken<boolean>;
 
 export declare function ɵallowSanitizationBypassAndThrow(value: any, type: ɵBypassType.Html): value is ɵSafeHtml;
@@ -9920,7 +9975,7 @@ export declare function ɵinjectChangeDetectorRef(flags: InjectFlags): ChangeDet
  * as a root scoped injector when processing requests for unknown tokens which may indicate
  * they are provided in the root scope.
  */
-export declare const ɵINJECTOR_SCOPE: InjectionToken<"root" | "platform" | null>;
+export declare const ɵINJECTOR_SCOPE: InjectionToken<InjectorScope | null>;
 
 export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
 
@@ -10432,7 +10487,7 @@ export declare class ɵRender3ComponentFactory<T> extends ComponentFactory<T> {
      * @param ngModule The NgModuleRef to which the factory is bound.
      */
     constructor(componentDef: ɵComponentDef<any>, ngModule?: NgModuleRef<any> | undefined);
-    create(injector: Injector, projectableNodes?: any[][] | undefined, rootSelectorOrNode?: any, ngModule?: NgModuleRef<any> | undefined): ComponentRef<T>;
+    create(injector: Injector, projectableNodes?: any[][] | undefined, rootSelectorOrNode?: any, environmentInjector?: NgModuleRef<any> | EnvironmentInjector | undefined): ComponentRef<T>;
 }
 
 /**
@@ -10457,11 +10512,11 @@ export declare class ɵRender3ComponentRef<T> extends ComponentRef<T> {
     onDestroy(callback: () => void): void;
 }
 
-export declare class ɵRender3NgModuleRef<T> extends NgModuleRef<T> implements InternalNgModuleRef<T> {
+export declare class ɵRender3NgModuleRef<T> extends NgModuleRef<T> implements InternalNgModuleRef<T>, EnvironmentInjector {
     _parent: Injector | null;
     _bootstrapComponents: Type<any>[];
     _r3Injector: R3Injector;
-    injector: Injector;
+    injector: EnvironmentInjector;
     instance: T;
     destroyCbs: (() => void)[] | null;
     readonly componentFactoryResolver: ComponentFactoryResolver_2;
@@ -11564,7 +11619,7 @@ export declare type ɵɵComponentDeclaration<T, Selector extends String, ExportA
     [key: string]: string;
 }, OutputMap extends {
     [key: string]: string;
-}, QueryFields extends string[], NgContentSelectors extends string[]> = unknown;
+}, QueryFields extends string[], NgContentSelectors extends string[], IsStandalone extends boolean = false> = unknown;
 
 /**
  * Registers a QueryList, associated with a content query, for later refresh (part of a view
@@ -11823,19 +11878,12 @@ export declare function ɵɵdefineComponent<T>(componentDefinition: {
      */
     changeDetection?: ChangeDetectionStrategy;
     /**
-     * Registry of directives and components that may be found in this component's view.
-     *
-     * The property is either an array of `DirectiveDef`s or a function which returns the array of
-     * `DirectiveDef`s. The function is necessary to be able to support forward declarations.
-     */
-    directives?: DirectiveTypesOrFactory | null;
-    /**
-     * Registry of pipes that may be found in this component's view.
+     * Registry of directives, components, and pipes that may be found in this component's view.
      *
-     * The property is either an array of `PipeDefs`s or a function which returns the array of
-     * `PipeDefs`s. The function is necessary to be able to support forward declarations.
+     * This property is either an array of types or a function that returns the array of types. This
+     * function may be necessary to support forward declarations.
      */
-    pipes?: PipeTypesOrFactory | null;
+    dependencies?: TypeOrFactory<DependencyTypeList>;
     /**
      * The set of schemas that declare elements to be allowed in the component's template.
      */
@@ -12008,7 +12056,7 @@ export declare const ɵɵdefineDirective: <T>(directiveDefinition: {
  */
 export declare function ɵɵdefineInjectable<T>(opts: {
     token: unknown;
-    providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'env' | null;
     factory: () => T;
 }): unknown;
 
@@ -12094,7 +12142,7 @@ export declare type ɵɵDirectiveDeclaration<T, Selector extends string, ExportA
     [key: string]: string;
 }, OutputMap extends {
     [key: string]: string;
-}, QueryFields extends string[]> = unknown;
+}, QueryFields extends string[], NgContentSelectors extends never = never, IsStandalone extends boolean = false> = unknown;
 
 /**
  * Returns the value associated to the given token from the injectors.
@@ -12456,7 +12504,7 @@ export declare interface ɵɵInjectableDeclaration<T> {
      * - `null`, does not belong to any injector. Must be explicitly listed in the injector
      *   `providers`.
      */
-    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | null;
+    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | 'environment' | null;
     /**
      * The token to which this definition belongs.
      *
@@ -12772,7 +12820,7 @@ export declare function ɵɵpipeBindV(index: number, slotOffset: number, values:
 /**
  * @publicApi
  */
-export declare type ɵɵPipeDeclaration<T, Name extends string> = unknown;
+export declare type ɵɵPipeDeclaration<T, Name extends string, IsStandalone extends boolean = false> = unknown;
 
 /**
  * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call
@@ -13627,6 +13675,13 @@ export declare function ɵɵsetNgModuleScope(type: any, scope: {
     exports?: Type<any>[] | (() => Type<any>[]);
 }): unknown;
 
+/**
+ * TODO: Implements standalone stuff!
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵStandaloneFeature(definition: ɵDirectiveDef<unknown>): void;
+
 /**
  * Update style bindings using an object literal on an element.
  *