shaka-player 3.2.2 → 3.3.0

package/dist/shaka-player.compiled.externs.js

@@ -33,6 +33,8 @@ shaka.offline = {};
 shaka.text = {};
 /** @const */
 shaka.util = {};
+/** @const */
+shaka.util.CmcdManager = {};
 
 /**
  * @implements {shaka.extern.Cue}
@@ -124,6 +126,14 @@ shaka.text.Cue.prototype.backgroundImage;
      * @override
      */
 shaka.text.Cue.prototype.border;
+/**
+     * @override
+     */
+shaka.text.Cue.prototype.textStrokeColor;
+/**
+     * @override
+     */
+shaka.text.Cue.prototype.textStrokeWidth;
 /**
      * @override
      */
@@ -631,6 +641,7 @@ shaka.util.Error.Code = {
   'MISSING_STORAGE_CELL': 9013,
   'STORAGE_LIMIT_REACHED': 9014,
   'DOWNLOAD_SIZE_CALLBACK_ERROR': 9015,
+  'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
   'CS_IMA_SDK_MISSING': 10000,
   'CS_AD_MANAGER_NOT_INITIALIZED': 10001,
   'SS_IMA_SDK_MISSING': 10002,
@@ -764,6 +775,149 @@ shaka.text.TextEngine = class {
    */
   destroy() {}
 };
+/**
+ * @summary A set of language utility functions.
+ * @final
+ */
+shaka.util.LanguageUtils = class {
+  /**
+   * Check if |locale1| and |locale2| are locale-compatible.
+   * Locale-compatible is defined as all components in each locale match. Since
+   * we only respect the language and region components, we only check that
+   * the language and region components match.
+   * Examples:
+   *  Locale A | Locale B | Locale Compatible
+   *  ---------------------------------------
+   *  en-US    | en-US    | true
+   *  en       | en-US    | false
+   *  en-US    | en-CA    | false
+   * @param {string} locale1
+   * @param {string} locale2
+   * @return {boolean}
+   */
+  static areLocaleCompatible(locale1, locale2) {}
+  /**
+   * Check if |locale1| and |locale2| are language-compatible.
+   * Language compatible is when the language component of each locale matches.
+   * This means that no matter what region they have (or don't have) as long as
+   * the language components match, they are language-compatible.
+   * Examples:
+   *  Locale A | Locale B | Language-Compatible
+   *  -----------------------------------------
+   *  en-US    | en-US    | true
+   *  en-US    | en       | true
+   *  en-US    | en-CA    | true
+   *  en-CA    | fr-CA    | false
+   * @param {string} locale1
+   * @param {string} locale2
+   * @return {boolean}
+   */
+  static areLanguageCompatible(locale1, locale2) {}
+  /**
+   * Check if |possibleParent| is the parent locale of |possibleChild|. Because
+   * we do not support dialects, the parent-child relationship is a lot simpler.
+   * In a parent child relationship:
+   *    - The parent and child have the same language-component
+   *    - The parent has no region-component
+   *    - The child has a region-component
+   * Example:
+   *  Locale A | Locale B | Is A The parent of B?
+   *  --------------------------------------------
+   *  en-US    | en-US    | no
+   *  en-US    | en       | no
+   *  en       | en-US    | yes
+   *  en       | en       | no
+   *  en       | fr       | no
+   * @param {string} possibleParent
+   * @param {string} possibleChild
+   * @return {boolean}
+   */
+  static isParentOf(possibleParent, possibleChild) {}
+  /**
+   * Check if |localeA| shares the same parent with |localeB|. Since we don't
+   * support dialect, we will only look at language and region. For two locales
+   * to be siblings:
+   *    - Both must have language-components
+   *    - Both must have region-components
+   *    - Both must have the same language-component
+   * Example:
+   *  Locale A | Locale B | Siblings?
+   *  --------------------------------------------
+   *  en-US    | en-US    | yes
+   *  en-US    | en-CA    | yes
+   *  en-US    | en       | no
+   *  en       | en-US    | no
+   *  en       | en       | no
+   *  en       | fr       | no
+   * @param {string} localeA
+   * @param {string} localeB
+   * @return {boolean}
+   */
+  static isSiblingOf(localeA, localeB) {}
+  /**
+   * Normalize a locale. This will take a locale and canonicalize it to a state
+   * that we are prepared to work with.
+   * We only support with:
+   *   - language
+   *   - language-REGION
+   * If given a dialect, we will discard it. We will convert any 3-character
+   * codes to 2-character codes. We will force language codes to lowercase and
+   * region codes to uppercase.
+   * @param {string} locale
+   * @return {string}
+   */
+  static normalize(locale) {}
+  /**
+   * Check if two language codes are siblings. Language codes are siblings if
+   * they share the same base language while neither one is the base language.
+   * For example, "en-US" and "en-CA" are siblings but "en-US" and "en" are not
+   * siblings.
+   * @param {string} a
+   * @param {string} b
+   * @return {boolean}
+   */
+  static areSiblings(a, b) {}
+  /**
+   * Compute a numerical relatedness for language codes.  Language codes with a
+   * higher relatedness are a better match.  Unrelated language codes have a
+   * relatedness score of 0.
+   * @param {string} target
+   * @param {string} candidate
+   * @return {number}
+   */
+  static relatedness(target, candidate) {}
+  /**
+   * Get the normalized base language for a language code.
+   * @param {string} lang
+   * @return {string}
+   */
+  static getBase(lang) {}
+  /**
+   * Get the normalized language of the given text stream. Will return 'und' if
+   * a language is not found on the text stream.
+   * This should always be used to get the language from a text stream.
+   * @param {shaka.extern.Stream} stream
+   * @return {string}
+   */
+  static getLocaleForText(stream) {}
+  /**
+   * Get the normalized locale for the given variant. This will look through
+   * the variant to find the locale that represents the content in the variant.
+   * This will return 'und' if no language can be found.
+   * This should always be used to get the locale from a variant.
+   * @param {shaka.extern.Variant} variant
+   * @return {string}
+   */
+  static getLocaleForVariant(variant) {}
+  /**
+   * Find the locale in |searchSpace| that comes closest to |target|. If no
+   * locale is found to be close to |target|, then |null| will be returned.
+   * @param {string} target
+   * @param {!Iterable.<string>} searchSpace
+   * @return {?string}
+   */
+  static findClosestLocale(target, searchSpace) {}
+};
 /**
  * A timer allows a single function to be executed at a later time or at
  * regular intervals.
@@ -1021,8 +1175,12 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    * @param {function(number, number)=} onProgressUpdated Called when a progress
    *   event is triggered. Passed the duration, in milliseconds, that the
    *   request took, and the number of bytes transferred.
+   * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
+   *   Called when the headers are received for a download.
+   * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
+   *   Called when a download fails, for any reason.
    */
-  constructor(onProgressUpdated) {}
+  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed) {}
   /**
    * @param {boolean} forceHTTPS
    */
