@angular/core 9.1.7 → 9.1.11

package/bundles/core.umd.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
  */
@@ -2126,7 +2126,15 @@
      * 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
@@ -2511,12 +2519,6 @@
     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
@@ -6413,6 +6415,24 @@
             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
@@ -6766,8 +6786,10 @@
         parent, //
         projection, //
         styles, //
+        stylesWithoutHost, //
         residualStyles, //
         classes, //
+        classesWithoutHost, //
         residualClasses, //
         classBindings, //
         styleBindings) {
@@ -6795,8 +6817,10 @@
             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;
@@ -7190,17 +7214,9 @@
         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
@@ -7656,7 +7672,7 @@
             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
@@ -7796,7 +7812,7 @@
             // 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);
@@ -8167,8 +8183,10 @@
         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) :
@@ -8196,8 +8214,10 @@
                 parent: tParent,
                 projection: null,
                 styles: null,
+                stylesWithoutHost: null,
                 residualStyles: undefined,
                 classes: null,
+                classesWithoutHost: null,
                 residualClasses: undefined,
                 classBindings: 0,
                 styleBindings: 0,
@@ -8844,7 +8864,7 @@
         // 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
@@ -8858,10 +8878,10 @@
         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];
@@ -8873,60 +8893,31 @@
             }
         }
     }
-    /**
-     * 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 */;
             }
         }
     }
@@ -9497,7 +9488,7 @@
             // 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];
@@ -10286,10 +10277,6 @@
             this._cdRefInjectingView = _cdRefInjectingView;
             this._appRef = null;
             this._viewContainerRef = null;
-            /**
-             * @internal
-             */
-            this._tViewNode = null;
         }
         Object.defineProperty(ViewRef.prototype, "rootNodes", {
             get: function () {
@@ -10682,9 +10669,7 @@
                         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));
@@ -10875,7 +10860,6 @@
         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;
@@ -11066,7 +11050,7 @@
     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.
@@ -13527,29 +13511,34 @@
      *
      * @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;
     }
 
     /**
@@ -14641,8 +14630,11 @@
         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);
@@ -14731,11 +14723,11 @@
                 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);
         }
     }
     /**
@@ -14803,7 +14795,7 @@
         // 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);
@@ -16686,7 +16678,7 @@
                 // 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) {
@@ -19191,7 +19183,7 @@
         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) {
@@ -20227,7 +20219,7 @@
     /**
      * @publicApi
      */
-    var VERSION = new Version('9.1.7');
+    var VERSION = new Version('9.1.11');
 
     /**
      * @license
@@ -23353,7 +23345,8 @@
             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;
         };
@@ -23388,7 +23381,7 @@
             _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;
         }