@angular/core 7.2.0-rc.0 → 7.2.3

package/bundles/core-testing.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v7.2.0-rc.0
+ * @license Angular v7.2.3
  * (c) 2010-2018 Google, Inc. https://angular.io/
  * License: MIT
  */
@@ -7,8 +7,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core')) :
     typeof define === 'function' && define.amd ? define('@angular/core/testing', ['exports', '@angular/core'], factory) :
-    (factory((global.ng = global.ng || {}, global.ng.core = global.ng.core || {}, global.ng.core.testing = {}),global.ng.core));
-}(this, (function (exports,core) { 'use strict';
+    (global = global || self, factory((global.ng = global.ng || {}, global.ng.core = global.ng.core || {}, global.ng.core.testing = {}), global.ng.core));
+}(this, function (exports, core) { 'use strict';
 
     /**
      * @license
@@ -626,6 +626,17 @@
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     }
 
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
     function __decorate(decorators, target, key, desc) {
         var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
         if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -837,7 +848,9 @@
             this.overrides.clear();
             overrides.forEach(function (_a) {
                 var _b = __read(_a, 2), type = _b[0], override = _b[1];
-                return _this.overrides.set(type, override);
+                var overrides = _this.overrides.get(type) || [];
+                overrides.push(override);
+                _this.overrides.set(type, overrides);
             });
         };
         OverrideResolver.prototype.getAnnotation = function (type) {
@@ -845,14 +858,17 @@
             return reflection.annotations(type).find(function (a) { return a instanceof _this.type; }) || null;
         };
         OverrideResolver.prototype.resolve = function (type) {
+            var _this = this;
             var resolved = this.resolved.get(type) || null;
             if (!resolved) {
                 resolved = this.getAnnotation(type);
                 if (resolved) {
-                    var override = this.overrides.get(type);
-                    if (override) {
-                        var overrider = new MetadataOverrider();
-                        resolved = overrider.overrideMetadata(this.type, resolved, override);
+                    var overrides = this.overrides.get(type);
+                    if (overrides) {
+                        var overrider_1 = new MetadataOverrider();
+                        overrides.forEach(function (override) {
+                            resolved = overrider_1.overrideMetadata(_this.type, resolved, override);
+                        });
                     }
                 }
                 this.resolved.set(type, resolved);
@@ -945,6 +961,7 @@
      * found in the LICENSE file at https://angular.io/license
      */
     var _nextRootElementId = 0;
+    var EMPTY_ARRAY = [];
     /**
      * @description
      * Configures and initializes environment for unit testing and provides methods for
@@ -967,6 +984,8 @@
             this._pipeOverrides = [];
             this._providerOverrides = [];
             this._rootProviderOverrides = [];
+            this._providerOverridesByToken = new Map();
+            this._templateOverrides = new Map();
             // test module configuration
             this._providers = [];
             this._declarations = [];
@@ -974,6 +993,7 @@
             this._schemas = [];
             this._activeFixtures = [];
             this._moduleRef = null;
+            this._testModuleType = null;
             this._instantiated = false;
         }
         /**
@@ -1049,7 +1069,10 @@
             return TestBedRender3;
         };
         TestBedRender3.prototype.overrideTemplateUsingTestingModule = function (component, template) {
-            throw new Error('Render3TestBed.overrideTemplateUsingTestingModule is not implemented yet');
+            if (this._instantiated) {
+                throw new Error('Cannot override template when the test module has already been instantiated');
+            }
+            this._templateOverrides.set(component, template);
         };
         TestBedRender3.overrideProvider = function (token, provider) {
             _getTestBedRender3().overrideProvider(token, provider);
@@ -1108,12 +1131,15 @@
             this._pipeOverrides = [];
             this._providerOverrides = [];
             this._rootProviderOverrides = [];
+            this._providerOverridesByToken.clear();
+            this._templateOverrides.clear();
             // reset test module config
             this._providers = [];
             this._declarations = [];
             this._imports = [];
             this._schemas = [];
             this._moduleRef = null;
+            this._testModuleType = null;
             this._instantiated = false;
             this._activeFixtures.forEach(function (fixture) {
                 try {
@@ -1192,16 +1218,18 @@
          * Overwrites all providers for the given token with the given provider definition.
          */
         TestBedRender3.prototype.overrideProvider = function (token, provider) {
+            var providerDef = provider.useFactory ?
+                { provide: token, useFactory: provider.useFactory, deps: provider.deps || [] } :
+                { provide: token, useValue: provider.useValue };
             var injectableDef;
             var isRoot = (typeof token !== 'string' && (injectableDef = core.ɵgetInjectableDef(token)) &&
                 injectableDef.providedIn === 'root');
-            var overrides = isRoot ? this._rootProviderOverrides : this._providerOverrides;
-            if (provider.useFactory) {
-                overrides.push({ provide: token, useFactory: provider.useFactory, deps: provider.deps || [] });
-            }
-            else {
-                overrides.push({ provide: token, useValue: provider.useValue });
-            }
+            var overridesBucket = isRoot ? this._rootProviderOverrides : this._providerOverrides;
+            overridesBucket.push(providerDef);
+            // keep all overrides grouped by token as well for fast lookups using token
+            var overridesForToken = this._providerOverridesByToken.get(token) || [];
+            overridesForToken.push(providerDef);
+            this._providerOverridesByToken.set(token, overridesForToken);
         };
         TestBedRender3.prototype.deprecatedOverrideProvider = function (token, provider) {
             throw new Error('No implemented in IVY');
@@ -1234,15 +1262,22 @@
                 return;
             }
             var resolvers = this._getResolvers();
-            var testModuleType = this._createTestModule();
-            compileNgModule(testModuleType, resolvers);
+            this._testModuleType = this._createTestModule();
+            this._compileNgModule(this._testModuleType, resolvers);
             var parentInjector = this.platform.injector;
-            this._moduleRef = new core.ɵRender3NgModuleRef(testModuleType, parentInjector);
+            this._moduleRef = new core.ɵRender3NgModuleRef(this._testModuleType, parentInjector);
             // ApplicationInitStatus.runInitializers() is marked @internal
             // to core. Cast it to any before accessing it.
             this._moduleRef.injector.get(core.ApplicationInitStatus).runInitializers();
             this._instantiated = true;
         };
+        // get overrides for a specific provider (if any)
+        TestBedRender3.prototype._getProviderOverrides = function (provider) {
+            var token = typeof provider === 'object' && provider.hasOwnProperty('provide') ?
+                provider.provide :
+                provider;
+            return this._providerOverridesByToken.get(token) || [];
+        };
         // creates resolvers taking overrides into account
         TestBedRender3.prototype._getResolvers = function () {
             var module = new NgModuleResolver();
@@ -1289,128 +1324,155 @@
             }());
             return DynamicTestModule;
         };
+        TestBedRender3.prototype._getMetaWithOverrides = function (meta, type) {
+            var _this = this;
+            var overrides = {};
+            if (meta.providers && meta.providers.length) {
+                var providerOverrides = flatten(meta.providers, function (provider) { return _this._getProviderOverrides(provider); });
+                if (providerOverrides.length) {
+                    overrides.providers = __spread(meta.providers, providerOverrides);
+                }
+            }
+            var hasTemplateOverride = !!type && this._templateOverrides.has(type);
+            if (hasTemplateOverride) {
+                overrides.template = this._templateOverrides.get(type);
+            }
+            return Object.keys(overrides).length ? __assign({}, meta, overrides) : meta;
+        };
+        TestBedRender3.prototype._compileNgModule = function (moduleType, resolvers) {
+            var _this = this;
+            var ngModule = resolvers.module.resolve(moduleType);
+            if (ngModule === null) {
+                throw new Error(core.ɵstringify(moduleType) + " has not @NgModule annotation");
+            }
+            var metadata = this._getMetaWithOverrides(ngModule);
+            core.ɵcompileNgModuleDefs(moduleType, metadata);
+            var declarations = flatten(ngModule.declarations || EMPTY_ARRAY, core.resolveForwardRef);
+            var compiledComponents = [];
+            // Compile the components, directives and pipes declared by this module
+            declarations.forEach(function (declaration) {
+                var component = resolvers.component.resolve(declaration);
+                if (component) {
+                    var metadata_1 = _this._getMetaWithOverrides(component, declaration);
+                    core.ɵcompileComponent(declaration, metadata_1);
+                    compiledComponents.push(declaration);
+                    return;
+                }
+                var directive = resolvers.directive.resolve(declaration);
+                if (directive) {
+                    var metadata_2 = _this._getMetaWithOverrides(directive);
+                    core.ɵcompileDirective(declaration, metadata_2);
+                    return;
+                }
+                var pipe = resolvers.pipe.resolve(declaration);
+                if (pipe) {
+                    core.ɵcompilePipe(declaration, pipe);
+                    return;
+                }
+            });
+            // Compile transitive modules, components, directives and pipes
+            var transitiveScope = this._transitiveScopesFor(moduleType, resolvers);
+            compiledComponents.forEach(function (cmp) {
+                var scope = _this._templateOverrides.has(cmp) ?
+                    // if we have template override via `TestBed.overrideTemplateUsingTestingModule` -
+                    // define Component scope as TestingModule scope, instead of the scope of NgModule
+                    // where this Component was declared
+                    _this._transitiveScopesFor(_this._testModuleType, resolvers) :
+                    transitiveScope;
+                core.ɵpatchComponentDefWithScope(cmp.ngComponentDef, scope);
+            });
+        };
+        /**
+         * Compute the pair of transitive scopes (compilation scope and exported scope) for a given
+         * module.
+         *
+         * This operation is memoized and the result is cached on the module's definition. It can be
+         * called on modules with components that have not fully compiled yet, but the result should not
+         * be used until they have.
+         */
+        TestBedRender3.prototype._transitiveScopesFor = function (moduleType, resolvers) {
+            var _this = this;
+            if (!isNgModule(moduleType)) {
+                throw new Error(moduleType.name + " does not have an ngModuleDef");
+            }
+            var def = moduleType.ngModuleDef;
+            if (def.transitiveCompileScopes !== null) {
+                return def.transitiveCompileScopes;
+            }
+            var scopes = {
+                compilation: {
+                    directives: new Set(),
+                    pipes: new Set(),
+                },
+                exported: {
+                    directives: new Set(),
+                    pipes: new Set(),
+                },
+            };
+            def.declarations.forEach(function (declared) {
+                var declaredWithDefs = declared;
+                if (declaredWithDefs.ngPipeDef !== undefined) {
+                    scopes.compilation.pipes.add(declared);
+                }
+                else {
+                    scopes.compilation.directives.add(declared);
+                }
+            });
+            def.imports.forEach(function (imported) {
+                var ngModule = resolvers.module.resolve(imported);
+                if (ngModule === null) {
+                    throw new Error("Importing " + imported.name + " which does not have an @ngModule");
+                }
+                else {
+                    _this._compileNgModule(imported, resolvers);
+                }
+                // When this module imports another, the imported module's exported directives and pipes are
+                // added to the compilation scope of this module.
+                var importedScope = _this._transitiveScopesFor(imported, resolvers);
+                importedScope.exported.directives.forEach(function (entry) { return scopes.compilation.directives.add(entry); });
+                importedScope.exported.pipes.forEach(function (entry) { return scopes.compilation.pipes.add(entry); });
+            });
+            def.exports.forEach(function (exported) {
+                var exportedTyped = exported;
+                // Either the type is a module, a pipe, or a component/directive (which may not have an
+                // ngComponentDef as it might be compiled asynchronously).
+                if (isNgModule(exportedTyped)) {
+                    // When this module exports another, the exported module's exported directives and pipes are
+                    // added to both the compilation and exported scopes of this module.
+                    var exportedScope = _this._transitiveScopesFor(exportedTyped, resolvers);
+                    exportedScope.exported.directives.forEach(function (entry) {
+                        scopes.compilation.directives.add(entry);
+                        scopes.exported.directives.add(entry);
+                    });
+                    exportedScope.exported.pipes.forEach(function (entry) {
+                        scopes.compilation.pipes.add(entry);
+                        scopes.exported.pipes.add(entry);
+                    });
+                }
+                else if (exportedTyped.ngPipeDef !== undefined) {
+                    scopes.exported.pipes.add(exportedTyped);
+                }
+                else {
+                    scopes.exported.directives.add(exportedTyped);
+                }
+            });
+            def.transitiveCompileScopes = scopes;
+            return scopes;
+        };
         return TestBedRender3;
     }());
     var testBed;
     function _getTestBedRender3() {
         return testBed = testBed || new TestBedRender3();
     }
