@angular/core 8.0.3 → 8.1.0-beta.0

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

@@ -0,0 +1,366 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+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.
+ * @return {?}
+ */
+export function stylingInit() {
+    /** @type {?} */
+    const lView = getLView();
+    /** @type {?} */
+    const index = getSelectedIndex();
+    /** @type {?} */
+    const 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.
+ *
+ * \@codeGenApi
+ * @param {?} sanitizer
+ * @return {?}
+ */
+export function styleSanitizer(sanitizer) {
+    setCurrentStyleSanitizer(sanitizer);
+}
+/**
+ * Mirror implementation of the `styleProp()` instruction (found in `instructions/styling.ts`).
+ * @param {?} prop
+ * @param {?} value
+ * @param {?=} suffix
+ * @return {?}
+ */
+export function styleProp(prop, value, suffix) {
+    _stylingProp(prop, resolveStylePropValue(value, suffix), false);
+}
+/**
+ * Mirror implementation of the `classProp()` instruction (found in `instructions/styling.ts`).
+ * @param {?} className
+ * @param {?} value
+ * @return {?}
+ */
+export function classProp(className, value) {
+    _stylingProp(className, value, true);
+}
+/**
+ * Shared function used to update a prop-based styling binding for an element.
+ * @param {?} prop
+ * @param {?} value
+ * @param {?} isClassBased
+ * @return {?}
+ */
+function _stylingProp(prop, value, isClassBased) {
+    /** @type {?} */
+    const index = getSelectedIndex();
+    /** @type {?} */
+    const lView = getLView();
+    /** @type {?} */
+    const bindingIndex = lView[BINDING_INDEX]++;
+    /** @type {?} */
+    const tNode = getTNode(index, lView);
+    /** @type {?} */
+    const defer = getActiveDirectiveSuperClassHeight() > 0;
+    if (isClassBased) {
+        updateClassBinding(getClassesContext(tNode), lView, prop, bindingIndex, (/** @type {?} */ (value)), defer, false);
+    }
+    else {
+        /** @type {?} */
+        const sanitizer = getCurrentOrLViewSanitizer(lView);
+        updateStyleBinding(getStylesContext(tNode), lView, prop, bindingIndex, (/** @type {?} */ (value)), sanitizer, defer, false);
+    }
+}
+/**
+ * Mirror implementation of the `styleMap()` instruction (found in `instructions/styling.ts`).
+ * @param {?} styles
+ * @return {?}
+ */
+export function styleMap(styles) {
+    _stylingMap(styles, false);
+}
+/**
+ * Mirror implementation of the `classMap()` instruction (found in `instructions/styling.ts`).
+ * @param {?} classes
+ * @return {?}
+ */
+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.
+ * @param {?} value
+ * @param {?} isClassBased
+ * @return {?}
+ */
+function _stylingMap(value, isClassBased) {
+    activeStylingMapFeature();
+    /** @type {?} */
+    const index = getSelectedIndex();
+    /** @type {?} */
+    const lView = getLView();
+    /** @type {?} */
+    const bindingIndex = lView[BINDING_INDEX]++;
+    if (value !== NO_CHANGE) {
+        /** @type {?} */
+        const tNode = getTNode(index, lView);
+        /** @type {?} */
+        const defer = getActiveDirectiveSuperClassHeight() > 0;
+        /** @type {?} */
+        const oldValue = lView[bindingIndex];
+        /** @type {?} */
+        const valueHasChanged = hasValueChanged(oldValue, value);
+        /** @type {?} */
+        const lStylingMap = normalizeIntoStylingMap(oldValue, value);
+        if (isClassBased) {
+            updateClassBinding(getClassesContext(tNode), lView, null, bindingIndex, lStylingMap, defer, valueHasChanged);
+        }
+        else {
+            /** @type {?} */
+            const 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`).
+ * @return {?}
+ */
+export function stylingApply() {
+    /** @type {?} */
+    const index = getSelectedIndex();
+    /** @type {?} */
+    const lView = getLView();
+    /** @type {?} */
+    const tNode = getTNode(index, lView);
+    /** @type {?} */
+    const renderer = getRenderer(tNode, lView);
+    /** @type {?} */
+    const native = getNativeFromLView(index, lView);
+    /** @type {?} */
+    const directiveIndex = getActiveDirectiveStylingIndex();
+    applyClasses(renderer, lView, getClassesContext(tNode), native, directiveIndex);
+    /** @type {?} */
+    const 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.
+ * @param {?} index
+ * @param {?} viewData
+ * @return {?}
+ */
+function getNativeFromLView(index, viewData) {
+    /** @type {?} */
+    let storageIndex = index + HEADER_OFFSET;
+    /** @type {?} */
+    let slotValue = viewData[storageIndex];
+    /** @type {?} */
+    let wrapper = viewData;
+    while (Array.isArray(slotValue)) {
+        wrapper = slotValue;
+        slotValue = (/** @type {?} */ (slotValue[HOST]));
+    }
+    if (isOldStylingContext(wrapper)) {
+        return (/** @type {?} */ (wrapper[0 /* ElementPosition */]));
+    }
+    else {
+        return slotValue;
+    }
+}
+/**
+ * @param {?} tNode
+ * @param {?} lView
+ * @return {?}
+ */
+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.
+ * @param {?} tNode
+ * @param {?} attrs
+ * @param {?} startIndex
+ * @return {?}
+ */
+export function registerInitialStylingIntoContext(tNode, attrs, startIndex) {
+    /** @type {?} */
+    let classesContext;
+    /** @type {?} */
+    let stylesContext;
+    /** @type {?} */
+    let mode = -1;
+    for (let i = startIndex; i < attrs.length; i++) {
+        /** @type {?} */
+        const attr = attrs[i];
+        if (typeof attr == 'number') {
+            mode = attr;
+        }
+        else if (mode == 1 /* Classes */) {
+            classesContext = classesContext || getClassesContext(tNode);
+            registerBinding(classesContext, -1, (/** @type {?} */ (attr)), true, false);
+        }
+        else if (mode == 2 /* Styles */) {
+            stylesContext = stylesContext || getStylesContext(tNode);
+            registerBinding(stylesContext, -1, (/** @type {?} */ (attr)), (/** @type {?} */ (attrs[++i])), false);
+        }
+    }
+}
+/**
+ * Mirror implementation of the same function found in `instructions/styling.ts`.
+ * @return {?}
+ */
+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).
+ * @param {?} tNode
+ * @param {?} directiveIndex
+ * @return {?}
+ */
+function updateLastDirectiveIndex(tNode, directiveIndex) {
+    updateContextDirectiveIndex(getClassesContext(tNode), directiveIndex);
+    updateContextDirectiveIndex(getStylesContext(tNode), directiveIndex);
+}
+/**
+ * @param {?} tNode
+ * @return {?}
+ */
+function getStylesContext(tNode) {
+    return getContext(tNode, false);
+}
+/**
+ * @param {?} tNode
+ * @return {?}
+ */
+function getClassesContext(tNode) {
+    return getContext(tNode, true);
+}
+/**
+ * Returns/instantiates a styling context from/to a `tNode` instance.
+ * @param {?} tNode
+ * @param {?} isClassBased
+ * @return {?}
+ */
+function getContext(tNode, isClassBased) {
+    /** @type {?} */
+    let 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;
+}
+/**
+ * @param {?} value
+ * @param {?} suffix
+ * @return {?}
+ */
+function resolveStylePropValue(value, suffix) {
+    /** @type {?} */
+    let 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 = (/** @type {?} */ ((/** @type {?} */ (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"]}