Closure warnings

externs/polymer-closure-types.html

@@ -0,0 +1,157 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<!--<script src="closure-types.js"></script>-->
+<script>
+  /* eslint-disable no-unused-vars, strict */
+  /**
+   * @constructor
+   * @extends {DocumentFragment}
+   */
+  function StampedTemplate(){}
+  /** @type {boolean} */
+  StampedTemplate.prototype.__noInsertionPoint;
+  /** @type {!Array<!Node>} */
+  StampedTemplate.prototype.nodeList;
+  /** @type {!Object<string, !Node>} */
+  StampedTemplate.prototype.$;
+  /** @type {!TemplateInfo | undefined} */
+  StampedTemplate.prototype.templateInfo;
+
+  /** @record */
+  function NodeInfo(){}
+  /** @type {string} */
+  NodeInfo.prototype.id;
+  /** @type {!Array<{name: string, value: string}>}*/
+  NodeInfo.prototype.events;
+  /** @type {boolean} */
+  NodeInfo.prototype.hasInsertionPoint;
+  /** @type {!TemplateInfo} */
+  NodeInfo.prototype.templateInfo;
+  /** @type {!NodeInfo} */
+  NodeInfo.prototype.parentInfo;
+  /** @type {number} */
+  NodeInfo.prototype.parentIndex;
+  /** @type {number} */
+  NodeInfo.prototype.infoIndex;
+  /** @type {!Array<!Binding>} */
+  NodeInfo.prototype.bindings;
+
+  /** @record */
+  function TemplateInfo(){}
+  /** @type {!Array<!NodeInfo>} */
+  TemplateInfo.prototype.nodeInfoList;
+  /** @type {!Array<!Node>} */
+  TemplateInfo.prototype.nodeList;
+  /** @type {boolean} */
+  TemplateInfo.prototype.stripWhitespace;
+  /** @type {boolean | undefined} */
+  TemplateInfo.prototype.hasInsertionPoint;
+  /** @type {!Object} */
+  TemplateInfo.prototype.hostProps;
+  /** @type {!Object} */
+  TemplateInfo.prototype.propertyEffects;
+  /** @type {TemplateInfo | undefined} */
+  TemplateInfo.prototype.nextTemplateInfo;
+  /** @type {TemplateInfo | undefined} */
+  TemplateInfo.prototype.previousTemplateInfo;
+  /** @type {!Array<!Node>} */
+  TemplateInfo.prototype.childNodes;
+  /** @type {boolean} */
+  TemplateInfo.prototype.wasPreBound;
+
+  /**
+   * type for HTMLTemplateElement with `_templateInfo`
+   *
+   * @constructor
+   * @extends {HTMLTemplateElement}
+   */
+  function HTMLTemplateElementWithInfo(){}
+  /** @type {TemplateInfo} */
+  HTMLTemplateElementWithInfo.prototype._templateInfo;
+
+  /**
+   * @typedef {{
+   * literal: string,
+   * compoundIndex: (number | undefined)
+   * }}
+   */
+  let LiteralBindingPart;
+
+  /**
+   * @typedef {{
+   * literal: boolean,
+   * name: string,
+   * value: (string | number),
+   * rootProperty: (string | undefined),
+   * structured: (boolean | undefined),
+   * wildcard: (boolean | undefined)
+   * }}
+   */
+  let MethodArg;
+
+  /**
+   * @typedef {{
+   * methodName: string,
+   * static: boolean,
+   * args: !Array<!MethodArg>,
+   * dynamicFn: (boolean | undefined),
+   * }}
+   */
+  let MethodSignature;
+
+  /**
+   * @typedef {{
+   * mode: string,
+   * negate: boolean,
+   * source: string,
+   * dependencies: !Array<(!MethodArg|string)>,
+   * customEvent: boolean,
+   * signature: Object,
+   * event: string
+   * }}
+   */
+  let ExpressionBindingPart;
+
+  /**
+   * @typedef {LiteralBindingPart | ExpressionBindingPart}
+   */
+  let BindingPart;
+
+  /**
+   * @typedef {{
+   * kind: string,
+   * target: string,
+   * parts: Array<!BindingPart>,
+   * literal: (string | undefined),
+   * isCompound: boolean,
+   * listenerEvent: (string | undefined),
+   * listenerNegate: (boolean | undefined)
+   * }}
+   */
+  let Binding;
+
+  /**
+   * @typedef {{
+   * path: string
+   * }}
+   */
+  let PathInfo;
+
+  /**
+   * @typedef {{
+   * forwardHostProp: (function(string, *) | undefined),
+   * instanceProps: (Object | undefined),
+   * mutableData: (boolean | undefined),
+   * notifyInstanceProp: (function(*, string, *) | undefined),
+   * parentModel: (boolean | undefined)
+   * }}
+   */
+  let TemplatizeOptions;
+</script>

