rx-player 3.33.0 → 3.33.1

package/src/utils/request/xhr.ts

@@ -1,287 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * 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.
- */
-
-import { RequestError } from "../../errors";
-import isNonEmptyString from "../is_non_empty_string";
-import isNullOrUndefined from "../is_null_or_undefined";
-import {
-  CancellationError,
-  CancellationSignal,
-} from "../task_canceller";
-
-
-const DEFAULT_RESPONSE_TYPE : XMLHttpRequestResponseType = "json";
-
-/**
- * Perform an HTTP request, according to the options given.
- *
- * Several errors can be rejected. Namely:
- *   - RequestErrorTypes.TIMEOUT_ERROR: the request timeouted (took too long to
- *     respond).
- *   - RequestErrorTypes.PARSE_ERROR: the browser APIs used to parse the
- *                                    data failed.
- *   - RequestErrorTypes.ERROR_HTTP_CODE: the HTTP code at the time of reception
- *                                        was not in the 200-299 (included)
- *                                        range.
- *   - RequestErrorTypes.ERROR_EVENT: The XHR had an error event before the
- *                                    response could be fetched.
- * @param {Object} options
- * @returns {Promise.<Object>}
- */
-export default function request(
-  options : IRequestOptions< undefined | null | "" | "text" >
-) : Promise<IRequestResponse< string, "text" >>;
-export default function request(
-  options : IRequestOptions< "arraybuffer" >
-) : Promise<IRequestResponse< ArrayBuffer, "arraybuffer" >>;
-export default function request(
-  options : IRequestOptions< "document" >
-) : Promise<IRequestResponse< Document, "document" >>;
-export default function request(
-  options : IRequestOptions< "json" >
-)
-// eslint-disable-next-line @typescript-eslint/ban-types
-: Promise<IRequestResponse< object, "json" >>;
-export default function request(
-  options : IRequestOptions< "blob" >,
-)
-: Promise<IRequestResponse< Blob, "blob" >>;
-export default function request<T>(
-  options : IRequestOptions< XMLHttpRequestResponseType | null | undefined >
-) : Promise<IRequestResponse< T, XMLHttpRequestResponseType >> {
-
-  const requestOptions = {
-    url: options.url,
-    headers: options.headers,
-    responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
-                                                            options.responseType,
-    timeout: options.timeout,
-  };
-
-  return new Promise((resolve, reject) => {
-    const { onProgress, cancelSignal } = options;
-    const { url,
-            headers,
-            responseType,
-            timeout } = requestOptions;
-    const xhr = new XMLHttpRequest();
-    xhr.open("GET", url, true);
-
-    let timeoutId : undefined | number;
-    if (timeout !== undefined) {
-      xhr.timeout = timeout;
-
-      // We've seen on some browser (mainly on some LG TVs), that `xhr.timeout`
-      // was either not supported or did not function properly despite the
-      // browser being recent enough to support it.
-      // That's why we also start a manual timeout. We do this a little later
-      // than the "native one" performed on the xhr assuming that the latter
-      // is more precise, it might also be more efficient.
-      timeoutId = window.setTimeout(() => {
-        clearCancellingProcess();
-        reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
-      }, timeout + 3000);
-    }
-
-    xhr.responseType = responseType;
-
-    if (xhr.responseType === "document") {
-      xhr.overrideMimeType("text/xml");
-    }
-
-    if (!isNullOrUndefined(headers)) {
-      const _headers = headers;
-      for (const key in _headers) {
-        if (_headers.hasOwnProperty(key)) {
-          xhr.setRequestHeader(key, _headers[key]);
-        }
-      }
-    }
-
-    const sendingTime = performance.now();
-
-    // Handle request cancellation
-    let deregisterCancellationListener : (() => void) | null = null;
-    if (cancelSignal !== undefined) {
-      deregisterCancellationListener = cancelSignal
-        .register(function abortRequest(err : CancellationError) {
-          clearCancellingProcess();
-          if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
-            xhr.abort();
-          }
-          reject(err);
-        });
-
-      if (cancelSignal.isCancelled()) {
-        return;
-      }
-    }
-
-    xhr.onerror = function onXHRError() {
-      clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "ERROR_EVENT", xhr));
-    };
-
-    xhr.ontimeout = function onXHRTimeout() {
-      clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
-    };
-
-    if (onProgress !== undefined) {
-      xhr.onprogress = function onXHRProgress(event) {
-        const currentTime = performance.now();
-        onProgress({ url,
-                     duration: currentTime - sendingTime,
-                     sendingTime,
-                     currentTime,
-                     size: event.loaded,
-                     totalSize: event.total });
-      };
-    }
-
-    xhr.onload = function onXHRLoad(event : ProgressEvent) {
-      if (xhr.readyState === 4) {
-        clearCancellingProcess();
-        if (xhr.status >= 200 && xhr.status < 300) {
-          const receivedTime = performance.now();
-          const totalSize = xhr.response instanceof
-                              ArrayBuffer ? xhr.response.byteLength :
-                                            event.total;
-          const status = xhr.status;
-          const loadedResponseType = xhr.responseType;
-          const _url = isNonEmptyString(xhr.responseURL) ? xhr.responseURL :
-                                                           url;
-
-          let responseData : T;
-          if (loadedResponseType === "json") {
-            // IE bug where response is string with responseType json
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            responseData = typeof xhr.response === "object" ?
-              xhr.response :
-              toJSONForIE(xhr.responseText);
-          } else {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            responseData = xhr.response;
-          }
-
-          if (isNullOrUndefined(responseData)) {
-            reject(new RequestError(url, xhr.status, "PARSE_ERROR", xhr));
-            return;
-          }
-
-          resolve({ status,
-                    url: _url,
-                    responseType: loadedResponseType,
-                    sendingTime,
-                    receivedTime,
-                    requestDuration: receivedTime - sendingTime,
-                    size: totalSize,
-                    responseData });
-
-        } else {
-          reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE", xhr));
-        }
-      }
-    };
-
-    xhr.send();
-
-    /**
-     * Clear resources and timers created to handle cancellation and timeouts.
-     */
-    function clearCancellingProcess() {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId);
-      }
-      if (deregisterCancellationListener !== null) {
-        deregisterCancellationListener();
-      }
-    }
-  });
-}
-
-/**
- * @param {string} data
- * @returns {Object|null}
- */
-function toJSONForIE(data : string) : unknown {
-  try {
-    return JSON.parse(data);
-  } catch (e) {
-    return null;
-  }
-}
-
-/** Options given to `request` */
-export interface IRequestOptions<ResponseType> {
-  /** URL you want to request. */
-  url : string;
-  /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
-  headers? : { [ header: string ] : string } |
-             null |
-             undefined;
-  /** Wanted format for the response */
-  responseType? : ResponseType | undefined;
-  /**
-   * Optional timeout, in milliseconds, after which we will cancel a request.
-   * To not set or to set to `undefined` for disable.
-   */
-  timeout? : number | undefined;
-  /**
-   * "Cancelation token" used to be able to cancel the request.
-   * When this token is "cancelled", the request will be aborted and the Promise
-   * returned by `request` will be rejected.
-   */
-  cancelSignal? : CancellationSignal | undefined;
-  /**
-   * When defined, this callback will be called on each XHR "progress" event
-   * with data related to this request's progress.
-   */
-  onProgress? : ((info : IProgressInfo) => void) | undefined;
-}
-
-/** Data emitted by `request`'s Promise when the request succeeded. */
-export interface IRequestResponse<T, U> {
-  /** Time taken by the request, in milliseconds. */
-  requestDuration : number;
-  /** Time (relative to the "time origin") at which the request ended. */
-  receivedTime : number;
-  /** Data requested. Its type will depend on the responseType. */
-  responseData : T;
-  /** `responseType` requested, gives an indice on the type of `responseData`. */
-  responseType : U;
-  /** Time (relative to the "time origin") at which the request began. */
-  sendingTime : number;
-  /** Full size of the requested data, in bytes. */
-  size : number;
-  /** HTTP status of the response */
-  status : number;
-  /**
-   * Actual URL requested.
-   * Can be different from the one given to `request` due to a possible
-   * redirection.
-   */
-  url : string;
-}
-
-export interface IProgressInfo {
-  currentTime : number;
-  duration : number;
-  size : number;
-  sendingTime : number;
-  url : string;
-  totalSize? : number | undefined;
-}

