fix(ivy): adhere to bootstrap options for JIT compiled components

packages/core/src/application_ref.ts

@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import './util/ng_jit_mode';
+
 import {Observable, Observer, Subscription, merge} from 'rxjs';
 import {share} from 'rxjs/operators';
 
@@ -29,6 +31,7 @@ import {isComponentResourceResolutionQueueEmpty, resolveComponentResources} from
 import {assertNgModuleType} from './render3/assert';
 import {ComponentFactory as R3ComponentFactory} from './render3/component_ref';
 import {setLocaleId} from './render3/i18n';
+import {setJitOptions} from './render3/jit/jit_options';
 import {NgModuleFactory as R3NgModuleFactory} from './render3/ng_module_ref';
 import {publishDefaultGlobalUtils as _publishDefaultGlobalUtils} from './render3/util/global_utils';
 import {Testability, TestabilityRegistry} from './testability/testability';
@@ -56,13 +59,27 @@ export function compileNgModuleFactory__POST_R3__<M>(
     injector: Injector, options: CompilerOptions,
     moduleType: Type<M>): Promise<NgModuleFactory<M>> {
   ngDevMode && assertNgModuleType(moduleType);
+
+  const compilerOptions = injector.get(COMPILER_OPTIONS, []).concat(options);
+
+  if (typeof ngJitMode === 'undefined' || ngJitMode) {
+    // Configure the compiler to use the provided options. This call may fail when multiple modules
+    // are bootstrapped with incompatible options, as a component can only be compiled according to
+    // a single set of options.
+    setJitOptions({
+      defaultEncapsulation:
+          _lastDefined(compilerOptions.map(options => options.defaultEncapsulation)),
+      preserveWhitespaces:
+          _lastDefined(compilerOptions.map(options => options.preserveWhitespaces)),
+    });
+  }
+
   const moduleFactory = new R3NgModuleFactory(moduleType);
 
   if (isComponentResourceResolutionQueueEmpty()) {
     return Promise.resolve(moduleFactory);
   }
 
-  const compilerOptions = injector.get(COMPILER_OPTIONS, []).concat(options);
   const compilerProviders = _mergeArrays(compilerOptions.map(o => o.providers !));
 
   // In case there are no compiler providers, we just return the module factory as
@@ -748,6 +765,15 @@ function remove<T>(list: T[], el: T): void {
   }
 }
 
+function _lastDefined<T>(args: T[]): T|undefined {
+  for (let i = args.length - 1; i >= 0; i--) {
+    if (args[i] !== undefined) {
+      return args[i];
+    }
+  }
+  return undefined;
+}
+
 function _mergeArrays(parts: any[][]): any[] {
   const result: any[] = [];
   parts.forEach((part) => part && result.push(...part));

packages/core/src/core_render3_private_export.ts

@@ -197,6 +197,9 @@ export {
 export {
   compilePipe as ɵcompilePipe,
 } from './render3/jit/pipe';
+export {
+  resetJitOptions as ɵresetJitOptions,
+} from './render3/jit/jit_options';
 
 export {
   NgModuleDef as ɵNgModuleDef,

packages/core/src/render3/jit/directive.ts

@@ -23,6 +23,7 @@ import {ComponentType} from '../interfaces/definition';
 import {stringifyForError} from '../util/misc_utils';
 
 import {angularCoreEnv} from './environment';
+import {getJitOptions} from './jit_options';
 import {flushModuleScopingQueueAsMuchAsPossible, patchComponentDefWithScope, transitiveScopesFor} from './module';
 
 
@@ -68,18 +69,34 @@ export function compileComponent(type: Type<any>, metadata: Component): void {
           throw new Error(error.join('\n'));
         }
 
+        const jitOptions = getJitOptions();
+        let preserveWhitespaces = metadata.preserveWhitespaces;
+        if (preserveWhitespaces === undefined) {
+          if (jitOptions !== null && jitOptions.preserveWhitespaces !== undefined) {
+            preserveWhitespaces = jitOptions.preserveWhitespaces;
+          } else {
+            preserveWhitespaces = false;
+          }
+        }
+        let encapsulation = metadata.encapsulation;
+        if (encapsulation === undefined) {
+          if (jitOptions !== null && jitOptions.defaultEncapsulation !== undefined) {
+            encapsulation = jitOptions.defaultEncapsulation;
+          } else {
+            encapsulation = ViewEncapsulation.Emulated;
+          }
+        }
+
         const templateUrl = metadata.templateUrl || `ng:///${type.name}/template.html`;
         const meta: R3ComponentMetadataFacade = {
           ...directiveMetadata(type, metadata),
           typeSourceSpan: compiler.createParseSourceSpan('Component', type.name, templateUrl),
-          template: metadata.template || '',
-          preserveWhitespaces: metadata.preserveWhitespaces || false,
+          template: metadata.template || '', preserveWhitespaces,
           styles: metadata.styles || EMPTY_ARRAY,
           animations: metadata.animations,
           directives: [],
           changeDetection: metadata.changeDetection,
-          pipes: new Map(),
-          encapsulation: metadata.encapsulation || ViewEncapsulation.Emulated,
+          pipes: new Map(), encapsulation,
           interpolation: metadata.interpolation,
           viewProviders: metadata.viewProviders || null,
         };

packages/core/src/render3/jit/jit_options.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import {ViewEncapsulation} from '../../metadata/view';
+
+export interface JitCompilerOptions {
+  defaultEncapsulation?: ViewEncapsulation;
+  preserveWhitespaces?: boolean;
+}
+
+let jitOptions: JitCompilerOptions|null = null;
+
+export function setJitOptions(options: JitCompilerOptions): void {
+  if (jitOptions !== null) {
+    if (options.defaultEncapsulation !== jitOptions.defaultEncapsulation) {
+      ngDevMode &&
+          console.error(
+              'Provided value for `defaultEncapsulation` can not be changed once it has been set.');
+      return;
+    }
+    if (options.preserveWhitespaces !== jitOptions.preserveWhitespaces) {
+      ngDevMode &&
+          console.error(
+              'Provided value for `preserveWhitespaces` can not be changed once it has been set.');
+      return;
+    }
+  }
+  jitOptions = options;
+}
+
+export function getJitOptions(): JitCompilerOptions|null {
+  return jitOptions;
+}
+
+export function resetJitOptions(): void {
+  jitOptions = null;
+}

packages/core/src/util/ng_jit_mode.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+
+declare global {
+  const ngJitMode: boolean;
+}
+
+// Make this an ES module to be able to augment the global scope
+export {};