-    // Module compiler
-    var EMPTY_ARRAY = [];
-    function compileNgModule(moduleType, resolvers) {
-        var ngModule = resolvers.module.resolve(moduleType);
-        if (ngModule === null) {
-            throw new Error(core.ɵstringify(moduleType) + " has not @NgModule annotation");
-        }
-        core.ɵcompileNgModuleDefs(moduleType, ngModule);
-        var declarations = flatten(ngModule.declarations || EMPTY_ARRAY);
-        var compiledComponents = [];
-        // Compile the components, directives and pipes declared by this module
-        declarations.forEach(function (declaration) {
-            var component = resolvers.component.resolve(declaration);
-            if (component) {
-                core.ɵcompileComponent(declaration, component);
-                compiledComponents.push(declaration);
-                return;
-            }
-            var directive = resolvers.directive.resolve(declaration);
-            if (directive) {
-                core.ɵcompileDirective(declaration, directive);
-                return;
-            }
-            var pipe = resolvers.pipe.resolve(declaration);
-            if (pipe) {
-                core.ɵcompilePipe(declaration, pipe);
-                return;
-            }
-        });
-        // Compile transitive modules, components, directives and pipes
-        var transitiveScope = transitiveScopesFor(moduleType, resolvers);
-        compiledComponents.forEach(function (cmp) { return core.ɵpatchComponentDefWithScope(cmp.ngComponentDef, transitiveScope); });
-    }
-    /**
-     * Compute the pair of transitive scopes (compilation scope and exported scope) for a given module.
-     *
-     * This operation is memoized and the result is cached on the module's definition. It can be called
-     * on modules with components that have not fully compiled yet, but the result should not be used
-     * until they have.
-     */
-    function transitiveScopesFor(moduleType, resolvers) {
-        if (!isNgModule(moduleType)) {
-            throw new Error(moduleType.name + " does not have an ngModuleDef");
-        }
-        var def = moduleType.ngModuleDef;
-        if (def.transitiveCompileScopes !== null) {
-            return def.transitiveCompileScopes;
-        }
-        var scopes = {
-            compilation: {
-                directives: new Set(),
-                pipes: new Set(),
-            },
-            exported: {
-                directives: new Set(),
-                pipes: new Set(),
-            },
-        };
-        def.declarations.forEach(function (declared) {
-            var declaredWithDefs = declared;
-            if (declaredWithDefs.ngPipeDef !== undefined) {
-                scopes.compilation.pipes.add(declared);
-            }
-            else {
-                scopes.compilation.directives.add(declared);
-            }
-        });
-        def.imports.forEach(function (imported) {
-            var ngModule = resolvers.module.resolve(imported);
-            if (ngModule === null) {
-                throw new Error("Importing " + imported.name + " which does not have an @ngModule");
-            }
-            else {
-                compileNgModule(imported, resolvers);
-            }
-            // When this module imports another, the imported module's exported directives and pipes are
-            // added to the compilation scope of this module.
-            var importedScope = transitiveScopesFor(imported, resolvers);
-            importedScope.exported.directives.forEach(function (entry) { return scopes.compilation.directives.add(entry); });
-            importedScope.exported.pipes.forEach(function (entry) { return scopes.compilation.pipes.add(entry); });
-        });
-        def.exports.forEach(function (exported) {
-            var exportedTyped = exported;
-            // Either the type is a module, a pipe, or a component/directive (which may not have an
-            // ngComponentDef as it might be compiled asynchronously).
-            if (isNgModule(exportedTyped)) {
-                // When this module exports another, the exported module's exported directives and pipes are
-                // added to both the compilation and exported scopes of this module.
-                var exportedScope = transitiveScopesFor(exportedTyped, resolvers);
-                exportedScope.exported.directives.forEach(function (entry) {
-                    scopes.compilation.directives.add(entry);
-                    scopes.exported.directives.add(entry);
-                });
-                exportedScope.exported.pipes.forEach(function (entry) {
-                    scopes.compilation.pipes.add(entry);
-                    scopes.exported.pipes.add(entry);
-                });
-            }
-            else if (exportedTyped.ngPipeDef !== undefined) {
-                scopes.exported.pipes.add(exportedTyped);
-            }
-            else {
-                scopes.exported.directives.add(exportedTyped);
-            }
-        });
-        def.transitiveCompileScopes = scopes;
-        return scopes;
-    }
-    function flatten(values) {
+    function flatten(values, mapFn) {
         var out = [];
         values.forEach(function (value) {
             if (Array.isArray(value)) {
-                out.push.apply(out, __spread(flatten(value)));
+                out.push.apply(out, __spread(flatten(value, mapFn)));
             }
             else {
-                out.push(value);
+                out.push(mapFn ? mapFn(value) : value);
             }
         });
         return out;
@@ -2132,5 +2194,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=core-testing.umd.js.map