@angular/core 6.1.6 → 6.1.10

package/bundles/core.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v6.1.6
+ * @license Angular v6.1.10
  * (c) 2010-2018 Google, Inc. https://angular.io/
  * License: MIT
  */
@@ -50,6 +50,21 @@
         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);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
     function __values(o) {
         var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
         if (m) return m.call(o);
@@ -174,11 +189,11 @@
      * @usageNotes
      * ### Basic Example
      *
-     * #### Plain InjectionToken
+     * ### Plain InjectionToken
      *
      * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
      *
-     * #### Tree-shakable InjectionToken
+     * ### Tree-shakable InjectionToken
      *
      * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
      *
@@ -1666,9 +1681,6 @@
          * For the DOM this means using modern [Shadow
          * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
          * creating a ShadowRoot for Component's Host Element.
-         *
-         * ### Example
-         * {@example core/ts/metadata/encapsulation.ts region='longform'}
          */
         ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom";
     })(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));
@@ -1702,7 +1714,7 @@
         }
         return Version;
     }());
-    var VERSION = new Version('6.1.6');
+    var VERSION = new Version('6.1.10');
 
     /**
      * @license
@@ -3098,13 +3110,11 @@
             }
             this.initialized = true;
         };
-        ApplicationInitStatus.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        ApplicationInitStatus.ctorParameters = function () { return [
-            { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional }] }
-        ]; };
+        ApplicationInitStatus = __decorate([
+            Injectable(),
+            __param(0, Inject(APP_INITIALIZER)), __param(0, Optional()),
+            __metadata("design:paramtypes", [Array])
+        ], ApplicationInitStatus);
         return ApplicationInitStatus;
     }());
 
@@ -3185,9 +3195,9 @@
             // tslint:disable-next-line:no-console
             console.warn(message);
         };
-        Console.decorators = [
-            { type: Injectable }
-        ];
+        Console = __decorate([
+            Injectable()
+        ], Console);
         return Console;
     }());
 
@@ -3259,9 +3269,9 @@
          * Returns the id for a given NgModule, if one is defined and known to the compiler.
          */
         Compiler.prototype.getModuleId = function (moduleType) { return undefined; };
-        Compiler.decorators = [
-            { type: Injectable }
-        ];
+        Compiler = __decorate([
+            Injectable()
+        ], Compiler);
         return Compiler;
     }());
     /**
@@ -3289,11 +3299,9 @@
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents an instance of a Component created via a {@link ComponentFactory}.
-     *
-     * `ComponentRef` provides access to the Component Instance as well other objects related to this
-     * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}
-     * method.
+     * Represents a component created by a `ComponentFactory`.
+     * Provides access to the component instance and related objects,
+     * and provides the means of destroying the instance.
      *
      */
     var ComponentRef = /** @class */ (function () {
@@ -4106,13 +4114,10 @@
             // TODO(juliemr): implement.
             return [];
         };
-        Testability.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        Testability.ctorParameters = function () { return [
-            { type: NgZone }
-        ]; };
+        Testability = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [NgZone])
+        ], Testability);
         return Testability;
     }());
     /**
@@ -4165,11 +4170,10 @@
             if (findInAncestors === void 0) { findInAncestors = true; }
             return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
         };
-        TestabilityRegistry.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        TestabilityRegistry.ctorParameters = function () { return []; };
+        TestabilityRegistry = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [])
+        ], TestabilityRegistry);
         return TestabilityRegistry;
     }());
     var _NoopGetTestability = /** @class */ (function () {
@@ -4453,13 +4457,10 @@
             enumerable: true,
             configurable: true
         });
-        PlatformRef.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        PlatformRef.ctorParameters = function () { return [
-            { type: Injector }
-        ]; };
+        PlatformRef = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [Injector])
+        ], PlatformRef);
         return PlatformRef;
     }());
     function getNgZone(ngZoneOption) {
@@ -4570,6 +4571,7 @@
             this.isStable =
                 rxjs.merge(isCurrentlyStable, isStable.pipe(operators.share()));
         }
