@angular/core 8.0.0 → 8.1.0-beta.0

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

@@ -0,0 +1,374 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * A static-level representation of all style or class bindings/values
+ * associated with a `TNode`.
+ *
+ * The `TStylingContext` unites all template styling bindings (i.e.
+ * `[class]` and `[style]` bindings) as well as all host-level
+ * styling bindings (for components and directives) together into
+ * a single manifest. It is used each time there are one or more
+ * styling bindings present for an element.
+ *
+ * The styling context is stored on a `TNode` on and there are
+ * two instances of it: one for classes and another for styles.
+ *
+ * ```typescript
+ * tNode.styles = [ ... a context only for styles ... ];
+ * tNode.classes = [ ... a context only for classes ... ];
+ * ```
+ *
+ * Due to the fact the the `TStylingContext` is stored on a `TNode`
+ * this means that all data within the context is static. Instead of
+ * storing actual styling binding values, the lView binding index values
+ * are stored within the context. (static nature means it is more compact.)
+ *
+ * ```typescript
+ * // <div [class.active]="c"  // lView binding index = 20
+ * //      [style.width]="x"   // lView binding index = 21
+ * //      [style.height]="y"> // lView binding index = 22
+ * tNode.stylesContext = [
+ *   0, // the context config value
+ *
+ *   0b001, // guard mask for width
+ *   2, // total entries for width
+ *   'width', // the property name
+ *   21, // the binding location for the "x" binding in the lView
+ *   null,
+ *
+ *   0b010, // guard mask for height
+ *   2, // total entries for height
+ *   'height', // the property name
+ *   22, // the binding location for the "y" binding in the lView
+ *   null,
+ * ];
+ *
+ * tNode.classesContext = [
+ *   0, // the context config value
+ *
+ *   0b001, // guard mask for active
+ *   2, // total entries for active
+ *   'active', // the property name
+ *   20, // the binding location for the "c" binding in the lView
+ *   null,
+ * ];
+ * ```
+ *
+ * Entry value present in an entry (called a tuple) within the
+ * styling context is as follows:
+ *
+ * ```typescript
+ * context = [
+ *   CONFIG, // the styling context config value
+ *   //...
+ *   guardMask,
+ *   totalEntries,
+ *   propName,
+ *   bindingIndices...,
+ *   defaultValue
+ * ];
+ * ```
+ *
+ * Below is a breakdown of each value:
+ *
+ * - **guardMask**:
+ *   A numeric value where each bit represents a binding index
+ *   location. Each binding index location is assigned based on
+ *   a local counter value that increments each time an instruction
+ *   is called:
+ *
+ * ```
+ * <div [style.width]="x"   // binding index = 21 (counter index = 0)
+ *      [style.height]="y"> // binding index = 22 (counter index = 1)
+ * ```
+ *
+ *   In the example code above, if the `width` value where to change
+ *   then the first bit in the local bit mask value would be flipped
+ *   (and the second bit for when `height`).
+ *
+ *   If and when there are more than 32 binding sources in the context
+ *   (more than 32 `[style/class]` bindings) then the bit masking will
+ *   overflow and we are left with a situation where a `-1` value will
+ *   represent the bit mask. Due to the way that JavaScript handles
+ *   negative values, when the bit mask is `-1` then all bits within
+ *   that value will be automatically flipped (this is a quick and
+ *   efficient way to flip all bits on the mask when a special kind
+ *   of caching scenario occurs or when there are more than 32 bindings).
+ *
+ * - **totalEntries**:
+ *   Each property present in the contains various binding sources of
+ *   where the styling data could come from. This includes template
+ *   level bindings, directive/component host bindings as well as the
+ *   default value (or static value) all writing to the same property.
+ *   This value depicts how many binding source entries exist for the
+ *   property.
+ *
+ *   The reason why the totalEntries value is needed is because the
+ *   styling context is dynamic in size and it's not possible
+ *   for the flushing or update algorithms to know when and where
+ *   a property starts and ends without it.
+ *
+ * - **propName**:
+ *   The CSS property name or class name (e.g `width` or `active`).
+ *
+ * - **bindingIndices...**:
+ *   A series of numeric binding values that reflect where in the
+ *   lView to find the style/class values associated with the property.
+ *   Each value is in order in terms of priority (templates are first,
+ *   then directives and then components). When the context is flushed
+ *   and the style/class values are applied to the element (this happens
+ *   inside of the `stylingApply` instruction) then the flushing code
+ *   will keep checking each binding index against the associated lView
+ *   to find the first style/class value that is non-null.
+ *
+ * - **defaultValue**:
+ *   This is the default that will always be applied to the element if
+ *   and when all other binding sources return a result that is null.
+ *   Usually this value is null but it can also be a static value that
+ *   is intercepted when the tNode is first constructured (e.g.
+ *   `<div style="width:200px">` has a default value of `200px` for
+ *   the `width` property).
+ *
+ * Each time a new binding is encountered it is registered into the
+ * context. The context then is continually updated until the first
+ * styling apply call has been called (this is triggered by the
+ * `stylingApply()` instruction for the active element).
+ *
+ * # How Styles/Classes are Rendered
+ * Each time a styling instruction (e.g. `[class.name]`, `[style.prop]`,
+ * etc...) is executed, the associated `lView` for the view is updated
+ * at the current binding location. Also, when this happens, a local
+ * counter value is incremented. If the binding value has changed then
+ * a local `bitMask` variable is updated with the specific bit based
+ * on the counter value.
+ *
+ * Below is a lightweight example of what happens when a single style
+ * property is updated (i.e. `<div [style.prop]="val">`):
+ *
+ * ```typescript
+ * function updateStyleProp(prop: string, value: string) {
+ *   const lView = getLView();
+ *   const bindingIndex = BINDING_INDEX++;
+ *   const indexForStyle = localStylesCounter++;
+ *   if (lView[bindingIndex] !== value) {
+ *     lView[bindingIndex] = value;
+ *     localBitMaskForStyles |= 1 << indexForStyle;
+ *   }
+ * }
+ * ```
+ *
+ * ## The Apply Algorithm
+ * As explained above, each time a binding updates its value, the resulting
+ * value is stored in the `lView` array. These styling values have yet to
+ * be flushed to the element.
+ *
+ * Once all the styling instructions have been evaluated, then the styling
+ * context(s) are flushed to the element. When this happens, the context will
+ * be iterated over (property by property) and each binding source will be
+ * examined and the first non-null value will be applied to the element.
+ *
+ * Let's say that we the following template code:
+ *
+ * ```html
+ * <div [style.width]="w1" dir-that-set-width="w2"></div>
+ * ```
+ *
+ * There are two styling bindings in the code above and they both write
+ * to the `width` property. When styling is flushed on the element, the
+ * algorithm will try and figure out which one of these values to write
+ * to the element.
+ *
+ * In order to figure out which value to apply, the following
+ * binding prioritization is adhered to:
+ *
+ *   1. First template-level styling bindings are applied (if present).
+ *      This includes things like `[style.width]` and `[class.active]`.
+ *
+ *   2. Second are styling-level host bindings present in directives.
+ *      (if there are sub/super directives present then the sub directives
+ *      are applied first).
+ *
+ *   3. Third are styling-level host bindings present in components.
+ *      (if there are sub/super components present then the sub directives
+ *      are applied first).
+ *
+ * This means that in the code above the styling binding present in the
+ * template is applied first and, only if its falsy, then the directive
+ * styling binding for width will be applied.
+ *
+ * ### What about map-based styling bindings?
+ * Map-based styling bindings are activated when there are one or more
+ * `[style]` and/or `[class]` bindings present on an element. When this
+ * code is activated, the apply algorithm will iterate over each map
+ * entry and apply each styling value to the element with the same
+ * prioritization rules as above.
+ *
+ * For the algorithm to apply styling values efficiently, the
+ * styling map entries must be applied in sync (property by property)
+ * with prop-based bindings. (The map-based algorithm is described
+ * more inside of the `render3/styling_next/map_based_bindings.ts` file.)
+ *
+ * ## Sanitization
+ * Sanitization is used to prevent invalid style values from being applied to
+ * the element.
+ *
+ * It is enabled in two cases:
+ *
+ *   1. The `styleSanitizer(sanitizerFn)` instruction was called (just before any other
+ *      styling instructions are run).
+ *
+ *   2. The component/directive `LView` instance has a sanitizer object attached to it
+ *      (this happens when `renderComponent` is executed with a `sanitizer` value or
+ *      if the ngModule contains a sanitizer provider attached to it).
+ *
+ * If and when sanitization is active then all property/value entries will be evaluated
+ * through the active sanitizer before they are applied to the element (or the styling
+ * debug handler).
+ *
+ * If a `Sanitizer` object is used (via the `LView[SANITIZER]` value) then that object
+ * will be used for every property.
+ *
+ * If a `StyleSanitizerFn` function is used (via the `styleSanitizer`) then it will be
+ * called in two ways:
+ *
+ *   1. property validation mode: this will be called early to mark whether a property
+ *      should be sanitized or not at during the flushing stage.
+ *
+ *   2. value sanitization mode: this will be called during the flushing stage and will
+ *      run the sanitizer function against the value before applying it to the element.
+ *
+ * If sanitization returns an empty value then that empty value will be applied
+ * to the element.
+ * @record
+ */
+export function TStylingContext() { }
+if (false) {
+    /* Skipping unnamed member:
+    [TStylingContextIndex.ConfigPosition]: TStylingConfigFlags;*/
+    /* Skipping unnamed member:
+    [TStylingContextIndex.MaxDirectiveIndexPosition]: number;*/
+    /* Skipping unnamed member:
+    [TStylingContextIndex.MapBindingsBitGuardPosition]: number;*/
+    /* Skipping unnamed member:
+    [TStylingContextIndex.MapBindingsValuesCountPosition]: number;*/
+    /* Skipping unnamed member:
+    [TStylingContextIndex.MapBindingsPropPosition]: string;*/
+}
+/** @enum {number} */
+const TStylingConfigFlags = {
+    /**
+     * The initial state of the styling context config
+     */
+    Initial: 0,
+    /**
+     * A flag which marks the context as being locked.
+     *
+     * The styling context is constructed across an element template
+     * function as well as any associated hostBindings functions. When
+     * this occurs, the context itself is open to mutation and only once
+     * it has been flushed once then it will be locked for good (no extra
+     * bindings can be added to it).
+     */
+    Locked: 1,
+};
+export { TStylingConfigFlags };
+/** @enum {number} */
+const TStylingContextIndex = {
+    ConfigPosition: 0,
+    MaxDirectiveIndexPosition: 1,
+    // index/offset values for map-based entries (i.e. `[style]`
+    // and `[class] bindings).
+    MapBindingsPosition: 2,
+    MapBindingsBitGuardPosition: 2,
+    MapBindingsValuesCountPosition: 3,
+    MapBindingsPropPosition: 4,
+    MapBindingsBindingsStartPosition: 5,
+    // each tuple entry in the context
+    // (mask, count, prop, ...bindings||default-value)
+    ConfigAndGuardOffset: 0,
+    ValuesCountOffset: 1,
+    PropOffset: 2,
+    BindingsStartOffset: 3,
+};
+export { TStylingContextIndex };
+/** @enum {number} */
+const TStylingContextPropConfigFlags = {
+    Default: 0,
+    SanitizationRequired: 1,
+    TotalBits: 1,
+    Mask: 1,
+};
+export { TStylingContextPropConfigFlags };
+/**
+ * A function used to apply or remove styling from an element for a given property.
+ * @record
+ */
+export function ApplyStylingFn() { }
+/**
+ * Array-based representation of a key/value array.
+ *
+ * The format of the array is "property", "value", "property2",
+ * "value2", etc...
+ *
+ * The first value in the array is reserved to store the instance
+ * of the key/value array that was used to populate the property/
+ * value entries that take place in the remainder of the array.
+ * @record
+ */
+export function LStylingMap() { }
+if (false) {
+    /* Skipping unnamed member:
+    [LStylingMapIndex.RawValuePosition]: {}|string|null;*/
+}
+/** @enum {number} */
+const LStylingMapIndex = {
+    /** The location of the raw key/value map instance used last to populate the array entries */
+    RawValuePosition: 0,
+    /** Where the values start in the array */
+    ValuesStartPosition: 1,
+    /** The size of each property/value entry */
+    TupleSize: 2,
+    /** The offset for the property entry in the tuple */
+    PropOffset: 0,
+    /** The offset for the value entry in the tuple */
+    ValueOffset: 1,
+};
+export { LStylingMapIndex };
+/**
+ * Used to apply/traverse across all map-based styling entries up to the provided `targetProp`
+ * value.
+ *
+ * When called, each of the map-based `LStylingMap` entries (which are stored in
+ * the provided `LStylingData` array) will be iterated over. Depending on the provided
+ * `mode` value, each prop/value entry may be applied or skipped over.
+ *
+ * If `targetProp` value is provided the iteration code will stop once it reaches
+ * the property (if found). Otherwise if the target property is not encountered then
+ * it will stop once it reaches the next value that appears alphabetically after it.
+ *
+ * If a `defaultValue` is provided then it will be applied to the element only if the
+ * `targetProp` property value is encountered and the value associated with the target
+ * property is `null`. The reason why the `defaultValue` is needed is to avoid having the
+ * algorithm apply a `null` value and then apply a default value afterwards (this would
+ * end up being two style property writes).
+ *
+ * @return whether or not the target property was reached and its value was
+ *  applied to the element.
+ * @record
+ */
+export function SyncStylingMapsFn() { }
+/** @enum {number} */
+const StylingMapsSyncMode = {
+    /** Only traverse values (no prop/value styling entries get applied) */
+    TraverseValues: 0,
+    /** Apply every prop/value styling entry to the element */
+    ApplyAllValues: 1,
+    /** Only apply the target prop/value entry */
+    ApplyTargetProp: 2,
+    /** Skip applying the target prop/value entry */
+    SkipTargetProp: 4,
+};
+export { StylingMapsSyncMode };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling_next/interfaces.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsQA,qCAqBC;;;;;;;;;;;;;;;IAOC;;OAEG;IACH,UAAa;IAEb;;;;;;;;OAQG;IACH,SAAY;;;;;IAOZ,iBAAkB;IAClB,4BAA6B;IAE7B,4DAA4D;IAC5D,0BAA0B;IAC1B,sBAAuB;IACvB,8BAA+B;IAC/B,iCAAkC;IAClC,0BAA2B;IAC3B,mCAAoC;IAEpC,kCAAkC;IAClC,kDAAkD;IAClD,uBAAwB;IACxB,oBAAqB;IACrB,aAAc;IACd,sBAAuB;;;;;IAOvB,UAAa;IACb,uBAA0B;IAC1B,YAAa;IACb,OAAU;;;;;;;AAMZ,oCAGC;;;;;;;;;;;;AAsBD,iCAEC;;;;;;;IAMC,6FAA6F;IAC7F,mBAAoB;IAEpB,0CAA0C;IAC1C,sBAAuB;IAEvB,4CAA4C;IAC5C,YAAa;IAEb,qDAAqD;IACrD,aAAc;IAEd,kDAAkD;IAClD,cAAe;;;;;;;;;;;;;;;;;;;;;;;;;AAwBjB,uCAIC;;;IAMC,uEAAuE;IACvE,iBAAsB;IAEtB,0DAA0D;IAC1D,iBAAsB;IAEtB,6CAA6C;IAC7C,kBAAuB;IAEvB,gDAAgD;IAChD,iBAAsB","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} from '../../sanitization/style_sanitizer';\nimport {ProceduralRenderer3, RElement, Renderer3} from '../interfaces/renderer';\nimport {LView} from '../interfaces/view';\n\n/**\n * --------\n *\n * This file contains the core interfaces for styling in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n/**\n * A static-level representation of all style or class bindings/values\n * associated with a `TNode`.\n *\n * The `TStylingContext` unites all template styling bindings (i.e.\n * `[class]` and `[style]` bindings) as well as all host-level\n * styling bindings (for components and directives) together into\n * a single manifest. It is used each time there are one or more\n * styling bindings present for an element.\n *\n * The styling context is stored on a `TNode` on and there are\n * two instances of it: one for classes and another for styles.\n *\n * ```typescript\n * tNode.styles = [ ... a context only for styles ... ];\n * tNode.classes = [ ... a context only for classes ... ];\n * ```\n *\n * Due to the fact the the `TStylingContext` is stored on a `TNode`\n * this means that all data within the context is static. Instead of\n * storing actual styling binding values, the lView binding index values\n * are stored within the context. (static nature means it is more compact.)\n\n *\n * ```typescript\n * // <div [class.active]=\"c\"  // lView binding index = 20\n * //      [style.width]=\"x\"   // lView binding index = 21\n * //      [style.height]=\"y\"> // lView binding index = 22\n * tNode.stylesContext = [\n *   0, // the context config value\n *\n *   0b001, // guard mask for width\n *   2, // total entries for width\n *   'width', // the property name\n *   21, // the binding location for the \"x\" binding in the lView\n *   null,\n *\n *   0b010, // guard mask for height\n *   2, // total entries for height\n *   'height', // the property name\n *   22, // the binding location for the \"y\" binding in the lView\n *   null,\n * ];\n *\n * tNode.classesContext = [\n *   0, // the context config value\n *\n *   0b001, // guard mask for active\n *   2, // total entries for active\n *   'active', // the property name\n *   20, // the binding location for the \"c\" binding in the lView\n *   null,\n * ];\n * ```\n *\n * Entry value present in an entry (called a tuple) within the\n * styling context is as follows:\n *\n * ```typescript\n * context = [\n *   CONFIG, // the styling context config value\n *   //...\n *   guardMask,\n *   totalEntries,\n *   propName,\n *   bindingIndices...,\n *   defaultValue\n * ];\n * ```\n *\n * Below is a breakdown of each value:\n *\n * - **guardMask**:\n *   A numeric value where each bit represents a binding index\n *   location. Each binding index location is assigned based on\n *   a local counter value that increments each time an instruction\n *   is called:\n *\n * ```\n * <div [style.width]=\"x\"   // binding index = 21 (counter index = 0)\n *      [style.height]=\"y\"> // binding index = 22 (counter index = 1)\n * ```\n *\n *   In the example code above, if the `width` value where to change\n *   then the first bit in the local bit mask value would be flipped\n *   (and the second bit for when `height`).\n *\n *   If and when there are more than 32 binding sources in the context\n *   (more than 32 `[style/class]` bindings) then the bit masking will\n *   overflow and we are left with a situation where a `-1` value will\n *   represent the bit mask. Due to the way that JavaScript handles\n *   negative values, when the bit mask is `-1` then all bits within\n *   that value will be automatically flipped (this is a quick and\n *   efficient way to flip all bits on the mask when a special kind\n *   of caching scenario occurs or when there are more than 32 bindings).\n *\n * - **totalEntries**:\n *   Each property present in the contains various binding sources of\n *   where the styling data could come from. This includes template\n *   level bindings, directive/component host bindings as well as the\n *   default value (or static value) all writing to the same property.\n *   This value depicts how many binding source entries exist for the\n *   property.\n *\n *   The reason why the totalEntries value is needed is because the\n *   styling context is dynamic in size and it's not possible\n *   for the flushing or update algorithms to know when and where\n *   a property starts and ends without it.\n *\n * - **propName**:\n *   The CSS property name or class name (e.g `width` or `active`).\n *\n * - **bindingIndices...**:\n *   A series of numeric binding values that reflect where in the\n *   lView to find the style/class values associated with the property.\n *   Each value is in order in terms of priority (templates are first,\n *   then directives and then components). When the context is flushed\n *   and the style/class values are applied to the element (this happens\n *   inside of the `stylingApply` instruction) then the flushing code\n *   will keep checking each binding index against the associated lView\n *   to find the first style/class value that is non-null.\n *\n * - **defaultValue**:\n *   This is the default that will always be applied to the element if\n *   and when all other binding sources return a result that is null.\n *   Usually this value is null but it can also be a static value that\n *   is intercepted when the tNode is first constructured (e.g.\n *   `<div style=\"width:200px\">` has a default value of `200px` for\n *   the `width` property).\n *\n * Each time a new binding is encountered it is registered into the\n * context. The context then is continually updated until the first\n * styling apply call has been called (this is triggered by the\n * `stylingApply()` instruction for the active element).\n *\n * # How Styles/Classes are Rendered\n * Each time a styling instruction (e.g. `[class.name]`, `[style.prop]`,\n * etc...) is executed, the associated `lView` for the view is updated\n * at the current binding location. Also, when this happens, a local\n * counter value is incremented. If the binding value has changed then\n * a local `bitMask` variable is updated with the specific bit based\n * on the counter value.\n *\n * Below is a lightweight example of what happens when a single style\n * property is updated (i.e. `<div [style.prop]=\"val\">`):\n *\n * ```typescript\n * function updateStyleProp(prop: string, value: string) {\n *   const lView = getLView();\n *   const bindingIndex = BINDING_INDEX++;\n *   const indexForStyle = localStylesCounter++;\n *   if (lView[bindingIndex] !== value) {\n *     lView[bindingIndex] = value;\n *     localBitMaskForStyles |= 1 << indexForStyle;\n *   }\n * }\n * ```\n *\n * ## The Apply Algorithm\n * As explained above, each time a binding updates its value, the resulting\n * value is stored in the `lView` array. These styling values have yet to\n * be flushed to the element.\n *\n * Once all the styling instructions have been evaluated, then the styling\n * context(s) are flushed to the element. When this happens, the context will\n * be iterated over (property by property) and each binding source will be\n * examined and the first non-null value will be applied to the element.\n *\n * Let's say that we the following template code:\n *\n * ```html\n * <div [style.width]=\"w1\" dir-that-set-width=\"w2\"></div>\n * ```\n *\n * There are two styling bindings in the code above and they both write\n * to the `width` property. When styling is flushed on the element, the\n * algorithm will try and figure out which one of these values to write\n * to the element.\n *\n * In order to figure out which value to apply, the following\n * binding prioritization is adhered to:\n *\n *   1. First template-level styling bindings are applied (if present).\n *      This includes things like `[style.width]` and `[class.active]`.\n *\n *   2. Second are styling-level host bindings present in directives.\n *      (if there are sub/super directives present then the sub directives\n *      are applied first).\n *\n *   3. Third are styling-level host bindings present in components.\n *      (if there are sub/super components present then the sub directives\n *      are applied first).\n *\n * This means that in the code above the styling binding present in the\n * template is applied first and, only if its falsy, then the directive\n * styling binding for width will be applied.\n *\n * ### What about map-based styling bindings?\n * Map-based styling bindings are activated when there are one or more\n * `[style]` and/or `[class]` bindings present on an element. When this\n * code is activated, the apply algorithm will iterate over each map\n * entry and apply each styling value to the element with the same\n * prioritization rules as above.\n *\n * For the algorithm to apply styling values efficiently, the\n * styling map entries must be applied in sync (property by property)\n * with prop-based bindings. (The map-based algorithm is described\n * more inside of the `render3/styling_next/map_based_bindings.ts` file.)\n *\n * ## Sanitization\n * Sanitization is used to prevent invalid style values from being applied to\n * the element.\n *\n * It is enabled in two cases:\n *\n *   1. The `styleSanitizer(sanitizerFn)` instruction was called (just before any other\n *      styling instructions are run).\n *\n *   2. The component/directive `LView` instance has a sanitizer object attached to it\n *      (this happens when `renderComponent` is executed with a `sanitizer` value or\n *      if the ngModule contains a sanitizer provider attached to it).\n *\n * If and when sanitization is active then all property/value entries will be evaluated\n * through the active sanitizer before they are applied to the element (or the styling\n * debug handler).\n *\n * If a `Sanitizer` object is used (via the `LView[SANITIZER]` value) then that object\n * will be used for every property.\n *\n * If a `StyleSanitizerFn` function is used (via the `styleSanitizer`) then it will be\n * called in two ways:\n *\n *   1. property validation mode: this will be called early to mark whether a property\n *      should be sanitized or not at during the flushing stage.\n *\n *   2. value sanitization mode: this will be called during the flushing stage and will\n *      run the sanitizer function against the value before applying it to the element.\n *\n * If sanitization returns an empty value then that empty value will be applied\n * to the element.\n */\nexport interface TStylingContext extends Array<number|string|number|boolean|null|LStylingMap> {\n  /** Configuration data for the context */\n  [TStylingContextIndex.ConfigPosition]: TStylingConfigFlags;\n\n  /** Temporary value used to track directive index entries until\n     the old styling code is fully removed. The reason why this\n     is required is to figure out which directive is last and,\n     when encountered, trigger a styling flush to happen */\n  [TStylingContextIndex.MaxDirectiveIndexPosition]: number;\n\n  /** The bit guard value for all map-based bindings on an element */\n  [TStylingContextIndex.MapBindingsBitGuardPosition]: number;\n\n  /** The total amount of map-based bindings present on an element */\n  [TStylingContextIndex.MapBindingsValuesCountPosition]: number;\n\n  /** The prop value for map-based bindings (there actually isn't a\n   * value at all, but this is just used in the context to avoid\n   * having any special code to update the binding information for\n   * map-based entries). */\n  [TStylingContextIndex.MapBindingsPropPosition]: string;\n}\n\n/**\n * A series of flags used to configure the config value present within a\n * `TStylingContext` value.\n */\nexport const enum TStylingConfigFlags {\n  /**\n   * The initial state of the styling context config\n   */\n  Initial = 0b0,\n\n  /**\n   * A flag which marks the context as being locked.\n   *\n   * The styling context is constructed across an element template\n   * function as well as any associated hostBindings functions. When\n   * this occurs, the context itself is open to mutation and only once\n   * it has been flushed once then it will be locked for good (no extra\n   * bindings can be added to it).\n   */\n  Locked = 0b1,\n}\n\n/**\n * An index of position and offset values used to natigate the `TStylingContext`.\n */\nexport const enum TStylingContextIndex {\n  ConfigPosition = 0,\n  MaxDirectiveIndexPosition = 1,\n\n  // index/offset values for map-based entries (i.e. `[style]`\n  // and `[class] bindings).\n  MapBindingsPosition = 2,\n  MapBindingsBitGuardPosition = 2,\n  MapBindingsValuesCountPosition = 3,\n  MapBindingsPropPosition = 4,\n  MapBindingsBindingsStartPosition = 5,\n\n  // each tuple entry in the context\n  // (mask, count, prop, ...bindings||default-value)\n  ConfigAndGuardOffset = 0,\n  ValuesCountOffset = 1,\n  PropOffset = 2,\n  BindingsStartOffset = 3,\n}\n\n/**\n * A series of flags used for each property entry within the `TStylingContext`.\n */\nexport const enum TStylingContextPropConfigFlags {\n  Default = 0b0,\n  SanitizationRequired = 0b1,\n  TotalBits = 1,\n  Mask = 0b1,\n}\n\n/**\n * A function used to apply or remove styling from an element for a given property.\n */\nexport interface ApplyStylingFn {\n  (renderer: Renderer3|ProceduralRenderer3|null, element: RElement, prop: string,\n   value: string|null, bindingIndex?: number|null): void;\n}\n\n/**\n * Runtime data type that is used to store binding data referenced from the `TStylingContext`.\n *\n * Because `LView` is just an array with data, there is no reason to\n * special case `LView` everywhere in the styling algorithm. By allowing\n * this data type to be an array that contains various scalar data types,\n * an instance of `LView` doesn't need to be constructed for tests.\n */\nexport type LStylingData = LView | (string | number | boolean | null)[];\n\n/**\n * Array-based representation of a key/value array.\n *\n * The format of the array is \"property\", \"value\", \"property2\",\n * \"value2\", etc...\n *\n * The first value in the array is reserved to store the instance\n * of the key/value array that was used to populate the property/\n * value entries that take place in the remainder of the array.\n */\nexport interface LStylingMap extends Array<{}|string|number|null> {\n  [LStylingMapIndex.RawValuePosition]: {}|string|null;\n}\n\n/**\n * An index of position and offset points for any data stored within a `LStylingMap` instance.\n */\nexport const enum LStylingMapIndex {\n  /** The location of the raw key/value map instance used last to populate the array entries */\n  RawValuePosition = 0,\n\n  /** Where the values start in the array */\n  ValuesStartPosition = 1,\n\n  /** The size of each property/value entry */\n  TupleSize = 2,\n\n  /** The offset for the property entry in the tuple */\n  PropOffset = 0,\n\n  /** The offset for the value entry in the tuple */\n  ValueOffset = 1,\n}\n\n/**\n * Used to apply/traverse across all map-based styling entries up to the provided `targetProp`\n * value.\n *\n * When called, each of the map-based `LStylingMap` entries (which are stored in\n * the provided `LStylingData` array) will be iterated over. Depending on the provided\n * `mode` value, each prop/value entry may be applied or skipped over.\n *\n * If `targetProp` value is provided the iteration code will stop once it reaches\n * the property (if found). Otherwise if the target property is not encountered then\n * it will stop once it reaches the next value that appears alphabetically after it.\n *\n * If a `defaultValue` is provided then it will be applied to the element only if the\n * `targetProp` property value is encountered and the value associated with the target\n * property is `null`. The reason why the `defaultValue` is needed is to avoid having the\n * algorithm apply a `null` value and then apply a default value afterwards (this would\n * end up being two style property writes).\n *\n * @returns whether or not the target property was reached and its value was\n *  applied to the element.\n */\nexport interface SyncStylingMapsFn {\n  (context: TStylingContext, renderer: Renderer3|ProceduralRenderer3|null, element: RElement,\n   data: LStylingData, applyStylingFn: ApplyStylingFn, sanitizer: StyleSanitizeFn|null,\n   mode: StylingMapsSyncMode, targetProp?: string|null, defaultValue?: string|null): boolean;\n}\n\n/**\n * Used to direct how map-based values are applied/traversed when styling is flushed.\n */\nexport const enum StylingMapsSyncMode {\n  /** Only traverse values (no prop/value styling entries get applied) */\n  TraverseValues = 0b000,\n\n  /** Apply every prop/value styling entry to the element */\n  ApplyAllValues = 0b001,\n\n  /** Only apply the target prop/value entry */\n  ApplyTargetProp = 0b010,\n\n  /** Skip applying the target prop/value entry */\n  SkipTargetProp = 0b100,\n}\n"]}