@angular/core 9.1.7 → 9.1.11

package/fesm2015/testing.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.7
+ * @license Angular v9.1.11
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm5/core.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.7
+ * @license Angular v9.1.11
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1941,7 +1941,15 @@ var TYPE = 1;
  * without having to remember the specific indices.
  * Uglify will inline these when minifying so there shouldn't be a cost.
  */
-var ACTIVE_INDEX = 2;
+/**
+ * Flag to signify that this `LContainer` may have transplanted views which need to be change
+ * detected. (see: `LView[DECLARATION_COMPONENT_VIEW])`.
+ *
+ * This flag, once set, is never unset for the `LContainer`. This means that when unset we can skip
+ * a lot of work in `refreshEmbeddedViews`. But when set we still need to verify
+ * that the `MOVED_VIEWS` are transplanted and on-push.
+ */
+var HAS_TRANSPLANTED_VIEWS = 2;
 // PARENT, NEXT, TRANSPLANTED_VIEWS_TO_REFRESH are indices 3, 4, and 5
 // As we already have these constants in LView, we don't need to re-create them.
 // T_HOST is index 6
@@ -2326,12 +2334,6 @@ function getConstant(consts, index) {
 function resetPreOrderHookFlags(lView) {
     lView[PREORDER_HOOK_FLAGS] = 0;
 }
-function getLContainerActiveIndex(lContainer) {
-    return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
-}
-function setLContainerActiveIndex(lContainer, index) {
-    lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
-}
 /**
  * Updates the `TRANSPLANTED_VIEWS_TO_REFRESH` counter on the `LContainer` as well as the parents
  * whose
@@ -6238,6 +6240,24 @@ function getRootContext(viewOrComponent) {
         assertDefined(rootView[CONTEXT], 'RootView has no context. Perhaps it is disconnected?');
     return rootView[CONTEXT];
 }
+/**
+ * Gets the first `LContainer` in the LView or `null` if none exists.
+ */
+function getFirstLContainer(lView) {
+    return getNearestLContainer(lView[CHILD_HEAD]);
+}
+/**
+ * Gets the next `LContainer` that is a sibling of the given container.
+ */
+function getNextLContainer(container) {
+    return getNearestLContainer(container[NEXT]);
+}
+function getNearestLContainer(viewOrContainer) {
+    while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
+        viewOrContainer = viewOrContainer[NEXT];
+    }
+    return viewOrContainer;
+}
 
 /**
  * @license
@@ -6591,8 +6611,10 @@ var TNode = /** @class */ (function () {
     parent, //
     projection, //
     styles, //
+    stylesWithoutHost, //
     residualStyles, //
     classes, //
+    classesWithoutHost, //
     residualClasses, //
     classBindings, //
     styleBindings) {
@@ -6620,8 +6642,10 @@ var TNode = /** @class */ (function () {
         this.parent = parent;
         this.projection = projection;
         this.styles = styles;
+        this.stylesWithoutHost = stylesWithoutHost;
         this.residualStyles = residualStyles;
         this.classes = classes;
+        this.classesWithoutHost = classesWithoutHost;
         this.residualClasses = residualClasses;
         this.classBindings = classBindings;
         this.styleBindings = styleBindings;
@@ -7015,17 +7039,9 @@ var LContainerDebug = /** @class */ (function () {
     function LContainerDebug(_raw_lContainer) {
         this._raw_lContainer = _raw_lContainer;
     }
-    Object.defineProperty(LContainerDebug.prototype, "activeIndex", {
-        get: function () {
-            return getLContainerActiveIndex(this._raw_lContainer);
-        },
-        enumerable: true,
-        configurable: true
-    });
     Object.defineProperty(LContainerDebug.prototype, "hasTransplantedViews", {
         get: function () {
-            return (this._raw_lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) ===
-                1 /* HAS_TRANSPLANTED_VIEWS */;
+            return this._raw_lContainer[HAS_TRANSPLANTED_VIEWS];
         },
         enumerable: true,
         configurable: true
@@ -7481,7 +7497,7 @@ function assignTViewNodeToLView(tView, tParentNode, index, lView) {
         tView.node = tNode = createTNode(tView, tParentNode, //
         2 /* View */, index, null, null);
     }
-    return lView[T_HOST] = tNode;
+    lView[T_HOST] = tNode;
 }
 /**
  * When elements are created dynamically after a view blueprint is created (e.g. through
@@ -7621,7 +7637,7 @@ function refreshView(tView, lView, templateFn, context) {
         // insertion points. This is needed to avoid the situation where the template is defined in this
         // `LView` but its declaration appears after the insertion component.
         markTransplantedViewsForRefresh(lView);
-        refreshDynamicEmbeddedViews(lView);
+        refreshEmbeddedViews(lView);
         // Content query results must be refreshed before content hooks are called.
         if (tView.contentQueries !== null) {
             refreshContentQueries(tView, lView);
@@ -7992,8 +8008,10 @@ function createTNode(tView, tParent, type, adjustedIndex, tagName, attrs) {
     tParent, // parent: TElementNode|TContainerNode|null
     null, // projection: number|(ITNode|RNode[])[]|null
     null, // styles: string|null
+    null, // stylesWithoutHost: string|null
     undefined, // residualStyles: string|null
     null, // classes: string|null
+    null, // classesWithoutHost: string|null
     undefined, // residualClasses: string|null
     0, // classBindings: TStylingRange;
     0) :
@@ -8021,8 +8039,10 @@ function createTNode(tView, tParent, type, adjustedIndex, tagName, attrs) {
             parent: tParent,
             projection: null,
             styles: null,
+            stylesWithoutHost: null,
             residualStyles: undefined,
             classes: null,
+            classesWithoutHost: null,
             residualClasses: undefined,
             classBindings: 0,
             styleBindings: 0,
@@ -8669,7 +8689,7 @@ function createLContainer(hostNative, currentView, native, tNode) {
     // https://jsperf.com/array-literal-vs-new-array-really
     var lContainer = new (ngDevMode ? LContainerArray : Array)(hostNative, // host native
     true, // Boolean `true` in this position signifies that this is an `LContainer`
-    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */ << 1 /* SHIFT */, // active index
+    false, // has transplanted views
     currentView, // parent
     null, // next
     0, // transplanted views to refresh count
@@ -8683,10 +8703,10 @@ function createLContainer(hostNative, currentView, native, tNode) {
     return lContainer;
 }
 /**
- * Goes over dynamic embedded views (ones created through ViewContainerRef APIs) and refreshes
+ * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes
  * them by executing an associated template function.
  */
-function refreshDynamicEmbeddedViews(lView) {
+function refreshEmbeddedViews(lView) {
     for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
         for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
             var embeddedLView = lContainer[i];
@@ -8698,60 +8718,31 @@ function refreshDynamicEmbeddedViews(lView) {
         }
     }
 }
-/**
- * Gets the first `LContainer` in the LView or `null` if none exists.
- */
-function getFirstLContainer(lView) {
-    var viewOrContainer = lView[CHILD_HEAD];
-    while (viewOrContainer !== null &&
-        !(isLContainer(viewOrContainer) &&
-            viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
-                -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
-        viewOrContainer = viewOrContainer[NEXT];
-    }
-    return viewOrContainer;
-}
-/**
- * Gets the next `LContainer` that is a sibling of the given container.
- */
-function getNextLContainer(container) {
-    var viewOrContainer = container[NEXT];
-    while (viewOrContainer !== null &&
-        !(isLContainer(viewOrContainer) &&
-            viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
-                -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
-        viewOrContainer = viewOrContainer[NEXT];
-    }
-    return viewOrContainer;
-}
 /**
  * Mark transplanted views as needing to be refreshed at their insertion points.
  *
- * See: `ActiveIndexFlag.HAS_TRANSPLANTED_VIEWS` and `LView[DECLARATION_COMPONENT_VIEW]` for
- * explanation of transplanted views.
- *
  * @param lView The `LView` that may have transplanted views.
  */
 function markTransplantedViewsForRefresh(lView) {
     for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
-        if ((lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
-            var movedViews = lContainer[MOVED_VIEWS];
-            ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
-            for (var i = 0; i < movedViews.length; i++) {
-                var movedLView = movedViews[i];
-                var insertionLContainer = movedLView[PARENT];
-                ngDevMode && assertLContainer(insertionLContainer);
-                // We don't want to increment the counter if the moved LView was already marked for
-                // refresh.
-                if ((movedLView[FLAGS] & 1024 /* RefreshTransplantedView */) === 0) {
-                    updateTransplantedViewCount(insertionLContainer, 1);
-                }
-                // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
-                // those that aren't (declaration component === insertion component). In the latter case,
-                // it's fine to add the flag, as we will clear it immediately in
-                // `refreshDynamicEmbeddedViews` for the view currently being refreshed.
-                movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
+        if (!lContainer[HAS_TRANSPLANTED_VIEWS])
+            continue;
+        var movedViews = lContainer[MOVED_VIEWS];
+        ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
+        for (var i = 0; i < movedViews.length; i++) {
+            var movedLView = movedViews[i];
+            var insertionLContainer = movedLView[PARENT];
+            ngDevMode && assertLContainer(insertionLContainer);
+            // We don't want to increment the counter if the moved LView was already marked for
+            // refresh.
+            if ((movedLView[FLAGS] & 1024 /* RefreshTransplantedView */) === 0) {
+                updateTransplantedViewCount(insertionLContainer, 1);
             }
+            // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
+            // those that aren't (declaration component === insertion component). In the latter case,
+            // it's fine to add the flag, as we will clear it immediately in
+            // `refreshEmbeddedViews` for the view currently being refreshed.
+            movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
         }
     }
 }
@@ -9322,7 +9313,7 @@ function trackMovedView(declarationContainer, lView) {
         // At this point the declaration-component is not same as insertion-component; this means that
         // this is a transplanted view. Mark the declared lView as having transplanted views so that
         // those views can participate in CD.
-        declarationContainer[ACTIVE_INDEX] |= 1 /* HAS_TRANSPLANTED_VIEWS */;
+        declarationContainer[HAS_TRANSPLANTED_VIEWS] = true;
     }
     if (movedViews === null) {
         declarationContainer[MOVED_VIEWS] = [lView];
@@ -10111,10 +10102,6 @@ var ViewRef = /** @class */ (function () {
         this._cdRefInjectingView = _cdRefInjectingView;
         this._appRef = null;
         this._viewContainerRef = null;
-        /**
-         * @internal
-         */
-        this._tViewNode = null;
     }
     Object.defineProperty(ViewRef.prototype, "rootNodes", {
         get: function () {
@@ -10507,9 +10494,7 @@ function createTemplateRef(TemplateRefToken, ElementRefToken, hostTNode, hostVie
                     embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
                 }
                 renderView(embeddedTView, embeddedLView, context);
-                var viewRef = new ViewRef(embeddedLView);
-                viewRef._tViewNode = embeddedLView[T_HOST];
-                return viewRef;
+                return new ViewRef(embeddedLView);
             };
             return TemplateRef;
         }(TemplateRefToken));
@@ -10700,7 +10685,6 @@ function createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, h
     if (isLContainer(slotValue)) {
         // If the host is a container, we don't need to create a new LContainer
         lContainer = slotValue;
-        setLContainerActiveIndex(lContainer, -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */);
     }
     else {
         var commentNode = void 0;
@@ -10891,7 +10875,7 @@ function isType(v) {
 var DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*arguments\)/;
 var INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
 var INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
-var INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s+super\(\.\.\.arguments\)/;
+var INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s*super\(\.\.\.arguments\)/;
 /**
  * Determine whether a stringified type is a class which delegates its constructor
  * to its parent.
@@ -13352,29 +13336,34 @@ function componentDefResolved(type) {
  *
  * @param tNode The `TNode` into which the styling information should be loaded.
  * @param attrs `TAttributes` containing the styling information.
+ * @param writeToHost Where should the resulting static styles be written?
+ *   - `false` Write to `TNode.stylesWithoutHost` / `TNode.classesWithoutHost`
+ *   - `true` Write to `TNode.styles` / `TNode.classes`
  */
-function computeStaticStyling(tNode, attrs) {
+function computeStaticStyling(tNode, attrs, writeToHost) {
     ngDevMode &&
         assertFirstCreatePass(getTView(), 'Expecting to be called in first template pass only');
-    var styles = tNode.styles;
-    var classes = tNode.classes;
+    var styles = writeToHost ? tNode.styles : null;
+    var classes = writeToHost ? tNode.classes : null;
     var mode = 0;
-    for (var i = 0; i < attrs.length; i++) {
-        var value = attrs[i];
-        if (typeof value === 'number') {
-            mode = value;
-        }
-        else if (mode == 1 /* Classes */) {
-            classes = concatStringsWithSpace(classes, value);
-        }
-        else if (mode == 2 /* Styles */) {
-            var style = value;
-            var styleValue = attrs[++i];
-            styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+    if (attrs !== null) {
+        for (var i = 0; i < attrs.length; i++) {
+            var value = attrs[i];
+            if (typeof value === 'number') {
+                mode = value;
+            }
+            else if (mode == 1 /* Classes */) {
+                classes = concatStringsWithSpace(classes, value);
+            }
+            else if (mode == 2 /* Styles */) {
+                var style = value;
+                var styleValue = attrs[++i];
+                styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+            }
         }
     }
-    styles !== null && (tNode.styles = styles);
-    classes !== null && (tNode.classes = classes);
+    writeToHost ? tNode.styles = styles : tNode.stylesWithoutHost = styles;
+    writeToHost ? tNode.classes = classes : tNode.classesWithoutHost = classes;
 }
 
 /**
@@ -14466,8 +14455,11 @@ function elementStartFirstCreatePass(index, tView, lView, native, name, attrsInd
     var tNode = getOrCreateTNode(tView, lView[T_HOST], index, 3 /* Element */, name, attrs);
     var hasDirectives = resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
     ngDevMode && warnAboutUnknownElement(tView, lView, native, tNode, hasDirectives);
+    if (tNode.attrs !== null) {
+        computeStaticStyling(tNode, tNode.attrs, false);
+    }
     if (tNode.mergedAttrs !== null) {
-        computeStaticStyling(tNode, tNode.mergedAttrs);
+        computeStaticStyling(tNode, tNode.mergedAttrs, true);
     }
     if (tView.queries !== null) {
         tView.queries.elementStart(tView, tNode);
@@ -14556,11 +14548,11 @@ function ɵɵelementEnd() {
             tView.queries.elementEnd(previousOrParentTNode);
         }
     }
-    if (tNode.classes !== null && hasClassInput(tNode)) {
-        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classes, true);
+    if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);
     }
-    if (tNode.styles !== null && hasStyleInput(tNode)) {
-        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.styles, false);
+    if (tNode.stylesWithoutHost != null && hasStyleInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.stylesWithoutHost, false);
     }
 }
 /**
@@ -14628,7 +14620,7 @@ function elementContainerStartFirstCreatePass(index, tView, lView, attrsIndex, l
     // While ng-container doesn't necessarily support styling, we use the style context to identify
     // and execute directives on the ng-container.
     if (attrs !== null) {
-        computeStaticStyling(tNode, attrs);
+        computeStaticStyling(tNode, attrs, true);
     }
     var localRefs = getConstant(tViewConsts, localRefsIndex);
     resolveDirectives(tView, lView, tNode, localRefs);
@@ -16511,7 +16503,7 @@ function checkStylingMap(keyValueArraySet, stringParser, value, isClassBased) {
             // the binding has removed it. This would confuse `[ngStyle]`/`[ngClass]` to do the wrong
             // thing as it would think that the static portion was removed. For this reason we
             // concatenate it so that `[ngStyle]`/`[ngClass]`  can continue to work on changed.
-            var staticPrefix = isClassBased ? tNode.classes : tNode.styles;
+            var staticPrefix = isClassBased ? tNode.classesWithoutHost : tNode.stylesWithoutHost;
             ngDevMode && isClassBased === false && staticPrefix !== null &&
                 assertEqual(staticPrefix.endsWith(';'), true, 'Expecting static portion to end with \';\'');
             if (staticPrefix !== null) {
@@ -19016,7 +19008,7 @@ function createRootComponentView(rNode, def, rootView, rendererFactory, hostRend
     var tNode = getOrCreateTNode(tView, null, 0, 3 /* Element */, null, null);
     var mergedAttrs = tNode.mergedAttrs = def.hostAttrs;
     if (mergedAttrs !== null) {
-        computeStaticStyling(tNode, mergedAttrs);
+        computeStaticStyling(tNode, mergedAttrs, true);
         if (rNode !== null) {
             setUpAttributes(hostRenderer, rNode, mergedAttrs);
             if (tNode.classes !== null) {
@@ -20057,7 +20049,7 @@ var Version = /** @class */ (function () {
 /**
  * @publicApi
  */
-var VERSION = new Version('9.1.7');
+var VERSION = new Version('9.1.11');
 
 /**
  * @license
@@ -23183,7 +23175,8 @@ var ComponentFactory$1 = /** @class */ (function (_super) {
         if (!rootSelectorOrNode || isIsolated) {
             // The host element of the internal or isolated root view is attached to the component's host
             // view node.
-            componentRef.hostView._tViewNode.child = tElementNode;
+            ngDevMode && assertNodeOfPossibleTypes(rootTView.node, 2 /* View */);
+            rootTView.node.child = tElementNode;
         }
         return componentRef;
     };
@@ -23218,7 +23211,7 @@ var ComponentRef$1 = /** @class */ (function (_super) {
         _this.destroyCbs = [];
         _this.instance = instance;
         _this.hostView = _this.changeDetectorRef = new RootViewRef(_rootLView);
-        _this.hostView._tViewNode = assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
+        assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
         _this.componentType = componentType;
         return _this;
     }