Update bower.json for Polymer elements and add PRESUBMIT.py

third_party/polymer/v1_0/components/polymer-externs/polymer.externs.js

 /**
  * @fileoverview Closure compiler externs for the Polymer library.
  *
  * @externs
  * @license
  * Copyright (c) 2015 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
@@ skipping 54 matching lines @@
  * observers in that the change handler is called asynchronously.
  *
  * @type {!Object<string, string>|undefined}
  */
 PolymerElement.prototype.observers;
 
 /** On create callback. */
 PolymerElement.prototype.created = function() {};
 /** On ready callback. */
 PolymerElement.prototype.ready = function() {};
+/** On registered callback. */
+PolymerElement.prototype.registered = function() {};
 /** On attached to the DOM callback. */
 PolymerElement.prototype.attached = function() {};
 /** On detached from the DOM callback. */
 PolymerElement.prototype.detached = function() {};
 
 /**
  * Callback fired when an attribute on the element has been changed.
  *
  * @param {string} name The name of the attribute that changed.
  */
@@ skipping 72 matching lines @@
  *   *must* be separated by dots.  Note that when dereferencing array
  *   indicies, the index may be used as a dotted part directly
  *   (e.g. `users.12.name` or `['users', 12, 'name']`).
  * @param {Object=} root Root object from which the path is evaluated.
  * @return {*} Value at the path, or `undefined` if any part of the path
  *   is undefined.
  */
 PolymerElement.prototype.get = function(path, root) {};
 
 /**
+ * Adds items onto the end of the array at the path specified.
+ *
+ * The arguments after `path` and return value match that of
+ * `Array.prototype.push`.
+ *
+ * This method notifies other paths to the same array that a
+ * splice occurred to the array.
+ *
+ * @param {string} path Path to array.
+ * @param {...*} var_args Items to push onto array
+ * @return {number} New length of the array.
+ */
+PolymerElement.prototype.push = function(path, var_args) {};
+
+/**
+ * Removes an item from the end of array at the path specified.
+ *
+ * The arguments after `path` and return value match that of
+ * `Array.prototype.pop`.
+ *
+ * This method notifies other paths to the same array that a
+ * splice occurred to the array.
+ *
+ * @param {string} path Path to array.
+ * @return {*} Item that was removed.
+ */
+PolymerElement.prototype.pop = function(path) {};
+
+/**
+ * Starting from the start index specified, removes 0 or more items
+ * from the array and inserts 0 or more new itms in their place.
+ *
+ * The arguments after `path` and return value match that of
+ * `Array.prototype.splice`.
+ *
+ * This method notifies other paths to the same array that a
+ * splice occurred to the array.
+ *
+ * @param {string} path Path to array.
+ * @param {number} start Index from which to start removing/inserting.
+ * @param {number} deleteCount Number of items to remove.
+ * @param {...*} var_args Items to insert into array.
+ * @return {!Array} Array of removed items.
+ */
+PolymerElement.prototype.splice = function(path, start, deleteCount, var_args) {};
+
+/**
+ * Removes an item from the beginning of array at the path specified.
+ *
+ * The arguments after `path` and return value match that of
+ * `Array.prototype.pop`.
+ *
+ * This method notifies other paths to the same array that a
+ * splice occurred to the array.
+ *
+ * @param {string} path Path to array.
+ * @return {*} Item that was removed.
+ */
+PolymerElement.prototype.shift = function(path) {};
+
+/**
+ * Adds items onto the beginning of the array at the path specified.
+ *
+ * The arguments after `path` and return value match that of
+ * `Array.prototype.push`.
+ *
+ * This method notifies other paths to the same array that a
+ * splice occurred to the array.
+ *
+ * @param {string} path Path to array.
+ * @param {...*} var_args Items to insert info array
+ * @return {number} New length of the array.
+ */
+PolymerElement.prototype.unshift = function(path, var_args) {};
+
+/**
  * Fire an event.
  *
  * @param {string} type An event name.
  * @param {Object=} detail
  * @param {{
  *   bubbles: (boolean|undefined),
  *   cancelable: (boolean|undefined),
  *   node: (!HTMLElement|undefined)}=} options
  * @return {Object} event
  */
@@ skipping 31 matching lines @@
 /**
  * Convenience method to add an event listener on a given element, late bound to
  * a named method on this element.
  * @param {!Element} node Element to add event listener to.
  * @param {string} eventName Name of event to listen for.
  * @param {string} methodName Name of handler method on this to call.
  */
 PolymerElement.prototype.listen = function(node, eventName, methodName) {};
 
 /**
+ * Convenience method to remove an event listener from a given element.
+ * @param {!Element} node Element to remove event listener from.
+ * @param {string} eventName Name of event to stop listening for.
+ * @param {string} methodName Name of handler method on this to remove.
+ */
+PolymerElement.prototype.unlisten = function(node, eventName, methodName) {};
+
+/**
  * Override scrolling behavior to all direction, one direction, or none.
  *
  * Valid scroll directions:
  * 'all': scroll in any direction
  * 'x': scroll only in the 'x' direction
  * 'y': scroll only in the 'y' direction
  * 'none': disable scrolling for this node
  *
  * @param {string=} direction Direction to allow scrolling Defaults to all.
  * @param {HTMLElement=} node Element to apply scroll direction setting.
  *     Defaults to this.
  */
 PolymerElement.prototype.setScrollDirection = function(direction, node) {};
 
 /**
  * @param {!Function} method
  * @param {number=} wait
  * @return {number} A handle which can be used to cancel the job.
  */
 PolymerElement.prototype.async = function(method, wait) {};
 
