Update closure-library to 04a8ceefc6972511e669563d47abeca18b28092c

Author: jleyba

rake-tasks/crazy_fun/mappings/javascript.rb

@@ -572,7 +572,6 @@ def handle(fun, dir, args)
         formatting = !args[:no_format].nil? ? "" : '--formatting=PRETTY_PRINT'
         flags.push(formatting)
 
-        flags.push('--third_party=true') unless !flags.index('--third_party=false').nil?
         flags.push("--js_output_file=#{output}")
 
         cmd = "" <<
@@ -845,7 +844,6 @@ def handle(fun, dir, args)
             (ENV['pretty_print'] == 'true') ?  "--formatting=PRETTY_PRINT" : ""
 
         cmd = "" <<
-            "--third_party=false " <<
             "--js_output_file=#{output} " <<
             "--output_wrapper='#{wrapper}' " <<
             "--compilation_level=#{compilation_level(minify)} " <<

third_party/closure/goog/a11y/aria/aria.js

@@ -75,6 +75,32 @@ goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_ = [
 ];
 
 
+/**
+ * A list of roles which are considered container roles.
+ * Container roles are ARIA roles which use the aria-activedescendant property
+ * to manage their active descendants or children. See
+ * {@link http://www.w3.org/TR/wai-aria/states_and_properties
+ * #aria-activedescendant} for more information.
+ * @private @const
+ */
+goog.a11y.aria.CONTAINER_ROLES_ = [
+  goog.a11y.aria.Role.COMBOBOX,
+  goog.a11y.aria.Role.GRID,
+  goog.a11y.aria.Role.GROUP,
+  goog.a11y.aria.Role.LISTBOX,
+  goog.a11y.aria.Role.MENU,
+  goog.a11y.aria.Role.MENUBAR,
+  goog.a11y.aria.Role.RADIOGROUP,
+  goog.a11y.aria.Role.ROW,
+  goog.a11y.aria.Role.ROWGROUP,
+  goog.a11y.aria.Role.TAB_LIST,
+  goog.a11y.aria.Role.TEXTBOX,
+  goog.a11y.aria.Role.TOOLBAR,
+  goog.a11y.aria.Role.TREE,
+  goog.a11y.aria.Role.TREEGRID
+];
+
+
 /**
  * Sets the role of an element. If the roleName is
  * empty string or null, the role for the element is removed.
@@ -335,8 +361,8 @@ goog.a11y.aria.getStateString = function(element, stateName) {
   var attr = element.getAttribute(
       goog.a11y.aria.getAriaAttributeName_(stateName));
   goog.asserts.assert((attr == null || goog.isString(attr)) &&
-      isNaN(Number(attr)) && attr != 'true' && attr != 'false');
-  return attr == null ? null : attr;
+      (attr == '' || isNaN(Number(attr))) && attr != 'true' && attr != 'false');
+  return (attr == null || attr == '') ? null : attr;
 };
 
 
@@ -356,6 +382,32 @@ goog.a11y.aria.getStringArrayStateInternalUtil = function(element, stateName) {
 };
 
 
+/**
+ * Returns true if element has an ARIA state/property, false otherwise.
+ * @param {!Element} element The element to get the ARIA state for.
+ * @param {!goog.a11y.aria.State|string} stateName the ARIA state name.
+ * @return {boolean}
+ */
+goog.a11y.aria.hasState = function(element, stateName) {
+  return element.hasAttribute(goog.a11y.aria.getAriaAttributeName_(stateName));
+};
+
+
+/**
+ * Returns whether the element has a container ARIA role.
+ * Container roles are ARIA roles that use the aria-activedescendant property
+ * to manage their active descendants or children. See
+ * {@link http://www.w3.org/TR/wai-aria/states_and_properties
+ * #aria-activedescendant} for more information.
+ * @param {!Element} element
+ * @return {boolean}
+ */
+goog.a11y.aria.isContainerRole = function(element) {
+  var role = goog.a11y.aria.getRole(element);
+  return goog.array.contains(goog.a11y.aria.CONTAINER_ROLES_, role);
+};
+
+
 /**
  * Splits the input stringValue on whitespace.
  * @param {string} stringValue The value of the string to split.

third_party/closure/goog/a11y/aria/roles.js

@@ -196,6 +196,9 @@ goog.a11y.aria.Role = {
   // ARIA role for a textbox element.
   TEXTBOX: 'textbox',
 
+  // ARIA role for a textinfo element.
+  TEXTINFO: 'textinfo',
+
   // ARIA role for an element displaying elapsed time or time remaining.
   TIMER: 'timer',
 

third_party/closure/goog/array/array.js

@@ -966,8 +966,8 @@ goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
   var defaultHashFn = function(item) {
     // Prefix each type with a single character representing the type to
     // prevent conflicting keys (e.g. true and 'true').
-    return goog.isObject(current) ? 'o' + goog.getUid(current) :
-        (typeof current).charAt(0) + current;
+    return goog.isObject(item) ? 'o' + goog.getUid(item) :
+        (typeof item).charAt(0) + item;
   };
   var hashFn = opt_hashFn || defaultHashFn;
 
@@ -1181,8 +1181,7 @@ goog.array.stableSort = function(arr, opt_compareFn) {
  *     and return a negative number, zero, or a positive number depending on
  *     whether the first argument is less than, equal to, or greater than the
  *     second.
- * @template T
- * @template K
+ * @template T,K
  */
 goog.array.sortByKey = function(arr, keyFn, opt_compareFn) {
   var keyCompareFn = opt_compareFn || goog.array.defaultCompare;

third_party/closure/goog/asserts/asserts.js

@@ -60,7 +60,7 @@ goog.define('goog.asserts.ENABLE_ASSERTS', goog.DEBUG);
 goog.asserts.AssertionError = function(messagePattern, messageArgs) {
   messageArgs.unshift(messagePattern);
   goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
-  // Remove the messagePattern afterwards to avoid permenantly modifying the
+  // Remove the messagePattern afterwards to avoid permanently modifying the
   // passed in array.
   messageArgs.shift();
 

third_party/closure/goog/async/animationdelay.js

@@ -53,7 +53,6 @@ goog.require('goog.functions');
  * @param {Object=} opt_handler The object scope to invoke the function in.
  * @constructor
  * @struct
- * @suppress {checkStructDictInheritance}
  * @extends {goog.Disposable}
  * @final
  */

third_party/closure/goog/async/conditionaldelay.js

@@ -67,7 +67,6 @@ goog.require('goog.async.Delay');
  * @param {Object=} opt_handler The object scope to invoke the function in.
  * @constructor
  * @struct
- * @suppress {checkStructDictInheritance}
  * @extends {goog.Disposable}
  */
 goog.async.ConditionalDelay = function(listener, opt_handler) {

third_party/closure/goog/async/debouncer.js

@@ -0,0 +1,182 @@
+// Copyright 2015 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Definition of the goog.async.Debouncer class.
+ *
+ * @see ../demos/timers.html
+ */
+
+goog.provide('goog.async.Debouncer');
+
+goog.require('goog.Disposable');
+goog.require('goog.Timer');
+
+
+
+/**
+ * Debouncer will perform a specified action exactly once for any sequence of
+ * signals fired repeatedly so long as they are fired less than a specified
+ * interval apart (in milliseconds). Whether it receives one signal or multiple,
+ * it will always wait until a full interval has elapsed since the last signal
+ * before performing the action.
+ * @param {function(this: T)} listener Function to callback when the action is
+ *     triggered.
+ * @param {number} interval Interval over which to debounce. The listener will
+ *     only be called after the full interval has elapsed since the last signal.
+ * @param {T=} opt_handler Object in whose scope to call the listener.
+ * @constructor
+ * @struct
+ * @extends {goog.Disposable}
+ * @final
+ * @template T
+ */
+goog.async.Debouncer = function(listener, interval, opt_handler) {
+  goog.async.Debouncer.base(this, 'constructor');
+
+  /**
+   * Function to callback
+   * @private {function(this: T)}
+   */
+  this.listener_ = listener;
+
+  /**
+   * Interval for the debounce time
+   * @type {number}
+   * @private
+   */
+  this.interval_ = interval;
+
+  /**
+   * "this" context for the listener
+   * @type {Object|undefined}
+   * @private
+   */
+  this.handler_ = opt_handler;
+
+  /**
+   * Cached callback function invoked after the debounce timeout completes
+   * @type {Function}
+   * @private
+   */
+  this.callback_ = goog.bind(this.onTimer_, this);
+
+  /**
+   * Indicates that the action is pending and needs to be fired.
+   * @type {boolean}
+   * @private
+   */
+  this.shouldFire_ = false;
+
+  /**
+   * Indicates the count of nested pauses currently in effect on the debouncer.
+   * When this count is not zero, fired actions will be postponed until the
+   * debouncer is resumed enough times to drop the pause count to zero.
+   * @type {number}
+   * @private
+   */
+  this.pauseCount_ = 0;
+
+  /**
+   * Timer for scheduling the next callback
+   * @type {?number}
+   * @private
+   */
+  this.timer_ = null;
+};
+goog.inherits(goog.async.Debouncer, goog.Disposable);
+
+
+/**
+ * Notifies the debouncer that the action has happened. It will debounce the
+ * call so that the callback is only called after the last action in a sequence
+ * of actions separated by periods less the interval parameter passed to the
+ * constructor.
+ */
+goog.async.Debouncer.prototype.fire = function() {
+  this.stop();
+  this.timer_ = goog.Timer.callOnce(this.callback_, this.interval_);
+};
+
+
+/**
+ * Cancels any pending action callback. The debouncer can be restarted by
+ * calling {@link #fire}.
+ */
+goog.async.Debouncer.prototype.stop = function() {
+  if (this.timer_) {
+    goog.Timer.clear(this.timer_);
+    this.timer_ = null;
+  }
+  this.shouldFire_ = false;
+};
+
+
+/**
+ * Pauses the debouncer. All pending and future action callbacks will be delayed
+ * until the debouncer is resumed. Pauses can be nested.
+ */
+goog.async.Debouncer.prototype.pause = function() {
+  ++this.pauseCount_;
+};
+
+
+/**
+ * Resumes the debouncer. If doing so drops the pausing count to zero, pending
+ * action callbacks will be executed as soon as possible, but still no sooner
+ * than an interval's delay after the previous call. Future action callbacks
+ * will be executed as normal.
+ */
+goog.async.Debouncer.prototype.resume = function() {
+  if (!this.pauseCount_) {
+    return;
+  }
+
+  --this.pauseCount_;
+  if (!this.pauseCount_ && this.shouldFire_) {
+    this.doAction_();
+  }
+};
+
+
+/** @override */
+goog.async.Debouncer.prototype.disposeInternal = function() {
+  this.stop();
+  goog.async.Debouncer.base(this, 'disposeInternal');
+};
+
+
+/**
+ * Handler for the timer to fire the debouncer.
+ * @private
+ */
+goog.async.Debouncer.prototype.onTimer_ = function() {
+  this.timer_ = null;
+
+  if (!this.pauseCount_) {
+    this.doAction_();
+  } else {
+    this.shouldFire_ = true;
+  }
+};
+
+
+/**
+ * Calls the callback.
+ * @private
+ */
+goog.async.Debouncer.prototype.doAction_ = function() {
+  this.shouldFire_ = false;
+  this.listener_.call(this.handler_);
+};

third_party/closure/goog/async/delay.js

@@ -44,7 +44,6 @@ goog.require('goog.Timer');
  * @template THIS
  * @constructor
  * @struct
- * @suppress {checkStructDictInheritance}
  * @extends {goog.Disposable}
  * @final
  */
@@ -129,6 +128,19 @@ goog.async.Delay.prototype.start = function(opt_interval) {
 };
 
 
+/**
+ * Starts the delay timer if it's not already active.
+ * @param {number=} opt_interval If specified and the timer is not already
+ *     active, overrides the object's default interval with this one (in
+ *     milliseconds).
+ */
+goog.async.Delay.prototype.startIfNotActive = function(opt_interval) {
+  if (!this.isActive()) {
+    this.start(opt_interval);
+  }
+};
+
+
 /**
  * Stops the delay timer if it is active. No action is taken if the timer is not
  * in use.

third_party/closure/goog/async/run.js

@@ -51,7 +51,7 @@ goog.async.run.initializeRunner_ = function() {
   // on a fulfilled promise, which is specified to be async, but as fast as
   // possible.
   if (goog.global.Promise && goog.global.Promise.resolve) {
-    var promise = goog.global.Promise.resolve();
+    var promise = goog.global.Promise.resolve(undefined);
     goog.async.run.schedule_ = function() {
       promise.then(goog.async.run.processWorkQueue);
     };