google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/externs/browser/w3c_speech.js

@@ -0,0 +1,426 @@
+/*
+ * Copyright 2011 The Closure Compiler Authors
+ *
+ * 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 Definitions for W3C's Speech Input 2010 draft API and the
+ * 2012 Web Speech draft API (in progress).
+ * 2010 Speech Input API:
+ * http://www.w3.org/2005/Incubator/htmlspeech/2010/10/google-api-draft.html
+ * 2012 Web Speech API:
+ * http://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html
+ * This file contains only those functions/properties that are actively
+ * used in the Voice Search experiment. Because the draft is under discussion
+ * and constantly evolving, this file does not attempt to stay in sync with it.
+ *
+ * @externs
+ */
+
+// W3C Speech Input API implemented in Chrome M12
+/**
+ * @constructor
+ * @extends {UIEvent}
+ */
+function SpeechInputEvent() {}
+
+/** @type {SpeechInputResultList} */
+SpeechInputEvent.prototype.results;
+
+
+/**
+ * @constructor
+ */
+function SpeechInputResultList() {}
+
+/** @type {number} */
+SpeechInputResultList.prototype.length;
+
+
+/**
+ * @constructor
+ */
+function SpeechInputResult() {}
+
+/** @type {string} */
+SpeechInputResult.prototype.utterance;
+
+/** @type {number} */
+SpeechInputResult.prototype.confidence;
+
+
+// HTMLInputElement
+/** @type {boolean} */
+HTMLInputElement.prototype.webkitspeech;
+
+/** @type {?function (Event)} */
+HTMLInputElement.prototype.onwebkitspeechchange;
+
+
+
+// W3C Web Speech API implemented in Chrome M23
+/**
+ * @constructor
+ * @implements {EventTarget}
+ */
+function SpeechRecognition() {}
+
+/** @override */
+SpeechRecognition.prototype.addEventListener = function(
+    type, listener, opt_options) {};
+
+/** @override */
+SpeechRecognition.prototype.removeEventListener = function(
+    type, listener, opt_options) {};
+
+/** @override */
+SpeechRecognition.prototype.dispatchEvent = function(evt) {};
+
+/** @type {SpeechGrammarList} */
+SpeechRecognition.prototype.grammars;
+
+/** @type {string} */
+SpeechRecognition.prototype.lang;
+
+/** @type {boolean} */
+SpeechRecognition.prototype.continuous;
+
+/** @type {boolean} */
+SpeechRecognition.prototype.interimResults;
+
+/** @type {number} */
+SpeechRecognition.prototype.maxAlternatives;
+
+/** @type {string} */
+SpeechRecognition.prototype.serviceURI;
+
+/** @type {function()} */
+SpeechRecognition.prototype.start;
+
+/** @type {function()} */
+SpeechRecognition.prototype.stop;
+
+/** @type {function()} */
+SpeechRecognition.prototype.abort;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onaudiostart;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onsoundstart;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onspeechstart;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onspeechend;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onsoundend;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onaudioend;
+
+/** @type {?function(!SpeechRecognitionEvent)} */
+SpeechRecognition.prototype.onresult;
+
+/** @type {?function(!SpeechRecognitionEvent)} */
+SpeechRecognition.prototype.onnomatch;
+
+/** @type {?function(!SpeechRecognitionError)} */
+SpeechRecognition.prototype.onerror;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onstart;
+
+/** @type {?function(!Event)} */
+SpeechRecognition.prototype.onend;
+
+
+/**
+ * @constructor
+ * @extends {Event}
+ */
+function SpeechRecognitionError() {}
+
+/** @type {string} */
+SpeechRecognitionError.prototype.error;
+
+/** @type {string} */
+SpeechRecognitionError.prototype.message;
+
+
+/**
+ * @constructor
+ */
+function SpeechRecognitionAlternative() {}
+
+/** @type {string} */
+SpeechRecognitionAlternative.prototype.transcript;
+
+/** @type {number} */
+SpeechRecognitionAlternative.prototype.confidence;
+
+
+/**
+ * @constructor
+ */
+function SpeechRecognitionResult() {}
+
+/**
+ * @type {number}
+ */
+SpeechRecognitionResult.prototype.length;
+
+/**
+ * @type {function(number): SpeechRecognitionAlternative}
+ */
+SpeechRecognitionResult.prototype.item = function(index) {};
+
+/**
+ * @type {boolean}
+ */
+SpeechRecognitionResult.prototype.isFinal;
+
+
+/**
+ * @constructor
+ */
+function SpeechRecognitionResultList() {}
+
+/**
+ * @type {number}
+ */
+SpeechRecognitionResultList.prototype.length;
+
+/**
+ * @type {function(number): SpeechRecognitionResult}
+ */
+SpeechRecognitionResultList.prototype.item = function(index) {};
+
+
+/**
+ * @constructor
+ * @extends {Event}
+ */
+function SpeechRecognitionEvent() {}
+
+/** @type {number} */
+SpeechRecognitionEvent.prototype.resultIndex;
+
+/** @type {SpeechRecognitionResultList} */
+SpeechRecognitionEvent.prototype.results;
+
+/** @type {*} */
+SpeechRecognitionEvent.prototype.interpretation;
+
+/** @type {Document} */
+SpeechRecognitionEvent.prototype.emma;
+
+
+/**
+ * @constructor
+ */
+function SpeechGrammar() {}
+
+/** @type {string} */
+SpeechGrammar.prototype.src;
+
+/** @type {number} */
+SpeechGrammar.prototype.weight;
+
+
+/**
+ * @constructor
+ */
+function SpeechGrammarList() {}
+
+/**
+ * @type {number}
+ */
+SpeechGrammarList.prototype.length;
+
+/**
+ * @type {function(number): SpeechGrammar}
+ */
+SpeechGrammarList.prototype.item = function(index) {};
+
+/**
+ * @type {function(string, number)}
+ */
+SpeechGrammarList.prototype.addFromUri = function(src, weight) {};
+
+/**
+ * @type {function(string, number)}
+ */
+SpeechGrammarList.prototype.addFromURI = function(src, weight) {};
+
+/**
+ * @type {function(string, number)}
+ */
+SpeechGrammarList.prototype.addFromString = function(str, weight) {};
+
+
+// Webkit implementations of Web Speech API
+/**
+ * @constructor
+ * @extends {SpeechGrammarList}
+ */
+function webkitSpeechGrammarList() {}
+
+
+/**
+ * @constructor
+ * @extends {SpeechGrammar}
+ */
+function webkitSpeechGrammar() {}
+
+
+/**
+ * @constructor
+ * @extends {SpeechRecognitionEvent}
+ */
+function webkitSpeechRecognitionEvent() {}
+
+
+/**
+ * @constructor
+ * @extends {SpeechRecognitionError}
+ */
+function webkitSpeechRecognitionError() {}
+
+
+/**
+ * @constructor
+ * @extends {SpeechRecognition}
+ */
+function webkitSpeechRecognition() {}
+
+
+
+// W3C Web Speech Synthesis API is implemented in Chrome M33
+/**
+ * @type {SpeechSynthesis}
+ * @see https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html#tts-section
+ */
+var speechSynthesis;
+
+
+/**
+ * @constructor
+ * @param {string} text
+ */
+function SpeechSynthesisUtterance(text) {}
+
+/** @type {string} */
+SpeechSynthesisUtterance.prototype.text;
+
+/** @type {string} */
+SpeechSynthesisUtterance.prototype.lang;
+
+/** @type {number} */
+SpeechSynthesisUtterance.prototype.pitch;
+
+/** @type {number} */
+SpeechSynthesisUtterance.prototype.rate;
+
+/** @type {SpeechSynthesisVoice} */
+SpeechSynthesisUtterance.prototype.voice;
+
+/** @type {number} */
+SpeechSynthesisUtterance.prototype.volume;
+
+/**
+ * @param {Event} event
+ */
+SpeechSynthesisUtterance.prototype.onstart = function(event) {};
+
+/**
+ * @param {Event} event
+ */
+SpeechSynthesisUtterance.prototype.onend = function(event) {};
+
+/**
+ * @param {Event} event
+ */
+SpeechSynthesisUtterance.prototype.onerror = function(event) {};
+
+/**
+ * @constructor
+ */
+function SpeechSynthesisVoice() {}
+
+/** @type {string} */
+SpeechSynthesisVoice.prototype.voiceURI;
+
+/** @type {string} */
+SpeechSynthesisVoice.prototype.name;
+
+/** @type {string} */
+SpeechSynthesisVoice.prototype.lang;
+
+/** @type {boolean} */
+SpeechSynthesisVoice.prototype.localService;
+
+/** @type {boolean} */
+SpeechSynthesisVoice.prototype.default;
+
+
+/**
+ * @constructor
+ * @extends {Array<!SpeechSynthesisVoice>}
+ */
+function SpeechSynthesisVoiceList() {}
+
+
+/**
+ * @interface
+ * @extends {EventTarget}
+ */
+function SpeechSynthesis() {}
+
+/**
+ * @param {SpeechSynthesisUtterance} utterance
+ * @return {undefined}
+ */
+SpeechSynthesis.prototype.speak = function(utterance) {};
+
+/** @type {function()} */
+SpeechSynthesis.prototype.cancel;
+
+/** @type {function()} */
+SpeechSynthesis.prototype.pause;
+
+/** @type {function()} */
+SpeechSynthesis.prototype.resume;
+
+/** @type {boolean} */
+SpeechSynthesis.prototype.paused;
+
+/** @type {boolean} */
+SpeechSynthesis.prototype.pending;
+
+/** @type {boolean} */
+SpeechSynthesis.prototype.speaking;
+
+/**
+ * @return {SpeechSynthesisVoiceList}
+ */
+SpeechSynthesis.prototype.getVoices = function() {};
+
+/**
+ * @param {Event} event
+ * @see https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi-errata.html
+ */
+SpeechSynthesis.prototype.onvoiceschanged = function(event) {};