+        ApplicationRef_1 = ApplicationRef;
         /**
          * Bootstrap a new component at the root level of the application.
          *
@@ -4633,7 +4635,7 @@
             if (this._runningTick) {
                 throw new Error('ApplicationRef.tick is called recursively');
             }
-            var scope = ApplicationRef._tickScope();
+            var scope = ApplicationRef_1._tickScope();
             try {
                 this._runningTick = true;
                 this._views.forEach(function (view) { return view.detectChanges(); });
@@ -4693,20 +4695,16 @@
             enumerable: true,
             configurable: true
         });
+        var ApplicationRef_1;
         /** @internal */
         ApplicationRef._tickScope = wtfCreateScope('ApplicationRef#tick()');
-        ApplicationRef.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        ApplicationRef.ctorParameters = function () { return [
-            { type: NgZone },
-            { type: Console },
-            { type: Injector },
-            { type: ErrorHandler },
-            { type: ComponentFactoryResolver },
-            { type: ApplicationInitStatus }
-        ]; };
+        ApplicationRef = ApplicationRef_1 = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [NgZone, Console, Injector,
+                ErrorHandler,
+                ComponentFactoryResolver,
+                ApplicationInitStatus])
+        ], ApplicationRef);
         return ApplicationRef;
     }());
     function remove(list, el) {
@@ -5062,14 +5060,11 @@
                 .then(function (module) { return module[exportName + factoryClassSuffix]; })
                 .then(function (factory) { return checkNotEmpty(factory, module, exportName); });
         };
