@angular/core 7.1.0 → 7.1.4

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,17 +9,22 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+/**
+ * The goal here is to make sure that the browser DOM API is the Renderer.
+ * We do this by defining a subset of DOM API to be the renderer and than
+ * use that time for rendering.
+ *
+ * At runtime we can than use the DOM api directly, in server or web-worker
+ * it will be easy to implement such API.
+ */
 /** @enum {number} */
-var RendererStyleFlags3 = {
+const RendererStyleFlags3 = {
     Important: 1,
     DashCase: 2,
 };
 export { RendererStyleFlags3 };
 RendererStyleFlags3[RendererStyleFlags3.Important] = 'Important';
 RendererStyleFlags3[RendererStyleFlags3.DashCase] = 'DashCase';
-/** @typedef {?} */
-var Renderer3;
-export { Renderer3 };
 /**
  * Object Oriented style of API needed to create elements and text nodes.
  *
@@ -30,23 +35,41 @@ export { Renderer3 };
  * @record
  */
 export function ObjectOrientedRenderer3() { }
-/** @type {?} */
-ObjectOrientedRenderer3.prototype.createComment;
-/** @type {?} */
-ObjectOrientedRenderer3.prototype.createElement;
-/** @type {?} */
-ObjectOrientedRenderer3.prototype.createElementNS;
-/** @type {?} */
-ObjectOrientedRenderer3.prototype.createTextNode;
-/** @type {?} */
-ObjectOrientedRenderer3.prototype.querySelector;
+if (false) {
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createComment = function (data) { };
+    /**
+     * @param {?} tagName
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createElement = function (tagName) { };
+    /**
+     * @param {?} namespace
+     * @param {?} tagName
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createElementNS = function (namespace, tagName) { };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createTextNode = function (data) { };
+    /**
+     * @param {?} selectors
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.querySelector = function (selectors) { };
+}
 /**
  * Returns whether the `renderer` is a `ProceduralRenderer3`
  * @param {?} renderer
  * @return {?}
  */
 export function isProceduralRenderer(renderer) {
-    return !!((/** @type {?} */ (renderer)).listen);
+    return !!(((/** @type {?} */ (renderer))).listen);
 }
 /**
  * Procedural style of API needed to create elements and text nodes.
@@ -57,61 +80,151 @@ export function isProceduralRenderer(renderer) {
  * @record
  */
 export function ProceduralRenderer3() { }
-/** @type {?} */
-ProceduralRenderer3.prototype.destroy;
-/** @type {?} */
-ProceduralRenderer3.prototype.createComment;
-/** @type {?} */
-ProceduralRenderer3.prototype.createElement;
-/** @type {?} */
-ProceduralRenderer3.prototype.createText;
-/**
- * This property is allowed to be null / undefined,
- * in which case the view engine won't call it.
- * This is used as a performance optimization for production mode.
- * @type {?|undefined}
- */
-ProceduralRenderer3.prototype.destroyNode;
-/** @type {?} */
-ProceduralRenderer3.prototype.appendChild;
-/** @type {?} */
-ProceduralRenderer3.prototype.insertBefore;
-/** @type {?} */
-ProceduralRenderer3.prototype.removeChild;
-/** @type {?} */
-ProceduralRenderer3.prototype.selectRootElement;
-/** @type {?} */
-ProceduralRenderer3.prototype.parentNode;
-/** @type {?} */
-ProceduralRenderer3.prototype.nextSibling;
-/** @type {?} */
-ProceduralRenderer3.prototype.setAttribute;
-/** @type {?} */
-ProceduralRenderer3.prototype.removeAttribute;
-/** @type {?} */
-ProceduralRenderer3.prototype.addClass;
-/** @type {?} */
-ProceduralRenderer3.prototype.removeClass;
-/** @type {?} */
-ProceduralRenderer3.prototype.setStyle;
-/** @type {?} */
-ProceduralRenderer3.prototype.removeStyle;
-/** @type {?} */
-ProceduralRenderer3.prototype.setProperty;
-/** @type {?} */
-ProceduralRenderer3.prototype.setValue;
-/** @type {?} */
-ProceduralRenderer3.prototype.listen;
+if (false) {
+    /**
+     * This property is allowed to be null / undefined,
+     * in which case the view engine won't call it.
+     * This is used as a performance optimization for production mode.
+     * @type {?|undefined}
+     */
+    ProceduralRenderer3.prototype.destroyNode;
+    /**
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.destroy = function () { };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createComment = function (value) { };
+    /**
+     * @param {?} name
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createElement = function (name, namespace) { };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createText = function (value) { };
+    /**
+     * @param {?} parent
+     * @param {?} newChild
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.appendChild = function (parent, newChild) { };
+    /**
+     * @param {?} parent
+     * @param {?} newChild
+     * @param {?} refChild
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.insertBefore = function (parent, newChild, refChild) { };
+    /**
+     * @param {?} parent
+     * @param {?} oldChild
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeChild = function (parent, oldChild) { };
+    /**
+     * @param {?} selectorOrNode
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.selectRootElement = function (selectorOrNode) { };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.parentNode = function (node) { };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.nextSibling = function (node) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?} value
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setAttribute = function (el, name, value, namespace) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeAttribute = function (el, name, namespace) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.addClass = function (el, name) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeClass = function (el, name) { };
+    /**
+     * @param {?} el
+     * @param {?} style
+     * @param {?} value
+     * @param {?=} flags
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setStyle = function (el, style, value, flags) { };
+    /**
+     * @param {?} el
+     * @param {?} style
+     * @param {?=} flags
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeStyle = function (el, style, flags) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setProperty = function (el, name, value) { };
+    /**
+     * @param {?} node
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setValue = function (node, value) { };
+    /**
+     * @param {?} target
+     * @param {?} eventName
+     * @param {?} callback
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.listen = function (target, eventName, callback) { };
+}
 /**
  * @record
  */
 export function RendererFactory3() { }
-/** @type {?} */
-RendererFactory3.prototype.createRenderer;
-/** @type {?|undefined} */
-RendererFactory3.prototype.begin;
-/** @type {?|undefined} */
-RendererFactory3.prototype.end;
+if (false) {
+    /**
+     * @param {?} hostElement
+     * @param {?} rendererType
+     * @return {?}
+     */
+    RendererFactory3.prototype.createRenderer = function (hostElement, rendererType) { };
+    /**
+     * @return {?}
+     */
+    RendererFactory3.prototype.begin = function () { };
+    /**
+     * @return {?}
+     */
+    RendererFactory3.prototype.end = function () { };
+}
 /** @type {?} */
 export const domRendererFactory3 = {
     createRenderer: (hostElement, rendererType) => { return document; }
@@ -121,77 +234,135 @@ export const domRendererFactory3 = {
  * @record
  */
 export function RNode() { }
-/** @type {?} */
-RNode.prototype.parentNode;
-/** @type {?} */
-RNode.prototype.nextSibling;
-/** @type {?} */
-RNode.prototype.removeChild;
-/**
- * Insert a child node.
- *
- * Used exclusively for adding View root nodes into ViewAnchor location.
- * @type {?}
- */
-RNode.prototype.insertBefore;
-/**
- * Append a child node.
- *
- * Used exclusively for building up DOM which are static (ie not View roots)
- * @type {?}
- */
-RNode.prototype.appendChild;
+if (false) {
+    /** @type {?} */
+    RNode.prototype.parentNode;
+    /** @type {?} */
+    RNode.prototype.nextSibling;
+    /**
+     * @param {?} oldChild
+     * @return {?}
+     */
+    RNode.prototype.removeChild = function (oldChild) { };
+    /**
+     * Insert a child node.
+     *
+     * Used exclusively for adding View root nodes into ViewAnchor location.
+     * @param {?} newChild
+     * @param {?} refChild
+     * @param {?} isViewRoot
+     * @return {?}
+     */
+    RNode.prototype.insertBefore = function (newChild, refChild, isViewRoot) { };
+    /**
+     * Append a child node.
+     *
+     * Used exclusively for building up DOM which are static (ie not View roots)
+     * @param {?} newChild
+     * @return {?}
+     */
+    RNode.prototype.appendChild = function (newChild) { };
+}
 /**
  * Subset of API needed for writing attributes, properties, and setting up
  * listeners on Element.
  * @record
  */
 export function RElement() { }
-/** @type {?} */
-RElement.prototype.style;
-/** @type {?} */
-RElement.prototype.classList;
-/** @type {?} */
-RElement.prototype.className;
-/** @type {?} */
-RElement.prototype.setAttribute;
-/** @type {?} */
-RElement.prototype.removeAttribute;
-/** @type {?} */
-RElement.prototype.setAttributeNS;
-/** @type {?} */
-RElement.prototype.addEventListener;
-/** @type {?} */
-RElement.prototype.removeEventListener;
-/** @type {?|undefined} */
-RElement.prototype.setProperty;
+if (false) {
+    /** @type {?} */
+    RElement.prototype.style;
+    /** @type {?} */
+    RElement.prototype.classList;
+    /** @type {?} */
+    RElement.prototype.className;
+    /**
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setAttribute = function (name, value) { };
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    RElement.prototype.removeAttribute = function (name) { };
+    /**
+     * @param {?} namespaceURI
+     * @param {?} qualifiedName
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setAttributeNS = function (namespaceURI, qualifiedName, value) { };
+    /**
+     * @param {?} type
+     * @param {?} listener
+     * @param {?=} useCapture
+     * @return {?}
+     */
+    RElement.prototype.addEventListener = function (type, listener, useCapture) { };
+    /**
+     * @param {?} type
+     * @param {?=} listener
+     * @param {?=} options
+     * @return {?}
+     */
+    RElement.prototype.removeEventListener = function (type, listener, options) { };
+    /**
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setProperty = function (name, value) { };
+}
 /**
  * @record
  */
 export function RCssStyleDeclaration() { }
-/** @type {?} */
-RCssStyleDeclaration.prototype.removeProperty;
-/** @type {?} */
-RCssStyleDeclaration.prototype.setProperty;
+if (false) {
+    /**
+     * @param {?} propertyName
+     * @return {?}
+     */
+    RCssStyleDeclaration.prototype.removeProperty = function (propertyName) { };
+    /**
+     * @param {?} propertyName
+     * @param {?} value
+     * @param {?=} priority
+     * @return {?}
+     */
+    RCssStyleDeclaration.prototype.setProperty = function (propertyName, value, priority) { };
+}
 /**
  * @record
  */
 export function RDomTokenList() { }
-/** @type {?} */
-RDomTokenList.prototype.add;
-/** @type {?} */
-RDomTokenList.prototype.remove;
+if (false) {
+    /**
+     * @param {?} token
+     * @return {?}
+     */
+    RDomTokenList.prototype.add = function (token) { };
+    /**
+     * @param {?} token
+     * @return {?}
+     */
+    RDomTokenList.prototype.remove = function (token) { };
+}
 /**
  * @record
  */
 export function RText() { }
-/** @type {?} */
-RText.prototype.textContent;
+if (false) {
+    /** @type {?} */
+    RText.prototype.textContent;
+}
 /**
  * @record
  */
 export function RComment() { }
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/renderer.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAsBE,YAAkB;IAClB,WAAiB;;;wCADjB,SAAS;wCACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBV,MAAM,UAAU,oBAAoB,CAAC,QAAuD;IAE1F,OAAO,CAAC,CAAC,CAAC,mBAAC,QAAe,EAAC,CAAC,MAAM,CAAC,CAAC;CACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDD,aAAa,mBAAmB,GAAqB;IACnD,cAAc,EAAE,CAAC,WAA4B,EAAE,YAAkC,EACnD,EAAE,GAAG,OAAO,QAAQ,CAAC,EAAC;CACrD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DF,aAAa,6BAA6B,GAAG,CAAC,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 */\n\n/**\n * The goal here is to make sure that the browser DOM API is the Renderer.\n * We do this by defining a subset of DOM API to be the renderer and than\n * use that time for rendering.\n *\n * At runtime we can than use the DOM api directly, in server or web-worker\n * it will be easy to implement such API.\n */\n\nimport {RendererStyleFlags2, RendererType2} from '../../render/api';\n\n\n// TODO: cleanup once the code is merged in angular/angular\nexport enum RendererStyleFlags3 {\n  Important = 1 << 0,\n  DashCase = 1 << 1\n}\n\nexport type Renderer3 = ObjectOrientedRenderer3 | ProceduralRenderer3;\n\n/**\n * Object Oriented style of API needed to create elements and text nodes.\n *\n * This is the native browser API style, e.g. operations are methods on individual objects\n * like HTMLElement. With this style, no additional code is needed as a facade\n * (reducing payload size).\n * */\nexport interface ObjectOrientedRenderer3 {\n  createComment(data: string): RComment;\n  createElement(tagName: string): RElement;\n  createElementNS(namespace: string, tagName: string): RElement;\n  createTextNode(data: string): RText;\n\n  querySelector(selectors: string): RElement|null;\n}\n\n/** Returns whether the `renderer` is a `ProceduralRenderer3` */\nexport function isProceduralRenderer(renderer: ProceduralRenderer3 | ObjectOrientedRenderer3):\n    renderer is ProceduralRenderer3 {\n  return !!((renderer as any).listen);\n}\n\n/**\n * Procedural style of API needed to create elements and text nodes.\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the\n * facade that enables element manipulation. This also facilitates backwards compatibility\n * with Renderer2.\n */\nexport interface ProceduralRenderer3 {\n  destroy(): void;\n  createComment(value: string): RComment;\n  createElement(name: string, namespace?: string|null): RElement;\n  createText(value: string): RText;\n  /**\n   * This property is allowed to be null / undefined,\n   * in which case the view engine won't call it.\n   * This is used as a performance optimization for production mode.\n   */\n  destroyNode?: ((node: RNode) => void)|null;\n  appendChild(parent: RElement, newChild: RNode): void;\n  insertBefore(parent: RNode, newChild: RNode, refChild: RNode|null): void;\n  removeChild(parent: RElement, oldChild: RNode): void;\n  selectRootElement(selectorOrNode: string|any): RElement;\n\n  parentNode(node: RNode): RElement|null;\n  nextSibling(node: RNode): RNode|null;\n\n  setAttribute(el: RElement, name: string, value: string, namespace?: string|null): void;\n  removeAttribute(el: RElement, name: string, namespace?: string|null): void;\n  addClass(el: RElement, name: string): void;\n  removeClass(el: RElement, name: string): void;\n  setStyle(\n      el: RElement, style: string, value: any,\n      flags?: RendererStyleFlags2|RendererStyleFlags3): void;\n  removeStyle(el: RElement, style: string, flags?: RendererStyleFlags2|RendererStyleFlags3): void;\n  setProperty(el: RElement, name: string, value: any): void;\n  setValue(node: RText, value: string): void;\n\n  // TODO(misko): Deprecate in favor of addEventListener/removeEventListener\n  listen(target: RNode, eventName: string, callback: (event: any) => boolean | void): () => void;\n}\n\nexport interface RendererFactory3 {\n  createRenderer(hostElement: RElement|null, rendererType: RendererType2|null): Renderer3;\n  begin?(): void;\n  end?(): void;\n}\n\nexport const domRendererFactory3: RendererFactory3 = {\n  createRenderer: (hostElement: RElement | null, rendererType: RendererType2 | null):\n                      Renderer3 => { return document;}\n};\n\n/** Subset of API needed for appending elements and text nodes. */\nexport interface RNode {\n  parentNode: RNode|null;\n\n  nextSibling: RNode|null;\n\n  removeChild(oldChild: RNode): void;\n\n  /**\n   * Insert a child node.\n   *\n   * Used exclusively for adding View root nodes into ViewAnchor location.\n   */\n  insertBefore(newChild: RNode, refChild: RNode|null, isViewRoot: boolean): void;\n\n  /**\n   * Append a child node.\n   *\n   * Used exclusively for building up DOM which are static (ie not View roots)\n   */\n  appendChild(newChild: RNode): RNode;\n}\n\n/**\n * Subset of API needed for writing attributes, properties, and setting up\n * listeners on Element.\n */\nexport interface RElement extends RNode {\n  style: RCssStyleDeclaration;\n  classList: RDomTokenList;\n  className: string;\n  setAttribute(name: string, value: string): void;\n  removeAttribute(name: string): void;\n  setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;\n  addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;\n  removeEventListener(type: string, listener?: EventListener, options?: boolean): void;\n\n  setProperty?(name: string, value: any): void;\n}\n\nexport interface RCssStyleDeclaration {\n  removeProperty(propertyName: string): string;\n  setProperty(propertyName: string, value: string|null, priority?: string): void;\n}\n\nexport interface RDomTokenList {\n  add(token: string): void;\n  remove(token: string): void;\n}\n\nexport interface RText extends RNode { textContent: string|null; }\n\nexport interface RComment extends RNode {}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/renderer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;IAsBE,YAAkB;IAClB,WAAiB;;;;;;;;;;;;;;AAYnB,6CAOC;;;;;;IANC,sEAAsC;;;;;IACtC,yEAAyC;;;;;;IACzC,sFAA8D;;;;;IAC9D,uEAAoC;;;;;IAEpC,2EAAgD;;;;;;;AAIlD,MAAM,UAAU,oBAAoB,CAAC,QAAuD;IAE1F,OAAO,CAAC,CAAC,CAAC,CAAC,mBAAA,QAAQ,EAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AACtC,CAAC;;;;;;;;;AASD,yCAgCC;;;;;;;;IAtBC,0CAA2C;;;;IAT3C,wDAAgB;;;;;IAChB,mEAAuC;;;;;;IACvC,6EAA+D;;;;;IAC/D,gEAAiC;;;;;;IAOjC,4EAAqD;;;;;;;IACrD,uFAAyE;;;;;;IACzE,4EAAqD;;;;;IACrD,gFAAwD;;;;;IAExD,+DAAuC;;;;;IACvC,gEAAqC;;;;;;;;IAErC,uFAAuF;;;;;;;IACvF,mFAA2E;;;;;;IAC3E,iEAA2C;;;;;;IAC3C,oEAA8C;;;;;;;;IAC9C,gFAE2D;;;;;;;IAC3D,4EAAgG;;;;;;;IAChG,2EAA0D;;;;;;IAC1D,oEAA2C;;;;;;;IAG3C,kFAA+F;;;;;AAGjG,sCAIC;;;;;;;IAHC,qFAAwF;;;;IACxF,mDAAe;;;;IACf,iDAAa;;;AAGf,MAAM,OAAO,mBAAmB,GAAqB;IACnD,cAAc,EAAE,CAAC,WAA4B,EAAE,YAAkC,EACnD,EAAE,GAAG,OAAO,QAAQ,CAAC,CAAA,CAAC;CACrD;;;;;AAGD,2BAoBC;;;IAnBC,2BAAuB;;IAEvB,4BAAwB;;;;;IAExB,sDAAmC;;;;;;;;;;IAOnC,6EAA+E;;;;;;;;IAO/E,sDAAoC;;;;;;;AAOtC,8BAWC;;;IAVC,yBAA4B;;IAC5B,6BAAyB;;IACzB,6BAAkB;;;;;;IAClB,6DAAgD;;;;;IAChD,yDAAoC;;;;;;;IACpC,sFAAiF;;;;;;;IACjF,gFAAoF;;;;;;;IACpF,gFAAqF;;;;;;IAErF,4DAA6C;;;;;AAG/C,0CAGC;;;;;;IAFC,4EAA6C;;;;;;;IAC7C,0FAA+E;;;;;AAGjF,mCAGC;;;;;;IAFC,mDAAyB;;;;;IACzB,sDAA4B;;;;;AAG9B,2BAAkE;;;IAA3B,4BAAyB;;;;;AAEhE,8BAA0C;;;;AAI1C,MAAM,OAAO,6BAA6B,GAAG,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 */\n\n/**\n * The goal here is to make sure that the browser DOM API is the Renderer.\n * We do this by defining a subset of DOM API to be the renderer and than\n * use that time for rendering.\n *\n * At runtime we can than use the DOM api directly, in server or web-worker\n * it will be easy to implement such API.\n */\n\nimport {RendererStyleFlags2, RendererType2} from '../../render/api';\n\n\n// TODO: cleanup once the code is merged in angular/angular\nexport enum RendererStyleFlags3 {\n  Important = 1 << 0,\n  DashCase = 1 << 1\n}\n\nexport type Renderer3 = ObjectOrientedRenderer3 | ProceduralRenderer3;\n\n/**\n * Object Oriented style of API needed to create elements and text nodes.\n *\n * This is the native browser API style, e.g. operations are methods on individual objects\n * like HTMLElement. With this style, no additional code is needed as a facade\n * (reducing payload size).\n * */\nexport interface ObjectOrientedRenderer3 {\n  createComment(data: string): RComment;\n  createElement(tagName: string): RElement;\n  createElementNS(namespace: string, tagName: string): RElement;\n  createTextNode(data: string): RText;\n\n  querySelector(selectors: string): RElement|null;\n}\n\n/** Returns whether the `renderer` is a `ProceduralRenderer3` */\nexport function isProceduralRenderer(renderer: ProceduralRenderer3 | ObjectOrientedRenderer3):\n    renderer is ProceduralRenderer3 {\n  return !!((renderer as any).listen);\n}\n\n/**\n * Procedural style of API needed to create elements and text nodes.\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the\n * facade that enables element manipulation. This also facilitates backwards compatibility\n * with Renderer2.\n */\nexport interface ProceduralRenderer3 {\n  destroy(): void;\n  createComment(value: string): RComment;\n  createElement(name: string, namespace?: string|null): RElement;\n  createText(value: string): RText;\n  /**\n   * This property is allowed to be null / undefined,\n   * in which case the view engine won't call it.\n   * This is used as a performance optimization for production mode.\n   */\n  destroyNode?: ((node: RNode) => void)|null;\n  appendChild(parent: RElement, newChild: RNode): void;\n  insertBefore(parent: RNode, newChild: RNode, refChild: RNode|null): void;\n  removeChild(parent: RElement, oldChild: RNode): void;\n  selectRootElement(selectorOrNode: string|any): RElement;\n\n  parentNode(node: RNode): RElement|null;\n  nextSibling(node: RNode): RNode|null;\n\n  setAttribute(el: RElement, name: string, value: string, namespace?: string|null): void;\n  removeAttribute(el: RElement, name: string, namespace?: string|null): void;\n  addClass(el: RElement, name: string): void;\n  removeClass(el: RElement, name: string): void;\n  setStyle(\n      el: RElement, style: string, value: any,\n      flags?: RendererStyleFlags2|RendererStyleFlags3): void;\n  removeStyle(el: RElement, style: string, flags?: RendererStyleFlags2|RendererStyleFlags3): void;\n  setProperty(el: RElement, name: string, value: any): void;\n  setValue(node: RText, value: string): void;\n\n  // TODO(misko): Deprecate in favor of addEventListener/removeEventListener\n  listen(target: RNode, eventName: string, callback: (event: any) => boolean | void): () => void;\n}\n\nexport interface RendererFactory3 {\n  createRenderer(hostElement: RElement|null, rendererType: RendererType2|null): Renderer3;\n  begin?(): void;\n  end?(): void;\n}\n\nexport const domRendererFactory3: RendererFactory3 = {\n  createRenderer: (hostElement: RElement | null, rendererType: RendererType2 | null):\n                      Renderer3 => { return document;}\n};\n\n/** Subset of API needed for appending elements and text nodes. */\nexport interface RNode {\n  parentNode: RNode|null;\n\n  nextSibling: RNode|null;\n\n  removeChild(oldChild: RNode): void;\n\n  /**\n   * Insert a child node.\n   *\n   * Used exclusively for adding View root nodes into ViewAnchor location.\n   */\n  insertBefore(newChild: RNode, refChild: RNode|null, isViewRoot: boolean): void;\n\n  /**\n   * Append a child node.\n   *\n   * Used exclusively for building up DOM which are static (ie not View roots)\n   */\n  appendChild(newChild: RNode): RNode;\n}\n\n/**\n * Subset of API needed for writing attributes, properties, and setting up\n * listeners on Element.\n */\nexport interface RElement extends RNode {\n  style: RCssStyleDeclaration;\n  classList: RDomTokenList;\n  className: string;\n  setAttribute(name: string, value: string): void;\n  removeAttribute(name: string): void;\n  setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;\n  addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;\n  removeEventListener(type: string, listener?: EventListener, options?: boolean): void;\n\n  setProperty?(name: string, value: any): void;\n}\n\nexport interface RCssStyleDeclaration {\n  removeProperty(propertyName: string): string;\n  setProperty(propertyName: string, value: string|null, priority?: string): void;\n}\n\nexport interface RDomTokenList {\n  add(token: string): void;\n  remove(token: string): void;\n}\n\nexport interface RText extends RNode { textContent: string|null; }\n\nexport interface RComment extends RNode {}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,8 +9,4 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-/** @typedef {?} */
-var SanitizerFn;
-export { SanitizerFn };
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy9pbnRlcmZhY2VzL3Nhbml0aXphdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIEZ1bmN0aW9uIHVzZWQgdG8gc2FuaXRpemUgdGhlIHZhbHVlIGJlZm9yZSB3cml0aW5nIGl0IGludG8gdGhlIHJlbmRlcmVyLlxuICovXG5leHBvcnQgdHlwZSBTYW5pdGl6ZXJGbiA9ICh2YWx1ZTogYW55KSA9PiBzdHJpbmc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemF0aW9uLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLyIsInNvdXJjZXMiOlsicGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy9pbnRlcmZhY2VzL3Nhbml0aXphdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIEZ1bmN0aW9uIHVzZWQgdG8gc2FuaXRpemUgdGhlIHZhbHVlIGJlZm9yZSB3cml0aW5nIGl0IGludG8gdGhlIHJlbmRlcmVyLlxuICovXG5leHBvcnQgdHlwZSBTYW5pdGl6ZXJGbiA9ICh2YWx1ZTogYW55KSA9PiBzdHJpbmc7XG4iXX0=

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * The styling context acts as a styling manifest (shaped as an array) for determining which
@@ -109,6 +109,24 @@
  * @record
  */
 export function StylingContext() { }
+if (false) {
+    /* Skipping unnamed member:
+    [StylingIndex.PlayerContext]: PlayerContext|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.StyleSanitizerPosition]: StyleSanitizeFn|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.InitialStylesPosition]: InitialStyles;*/
+    /* Skipping unnamed member:
+    [StylingIndex.MasterFlagPosition]: number;*/
+    /* Skipping unnamed member:
+    [StylingIndex.ClassOffsetPosition]: number;*/
+    /* Skipping unnamed member:
+    [StylingIndex.ElementPosition]: RElement|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.PreviousOrCachedMultiClassValue]: {[key: string]: any}|string|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.PreviousMultiStyleValue]: {[key: string]: any}|null;*/
+}
 /**
  * The initial styles is populated whether or not there are any initial styles passed into
  * the context during allocation. The 0th value must be null so that index values of `0` within
@@ -119,8 +137,12 @@ export function StylingContext() { }
  * @record
  */
 export function InitialStyles() { }
+if (false) {
+    /* Skipping unnamed member:
+    [0]: null;*/
+}
 /** @enum {number} */
-var StylingFlags = {
+const StylingFlags = {
     // Implies no configurations
     None: 0,
     // Whether or not the entry or context itself is dirty
@@ -141,7 +163,7 @@ var StylingFlags = {
 };
 export { StylingFlags };
 /** @enum {number} */
-var StylingIndex = {
+const StylingIndex = {
     // Position of where the initial styles are stored in the styling context
     PlayerContext: 0,
     // Position of where the style sanitizer is stored within the styling context
@@ -171,10 +193,8 @@ var StylingIndex = {
     Size: 4,
     // Each flag has a binary digit length of this value
     BitCountSize: 14,
-    // (32 - 4) / 2 = ~14
     // The binary digit value as a mask
     BitMask: 16383,
 };
 export { StylingIndex };
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuLE,OAAc;;IAEd,QAAe;;IAEf,QAAe;;IAEf,WAAkB;;IAElB,sBAA6B;;;IAG7B,4BAAkC;;IAElC,eAAgB;;IAEhB,WAAiB;;;;;;IAMjB,gBAAiB;;IAEjB,yBAA0B;;IAE1B,wBAAyB;;IAEzB,qBAAsB;;IAEtB,sBAAuB;;;IAGvB,kBAAmB;;;IAGnB,kCAAmC;;IAEnC,0BAA2B;;IAE3B,4BAA6B;;IAE7B,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;;IAE5B,OAAQ;;IAER,gBAAiB;;;IAEjB,cAA0B","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 {RElement} from '../interfaces/renderer';\nimport {PlayerContext} from './player';\n\n\n/**\n * The styling context acts as a styling manifest (shaped as an array) for determining which\n * styling properties have been assigned via the provided `updateStylingMap`, `updateStyleProp`\n * and `updateClassProp` functions. There are also two initialization functions\n * `allocStylingContext` and `createStylingContextTemplate` which are used to initialize\n * and/or clone the context.\n *\n * The context is an array where the first two cells are used for static data (initial styling)\n * and dirty flags / index offsets). The remaining set of cells is used for multi (map) and single\n * (prop) style values.\n *\n * each value from here onwards is mapped as so:\n * [i] = mutation/type flag for the style/class value\n * [i + 1] = prop string (or null incase it has been removed)\n * [i + 2] = value string (or null incase it has been removed)\n *\n * There are three types of styling types stored in this context:\n *   initial: any styles that are passed in once the context is created\n *            (these are stored in the first cell of the array and the first\n *             value of this array is always `null` even if no initial styling exists.\n *             the `null` value is there so that any new styles have a parent to point\n *             to. This way we can always assume that there is a parent.)\n *\n *   single: any styles that are updated using `updateStyleProp` or `updateClassProp` (fixed set)\n *\n *   multi: any styles that are updated using `updateStylingMap` (dynamic set)\n *\n * Note that context is only used to collect style information. Only when `renderStyling`\n * is called is when the styling payload will be rendered (or built as a key/value map).\n *\n * When the context is created, depending on what initial styling values are passed in, the\n * context itself will be pre-filled with slots based on the initial style properties. Say\n * for example we have a series of initial styles that look like so:\n *\n *   style=\"width:100px; height:200px;\"\n *   class=\"foo\"\n *\n * Then the initial state of the context (once initialized) will look like so:\n *\n * ```\n * context = [\n *   element,\n *   playerContext | null,\n *   styleSanitizer | null,\n *   [null, '100px', '200px', true],  // property names are not needed since they have already been\n * written to DOM.\n *\n *   configMasterVal,\n *   1, // this instructs how many `style` values there are so that class index values can be\n * offsetted\n *   { classOne: true, classTwo: false } | 'classOne classTwo' | null // last class value provided\n * into updateStylingMap\n *   { styleOne: '100px', styleTwo: 0 } | null // last style value provided into updateStylingMap\n *\n *   // 8\n *   'width',\n *   pointers(1, 15);  // Point to static `width`: `100px` and multi `width`.\n *   null,\n *\n *   // 11\n *   'height',\n *   pointers(2, 18); // Point to static `height`: `200px` and multi `height`.\n *   null,\n *\n *   // 14\n *   'foo',\n *   pointers(1, 21);  // Point to static `foo`: `true` and multi `foo`.\n *   null,\n *\n *   // 17\n *   'width',\n *   pointers(1, 6);  // Point to static `width`: `100px` and single `width`.\n *   null,\n *\n *   // 21\n *   'height',\n *   pointers(2, 9);  // Point to static `height`: `200px` and single `height`.\n *   null,\n *\n *   // 24\n *   'foo',\n *   pointers(3, 12);  // Point to static `foo`: `true` and single `foo`.\n *   null,\n * ]\n *\n * function pointers(staticIndex: number, dynamicIndex: number) {\n *   // combine the two indices into a single word.\n *   return (staticIndex << StylingFlags.BitCountSize) |\n *     (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));\n * }\n * ```\n *\n * The values are duplicated so that space is set aside for both multi ([style] and [class])\n * and single ([style.prop] or [class.named]) values. The respective config values\n * (configValA, configValB, etc...) are a combination of the StylingFlags with two index\n * values: the `initialIndex` (which points to the index location of the style value in\n * the initial styles array in slot 0) and the `dynamicIndex` (which points to the\n * matching single/multi index position in the context array for the same prop).\n *\n * This means that every time `updateStyleProp` or `updateClassProp` are called then they\n * must be called using an index value (not a property string) which references the index\n * value of the initial style prop/class when the context was created. This also means that\n * `updateStyleProp` or `updateClassProp` cannot be called with a new property (only\n * `updateStylingMap` can include new CSS properties that will be added to the context).\n */\nexport interface StylingContext extends Array<InitialStyles|{[key: string]: any}|number|string|\n                                              boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\n  /**\n   * Location of animation context (which contains the active players) for this element styling\n   * context.\n   */\n  [StylingIndex.PlayerContext]: PlayerContext|null;\n\n  /**\n   * The style sanitizer that is used within this context\n   */\n  [StylingIndex.StyleSanitizerPosition]: StyleSanitizeFn|null;\n\n  /**\n   * Location of initial data shared by all instances of this style.\n   */\n  [StylingIndex.InitialStylesPosition]: InitialStyles;\n\n  /**\n   * A numeric value representing the configuration status (whether the context is dirty or not)\n   * mixed together (using bit shifting) with a index value which tells the starting index value\n   * of where the multi style entries begin.\n   */\n  [StylingIndex.MasterFlagPosition]: number;\n\n  /**\n   * A numeric value representing the class index offset value. Whenever a single class is\n   * applied (using `elementClassProp`) it should have an styling index value that doesn't\n   * need to take into account any style values that exist in the context.\n   */\n  [StylingIndex.ClassOffsetPosition]: number;\n\n  /**\n   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: RElement|null;\n\n  /**\n   * The last class value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.PreviousOrCachedMultiClassValue]: {[key: string]: any}|string|null;\n\n  /**\n   * The last style value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.PreviousMultiStyleValue]: {[key: string]: any}|null;\n}\n\n/**\n * The initial styles is populated whether or not there are any initial styles passed into\n * the context during allocation. The 0th value must be null so that index values of `0` within\n * the context flags can always point to a null value safely when nothing is set.\n *\n * All other entries in this array are of `string` value and correspond to the values that\n * were extracted from the `style=\"\"` attribute in the HTML code for the provided template.\n */\nexport interface InitialStyles extends Array<string|null|boolean> { [0]: null; }\n\n/**\n * Used to set the context to be dirty or not both on the master flag (position 1)\n * or for each single/multi property that exists in the context.\n */\nexport const enum StylingFlags {\n  // Implies no configurations\n  None = 0b00000,\n  // Whether or not the entry or context itself is dirty\n  Dirty = 0b00001,\n  // Whether or not this is a class-based assignment\n  Class = 0b00010,\n  // Whether or not a sanitizer was applied to this property\n  Sanitize = 0b00100,\n  // Whether or not any player builders within need to produce new players\n  PlayerBuildersDirty = 0b01000,\n  // If NgClass is present (or some other class handler) then it will handle the map expressions and\n  // initial classes\n  OnlyProcessSingleClasses = 0b10000,\n  // The max amount of bits used to represent these configuration values\n  BitCountSize = 5,\n  // There are only five bits here\n  BitMask = 0b11111\n}\n\n/** Used as numeric pointer values to determine what cells to update in the `StylingContext` */\nexport const enum StylingIndex {\n  // Position of where the initial styles are stored in the styling context\n  PlayerContext = 0,\n  // Position of where the style sanitizer is stored within the styling context\n  StyleSanitizerPosition = 1,\n  // Position of where the initial styles are stored in the styling context\n  InitialStylesPosition = 2,\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 3,\n  // Index of location where the class index offset value is located\n  ClassOffsetPosition = 4,\n  // Position of where the initial styles are stored in the styling context\n  // This index must align with HOST, see interfaces/view.ts\n  ElementPosition = 5,\n  // Position of where the last string-based CSS class value was stored (or a cached version of the\n  // initial styles when a [class] directive is present)\n  PreviousOrCachedMultiClassValue = 6,\n  // Position of where the last string-based CSS class value was stored\n  PreviousMultiStyleValue = 7,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 8,\n  // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue\n  FlagsOffset = 0,\n  PropertyOffset = 1,\n  ValueOffset = 2,\n  PlayerBuilderIndexOffset = 3,\n  // Size of each multi or single entry (flag + prop + value + playerBuilderIndex)\n  Size = 4,\n  // Each flag has a binary digit length of this value\n  BitCountSize = 14,  // (32 - 4) / 2 = ~14\n  // The binary digit value as a mask\n  BitMask = 0b11111111111111,  // 14 bits\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqHA,oCAgDC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUD,mCAAgF;;;;;;;IAO9E,4BAA4B;IAC5B,OAAc;IACd,sDAAsD;IACtD,QAAe;IACf,kDAAkD;IAClD,QAAe;IACf,0DAA0D;IAC1D,WAAkB;IAClB,wEAAwE;IACxE,sBAA6B;IAC7B,kGAAkG;IAClG,kBAAkB;IAClB,4BAAkC;IAClC,sEAAsE;IACtE,eAAgB;IAChB,gCAAgC;IAChC,WAAiB;;;;;IAKjB,yEAAyE;IACzE,gBAAiB;IACjB,6EAA6E;IAC7E,yBAA0B;IAC1B,yEAAyE;IACzE,wBAAyB;IACzB,yFAAyF;IACzF,qBAAsB;IACtB,kEAAkE;IAClE,sBAAuB;IACvB,yEAAyE;IACzE,0DAA0D;IAC1D,kBAAmB;IACnB,iGAAiG;IACjG,sDAAsD;IACtD,kCAAmC;IACnC,qEAAqE;IACrE,0BAA2B;IAC3B,wEAAwE;IACxE,4BAA6B;IAC7B,iGAAiG;IACjG,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;IAC5B,gFAAgF;IAChF,OAAQ;IACR,oDAAoD;IACpD,gBAAiB;IACjB,mCAAmC;IACnC,cAA0B","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 {RElement} from '../interfaces/renderer';\nimport {PlayerContext} from './player';\n\n\n/**\n * The styling context acts as a styling manifest (shaped as an array) for determining which\n * styling properties have been assigned via the provided `updateStylingMap`, `updateStyleProp`\n * and `updateClassProp` functions. There are also two initialization functions\n * `allocStylingContext` and `createStylingContextTemplate` which are used to initialize\n * and/or clone the context.\n *\n * The context is an array where the first two cells are used for static data (initial styling)\n * and dirty flags / index offsets). The remaining set of cells is used for multi (map) and single\n * (prop) style values.\n *\n * each value from here onwards is mapped as so:\n * [i] = mutation/type flag for the style/class value\n * [i + 1] = prop string (or null incase it has been removed)\n * [i + 2] = value string (or null incase it has been removed)\n *\n * There are three types of styling types stored in this context:\n *   initial: any styles that are passed in once the context is created\n *            (these are stored in the first cell of the array and the first\n *             value of this array is always `null` even if no initial styling exists.\n *             the `null` value is there so that any new styles have a parent to point\n *             to. This way we can always assume that there is a parent.)\n *\n *   single: any styles that are updated using `updateStyleProp` or `updateClassProp` (fixed set)\n *\n *   multi: any styles that are updated using `updateStylingMap` (dynamic set)\n *\n * Note that context is only used to collect style information. Only when `renderStyling`\n * is called is when the styling payload will be rendered (or built as a key/value map).\n *\n * When the context is created, depending on what initial styling values are passed in, the\n * context itself will be pre-filled with slots based on the initial style properties. Say\n * for example we have a series of initial styles that look like so:\n *\n *   style=\"width:100px; height:200px;\"\n *   class=\"foo\"\n *\n * Then the initial state of the context (once initialized) will look like so:\n *\n * ```\n * context = [\n *   element,\n *   playerContext | null,\n *   styleSanitizer | null,\n *   [null, '100px', '200px', true],  // property names are not needed since they have already been\n * written to DOM.\n *\n *   configMasterVal,\n *   1, // this instructs how many `style` values there are so that class index values can be\n * offsetted\n *   { classOne: true, classTwo: false } | 'classOne classTwo' | null // last class value provided\n * into updateStylingMap\n *   { styleOne: '100px', styleTwo: 0 } | null // last style value provided into updateStylingMap\n *\n *   // 8\n *   'width',\n *   pointers(1, 15);  // Point to static `width`: `100px` and multi `width`.\n *   null,\n *\n *   // 11\n *   'height',\n *   pointers(2, 18); // Point to static `height`: `200px` and multi `height`.\n *   null,\n *\n *   // 14\n *   'foo',\n *   pointers(1, 21);  // Point to static `foo`: `true` and multi `foo`.\n *   null,\n *\n *   // 17\n *   'width',\n *   pointers(1, 6);  // Point to static `width`: `100px` and single `width`.\n *   null,\n *\n *   // 21\n *   'height',\n *   pointers(2, 9);  // Point to static `height`: `200px` and single `height`.\n *   null,\n *\n *   // 24\n *   'foo',\n *   pointers(3, 12);  // Point to static `foo`: `true` and single `foo`.\n *   null,\n * ]\n *\n * function pointers(staticIndex: number, dynamicIndex: number) {\n *   // combine the two indices into a single word.\n *   return (staticIndex << StylingFlags.BitCountSize) |\n *     (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));\n * }\n * ```\n *\n * The values are duplicated so that space is set aside for both multi ([style] and [class])\n * and single ([style.prop] or [class.named]) values. The respective config values\n * (configValA, configValB, etc...) are a combination of the StylingFlags with two index\n * values: the `initialIndex` (which points to the index location of the style value in\n * the initial styles array in slot 0) and the `dynamicIndex` (which points to the\n * matching single/multi index position in the context array for the same prop).\n *\n * This means that every time `updateStyleProp` or `updateClassProp` are called then they\n * must be called using an index value (not a property string) which references the index\n * value of the initial style prop/class when the context was created. This also means that\n * `updateStyleProp` or `updateClassProp` cannot be called with a new property (only\n * `updateStylingMap` can include new CSS properties that will be added to the context).\n */\nexport interface StylingContext extends Array<InitialStyles|{[key: string]: any}|number|string|\n                                              boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\n  /**\n   * Location of animation context (which contains the active players) for this element styling\n   * context.\n   */\n  [StylingIndex.PlayerContext]: PlayerContext|null;\n\n  /**\n   * The style sanitizer that is used within this context\n   */\n  [StylingIndex.StyleSanitizerPosition]: StyleSanitizeFn|null;\n\n  /**\n   * Location of initial data shared by all instances of this style.\n   */\n  [StylingIndex.InitialStylesPosition]: InitialStyles;\n\n  /**\n   * A numeric value representing the configuration status (whether the context is dirty or not)\n   * mixed together (using bit shifting) with a index value which tells the starting index value\n   * of where the multi style entries begin.\n   */\n  [StylingIndex.MasterFlagPosition]: number;\n\n  /**\n   * A numeric value representing the class index offset value. Whenever a single class is\n   * applied (using `elementClassProp`) it should have an styling index value that doesn't\n   * need to take into account any style values that exist in the context.\n   */\n  [StylingIndex.ClassOffsetPosition]: number;\n\n  /**\n   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: RElement|null;\n\n  /**\n   * The last class value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.PreviousOrCachedMultiClassValue]: {[key: string]: any}|string|null;\n\n  /**\n   * The last style value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.PreviousMultiStyleValue]: {[key: string]: any}|null;\n}\n\n/**\n * The initial styles is populated whether or not there are any initial styles passed into\n * the context during allocation. The 0th value must be null so that index values of `0` within\n * the context flags can always point to a null value safely when nothing is set.\n *\n * All other entries in this array are of `string` value and correspond to the values that\n * were extracted from the `style=\"\"` attribute in the HTML code for the provided template.\n */\nexport interface InitialStyles extends Array<string|null|boolean> { [0]: null; }\n\n/**\n * Used to set the context to be dirty or not both on the master flag (position 1)\n * or for each single/multi property that exists in the context.\n */\nexport const enum StylingFlags {\n  // Implies no configurations\n  None = 0b00000,\n  // Whether or not the entry or context itself is dirty\n  Dirty = 0b00001,\n  // Whether or not this is a class-based assignment\n  Class = 0b00010,\n  // Whether or not a sanitizer was applied to this property\n  Sanitize = 0b00100,\n  // Whether or not any player builders within need to produce new players\n  PlayerBuildersDirty = 0b01000,\n  // If NgClass is present (or some other class handler) then it will handle the map expressions and\n  // initial classes\n  OnlyProcessSingleClasses = 0b10000,\n  // The max amount of bits used to represent these configuration values\n  BitCountSize = 5,\n  // There are only five bits here\n  BitMask = 0b11111\n}\n\n/** Used as numeric pointer values to determine what cells to update in the `StylingContext` */\nexport const enum StylingIndex {\n  // Position of where the initial styles are stored in the styling context\n  PlayerContext = 0,\n  // Position of where the style sanitizer is stored within the styling context\n  StyleSanitizerPosition = 1,\n  // Position of where the initial styles are stored in the styling context\n  InitialStylesPosition = 2,\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 3,\n  // Index of location where the class index offset value is located\n  ClassOffsetPosition = 4,\n  // Position of where the initial styles are stored in the styling context\n  // This index must align with HOST, see interfaces/view.ts\n  ElementPosition = 5,\n  // Position of where the last string-based CSS class value was stored (or a cached version of the\n  // initial styles when a [class] directive is present)\n  PreviousOrCachedMultiClassValue = 6,\n  // Position of where the last string-based CSS class value was stored\n  PreviousMultiStyleValue = 7,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 8,\n  // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue\n  FlagsOffset = 0,\n  PropertyOffset = 1,\n  ValueOffset = 2,\n  PlayerBuilderIndexOffset = 3,\n  // Size of each multi or single entry (flag + prop + value + playerBuilderIndex)\n  Size = 4,\n  // Each flag has a binary digit length of this value\n  BitCountSize = 14,  // (32 - 4) / 2 = ~14\n  // The binary digit value as a mask\n  BitMask = 0b11111111111111,  // 14 bits\n}\n"]}