@angular/core 8.0.0 → 8.1.0-beta.0

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

@@ -0,0 +1,277 @@
+import { BINDING_INDEX, HEADER_OFFSET, HOST, RENDERER } from '../interfaces/view';
+import { getActiveDirectiveId, getActiveDirectiveSuperClassDepth, getActiveDirectiveSuperClassHeight, getLView, getSelectedIndex } from '../state';
+import { NO_CHANGE } from '../tokens';
+import { renderStringify } from '../util/misc_utils';
+import { getTNode, isStylingContext as isOldStylingContext } from '../util/view_utils';
+import { applyClasses, applyStyles, registerBinding, updateClassBinding, updateStyleBinding } from './bindings';
+import { activeStylingMapFeature, normalizeIntoStylingMap } from './map_based_bindings';
+import { setCurrentStyleSanitizer } from './state';
+import { attachStylingDebugObject } from './styling_debug';
+import { allocTStylingContext, getCurrentOrLViewSanitizer, hasValueChanged, updateContextDirectiveIndex } from './util';
+/**
+ * --------
+ *
+ * This file contains the core logic for how styling instructions are processed in Angular.
+ *
+ * To learn more about the algorithm see `TStylingContext`.
+ *
+ * --------
+ */
+/**
+ * Temporary function to bridge styling functionality between this new
+ * refactor (which is here inside of `styling_next/`) and the old
+ * implementation (which lives inside of `styling/`).
+ *
+ * This function is executed during the creation block of an element.
+ * Because the existing styling implementation issues a call to the
+ * `styling()` instruction, this instruction will also get run. The
+ * central idea here is that the directive index values are bound
+ * into the context. The directive index is temporary and is only
+ * required until the `select(n)` instruction is fully functional.
+ */
+export function stylingInit() {
+    var lView = getLView();
+    var index = getSelectedIndex();
+    var tNode = getTNode(index, lView);
+    updateLastDirectiveIndex(tNode, getActiveDirectiveStylingIndex());
+}
+/**
+ * Sets the current style sanitizer function which will then be used
+ * within all follow-up prop and map-based style binding instructions
+ * for the given element.
+ *
+ * Note that once styling has been applied to the element (i.e. once
+ * `select(n)` is executed or the hostBindings/template function exits)
+ * then the active `sanitizerFn` will be set to `null`. This means that
+ * once styling is applied to another element then a another call to
+ * `styleSanitizer` will need to be made.
+ *
+ * @param sanitizerFn The sanitization function that will be used to
+ *       process style prop/value entries.
+ *
+ * @codeGenApi
+ */
+export function styleSanitizer(sanitizer) {
+    setCurrentStyleSanitizer(sanitizer);
+}
+/**
+ * Mirror implementation of the `styleProp()` instruction (found in `instructions/styling.ts`).
+ */
+export function styleProp(prop, value, suffix) {
+    _stylingProp(prop, resolveStylePropValue(value, suffix), false);
+}
+/**
+ * Mirror implementation of the `classProp()` instruction (found in `instructions/styling.ts`).
+ */
+export function classProp(className, value) {
+    _stylingProp(className, value, true);
+}
+/**
+ * Shared function used to update a prop-based styling binding for an element.
+ */
+function _stylingProp(prop, value, isClassBased) {
+    var index = getSelectedIndex();
+    var lView = getLView();
+    var bindingIndex = lView[BINDING_INDEX]++;
+    var tNode = getTNode(index, lView);
+    var defer = getActiveDirectiveSuperClassHeight() > 0;
+    if (isClassBased) {
+        updateClassBinding(getClassesContext(tNode), lView, prop, bindingIndex, value, defer, false);
+    }
+    else {
+        var sanitizer = getCurrentOrLViewSanitizer(lView);
+        updateStyleBinding(getStylesContext(tNode), lView, prop, bindingIndex, value, sanitizer, defer, false);
+    }
+}
+/**
+ * Mirror implementation of the `styleMap()` instruction (found in `instructions/styling.ts`).
+ */
+export function styleMap(styles) {
+    _stylingMap(styles, false);
+}
+/**
+ * Mirror implementation of the `classMap()` instruction (found in `instructions/styling.ts`).
+ */
+export function classMap(classes) {
+    _stylingMap(classes, true);
+}
+/**
+ * Shared function used to update a map-based styling binding for an element.
+ *
+ * When this function is called it will activate support for `[style]` and
+ * `[class]` bindings in Angular.
+ */
+function _stylingMap(value, isClassBased) {
+    activeStylingMapFeature();
+    var index = getSelectedIndex();
+    var lView = getLView();
+    var bindingIndex = lView[BINDING_INDEX]++;
+    if (value !== NO_CHANGE) {
+        var tNode = getTNode(index, lView);
+        var defer = getActiveDirectiveSuperClassHeight() > 0;
+        var oldValue = lView[bindingIndex];
+        var valueHasChanged = hasValueChanged(oldValue, value);
+        var lStylingMap = normalizeIntoStylingMap(oldValue, value);
+        if (isClassBased) {
+            updateClassBinding(getClassesContext(tNode), lView, null, bindingIndex, lStylingMap, defer, valueHasChanged);
+        }
+        else {
+            var sanitizer = getCurrentOrLViewSanitizer(lView);
+            updateStyleBinding(getStylesContext(tNode), lView, null, bindingIndex, lStylingMap, sanitizer, defer, valueHasChanged);
+        }
+    }
+}
+/**
+ * Temporary function to bridge styling functionality between this new
+ * refactor (which is here inside of `styling_next/`) and the old
+ * implementation (which lives inside of `styling/`).
+ *
+ * The new styling refactor ensures that styling flushing is called
+ * automatically when a template function exits or a follow-up element
+ * is visited (i.e. when `select(n)` is called). Because the `select(n)`
+ * instruction is not fully implemented yet (it doesn't actually execute
+ * host binding instruction code at the right time), this means that a
+ * styling apply function is still needed.
+ *
+ * This function is a mirror implementation of the `stylingApply()`
+ * instruction (found in `instructions/styling.ts`).
+ */
+export function stylingApply() {
+    var index = getSelectedIndex();
+    var lView = getLView();
+    var tNode = getTNode(index, lView);
+    var renderer = getRenderer(tNode, lView);
+    var native = getNativeFromLView(index, lView);
+    var directiveIndex = getActiveDirectiveStylingIndex();
+    applyClasses(renderer, lView, getClassesContext(tNode), native, directiveIndex);
+    var sanitizer = getCurrentOrLViewSanitizer(lView);
+    applyStyles(renderer, lView, getStylesContext(tNode), native, directiveIndex, sanitizer);
+    setCurrentStyleSanitizer(null);
+}
+/**
+ * Temporary function to bridge styling functionality between this new
+ * refactor (which is here inside of `styling_next/`) and the old
+ * implementation (which lives inside of `styling/`).
+ *
+ * The purpose of this function is to traverse through the LView data
+ * for a specific element index and return the native node. Because the
+ * current implementation relies on there being a styling context array,
+ * the code below will need to loop through these array values until it
+ * gets a native element node.
+ *
+ * Note that this code is temporary and will disappear once the new
+ * styling refactor lands in its entirety.
+ */
+function getNativeFromLView(index, viewData) {
+    var storageIndex = index + HEADER_OFFSET;
+    var slotValue = viewData[storageIndex];
+    var wrapper = viewData;
+    while (Array.isArray(slotValue)) {
+        wrapper = slotValue;
+        slotValue = slotValue[HOST];
+    }
+    if (isOldStylingContext(wrapper)) {
+        return wrapper[0 /* ElementPosition */];
+    }
+    else {
+        return slotValue;
+    }
+}
+function getRenderer(tNode, lView) {
+    return tNode.type === 3 /* Element */ ? lView[RENDERER] : null;
+}
+/**
+ * Searches and assigns provided all static style/class entries (found in the `attrs` value)
+ * and registers them in their respective styling contexts.
+ */
+export function registerInitialStylingIntoContext(tNode, attrs, startIndex) {
+    var classesContext;
+    var stylesContext;
+    var mode = -1;
+    for (var i = startIndex; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (typeof attr == 'number') {
+            mode = attr;
+        }
+        else if (mode == 1 /* Classes */) {
+            classesContext = classesContext || getClassesContext(tNode);
+            registerBinding(classesContext, -1, attr, true, false);
+        }
+        else if (mode == 2 /* Styles */) {
+            stylesContext = stylesContext || getStylesContext(tNode);
+            registerBinding(stylesContext, -1, attr, attrs[++i], false);
+        }
+    }
+}
+/**
+ * Mirror implementation of the same function found in `instructions/styling.ts`.
+ */
+export function getActiveDirectiveStylingIndex() {
+    // whenever a directive's hostBindings function is called a uniqueId value
+    // is assigned. Normally this is enough to help distinguish one directive
+    // from another for the styling context, but there are situations where a
+    // sub-class directive could inherit and assign styling in concert with a
+    // parent directive. To help the styling code distinguish between a parent
+    // sub-classed directive the inheritance depth is taken into account as well.
+    return getActiveDirectiveId() + getActiveDirectiveSuperClassDepth();
+}
+/**
+ * Temporary function that will update the max directive index value in
+ * both the classes and styles contexts present on the provided `tNode`.
+ *
+ * This code is only used because the `select(n)` code functionality is not
+ * yet 100% functional. The `select(n)` instruction cannot yet evaluate host
+ * bindings function code in sync with the associated template function code.
+ * For this reason the styling algorithm needs to track the last directive index
+ * value so that it knows exactly when to render styling to the element since
+ * `stylingApply()` is called multiple times per CD (`stylingApply` will be
+ * removed once `select(n)` is fixed).
+ */
+function updateLastDirectiveIndex(tNode, directiveIndex) {
+    updateContextDirectiveIndex(getClassesContext(tNode), directiveIndex);
+    updateContextDirectiveIndex(getStylesContext(tNode), directiveIndex);
+}
+function getStylesContext(tNode) {
+    return getContext(tNode, false);
+}
+function getClassesContext(tNode) {
+    return getContext(tNode, true);
+}
+/**
+ * Returns/instantiates a styling context from/to a `tNode` instance.
+ */
+function getContext(tNode, isClassBased) {
+    var context = isClassBased ? tNode.newClasses : tNode.newStyles;
+    if (!context) {
+        context = allocTStylingContext();
+        if (ngDevMode) {
+            attachStylingDebugObject(context);
+        }
+        if (isClassBased) {
+            tNode.newClasses = context;
+        }
+        else {
+            tNode.newStyles = context;
+        }
+    }
+    return context;
+}
+function resolveStylePropValue(value, suffix) {
+    var resolvedValue = null;
+    if (value !== null) {
+        if (suffix) {
+            // when a suffix is applied then it will bypass
+            // sanitization entirely (b/c a new string is created)
+            resolvedValue = renderStringify(value) + suffix;
+        }
+        else {
+            // sanitization happens by dealing with a String value
+            // this means that the string value will be passed through
+            // into the style rendering later (which is where the value
+            // will be sanitized before it is applied)
+            resolvedValue = value;
+        }
+    }
+    return resolvedValue;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling_next/instructions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\nimport {Sanitizer} from '../../sanitization/security';\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {LContainer} from '../interfaces/container';\nimport {AttributeMarker, TAttributes, TNode, TNodeType} from '../interfaces/node';\nimport {RElement} from '../interfaces/renderer';\nimport {StylingContext as OldStylingContext, StylingIndex as OldStylingIndex} from '../interfaces/styling';\nimport {BINDING_INDEX, HEADER_OFFSET, HOST, LView, RENDERER, SANITIZER} from '../interfaces/view';\nimport {getActiveDirectiveId, getActiveDirectiveSuperClassDepth, getActiveDirectiveSuperClassHeight, getLView, getSelectedIndex} from '../state';\nimport {NO_CHANGE} from '../tokens';\nimport {renderStringify} from '../util/misc_utils';\nimport {getTNode, isStylingContext as isOldStylingContext} from '../util/view_utils';\n\nimport {applyClasses, applyStyles, registerBinding, updateClassBinding, updateStyleBinding} from './bindings';\nimport {TStylingContext} from './interfaces';\nimport {activeStylingMapFeature, normalizeIntoStylingMap} from './map_based_bindings';\nimport {getCurrentStyleSanitizer, setCurrentStyleSanitizer} from './state';\nimport {attachStylingDebugObject} from './styling_debug';\nimport {allocTStylingContext, getCurrentOrLViewSanitizer, hasValueChanged, updateContextDirectiveIndex} from './util';\n\n\n\n/**\n * --------\n *\n * This file contains the core logic for how styling instructions are processed in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n/**\n * Temporary function to bridge styling functionality between this new\n * refactor (which is here inside of `styling_next/`) and the old\n * implementation (which lives inside of `styling/`).\n *\n * This function is executed during the creation block of an element.\n * Because the existing styling implementation issues a call to the\n * `styling()` instruction, this instruction will also get run. The\n * central idea here is that the directive index values are bound\n * into the context. The directive index is temporary and is only\n * required until the `select(n)` instruction is fully functional.\n */\nexport function stylingInit() {\n  const lView = getLView();\n  const index = getSelectedIndex();\n  const tNode = getTNode(index, lView);\n  updateLastDirectiveIndex(tNode, getActiveDirectiveStylingIndex());\n}\n\n/**\n * Sets the current style sanitizer function which will then be used\n * within all follow-up prop and map-based style binding instructions\n * for the given element.\n *\n * Note that once styling has been applied to the element (i.e. once\n * `select(n)` is executed or the hostBindings/template function exits)\n * then the active `sanitizerFn` will be set to `null`. This means that\n * once styling is applied to another element then a another call to\n * `styleSanitizer` will need to be made.\n *\n * @param sanitizerFn The sanitization function that will be used to\n *       process style prop/value entries.\n *\n * @codeGenApi\n */\nexport function styleSanitizer(sanitizer: Sanitizer | StyleSanitizeFn | null): void {\n  setCurrentStyleSanitizer(sanitizer);\n}\n\n/**\n * Mirror implementation of the `styleProp()` instruction (found in `instructions/styling.ts`).\n */\nexport function styleProp(\n    prop: string, value: string | number | String | null, suffix?: string | null): void {\n  _stylingProp(prop, resolveStylePropValue(value, suffix), false);\n}\n\n/**\n * Mirror implementation of the `classProp()` instruction (found in `instructions/styling.ts`).\n */\nexport function classProp(className: string, value: boolean | null): void {\n  _stylingProp(className, value, true);\n}\n\n/**\n * Shared function used to update a prop-based styling binding for an element.\n */\nfunction _stylingProp(\n    prop: string, value: boolean | number | String | string | null, isClassBased: boolean) {\n  const index = getSelectedIndex();\n  const lView = getLView();\n  const bindingIndex = lView[BINDING_INDEX]++;\n  const tNode = getTNode(index, lView);\n  const defer = getActiveDirectiveSuperClassHeight() > 0;\n  if (isClassBased) {\n    updateClassBinding(\n        getClassesContext(tNode), lView, prop, bindingIndex, value as string | boolean | null,\n        defer, false);\n  } else {\n    const sanitizer = getCurrentOrLViewSanitizer(lView);\n    updateStyleBinding(\n        getStylesContext(tNode), lView, prop, bindingIndex, value as string | null, sanitizer,\n        defer, false);\n  }\n}\n\n/**\n * Mirror implementation of the `styleMap()` instruction (found in `instructions/styling.ts`).\n */\nexport function styleMap(styles: {[styleName: string]: any} | NO_CHANGE | null): void {\n  _stylingMap(styles, false);\n}\n\n/**\n * Mirror implementation of the `classMap()` instruction (found in `instructions/styling.ts`).\n */\nexport function classMap(classes: {[className: string]: any} | NO_CHANGE | string | null): void {\n  _stylingMap(classes, true);\n}\n\n/**\n * Shared function used to update a map-based styling binding for an element.\n *\n * When this function is called it will activate support for `[style]` and\n * `[class]` bindings in Angular.\n */\nfunction _stylingMap(value: {[key: string]: any} | string | null, isClassBased: boolean) {\n  activeStylingMapFeature();\n  const index = getSelectedIndex();\n  const lView = getLView();\n  const bindingIndex = lView[BINDING_INDEX]++;\n\n  if (value !== NO_CHANGE) {\n    const tNode = getTNode(index, lView);\n    const defer = getActiveDirectiveSuperClassHeight() > 0;\n    const oldValue = lView[bindingIndex];\n    const valueHasChanged = hasValueChanged(oldValue, value);\n    const lStylingMap = normalizeIntoStylingMap(oldValue, value);\n    if (isClassBased) {\n      updateClassBinding(\n          getClassesContext(tNode), lView, null, bindingIndex, lStylingMap, defer, valueHasChanged);\n    } else {\n      const sanitizer = getCurrentOrLViewSanitizer(lView);\n      updateStyleBinding(\n          getStylesContext(tNode), lView, null, bindingIndex, lStylingMap, sanitizer, defer,\n          valueHasChanged);\n    }\n  }\n}\n\n/**\n * Temporary function to bridge styling functionality between this new\n * refactor (which is here inside of `styling_next/`) and the old\n * implementation (which lives inside of `styling/`).\n *\n * The new styling refactor ensures that styling flushing is called\n * automatically when a template function exits or a follow-up element\n * is visited (i.e. when `select(n)` is called). Because the `select(n)`\n * instruction is not fully implemented yet (it doesn't actually execute\n * host binding instruction code at the right time), this means that a\n * styling apply function is still needed.\n *\n * This function is a mirror implementation of the `stylingApply()`\n * instruction (found in `instructions/styling.ts`).\n */\nexport function stylingApply() {\n  const index = getSelectedIndex();\n  const lView = getLView();\n  const tNode = getTNode(index, lView);\n  const renderer = getRenderer(tNode, lView);\n  const native = getNativeFromLView(index, lView);\n  const directiveIndex = getActiveDirectiveStylingIndex();\n  applyClasses(renderer, lView, getClassesContext(tNode), native, directiveIndex);\n\n  const sanitizer = getCurrentOrLViewSanitizer(lView);\n  applyStyles(renderer, lView, getStylesContext(tNode), native, directiveIndex, sanitizer);\n\n  setCurrentStyleSanitizer(null);\n}\n\n/**\n * Temporary function to bridge styling functionality between this new\n * refactor (which is here inside of `styling_next/`) and the old\n * implementation (which lives inside of `styling/`).\n *\n * The purpose of this function is to traverse through the LView data\n * for a specific element index and return the native node. Because the\n * current implementation relies on there being a styling context array,\n * the code below will need to loop through these array values until it\n * gets a native element node.\n *\n * Note that this code is temporary and will disappear once the new\n * styling refactor lands in its entirety.\n */\nfunction getNativeFromLView(index: number, viewData: LView): RElement {\n  let storageIndex = index + HEADER_OFFSET;\n  let slotValue: LContainer|LView|OldStylingContext|RElement = viewData[storageIndex];\n  let wrapper: LContainer|LView|OldStylingContext = viewData;\n  while (Array.isArray(slotValue)) {\n    wrapper = slotValue;\n    slotValue = slotValue[HOST] as LView | OldStylingContext | RElement;\n  }\n  if (isOldStylingContext(wrapper)) {\n    return wrapper[OldStylingIndex.ElementPosition] as RElement;\n  } else {\n    return slotValue;\n  }\n}\n\nfunction getRenderer(tNode: TNode, lView: LView) {\n  return tNode.type === TNodeType.Element ? lView[RENDERER] : null;\n}\n\n/**\n * Searches and assigns provided all static style/class entries (found in the `attrs` value)\n * and registers them in their respective styling contexts.\n */\nexport function registerInitialStylingIntoContext(\n    tNode: TNode, attrs: TAttributes, startIndex: number) {\n  let classesContext !: TStylingContext;\n  let stylesContext !: TStylingContext;\n  let mode = -1;\n  for (let i = startIndex; i < attrs.length; i++) {\n    const attr = attrs[i];\n    if (typeof attr == 'number') {\n      mode = attr;\n    } else if (mode == AttributeMarker.Classes) {\n      classesContext = classesContext || getClassesContext(tNode);\n      registerBinding(classesContext, -1, attr as string, true, false);\n    } else if (mode == AttributeMarker.Styles) {\n      stylesContext = stylesContext || getStylesContext(tNode);\n      registerBinding(stylesContext, -1, attr as string, attrs[++i] as string, false);\n    }\n  }\n}\n\n/**\n * Mirror implementation of the same function found in `instructions/styling.ts`.\n */\nexport function getActiveDirectiveStylingIndex(): number {\n  // whenever a directive's hostBindings function is called a uniqueId value\n  // is assigned. Normally this is enough to help distinguish one directive\n  // from another for the styling context, but there are situations where a\n  // sub-class directive could inherit and assign styling in concert with a\n  // parent directive. To help the styling code distinguish between a parent\n  // sub-classed directive the inheritance depth is taken into account as well.\n  return getActiveDirectiveId() + getActiveDirectiveSuperClassDepth();\n}\n\n/**\n * Temporary function that will update the max directive index value in\n * both the classes and styles contexts present on the provided `tNode`.\n *\n * This code is only used because the `select(n)` code functionality is not\n * yet 100% functional. The `select(n)` instruction cannot yet evaluate host\n * bindings function code in sync with the associated template function code.\n * For this reason the styling algorithm needs to track the last directive index\n * value so that it knows exactly when to render styling to the element since\n * `stylingApply()` is called multiple times per CD (`stylingApply` will be\n * removed once `select(n)` is fixed).\n */\nfunction updateLastDirectiveIndex(tNode: TNode, directiveIndex: number) {\n  updateContextDirectiveIndex(getClassesContext(tNode), directiveIndex);\n  updateContextDirectiveIndex(getStylesContext(tNode), directiveIndex);\n}\n\nfunction getStylesContext(tNode: TNode): TStylingContext {\n  return getContext(tNode, false);\n}\n\nfunction getClassesContext(tNode: TNode): TStylingContext {\n  return getContext(tNode, true);\n}\n\n/**\n * Returns/instantiates a styling context from/to a `tNode` instance.\n */\nfunction getContext(tNode: TNode, isClassBased: boolean) {\n  let context = isClassBased ? tNode.newClasses : tNode.newStyles;\n  if (!context) {\n    context = allocTStylingContext();\n    if (ngDevMode) {\n      attachStylingDebugObject(context);\n    }\n    if (isClassBased) {\n      tNode.newClasses = context;\n    } else {\n      tNode.newStyles = context;\n    }\n  }\n  return context;\n}\n\nfunction resolveStylePropValue(\n    value: string | number | String | null, suffix: string | null | undefined) {\n  let resolvedValue: string|null = null;\n  if (value !== null) {\n    if (suffix) {\n      // when a suffix is applied then it will bypass\n      // sanitization entirely (b/c a new string is created)\n      resolvedValue = renderStringify(value) + suffix;\n    } else {\n      // sanitization happens by dealing with a String value\n      // this means that the string value will be passed through\n      // into the style rendering later (which is where the value\n      // will be sanitized before it is applied)\n      resolvedValue = value as any as string;\n    }\n  }\n  return resolvedValue;\n}\n"]}

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

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling_next/interfaces.ts"],"names":[],"mappings":"","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"]}