package/src/utils/resolve_url.ts

@@ -1,126 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * 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.
- */
-
-// Scheme part of an url (e.g. "http://").
-const schemeRe = /^(?:[a-z]+:)?\/\//i;
-
-// Captures "/../" or "/./".
-const selfDirRe = /\/\.{1,2}\//;
-
-/**
- * Resolve self directory and previous directory references to obtain a
- * "normalized" url.
- * @example "https://foo.bar/baz/booz/../biz" => "https://foo.bar/baz/biz"
- * @param {string} url
- * @returns {string}
- */
-function _normalizeUrl(url : string) : string {
-  // fast path if no ./ or ../ are present in the url
-  if (!selfDirRe.test(url)) {
-    return url;
-  }
-
-  const newUrl : string[] = [];
-  const oldUrl = url.split("/");
-  for (let i = 0, l = oldUrl.length; i < l; i++) {
-    if (oldUrl[i] === "..") {
-      newUrl.pop();
-    } else if (oldUrl[i] === ".") {
-      continue;
-    } else {
-      newUrl.push(oldUrl[i]);
-    }
-  }
-
-  return newUrl.join("/");
-}
-
-/**
- * Construct an url from the arguments given.
- * Basically:
- *   - The last arguments that contains a scheme (e.g. "http://") is the base
- *     of the url.
- *   - every subsequent string arguments are concatened to it.
- * @param {...string|undefined} args
- * @returns {string}
- */
-export default function resolveURL(...args : Array<string|undefined>) : string {
-  const len = args.length;
-  if (len === 0) {
-    return "";
-  }
-
-  let base = "";
-  for (let i = 0; i < len; i++) {
-    let part = args[i];
-    if (typeof part !== "string" || part === "") {
-      continue;
-    }
-    if (schemeRe.test(part)) {
-      base = part;
-    }
-    else {
-      // trim if begins with "/"
-      if (part[0] === "/") {
-        part = part.substring(1);
-      }
-
-      // trim if ends with "/"
-      if (base[base.length - 1] === "/") {
-        base = base.substring(0, base.length - 1);
-      }
-
-      base = base + "/" + part;
-    }
-  }
-
-  return _normalizeUrl(base);
-}
-
-/**
- * In a given URL, find the index at which the filename begins.
- * That is, this function finds the index of the last `/` character and returns
- * the index after it, returning the length of the whole URL if no `/` was found
- * after the scheme (i.e. in `http://`, the slashes are not considered).
- * @param {string} url
- * @returns {number}
- */
-function getFilenameIndexInUrl(url : string) : number {
-  const indexOfLastSlash = url.lastIndexOf("/");
-  if (indexOfLastSlash < 0) {
-    return url.length;
-  }
-
-  if (schemeRe.test(url)) {
-    const firstSlashIndex = url.indexOf("/");
-    if (firstSlashIndex >= 0 && indexOfLastSlash === firstSlashIndex + 1) {
-      // The "/" detected is actually the one from the protocol part of the URL
-      // ("https://")
-      return url.length;
-    }
-  }
-
-  const indexOfQuestionMark = url.indexOf("?");
-  if (indexOfQuestionMark >= 0 && indexOfQuestionMark < indexOfLastSlash) {
-    // There are query parameters. Let's ignore them and re-run the logic
-    // without
-    return getFilenameIndexInUrl(url.substring(0, indexOfQuestionMark));
-  }
-
-  return indexOfLastSlash + 1;
-}
-
-export { getFilenameIndexInUrl };