-        SystemJsNgModuleLoader.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        SystemJsNgModuleLoader.ctorParameters = function () { return [
-            { type: Compiler },
-            { type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional }] }
-        ]; };
+        SystemJsNgModuleLoader = __decorate([
+            Injectable(),
+            __param(1, Optional()),
+            __metadata("design:paramtypes", [Compiler, SystemJsNgModuleLoaderConfig])
+        ], SystemJsNgModuleLoader);
         return SystemJsNgModuleLoader;
     }());
     function checkNotEmpty(value, modulePath, exportName) {
@@ -5087,15 +5082,20 @@
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents an Embedded Template that can be used to instantiate Embedded Views.
+     * Represents an embedded template that can be used to instantiate embedded views.
+     * To instantiate embedded views based on a template, use the `ViewContainerRef`
+     * method `createEmbeddedView()`.
+     *
+     * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`
+     * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view
+     * is injected into the constructor of the directive,
+     * using the `TemplateRef` token.
      *
-     * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element
-     * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into
-     * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for
-     * the `TemplateRef` from a Component or a Directive via {@link Query}.
+     * You can also use a `Query` to find a `TemplateRef` associated with
+     * a component or a directive.
      *
-     * To instantiate Embedded Views based on a Template, use {@link ViewContainerRef#
-     * createEmbeddedView}, which will create the View and attach it to the View Container.
+     * @see `ViewContainerRef`
+     * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)
      *
      */
     var TemplateRef = /** @class */ (function () {
@@ -5112,21 +5112,17 @@
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents a container where one or more Views can be attached.
+     * Represents a container where one or more views can be attached to a component.
      *
-     * The container can contain two kinds of Views. Host Views, created by instantiating a
-     * {@link Component} via {@link #createComponent}, and Embedded Views, created by instantiating an
-     * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
+     * Can contain *host views* (created by instantiating a
+     * component with the `createComponent()` method), and *embedded views*
+     * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
      *
-     * The location of the View Container within the containing View is specified by the Anchor
-     * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
-     * have a single View Container.
+     * A view container instance can contain other view containers,
+     * creating a [view hierarchy](guide/glossary#view-tree).
      *
-     * Root elements of Views attached to this container become siblings of the Anchor Element in
-     * the Rendered View.
-     *
-     * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
-     * with `ViewContainerRef` on the Element, or you obtain it via a {@link ViewChild} query.
+     * @see `ComponentRef`
+     * @see `EmbeddedViewRef`
      *
      */
     var ViewContainerRef = /** @class */ (function () {
@@ -5180,7 +5176,7 @@
      * when the `live` property is set to false, and reattaches it when the property
      * becomes true.
      *
-     * <code-example path="core/ts/change_detect/change-detection.ts" region="detach"></code-example>
+     * <code-example path="core/ts/change_detect/change-detection.ts" region="reattach"></code-example>
      *
      */
     var ChangeDetectorRef = /** @class */ (function () {
@@ -5196,6 +5192,14 @@
      * 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
      */
+    /**
+     * Represents an Angular [view](guide/glossary#view),
+     * specifically the [host view](guide/glossary#view-tree) that is defined by a component.
+     * Also serves as the base class
+     * that adds destroy methods for [embedded views](guide/glossary#view-tree).
+     *
+     * @see `EmbeddedViewRef`
+     */
     var ViewRef = /** @class */ (function (_super) {
         __extends(ViewRef, _super);
         function ViewRef() {
@@ -5204,21 +5208,21 @@
         return ViewRef;
     }(ChangeDetectorRef));
     /**
-     * Represents an Angular View.
+     * Represents an Angular [view](guide/glossary#view) in a view container.
+     * An [embedded view](guide/glossary#view-tree) can be referenced from a component
+     * other than the hosting component whose template defines it, or it can be defined
+     * independently by a `TemplateRef`.
      *
-     * <!-- TODO: move the next two paragraphs to the dev guide -->
-     * A View is a fundamental building block of the application UI. It is the smallest grouping of
-     * Elements which are created and destroyed together.
+     * Properties of elements in a view can change, but the structure (number and order) of elements in
+     * a view cannot. Change the structure of elements by inserting, moving, or
+     * removing nested views in a view container.
      *
-     * Properties of elements in a View can change, but the structure (number and order) of elements in
-     * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
-     * removing nested Views via a `ViewContainerRef`. Each View can contain many View Containers.
-     * <!-- /TODO -->
+     * @see `ViewContainerRef`
      *
      * @usageNotes
-     * ### Example
      *
-     * Given this template...
+     * The following template breaks down into two separate `TemplateRef` instances,
+     * an outer one and an inner one.
      *
      * ```
      * Count: {{items.length}}
@@ -5227,9 +5231,7 @@
      * </ul>
      * ```
      *
-     * We have two `TemplateRef`s:
-     *
-     * Outer `TemplateRef`:
+     * This is the outer `TemplateRef`:
      *
      * ```
      * Count: {{items.length}}
@@ -5238,15 +5240,13 @@
      * </ul>
      * ```
      *
-     * Inner `TemplateRef`:
+     * This is the inner `TemplateRef`:
      *
      * ```
      *   <li>{{item}}</li>
      * ```
      *
-     * Notice that the original template is broken down into two separate `TemplateRef`s.
-     *
-     * The outer/inner `TemplateRef`s are then assembled into views like so:
+     * The outer and inner `TemplateRef` instances are assembled into views as follows:
      *
      * ```
      * <!-- ViewRef: outer-0 -->
@@ -6792,6 +6792,10 @@
     function _localeFactory(locale) {
         return locale || 'en-US';
     }
+    /**
+     * A built-in [dependency injection token](guide/glossary#di-token)
+     * that is used to configure the root injector for bootstrapping.
+     */
     var APPLICATION_MODULE_PROVIDERS = [
         {
             provide: ApplicationRef,
@@ -6814,8 +6818,12 @@
         },
     ];
     /**
-     * This module includes the providers of @angular/core that are needed
-     * to bootstrap components via `ApplicationRef`.
+     * Configures the root injector for an app with
+     * providers of `@angular/core` dependencies that `ApplicationRef` needs
+     * to bootstrap components.
+     *
+     * Re-exported by `BrowserModule`, which is included automatically in the root
+     * `AppModule` when you create a new app with the CLI `new` command.
      *
      * @experimental
      */
@@ -6823,13 +6831,10 @@
         // Inject ApplicationRef to make it eager...
         function ApplicationModule(appRef) {
         }
-        ApplicationModule.decorators = [
-            { type: NgModule, args: [{ providers: APPLICATION_MODULE_PROVIDERS },] }
-        ];
-        /** @nocollapse */
-        ApplicationModule.ctorParameters = function () { return [
-            { type: ApplicationRef }
-        ]; };
+        ApplicationModule = __decorate([
+            NgModule({ providers: APPLICATION_MODULE_PROVIDERS }),
+            __metadata("design:paramtypes", [ApplicationRef])
+        ], ApplicationModule);
         return ApplicationModule;
     }());
 
