@angular/core 12.1.0-next.6 → 12.1.3

package/fesm2015/core.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.1.0-next.6
+ * @license Angular v12.1.3
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -4025,15 +4025,38 @@ var ViewEncapsulation$1;
  * 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
  */
-function getCompilerFacade() {
+function getCompilerFacade(request) {
     const globalNg = _global['ng'];
-    if (!globalNg || !globalNg.ɵcompilerFacade) {
-        throw new Error(`Angular JIT compilation failed: '@angular/compiler' not loaded!\n` +
-            `  - JIT compilation is discouraged for production use-cases! Consider AOT mode instead.\n` +
-            `  - Did you bootstrap using '@angular/platform-browser-dynamic' or '@angular/platform-server'?\n` +
-            `  - Alternatively provide the compiler with 'import "@angular/compiler";' before bootstrapping.`);
+    if (globalNg && globalNg.ɵcompilerFacade) {
+        return globalNg.ɵcompilerFacade;
+    }
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        // Log the type as an error so that a developer can easily navigate to the type from the
+        // console.
+        console.error(`JIT compilation failed for ${request.kind}`, request.type);
+        let message = `The ${request.kind} '${request
+            .type.name}' needs to be compiled using the JIT compiler, but '@angular/compiler' is not available.\n\n`;
+        if (request.usage === 1 /* PartialDeclaration */) {
+            message += `The ${request.kind} is part of a library that has been partially compiled.\n`;
+            message +=
+                `However, the Angular Linker has not processed the library such that JIT compilation is used as fallback.\n`;
+            message += '\n';
+            message +=
+                `Ideally, the library is processed using the Angular Linker to become fully AOT compiled.\n`;
+        }
+        else {
+            message +=
+                `JIT compilation is discouraged for production use-cases! Consider using AOT mode instead.\n`;
+        }
+        message +=
+            `Alternatively, the JIT compiler should be loaded by bootstrapping using '@angular/platform-browser-dynamic' or '@angular/platform-server',\n`;
+        message +=
+            `or manually provide the compiler with 'import "@angular/compiler";' before bootstrapping.`;
+        throw new Error(message);
+    }
+    else {
+        throw new Error('JIT compiler unavailable');
     }
-    return globalNg.ɵcompilerFacade;
 }
 
 /**
@@ -6511,11 +6534,7 @@ class ErrorHandler {
     }
     /** @internal */
     _findContext(error) {
-        if (error) {
-            return getDebugContext(error) ? getDebugContext(error) :
-                this._findContext(getOriginalError(error));
-        }
-        return null;
+        return error ? (getDebugContext(error) || this._findContext(getOriginalError(error))) : null;
     }
     /** @internal */
     _findOriginalError(error) {
@@ -11212,6 +11231,7 @@ class R3Injector {
         this.assertNotDestroyed();
         // Set the injection context.
         const previousInjector = setCurrentInjector(this);
+        const previousInjectImplementation = setInjectImplementation(undefined);
         try {
             // Check for the SkipSelf flag.
             if (!(flags & InjectFlags.SkipSelf)) {
@@ -11264,7 +11284,8 @@ class R3Injector {
             }
         }
         finally {
-            // Lastly, clean up the state by restoring the previous injector.
+            // Lastly, restore the previous injection context.
+            setInjectImplementation(previousInjectImplementation);
             setCurrentInjector(previousInjector);
         }
     }
@@ -13673,7 +13694,8 @@ function compileInjectable(type, meta) {
         Object.defineProperty(type, NG_PROV_DEF, {
             get: () => {
                 if (ngInjectableDef === null) {
-                    ngInjectableDef = getCompilerFacade().compileInjectable(angularCoreDiEnv, `ng:///${type.name}/ɵprov.js`, getInjectableMetadata(type, meta));
+                    const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'injectable', type });
+                    ngInjectableDef = compiler.compileInjectable(angularCoreDiEnv, `ng:///${type.name}/ɵprov.js`, getInjectableMetadata(type, meta));
                 }
                 return ngInjectableDef;
             },
@@ -13684,7 +13706,7 @@ function compileInjectable(type, meta) {
         Object.defineProperty(type, NG_FACTORY_DEF, {
             get: () => {
                 if (ngFactoryDef === null) {
-                    const compiler = getCompilerFacade();
+                    const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'injectable', type });
                     ngFactoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/ɵfac.js`, {
                         name: type.name,
                         type,
@@ -21469,7 +21491,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('12.1.0-next.6');
+const VERSION = new Version('12.1.3');
 
 /**
  * @license
@@ -26928,7 +26950,8 @@ function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInR
                     // go into an infinite loop before we've reached the point where we throw all the errors.
                     throw new Error(`'${stringifyForError(moduleType)}' module can't import itself`);
                 }
-                ngModuleDef = getCompilerFacade().compileNgModule(angularCoreEnv, `ng:///${moduleType.name}/ɵmod.js`, {
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'NgModule', type: moduleType });
+                ngModuleDef = compiler.compileNgModule(angularCoreEnv, `ng:///${moduleType.name}/ɵmod.js`, {
                     type: moduleType,
                     bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY).map(resolveForwardRef),
                     declarations: declarations.map(resolveForwardRef),
@@ -26956,7 +26979,7 @@ function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInR
     Object.defineProperty(moduleType, NG_FACTORY_DEF, {
         get: () => {
             if (ngFactoryDef === null) {
-                const compiler = getCompilerFacade();
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'NgModule', type: moduleType });
                 ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${moduleType.name}/ɵfac.js`, {
                     name: moduleType.name,
                     type: moduleType,
@@ -26985,7 +27008,9 @@ function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInR
                         (ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef),
                     ],
                 };
-                ngInjectorDef = getCompilerFacade().compileInjector(angularCoreEnv, `ng:///${moduleType.name}/ɵinj.js`, meta);
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'NgModule', type: moduleType });
+                ngInjectorDef =
+                    compiler.compileInjector(angularCoreEnv, `ng:///${moduleType.name}/ɵinj.js`, meta);
             }
             return ngInjectorDef;
         },
@@ -27351,7 +27376,7 @@ function compileComponent(type, metadata) {
     Object.defineProperty(type, NG_COMP_DEF, {
         get: () => {
             if (ngComponentDef === null) {
-                const compiler = getCompilerFacade();
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'component', type: type });
                 if (componentNeedsResolution(metadata)) {
                     const error = [`Component '${type.name}' is not resolved:`];
                     if (metadata.templateUrl) {
@@ -27442,8 +27467,9 @@ function compileDirective(type, directive) {
                 // that use `@Directive()` with no selector. In that case, pass empty object to the
                 // `directiveMetadata` function instead of null.
                 const meta = getDirectiveMetadata$1(type, directive || {});
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'directive', type });
                 ngDirectiveDef =
-                    getCompilerFacade().compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);
+                    compiler.compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);
             }
             return ngDirectiveDef;
         },
@@ -27454,7 +27480,7 @@ function compileDirective(type, directive) {
 function getDirectiveMetadata$1(type, metadata) {
     const name = type && type.name;
     const sourceMapUrl = `ng:///${name}/ɵdir.js`;
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'directive', type });
     const facade = directiveMetadata(type, metadata);
     facade.typeSourceSpan = compiler.createParseSourceSpan('Directive', name, sourceMapUrl);
     if (facade.usesInheritance) {
@@ -27468,7 +27494,7 @@ function addDirectiveFactoryDef(type, metadata) {
         get: () => {
             if (ngFactoryDef === null) {
                 const meta = getDirectiveMetadata$1(type, metadata);
-                const compiler = getCompilerFacade();
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'directive', type });
                 ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${type.name}/ɵfac.js`, {
                     name: meta.metadata.name,
                     type: meta.metadata.type,
@@ -27619,7 +27645,7 @@ function compilePipe(type, meta) {
         get: () => {
             if (ngFactoryDef === null) {
                 const metadata = getPipeMetadata(type, meta);
-                const compiler = getCompilerFacade();
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'pipe', type: metadata.type });
                 ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${metadata.name}/ɵfac.js`, {
                     name: metadata.name,
                     type: metadata.type,
@@ -27637,7 +27663,9 @@ function compilePipe(type, meta) {
         get: () => {
             if (ngPipeDef === null) {
                 const metadata = getPipeMetadata(type, meta);
-                ngPipeDef = getCompilerFacade().compilePipe(angularCoreEnv, `ng:///${metadata.name}/ɵpipe.js`, metadata);
+                const compiler = getCompilerFacade({ usage: 0 /* Decorator */, kind: 'pipe', type: metadata.type });
+                ngPipeDef =
+                    compiler.compilePipe(angularCoreEnv, `ng:///${metadata.name}/ɵpipe.js`, metadata);
             }
             return ngPipeDef;
         },
@@ -27877,11 +27905,11 @@ const SWITCH_COMPILE_NGMODULE = SWITCH_COMPILE_NGMODULE__PRE_R3__;
  * through DI.
  *
  * ```
- *  function initializeApp(httpClient: HttpClient): Observable<any> {
- *   return httpClient.get("https://someUrl.com/api/user")
+ *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
+ *   return () => httpClient.get("https://someUrl.com/api/user")
  *     .pipe(
  *        tap(user => { ... })
- *     )
+ *     );
  *  }
  *
  *  @NgModule({
@@ -27890,7 +27918,7 @@ const SWITCH_COMPILE_NGMODULE = SWITCH_COMPILE_NGMODULE__PRE_R3__;
  *    bootstrap: [AppComponent],
  *    providers: [{
  *      provide: APP_INITIALIZER,
- *      useFactory: initializeApp,
+ *      useFactory: initializeAppFactory,
  *      deps: [HttpClient],
  *      multi: true
  *    }]
@@ -29085,7 +29113,11 @@ function compileNgModuleFactory__POST_R3__(injector, options, moduleType) {
     if (compilerProviders.length === 0) {
         return Promise.resolve(moduleFactory);
     }
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({
+        usage: 0 /* Decorator */,
+        kind: 'NgModule',
+        type: moduleType,
+    });
     const compilerInjector = Injector.create({ providers: compilerProviders });
     const resourceLoader = compilerInjector.get(compiler.ResourceLoader);
     // The resource loader can also return a string while the "resolveComponentResources"
@@ -29567,20 +29599,41 @@ class ApplicationRef {
             merge$1(isCurrentlyStable, isStable.pipe(share()));
     }
     /**
-     * Bootstrap a new component at the root level of the application.
+     * Bootstrap a component onto the element identified by its selector or, optionally, to a
+     * specified element.
      *
      * @usageNotes
      * ### Bootstrap process
      *
-     * When bootstrapping a new root component into an application, Angular mounts the
-     * specified application component onto DOM elements identified by the componentType's
-     * selector and kicks off automatic change detection to finish initializing the component.
+     * When bootstrapping a component, Angular mounts it onto a target DOM element
+     * and kicks off automatic change detection. The target DOM element can be
+     * provided using the `rootSelectorOrNode` argument.
      *
-     * Optionally, a component can be mounted onto a DOM element that does not match the
-     * componentType's selector.
+     * If the target DOM element is not provided, Angular tries to find one on a page
+     * using the `selector` of the component that is being bootstrapped
+     * (first matched element is used).
      *
      * ### Example
-     * {@example core/ts/platform/platform.ts region='longform'}
+     *
+     * Generally, we define the component to bootstrap in the `bootstrap` array of `NgModule`,
+     * but it requires us to know the component while writing the application code.
+     *
+     * Imagine a situation where we have to wait for an API call to decide about the component to
+     * bootstrap. We can use the `ngDoBootstrap` hook of the `NgModule` and call this method to
+     * dynamically bootstrap a component.
+     *
+     * {@example core/ts/platform/platform.ts region='componentSelector'}
+     *
+     * Optionally, a component can be mounted onto a DOM element that does not match the
+     * selector of the bootstrapped component.
+     *
+     * In the following example, we are providing a CSS selector to match the target element.
+     *
+     * {@example core/ts/platform/platform.ts region='cssSelector'}
+     *
+     * While in this example, we are providing reference to a DOM node.
+     *
+     * {@example core/ts/platform/platform.ts region='domNode'}
      */
     bootstrap(componentOrFactory, rootSelectorOrNode) {
         if (!this._initStatus.done) {
@@ -33006,7 +33059,7 @@ class NgModuleFactory_ extends NgModuleFactory {
  * @codeGenApi
  */
 function ɵɵngDeclareDirective(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'directive', type: decl.type });
     return compiler.compileDirectiveDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
 }
 /**
@@ -33024,7 +33077,7 @@ function ɵɵngDeclareClassMetadata(decl) {
  * @codeGenApi
  */
 function ɵɵngDeclareComponent(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'component', type: decl.type });
     return compiler.compileComponentDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵcmp.js`, decl);
 }
 /**
@@ -33033,16 +33086,34 @@ function ɵɵngDeclareComponent(decl) {
  * @codeGenApi
  */
 function ɵɵngDeclareFactory(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({
+        usage: 1 /* PartialDeclaration */,
+        kind: getFactoryKind(decl.target),
+        type: decl.type
+    });
     return compiler.compileFactoryDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
 }
+function getFactoryKind(target) {
+    switch (target) {
+        case FactoryTarget.Directive:
+            return 'directive';
+        case FactoryTarget.Component:
+            return 'component';
+        case FactoryTarget.Injectable:
+            return 'injectable';
+        case FactoryTarget.Pipe:
+            return 'pipe';
+        case FactoryTarget.NgModule:
+            return 'NgModule';
+    }
+}
 /**
  * Compiles a partial injectable declaration object into a full injectable definition object.
  *
  * @codeGenApi
  */
 function ɵɵngDeclareInjectable(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'injectable', type: decl.type });
     return compiler.compileInjectableDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵprov.js`, decl);
 }
 /**
@@ -33051,7 +33122,7 @@ function ɵɵngDeclareInjectable(decl) {
  * @codeGenApi
  */
 function ɵɵngDeclareInjector(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'NgModule', type: decl.type });
     return compiler.compileInjectorDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵinj.js`, decl);
 }
 /**
@@ -33060,7 +33131,7 @@ function ɵɵngDeclareInjector(decl) {
  * @codeGenApi
  */
 function ɵɵngDeclareNgModule(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'NgModule', type: decl.type });
     return compiler.compileNgModuleDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵmod.js`, decl);
 }
 /**
@@ -33069,7 +33140,7 @@ function ɵɵngDeclareNgModule(decl) {
  * @codeGenApi
  */
 function ɵɵngDeclarePipe(decl) {
-    const compiler = getCompilerFacade();
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'pipe', type: decl.type });
     return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);
 }