@angular/core 7.2.0-beta.0 → 7.2.0

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,unusedPrivateMembers,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,139 @@ 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() { }
+if (false) {
+    /** @type {?} */
+    RComment.prototype.textContent;
+}
+// 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,oEAAoD;;;;;;;IAGpD,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,8BAAqE;;;IAA3B,+BAAyB;;;;;AAInE,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|RComment, 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 { textContent: string|null; }\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,unusedPrivateMembers,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=