+/**
+ * @param {...*} var_args
+ */
+PolymerElement.prototype.factoryImpl = function(var_args) {};
+
 Polymer.Base;
 
 /**
  * Used by the promise-polyfill on its own.
  *
  * @param {!Function} method
  * @param {number=} wait
  * @return {number} A handle which can be used to cancel the job.
  */
 Polymer.Base.async = function(method, wait) {};
 
 /**
+ * Returns a property descriptor object for the property specified.
+ *
+ * This method allows introspecting the configuration of a Polymer element's
+ * properties as configured in its `properties` object.  Note, this method
+ * normalizes shorthand forms of the `properties` object into longhand form.
+ *
+ * @param {string} property Name of property to introspect.
+ * @return {Object} Property descriptor for specified property.
+*/
+Polymer.Base.getPropertyInfo = function(property) {};
+
+/**
  * @param {number} handle
  */
 PolymerElement.prototype.cancelAsync = function(handle) {};
 
 /**
  * Call debounce to collapse multiple requests for a named task into one
  * invocation, which is made after the wait time has elapsed with no new
  * request. If no wait time is given, the callback is called at microtask timing
  * (guaranteed to be before paint).
  * @param {string} jobName
@@ skipping 145 matching lines @@
 PolymerDomApi.prototype.innerHTML;
 
 /**
  * @param {string} selector
  * @return {?HTMLElement}
  */
 PolymerDomApi.prototype.querySelector = function(selector) {};
 
 /**
  * @param {string} selector
- * @return {!Array<?HTMLElement>}
+ * @return {!Array<!HTMLElement>}
  */
 PolymerDomApi.prototype.querySelectorAll = function(selector) {};
 
 /** @return {!Array<!Node>} */
 PolymerDomApi.prototype.getDistributedNodes = function() {};
 
 /** @return {!Array<!Node>} */
 PolymerDomApi.prototype.getDestinationInsertionPoints = function() {};
 
 /** @return {?Node} */
 PolymerDomApi.prototype.getOwnerRoot = function() {};
 
 /**
  * @param {string} attribute
  * @param {string|number|boolean} value Values are converted to strings with
  *     ToString, so we accept number and boolean since both convert easily to
  *     strings.
  */
 PolymerDomApi.prototype.setAttribute = function(attribute, value) {};
 
 /** @param {string} attribute */
 PolymerDomApi.prototype.removeAttribute = function(attribute) {};
 
 /** @type {?DOMTokenList} */
 PolymerDomApi.prototype.classList;
 
 /**
+ * @param {string} selector
+ * @return {!Array<!HTMLElement>}
+ */
+PolymerDomApi.prototype.queryDistributedElements = function(selector) {};
+
+/**
  * A Polymer Event API.
  *
  * @constructor
  */
 var PolymerEventApi = function() {};
 
 /** @type {?EventTarget} */
 PolymerEventApi.prototype.rootTarget;
 
 /** @type {?EventTarget} */
@@ skipping 24 matching lines @@
 
 /**
  * Convert a string from camel-case to dash format.
  * @param {string} camel
  * @return {string} The string in dash format.
  */
 Polymer.CaseMap.camelToDashCase = function(camel) {};
 
 
 /**
+ * Settings pulled from
+ * https://github.com/Polymer/polymer/blob/master/src/lib/settings.html
+ */
+Polymer.Settings;
+
+/** @type {boolean} */
+Polymer.Settings.wantShadow;
+
+/** @type {boolean} */
+Polymer.Settings.hasShadow;
+
+/** @type {boolean} */
+Polymer.Settings.nativeShadow;
+
+/** @type {boolean} */
+Polymer.Settings.useShadow;
+
+/** @type {boolean} */
+Polymer.Settings.useNativeShadow;
+
+/** @type {boolean} */
+Polymer.Settings.useNativeImports;
+
+/** @type {boolean} */
+Polymer.Settings.useNativeCustomElements;
+
+
+/**
+ * @see https://github.com/Polymer/polymer/blob/master/src/lib/template/templatizer.html
+ * @polymerBehavior
+ */
+Polymer.Templatizer = {
+  /**
+   * @param {?Object} model
+   * @return {?Element}
+   */
+  stamp: function(model) {},
+
+  /**
+   * @param {?Element} template
+   */
+  templatize: function(template) {},
+};
+
+
+/**
  * An Event type fired when moving while finger/button is down.
  * state - a string indicating the tracking state:
  *     + start: fired when tracking is first detected (finger/button down and
  *              moved past a pre-set distance threshold)
  *     + track: fired while tracking
  *     + end: fired when tracking ends
  * x - clientX coordinate for event
  * y - clientY coordinate for event
  * dx - change in pixels horizontally since the first track event
  * dy - change in pixels vertically since the first track event
@@ skipping 21 matching lines @@
  * y - clientY coordinate for event
  * sourceEvent - the original DOM event that caused the down action
  *
  * @typedef {{
  *   x: number,
  *   y: number,
  *   sourceEvent: Event
  * }}
  */
 var PolymerTouchEvent;