package/externs/browser/w3c_touch_event.js

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2015 The Closure Compiler Authors
+ *
+ * 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 Definitions for W3C's Touch Events specification.
+ * @see http://www.w3.org/TR/touch-events/
+ * @externs
+ */
+
+/**
+ * @typedef {{
+ *   identifier: number,
+ *   target: !EventTarget,
+ *   clientX: (number|undefined),
+ *   clientY: (number|undefined),
+ *   screenX: (number|undefined),
+ *   screenY: (number|undefined),
+ *   pageX: (number|undefined),
+ *   pageY: (number|undefined),
+ *   radiusX: (number|undefined),
+ *   radiusY: (number|undefined),
+ *   rotationAngle: (number|undefined),
+ *   force: (number|undefined),
+ *   altitudeAngle: (number|undefined),
+ *   azimuthAngle: (number|undefined),
+ *   touchType: (string|undefined)
+ * }}
+ */
+var TouchInitDict;
+
+/**
+ * The Touch class represents a single touch on the surface. A touch is the
+ * presence or movement of a finger that is part of a unique multi-touch
+ * sequence.
+ * @see http://www.w3.org/TR/touch-events/#touch-interface
+ * @param {!TouchInitDict} touchInitDict
+ * @constructor
+ */
+function Touch(touchInitDict) {}
+
+/**
+ * The x-coordinate of the touch's location relative to the window's viewport.
+ * @type {number}
+ */
+Touch.prototype.clientX;
+
+/**
+ * The y-coordinate of the touch's location relative to the window's viewport.
+ * @type {number}
+ */
+Touch.prototype.clientY;
+
+/**
+ * The unique identifier for this touch object.
+ * @type {number}
+ */
+Touch.prototype.identifier;
+
+/**
+ * The x-coordinate of the touch's location in page coordinates.
+ * @type {number}
+ */
+Touch.prototype.pageX;
+
+/**
+ * The y-coordinate of the touch's location in page coordinates.
+ * @type {number}
+ */
+Touch.prototype.pageY;
+
+/**
+ * The x-coordinate of the touch's location in screen coordinates.
+ * @type {number}
+ */
+Touch.prototype.screenX;
+
+/**
+ * The y-coordinate of the touch's location in screen coordinates.
+ * @type {number}
+ */
+Touch.prototype.screenY;
+
+/**
+ * The target of this touch.
+ * @type {EventTarget}
+ */
+Touch.prototype.target;
+
+/**
+ * @type {number}
+ * @see http://www.w3.org/TR/touch-events-extensions/#widl-Touch-force
+ */
+Touch.prototype.force;
+
+/**
+ * @type {number}
+ * @see http://www.w3.org/TR/touch-events-extensions/#widl-Touch-radiusX
+ */
+Touch.prototype.radiusX;
+
+/**
+ * @type {number}
+ * @see http://www.w3.org/TR/touch-events-extensions/#widl-Touch-radiusY
+ */
+Touch.prototype.radiusY;
+
+
+/**
+ * @type {number}
+ * @see http://www.w3.org/TR/2011/WD-touch-events-20110505/#widl-Touch-rotationAngle
+ */
+Touch.prototype.rotationAngle;
+
+
+/**
+ * Creates a new Touch object.
+ * @see http://www.w3.org/TR/touch-events/#widl-Document-createTouch-Touch-WindowProxy-view-EventTarget-target-long-identifier-long-pageX-long-pageY-long-screenX-long-screenY
+ * @param {Window} view
+ * @param {EventTarget} target
+ * @param {number} identifier
+ * @param {number} pageX
+ * @param {number} pageY
+ * @param {number} screenX
+ * @param {number} screenY
+ * @return {Touch}
+ */
+Document.prototype.createTouch = function(view, target, identifier, pageX,
+    pageY, screenX, screenY) {};
+
+
+/**
+ * The TouchList class is used to represent a collection of Touch objects.
+ * @see http://www.w3.org/TR/touch-events/#touchlist-interface
+ * @constructor
+ * @implements {IArrayLike<!Touch>}
+ */
+function TouchList() {}
+
+/**
+ * The number of Touch objects in this TouchList object.
+ * @type {number}
+ */
+TouchList.prototype.length;
+
+/**
+ * Returns the Touch object at the given index.
+ * @param {number} index
+ * @return {?Touch}
+ */
+TouchList.prototype.item = function(index) {};
+
+/**
+ * @param {number} identifier
+ * @return {?Touch}
+ * @see http://www.w3.org/TR/touch-events-extensions/#widl-TouchList-identifiedTouch-Touch-long-identifier
+ */
+TouchList.prototype.identifiedTouch = function(identifier) {};
+
+/**
+ * Creates a new TouchList object.
+ * @see http://www.w3.org/TR/touch-events/#widl-Document-createTouchList-TouchList-Touch-touches
+ * @param {Array<?Touch>} touches
+ * @return {TouchList}
+ */
+Document.prototype.createTouchList = function(touches) {};
+
+/**
+ * @record
+ * @extends {UIEventInit}
+ */
+function TouchEventInit() {}
+
+/** @type {undefined|?EventTarget} */
+TouchEventInit.prototype.relatedTarget;
+
+/** @type {undefined|!Array<?Touch>} */
+TouchEventInit.prototype.touches;
+
+/** @type {undefined|!Array<?Touch>} */
+TouchEventInit.prototype.targetTouches;
+
+/** @type {undefined|!Array<?Touch>} */
+TouchEventInit.prototype.changedTouches;
+
+/**
+ * The TouchEvent class encapsulates information about a touch event.
+ *
+ * <p>The system continually sends TouchEvent objects to an application as
+ * fingers touch and move across a surface. A touch event provides a snapshot of
+ * all touches during a multi-touch sequence, most importantly the touches that
+ * are new or have changed for a particular target. A multi-touch sequence
+ * begins when a finger first touches the surface. Other fingers may
+ * subsequently touch the surface, and all fingers may move across the surface.
+ * The sequence ends when the last of these fingers is lifted from the surface.
+ * An application receives touch event objects during each phase of any touch.
+ * </p>
+ *
+ * <p>The different types of TouchEvent objects that can occur are:
+ * <ul>
+ *   <li>touchstart - Sent when a finger for a given event touches the surface.
+ *   <li>touchmove - Sent when a given event moves on the surface.
+ *   <li>touchend - Sent when a given event lifts from the surface.
+ *   <li>touchcancel - Sent when the system cancels tracking for the touch.
+ * </ul>
+ * TouchEvent objects are combined together to form high-level GestureEvent
+ * objects that are also sent during a multi-touch sequence.</p>
+ *
+ * @see http://www.w3.org/TR/touch-events/#touchevent-interface
+ * @param {string} type
+ * @param {!TouchEventInit=} opt_eventInitDict
+ * @extends {UIEvent}
+ * @constructor
+ */
+function TouchEvent(type, opt_eventInitDict) {}
+
+/**
+ * A collection of Touch objects representing all touches associated with this
+ * target.
+ * @type {TouchList}
+ */
+TouchEvent.prototype.touches;
+
+/**
+ * A collection of Touch objects representing all touches associated with this
+ * target.
+ * @type {TouchList}
+ */
+TouchEvent.prototype.targetTouches;
+
+/**
+ * A collection of Touch objects representing all touches that changed in this event.
+ * @type {TouchList}
+ */
+TouchEvent.prototype.changedTouches;
+
+/**
+ * @type {boolean}
+ */
+TouchEvent.prototype.altKey;
+
+/**
+ * @type {boolean}
+ */
+TouchEvent.prototype.metaKey;
+
+/**
+ * @type {boolean}
+ */
+TouchEvent.prototype.ctrlKey;
+
+/**
+ * @type {boolean}
+ */
+TouchEvent.prototype.shiftKey;
+
+
+/**
+ * Specifies the JavaScript method to invoke when the system cancels tracking
+ * for the touch.
+ * @type {?function(!TouchEvent)}
+ */
+Element.prototype.ontouchcancel;
+
+/**
+ * Specifies the JavaScript method to invoke when a given event lifts from the
+ * surface.
+ * @type {?function(!TouchEvent)}
+ */
+Element.prototype.ontouchend;
+
+/**
+ * Specifies the JavaScript method to invoke when a finger for a given event
+ * moves on the surface.
+ * @type {?function(!TouchEvent)}
+ */
+Element.prototype.ontouchmove;
+
+/**
+ * Specifies the JavaScript method to invoke when a finger for a given event
+ * touches the surface.
+ * @type {?function(!TouchEvent)}
+ */
+Element.prototype.ontouchstart;