package/src/utils/retry_promise_with_backoff.ts

@@ -1,95 +0,0 @@
-import { IPlayerError } from "../public_types";
-import getFuzzedDelay from "./get_fuzzed_delay";
-import isNullOrUndefined from "./is_null_or_undefined";
-import sleep from "./sleep";
-import { CancellationSignal } from "./task_canceller";
-
-/**
- * Retry the given Promise (if it rejects) with an exponential
- * backoff.
- * The backoff behavior can be tweaked through the options given.
- *
- * @param {Function} runProm
- * @param {Object} options - Configuration object.
- * This object contains the following properties:
- *
- *   - retryDelay {Number} - The initial delay, in ms.
- *     This delay will be fuzzed to fall under the range +-30% each time a new
- *     retry is done.
- *     Then, this delay will be multiplied by 2^(n-1), n being the counter of
- *     retry we performed (beginning at 1 for the first retry).
- *
- *   - totalRetry {Number} - The amount of time we should retry. 0
- *     means no retry, 1 means a single retry, Infinity means infinite retry
- *     etc.
- *     If the Promise still rejects after this number of retry, the error will
- *     be throwed through the returned Promise.
- *
- *   - shouldRetry {Function|undefined} -  Function which will receive the
- *     error each time it fails, and should return a boolean. If this boolean
- *     is false, the error will be directly thrown (without anymore retry).
- *
- *   - onRetry {Function|undefined} - Function which will be triggered at
- *     each retry. Will receive two arguments:
- *       1. The error
- *       2. The current retry count, beginning at 1 for the first retry
- *
- * @param {Object} cancelSignal
- * @returns {Promise}
- * TODO Take errorSelector out. Should probably be entirely managed in the
- * calling code via a catch (much simpler to use and to understand).
- */
-export default function retryPromiseWithBackoff<T>(
-  runProm : () => Promise<T>,
-  options : IBackoffOptions,
-  cancelSignal : CancellationSignal
-) : Promise<T> {
-  const { baseDelay,
-          maxDelay,
-          totalRetry,
-          shouldRetry,
-          onRetry } = options;
-
-  let retryCount = 0;
-
-  return iterate();
-  async function iterate() : Promise<T> {
-    if (cancelSignal.cancellationError !== null) {
-      throw cancelSignal.cancellationError;
-    }
-    try {
-      const res = await runProm();
-      return res;
-    } catch (error) {
-      if (cancelSignal.cancellationError !== null) {
-        throw cancelSignal.cancellationError;
-      }
-      if ((!isNullOrUndefined(shouldRetry) && !shouldRetry(error)) ||
-           retryCount++ >= totalRetry)
-      {
-        throw error;
-      }
-
-      if (typeof onRetry === "function") {
-        onRetry(error, retryCount);
-      }
-
-      const delay = Math.min(baseDelay * Math.pow(2, retryCount - 1),
-                             maxDelay);
-
-      const fuzzedDelay = getFuzzedDelay(delay);
-      await sleep(fuzzedDelay);
-      const res = iterate();
-      return res;
-    }
-  }
-}
-
-export interface IBackoffOptions {
-  baseDelay : number;
-  maxDelay : number;
-  totalRetry : number;
-  shouldRetry? : (error : unknown) => boolean;
-  errorSelector? : (error : unknown, retryCount : number) => Error | IPlayerError;
-  onRetry? : (error : unknown, retryCount : number) => void;
-}

