@angular/core 14.1.0-rc.0 → 14.2.0-next.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.1.0-rc.0
+ * @license Angular v14.2.0-next.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1318,6 +1318,46 @@ declare class ComponentFactoryResolver_2 extends ComponentFactoryResolver {
 
 declare type ComponentInstance = {};
 
+/**
+ * An interface that describes the subset of component metadata
+ * that can be retrieved using the `reflectComponentType` function.
+ *
+ * @publicApi
+ */
+export declare interface ComponentMirror<C> {
+    /**
+     * The component's HTML selector.
+     */
+    get selector(): string;
+    /**
+     * The type of component the factory will create.
+     */
+    get type(): Type<C>;
+    /**
+     * The inputs of the component.
+     */
+    get inputs(): ReadonlyArray<{
+        readonly propName: string;
+        readonly templateName: string;
+    }>;
+    /**
+     * The outputs of the component.
+     */
+    get outputs(): ReadonlyArray<{
+        readonly propName: string;
+        readonly templateName: string;
+    }>;
+    /**
+     * Selector for all <ng-content> elements in the component.
+     */
+    get ngContentSelectors(): ReadonlyArray<string>;
+    /**
+     * Whether this component is marked as standalone.
+     * Note: an extra flag, not present in `ComponentFactory`.
+     */
+    get isStandalone(): boolean;
+}
+
 /**
  * Represents a component created by a `ComponentFactory`.
  * Provides access to the component instance and related objects,
@@ -1618,6 +1658,72 @@ declare type ContentQueriesFunction<T> = <U extends T>(rf: ɵRenderFlags, ctx: U
 
 declare const CONTEXT = 8;
 
+/**
+ * Creates a `ComponentRef` instance based on provided component type and a set of options.
+ *
+ * @usageNotes
+ *
+ * The example below demonstrates how the `createComponent` function can be used
+ * to create an instance of a ComponentRef dynamically and attach it to an ApplicationRef,
+ * so that it gets included into change detection cycles.
+ *
+ * Note: the example uses standalone components, but the function can also be used for
+ * non-standalone components (declared in an NgModule) as well.
+ *
+ * ```typescript
+ * @Component({
+ *   standalone: true,
+ *   template: `Hello {{ name }}!`
+ * })
+ * class HelloComponent {
+ *   name = 'Angular';
+ * }
+ *
+ * @Component({
+ *   standalone: true,
+ *   template: `<div id="hello-component-host"></div>`
+ * })
+ * class RootComponent {}
+ *
+ * // Bootstrap an application.
+ * const applicationRef = await bootstrapApplication(RootComponent);
+ *
+ * // Locate a DOM node that would be used as a host.
+ * const host = document.getElementById('hello-component-host');
+ *
+ * // Get an `EnvironmentInjector` instance from the `ApplicationRef`.
+ * const environmentInjector = applicationRef.injector;
+ *
+ * // We can now create a `ComponentRef` instance.
+ * const componentRef = createComponent(HelloComponent, {host, environmentInjector});
+ *
+ * // Last step is to register the newly created ref using the `ApplicationRef` instance
+ * // to include the component view into change detection cycles.
+ * applicationRef.attachView(componentRef.hostView);
+ * ```
+ *
+ * @param component Component class reference.
+ * @param options Set of options to use:
+ *  * `environmentInjector`: An `EnvironmentInjector` instance to be used for the component, see
+ * additional info about it at https://angular.io/guide/standalone-components#environment-injectors.
+ *  * `hostElement` (optional): A DOM node that should act as a host node for the component. If not
+ * provided, Angular creates one based on the tag name used in the component selector (and falls
+ * back to using `div` if selector doesn't have tag name info).
+ *  * `elementInjector` (optional): An `ElementInjector` instance, see additional info about it at
+ * https://angular.io/guide/hierarchical-dependency-injection#elementinjector.
+ *  * `projectableNodes` (optional): A list of DOM nodes that should be projected through
+ *                      [`<ng-content>`](api/core/ng-content) of the new component instance.
+ * @returns ComponentRef instance that represents a given Component.
+ *
+ * @publicApi
+ */
+export declare function createComponent<C>(component: Type<C>, options: {
+    environmentInjector: EnvironmentInjector;
+    hostElement?: Element;
+    elementInjector?: Injector;
+    projectableNodes?: Node[][];
+}): ComponentRef<C>;
+
 /**
  * Create a new environment injector.
  *
@@ -6342,6 +6448,47 @@ declare interface RDomTokenList {
     remove(token: string): void;
 }
 
+/**
+ * Creates an object that allows to retrieve component metadata.
+ *
+ * @usageNotes
+ *
+ * The example below demonstrates how to use the function and how the fields
+ * of the returned object map to the component metadata.
+ *
+ * ```typescript
+ * @Component({
+ *   standalone: true,
+ *   selector: 'foo-component',
+ *   template: `
+ *     <ng-content></ng-content>
+ *     <ng-content select="content-selector-a"></ng-content>
+ *   `,
+ * })
+ * class FooComponent {
+ *   @Input('inputName') inputPropName: string;
+ *   @Output('outputName') outputPropName = new EventEmitter<void>();
+ * }
+ *
+ * const mirror = reflectComponentType(FooComponent);
+ * expect(mirror.type).toBe(FooComponent);
+ * expect(mirror.selector).toBe('foo-component');
+ * expect(mirror.isStandalone).toBe(true);
+ * expect(mirror.inputs).toEqual([{propName: 'inputName', templateName: 'inputPropName'}]);
+ * expect(mirror.outputs).toEqual([{propName: 'outputName', templateName: 'outputPropName'}]);
+ * expect(mirror.ngContentSelectors).toEqual([
+ *   '*',                 // first `<ng-content>` in a template, the selector defaults to `*`
+ *   'content-selector-a' // second `<ng-content>` in a template
+ * ]);
+ * ```
+ *
+ * @param component Component class reference.
+ * @returns An object that allows to retrieve component metadata.
+ *
+ * @publicApi
+ */
+export declare function reflectComponentType<C>(component: Type<C>): ComponentMirror<C> | null;
+
 /**
  * `Dependency` is used by the framework to extend DI.
  * This is internal to Angular and should not be used directly.
@@ -7083,6 +7230,7 @@ declare const enum RuntimeErrorCode {
     INJECTOR_ALREADY_DESTROYED = 205,
     PROVIDER_IN_WRONG_CONTEXT = 207,
     MISSING_INJECTION_TOKEN = 208,
+    INVALID_MULTI_PROVIDER = 209,
     MULTIPLE_COMPONENTS_MATCH = -300,
     EXPORT_NOT_FOUND = -301,
     PIPE_NOT_FOUND = -302,
@@ -10169,7 +10317,8 @@ export declare function ɵinjectChangeDetectorRef(flags: InjectFlags): ChangeDet
 export declare const ɵINJECTOR_SCOPE: InjectionToken<InjectorScope | null>;
 
 /**
- * Internal bootstrap application API that implements the core bootstrap logic.
+ * Internal create application API that implements the core application creation logic and optional
+ * bootstrap logic.
  *
  * Platforms (such as `platform-browser`) may require different set of application and platform
  * providers for an application to function correctly. As a result, platforms may use this function
@@ -10178,8 +10327,8 @@ export declare const ɵINJECTOR_SCOPE: InjectionToken<InjectorScope | null>;
  *
  * @returns A promise that returns an `ApplicationRef` instance once resolved.
  */
-export declare function ɵinternalBootstrapApplication(config: {
-    rootComponent: Type<unknown>;
+export declare function ɵinternalCreateApplication(config: {
+    rootComponent?: Type<unknown>;
     appProviders?: Array<Provider | ImportedNgModuleProviders>;
     platformProviders?: Provider[];
 }): Promise<ApplicationRef>;
@@ -10722,17 +10871,15 @@ export declare class ɵRender3ComponentRef<T> extends ComponentRef<T> {
     onDestroy(callback: () => void): void;
 }
 
-export declare class ɵRender3NgModuleRef<T> extends NgModuleRef<T> implements InternalNgModuleRef<T>, EnvironmentInjector {
+export declare class ɵRender3NgModuleRef<T> extends NgModuleRef<T> implements InternalNgModuleRef<T> {
     _parent: Injector | null;
     _bootstrapComponents: Type<any>[];
     _r3Injector: R3Injector;
-    injector: EnvironmentInjector;
     instance: T;
     destroyCbs: (() => void)[] | null;
     readonly componentFactoryResolver: ComponentFactoryResolver_2;
     constructor(ngModuleType: Type<T>, _parent: Injector | null);
-    get(token: any, notFoundValue?: any, injectFlags?: InjectFlags): any;
-    runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
+    get injector(): EnvironmentInjector;
     destroy(): void;
     onDestroy(callback: () => void): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "14.1.0-rc.0",
+  "version": "14.2.0-next.0",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/testing/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.1.0-rc.0
+ * @license Angular v14.2.0-next.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -178,13 +178,11 @@ export declare function flush(maxTurns?: number): number;
 export declare function flushMicrotasks(): void;
 
 /**
- * Returns a singleton of the applicable `TestBed`.
- *
- * It will be either an instance of `TestBedViewEngine` or `TestBedRender3`.
+ * Returns a singleton of the `TestBed` class.
  *
  * @publicApi
  */
-export declare const getTestBed: () => TestBed;
+export declare function getTestBed(): TestBed;
 
 /**
  * Allows injecting dependencies in `beforeEach()` and `it()`. Note: this function
@@ -237,7 +235,7 @@ export declare type MetadataOverride<T> = {
  * @publicApi
  */
 export declare interface ModuleTeardownOptions {
-    /** Whether the test module should be destroyed after every test. */
+    /** Whether the test module should be destroyed after every test. Defaults to `true`. */
     destroyAfterEach: boolean;
     /** Whether errors during test module destruction should be re-thrown. Defaults to `true`. */
     rethrowErrors?: boolean;
@@ -255,8 +253,8 @@ export declare function resetFakeAsyncZone(): void;
  * @publicApi
  */
 export declare interface TestBed {
-    platform: PlatformRef;
-    ngModule: Type<any> | Type<any>[];
+    get platform(): PlatformRef;
+    get ngModule(): Type<any> | Type<any>[];
     /**
      * Initialize the environment for testing with a compiler factory, a PlatformRef, and an
      * angular module. These are common to every test in the suite.
@@ -273,12 +271,12 @@ export declare interface TestBed {
      * Reset the providers for the test injector.
      */
     resetTestEnvironment(): void;
-    resetTestingModule(): void;
+    resetTestingModule(): TestBed;
     configureCompiler(config: {
         providers?: any[];
         useJit?: boolean;
     }): void;
-    configureTestingModule(moduleDef: TestModuleMetadata): void;
+    configureTestingModule(moduleDef: TestModuleMetadata): TestBed;
     compileComponents(): Promise<any>;
     inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
     inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T | null;
@@ -287,26 +285,27 @@ export declare interface TestBed {
     /** @deprecated from v9.0.0 use TestBed.inject */
     get(token: any, notFoundValue?: any): any;
     execute(tokens: any[], fn: Function, context?: any): any;
-    overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): void;
-    overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void;
-    overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): void;
-    overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): void;
+    overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBed;
+    overrideComponent(component: Type<any>, override: MetadataOverride<Component>): TestBed;
+    overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): TestBed;
+    overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBed;
+    overrideTemplate(component: Type<any>, template: string): TestBed;
     /**
      * Overwrites all providers for the given token with the given provider definition.
      */
     overrideProvider(token: any, provider: {
         useFactory: Function;
         deps: any[];
-    }): void;
+    }): TestBed;
     overrideProvider(token: any, provider: {
         useValue: any;
-    }): void;
+    }): TestBed;
     overrideProvider(token: any, provider: {
         useFactory?: Function;
         useValue?: any;
         deps?: any[];
-    }): void;
-    overrideTemplateUsingTestingModule(component: Type<any>, template: string): void;
+    }): TestBed;
+    overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBed;
     createComponent<T>(component: Type<T>): ComponentFixture<T>;
 }
 
