@angular/core 8.0.0 → 8.1.0-beta.0

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

@@ -0,0 +1,602 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { RendererStyleFlags3, isProceduralRenderer } from '../interfaces/renderer';
+import { allowStylingFlush, getBindingValue, getGuardMask, getProp, getPropValuesStartPosition, getValuesCount, hasValueChanged, isContextLocked, isSanitizationRequired, isStylingValueDefined, lockContext, setGuardMask } from './util';
+/**
+ * --------
+ *
+ * This file contains the core logic for styling in Angular.
+ *
+ * All styling bindings (i.e. `[style]`, `[style.prop]`, `[class]` and `[class.name]`)
+ * will have their values be applied through the logic in this file.
+ *
+ * When a binding is encountered (e.g. `<div [style.width]="w">`) then
+ * the binding data will be populated into a `TStylingContext` data-structure.
+ * There is only one `TStylingContext` per `TNode` and each element instance
+ * will update its style/class binding values in concert with the styling
+ * context.
+ *
+ * To learn more about the algorithm see `TStylingContext`.
+ *
+ * --------
+ * @type {?}
+ */
+const DEFAULT_BINDING_VALUE = null;
+/** @type {?} */
+const DEFAULT_SIZE_VALUE = 1;
+// The first bit value reflects a map-based binding value's bit.
+// The reason why it's always activated for every entry in the map
+// is so that if any map-binding values update then all other prop
+// based bindings will pass the guard check automatically without
+// any extra code or flags.
+/** @type {?} */
+export const DEFAULT_GUARD_MASK_VALUE = 0b1;
+/** @type {?} */
+const STYLING_INDEX_FOR_MAP_BINDING = 0;
+/** @type {?} */
+const STYLING_INDEX_START_VALUE = 1;
+// the values below are global to all styling code below. Each value
+// will either increment or mutate each time a styling instruction is
+// executed. Do not modify the values below.
+/** @type {?} */
+let currentStyleIndex = STYLING_INDEX_START_VALUE;
+/** @type {?} */
+let currentClassIndex = STYLING_INDEX_START_VALUE;
+/** @type {?} */
+let stylesBitMask = 0;
+/** @type {?} */
+let classesBitMask = 0;
+/** @type {?} */
+let deferredBindingQueue = [];
+/**
+ * Visits a class-based binding and updates the new value (if changed).
+ *
+ * This function is called each time a class-based styling instruction
+ * is executed. It's important that it's always called (even if the value
+ * has not changed) so that the inner counter index value is incremented.
+ * This way, each instruction is always guaranteed to get the same counter
+ * state each time it's called (which then allows the `TStylingContext`
+ * and the bit mask values to be in sync).
+ * @param {?} context
+ * @param {?} data
+ * @param {?} prop
+ * @param {?} bindingIndex
+ * @param {?} value
+ * @param {?} deferRegistration
+ * @param {?} forceUpdate
+ * @return {?}
+ */
+export function updateClassBinding(context, data, prop, bindingIndex, value, deferRegistration, forceUpdate) {
+    /** @type {?} */
+    const isMapBased = !prop;
+    /** @type {?} */
+    const index = isMapBased ? STYLING_INDEX_FOR_MAP_BINDING : currentClassIndex++;
+    /** @type {?} */
+    const updated = updateBindingData(context, data, index, prop, bindingIndex, value, deferRegistration, forceUpdate, false);
+    if (updated || forceUpdate) {
+        classesBitMask |= 1 << index;
+    }
+}
+/**
+ * Visits a style-based binding and updates the new value (if changed).
+ *
+ * This function is called each time a style-based styling instruction
+ * is executed. It's important that it's always called (even if the value
+ * has not changed) so that the inner counter index value is incremented.
+ * This way, each instruction is always guaranteed to get the same counter
+ * state each time it's called (which then allows the `TStylingContext`
+ * and the bit mask values to be in sync).
+ * @param {?} context
+ * @param {?} data
+ * @param {?} prop
+ * @param {?} bindingIndex
+ * @param {?} value
+ * @param {?} sanitizer
+ * @param {?} deferRegistration
+ * @param {?} forceUpdate
+ * @return {?}
+ */
+export function updateStyleBinding(context, data, prop, bindingIndex, value, sanitizer, deferRegistration, forceUpdate) {
+    /** @type {?} */
+    const isMapBased = !prop;
+    /** @type {?} */
+    const index = isMapBased ? STYLING_INDEX_FOR_MAP_BINDING : currentStyleIndex++;
+    /** @type {?} */
+    const sanitizationRequired = isMapBased ?
+        true :
+        (sanitizer ? sanitizer((/** @type {?} */ (prop)), null, 1 /* ValidateProperty */) : false);
+    /** @type {?} */
+    const updated = updateBindingData(context, data, index, prop, bindingIndex, value, deferRegistration, forceUpdate, sanitizationRequired);
+    if (updated || forceUpdate) {
+        stylesBitMask |= 1 << index;
+    }
+}
+/**
+ * Called each time a binding value has changed within the provided `TStylingContext`.
+ *
+ * This function is designed to be called from `updateStyleBinding` and `updateClassBinding`.
+ * If called during the first update pass, the binding will be registered in the context.
+ * If the binding does get registered and the `deferRegistration` flag is true then the
+ * binding data will be queued up until the context is later flushed in `applyStyling`.
+ *
+ * This function will also update binding slot in the provided `LStylingData` with the
+ * new binding entry (if it has changed).
+ *
+ * @param {?} context
+ * @param {?} data
+ * @param {?} counterIndex
+ * @param {?} prop
+ * @param {?} bindingIndex
+ * @param {?} value
+ * @param {?} deferRegistration
+ * @param {?} forceUpdate
+ * @param {?} sanitizationRequired
+ * @return {?} whether or not the binding value was updated in the `LStylingData`.
+ */
+function updateBindingData(context, data, counterIndex, prop, bindingIndex, value, deferRegistration, forceUpdate, sanitizationRequired) {
+    if (!isContextLocked(context)) {
+        if (deferRegistration) {
+            deferBindingRegistration(context, counterIndex, prop, bindingIndex, sanitizationRequired);
+        }
+        else {
+            deferredBindingQueue.length && flushDeferredBindings();
+            // this will only happen during the first update pass of the
+            // context. The reason why we can't use `tNode.firstTemplatePass`
+            // here is because its not guaranteed to be true when the first
+            // update pass is executed (remember that all styling instructions
+            // are run in the update phase, and, as a result, are no more
+            // styling instructions that are run in the creation phase).
+            registerBinding(context, counterIndex, prop, bindingIndex, sanitizationRequired);
+        }
+    }
+    /** @type {?} */
+    const changed = forceUpdate || hasValueChanged(data[bindingIndex], value);
+    if (changed) {
+        data[bindingIndex] = value;
+    }
+    return changed;
+}
+/**
+ * Schedules a binding registration to be run at a later point.
+ *
+ * The reasoning for this feature is to ensure that styling
+ * bindings are registered in the correct order for when
+ * directives/components have a super/sub class inheritance
+ * chains. Each directive's styling bindings must be
+ * registered into the context in reverse order. Therefore all
+ * bindings will be buffered in reverse order and then applied
+ * after the inheritance chain exits.
+ * @param {?} context
+ * @param {?} counterIndex
+ * @param {?} prop
+ * @param {?} bindingIndex
+ * @param {?} sanitizationRequired
+ * @return {?}
+ */
+function deferBindingRegistration(context, counterIndex, prop, bindingIndex, sanitizationRequired) {
+    deferredBindingQueue.unshift(context, counterIndex, prop, bindingIndex, sanitizationRequired);
+}
+/**
+ * Flushes the collection of deferred bindings and causes each entry
+ * to be registered into the context.
+ * @return {?}
+ */
+function flushDeferredBindings() {
+    /** @type {?} */
+    let i = 0;
+    while (i < deferredBindingQueue.length) {
+        /** @type {?} */
+        const context = (/** @type {?} */ (deferredBindingQueue[i++]));
+        /** @type {?} */
+        const count = (/** @type {?} */ (deferredBindingQueue[i++]));
+        /** @type {?} */
+        const prop = (/** @type {?} */ (deferredBindingQueue[i++]));
+        /** @type {?} */
+        const bindingIndex = (/** @type {?} */ (deferredBindingQueue[i++]));
+        /** @type {?} */
+        const sanitizationRequired = (/** @type {?} */ (deferredBindingQueue[i++]));
+        registerBinding(context, count, prop, bindingIndex, sanitizationRequired);
+    }
+    deferredBindingQueue.length = 0;
+}
+/**
+ * Registers the provided binding (prop + bindingIndex) into the context.
+ *
+ * This function is shared between bindings that are assigned immediately
+ * (via `updateBindingData`) and at a deferred stage. When called, it will
+ * figure out exactly where to place the binding data in the context.
+ *
+ * It is needed because it will either update or insert a styling property
+ * into the context at the correct spot.
+ *
+ * When called, one of two things will happen:
+ *
+ * 1) If the property already exists in the context then it will just add
+ *    the provided `bindingValue` to the end of the binding sources region
+ *    for that particular property.
+ *
+ *    - If the binding value is a number then it will be added as a new
+ *      binding index source next to the other binding sources for the property.
+ *
+ *    - Otherwise, if the binding value is a string/boolean/null type then it will
+ *      replace the default value for the property if the default value is `null`.
+ *
+ * 2) If the property does not exist then it will be inserted into the context.
+ *    The styling context relies on all properties being stored in alphabetical
+ *    order, so it knows exactly where to store it.
+ *
+ *    When inserted, a default `null` value is created for the property which exists
+ *    as the default value for the binding. If the bindingValue property is inserted
+ *    and it is either a string, number or null value then that will replace the default
+ *    value.
+ *
+ * Note that this function is also used for map-based styling bindings. They are treated
+ * much the same as prop-based bindings, but, because they do not have a property value
+ * (since it's a map), all map-based entries are stored in an already populated area of
+ * the context at the top (which is reserved for map-based entries).
+ * @param {?} context
+ * @param {?} countId
+ * @param {?} prop
+ * @param {?} bindingValue
+ * @param {?=} sanitizationRequired
+ * @return {?}
+ */
+export function registerBinding(context, countId, prop, bindingValue, sanitizationRequired) {
+    // prop-based bindings (e.g `<div [style.width]="w" [class.foo]="f">`)
+    if (prop) {
+        /** @type {?} */
+        let found = false;
+        /** @type {?} */
+        let i = getPropValuesStartPosition(context);
+        while (i < context.length) {
+            /** @type {?} */
+            const valuesCount = getValuesCount(context, i);
+            /** @type {?} */
+            const p = getProp(context, i);
+            found = prop <= p;
+            if (found) {
+                // all style/class bindings are sorted by property name
+                if (prop < p) {
+                    allocateNewContextEntry(context, i, prop, sanitizationRequired);
+                }
+                addBindingIntoContext(context, false, i, bindingValue, countId);
+                break;
+            }
+            i += 3 /* BindingsStartOffset */ + valuesCount;
+        }
+        if (!found) {
+            allocateNewContextEntry(context, context.length, prop, sanitizationRequired);
+            addBindingIntoContext(context, false, i, bindingValue, countId);
+        }
+    }
+    else {
+        // map-based bindings (e.g `<div [style]="s" [class]="{className:true}">`)
+        // there is no need to allocate the map-based binding region into the context
+        // since it is already there when the context is first created.
+        addBindingIntoContext(context, true, 2 /* MapBindingsPosition */, bindingValue, countId);
+    }
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @param {?} prop
+ * @param {?=} sanitizationRequired
+ * @return {?}
+ */
+function allocateNewContextEntry(context, index, prop, sanitizationRequired) {
+    // 1,2: splice index locations
+    // 3: each entry gets a config value (guard mask + flags)
+    // 4. each entry gets a size value (which is always one because there is always a default binding
+    // value)
+    // 5. the property that is getting allocated into the context
+    // 6. the default binding value (usually `null`)
+    /** @type {?} */
+    const config = sanitizationRequired ? 1 /* SanitizationRequired */ :
+        0 /* Default */;
+    context.splice(index, 0, config, DEFAULT_SIZE_VALUE, prop, DEFAULT_BINDING_VALUE);
+    setGuardMask(context, index, DEFAULT_GUARD_MASK_VALUE);
+}
+/**
+ * Inserts a new binding value into a styling property tuple in the `TStylingContext`.
+ *
+ * A bindingValue is inserted into a context during the first update pass
+ * of a template or host bindings function. When this occurs, two things
+ * happen:
+ *
+ * - If the bindingValue value is a number then it is treated as a bindingIndex
+ *   value (a index in the `LView`) and it will be inserted next to the other
+ *   binding index entries.
+ *
+ * - Otherwise the binding value will update the default value for the property
+ *   and this will only happen if the default value is `null`.
+ *
+ * Note that this function also handles map-based bindings and will insert them
+ * at the top of the context.
+ * @param {?} context
+ * @param {?} isMapBased
+ * @param {?} index
+ * @param {?} bindingValue
+ * @param {?} countId
+ * @return {?}
+ */
+function addBindingIntoContext(context, isMapBased, index, bindingValue, countId) {
+    /** @type {?} */
+    const valuesCount = getValuesCount(context, index);
+    /** @type {?} */
+    let lastValueIndex = index + 3 /* BindingsStartOffset */ + valuesCount;
+    if (!isMapBased) {
+        // prop-based values all have default values, but map-based entries do not.
+        // we want to access the index for the default value in this case and not just
+        // the bindings...
+        lastValueIndex--;
+    }
+    if (typeof bindingValue === 'number') {
+        context.splice(lastValueIndex, 0, bindingValue);
+        ((/** @type {?} */ (context[index + 1 /* ValuesCountOffset */])))++;
+        // now that a new binding index has been added to the property
+        // the guard mask bit value (at the `countId` position) needs
+        // to be included into the existing mask value.
+        /** @type {?} */
+        const guardMask = getGuardMask(context, index) | (1 << countId);
+        setGuardMask(context, index, guardMask);
+    }
+    else if (typeof bindingValue === 'string' && context[lastValueIndex] == null) {
+        context[lastValueIndex] = bindingValue;
+    }
+}
+/**
+ * Applies all class entries in the provided context to the provided element and resets
+ * any counter and/or bitMask values associated with class bindings.
+ *
+ * @param {?} renderer
+ * @param {?} data
+ * @param {?} context
+ * @param {?} element
+ * @param {?} directiveIndex
+ * @return {?} whether or not the classes were flushed to the element.
+ */
+export function applyClasses(renderer, data, context, element, directiveIndex) {
+    /** @type {?} */
+    let classesFlushed = false;
+    if (allowStylingFlush(context, directiveIndex)) {
+        /** @type {?} */
+        const isFirstPass = !isContextLocked(context);
+        isFirstPass && lockContext(context);
+        if (classesBitMask) {
+            // there is no way to sanitize a class value therefore `sanitizer=null`
+            applyStyling(context, renderer, element, data, classesBitMask, setClass, null);
+            classesBitMask = 0;
+            classesFlushed = true;
+        }
+        currentClassIndex = STYLING_INDEX_START_VALUE;
+    }
+    return classesFlushed;
+}
+/**
+ * Applies all style entries in the provided context to the provided element and resets
+ * any counter and/or bitMask values associated with style bindings.
+ *
+ * @param {?} renderer
+ * @param {?} data
+ * @param {?} context
+ * @param {?} element
+ * @param {?} directiveIndex
+ * @param {?} sanitizer
+ * @return {?} whether or not the styles were flushed to the element.
+ */
+export function applyStyles(renderer, data, context, element, directiveIndex, sanitizer) {
+    /** @type {?} */
+    let stylesFlushed = false;
+    if (allowStylingFlush(context, directiveIndex)) {
+        /** @type {?} */
+        const isFirstPass = !isContextLocked(context);
+        isFirstPass && lockContext(context);
+        if (stylesBitMask) {
+            applyStyling(context, renderer, element, data, stylesBitMask, setStyle, sanitizer);
+            stylesBitMask = 0;
+            stylesFlushed = true;
+        }
+        currentStyleIndex = STYLING_INDEX_START_VALUE;
+        return true;
+    }
+    return stylesFlushed;
+}
+/**
+ * Runs through the provided styling context and applies each value to
+ * the provided element (via the renderer) if one or more values are present.
+ *
+ * This function will iterate over all entries present in the provided
+ * `TStylingContext` array (both prop-based and map-based bindings).-
+ *
+ * Each entry, within the `TStylingContext` array, is stored alphabetically
+ * and this means that each prop/value entry will be applied in order
+ * (so long as it is marked dirty in the provided `bitMask` value).
+ *
+ * If there are any map-based entries present (which are applied to the
+ * element via the `[style]` and `[class]` bindings) then those entries
+ * will be applied as well. However, the code for that is not apart of
+ * this function. Instead, each time a property is visited, then the
+ * code below will call an external function called `stylingMapsSyncFn`
+ * and, if present, it will keep the application of styling values in
+ * map-based bindings up to sync with the application of prop-based
+ * bindings.
+ *
+ * Visit `styling_next/map_based_bindings.ts` to learn more about how the
+ * algorithm works for map-based styling bindings.
+ *
+ * Note that this function is not designed to be called in isolation (use
+ * `applyClasses` and `applyStyles` to actually apply styling values).
+ * @param {?} context
+ * @param {?} renderer
+ * @param {?} element
+ * @param {?} bindingData
+ * @param {?} bitMaskValue
+ * @param {?} applyStylingFn
+ * @param {?} sanitizer
+ * @return {?}
+ */
+export function applyStyling(context, renderer, element, bindingData, bitMaskValue, applyStylingFn, sanitizer) {
+    deferredBindingQueue.length && flushDeferredBindings();
+    /** @type {?} */
+    const bitMask = normalizeBitMaskValue(bitMaskValue);
+    /** @type {?} */
+    const stylingMapsSyncFn = getStylingMapsSyncFn();
+    /** @type {?} */
+    const mapsGuardMask = getGuardMask(context, 2 /* MapBindingsPosition */);
+    /** @type {?} */
+    const applyAllValues = (bitMask & mapsGuardMask) > 0;
+    /** @type {?} */
+    const mapsMode = applyAllValues ? 1 /* ApplyAllValues */ : 0 /* TraverseValues */;
+    /** @type {?} */
+    let i = getPropValuesStartPosition(context);
+    while (i < context.length) {
+        /** @type {?} */
+        const valuesCount = getValuesCount(context, i);
+        /** @type {?} */
+        const guardMask = getGuardMask(context, i);
+        if (bitMask & guardMask) {
+            /** @type {?} */
+            let valueApplied = false;
+            /** @type {?} */
+            const prop = getProp(context, i);
+            /** @type {?} */
+            const valuesCountUpToDefault = valuesCount - 1;
+            /** @type {?} */
+            const defaultValue = (/** @type {?} */ (getBindingValue(context, i, valuesCountUpToDefault)));
+            // case 1: apply prop-based values
+            // try to apply the binding values and see if a non-null
+            // value gets set for the styling binding
+            for (let j = 0; j < valuesCountUpToDefault; j++) {
+                /** @type {?} */
+                const bindingIndex = (/** @type {?} */ (getBindingValue(context, i, j)));
+                /** @type {?} */
+                const value = bindingData[bindingIndex];
+                if (isStylingValueDefined(value)) {
+                    /** @type {?} */
+                    const finalValue = sanitizer && isSanitizationRequired(context, i) ?
+                        sanitizer(prop, value, 2 /* SanitizeOnly */) :
+                        value;
+                    applyStylingFn(renderer, element, prop, finalValue, bindingIndex);
+                    valueApplied = true;
+                    break;
+                }
+            }
+            // case 2: apply map-based values
+            // traverse through each map-based styling binding and update all values up to
+            // the provided `prop` value. If the property was not applied in the loop above
+            // then it will be attempted to be applied in the maps sync code below.
+            if (stylingMapsSyncFn) {
+                // determine whether or not to apply the target property or to skip it
+                /** @type {?} */
+                const mode = mapsMode | (valueApplied ? 4 /* SkipTargetProp */ :
+                    2 /* ApplyTargetProp */);
+                /** @type {?} */
+                const valueAppliedWithinMap = stylingMapsSyncFn(context, renderer, element, bindingData, applyStylingFn, sanitizer, mode, prop, defaultValue);
+                valueApplied = valueApplied || valueAppliedWithinMap;
+            }
+            // case 3: apply the default value
+            // if the value has not yet been applied then a truthy value does not exist in the
+            // prop-based or map-based bindings code. If and when this happens, just apply the
+            // default value (even if the default value is `null`).
+            if (!valueApplied) {
+                applyStylingFn(renderer, element, prop, defaultValue);
+            }
+        }
+        i += 3 /* BindingsStartOffset */ + valuesCount;
+    }
+    // the map-based styling entries may have not applied all their
+    // values. For this reason, one more call to the sync function
+    // needs to be issued at the end.
+    if (stylingMapsSyncFn) {
+        stylingMapsSyncFn(context, renderer, element, bindingData, applyStylingFn, sanitizer, mapsMode);
+    }
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function normalizeBitMaskValue(value) {
+    // if pass => apply all values (-1 implies that all bits are flipped to true)
+    if (value === true)
+        return -1;
+    // if pass => skip all values
+    if (value === false)
+        return 0;
+    // return the bit mask value as is
+    return value;
+}
+/** @type {?} */
+let _activeStylingMapApplyFn = null;
+/**
+ * @return {?}
+ */
+export function getStylingMapsSyncFn() {
+    return _activeStylingMapApplyFn;
+}
+/**
+ * @param {?} fn
+ * @return {?}
+ */
+export function setStylingMapsSyncFn(fn) {
+    _activeStylingMapApplyFn = fn;
+}
+/**
+ * Assigns a style value to a style property for the given element.
+ * @type {?}
+ */
+const setStyle = (/**
+ * @param {?} renderer
+ * @param {?} native
+ * @param {?} prop
+ * @param {?} value
+ * @return {?}
+ */
+(renderer, native, prop, value) => {
+    if (value) {
+        // opacity, z-index and flexbox all have number values
+        // and these need to be converted into strings so that
+        // they can be assigned properly.
+        value = value.toString();
+        ngDevMode && ngDevMode.rendererSetStyle++;
+        renderer && isProceduralRenderer(renderer) ?
+            renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :
+            native.style.setProperty(prop, value);
+    }
+    else {
+        ngDevMode && ngDevMode.rendererRemoveStyle++;
+        renderer && isProceduralRenderer(renderer) ?
+            renderer.removeStyle(native, prop, RendererStyleFlags3.DashCase) :
+            native.style.removeProperty(prop);
+    }
+});
+const ɵ0 = setStyle;
+/**
+ * Adds/removes the provided className value to the provided element.
+ * @type {?}
+ */
+const setClass = (/**
+ * @param {?} renderer
+ * @param {?} native
+ * @param {?} className
+ * @param {?} value
+ * @return {?}
+ */
+(renderer, native, className, value) => {
+    if (className !== '') {
+        if (value) {
+            ngDevMode && ngDevMode.rendererAddClass++;
+            renderer && isProceduralRenderer(renderer) ? renderer.addClass(native, className) :
+                native.classList.add(className);
+        }
+        else {
+            ngDevMode && ngDevMode.rendererRemoveClass++;
+            renderer && isProceduralRenderer(renderer) ? renderer.removeClass(native, className) :
+                native.classList.remove(className);
+        }
+    }
+});
+const ɵ1 = setClass;
+export { ɵ0, ɵ1 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bindings.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling_next/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, RendererStyleFlags3, isProceduralRenderer} from '../interfaces/renderer';\n\nimport {ApplyStylingFn, LStylingData, LStylingMap, StylingMapsSyncMode, SyncStylingMapsFn, TStylingContext, TStylingContextIndex, TStylingContextPropConfigFlags} from './interfaces';\nimport {allowStylingFlush, getBindingValue, getGuardMask, getProp, getPropValuesStartPosition, getValuesCount, hasValueChanged, isContextLocked, isSanitizationRequired, isStylingValueDefined, lockContext, setGuardMask} from './util';\n\n\n/**\n * --------\n *\n * This file contains the core logic for styling in Angular.\n *\n * All styling bindings (i.e. `[style]`, `[style.prop]`, `[class]` and `[class.name]`)\n * will have their values be applied through the logic in this file.\n *\n * When a binding is encountered (e.g. `<div [style.width]=\"w\">`) then\n * the binding data will be populated into a `TStylingContext` data-structure.\n * There is only one `TStylingContext` per `TNode` and each element instance\n * will update its style/class binding values in concert with the styling\n * context.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\nconst DEFAULT_BINDING_VALUE = null;\nconst DEFAULT_SIZE_VALUE = 1;\n\n// The first bit value reflects a map-based binding value's bit.\n// The reason why it's always activated for every entry in the map\n// is so that if any map-binding values update then all other prop\n// based bindings will pass the guard check automatically without\n// any extra code or flags.\nexport const DEFAULT_GUARD_MASK_VALUE = 0b1;\nconst STYLING_INDEX_FOR_MAP_BINDING = 0;\nconst STYLING_INDEX_START_VALUE = 1;\n\n// the values below are global to all styling code below. Each value\n// will either increment or mutate each time a styling instruction is\n// executed. Do not modify the values below.\nlet currentStyleIndex = STYLING_INDEX_START_VALUE;\nlet currentClassIndex = STYLING_INDEX_START_VALUE;\nlet stylesBitMask = 0;\nlet classesBitMask = 0;\nlet deferredBindingQueue: (TStylingContext | number | string | null | boolean)[] = [];\n\n/**\n * Visits a class-based binding and updates the new value (if changed).\n *\n * This function is called each time a class-based styling instruction\n * is executed. It's important that it's always called (even if the value\n * has not changed) so that the inner counter index value is incremented.\n * This way, each instruction is always guaranteed to get the same counter\n * state each time it's called (which then allows the `TStylingContext`\n * and the bit mask values to be in sync).\n */\nexport function updateClassBinding(\n    context: TStylingContext, data: LStylingData, prop: string | null, bindingIndex: number,\n    value: boolean | string | null | undefined | LStylingMap, deferRegistration: boolean,\n    forceUpdate: boolean): void {\n  const isMapBased = !prop;\n  const index = isMapBased ? STYLING_INDEX_FOR_MAP_BINDING : currentClassIndex++;\n  const updated = updateBindingData(\n      context, data, index, prop, bindingIndex, value, deferRegistration, forceUpdate, false);\n  if (updated || forceUpdate) {\n    classesBitMask |= 1 << index;\n  }\n}\n\n/**\n * Visits a style-based binding and updates the new value (if changed).\n *\n * This function is called each time a style-based styling instruction\n * is executed. It's important that it's always called (even if the value\n * has not changed) so that the inner counter index value is incremented.\n * This way, each instruction is always guaranteed to get the same counter\n * state each time it's called (which then allows the `TStylingContext`\n * and the bit mask values to be in sync).\n */\nexport function updateStyleBinding(\n    context: TStylingContext, data: LStylingData, prop: string | null, bindingIndex: number,\n    value: String | string | number | null | undefined | LStylingMap,\n    sanitizer: StyleSanitizeFn | null, deferRegistration: boolean, forceUpdate: boolean): void {\n  const isMapBased = !prop;\n  const index = isMapBased ? STYLING_INDEX_FOR_MAP_BINDING : currentStyleIndex++;\n  const sanitizationRequired = isMapBased ?\n      true :\n      (sanitizer ? sanitizer(prop !, null, StyleSanitizeMode.ValidateProperty) : false);\n  const updated = updateBindingData(\n      context, data, index, prop, bindingIndex, value, deferRegistration, forceUpdate,\n      sanitizationRequired);\n  if (updated || forceUpdate) {\n    stylesBitMask |= 1 << index;\n  }\n}\n\n/**\n * Called each time a binding value has changed within the provided `TStylingContext`.\n *\n * This function is designed to be called from `updateStyleBinding` and `updateClassBinding`.\n * If called during the first update pass, the binding will be registered in the context.\n * If the binding does get registered and the `deferRegistration` flag is true then the\n * binding data will be queued up until the context is later flushed in `applyStyling`.\n *\n * This function will also update binding slot in the provided `LStylingData` with the\n * new binding entry (if it has changed).\n *\n * @returns whether or not the binding value was updated in the `LStylingData`.\n */\nfunction updateBindingData(\n    context: TStylingContext, data: LStylingData, counterIndex: number, prop: string | null,\n    bindingIndex: number,\n    value: string | String | number | boolean | null | undefined | LStylingMap,\n    deferRegistration: boolean, forceUpdate: boolean, sanitizationRequired: boolean): boolean {\n  if (!isContextLocked(context)) {\n    if (deferRegistration) {\n      deferBindingRegistration(context, counterIndex, prop, bindingIndex, sanitizationRequired);\n    } else {\n      deferredBindingQueue.length && flushDeferredBindings();\n\n      // this will only happen during the first update pass of the\n      // context. The reason why we can't use `tNode.firstTemplatePass`\n      // here is because its not guaranteed to be true when the first\n      // update pass is executed (remember that all styling instructions\n      // are run in the update phase, and, as a result, are no more\n      // styling instructions that are run in the creation phase).\n      registerBinding(context, counterIndex, prop, bindingIndex, sanitizationRequired);\n    }\n  }\n\n  const changed = forceUpdate || hasValueChanged(data[bindingIndex], value);\n  if (changed) {\n    data[bindingIndex] = value;\n  }\n  return changed;\n}\n\n/**\n * Schedules a binding registration to be run at a later point.\n *\n * The reasoning for this feature is to ensure that styling\n * bindings are registered in the correct order for when\n * directives/components have a super/sub class inheritance\n * chains. Each directive's styling bindings must be\n * registered into the context in reverse order. Therefore all\n * bindings will be buffered in reverse order and then applied\n * after the inheritance chain exits.\n */\nfunction deferBindingRegistration(\n    context: TStylingContext, counterIndex: number, prop: string | null, bindingIndex: number,\n    sanitizationRequired: boolean) {\n  deferredBindingQueue.unshift(context, counterIndex, prop, bindingIndex, sanitizationRequired);\n}\n\n/**\n * Flushes the collection of deferred bindings and causes each entry\n * to be registered into the context.\n */\nfunction flushDeferredBindings() {\n  let i = 0;\n  while (i < deferredBindingQueue.length) {\n    const context = deferredBindingQueue[i++] as TStylingContext;\n    const count = deferredBindingQueue[i++] as number;\n    const prop = deferredBindingQueue[i++] as string;\n    const bindingIndex = deferredBindingQueue[i++] as number | null;\n    const sanitizationRequired = deferredBindingQueue[i++] as boolean;\n    registerBinding(context, count, prop, bindingIndex, sanitizationRequired);\n  }\n  deferredBindingQueue.length = 0;\n}\n\n/**\n * Registers the provided binding (prop + bindingIndex) into the context.\n *\n * This function is shared between bindings that are assigned immediately\n * (via `updateBindingData`) and at a deferred stage. When called, it will\n * figure out exactly where to place the binding data in the context.\n *\n * It is needed because it will either update or insert a styling property\n * into the context at the correct spot.\n *\n * When called, one of two things will happen:\n *\n * 1) If the property already exists in the context then it will just add\n *    the provided `bindingValue` to the end of the binding sources region\n *    for that particular property.\n *\n *    - If the binding value is a number then it will be added as a new\n *      binding index source next to the other binding sources for the property.\n *\n *    - Otherwise, if the binding value is a string/boolean/null type then it will\n *      replace the default value for the property if the default value is `null`.\n *\n * 2) If the property does not exist then it will be inserted into the context.\n *    The styling context relies on all properties being stored in alphabetical\n *    order, so it knows exactly where to store it.\n *\n *    When inserted, a default `null` value is created for the property which exists\n *    as the default value for the binding. If the bindingValue property is inserted\n *    and it is either a string, number or null value then that will replace the default\n *    value.\n *\n * Note that this function is also used for map-based styling bindings. They are treated\n * much the same as prop-based bindings, but, because they do not have a property value\n * (since it's a map), all map-based entries are stored in an already populated area of\n * the context at the top (which is reserved for map-based entries).\n */\nexport function registerBinding(\n    context: TStylingContext, countId: number, prop: string | null,\n    bindingValue: number | null | string | boolean, sanitizationRequired?: boolean) {\n  // prop-based bindings (e.g `<div [style.width]=\"w\" [class.foo]=\"f\">`)\n  if (prop) {\n    let found = false;\n    let i = getPropValuesStartPosition(context);\n    while (i < context.length) {\n      const valuesCount = getValuesCount(context, i);\n      const p = getProp(context, i);\n      found = prop <= p;\n      if (found) {\n        // all style/class bindings are sorted by property name\n        if (prop < p) {\n          allocateNewContextEntry(context, i, prop, sanitizationRequired);\n        }\n        addBindingIntoContext(context, false, i, bindingValue, countId);\n        break;\n      }\n      i += TStylingContextIndex.BindingsStartOffset + valuesCount;\n    }\n\n    if (!found) {\n      allocateNewContextEntry(context, context.length, prop, sanitizationRequired);\n      addBindingIntoContext(context, false, i, bindingValue, countId);\n    }\n  } else {\n    // map-based bindings (e.g `<div [style]=\"s\" [class]=\"{className:true}\">`)\n    // there is no need to allocate the map-based binding region into the context\n    // since it is already there when the context is first created.\n    addBindingIntoContext(\n        context, true, TStylingContextIndex.MapBindingsPosition, bindingValue, countId);\n  }\n}\n\nfunction allocateNewContextEntry(\n    context: TStylingContext, index: number, prop: string, sanitizationRequired?: boolean) {\n  // 1,2: splice index locations\n  // 3: each entry gets a config value (guard mask + flags)\n  // 4. each entry gets a size value (which is always one because there is always a default binding\n  // value)\n  // 5. the property that is getting allocated into the context\n  // 6. the default binding value (usually `null`)\n  const config = sanitizationRequired ? TStylingContextPropConfigFlags.SanitizationRequired :\n                                        TStylingContextPropConfigFlags.Default;\n  context.splice(index, 0, config, DEFAULT_SIZE_VALUE, prop, DEFAULT_BINDING_VALUE);\n  setGuardMask(context, index, DEFAULT_GUARD_MASK_VALUE);\n}\n\n/**\n * Inserts a new binding value into a styling property tuple in the `TStylingContext`.\n *\n * A bindingValue is inserted into a context during the first update pass\n * of a template or host bindings function. When this occurs, two things\n * happen:\n *\n * - If the bindingValue value is a number then it is treated as a bindingIndex\n *   value (a index in the `LView`) and it will be inserted next to the other\n *   binding index entries.\n *\n * - Otherwise the binding value will update the default value for the property\n *   and this will only happen if the default value is `null`.\n *\n * Note that this function also handles map-based bindings and will insert them\n * at the top of the context.\n */\nfunction addBindingIntoContext(\n    context: TStylingContext, isMapBased: boolean, index: number,\n    bindingValue: number | string | boolean | null, countId: number) {\n  const valuesCount = getValuesCount(context, index);\n\n  let lastValueIndex = index + TStylingContextIndex.BindingsStartOffset + valuesCount;\n  if (!isMapBased) {\n    // prop-based values all have default values, but map-based entries do not.\n    // we want to access the index for the default value in this case and not just\n    // the bindings...\n    lastValueIndex--;\n  }\n\n  if (typeof bindingValue === 'number') {\n    context.splice(lastValueIndex, 0, bindingValue);\n    (context[index + TStylingContextIndex.ValuesCountOffset] as number)++;\n\n    // now that a new binding index has been added to the property\n    // the guard mask bit value (at the `countId` position) needs\n    // to be included into the existing mask value.\n    const guardMask = getGuardMask(context, index) | (1 << countId);\n    setGuardMask(context, index, guardMask);\n  } else if (typeof bindingValue === 'string' && context[lastValueIndex] == null) {\n    context[lastValueIndex] = bindingValue;\n  }\n}\n\n/**\n * Applies all class entries in the provided context to the provided element and resets\n * any counter and/or bitMask values associated with class bindings.\n *\n * @returns whether or not the classes were flushed to the element.\n */\nexport function applyClasses(\n    renderer: Renderer3 | ProceduralRenderer3 | null, data: LStylingData, context: TStylingContext,\n    element: RElement, directiveIndex: number): boolean {\n  let classesFlushed = false;\n  if (allowStylingFlush(context, directiveIndex)) {\n    const isFirstPass = !isContextLocked(context);\n    isFirstPass && lockContext(context);\n    if (classesBitMask) {\n      // there is no way to sanitize a class value therefore `sanitizer=null`\n      applyStyling(context, renderer, element, data, classesBitMask, setClass, null);\n      classesBitMask = 0;\n      classesFlushed = true;\n    }\n    currentClassIndex = STYLING_INDEX_START_VALUE;\n  }\n  return classesFlushed;\n}\n\n/**\n * Applies all style entries in the provided context to the provided element and resets\n * any counter and/or bitMask values associated with style bindings.\n *\n * @returns whether or not the styles were flushed to the element.\n */\nexport function applyStyles(\n    renderer: Renderer3 | ProceduralRenderer3 | null, data: LStylingData, context: TStylingContext,\n    element: RElement, directiveIndex: number, sanitizer: StyleSanitizeFn | null): boolean {\n  let stylesFlushed = false;\n  if (allowStylingFlush(context, directiveIndex)) {\n    const isFirstPass = !isContextLocked(context);\n    isFirstPass && lockContext(context);\n    if (stylesBitMask) {\n      applyStyling(context, renderer, element, data, stylesBitMask, setStyle, sanitizer);\n      stylesBitMask = 0;\n      stylesFlushed = true;\n    }\n    currentStyleIndex = STYLING_INDEX_START_VALUE;\n    return true;\n  }\n  return stylesFlushed;\n}\n\n/**\n * Runs through the provided styling context and applies each value to\n * the provided element (via the renderer) if one or more values are present.\n *\n * This function will iterate over all entries present in the provided\n * `TStylingContext` array (both prop-based and map-based bindings).-\n *\n * Each entry, within the `TStylingContext` array, is stored alphabetically\n * and this means that each prop/value entry will be applied in order\n * (so long as it is marked dirty in the provided `bitMask` value).\n *\n * If there are any map-based entries present (which are applied to the\n * element via the `[style]` and `[class]` bindings) then those entries\n * will be applied as well. However, the code for that is not apart of\n * this function. Instead, each time a property is visited, then the\n * code below will call an external function called `stylingMapsSyncFn`\n * and, if present, it will keep the application of styling values in\n * map-based bindings up to sync with the application of prop-based\n * bindings.\n *\n * Visit `styling_next/map_based_bindings.ts` to learn more about how the\n * algorithm works for map-based styling bindings.\n *\n * Note that this function is not designed to be called in isolation (use\n * `applyClasses` and `applyStyles` to actually apply styling values).\n */\nexport function applyStyling(\n    context: TStylingContext, renderer: Renderer3 | ProceduralRenderer3 | null, element: RElement,\n    bindingData: LStylingData, bitMaskValue: number | boolean, applyStylingFn: ApplyStylingFn,\n    sanitizer: StyleSanitizeFn | null) {\n  deferredBindingQueue.length && flushDeferredBindings();\n\n  const bitMask = normalizeBitMaskValue(bitMaskValue);\n  const stylingMapsSyncFn = getStylingMapsSyncFn();\n  const mapsGuardMask = getGuardMask(context, TStylingContextIndex.MapBindingsPosition);\n  const applyAllValues = (bitMask & mapsGuardMask) > 0;\n  const mapsMode =\n      applyAllValues ? StylingMapsSyncMode.ApplyAllValues : StylingMapsSyncMode.TraverseValues;\n\n  let i = getPropValuesStartPosition(context);\n  while (i < context.length) {\n    const valuesCount = getValuesCount(context, i);\n    const guardMask = getGuardMask(context, i);\n    if (bitMask & guardMask) {\n      let valueApplied = false;\n      const prop = getProp(context, i);\n      const valuesCountUpToDefault = valuesCount - 1;\n      const defaultValue = getBindingValue(context, i, valuesCountUpToDefault) as string | null;\n\n      // case 1: apply prop-based values\n      // try to apply the binding values and see if a non-null\n      // value gets set for the styling binding\n      for (let j = 0; j < valuesCountUpToDefault; j++) {\n        const bindingIndex = getBindingValue(context, i, j) as number;\n        const value = bindingData[bindingIndex];\n        if (isStylingValueDefined(value)) {\n          const finalValue = sanitizer && isSanitizationRequired(context, i) ?\n              sanitizer(prop, value, StyleSanitizeMode.SanitizeOnly) :\n              value;\n          applyStylingFn(renderer, element, prop, finalValue, bindingIndex);\n          valueApplied = true;\n          break;\n        }\n      }\n\n      // case 2: apply map-based values\n      // traverse through each map-based styling binding and update all values up to\n      // the provided `prop` value. If the property was not applied in the loop above\n      // then it will be attempted to be applied in the maps sync code below.\n      if (stylingMapsSyncFn) {\n        // determine whether or not to apply the target property or to skip it\n        const mode = mapsMode | (valueApplied ? StylingMapsSyncMode.SkipTargetProp :\n                                                StylingMapsSyncMode.ApplyTargetProp);\n        const valueAppliedWithinMap = stylingMapsSyncFn(\n            context, renderer, element, bindingData, applyStylingFn, sanitizer, mode, prop,\n            defaultValue);\n        valueApplied = valueApplied || valueAppliedWithinMap;\n      }\n\n      // case 3: apply the default value\n      // if the value has not yet been applied then a truthy value does not exist in the\n      // prop-based or map-based bindings code. If and when this happens, just apply the\n      // default value (even if the default value is `null`).\n      if (!valueApplied) {\n        applyStylingFn(renderer, element, prop, defaultValue);\n      }\n    }\n\n    i += TStylingContextIndex.BindingsStartOffset + valuesCount;\n  }\n\n  // the map-based styling entries may have not applied all their\n  // values. For this reason, one more call to the sync function\n  // needs to be issued at the end.\n  if (stylingMapsSyncFn) {\n    stylingMapsSyncFn(context, renderer, element, bindingData, applyStylingFn, sanitizer, mapsMode);\n  }\n}\n\nfunction normalizeBitMaskValue(value: number | boolean): number {\n  // if pass => apply all values (-1 implies that all bits are flipped to true)\n  if (value === true) return -1;\n\n  // if pass => skip all values\n  if (value === false) return 0;\n\n  // return the bit mask value as is\n  return value;\n}\n\nlet _activeStylingMapApplyFn: SyncStylingMapsFn|null = null;\nexport function getStylingMapsSyncFn() {\n  return _activeStylingMapApplyFn;\n}\n\nexport function setStylingMapsSyncFn(fn: SyncStylingMapsFn) {\n  _activeStylingMapApplyFn = fn;\n}\n\n/**\n * Assigns a style value to a style property for the given element.\n */\nconst setStyle: ApplyStylingFn =\n    (renderer: Renderer3 | null, native: any, prop: string, value: string | null) => {\n      if (value) {\n        // opacity, z-index and flexbox all have number values\n        // and these need to be converted into strings so that\n        // they can be assigned properly.\n        value = value.toString();\n        ngDevMode && ngDevMode.rendererSetStyle++;\n        renderer && isProceduralRenderer(renderer) ?\n            renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :\n            native.style.setProperty(prop, value);\n      } else {\n        ngDevMode && ngDevMode.rendererRemoveStyle++;\n        renderer && isProceduralRenderer(renderer) ?\n            renderer.removeStyle(native, prop, RendererStyleFlags3.DashCase) :\n            native.style.removeProperty(prop);\n      }\n    };\n\n/**\n * Adds/removes the provided className value to the provided element.\n */\nconst setClass: ApplyStylingFn =\n    (renderer: Renderer3 | null, native: any, className: string, value: any) => {\n      if (className !== '') {\n        if (value) {\n          ngDevMode && ngDevMode.rendererAddClass++;\n          renderer && isProceduralRenderer(renderer) ? renderer.addClass(native, className) :\n                                                       native.classList.add(className);\n        } else {\n          ngDevMode && ngDevMode.rendererRemoveClass++;\n          renderer && isProceduralRenderer(renderer) ? renderer.removeClass(native, className) :\n                                                       native.classList.remove(className);\n        }\n      }\n    };\n"]}