@angular/core
Version:
Angular - the core framework
101 lines • 13.2 kB
JavaScript
import { isProceduralRenderer } from '../interfaces/renderer';
import { RENDERER } from '../interfaces/view';
import { getLView } from '../state';
import { isAnimationProp } from '../styling/util';
/**
* Assigns all attribute values to the provided element via the inferred renderer.
*
* This function accepts two forms of attribute entries:
*
* default: (key, value):
* attrs = [key1, value1, key2, value2]
*
* namespaced: (NAMESPACE_MARKER, uri, name, value)
* attrs = [NAMESPACE_MARKER, uri, name, value, NAMESPACE_MARKER, uri, name, value]
*
* The `attrs` array can contain a mix of both the default and namespaced entries.
* The "default" values are set without a marker, but if the function comes across
* a marker value then it will attempt to set a namespaced value. If the marker is
* not of a namespaced value then the function will quit and return the index value
* where it stopped during the iteration of the attrs array.
*
* See [AttributeMarker] to understand what the namespace marker value is.
*
* Note that this instruction does not support assigning style and class values to
* an element. See `elementStart` and `elementHostAttrs` to learn how styling values
* are applied to an element.
*
* @param native The element that the attributes will be assigned to
* @param attrs The attribute array of values that will be assigned to the element
* @returns the index value that was last accessed in the attributes array
*/
export function setUpAttributes(native, attrs) {
var renderer = getLView()[RENDERER];
var isProc = isProceduralRenderer(renderer);
var i = 0;
while (i < attrs.length) {
var value = attrs[i];
if (typeof value === 'number') {
// only namespaces are supported. Other value types (such as style/class
// entries) are not supported in this function.
if (value !== 0 /* NamespaceURI */) {
break;
}
// we just landed on the marker value ... therefore
// we should skip to the next entry
i++;
var namespaceURI = attrs[i++];
var attrName = attrs[i++];
var attrVal = attrs[i++];
ngDevMode && ngDevMode.rendererSetAttribute++;
isProc ?
renderer.setAttribute(native, attrName, attrVal, namespaceURI) :
native.setAttributeNS(namespaceURI, attrName, attrVal);
}
else {
// attrName is string;
var attrName = value;
var attrVal = attrs[++i];
// Standard attributes
ngDevMode && ngDevMode.rendererSetAttribute++;
if (isAnimationProp(attrName)) {
if (isProc) {
renderer.setProperty(native, attrName, attrVal);
}
}
else {
isProc ?
renderer
.setAttribute(native, attrName, attrVal) :
native.setAttribute(attrName, attrVal);
}
i++;
}
}
// another piece of code may iterate over the same attributes array. Therefore
// it may be helpful to return the exact spot where the attributes array exited
// whether by running into an unsupported marker or if all the static values were
// iterated over.
return i;
}
export function attrsStylingIndexOf(attrs, startIndex) {
for (var i = startIndex; i < attrs.length; i++) {
var val = attrs[i];
if (val === 1 /* Classes */ || val === 2 /* Styles */) {
return i;
}
}
return -1;
}
/**
* Test whether the given value is a marker that indicates that the following
* attribute values in a `TAttributes` array are only the names of attributes,
* and not name-value pairs.
* @param marker The attribute marker to test.
* @returns true if the marker is a "name-only" marker (e.g. `Bindings`, `Template` or `I18n`).
*/
export function isNameOnlyAttributeMarker(marker) {
return marker === 3 /* Bindings */ || marker === 4 /* Template */ ||
marker === 6 /* I18n */;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attrs_utils.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/util/attrs_utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAgC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAC,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,UAAU,CAAC;AAClC,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,eAAe,CAAC,MAAgB,EAAE,KAAkB;IAClE,IAAM,QAAQ,GAAG,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAM,MAAM,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAE9C,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE;QACvB,IAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,wEAAwE;YACxE,+CAA+C;YAC/C,IAAI,KAAK,yBAAiC,EAAE;gBAC1C,MAAM;aACP;YAED,mDAAmD;YACnD,mCAAmC;YACnC,CAAC,EAAE,CAAC;YAEJ,IAAM,YAAY,GAAG,KAAK,CAAC,CAAC,EAAE,CAAW,CAAC;YAC1C,IAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,EAAE,CAAW,CAAC;YACtC,IAAM,OAAO,GAAG,KAAK,CAAC,CAAC,EAAE,CAAW,CAAC;YACrC,SAAS,IAAI,SAAS,CAAC,oBAAoB,EAAE,CAAC;YAC9C,MAAM,CAAC,CAAC;gBACH,QAAgC,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;gBACzF,MAAM,CAAC,cAAc,CAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;SAC5D;aAAM;YACL,sBAAsB;YACtB,IAAM,QAAQ,GAAG,KAAe,CAAC;YACjC,IAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;YAC3B,sBAAsB;YACtB,SAAS,IAAI,SAAS,CAAC,oBAAoB,EAAE,CAAC;YAC9C,IAAI,eAAe,CAAC,QAAQ,CAAC,EAAE;gBAC7B,IAAI,MAAM,EAAE;oBACT,QAAgC,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;iBAC1E;aACF;iBAAM;gBACL,MAAM,CAAC,CAAC;oBACH,QAAgC;yBAC5B,YAAY,CAAC,MAAM,EAAE,QAAkB,EAAE,OAAiB,CAAC,CAAC,CAAC;oBAClE,MAAM,CAAC,YAAY,CAAC,QAAkB,EAAE,OAAiB,CAAC,CAAC;aAChE;YACD,CAAC,EAAE,CAAC;SACL;KACF;IAED,8EAA8E;IAC9E,+EAA+E;IAC/E,iFAAiF;IACjF,iBAAiB;IACjB,OAAO,CAAC,CAAC;AACX,CAAC;AAGD,MAAM,UAAU,mBAAmB,CAAC,KAAkB,EAAE,UAAkB;IACxE,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC9C,IAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,GAAG,oBAA4B,IAAI,GAAG,mBAA2B,EAAE;YACrE,OAAO,CAAC,CAAC;SACV;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAA8C;IACtF,OAAO,MAAM,qBAA6B,IAAI,MAAM,qBAA6B;QAC7E,MAAM,iBAAyB,CAAC;AACtC,CAAC","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 {AttributeMarker, TAttributes} from '../interfaces/node';\nimport {CssSelector} from '../interfaces/projection';\nimport {ProceduralRenderer3, RElement, isProceduralRenderer} from '../interfaces/renderer';\nimport {RENDERER} from '../interfaces/view';\nimport {getLView} from '../state';\nimport {isAnimationProp} from '../styling/util';\n\n\n\n/**\n * Assigns all attribute values to the provided element via the inferred renderer.\n *\n * This function accepts two forms of attribute entries:\n *\n * default: (key, value):\n *  attrs = [key1, value1, key2, value2]\n *\n * namespaced: (NAMESPACE_MARKER, uri, name, value)\n *  attrs = [NAMESPACE_MARKER, uri, name, value, NAMESPACE_MARKER, uri, name, value]\n *\n * The `attrs` array can contain a mix of both the default and namespaced entries.\n * The \"default\" values are set without a marker, but if the function comes across\n * a marker value then it will attempt to set a namespaced value. If the marker is\n * not of a namespaced value then the function will quit and return the index value\n * where it stopped during the iteration of the attrs array.\n *\n * See [AttributeMarker] to understand what the namespace marker value is.\n *\n * Note that this instruction does not support assigning style and class values to\n * an element. See `elementStart` and `elementHostAttrs` to learn how styling values\n * are applied to an element.\n *\n * @param native The element that the attributes will be assigned to\n * @param attrs The attribute array of values that will be assigned to the element\n * @returns the index value that was last accessed in the attributes array\n */\nexport function setUpAttributes(native: RElement, attrs: TAttributes): number {\n  const renderer = getLView()[RENDERER];\n  const isProc = isProceduralRenderer(renderer);\n\n  let i = 0;\n  while (i < attrs.length) {\n    const value = attrs[i];\n    if (typeof value === 'number') {\n      // only namespaces are supported. Other value types (such as style/class\n      // entries) are not supported in this function.\n      if (value !== AttributeMarker.NamespaceURI) {\n        break;\n      }\n\n      // we just landed on the marker value ... therefore\n      // we should skip to the next entry\n      i++;\n\n      const namespaceURI = attrs[i++] as string;\n      const attrName = attrs[i++] as string;\n      const attrVal = attrs[i++] as string;\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      isProc ?\n          (renderer as ProceduralRenderer3).setAttribute(native, attrName, attrVal, namespaceURI) :\n          native.setAttributeNS(namespaceURI, attrName, attrVal);\n    } else {\n      // attrName is string;\n      const attrName = value as string;\n      const attrVal = attrs[++i];\n      // Standard attributes\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      if (isAnimationProp(attrName)) {\n        if (isProc) {\n          (renderer as ProceduralRenderer3).setProperty(native, attrName, attrVal);\n        }\n      } else {\n        isProc ?\n            (renderer as ProceduralRenderer3)\n                .setAttribute(native, attrName as string, attrVal as string) :\n            native.setAttribute(attrName as string, attrVal as string);\n      }\n      i++;\n    }\n  }\n\n  // another piece of code may iterate over the same attributes array. Therefore\n  // it may be helpful to return the exact spot where the attributes array exited\n  // whether by running into an unsupported marker or if all the static values were\n  // iterated over.\n  return i;\n}\n\n\nexport function attrsStylingIndexOf(attrs: TAttributes, startIndex: number): number {\n  for (let i = startIndex; i < attrs.length; i++) {\n    const val = attrs[i];\n    if (val === AttributeMarker.Classes || val === AttributeMarker.Styles) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Test whether the given value is a marker that indicates that the following\n * attribute values in a `TAttributes` array are only the names of attributes,\n * and not name-value pairs.\n * @param marker The attribute marker to test.\n * @returns true if the marker is a \"name-only\" marker (e.g. `Bindings`, `Template` or `I18n`).\n */\nexport function isNameOnlyAttributeMarker(marker: string | AttributeMarker | CssSelector) {\n  return marker === AttributeMarker.Bindings || marker === AttributeMarker.Template ||\n      marker === AttributeMarker.I18n;\n}\n"]}