@@ -317,92 +316,17 @@ export declare interface TestBed {
  *
  * `TestBed` is the primary api for writing unit tests for Angular applications and libraries.
  *
- * Note: Use `TestBed` in tests. It will be set to either `TestBedViewEngine` or `TestBedRender3`
- * according to the compiler used.
- *
  * @publicApi
  */
 export declare const TestBed: TestBedStatic;
 
 /**
- * Static methods implemented by the `TestBedViewEngine` and `TestBedRender3`
+ * Static methods implemented by the `TestBed`.
  *
  * @publicApi
  */
-export declare interface TestBedStatic {
+export declare interface TestBedStatic extends TestBed {
     new (...args: any[]): TestBed;
-    /**
-     * Initialize the environment for testing with a compiler factory, a PlatformRef, and an
-     * angular module. These are common to every test in the suite.
-     *
-     * This may only be called once, to set up the common providers for the current test
-     * suite on the current platform. If you absolutely need to change the providers,
-     * first use `resetTestEnvironment`.
-     *
-     * Test modules and platforms for individual platforms are available from
-     * '@angular/<platform_name>/testing'.
-     */
-    initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, options?: TestEnvironmentOptions): TestBed;
-    /**
-     * Reset the providers for the test injector.
-     */
-    resetTestEnvironment(): void;
-    resetTestingModule(): TestBedStatic;
-    /**
-     * Allows overriding default compiler providers and settings
-     * which are defined in test_injector.js
-     */
-    configureCompiler(config: {
-        providers?: any[];
-        useJit?: boolean;
-    }): TestBedStatic;
-    /**
-     * Allows overriding default providers, directives, pipes, modules of the test injector,
-     * which are defined in test_injector.js
-     */
-    configureTestingModule(moduleDef: TestModuleMetadata): TestBedStatic;
-    /**
-     * Compile components with a `templateUrl` for the test's NgModule.
-     * It is necessary to call this function
-     * as fetching urls is asynchronous.
-     */
-    compileComponents(): Promise<any>;
-    overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBedStatic;
-    overrideComponent(component: Type<any>, override: MetadataOverride<Component>): TestBedStatic;
-    overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): TestBedStatic;
-    overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBedStatic;
-    overrideTemplate(component: Type<any>, template: string): TestBedStatic;
-    /**
-     * Overrides the template of the given component, compiling the template
-     * in the context of the TestingModule.
-     *
-     * Note: This works for JIT and AOTed components as well.
-     */
-    overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBedStatic;
-    /**
-     * Overwrites all providers for the given token with the given provider definition.
-     *
-     * Note: This works for JIT and AOTed components as well.
-     */
-    overrideProvider(token: any, provider: {
-        useFactory: Function;
-        deps: any[];
-    }): TestBedStatic;
-    overrideProvider(token: any, provider: {
-        useValue: any;
-    }): TestBedStatic;
-    overrideProvider(token: any, provider: {
-        useFactory?: Function;
-        useValue?: any;
-        deps?: any[];
-    }): TestBedStatic;
-    inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
-    inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T | null;
-    /** @deprecated from v9.0.0 use TestBed.inject */
-    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;
-    /** @deprecated from v9.0.0 use TestBed.inject */
-    get(token: any, notFoundValue?: any): any;
-    createComponent<T>(component: Type<T>): ComponentFixture<T>;
 }
 
 /**