@@ -1161,6 +1319,27 @@ shaka.net.NetworkingEngine.PluginPriority = {
   'PREFERRED': 2,
   'APPLICATION': 3
 };
+/**
+ * @typedef {function(
+ *    !Object.<string, string>,
+ *    !shaka.extern.Request,
+ *    !shaka.net.NetworkingEngine.RequestType)}
+ * @description
+ * A callback function that passes the shaka.extern.HeadersReceived along to
+ * the player, plus some extra data.
+ */
+shaka.net.NetworkingEngine.OnHeadersReceived;
+/**
+ * @typedef {function(
+ *    !shaka.extern.Request,
+ *    ?shaka.util.Error,
+ *    number,
+ *    boolean)}
+ * @description
+ * A callback function that notifies the player when a download fails, for any
+ * reason (e.g. even if the download was aborted).
+ */
+shaka.net.NetworkingEngine.OnDownloadFailed;
 /**
  * An interface to standardize how objects release internal references
  * synchronously. If an object needs to asynchronously release references, then
@@ -1459,11 +1638,13 @@ shaka.media.InitSegmentReference = class {
    *   of the resource containing the segment.
    * @param {number} startByte The offset from the start of the resource to the
    *   start of the segment.
-   * @param {?number} endByte The offset from the start of the resource to the
-   *   end of the segment, inclusive.  A value of null indicates that the
+   * @param {?number} endByte The offset from the start of the resource
+   *   to the end of the segment, inclusive.  A value of null indicates that the
    *   segment extends to the end of the resource.
+   * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
+   *   the quality of the media associated with this init segment.
    */
