Roll closure compiler

third_party/closure_compiler/externs/polymer-1.0.js

 //    SSSSSSSSSSSSSSS TTTTTTTTTTTTTTTTTTTTTTT     OOOOOOOOO     PPPPPPPPPPPPPPPPP
 //  SS:::::::::::::::ST:::::::::::::::::::::T   OO:::::::::OO   P::::::::::::::::P
 // S:::::SSSSSS::::::ST:::::::::::::::::::::T OO:::::::::::::OO P::::::PPPPPP:::::P
 // S:::::S     SSSSSSST:::::TT:::::::TT:::::TO:::::::OOO:::::::OPP:::::P     P:::::P
 // S:::::S            TTTTTT  T:::::T  TTTTTTO::::::O   O::::::O  P::::P     P:::::P
 // S:::::S                    T:::::T        O:::::O     O:::::O  P::::P     P:::::P
 //  S::::SSSS                                                     P::::PPPPPP:::::P
 //   SS::::::SSSSS       This file is generated. To update it,    P:::::::::::::PP
 //     SSS::::::::SS          run roll_closure_compiler.          P::::PPPPPPPPP
 //        SSSSSS::::S                                             P::::P
@@ skipping 166 matching lines @@
 
 /**
  * Return the element whose local dom within which this element is contained.
  * @type {?Element}
  */
 PolymerElement.prototype.domHost;
 
 /**
  * Notifies the event binding system of a change to a property.
  * @param  {string} path  The path to set.
- * @param  {*}      value The value to send in the update notification.
+ * @param  {*=} value The value to send in the update notification.
  * @param {boolean=} fromAbove When true, specifies that the change came from
  *     above this element and thus upward notification is not necessary.
  * @return {boolean} True if notification actually took place, based on a dirty
  *     check of whether the new value was already known.
  */
 PolymerElement.prototype.notifyPath = function(path, value, fromAbove) {};
 
 /**
  * @param {string} path Path that should be notified.
  * @param {!Array<!PolymerSplice>} splices Array of splice records indicating
@@ skipping 345 matching lines @@
  * Gets the original target of the given event.
  *
  * Cheaper than Polymer.dom(ev).path[0];
  * See https://github.com/Polymer/polymer/blob/master/src/standard/gestures.html#L191
  *
  * @param {Event} ev .
  * @return {Element} The original target of the event.
  */
 Polymer.Gestures.findOriginalTarget = function(ev) {};
 
+/**
+ * @type {!Object}
+ */
+Polymer.Gestures.gestures = {};
+
+/**
+ * @type {!Object}
+ */
+Polymer.Gestures.gestures.tap = {};
+
+/**
+ * Reset the tap gesture's state manually
+ * @type {function()}
+ */
+Polymer.Gestures.gestures.tap.reset = function() {};
 
 /**
  * @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
@@ skipping 92 matching lines @@
  *     shortcut for setting `customStyle` and then calling `updateStyles`.
  */
 PolymerElement.prototype.updateStyles = function(properties) {};
 
 /**
  * @type {!Object<string, string|undefined>}
  */
 PolymerElement.prototype.customStyle;
 
 /**
+ * Convenience method for creating an element and configuring it.
+ * @param {string} tagName HTML tag name
+ * @param {IObject<string, *>=} properties Object of properties to configure on the instance
+ * @return {!Element}
+ */
+PolymerElement.prototype.create = function(tagName, properties) {};
+
+/**
  * Returns the computed style value for the given property.
  * @param {string} property
  * @return {string} the computed value
  */
 PolymerElement.prototype.getComputedStyleValue = function(property) {};
 
 /**
  * Logs a message to the console.
  *
  * @param {...*} var_args
@@ skipping 46 matching lines @@
 PolymerElement.prototype._pathEffector = function(path, value) {};
 
 /**
  * Do not call this function.
  *
  * @param {string} path .
  * @param {*} value .
  */
 PolymerElement.prototype._propertySetter = function(path, value) {};
 
+/**
+ * Do not call this function.
+ *
+ * @param {string} path .
+ */
+PolymerElement.prototype._notifyChange = function(path) {};
 
 /**
  * A Polymer DOM API for manipulating DOM such that local DOM and light DOM
  * trees are properly maintained.
  *
  * @constructor
  */
 var PolymerDomApi = function() {};
 
 /**
@@ skipping 347 matching lines @@
 
 
 /**
  * @see https://github.com/Polymer/polymer/blob/master/src/lib/template/templatizer.html
  * @polymerBehavior
  */
 Polymer.Templatizer = {
   ctor: function() {},
 
   /**
-   * @param {?Object} model
+   * @param {?Object=} model
    * @return {?Element}
    */
   stamp: function(model) {},
 
   /**
    * @param {?Element} template
    */
   templatize: function(template) {},
 
   /**
@@ skipping 365 matching lines @@
   isContentBelow: function(){},
   /** Updates the elements scroll state */
   _updateScrollState: function(){},
   /** @return {boolean} true if the element is on screen */
   isOnScreen: function(){},
   /** @type {number} Internal bookkeeping to track screen position */
   _deltaHeight: 0,
   /** @return {?Element} Element in local dom by id. */
   _getDOMRef: function(title){}
 }
+
+/** @const */
+Polymer.ArraySplice = {};
+
+/**
+ * Returns an array of splice records indicating the minimum edits required
+ * to transform the `previous` array into the `current` array.
+ *
+ * Splice records are ordered by index and contain the following fields:
+ * - `index`: index where edit started
+ * - `removed`: array of removed items from this index
+ * - `addedCount`: number of items added at this index
+ *
+ * This function is based on the Levenshtein "minimum edit distance"
+ * algorithm. Note that updates are treated as removal followed by addition.
+ *
+ * The worst-case time complexity of this algorithm is `O(l * p)`
+ *   l: The length of the current array
+ *   p: The length of the previous array
+ *
+ * However, the worst-case complexity is reduced by an `O(n)` optimization
+ * to detect any shared prefix & suffix between the two arrays and only
+ * perform the more expensive minimum edit distance calculation over the
+ * non-shared portions of the arrays.
+ *
+ * @param {!Array} current The "changed" array for which splices will be
+ * calculated.
+ * @param {!Array} previous The "unchanged" original array to compare
+ * `current` against to determine the splices.
+ * @return {!Array} Returns an array of splice record objects. Each of these
+ * contains: `index` the location where the splice occurred; `removed`
+ * the array of removed items from this location; `addedCount` the number
+ * of items added at this location.
+ */
+Polymer.ArraySplice.calculateSplices = function(current, previous) {};
+
+/**
+ * @constructor @extends {PolymerElement}
+ */
+Polymer.DomModule = function() {};
+
+/**
+ * Retrieves the dom specified by `selector` in the module specified by
+ * `id`. For example, this.import('foo', 'img');
+ * @param {string} id
+ * @param {string=} opt_selector
+ * @return {?HTMLElement} Returns the dom which matches `selector` in the module
+ * at the specified `id`.
+ */
+Polymer.DomModule.import = function(id, opt_selector) {};
+
+/**
+ * For compatibility with both Polymer 1.0 and 2.0, code may check for certain
+ * objects and properties which don't exist in Polymer 1.0.
+ *
+ * We give those objects and properties the `undefined` type here, because
+ * the dependency tree will either contain these externs and Polymer 1.0 or
+ * it will contain Polymer 2.0 which defines the full types.
+ */
+
+/** @type {undefined} */
+var ShadyDOM;