@angular/core
Version:
Angular - the core framework
277 lines • 36.8 kB
JavaScript
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"]}