-  constructor(uris, startByte, endByte) {}
+  constructor(uris, startByte, endByte, mediaQuality) {}
   /**
    * Returns the offset from the start of the resource to the
    * start of the segment.
@@ -1994,6 +2175,46 @@ shaka.text.UITextDisplayer = class {
  */
 shaka.text.WebVttGenerator = class {
 };
+/**
+ * @typedef {{
+ *   type: string,
+ *   init: boolean,
+ *   duration: number,
+ *   mimeType: string,
+ *   codecs: string,
+ *   bandwidth: (number|undefined)
+ * }}
+ * @property {string} type
+ *   The media type
+ * @property {boolean} init
+ *   Flag indicating whether the segment is an init segment
+ * @property {number} duration
+ *   The duration of the segment in seconds
+ * @property {string} mimeType
+ *   The segment's mime type
+ * @property {string} codecs
+ *   The segment's codecs
+ * @property {(number|undefined)} bandwidth
+ *   The segment's variation bandwidth
+ */
+shaka.util.CmcdManager.SegmentInfo;
+/**
+ * @typedef {{
+ *   format: shaka.util.CmcdManager.StreamingFormat
+ * }}
+ * @property {shaka.util.CmcdManager.StreamingFormat} format
+ *   The manifest's stream format
+ */
+shaka.util.CmcdManager.ManifestInfo;
+/**
+ * @enum {string}
+ */
+shaka.util.CmcdManager.StreamingFormat = {
+  DASH: 'd',
+  HLS: 'h',
+  SMOOTH: 's',
+  OTHER: 'o'
+};
 /**  */
 shaka.util.ConfigUtils = class {
   /**
@@ -2133,6 +2354,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!Promise}
    */
   unload(initializeMediaSource) {}
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   * @param {number} startTime
+   */
+  updateStartTime(startTime) {}
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -2642,6 +2871,10 @@ shaka.ads.ClientSideAd = class {
    * @override
    */
   isMuted() {}
+  /**
+   * @override
+   */
+  isLinear() {}
   /**
    * @override
    */
@@ -2724,6 +2957,10 @@ shaka.ads.ServerSideAd = class {
    * @override
    */
   isMuted() {}
+  /**
+   * @override
+   */
+  isLinear() {}
   /**
    * @override
    */
@@ -3194,9 +3431,11 @@ shaka.net.HttpFetchPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    */
-  static parse(uri, request, requestType, progressUpdated) {}
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {}
   /**
    * Determine if the Fetch API is supported in the browser. Note: this is
    * deliberately exposed as a method to allow the client app to use the same
@@ -3215,9 +3454,11 @@ shaka.net.HttpXHRPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    */
-  static parse(uri, request, requestType, progressUpdated) {}
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {}
 };
 /**
  * StorageMuxer is responsible for managing StorageMechanisms and addressing
@@ -3544,6 +3785,15 @@ shaka.polyfill.PiPWebkit = class {
    */
   static install() {}
 };
+/**
+ * @summary A polyfill to provide window.crypto.randomUUID in all browsers.
+ */
+shaka.polyfill.RandomUUID = class {
+  /**
+   * Install the polyfill if needed.
+   */
+  static install() {}
+};
 /**
  * @summary A polyfill to provide navigator.storage.estimate in old
  * webkit browsers.