@@ -11816,34 +11821,55 @@
      * 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
      */
-    var ngDevModeResetPerfCounters = (typeof ngDevMode == 'undefined' && (function (global) {
-        function ngDevModeResetPerfCounters() {
-            global['ngDevMode'] = {
-                firstTemplatePass: 0,
-                tNode: 0,
-                tView: 0,
-                rendererCreateTextNode: 0,
-                rendererSetText: 0,
-                rendererCreateElement: 0,
-                rendererAddEventListener: 0,
-                rendererSetAttribute: 0,
-                rendererRemoveAttribute: 0,
-                rendererSetProperty: 0,
-                rendererSetClassName: 0,
-                rendererAddClass: 0,
-                rendererRemoveClass: 0,
-                rendererSetStyle: 0,
-                rendererRemoveStyle: 0,
-                rendererDestroy: 0,
-                rendererDestroyNode: 0,
-                rendererMoveNode: 0,
-                rendererRemoveNode: 0,
-            };
-        }
+    function ngDevModeResetPerfCounters() {
+        var newCounters = {
+            firstTemplatePass: 0,
+            tNode: 0,
+            tView: 0,
+            rendererCreateTextNode: 0,
+            rendererSetText: 0,
+            rendererCreateElement: 0,
+            rendererAddEventListener: 0,
+            rendererSetAttribute: 0,
+            rendererRemoveAttribute: 0,
+            rendererSetProperty: 0,
+            rendererSetClassName: 0,
+            rendererAddClass: 0,
+            rendererRemoveClass: 0,
+            rendererSetStyle: 0,
+            rendererRemoveStyle: 0,
+            rendererDestroy: 0,
+            rendererDestroyNode: 0,
+            rendererMoveNode: 0,
+            rendererRemoveNode: 0,
+        };
+        // NOTE: Under Ivy we may have both window & global defined in the Node
+        //    environment since ensureDocument() in render3.ts sets global.window.
+        if (typeof window != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            window['ngDevMode'] = newCounters;
+        }
+        if (typeof global != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            global['ngDevMode'] = newCounters;
+        }
+        if (typeof self != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            self['ngDevMode'] = newCounters;
+        }
+        return newCounters;
+    }
+    /**
+     * This checks to see if the `ngDevMode` has been set. If yes,
+     * than we honor it, otherwise we default to dev mode with additional checks.
+     *
+     * The idea is that unless we are doing production build where we explicitly
+     * set `ngDevMode == false` we should be helping the developer by providing
+     * as much early warning and errors as possible.
+     */
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
         ngDevModeResetPerfCounters();
-        return ngDevModeResetPerfCounters;
-    })(typeof window != 'undefined' && window || typeof self != 'undefined' && self ||
-        typeof global != 'undefined' && global));
+    }
 
     /** Called when directives inject each other (creating a circular dependency) */
     function throwCyclicDependencyError(token) {
@@ -14450,7 +14476,7 @@
      *
      * This method lazily creates the `StylingContext`. This is because in most cases
      * we have styling without any bindings. Creating `StylingContext` eagerly would mean that
-     * every style declaration such as `<div style="color: 'red' ">` would result `StyleContext`
+     * every style declaration such as `<div style="color: red">` would result `StyleContext`
      * which would create unnecessary memory pressure.
      *
      * @param index Index of the style allocation. See: `elementStyling`.
@@ -18839,6 +18865,7 @@
     exports.SkipSelf = SkipSelf;
     exports.Host = Host;
     exports.NgZone = NgZone;
+    exports.ɵNoopNgZone = NoopNgZone;
     exports.RenderComponentType = RenderComponentType;
     exports.Renderer = Renderer;
     exports.Renderer2 = Renderer2;