@angular/core 9.0.0-rc.9 → 9.0.0

package/esm5/src/render3/styling/style_binding_list.js

@@ -0,0 +1,411 @@
+/**
+* @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 { keyValueArrayIndexOf } from '../../util/array_utils';
+import { assertDataInRange, assertEqual, assertNotEqual } from '../../util/assert';
+import { assertFirstUpdatePass } from '../assert';
+import { getTStylingRangeNext, getTStylingRangePrev, setTStylingRangeNext, setTStylingRangeNextDuplicate, setTStylingRangePrev, setTStylingRangePrevDuplicate, toTStylingRange } from '../interfaces/styling';
+import { getTView } from '../state';
+/**
+ * NOTE: The word `styling` is used interchangeably as style or class styling.
+ *
+ * This file contains code to link styling instructions together so that they can be replayed in
+ * priority order. The file exists because Ivy styling instruction execution order does not match
+ * that of the priority order. The purpose of this code is to create a linked list so that the
+ * instructions can be traversed in priority order when computing the styles.
+ *
+ * Assume we are dealing with the following code:
+ * ```
+ * @Component({
+ *   template: `
+ *     <my-cmp [style]=" {color: '#001'} "
+ *             [style.color]=" #002 "
+ *             dir-style-color-1
+ *             dir-style-color-2> `
+ * })
+ * class ExampleComponent {
+ *   static ngComp = ... {
+ *     ...
+ *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`
+ *     ɵɵstyleMap({color: '#001'});
+ *     ɵɵstyleProp('color', '#002');
+ *     ...
+ *   }
+ * }
+ *
+ * @Directive({
+ *   selector: `[dir-style-color-1]',
+ * })
+ * class Style1Directive {
+ *   @HostBinding('style') style = {color: '#005'};
+ *   @HostBinding('style.color') color = '#006';
+ *
+ *   static ngDir = ... {
+ *     ...
+ *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`
+ *     ɵɵstyleMap({color: '#005'});
+ *     ɵɵstyleProp('color', '#006');
+ *     ...
+ *   }
+ * }
+ *
+ * @Directive({
+ *   selector: `[dir-style-color-2]',
+ * })
+ * class Style2Directive {
+ *   @HostBinding('style') style = {color: '#007'};
+ *   @HostBinding('style.color') color = '#008';
+ *
+ *   static ngDir = ... {
+ *     ...
+ *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`
+ *     ɵɵstyleMap({color: '#007'});
+ *     ɵɵstyleProp('color', '#008');
+ *     ...
+ *   }
+ * }
+ *
+ * @Directive({
+ *   selector: `my-cmp',
+ * })
+ * class MyComponent {
+ *   @HostBinding('style') style = {color: '#003'};
+ *   @HostBinding('style.color') color = '#004';
+ *
+ *   static ngComp = ... {
+ *     ...
+ *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`
+ *     ɵɵstyleMap({color: '#003'});
+ *     ɵɵstyleProp('color', '#004');
+ *     ...
+ *   }
+ * }
+ * ```
+ *
+ * The Order of instruction execution is:
+ *
+ * NOTE: the comment binding location is for illustrative purposes only.
+ *
+ * ```
+ * // Template: (ExampleComponent)
+ *     ɵɵstyleMap({color: '#001'});   // Binding index: 10
+ *     ɵɵstyleProp('color', '#002');  // Binding index: 12
+ * // MyComponent
+ *     ɵɵstyleMap({color: '#003'});   // Binding index: 20
+ *     ɵɵstyleProp('color', '#004');  // Binding index: 22
+ * // Style1Directive
+ *     ɵɵstyleMap({color: '#005'});   // Binding index: 24
+ *     ɵɵstyleProp('color', '#006');  // Binding index: 26
+ * // Style2Directive
+ *     ɵɵstyleMap({color: '#007'});   // Binding index: 28
+ *     ɵɵstyleProp('color', '#008');  // Binding index: 30
+ * ```
+ *
+ * The correct priority order of concatenation is:
+ *
+ * ```
+ * // MyComponent
+ *     ɵɵstyleMap({color: '#003'});   // Binding index: 20
+ *     ɵɵstyleProp('color', '#004');  // Binding index: 22
+ * // Style1Directive
+ *     ɵɵstyleMap({color: '#005'});   // Binding index: 24
+ *     ɵɵstyleProp('color', '#006');  // Binding index: 26
+ * // Style2Directive
+ *     ɵɵstyleMap({color: '#007'});   // Binding index: 28
+ *     ɵɵstyleProp('color', '#008');  // Binding index: 30
+ * // Template: (ExampleComponent)
+ *     ɵɵstyleMap({color: '#001'});   // Binding index: 10
+ *     ɵɵstyleProp('color', '#002');  // Binding index: 12
+ * ```
+ *
+ * What color should be rendered?
+ *
+ * Once the items are correctly sorted in the list, the answer is simply the last item in the
+ * concatenation list which is `#002`.
+ *
+ * To do so we keep a linked list of all of the bindings which pertain to this element.
+ * Notice that the bindings are inserted in the order of execution, but the `TView.data` allows
+ * us to traverse them in the order of priority.
+ *
+ * |Idx|`TView.data`|`LView`          | Notes
+ * |---|------------|-----------------|--------------
+ * |...|            |                 |
+ * |10 |`null`      |`{color: '#001'}`| `ɵɵstyleMap('color', {color: '#001'})`
+ * |11 |`30 | 12`   | ...             |
+ * |12 |`color`     |`'#002'`         | `ɵɵstyleProp('color', '#002')`
+ * |13 |`10 | 0`    | ...             |
+ * |...|            |                 |
+ * |20 |`null`      |`{color: '#003'}`| `ɵɵstyleMap('color', {color: '#003'})`
+ * |21 |`0 | 22`    | ...             |
+ * |22 |`color`     |`'#004'`         | `ɵɵstyleProp('color', '#004')`
+ * |23 |`20 | 24`   | ...             |
+ * |24 |`null`      |`{color: '#005'}`| `ɵɵstyleMap('color', {color: '#005'})`
+ * |25 |`22 | 26`   | ...             |
+ * |26 |`color`     |`'#006'`         | `ɵɵstyleProp('color', '#006')`
+ * |27 |`24 | 28`   | ...             |
+ * |28 |`null`      |`{color: '#007'}`| `ɵɵstyleMap('color', {color: '#007'})`
+ * |29 |`26 | 30`   | ...             |
+ * |30 |`color`     |`'#008'`         | `ɵɵstyleProp('color', '#008')`
+ * |31 |`28 | 10`   | ...             |
+ *
+ * The above data structure allows us to re-concatenate the styling no matter which data binding
+ * changes.
+ *
+ * NOTE: in addition to keeping track of next/previous index the `TView.data` also stores prev/next
+ * duplicate bit. The duplicate bit if true says there either is a binding with the same name or
+ * there is a map (which may contain the name). This information is useful in knowing if other
+ * styles with higher priority need to be searched for overwrites.
+ *
+ * NOTE: See `should support example in 'tnode_linked_list.ts' documentation` in
+ * `tnode_linked_list_spec.ts` for working example.
+ */
+var __unused_const_as_closure_does_not_like_standalone_comment_blocks__;
+/**
+ * Insert new `tStyleValue` at `TData` and link existing style bindings such that we maintain linked
+ * list of styles and compute the duplicate flag.
+ *
+ * Note: this function is executed during `firstUpdatePass` only to populate the `TView.data`.
+ *
+ * The function works by keeping track of `tStylingRange` which contains two pointers pointing to
+ * the head/tail of the template portion of the styles.
+ *  - if `isHost === false` (we are template) then insertion is at tail of `TStylingRange`
+ *  - if `isHost === true` (we are host binding) then insertion is at head of `TStylingRange`
+ *
+ * @param tData The `TData` to insert into.
+ * @param tNode `TNode` associated with the styling element.
+ * @param tStylingKey See `TStylingKey`.
+ * @param index location of where `tStyleValue` should be stored (and linked into list.)
+ * @param isHostBinding `true` if the insertion is for a `hostBinding`. (insertion is in front of
+ *               template.)
+ * @param isClassBinding True if the associated `tStylingKey` as a `class` styling.
+ *                       `tNode.classBindings` should be used (or `tNode.styleBindings` otherwise.)
+ */
+export function insertTStylingBinding(tData, tNode, tStylingKeyWithStatic, index, isHostBinding, isClassBinding) {
+    ngDevMode && assertFirstUpdatePass(getTView());
+    var tBindings = isClassBinding ? tNode.classBindings : tNode.styleBindings;
+    var tmplHead = getTStylingRangePrev(tBindings);
+    var tmplTail = getTStylingRangeNext(tBindings);
+    tData[index] = tStylingKeyWithStatic;
+    var isKeyDuplicateOfStatic = false;
+    var tStylingKey;
+    if (Array.isArray(tStylingKeyWithStatic)) {
+        // We are case when the `TStylingKey` contains static fields as well.
+        var staticKeyValueArray = tStylingKeyWithStatic;
+        tStylingKey = staticKeyValueArray[1]; // unwrap.
+        // We need to check if our key is present in the static so that we can mark it as duplicate.
+        if (tStylingKey === null ||
+            keyValueArrayIndexOf(staticKeyValueArray, tStylingKey) > 0) {
+            // tStylingKey is present in the statics, need to mark it as duplicate.
+            isKeyDuplicateOfStatic = true;
+        }
+    }
+    else {
+        tStylingKey = tStylingKeyWithStatic;
+    }
+    if (isHostBinding) {
+        // We are inserting host bindings
+        // If we don't have template bindings then `tail` is 0.
+        var hasTemplateBindings = tmplTail !== 0;
+        // This is important to know because that means that the `head` can't point to the first
+        // template bindings (there are none.) Instead the head points to the tail of the template.
+        if (hasTemplateBindings) {
+            // template head's "prev" will point to last host binding or to 0 if no host bindings yet
+            var previousNode = getTStylingRangePrev(tData[tmplHead + 1]);
+            tData[index + 1] = toTStylingRange(previousNode, tmplHead);
+            // if a host binding has already been registered, we need to update the next of that host
+            // binding to point to this one
+            if (previousNode !== 0) {
+                // We need to update the template-tail value to point to us.
+                tData[previousNode + 1] =
+                    setTStylingRangeNext(tData[previousNode + 1], index);
+            }
+            // The "previous" of the template binding head should point to this host binding
+            tData[tmplHead + 1] = setTStylingRangePrev(tData[tmplHead + 1], index);
+        }
+        else {
+            tData[index + 1] = toTStylingRange(tmplHead, 0);
+            // if a host binding has already been registered, we need to update the next of that host
+            // binding to point to this one
+            if (tmplHead !== 0) {
+                // We need to update the template-tail value to point to us.
+                tData[tmplHead + 1] = setTStylingRangeNext(tData[tmplHead + 1], index);
+            }
+            // if we don't have template, the head points to template-tail, and needs to be advanced.
+            tmplHead = index;
+        }
+    }
+    else {
+        // We are inserting in template section.
+        // We need to set this binding's "previous" to the current template tail
+        tData[index + 1] = toTStylingRange(tmplTail, 0);
+        ngDevMode && assertEqual(tmplHead !== 0 && tmplTail === 0, false, 'Adding template bindings after hostBindings is not allowed.');
+        if (tmplHead === 0) {
+            tmplHead = index;
+        }
+        else {
+            // We need to update the previous value "next" to point to this binding
+            tData[tmplTail + 1] = setTStylingRangeNext(tData[tmplTail + 1], index);
+        }
+        tmplTail = index;
+    }
+    // Now we need to update / compute the duplicates.
+    // Starting with our location search towards head (least priority)
+    if (isKeyDuplicateOfStatic) {
+        tData[index + 1] = setTStylingRangePrevDuplicate(tData[index + 1]);
+    }
+    markDuplicates(tData, tStylingKey, index, true, isClassBinding);
+    markDuplicates(tData, tStylingKey, index, false, isClassBinding);
+    markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding);
+    tBindings = toTStylingRange(tmplHead, tmplTail);
+    if (isClassBinding) {
+        tNode.classBindings = tBindings;
+    }
+    else {
+        tNode.styleBindings = tBindings;
+    }
+}
+/**
+ * Look into the residual styling to see if the current `tStylingKey` is duplicate of residual.
+ *
+ * @param tNode `TNode` where the residual is stored.
+ * @param tStylingKey `TStylingKey` to store.
+ * @param tData `TData` associated with the current `LView`.
+ * @param index location of where `tStyleValue` should be stored (and linked into list.)
+ * @param isClassBinding True if the associated `tStylingKey` as a `class` styling.
+ *                       `tNode.classBindings` should be used (or `tNode.styleBindings` otherwise.)
+ */
+function markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding) {
+    var residual = isClassBinding ? tNode.residualClasses : tNode.residualStyles;
+    if (residual != null /* or undefined */ && typeof tStylingKey == 'string' &&
+        keyValueArrayIndexOf(residual, tStylingKey) >= 0) {
+        // We have duplicate in the residual so mark ourselves as duplicate.
+        tData[index + 1] = setTStylingRangeNextDuplicate(tData[index + 1]);
+    }
+}
+/**
+ * Marks `TStyleValue`s as duplicates if another style binding in the list has the same
+ * `TStyleValue`.
+ *
+ * NOTE: this function is intended to be called twice once with `isPrevDir` set to `true` and once
+ * with it set to `false` to search both the previous as well as next items in the list.
+ *
+ * No duplicate case
+ * ```
+ *   [style.color]
+ *   [style.width.px] <<- index
+ *   [style.height.px]
+ * ```
+ *
+ * In the above case adding `[style.width.px]` to the existing `[style.color]` produces no
+ * duplicates because `width` is not found in any other part of the linked list.
+ *
+ * Duplicate case
+ * ```
+ *   [style.color]
+ *   [style.width.em]
+ *   [style.width.px] <<- index
+ * ```
+ * In the above case adding `[style.width.px]` will produce a duplicate with `[style.width.em]`
+ * because `width` is found in the chain.
+ *
+ * Map case 1
+ * ```
+ *   [style.width.px]
+ *   [style.color]
+ *   [style]  <<- index
+ * ```
+ * In the above case adding `[style]` will produce a duplicate with any other bindings because
+ * `[style]` is a Map and as such is fully dynamic and could produce `color` or `width`.
+ *
+ * Map case 2
+ * ```
+ *   [style]
+ *   [style.width.px]
+ *   [style.color]  <<- index
+ * ```
+ * In the above case adding `[style.color]` will produce a duplicate because there is already a
+ * `[style]` binding which is a Map and as such is fully dynamic and could produce `color` or
+ * `width`.
+ *
+ * NOTE: Once `[style]` (Map) is added into the system all things are mapped as duplicates.
+ * NOTE: We use `style` as example, but same logic is applied to `class`es as well.
+ *
+ * @param tData `TData` where the linked list is stored.
+ * @param tStylingKey `TStylingKeyPrimitive` which contains the value to compare to other keys in
+ *        the linked list.
+ * @param index Starting location in the linked list to search from
+ * @param isPrevDir Direction.
+ *        - `true` for previous (lower priority);
+ *        - `false` for next (higher priority).
+ */
+function markDuplicates(tData, tStylingKey, index, isPrevDir, isClassBinding) {
+    var tStylingAtIndex = tData[index + 1];
+    var isMap = tStylingKey === null;
+    var cursor = isPrevDir ? getTStylingRangePrev(tStylingAtIndex) : getTStylingRangeNext(tStylingAtIndex);
+    var foundDuplicate = false;
+    // We keep iterating as long as we have a cursor
+    // AND either:
+    // - we found what we are looking for, OR
+    // - we are a map in which case we have to continue searching even after we find what we were
+    //   looking for since we are a wild card and everything needs to be flipped to duplicate.
+    while (cursor !== 0 && (foundDuplicate === false || isMap)) {
+        ngDevMode && assertDataInRange(tData, cursor);
+        var tStylingValueAtCursor = tData[cursor];
+        var tStyleRangeAtCursor = tData[cursor + 1];
+        if (isStylingMatch(tStylingValueAtCursor, tStylingKey)) {
+            foundDuplicate = true;
+            tData[cursor + 1] = isPrevDir ? setTStylingRangeNextDuplicate(tStyleRangeAtCursor) :
+                setTStylingRangePrevDuplicate(tStyleRangeAtCursor);
+        }
+        cursor = isPrevDir ? getTStylingRangePrev(tStyleRangeAtCursor) :
+            getTStylingRangeNext(tStyleRangeAtCursor);
+    }
+    if (foundDuplicate) {
+        // if we found a duplicate, than mark ourselves.
+        tData[index + 1] = isPrevDir ? setTStylingRangePrevDuplicate(tStylingAtIndex) :
+            setTStylingRangeNextDuplicate(tStylingAtIndex);
+    }
+}
+/**
+ * Determines if two `TStylingKey`s are a match.
+ *
+ * When computing weather a binding contains a duplicate, we need to compare if the instruction
+ * `TStylingKey` has a match.
+ *
+ * Here are examples of `TStylingKey`s which match given `tStylingKeyCursor` is:
+ * - `color`
+ *    - `color`    // Match another color
+ *    - `null`     // That means that `tStylingKey` is a `classMap`/`styleMap` instruction
+ *    - `['', 'color', 'other', true]` // wrapped `color` so match
+ *    - `['', null, 'other', true]`       // wrapped `null` so match
+ *    - `['', 'width', 'color', 'value']` // wrapped static value contains a match on `'color'`
+ * - `null`       // `tStylingKeyCursor` always match as it is `classMap`/`styleMap` instruction
+ *
+ * @param tStylingKeyCursor
+ * @param tStylingKey
+ */
+function isStylingMatch(tStylingKeyCursor, tStylingKey) {
+    ngDevMode &&
+        assertNotEqual(Array.isArray(tStylingKey), true, 'Expected that \'tStylingKey\' has been unwrapped');
+    if (tStylingKeyCursor === null || // If the cursor is `null` it means that we have map at that
+        // location so we must assume that we have a match.
+        tStylingKey == null || // If `tStylingKey` is `null` then it is a map therefor assume that it
+        // contains a match.
+        (Array.isArray(tStylingKeyCursor) ? tStylingKeyCursor[1] : tStylingKeyCursor) ===
+            tStylingKey // If the keys match explicitly than we are a match.
+    ) {
+        return true;
+    }
+    else if (Array.isArray(tStylingKeyCursor) && typeof tStylingKey === 'string') {
+        // if we did not find a match, but `tStylingKeyCursor` is `KeyValueArray` that means cursor has
+        // statics and we need to check those as well.
+        return keyValueArrayIndexOf(tStylingKeyCursor, tStylingKey) >=
+            0; // see if we are matching the key
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"style_binding_list.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling/style_binding_list.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\n\nimport {KeyValueArray, keyValueArrayIndexOf} from '../../util/array_utils';\nimport {assertDataInRange, assertEqual, assertNotEqual} from '../../util/assert';\nimport {assertFirstUpdatePass} from '../assert';\nimport {TNode} from '../interfaces/node';\nimport {TStylingKey, TStylingKeyPrimitive, TStylingRange, getTStylingRangeNext, getTStylingRangePrev, setTStylingRangeNext, setTStylingRangeNextDuplicate, setTStylingRangePrev, setTStylingRangePrevDuplicate, toTStylingRange} from '../interfaces/styling';\nimport {TData} from '../interfaces/view';\nimport {getTView} from '../state';\n\n\n/**\n * NOTE: The word `styling` is used interchangeably as style or class styling.\n *\n * This file contains code to link styling instructions together so that they can be replayed in\n * priority order. The file exists because Ivy styling instruction execution order does not match\n * that of the priority order. The purpose of this code is to create a linked list so that the\n * instructions can be traversed in priority order when computing the styles.\n *\n * Assume we are dealing with the following code:\n * ```\n * @Component({\n *   template: `\n *     <my-cmp [style]=\" {color: '#001'} \"\n *             [style.color]=\" #002 \"\n *             dir-style-color-1\n *             dir-style-color-2> `\n * })\n * class ExampleComponent {\n *   static ngComp = ... {\n *     ...\n *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`\n *     ɵɵstyleMap({color: '#001'});\n *     ɵɵstyleProp('color', '#002');\n *     ...\n *   }\n * }\n *\n * @Directive({\n *   selector: `[dir-style-color-1]',\n * })\n * class Style1Directive {\n *   @HostBinding('style') style = {color: '#005'};\n *   @HostBinding('style.color') color = '#006';\n *\n *   static ngDir = ... {\n *     ...\n *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`\n *     ɵɵstyleMap({color: '#005'});\n *     ɵɵstyleProp('color', '#006');\n *     ...\n *   }\n * }\n *\n * @Directive({\n *   selector: `[dir-style-color-2]',\n * })\n * class Style2Directive {\n *   @HostBinding('style') style = {color: '#007'};\n *   @HostBinding('style.color') color = '#008';\n *\n *   static ngDir = ... {\n *     ...\n *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`\n *     ɵɵstyleMap({color: '#007'});\n *     ɵɵstyleProp('color', '#008');\n *     ...\n *   }\n * }\n *\n * @Directive({\n *   selector: `my-cmp',\n * })\n * class MyComponent {\n *   @HostBinding('style') style = {color: '#003'};\n *   @HostBinding('style.color') color = '#004';\n *\n *   static ngComp = ... {\n *     ...\n *     // Compiler ensures that `ɵɵstyleProp` is after `ɵɵstyleMap`\n *     ɵɵstyleMap({color: '#003'});\n *     ɵɵstyleProp('color', '#004');\n *     ...\n *   }\n * }\n * ```\n *\n * The Order of instruction execution is:\n *\n * NOTE: the comment binding location is for illustrative purposes only.\n *\n * ```\n * // Template: (ExampleComponent)\n *     ɵɵstyleMap({color: '#001'});   // Binding index: 10\n *     ɵɵstyleProp('color', '#002');  // Binding index: 12\n * // MyComponent\n *     ɵɵstyleMap({color: '#003'});   // Binding index: 20\n *     ɵɵstyleProp('color', '#004');  // Binding index: 22\n * // Style1Directive\n *     ɵɵstyleMap({color: '#005'});   // Binding index: 24\n *     ɵɵstyleProp('color', '#006');  // Binding index: 26\n * // Style2Directive\n *     ɵɵstyleMap({color: '#007'});   // Binding index: 28\n *     ɵɵstyleProp('color', '#008');  // Binding index: 30\n * ```\n *\n * The correct priority order of concatenation is:\n *\n * ```\n * // MyComponent\n *     ɵɵstyleMap({color: '#003'});   // Binding index: 20\n *     ɵɵstyleProp('color', '#004');  // Binding index: 22\n * // Style1Directive\n *     ɵɵstyleMap({color: '#005'});   // Binding index: 24\n *     ɵɵstyleProp('color', '#006');  // Binding index: 26\n * // Style2Directive\n *     ɵɵstyleMap({color: '#007'});   // Binding index: 28\n *     ɵɵstyleProp('color', '#008');  // Binding index: 30\n * // Template: (ExampleComponent)\n *     ɵɵstyleMap({color: '#001'});   // Binding index: 10\n *     ɵɵstyleProp('color', '#002');  // Binding index: 12\n * ```\n *\n * What color should be rendered?\n *\n * Once the items are correctly sorted in the list, the answer is simply the last item in the\n * concatenation list which is `#002`.\n *\n * To do so we keep a linked list of all of the bindings which pertain to this element.\n * Notice that the bindings are inserted in the order of execution, but the `TView.data` allows\n * us to traverse them in the order of priority.\n *\n * |Idx|`TView.data`|`LView`          | Notes\n * |---|------------|-----------------|--------------\n * |...|            |                 |\n * |10 |`null`      |`{color: '#001'}`| `ɵɵstyleMap('color', {color: '#001'})`\n * |11 |`30 | 12`   | ...             |\n * |12 |`color`     |`'#002'`         | `ɵɵstyleProp('color', '#002')`\n * |13 |`10 | 0`    | ...             |\n * |...|            |                 |\n * |20 |`null`      |`{color: '#003'}`| `ɵɵstyleMap('color', {color: '#003'})`\n * |21 |`0 | 22`    | ...             |\n * |22 |`color`     |`'#004'`         | `ɵɵstyleProp('color', '#004')`\n * |23 |`20 | 24`   | ...             |\n * |24 |`null`      |`{color: '#005'}`| `ɵɵstyleMap('color', {color: '#005'})`\n * |25 |`22 | 26`   | ...             |\n * |26 |`color`     |`'#006'`         | `ɵɵstyleProp('color', '#006')`\n * |27 |`24 | 28`   | ...             |\n * |28 |`null`      |`{color: '#007'}`| `ɵɵstyleMap('color', {color: '#007'})`\n * |29 |`26 | 30`   | ...             |\n * |30 |`color`     |`'#008'`         | `ɵɵstyleProp('color', '#008')`\n * |31 |`28 | 10`   | ...             |\n *\n * The above data structure allows us to re-concatenate the styling no matter which data binding\n * changes.\n *\n * NOTE: in addition to keeping track of next/previous index the `TView.data` also stores prev/next\n * duplicate bit. The duplicate bit if true says there either is a binding with the same name or\n * there is a map (which may contain the name). This information is useful in knowing if other\n * styles with higher priority need to be searched for overwrites.\n *\n * NOTE: See `should support example in 'tnode_linked_list.ts' documentation` in\n * `tnode_linked_list_spec.ts` for working example.\n */\nlet __unused_const_as_closure_does_not_like_standalone_comment_blocks__: undefined;\n\n/**\n * Insert new `tStyleValue` at `TData` and link existing style bindings such that we maintain linked\n * list of styles and compute the duplicate flag.\n *\n * Note: this function is executed during `firstUpdatePass` only to populate the `TView.data`.\n *\n * The function works by keeping track of `tStylingRange` which contains two pointers pointing to\n * the head/tail of the template portion of the styles.\n *  - if `isHost === false` (we are template) then insertion is at tail of `TStylingRange`\n *  - if `isHost === true` (we are host binding) then insertion is at head of `TStylingRange`\n *\n * @param tData The `TData` to insert into.\n * @param tNode `TNode` associated with the styling element.\n * @param tStylingKey See `TStylingKey`.\n * @param index location of where `tStyleValue` should be stored (and linked into list.)\n * @param isHostBinding `true` if the insertion is for a `hostBinding`. (insertion is in front of\n *               template.)\n * @param isClassBinding True if the associated `tStylingKey` as a `class` styling.\n *                       `tNode.classBindings` should be used (or `tNode.styleBindings` otherwise.)\n */\nexport function insertTStylingBinding(\n    tData: TData, tNode: TNode, tStylingKeyWithStatic: TStylingKey, index: number,\n    isHostBinding: boolean, isClassBinding: boolean): void {\n  ngDevMode && assertFirstUpdatePass(getTView());\n  let tBindings = isClassBinding ? tNode.classBindings : tNode.styleBindings;\n  let tmplHead = getTStylingRangePrev(tBindings);\n  let tmplTail = getTStylingRangeNext(tBindings);\n\n  tData[index] = tStylingKeyWithStatic;\n  let isKeyDuplicateOfStatic = false;\n  let tStylingKey: TStylingKeyPrimitive;\n  if (Array.isArray(tStylingKeyWithStatic)) {\n    // We are case when the `TStylingKey` contains static fields as well.\n    const staticKeyValueArray = tStylingKeyWithStatic as KeyValueArray<any>;\n    tStylingKey = staticKeyValueArray[1];  // unwrap.\n    // We need to check if our key is present in the static so that we can mark it as duplicate.\n    if (tStylingKey === null ||\n        keyValueArrayIndexOf(staticKeyValueArray, tStylingKey as string) > 0) {\n      // tStylingKey is present in the statics, need to mark it as duplicate.\n      isKeyDuplicateOfStatic = true;\n    }\n  } else {\n    tStylingKey = tStylingKeyWithStatic;\n  }\n  if (isHostBinding) {\n    // We are inserting host bindings\n\n    // If we don't have template bindings then `tail` is 0.\n    const hasTemplateBindings = tmplTail !== 0;\n    // This is important to know because that means that the `head` can't point to the first\n    // template bindings (there are none.) Instead the head points to the tail of the template.\n    if (hasTemplateBindings) {\n      // template head's \"prev\" will point to last host binding or to 0 if no host bindings yet\n      const previousNode = getTStylingRangePrev(tData[tmplHead + 1] as TStylingRange);\n      tData[index + 1] = toTStylingRange(previousNode, tmplHead);\n      // if a host binding has already been registered, we need to update the next of that host\n      // binding to point to this one\n      if (previousNode !== 0) {\n        // We need to update the template-tail value to point to us.\n        tData[previousNode + 1] =\n            setTStylingRangeNext(tData[previousNode + 1] as TStylingRange, index);\n      }\n      // The \"previous\" of the template binding head should point to this host binding\n      tData[tmplHead + 1] = setTStylingRangePrev(tData[tmplHead + 1] as TStylingRange, index);\n    } else {\n      tData[index + 1] = toTStylingRange(tmplHead, 0);\n      // if a host binding has already been registered, we need to update the next of that host\n      // binding to point to this one\n      if (tmplHead !== 0) {\n        // We need to update the template-tail value to point to us.\n        tData[tmplHead + 1] = setTStylingRangeNext(tData[tmplHead + 1] as TStylingRange, index);\n      }\n      // if we don't have template, the head points to template-tail, and needs to be advanced.\n      tmplHead = index;\n    }\n  } else {\n    // We are inserting in template section.\n    // We need to set this binding's \"previous\" to the current template tail\n    tData[index + 1] = toTStylingRange(tmplTail, 0);\n    ngDevMode && assertEqual(\n                     tmplHead !== 0 && tmplTail === 0, false,\n                     'Adding template bindings after hostBindings is not allowed.');\n    if (tmplHead === 0) {\n      tmplHead = index;\n    } else {\n      // We need to update the previous value \"next\" to point to this binding\n      tData[tmplTail + 1] = setTStylingRangeNext(tData[tmplTail + 1] as TStylingRange, index);\n    }\n    tmplTail = index;\n  }\n\n  // Now we need to update / compute the duplicates.\n  // Starting with our location search towards head (least priority)\n  if (isKeyDuplicateOfStatic) {\n    tData[index + 1] = setTStylingRangePrevDuplicate(tData[index + 1] as TStylingRange);\n  }\n  markDuplicates(tData, tStylingKey, index, true, isClassBinding);\n  markDuplicates(tData, tStylingKey, index, false, isClassBinding);\n  markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding);\n\n  tBindings = toTStylingRange(tmplHead, tmplTail);\n  if (isClassBinding) {\n    tNode.classBindings = tBindings;\n  } else {\n    tNode.styleBindings = tBindings;\n  }\n}\n\n/**\n * Look into the residual styling to see if the current `tStylingKey` is duplicate of residual.\n *\n * @param tNode `TNode` where the residual is stored.\n * @param tStylingKey `TStylingKey` to store.\n * @param tData `TData` associated with the current `LView`.\n * @param index location of where `tStyleValue` should be stored (and linked into list.)\n * @param isClassBinding True if the associated `tStylingKey` as a `class` styling.\n *                       `tNode.classBindings` should be used (or `tNode.styleBindings` otherwise.)\n */\nfunction markDuplicateOfResidualStyling(\n    tNode: TNode, tStylingKey: TStylingKey, tData: TData, index: number, isClassBinding: boolean) {\n  const residual = isClassBinding ? tNode.residualClasses : tNode.residualStyles;\n  if (residual != null /* or undefined */ && typeof tStylingKey == 'string' &&\n      keyValueArrayIndexOf(residual, tStylingKey) >= 0) {\n    // We have duplicate in the residual so mark ourselves as duplicate.\n    tData[index + 1] = setTStylingRangeNextDuplicate(tData[index + 1] as TStylingRange);\n  }\n}\n\n\n/**\n * Marks `TStyleValue`s as duplicates if another style binding in the list has the same\n * `TStyleValue`.\n *\n * NOTE: this function is intended to be called twice once with `isPrevDir` set to `true` and once\n * with it set to `false` to search both the previous as well as next items in the list.\n *\n * No duplicate case\n * ```\n *   [style.color]\n *   [style.width.px] <<- index\n *   [style.height.px]\n * ```\n *\n * In the above case adding `[style.width.px]` to the existing `[style.color]` produces no\n * duplicates because `width` is not found in any other part of the linked list.\n *\n * Duplicate case\n * ```\n *   [style.color]\n *   [style.width.em]\n *   [style.width.px] <<- index\n * ```\n * In the above case adding `[style.width.px]` will produce a duplicate with `[style.width.em]`\n * because `width` is found in the chain.\n *\n * Map case 1\n * ```\n *   [style.width.px]\n *   [style.color]\n *   [style]  <<- index\n * ```\n * In the above case adding `[style]` will produce a duplicate with any other bindings because\n * `[style]` is a Map and as such is fully dynamic and could produce `color` or `width`.\n *\n * Map case 2\n * ```\n *   [style]\n *   [style.width.px]\n *   [style.color]  <<- index\n * ```\n * In the above case adding `[style.color]` will produce a duplicate because there is already a\n * `[style]` binding which is a Map and as such is fully dynamic and could produce `color` or\n * `width`.\n *\n * NOTE: Once `[style]` (Map) is added into the system all things are mapped as duplicates.\n * NOTE: We use `style` as example, but same logic is applied to `class`es as well.\n *\n * @param tData `TData` where the linked list is stored.\n * @param tStylingKey `TStylingKeyPrimitive` which contains the value to compare to other keys in\n *        the linked list.\n * @param index Starting location in the linked list to search from\n * @param isPrevDir Direction.\n *        - `true` for previous (lower priority);\n *        - `false` for next (higher priority).\n */\nfunction markDuplicates(\n    tData: TData, tStylingKey: TStylingKeyPrimitive, index: number, isPrevDir: boolean,\n    isClassBinding: boolean) {\n  const tStylingAtIndex = tData[index + 1] as TStylingRange;\n  const isMap = tStylingKey === null;\n  let cursor =\n      isPrevDir ? getTStylingRangePrev(tStylingAtIndex) : getTStylingRangeNext(tStylingAtIndex);\n  let foundDuplicate = false;\n  // We keep iterating as long as we have a cursor\n  // AND either:\n  // - we found what we are looking for, OR\n  // - we are a map in which case we have to continue searching even after we find what we were\n  //   looking for since we are a wild card and everything needs to be flipped to duplicate.\n  while (cursor !== 0 && (foundDuplicate === false || isMap)) {\n    ngDevMode && assertDataInRange(tData, cursor);\n    const tStylingValueAtCursor = tData[cursor] as TStylingKey;\n    const tStyleRangeAtCursor = tData[cursor + 1] as TStylingRange;\n    if (isStylingMatch(tStylingValueAtCursor, tStylingKey)) {\n      foundDuplicate = true;\n      tData[cursor + 1] = isPrevDir ? setTStylingRangeNextDuplicate(tStyleRangeAtCursor) :\n                                      setTStylingRangePrevDuplicate(tStyleRangeAtCursor);\n    }\n    cursor = isPrevDir ? getTStylingRangePrev(tStyleRangeAtCursor) :\n                         getTStylingRangeNext(tStyleRangeAtCursor);\n  }\n  if (foundDuplicate) {\n    // if we found a duplicate, than mark ourselves.\n    tData[index + 1] = isPrevDir ? setTStylingRangePrevDuplicate(tStylingAtIndex) :\n                                   setTStylingRangeNextDuplicate(tStylingAtIndex);\n  }\n}\n\n/**\n * Determines if two `TStylingKey`s are a match.\n *\n * When computing weather a binding contains a duplicate, we need to compare if the instruction\n * `TStylingKey` has a match.\n *\n * Here are examples of `TStylingKey`s which match given `tStylingKeyCursor` is:\n * - `color`\n *    - `color`    // Match another color\n *    - `null`     // That means that `tStylingKey` is a `classMap`/`styleMap` instruction\n *    - `['', 'color', 'other', true]` // wrapped `color` so match\n *    - `['', null, 'other', true]`       // wrapped `null` so match\n *    - `['', 'width', 'color', 'value']` // wrapped static value contains a match on `'color'`\n * - `null`       // `tStylingKeyCursor` always match as it is `classMap`/`styleMap` instruction\n *\n * @param tStylingKeyCursor\n * @param tStylingKey\n */\nfunction isStylingMatch(tStylingKeyCursor: TStylingKey, tStylingKey: TStylingKeyPrimitive) {\n  ngDevMode &&\n      assertNotEqual(\n          Array.isArray(tStylingKey), true, 'Expected that \\'tStylingKey\\' has been unwrapped');\n  if (tStylingKeyCursor === null ||  // If the cursor is `null` it means that we have map at that\n                                     // location so we must assume that we have a match.\n      tStylingKey == null ||  // If `tStylingKey` is `null` then it is a map therefor assume that it\n                              // contains a match.\n      (Array.isArray(tStylingKeyCursor) ? tStylingKeyCursor[1] : tStylingKeyCursor) ===\n          tStylingKey  // If the keys match explicitly than we are a match.\n      ) {\n    return true;\n  } else if (Array.isArray(tStylingKeyCursor) && typeof tStylingKey === 'string') {\n    // if we did not find a match, but `tStylingKeyCursor` is `KeyValueArray` that means cursor has\n    // statics and we need to check those as well.\n    return keyValueArrayIndexOf(tStylingKeyCursor, tStylingKey) >=\n        0;  // see if we are matching the key\n  }\n  return false;\n}\n"]}