externs/polymer-externs.js

@@ -3,15 +3,81 @@
  * @externs
  */
 
+/* eslint-disable */
+
+/**
+ * @typedef {Object<string, {
+ *   value: *,
+ *   type: (Function | undefined),
+ *   readOnly: (boolean | undefined),
+ *   computed: (string | undefined),
+ *   reflectToAttribute: (boolean | undefined),
+ *   notify: (boolean | undefined),
+ *   observer: (string | undefined)
+ * }>}
+ */
+let PolymerElementProperties;
+
+/**
+ * @typedef {{
+ *   is: string,
+ *   extends: (string | undefined),
+ *   properties: (!PolymerElementProperties | undefined),
+ *   observers: (!Array<string> | undefined),
+ *   template: (!HTMLTemplateElement | string | undefined),
+ *   hostAttributes: (!Object<string, *> | undefined),
+ *   listeners: (!Object<string, string> | undefined)
+ * }}
+ */
+let PolymerInit;
+
+let PolymerElementConstructor = function (){};
+/** @type {(string | undefined)} */
+PolymerElementConstructor.is;
+/** @type {(string | undefined)} */
+PolymerElementConstructor.extends;
+/** @type {(!PolymerElementProperties | undefined)} */
+PolymerElementConstructor.properties;
+/** @type {(!Array<string> | undefined)} */
+PolymerElementConstructor.observers;
+/** @type {(!HTMLTemplateElement | string | undefined)} */
+PolymerElementConstructor.template;
+
 /**
- * @param {!{is: string}} init
+ * @param {!PolymerInit} init
  * @return {!HTMLElement}
  */
 function Polymer(init){}
 
+/** @type {PolymerElementProperties} */
+Polymer.ElementProperties;
+
+/**
+ * @type {(function(*,string,string,Node):*)|undefined}
+ */
+Polymer.sanitizeDOMValue;
+
 /**
  * @param {string} string
  * @param {Object} obj
  * @return {string}
  */
-function JSCompiler_renameProperty(string, obj) {}
+function JSCompiler_renameProperty(string, obj) {}
+
+/** @type {Object} */
+Polymer.telemetry;
+
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__computeEffects;
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__reflectEffects;
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__notifyEffects;
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__propagateEffects;
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__observeEffects;
+/** @type {Object} */
+Polymer_PropertyEffects.prototype.__readOnly;
+/** @type {Polymer_PropertyEffects} */
+Polymer_PropertyEffects.prototype.__dataHost;

externs/webcomponents-externs.js

@@ -2,12 +2,18 @@
  * @fileoverview Externs for webcomponents polyfills
  * @externs
  */
+/* eslint-disable */
 
 let HTMLImports = {
   /**
    * @param {function()} callback
    */
-  whenReady(callback){}
+  whenReady(callback){},
+  /**
+   * @param {Element} element
+   * @returns {Document} document
+   */
+  importForElement(element){}
 };
 
 window.HTMLImports = HTMLImports;
@@ -33,6 +39,9 @@ let ShadyDOM = {
 
 window.ShadyDOM = ShadyDOM;
 
+/** @type {function(this:ShadowRoot)} */
+ShadowRoot.prototype.forceRender;
+
 let WebComponents = {};
 window.WebComponents = WebComponents;
 
@@ -42,4 +51,9 @@ HTMLElement.prototype._activeElement;
 /**
  * @param {HTMLTemplateElement} template
  */
-HTMLTemplateElement.prototype.decorate = function(template){};
+HTMLTemplateElement.decorate = function(template){};
+
+/**
+ * @param {function(function())} cb callback
+ */
+CustomElementRegistry.prototype.polyfillWrapFlushCallback = function(cb){};