@angular/core 8.0.3 → 8.1.0-beta.0

package/esm5/src/render3/styling_next/map_based_bindings.js

@@ -0,0 +1,324 @@
+import { setStylingMapsSyncFn } from './bindings';
+import { getBindingValue, getValuesCount, isStylingValueDefined } from './util';
+/**
+ * --------
+ *
+ * This file contains the algorithm logic for applying map-based bindings
+ * such as `[style]` and `[class]`.
+ *
+ * --------
+ */
+/**
+ * Used to apply styling values presently within any map-based bindings on an element.
+ *
+ * Angular supports map-based styling bindings which can be applied via the
+ * `[style]` and `[class]` bindings which can be placed on any HTML element.
+ * These bindings can work independently, together or alongside prop-based
+ * styling bindings (e.g. `<div [style]="x" [style.width]="w">`).
+ *
+ * If a map-based styling binding is detected by the compiler, the following
+ * AOT code is produced:
+ *
+ * ```typescript
+ * styleMap(ctx.styles); // styles = {key:value}
+ * classMap(ctx.classes); // classes = {key:value}|string
+ * ```
+ *
+ * If and when either of the instructions above are evaluated, then the code
+ * present in this file is included into the bundle. The mechanism used, to
+ * activate support for map-based bindings at runtime is possible via the
+ * `activeStylingMapFeature` function (which is also present in this file).
+ *
+ * # The Algorithm
+ * Whenever a map-based binding updates (which is when the identity of the
+ * map-value changes) then the map is iterated over and a `LStylingMap` array
+ * is produced. The `LStylingMap` instance is stored in the binding location
+ * where the `BINDING_INDEX` is situated when the `styleMap()` or `classMap()`
+ * instruction were called. Once the binding changes, then the internal `bitMask`
+ * value is marked as dirty.
+ *
+ * Styling values are applied once CD exits the element (which happens when
+ * the `select(n)` instruction is called or the template function exits). When
+ * this occurs, all prop-based bindings are applied. If a map-based binding is
+ * present then a special flushing function (called a sync function) is made
+ * available and it will be called each time a styling property is flushed.
+ *
+ * The flushing algorithm is designed to apply styling for a property (which is
+ * a CSS property or a className value) one by one. If map-based bindings
+ * are present, then the flushing algorithm will keep calling the maps styling
+ * sync function each time a property is visited. This way, the flushing
+ * behavior of map-based bindings will always be at the same property level
+ * as the current prop-based property being iterated over (because everything
+ * is alphabetically sorted).
+ *
+ * Let's imagine we have the following HTML template code:
+ *
+ * ```html
+ * <div [style]="{width:'100px', height:'200px', 'z-index':'10'}"
+ *      [style.width.px]="200">...</div>
+ * ```
+ *
+ * When CD occurs, both the `[style]` and `[style.width]` bindings
+ * are evaluated. Then when the styles are flushed on screen, the
+ * following operations happen:
+ *
+ * 1. `[style.width]` is attempted to be written to the element.
+ *
+ * 2.  Once that happens, the algorithm instructs the map-based
+ *     entries (`[style]` in this case) to "catch up" and apply
+ *     all values up to the `width` value. When this happens the
+ *     `height` value is applied to the element (since it is
+ *     alphabetically situated before the `width` property).
+ *
+ * 3. Since there are no more prop-based entries anymore, the
+ *    loop exits and then, just before the flushing ends, it
+ *    instructs all map-based bindings to "finish up" applying
+ *    their values.
+ *
+ * 4. The only remaining value within the map-based entries is
+ *    the `z-index` value (`width` got skipped because it was
+ *    successfully applied via the prop-based `[style.width]`
+ *    binding). Since all map-based entries are told to "finish up",
+ *    the `z-index` value is iterated over and it is then applied
+ *    to the element.
+ *
+ * The most important thing to take note of here is that prop-based
+ * bindings are evaluated in order alongside map-based bindings.
+ * This allows all styling across an element to be applied in O(n)
+ * time (a similar algorithm is that of the array merge algorithm
+ * in merge sort).
+ */
+export var syncStylingMap = function (context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, defaultValue) {
+    var targetPropValueWasApplied = false;
+    // once the map-based styling code is activate it is never deactivated. For this reason a
+    // check to see if the current styling context has any map based bindings is required.
+    var totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
+    if (totalMaps) {
+        var runTheSyncAlgorithm = true;
+        var loopUntilEnd = !targetProp;
+        // If the code is told to finish up (run until the end), but the mode
+        // hasn't been flagged to apply values (it only traverses values) then
+        // there is no point in iterating over the array because nothing will
+        // be applied to the element.
+        if (loopUntilEnd && (mode & ~1 /* ApplyAllValues */)) {
+            runTheSyncAlgorithm = false;
+            targetPropValueWasApplied = true;
+        }
+        if (runTheSyncAlgorithm) {
+            targetPropValueWasApplied = innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp || null, 0, defaultValue || null);
+        }
+        if (loopUntilEnd) {
+            resetSyncCursors();
+        }
+    }
+    return targetPropValueWasApplied;
+};
+/**
+ * Recursive function designed to apply map-based styling to an element one map at a time.
+ *
+ * This function is designed to be called from the `syncStylingMap` function and will
+ * apply map-based styling data one map at a time to the provided `element`.
+ *
+ * This function is recursive and it will call itself if a follow-up map value is to be
+ * processed. To learn more about how the algorithm works, see `syncStylingMap`.
+ */
+function innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, currentMapIndex, defaultValue) {
+    var targetPropValueWasApplied = false;
+    var totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
+    if (currentMapIndex < totalMaps) {
+        var bindingIndex = getBindingValue(context, 2 /* MapBindingsPosition */, currentMapIndex);
+        var lStylingMap = data[bindingIndex];
+        var cursor = getCurrentSyncCursor(currentMapIndex);
+        while (cursor < lStylingMap.length) {
+            var prop = getMapProp(lStylingMap, cursor);
+            var iteratedTooFar = targetProp && prop > targetProp;
+            var isTargetPropMatched = !iteratedTooFar && prop === targetProp;
+            var value = getMapValue(lStylingMap, cursor);
+            var valueIsDefined = isStylingValueDefined(value);
+            // the recursive code is designed to keep applying until
+            // it reaches or goes past the target prop. If and when
+            // this happens then it will stop processing values, but
+            // all other map values must also catch up to the same
+            // point. This is why a recursive call is still issued
+            // even if the code has iterated too far.
+            var innerMode = iteratedTooFar ? mode : resolveInnerMapMode(mode, valueIsDefined, isTargetPropMatched);
+            var innerProp = iteratedTooFar ? targetProp : prop;
+            var valueApplied = innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, innerMode, innerProp, currentMapIndex + 1, defaultValue);
+            if (iteratedTooFar) {
+                break;
+            }
+            if (!valueApplied && isValueAllowedToBeApplied(mode, isTargetPropMatched)) {
+                var useDefault = isTargetPropMatched && !valueIsDefined;
+                var valueToApply = useDefault ? defaultValue : value;
+                var bindingIndexToApply = useDefault ? bindingIndex : null;
+                var finalValue = sanitizer ?
+                    sanitizer(prop, valueToApply, 3 /* ValidateAndSanitize */) :
+                    valueToApply;
+                applyStylingFn(renderer, element, prop, finalValue, bindingIndexToApply);
+                valueApplied = true;
+            }
+            targetPropValueWasApplied = valueApplied && isTargetPropMatched;
+            cursor += 2 /* TupleSize */;
+        }
+        setCurrentSyncCursor(currentMapIndex, cursor);
+    }
+    return targetPropValueWasApplied;
+}
+/**
+ * Enables support for map-based styling bindings (e.g. `[style]` and `[class]` bindings).
+ */
+export function activeStylingMapFeature() {
+    setStylingMapsSyncFn(syncStylingMap);
+}
+/**
+ * Used to determine the mode for the inner recursive call.
+ *
+ * If an inner map is iterated on then this is done so for one
+ * of two reasons:
+ *
+ * - The target property was detected and the inner map
+ *   must now "catch up" (pointer-wise) up to where the current
+ *   map's cursor is situated.
+ *
+ * - The target property was not detected in the current map
+ *   and must be found in an inner map. This can only be allowed
+ *   if the current map iteration is not set to skip the target
+ *   property.
+ */
+function resolveInnerMapMode(currentMode, valueIsDefined, isExactMatch) {
+    var innerMode = currentMode;
+    if (!valueIsDefined && isExactMatch && !(currentMode & 4 /* SkipTargetProp */)) {
+        // case 1: set the mode to apply the targeted prop value if it
+        // ends up being encountered in another map value
+        innerMode |= 2 /* ApplyTargetProp */;
+        innerMode &= ~4 /* SkipTargetProp */;
+    }
+    else {
+        // case 2: set the mode to skip the targeted prop value if it
+        // ends up being encountered in another map value
+        innerMode |= 4 /* SkipTargetProp */;
+        innerMode &= ~2 /* ApplyTargetProp */;
+    }
+    return innerMode;
+}
+/**
+ * Decides whether or not a prop/value entry will be applied to an element.
+ *
+ * To determine whether or not a value is to be applied,
+ * the following procedure is evaluated:
+ *
+ * First check to see the current `mode` status:
+ *  1. If the mode value permits all props to be applied then allow.
+ *    - But do not allow if the current prop is set to be skipped.
+ *  2. Otherwise if the current prop is permitted then allow.
+ */
+function isValueAllowedToBeApplied(mode, isTargetPropMatched) {
+    var doApplyValue = (mode & 1 /* ApplyAllValues */) > 0;
+    if (!doApplyValue) {
+        if (mode & 2 /* ApplyTargetProp */) {
+            doApplyValue = isTargetPropMatched;
+        }
+    }
+    else if ((mode & 4 /* SkipTargetProp */) && isTargetPropMatched) {
+        doApplyValue = false;
+    }
+    return doApplyValue;
+}
+/**
+ * Used to keep track of concurrent cursor values for multiple map-based styling bindings present on
+ * an element.
+ */
+var MAP_CURSORS = [];
+/**
+ * Used to reset the state of each cursor value being used to iterate over map-based styling
+ * bindings.
+ */
+function resetSyncCursors() {
+    for (var i = 0; i < MAP_CURSORS.length; i++) {
+        MAP_CURSORS[i] = 1 /* ValuesStartPosition */;
+    }
+}
+/**
+ * Returns an active cursor value at a given mapIndex location.
+ */
+function getCurrentSyncCursor(mapIndex) {
+    if (mapIndex >= MAP_CURSORS.length) {
+        MAP_CURSORS.push(1 /* ValuesStartPosition */);
+    }
+    return MAP_CURSORS[mapIndex];
+}
+/**
+ * Sets a cursor value at a given mapIndex location.
+ */
+function setCurrentSyncCursor(mapIndex, indexValue) {
+    MAP_CURSORS[mapIndex] = indexValue;
+}
+/**
+ * Used to convert a {key:value} map into a `LStylingMap` array.
+ *
+ * This function will either generate a new `LStylingMap` instance
+ * or it will patch the provided `newValues` map value into an
+ * existing `LStylingMap` value (this only happens if `bindingValue`
+ * is an instance of `LStylingMap`).
+ *
+ * If a new key/value map is provided with an old `LStylingMap`
+ * value then all properties will be overwritten with their new
+ * values or with `null`. This means that the array will never
+ * shrink in size (but it will also not be created and thrown
+ * away whenever the {key:value} map entries change).
+ */
+export function normalizeIntoStylingMap(bindingValue, newValues) {
+    var lStylingMap = Array.isArray(bindingValue) ? bindingValue : [null];
+    lStylingMap[0 /* RawValuePosition */] = newValues || null;
+    // because the new values may not include all the properties
+    // that the old ones had, all values are set to `null` before
+    // the new values are applied. This way, when flushed, the
+    // styling algorithm knows exactly what style/class values
+    // to remove from the element (since they are `null`).
+    for (var j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
+        setMapValue(lStylingMap, j, null);
+    }
+    var props = null;
+    var map;
+    var allValuesTrue = false;
+    if (typeof newValues === 'string') { // [class] bindings allow string values
+        if (newValues.length) {
+            props = newValues.split(/\s+/);
+            allValuesTrue = true;
+        }
+    }
+    else {
+        props = newValues ? Object.keys(newValues) : null;
+        map = newValues;
+    }
+    if (props) {
+        outer: for (var i = 0; i < props.length; i++) {
+            var prop = props[i];
+            var value = allValuesTrue ? true : map[prop];
+            for (var j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
+                var propAtIndex = getMapProp(lStylingMap, j);
+                if (prop <= propAtIndex) {
+                    if (propAtIndex === prop) {
+                        setMapValue(lStylingMap, j, value);
+                    }
+                    else {
+                        lStylingMap.splice(j, 0, prop, value);
+                    }
+                    continue outer;
+                }
+            }
+            lStylingMap.push(prop, value);
+        }
+    }
+    return lStylingMap;
+}
+export function getMapProp(map, index) {
+    return map[index + 0 /* PropOffset */];
+}
+export function setMapValue(map, index, value) {
+    map[index + 1 /* ValueOffset */] = value;
+}
+export function getMapValue(map, index) {
+    return map[index + 1 /* ValueOffset */];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map_based_bindings.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling_next/map_based_bindings.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*/\nimport {StyleSanitizeFn, StyleSanitizeMode} from '../../sanitization/style_sanitizer';\nimport {ProceduralRenderer3, RElement, Renderer3} from '../interfaces/renderer';\n\nimport {setStylingMapsSyncFn} from './bindings';\nimport {ApplyStylingFn, LStylingData, LStylingMap, LStylingMapIndex, StylingMapsSyncMode, SyncStylingMapsFn, TStylingContext, TStylingContextIndex} from './interfaces';\nimport {getBindingValue, getValuesCount, isStylingValueDefined} from './util';\n\n\n/**\n * --------\n *\n * This file contains the algorithm logic for applying map-based bindings\n * such as `[style]` and `[class]`.\n *\n * --------\n */\n\n/**\n * Used to apply styling values presently within any map-based bindings on an element.\n *\n * Angular supports map-based styling bindings which can be applied via the\n * `[style]` and `[class]` bindings which can be placed on any HTML element.\n * These bindings can work independently, together or alongside prop-based\n * styling bindings (e.g. `<div [style]=\"x\" [style.width]=\"w\">`).\n *\n * If a map-based styling binding is detected by the compiler, the following\n * AOT code is produced:\n *\n * ```typescript\n * styleMap(ctx.styles); // styles = {key:value}\n * classMap(ctx.classes); // classes = {key:value}|string\n * ```\n *\n * If and when either of the instructions above are evaluated, then the code\n * present in this file is included into the bundle. The mechanism used, to\n * activate support for map-based bindings at runtime is possible via the\n * `activeStylingMapFeature` function (which is also present in this file).\n *\n * # The Algorithm\n * Whenever a map-based binding updates (which is when the identity of the\n * map-value changes) then the map is iterated over and a `LStylingMap` array\n * is produced. The `LStylingMap` instance is stored in the binding location\n * where the `BINDING_INDEX` is situated when the `styleMap()` or `classMap()`\n * instruction were called. Once the binding changes, then the internal `bitMask`\n * value is marked as dirty.\n *\n * Styling values are applied once CD exits the element (which happens when\n * the `select(n)` instruction is called or the template function exits). When\n * this occurs, all prop-based bindings are applied. If a map-based binding is\n * present then a special flushing function (called a sync function) is made\n * available and it will be called each time a styling property is flushed.\n *\n * The flushing algorithm is designed to apply styling for a property (which is\n * a CSS property or a className value) one by one. If map-based bindings\n * are present, then the flushing algorithm will keep calling the maps styling\n * sync function each time a property is visited. This way, the flushing\n * behavior of map-based bindings will always be at the same property level\n * as the current prop-based property being iterated over (because everything\n * is alphabetically sorted).\n *\n * Let's imagine we have the following HTML template code:\n *\n * ```html\n * <div [style]=\"{width:'100px', height:'200px', 'z-index':'10'}\"\n *      [style.width.px]=\"200\">...</div>\n * ```\n *\n * When CD occurs, both the `[style]` and `[style.width]` bindings\n * are evaluated. Then when the styles are flushed on screen, the\n * following operations happen:\n *\n * 1. `[style.width]` is attempted to be written to the element.\n *\n * 2.  Once that happens, the algorithm instructs the map-based\n *     entries (`[style]` in this case) to \"catch up\" and apply\n *     all values up to the `width` value. When this happens the\n *     `height` value is applied to the element (since it is\n *     alphabetically situated before the `width` property).\n *\n * 3. Since there are no more prop-based entries anymore, the\n *    loop exits and then, just before the flushing ends, it\n *    instructs all map-based bindings to \"finish up\" applying\n *    their values.\n *\n * 4. The only remaining value within the map-based entries is\n *    the `z-index` value (`width` got skipped because it was\n *    successfully applied via the prop-based `[style.width]`\n *    binding). Since all map-based entries are told to \"finish up\",\n *    the `z-index` value is iterated over and it is then applied\n *    to the element.\n *\n * The most important thing to take note of here is that prop-based\n * bindings are evaluated in order alongside map-based bindings.\n * This allows all styling across an element to be applied in O(n)\n * time (a similar algorithm is that of the array merge algorithm\n * in merge sort).\n */\nexport const syncStylingMap: SyncStylingMapsFn =\n    (context: TStylingContext, renderer: Renderer3 | ProceduralRenderer3 | null, element: RElement,\n     data: LStylingData, applyStylingFn: ApplyStylingFn, sanitizer: StyleSanitizeFn | null,\n     mode: StylingMapsSyncMode, targetProp?: string | null,\n     defaultValue?: string | null): boolean => {\n      let targetPropValueWasApplied = false;\n\n      // once the map-based styling code is activate it is never deactivated. For this reason a\n      // check to see if the current styling context has any map based bindings is required.\n      const totalMaps = getValuesCount(context, TStylingContextIndex.MapBindingsPosition);\n      if (totalMaps) {\n        let runTheSyncAlgorithm = true;\n        const loopUntilEnd = !targetProp;\n\n        // If the code is told to finish up (run until the end), but the mode\n        // hasn't been flagged to apply values (it only traverses values) then\n        // there is no point in iterating over the array because nothing will\n        // be applied to the element.\n        if (loopUntilEnd && (mode & ~StylingMapsSyncMode.ApplyAllValues)) {\n          runTheSyncAlgorithm = false;\n          targetPropValueWasApplied = true;\n        }\n\n        if (runTheSyncAlgorithm) {\n          targetPropValueWasApplied = innerSyncStylingMap(\n              context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp || null,\n              0, defaultValue || null);\n        }\n\n        if (loopUntilEnd) {\n          resetSyncCursors();\n        }\n      }\n\n      return targetPropValueWasApplied;\n    };\n\n/**\n * Recursive function designed to apply map-based styling to an element one map at a time.\n *\n * This function is designed to be called from the `syncStylingMap` function and will\n * apply map-based styling data one map at a time to the provided `element`.\n *\n * This function is recursive and it will call itself if a follow-up map value is to be\n * processed. To learn more about how the algorithm works, see `syncStylingMap`.\n */\nfunction innerSyncStylingMap(\n    context: TStylingContext, renderer: Renderer3 | ProceduralRenderer3 | null, element: RElement,\n    data: LStylingData, applyStylingFn: ApplyStylingFn, sanitizer: StyleSanitizeFn | null,\n    mode: StylingMapsSyncMode, targetProp: string | null, currentMapIndex: number,\n    defaultValue: string | null): boolean {\n  let targetPropValueWasApplied = false;\n\n  const totalMaps = getValuesCount(context, TStylingContextIndex.MapBindingsPosition);\n  if (currentMapIndex < totalMaps) {\n    const bindingIndex = getBindingValue(\n        context, TStylingContextIndex.MapBindingsPosition, currentMapIndex) as number;\n    const lStylingMap = data[bindingIndex] as LStylingMap;\n\n    let cursor = getCurrentSyncCursor(currentMapIndex);\n    while (cursor < lStylingMap.length) {\n      const prop = getMapProp(lStylingMap, cursor);\n      const iteratedTooFar = targetProp && prop > targetProp;\n      const isTargetPropMatched = !iteratedTooFar && prop === targetProp;\n      const value = getMapValue(lStylingMap, cursor);\n      const valueIsDefined = isStylingValueDefined(value);\n\n      // the recursive code is designed to keep applying until\n      // it reaches or goes past the target prop. If and when\n      // this happens then it will stop processing values, but\n      // all other map values must also catch up to the same\n      // point. This is why a recursive call is still issued\n      // even if the code has iterated too far.\n      const innerMode =\n          iteratedTooFar ? mode : resolveInnerMapMode(mode, valueIsDefined, isTargetPropMatched);\n      const innerProp = iteratedTooFar ? targetProp : prop;\n      let valueApplied = innerSyncStylingMap(\n          context, renderer, element, data, applyStylingFn, sanitizer, innerMode, innerProp,\n          currentMapIndex + 1, defaultValue);\n\n      if (iteratedTooFar) {\n        break;\n      }\n\n      if (!valueApplied && isValueAllowedToBeApplied(mode, isTargetPropMatched)) {\n        const useDefault = isTargetPropMatched && !valueIsDefined;\n        const valueToApply = useDefault ? defaultValue : value;\n        const bindingIndexToApply = useDefault ? bindingIndex : null;\n        const finalValue = sanitizer ?\n            sanitizer(prop, valueToApply, StyleSanitizeMode.ValidateAndSanitize) :\n            valueToApply;\n        applyStylingFn(renderer, element, prop, finalValue, bindingIndexToApply);\n        valueApplied = true;\n      }\n\n      targetPropValueWasApplied = valueApplied && isTargetPropMatched;\n      cursor += LStylingMapIndex.TupleSize;\n    }\n    setCurrentSyncCursor(currentMapIndex, cursor);\n  }\n\n  return targetPropValueWasApplied;\n}\n\n\n/**\n * Enables support for map-based styling bindings (e.g. `[style]` and `[class]` bindings).\n */\nexport function activeStylingMapFeature() {\n  setStylingMapsSyncFn(syncStylingMap);\n}\n\n/**\n * Used to determine the mode for the inner recursive call.\n *\n * If an inner map is iterated on then this is done so for one\n * of two reasons:\n *\n * - The target property was detected and the inner map\n *   must now \"catch up\" (pointer-wise) up to where the current\n *   map's cursor is situated.\n *\n * - The target property was not detected in the current map\n *   and must be found in an inner map. This can only be allowed\n *   if the current map iteration is not set to skip the target\n *   property.\n */\nfunction resolveInnerMapMode(\n    currentMode: number, valueIsDefined: boolean, isExactMatch: boolean): number {\n  let innerMode = currentMode;\n  if (!valueIsDefined && isExactMatch && !(currentMode & StylingMapsSyncMode.SkipTargetProp)) {\n    // case 1: set the mode to apply the targeted prop value if it\n    // ends up being encountered in another map value\n    innerMode |= StylingMapsSyncMode.ApplyTargetProp;\n    innerMode &= ~StylingMapsSyncMode.SkipTargetProp;\n  } else {\n    // case 2: set the mode to skip the targeted prop value if it\n    // ends up being encountered in another map value\n    innerMode |= StylingMapsSyncMode.SkipTargetProp;\n    innerMode &= ~StylingMapsSyncMode.ApplyTargetProp;\n  }\n  return innerMode;\n}\n\n/**\n * Decides whether or not a prop/value entry will be applied to an element.\n *\n * To determine whether or not a value is to be applied,\n * the following procedure is evaluated:\n *\n * First check to see the current `mode` status:\n *  1. If the mode value permits all props to be applied then allow.\n *    - But do not allow if the current prop is set to be skipped.\n *  2. Otherwise if the current prop is permitted then allow.\n */\nfunction isValueAllowedToBeApplied(mode: number, isTargetPropMatched: boolean) {\n  let doApplyValue = (mode & StylingMapsSyncMode.ApplyAllValues) > 0;\n  if (!doApplyValue) {\n    if (mode & StylingMapsSyncMode.ApplyTargetProp) {\n      doApplyValue = isTargetPropMatched;\n    }\n  } else if ((mode & StylingMapsSyncMode.SkipTargetProp) && isTargetPropMatched) {\n    doApplyValue = false;\n  }\n  return doApplyValue;\n}\n\n/**\n * Used to keep track of concurrent cursor values for multiple map-based styling bindings present on\n * an element.\n */\nconst MAP_CURSORS: number[] = [];\n\n/**\n * Used to reset the state of each cursor value being used to iterate over map-based styling\n * bindings.\n */\nfunction resetSyncCursors() {\n  for (let i = 0; i < MAP_CURSORS.length; i++) {\n    MAP_CURSORS[i] = LStylingMapIndex.ValuesStartPosition;\n  }\n}\n\n/**\n * Returns an active cursor value at a given mapIndex location.\n */\nfunction getCurrentSyncCursor(mapIndex: number) {\n  if (mapIndex >= MAP_CURSORS.length) {\n    MAP_CURSORS.push(LStylingMapIndex.ValuesStartPosition);\n  }\n  return MAP_CURSORS[mapIndex];\n}\n\n/**\n * Sets a cursor value at a given mapIndex location.\n */\nfunction setCurrentSyncCursor(mapIndex: number, indexValue: number) {\n  MAP_CURSORS[mapIndex] = indexValue;\n}\n\n/**\n * Used to convert a {key:value} map into a `LStylingMap` array.\n *\n * This function will either generate a new `LStylingMap` instance\n * or it will patch the provided `newValues` map value into an\n * existing `LStylingMap` value (this only happens if `bindingValue`\n * is an instance of `LStylingMap`).\n *\n * If a new key/value map is provided with an old `LStylingMap`\n * value then all properties will be overwritten with their new\n * values or with `null`. This means that the array will never\n * shrink in size (but it will also not be created and thrown\n * away whenever the {key:value} map entries change).\n */\nexport function normalizeIntoStylingMap(\n    bindingValue: null | LStylingMap,\n    newValues: {[key: string]: any} | string | null | undefined): LStylingMap {\n  const lStylingMap: LStylingMap = Array.isArray(bindingValue) ? bindingValue : [null];\n  lStylingMap[LStylingMapIndex.RawValuePosition] = newValues || null;\n\n  // because the new values may not include all the properties\n  // that the old ones had, all values are set to `null` before\n  // the new values are applied. This way, when flushed, the\n  // styling algorithm knows exactly what style/class values\n  // to remove from the element (since they are `null`).\n  for (let j = LStylingMapIndex.ValuesStartPosition; j < lStylingMap.length;\n       j += LStylingMapIndex.TupleSize) {\n    setMapValue(lStylingMap, j, null);\n  }\n\n  let props: string[]|null = null;\n  let map: {[key: string]: any}|undefined|null;\n  let allValuesTrue = false;\n  if (typeof newValues === 'string') {  // [class] bindings allow string values\n    if (newValues.length) {\n      props = newValues.split(/\\s+/);\n      allValuesTrue = true;\n    }\n  } else {\n    props = newValues ? Object.keys(newValues) : null;\n    map = newValues;\n  }\n\n  if (props) {\n    outer: for (let i = 0; i < props.length; i++) {\n      const prop = props[i] as string;\n      const value = allValuesTrue ? true : map ![prop];\n      for (let j = LStylingMapIndex.ValuesStartPosition; j < lStylingMap.length;\n           j += LStylingMapIndex.TupleSize) {\n        const propAtIndex = getMapProp(lStylingMap, j);\n        if (prop <= propAtIndex) {\n          if (propAtIndex === prop) {\n            setMapValue(lStylingMap, j, value);\n          } else {\n            lStylingMap.splice(j, 0, prop, value);\n          }\n          continue outer;\n        }\n      }\n      lStylingMap.push(prop, value);\n    }\n  }\n\n  return lStylingMap;\n}\n\nexport function getMapProp(map: LStylingMap, index: number): string {\n  return map[index + LStylingMapIndex.PropOffset] as string;\n}\n\nexport function setMapValue(map: LStylingMap, index: number, value: string | null): void {\n  map[index + LStylingMapIndex.ValueOffset] = value;\n}\n\nexport function getMapValue(map: LStylingMap, index: number): string|null {\n  return map[index + LStylingMapIndex.ValueOffset] as string | null;\n}\n"]}

package/esm5/src/render3/styling_next/state.js

@@ -0,0 +1,23 @@
+var _stylingMode = 0;
+/**
+ * Temporary function used to inform the existing styling algorithm
+ * code to delegate all styling instruction calls to the new refactored
+ * styling code.
+ */
+export function runtimeSetStylingMode(mode) {
+    _stylingMode = mode;
+}
+export function runtimeIsNewStylingInUse() {
+    return _stylingMode > 0 /* UseOld */;
+}
+export function runtimeAllowOldStyling() {
+    return _stylingMode < 2 /* UseNew */;
+}
+var _currentSanitizer;
+export function setCurrentStyleSanitizer(sanitizer) {
+    _currentSanitizer = sanitizer;
+}
+export function getCurrentStyleSanitizer() {
+    return _currentSanitizer;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/src/render3/styling_next/styling_debug.js

@@ -0,0 +1,130 @@
+import { attachDebugObject } from '../util/debug_utils';
+import { applyStyling } from './bindings';
+import { activeStylingMapFeature } from './map_based_bindings';
+import { getCurrentOrLViewSanitizer, getDefaultValue, getGuardMask, getProp, getValuesCount, isContextLocked, isSanitizationRequired } from './util';
+/**
+ * Instantiates and attaches an instance of `TStylingContextDebug` to the provided context.
+ */
+export function attachStylingDebugObject(context) {
+    var debug = new TStylingContextDebug(context);
+    attachDebugObject(context, debug);
+    return debug;
+}
+/**
+ * A human-readable debug summary of the styling data present within `TStylingContext`.
+ *
+ * This class is designed to be used within testing code or when an
+ * application has `ngDevMode` activated.
+ */
+var TStylingContextDebug = /** @class */ (function () {
+    function TStylingContextDebug(context) {
+        this.context = context;
+    }
+    Object.defineProperty(TStylingContextDebug.prototype, "isLocked", {
+        get: function () { return isContextLocked(this.context); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TStylingContextDebug.prototype, "entries", {
+        /**
+         * Returns a detailed summary of each styling entry in the context.
+         *
+         * See `TStylingTupleSummary`.
+         */
+        get: function () {
+            var context = this.context;
+            var entries = {};
+            var start = 2 /* MapBindingsPosition */;
+            var i = start;
+            while (i < context.length) {
+                var valuesCount = getValuesCount(context, i);
+                // the context may contain placeholder values which are populated ahead of time,
+                // but contain no actual binding values. In this situation there is no point in
+                // classifying this as an "entry" since no real data is stored here yet.
+                if (valuesCount) {
+                    var prop = getProp(context, i);
+                    var guardMask = getGuardMask(context, i);
+                    var defaultValue = getDefaultValue(context, i);
+                    var sanitizationRequired = isSanitizationRequired(context, i);
+                    var bindingsStartPosition = i + 3 /* BindingsStartOffset */;
+                    var sources = [];
+                    for (var j = 0; j < valuesCount; j++) {
+                        sources.push(context[bindingsStartPosition + j]);
+                    }
+                    entries[prop] = { prop: prop, guardMask: guardMask, sanitizationRequired: sanitizationRequired, valuesCount: valuesCount, defaultValue: defaultValue, sources: sources };
+                }
+                i += 3 /* BindingsStartOffset */ + valuesCount;
+            }
+            return entries;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TStylingContextDebug;
+}());
+/**
+ * A human-readable debug summary of the styling data present for a `DebugNode` instance.
+ *
+ * This class is designed to be used within testing code or when an
+ * application has `ngDevMode` activated.
+ */
+var NodeStylingDebug = /** @class */ (function () {
+    function NodeStylingDebug(context, _data, _isClassBased) {
+        this.context = context;
+        this._data = _data;
+        this._isClassBased = _isClassBased;
+        this._sanitizer = null;
+    }
+    /**
+     * Overrides the sanitizer used to process styles.
+     */
+    NodeStylingDebug.prototype.overrideSanitizer = function (sanitizer) { this._sanitizer = sanitizer; };
+    Object.defineProperty(NodeStylingDebug.prototype, "summary", {
+        /**
+         * Returns a detailed summary of each styling entry in the context and
+         * what their runtime representation is.
+         *
+         * See `LStylingSummary`.
+         */
+        get: function () {
+            var entries = {};
+            this._mapValues(function (prop, value, bindingIndex) {
+                entries[prop] = { prop: prop, value: value, bindingIndex: bindingIndex };
+            });
+            return entries;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeStylingDebug.prototype, "values", {
+        /**
+         * Returns a key/value map of all the styles/classes that were last applied to the element.
+         */
+        get: function () {
+            var entries = {};
+            this._mapValues(function (prop, value) { entries[prop] = value; });
+            return entries;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    NodeStylingDebug.prototype._mapValues = function (fn) {
+        // there is no need to store/track an element instance. The
+        // element is only used when the styling algorithm attempts to
+        // style the value (and we mock out the stylingApplyFn anyway).
+        var mockElement = {};
+        var hasMaps = getValuesCount(this.context, 2 /* MapBindingsPosition */) > 0;
+        if (hasMaps) {
+            activeStylingMapFeature();
+        }
+        var mapFn = function (renderer, element, prop, value, bindingIndex) {
+            fn(prop, value, bindingIndex || null);
+        };
+        var sanitizer = this._isClassBased ? null : (this._sanitizer ||
+            getCurrentOrLViewSanitizer(this._data));
+        applyStyling(this.context, null, mockElement, this._data, true, mapFn, sanitizer);
+    };
+    return NodeStylingDebug;
+}());
+export { NodeStylingDebug };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling_debug.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling_next/styling_debug.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*/\nimport {Sanitizer} from '../../sanitization/security';\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {RElement} from '../interfaces/renderer';\nimport {LView, SANITIZER} from '../interfaces/view';\nimport {attachDebugObject} from '../util/debug_utils';\n\nimport {applyStyling} from './bindings';\nimport {ApplyStylingFn, LStylingData, TStylingContext, TStylingContextIndex} from './interfaces';\nimport {activeStylingMapFeature} from './map_based_bindings';\nimport {getCurrentStyleSanitizer} from './state';\nimport {getCurrentOrLViewSanitizer, getDefaultValue, getGuardMask, getProp, getValuesCount, isContextLocked, isMapBased, isSanitizationRequired} from './util';\n\n\n\n/**\n * --------\n *\n * This file contains the core debug functionality for styling in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n\n/**\n * A debug/testing-oriented summary of a styling entry.\n *\n * A value such as this is generated as an artifact of the `DebugStyling`\n * summary.\n */\nexport interface LStylingSummary {\n  /** The style/class property that the summary is attached to */\n  prop: string;\n\n  /** The last applied value for the style/class property */\n  value: string|boolean|null;\n\n  /** The binding index of the last applied style/class property */\n  bindingIndex: number|null;\n}\n\n/**\n * A debug/testing-oriented summary of all styling entries for a `DebugNode` instance.\n */\nexport interface DebugStyling {\n  /** The associated TStylingContext instance */\n  context: TStylingContext;\n\n  /**\n   * A summarization of each style/class property\n   * present in the context.\n   */\n  summary: {[key: string]: LStylingSummary};\n\n  /**\n   * A key/value map of all styling properties and their\n   * runtime values.\n   */\n  values: {[key: string]: string | number | null | boolean};\n\n  /**\n   * Overrides the sanitizer used to process styles.\n   */\n  overrideSanitizer(sanitizer: StyleSanitizeFn|null): void;\n}\n\n/**\n * A debug/testing-oriented summary of all styling entries within a `TStylingContext`.\n */\nexport interface TStylingTupleSummary {\n  /** The property (style or class property) that this tuple represents */\n  prop: string;\n\n  /** The total amount of styling entries apart of this tuple */\n  valuesCount: number;\n\n  /**\n   * The bit guard mask that is used to compare and protect against\n   * styling changes when and styling bindings update\n   */\n  guardMask: number;\n\n  /**\n   * Whether or not the entry requires sanitization\n   */\n  sanitizationRequired: boolean;\n\n  /**\n   * The default value that will be applied if any bindings are falsy.\n   */\n  defaultValue: string|boolean|null;\n\n  /**\n   * All bindingIndex sources that have been registered for this style.\n   */\n  sources: (number|null|string)[];\n}\n\n/**\n * Instantiates and attaches an instance of `TStylingContextDebug` to the provided context.\n */\nexport function attachStylingDebugObject(context: TStylingContext) {\n  const debug = new TStylingContextDebug(context);\n  attachDebugObject(context, debug);\n  return debug;\n}\n\n/**\n * A human-readable debug summary of the styling data present within `TStylingContext`.\n *\n * This class is designed to be used within testing code or when an\n * application has `ngDevMode` activated.\n */\nclass TStylingContextDebug {\n  constructor(public readonly context: TStylingContext) {}\n\n  get isLocked() { return isContextLocked(this.context); }\n\n  /**\n   * Returns a detailed summary of each styling entry in the context.\n   *\n   * See `TStylingTupleSummary`.\n   */\n  get entries(): {[prop: string]: TStylingTupleSummary} {\n    const context = this.context;\n    const entries: {[prop: string]: TStylingTupleSummary} = {};\n    const start = TStylingContextIndex.MapBindingsPosition;\n    let i = start;\n    while (i < context.length) {\n      const valuesCount = getValuesCount(context, i);\n      // the context may contain placeholder values which are populated ahead of time,\n      // but contain no actual binding values. In this situation there is no point in\n      // classifying this as an \"entry\" since no real data is stored here yet.\n      if (valuesCount) {\n        const prop = getProp(context, i);\n        const guardMask = getGuardMask(context, i);\n        const defaultValue = getDefaultValue(context, i);\n        const sanitizationRequired = isSanitizationRequired(context, i);\n        const bindingsStartPosition = i + TStylingContextIndex.BindingsStartOffset;\n\n        const sources: (number | string | null)[] = [];\n        for (let j = 0; j < valuesCount; j++) {\n          sources.push(context[bindingsStartPosition + j] as number | string | null);\n        }\n\n        entries[prop] = {prop, guardMask, sanitizationRequired, valuesCount, defaultValue, sources};\n      }\n\n      i += TStylingContextIndex.BindingsStartOffset + valuesCount;\n    }\n    return entries;\n  }\n}\n\n/**\n * A human-readable debug summary of the styling data present for a `DebugNode` instance.\n *\n * This class is designed to be used within testing code or when an\n * application has `ngDevMode` activated.\n */\nexport class NodeStylingDebug implements DebugStyling {\n  private _sanitizer: StyleSanitizeFn|null = null;\n\n  constructor(\n      public context: TStylingContext, private _data: LStylingData,\n      private _isClassBased?: boolean) {}\n\n  /**\n   * Overrides the sanitizer used to process styles.\n   */\n  overrideSanitizer(sanitizer: StyleSanitizeFn|null) { this._sanitizer = sanitizer; }\n\n  /**\n   * Returns a detailed summary of each styling entry in the context and\n   * what their runtime representation is.\n   *\n   * See `LStylingSummary`.\n   */\n  get summary(): {[key: string]: LStylingSummary} {\n    const entries: {[key: string]: LStylingSummary} = {};\n    this._mapValues((prop: string, value: any, bindingIndex: number | null) => {\n      entries[prop] = {prop, value, bindingIndex};\n    });\n    return entries;\n  }\n\n  /**\n   * Returns a key/value map of all the styles/classes that were last applied to the element.\n   */\n  get values(): {[key: string]: any} {\n    const entries: {[key: string]: any} = {};\n    this._mapValues((prop: string, value: any) => { entries[prop] = value; });\n    return entries;\n  }\n\n  private _mapValues(fn: (prop: string, value: any, bindingIndex: number|null) => any) {\n    // there is no need to store/track an element instance. The\n    // element is only used when the styling algorithm attempts to\n    // style the value (and we mock out the stylingApplyFn anyway).\n    const mockElement = {} as any;\n    const hasMaps = getValuesCount(this.context, TStylingContextIndex.MapBindingsPosition) > 0;\n    if (hasMaps) {\n      activeStylingMapFeature();\n    }\n\n    const mapFn: ApplyStylingFn =\n        (renderer: any, element: RElement, prop: string, value: any, bindingIndex: number) => {\n          fn(prop, value, bindingIndex || null);\n        };\n\n    const sanitizer = this._isClassBased ? null : (this._sanitizer ||\n                                                   getCurrentOrLViewSanitizer(this._data as LView));\n    applyStyling(this.context, null, mockElement, this._data, true, mapFn, sanitizer);\n  }\n}\n"]}