package/src/utils/simple_set.ts

@@ -1,67 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * 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.
- */
-
-/**
- * Simple hash-based set.
- * @class SimpleSet
- */
-export default class SimpleSet {
-  /**
-   * Hashes currently stored
-   * @type {Object}
-   * @private
-   */
-  private _hashes : Partial<Record<string, true>>;
-
-  constructor() {
-    this._hashes = {};
-  }
-
-  /**
-   * Add a new hash entry in the set.
-   * Do not have any effect on already-added hashes
-   * @param {string|number} x
-   */
-  public add(x : string|number) : void {
-    this._hashes[x] = true;
-  }
-
-  /**
-   * Remove an hash entry from the set.
-   * Do not have any effect on already-removed or inexistent hashes
-   * @param {string|number} x
-   */
-  public remove(x : string|number) : void {
-    delete this._hashes[x];
-  }
-
-  /**
-   * Test if the given hash has an entry in the set.
-   * @param {string|number} x
-   * @returns {boolean}
-   */
-  public test(x : string|number) : boolean {
-    return this._hashes.hasOwnProperty(x);
-  }
-
-  /**
-   * Returns true if there's currently no hash in this set.
-   * @returns {boolean}
-   */
-  public isEmpty() : boolean {
-    return Object.keys(this._hashes).length === 0;
-  }
-}

package/src/utils/sleep.ts

@@ -1,14 +0,0 @@
-/**
- * Convert a setTimeout to a Promise.
- *
- * You can use it to have a much more readable blocking code with async/await
- * in some asynchronous tests.
- *
- * @param {number} timeInMs
- * @returns {Promise}
- */
-export default function sleep(timeInMs : number) : Promise<void> {
-  return new Promise((res) => {
-    setTimeout(res, timeInMs);
-  });
-}

package/src/utils/slice_uint8array.ts

@@ -1,53 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * 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.
- */
-
-/**
- * @param {Uint8Array} arr - The Uint8Array you want to slice
- * @param {number} start - The starting byte index from the beginning
- * @param {number} end -     Byte index before which to end slicing.
- * If end is unspecified, the new ArrayBuffer contains all bytes from begin to
- * the end of this ArrayBuffer. If negative, it will make the Byte index begin
- * from the last Byte.
- * @returns {Uint8Array}
- */
-function arraySlice(
-  arr : Uint8Array,
-  start : number,
-  end? : number
-) : Uint8Array {
-  return new Uint8Array(Array.prototype.slice.call(arr, start, end));
-}
-
-/**
- * @param {Uint8Array} arr - The Uint8Array you want to slice
- * @param {number} start - The starting byte index from the beginning
- * @param {number} end -     Byte index before which to end slicing.
- * If end is unspecified, the new ArrayBuffer contains all bytes from begin to
- * the end of this ArrayBuffer. If negative, it will make the Byte index begin
- * from the last Byte.
- * @returns {Uint8Array}
- */
-function uint8ArraySlice(
-  arr : Uint8Array,
-  start : number,
-  end? : number
-) : Uint8Array {
-  return arr.slice(start, end);
-}
-
-export default typeof Uint8Array.prototype.slice === "function" ?
-  uint8ArraySlice :
-  arraySlice;