@angular/core 8.0.0 → 8.1.0-beta.0

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

@@ -0,0 +1,408 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { setStylingMapsSyncFn } from './bindings';
+import { getBindingValue, getValuesCount, isStylingValueDefined } from './util';
+/**
+ * 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).
+ * @type {?}
+ */
+export const syncStylingMap = (/**
+ * @param {?} context
+ * @param {?} renderer
+ * @param {?} element
+ * @param {?} data
+ * @param {?} applyStylingFn
+ * @param {?} sanitizer
+ * @param {?} mode
+ * @param {?=} targetProp
+ * @param {?=} defaultValue
+ * @return {?}
+ */
+(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, defaultValue) => {
+    /** @type {?} */
+    let 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.
+    /** @type {?} */
+    const totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
+    if (totalMaps) {
+        /** @type {?} */
+        let runTheSyncAlgorithm = true;
+        /** @type {?} */
+        const 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`.
+ * @param {?} context
+ * @param {?} renderer
+ * @param {?} element
+ * @param {?} data
+ * @param {?} applyStylingFn
+ * @param {?} sanitizer
+ * @param {?} mode
+ * @param {?} targetProp
+ * @param {?} currentMapIndex
+ * @param {?} defaultValue
+ * @return {?}
+ */
+function innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, currentMapIndex, defaultValue) {
+    /** @type {?} */
+    let targetPropValueWasApplied = false;
+    /** @type {?} */
+    const totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
+    if (currentMapIndex < totalMaps) {
+        /** @type {?} */
+        const bindingIndex = (/** @type {?} */ (getBindingValue(context, 2 /* MapBindingsPosition */, currentMapIndex)));
+        /** @type {?} */
+        const lStylingMap = (/** @type {?} */ (data[bindingIndex]));
+        /** @type {?} */
+        let cursor = getCurrentSyncCursor(currentMapIndex);
+        while (cursor < lStylingMap.length) {
+            /** @type {?} */
+            const prop = getMapProp(lStylingMap, cursor);
+            /** @type {?} */
+            const iteratedTooFar = targetProp && prop > targetProp;
+            /** @type {?} */
+            const isTargetPropMatched = !iteratedTooFar && prop === targetProp;
+            /** @type {?} */
+            const value = getMapValue(lStylingMap, cursor);
+            /** @type {?} */
+            const 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.
+            /** @type {?} */
+            const innerMode = iteratedTooFar ? mode : resolveInnerMapMode(mode, valueIsDefined, isTargetPropMatched);
+            /** @type {?} */
+            const innerProp = iteratedTooFar ? targetProp : prop;
+            /** @type {?} */
+            let valueApplied = innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, innerMode, innerProp, currentMapIndex + 1, defaultValue);
+            if (iteratedTooFar) {
+                break;
+            }
+            if (!valueApplied && isValueAllowedToBeApplied(mode, isTargetPropMatched)) {
+                /** @type {?} */
+                const useDefault = isTargetPropMatched && !valueIsDefined;
+                /** @type {?} */
+                const valueToApply = useDefault ? defaultValue : value;
+                /** @type {?} */
+                const bindingIndexToApply = useDefault ? bindingIndex : null;
+                /** @type {?} */
+                const 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).
+ * @return {?}
+ */
+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.
+ * @param {?} currentMode
+ * @param {?} valueIsDefined
+ * @param {?} isExactMatch
+ * @return {?}
+ */
+function resolveInnerMapMode(currentMode, valueIsDefined, isExactMatch) {
+    /** @type {?} */
+    let 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.
+ * @param {?} mode
+ * @param {?} isTargetPropMatched
+ * @return {?}
+ */
+function isValueAllowedToBeApplied(mode, isTargetPropMatched) {
+    /** @type {?} */
+    let 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.
+ * @type {?}
+ */
+const MAP_CURSORS = [];
+/**
+ * Used to reset the state of each cursor value being used to iterate over map-based styling
+ * bindings.
+ * @return {?}
+ */
+function resetSyncCursors() {
+    for (let i = 0; i < MAP_CURSORS.length; i++) {
+        MAP_CURSORS[i] = 1 /* ValuesStartPosition */;
+    }
+}
+/**
+ * Returns an active cursor value at a given mapIndex location.
+ * @param {?} mapIndex
+ * @return {?}
+ */
+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.
+ * @param {?} mapIndex
+ * @param {?} indexValue
+ * @return {?}
+ */
+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).
+ * @param {?} bindingValue
+ * @param {?} newValues
+ * @return {?}
+ */
+export function normalizeIntoStylingMap(bindingValue, newValues) {
+    /** @type {?} */
+    const 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 (let j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
+        setMapValue(lStylingMap, j, null);
+    }
+    /** @type {?} */
+    let props = null;
+    /** @type {?} */
+    let map;
+    /** @type {?} */
+    let 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 (let i = 0; i < props.length; i++) {
+            /** @type {?} */
+            const prop = (/** @type {?} */ (props[i]));
+            /** @type {?} */
+            const value = allValuesTrue ? true : (/** @type {?} */ (map))[prop];
+            for (let j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
+                /** @type {?} */
+                const 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;
+}
+/**
+ * @param {?} map
+ * @param {?} index
+ * @return {?}
+ */
+export function getMapProp(map, index) {
+    return (/** @type {?} */ (map[index + 0 /* PropOffset */]));
+}
+/**
+ * @param {?} map
+ * @param {?} index
+ * @param {?} value
+ * @return {?}
+ */
+export function setMapValue(map, index, value) {
+    map[index + 1 /* ValueOffset */] = value;
+}
+/**
+ * @param {?} map
+ * @param {?} index
+ * @return {?}
+ */
+export function getMapValue(map, index) {
+    return (/** @type {?} */ (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/esm2015/src/render3/styling_next/state.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {number} */
+const RuntimeStylingMode = {
+    UseOld: 0,
+    UseBothOldAndNew: 1,
+    UseNew: 2,
+};
+export { RuntimeStylingMode };
+/** @type {?} */
+let _stylingMode = 0;
+/**
+ * Temporary function used to inform the existing styling algorithm
+ * code to delegate all styling instruction calls to the new refactored
+ * styling code.
+ * @param {?} mode
+ * @return {?}
+ */
+export function runtimeSetStylingMode(mode) {
+    _stylingMode = mode;
+}
+/**
+ * @return {?}
+ */
+export function runtimeIsNewStylingInUse() {
+    return _stylingMode > 0 /* UseOld */;
+}
+/**
+ * @return {?}
+ */
+export function runtimeAllowOldStyling() {
+    return _stylingMode < 2 /* UseNew */;
+}
+/** @type {?} */
+let _currentSanitizer;
+/**
+ * @param {?} sanitizer
+ * @return {?}
+ */
+export function setCurrentStyleSanitizer(sanitizer) {
+    _currentSanitizer = sanitizer;
+}
+/**
+ * @return {?}
+ */
+export function getCurrentStyleSanitizer() {
+    return _currentSanitizer;
+}
+//# sourceMappingURL=data:application/json;base64,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