rx-player 3.33.0 → 3.33.1

package/src/utils/byte_parsing.ts

@@ -1,256 +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.
- */
-
-/**
- * Returns a Uint8Array from the arguments given, in order:
- *   - if the next argument given is a number N set the N next bytes to 0.
- *   - else set the next bytes to the argument given.
- * @param {...(Number|Uint8Array)} args
- * @returns {Uint8Array}
- */
-function concat(...args : Array<Uint8Array|number[]|number>) : Uint8Array {
-  const l = args.length;
-  let i = -1;
-  let len = 0;
-  let arg;
-  while (++i < l) {
-    arg = args[i];
-    len += (typeof arg === "number") ? arg : arg.length;
-  }
-  const arr = new Uint8Array(len);
-  let offset = 0;
-  i = -1;
-  while (++i < l) {
-    arg = args[i];
-    if (typeof arg === "number") {
-      offset += arg;
-    }
-    else if (arg.length > 0) {
-      arr.set(arg, offset);
-      offset += arg.length;
-    }
-  }
-  return arr;
-}
-
-/**
- * Translate groups of 2 big-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be2toi(bytes : Uint8Array, offset : number) : number {
-  return ((bytes[offset + 0] << 8) +
-          (bytes[offset + 1] << 0));
-}
-
-/**
- * Translate groups of 3 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be3toi(bytes : Uint8Array, offset : number) : number {
-  return ((bytes[offset + 0] * 0x0010000) +
-          (bytes[offset + 1] * 0x0000100) +
-          (bytes[offset + 2]));
-}
-
-/**
- * Translate groups of 4 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be4toi(bytes : Uint8Array, offset : number) : number {
-  return ((bytes[offset + 0] * 0x1000000) +
-          (bytes[offset + 1] * 0x0010000) +
-          (bytes[offset + 2] * 0x0000100) +
-          (bytes[offset + 3]));
-}
-
-/**
- * Translate groups of 8 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be8toi(bytes : Uint8Array, offset : number) : number {
-  return (((bytes[offset + 0] * 0x1000000) +
-           (bytes[offset + 1] * 0x0010000) +
-           (bytes[offset + 2] * 0x0000100) +
-           (bytes[offset + 3])) * 0x100000000 +
-
-         (bytes[offset + 4] * 0x1000000) +
-         (bytes[offset + 5] * 0x0010000) +
-         (bytes[offset + 6] * 0x0000100) +
-         (bytes[offset + 7]));
-}
-
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding big-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe2(num : number) : Uint8Array {
-  return new Uint8Array([ (num >>> 8) & 0xFF,
-                          (num)       & 0xFF ]);
-}
-
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding big-endian
- * bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe4(num : number) : Uint8Array {
-  return new Uint8Array([ (num >>> 24) & 0xFF,
-                          (num >>> 16) & 0xFF,
-                          (num >>>  8) & 0xFF,
-                          (num)        & 0xFF ]);
-}
-
-/**
- * Translate Integer to a Uint8Array of length 8 of the corresponding big-endian
- * bytes.
- * /!\ If the top-most bytes are set, this might go over MAX_SAFE_INTEGER, thus
- * leading to a "bad" value.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe8(num : number) : Uint8Array {
-  const l = (num % 0x100000000);
-  const h = (num - l) / 0x100000000;
-  return new Uint8Array([ (h >>> 24) & 0xFF,
-                          (h >>> 16) & 0xFF,
-                          (h >>>  8) & 0xFF,
-                          (h)        & 0xFF,
-                          (l >>> 24) & 0xFF,
-                          (l >>> 16) & 0xFF,
-                          (l >>>  8) & 0xFF,
-                          (l)        & 0xFF ]);
-}
-
-/**
- * Translate groups of 2 little-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le2toi(bytes : Uint8Array, offset : number) : number {
-  return ((bytes[offset + 0] << 0) +
-          (bytes[offset + 1] << 8));
-}
-
-/**
- * Translate groups of 4 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le4toi(bytes : Uint8Array, offset : number) : number {
-  return ((bytes[offset + 0]) +
-          (bytes[offset + 1] * 0x0000100) +
-          (bytes[offset + 2] * 0x0010000) +
-          (bytes[offset + 3] * 0x1000000));
-}
-
-/**
- * Translate groups of 8 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le8toi(bytes : Uint8Array, offset : number) : number {
-  return (bytes[offset + 0]) +
-         (bytes[offset + 1] * 0x0000100) +
-         (bytes[offset + 2] * 0x0010000) +
-         (bytes[offset + 3] * 0x1000000) +
-         (
-           (bytes[offset + 4]) +
-           (bytes[offset + 5] * 0x0000100) +
-           (bytes[offset + 6] * 0x0010000) +
-           (bytes[offset + 7] * 0x1000000)
-         ) * 0x100000000;
-}
-
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itole2(num : number) : Uint8Array {
-  return new Uint8Array([ (num)       & 0xFF,
-                          (num >>> 8) & 0xFF ]);
-}
-
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding
- * little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itole4(num : number) : Uint8Array {
-  return new Uint8Array([ (num)        & 0xFF,
-                          (num >>>  8) & 0xFF,
-                          (num >>> 16) & 0xFF,
-                          (num >>> 24) & 0xFF ]);
-}
-
-/**
- * Check if an ArrayBuffer is equal to the bytes given.
- * @param {ArrayBuffer} buffer
- * @param {Uint8Array} bytes
- * @returns {Boolean}
- */
-function isABEqualBytes(buffer : ArrayBuffer, bytes : Uint8Array) : boolean {
-  const view = new DataView(buffer);
-  const len = view.byteLength;
-  if (len !== bytes.length) {
-    return false;
-  }
-  for (let i = 0; i < len; i++) {
-    if (view.getUint8(i) !== bytes[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Convert any BufferSource-typed structure into the corresponding Uint8Array.
- * @param {BufferSource} input
- * @returns {Uint8Array}
- */
-function toUint8Array(
-  input : BufferSource
-) : Uint8Array {
-  return input instanceof Uint8Array ? input :
-         input instanceof ArrayBuffer ? new Uint8Array(input) :
-                                        new Uint8Array(input.buffer);
-}
-
-export {
-  concat,
-  be2toi, be3toi, be4toi, be8toi,
-  le2toi, le4toi, le8toi,
-  itobe2, itobe4, itobe8,
-  itole2, itole4,
-  isABEqualBytes,
-  toUint8Array,
-};

package/src/utils/cancellable_sleep.ts

@@ -1,41 +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 createCancellablePromise from "./create_cancellable_promise";
-import { CancellationSignal } from "./task_canceller";
-
-/**
- * Wait the given `delay`, resolving the Promise when finished.
- *
- * The `cancellationSignal` given allows to cancel that timeout. In the case it
- * is triggered before the timeout ended, this function will reject the
- * corresponding `CancellationError` through the returned Promise.
- *
- * @param {number} delay - Delay to wait, in milliseconds
- * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
- * the timeout.
- * @returns {Promise} - Resolve on timeout completion, rejects on timeout
- * cancellation with the corresponding `CancellationError`.
- */
-export default function cancellableSleep(
-  delay: number,
-  cancellationSignal: CancellationSignal
-) : Promise<void> {
-  return createCancellablePromise(cancellationSignal, (res) => {
-    const timeout = setTimeout(() => res(), delay);
-    return () => clearTimeout(timeout);
-  });
-}

package/src/utils/create_cancellable_promise.ts

@@ -1,69 +0,0 @@
-import {
-  CancellationError,
-  CancellationSignal,
-} from "./task_canceller";
-
-/**
- * Returns a Promise linked to a `CancellationSignal`, which will reject the
- * corresponding `CancellationError` if that signal emits before the wanted
- * task finishes (either on success or on error).
- *
- * The given callback mimicks the Promise interface with the added possibility
- * of returning a callback which will be called when and if the task is
- * cancelled before being either resolved or rejected.
- * In that case, that logic will be called just before the Promise is rejected
- * with the corresponding `CancellationError`.
- * The point of this callback is to implement aborting logic, such as for
- * example aborting a request.
- *
- * @param {Object} cancellationSignal - The `CancellationSignal` the returned
- * Promise will be linked to.
- * @param {Function} cb - The function implementing the cancellable Promise. Its
- * arguments follow Promise's semantics but it can also return a function which
- * will be called when and if `cancellationSignal` emits before either arguments
- * are called.
- * @returns {Promise} - The created Promise, which will resolve when and if the
- * first argument to `cb` is called first and reject either if the second
- * argument to `cb` is called first or if the given `CancellationSignal` emits
- * before either of the two previous conditions.
- */
-export default function createCancellablePromise<T>(
-  cancellationSignal : CancellationSignal,
-  cb : (
-    resolve : (val : T) => void,
-    reject : (err : unknown) => void,
-  ) => (() => void) | void
-) : Promise<T> {
-  let abortingLogic : (() => void) | void;
-  return new Promise((res, rej) => {
-    if (cancellationSignal.cancellationError !== null) {
-      // If the signal was already triggered before, do not even call `cb`
-      return rej(cancellationSignal.cancellationError);
-    }
-
-    let hasUnregistered = false;
-    abortingLogic = cb(
-      function onCancellablePromiseSuccess(val : T) {
-        cancellationSignal.deregister(onCancellablePromiseCancellation);
-        hasUnregistered = true;
-        res(val);
-      },
-      function onCancellablePromiseFailure(err : unknown) {
-        cancellationSignal.deregister(onCancellablePromiseCancellation);
-        hasUnregistered = true;
-        rej(err);
-      }
-    );
-
-    if (!hasUnregistered) {
-      cancellationSignal.register(onCancellablePromiseCancellation);
-    }
-
-    function onCancellablePromiseCancellation(error : CancellationError) {
-      if (abortingLogic !== undefined) {
-        abortingLogic();
-      }
-      rej(error);
-    }
-  });
-}

package/src/utils/deep_merge.ts

@@ -1,49 +0,0 @@
-import objectAssign from "./object_assign";
-
-/**
- * Check if an item is an object
- * @param item
- * @returns {boolean}
- */
-function isObject(item: unknown) : boolean {
-  return (item !== null
-          && item !== undefined
-          && !Array.isArray(item)
-          && typeof item === "object");
-}
-
-type IDeepPartial<T> = {
-  [P in keyof T]?: IDeepPartial<T[P]> ;
-};
-
-type ISourcesArgument = unknown[];
-
-/**
- * Deeply merge nested objects
- * @param target
- * @param sources
- * @returns output : merged object
- */
-export default function deepMerge<
-  T extends Record<string | number | symbol, unknown>
->(target: T, ...sources: ISourcesArgument): T {
-  if (sources.length === 0) {
-    return target;
-  }
-  const source = sources.shift() as IDeepPartial<T>;
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        let newTarget = target[key] as Record<string | number | symbol, unknown>;
-        if (newTarget === undefined) {
-          newTarget = {};
-          (target[key] as Record<string | number | symbol, unknown>) = newTarget;
-        }
-        deepMerge(newTarget, source[key] as IDeepPartial<typeof newTarget>);
-      } else {
-        objectAssign(target, { [key]: source[key] });
-      }
-    }
-  }
-  return deepMerge(target, ...sources);
-}

package/src/utils/event_emitter.ts

@@ -1,147 +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 log from "../log";
-import isNullOrUndefined from "./is_null_or_undefined";
-import { CancellationSignal } from "./task_canceller";
-
-export interface IEventEmitter<T> {
-  addEventListener<TEventName extends keyof T>(evt : TEventName,
-                                               fn : IListener<T, TEventName>) :
-                                                void;
-  removeEventListener<TEventName extends keyof T>(evt : TEventName,
-                                                  fn : IListener<T, TEventName>) :
-                                                   void;
-}
-
-// Type of the argument in the listener's callback
-export type IEventPayload<TEventRecord, TEventName
-     extends keyof TEventRecord> = TEventRecord[TEventName];
-
-// Type of the listener function
-export type IListener<
-  TEventRecord,
-  TEventName extends keyof TEventRecord
-> = (args: IEventPayload<TEventRecord, TEventName>) => void;
-
-type IListeners<TEventRecord> = {
-  [P in keyof TEventRecord]? : Array<IListener<TEventRecord, P>>
-};
-
-/**
- * Simple but fully type-safe EventEmitter implementation.
- * @class EventEmitter
- */
-export default class EventEmitter<T> implements IEventEmitter<T> {
-  /**
-   * @type {Object}
-   * @private
-   */
-  private _listeners : IListeners<T>;
-
-  constructor() {
-    this._listeners = {};
-  }
-
-  /**
-   * Register a new callback for an event.
-   *
-   * @param {string} evt - The event to register a callback to
-   * @param {Function} fn - The callback to call as that event is triggered.
-   * The callback will take as argument the eventual payload of the event
-   * (single argument).
-   * @param {Object | undefined} cancellationSignal - When that signal emits,
-   * the event listener is automatically removed.
-   */
-  public addEventListener<TEventName extends keyof T>(
-    evt : TEventName,
-    fn : IListener<T, TEventName>,
-    cancellationSignal? : CancellationSignal
-  ) : void {
-    const listeners = this._listeners[evt];
-    if (!Array.isArray(listeners)) {
-      this._listeners[evt] = [fn];
-    } else {
-      listeners.push(fn);
-    }
-    if (cancellationSignal !== undefined) {
-      cancellationSignal.register(() => {
-        this.removeEventListener(evt, fn);
-      });
-    }
-  }
-
-  /**
-   * Unregister callbacks linked to events.
-   * @param {string} [evt] - The event for which the callback[s] should be
-   * unregistered. Set it to null or undefined to remove all callbacks
-   * currently registered (for any event).
-   * @param {Function} [fn] - The callback to unregister. If set to null
-   * or undefined while the evt argument is set, all callbacks linked to that
-   * event will be unregistered.
-   */
-  public removeEventListener<TEventName extends keyof T>(
-    evt? : TEventName,
-    fn? : IListener<T, TEventName>
-  ) : void {
-    if (isNullOrUndefined(evt)) {
-      this._listeners = {};
-      return;
-    }
-
-    const listeners = this._listeners[evt];
-    if (!Array.isArray(listeners)) {
-      return;
-    }
-    if (isNullOrUndefined(fn)) {
-      delete this._listeners[evt];
-      return;
-    }
-
-    const index = listeners.indexOf(fn);
-    if (index !== -1) {
-      listeners.splice(index, 1);
-    }
-
-    if (listeners.length === 0) {
-      delete this._listeners[evt];
-    }
-  }
-
-  /**
-   * Trigger every registered callbacks for a given event
-   * @param {string} evt - The event to trigger
-   * @param {*} arg - The eventual payload for that event. All triggered
-   * callbacks will recieve this payload as argument.
-   */
-  protected trigger<TEventName extends keyof T>(
-    evt : TEventName,
-    arg : IEventPayload<T, TEventName>
-  ) : void {
-    const listeners = this._listeners[evt];
-    if (!Array.isArray(listeners)) {
-      return;
-    }
-
-    listeners.slice().forEach((listener) => {
-      try {
-        listener(arg);
-      } catch (e) {
-        log.error("EventEmitter: listener error", e instanceof Error ? e : null);
-      }
-    });
-  }
-}

package/src/utils/flat_map.ts

@@ -1,50 +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.
- */
-
-// Ugly transitory type to make duck typing work
-type ArrayWithFlatMap<T> = T[] & {
-  flatMap<U, This = undefined>(
-    callback: (this: This, value: T, index: number, array: T[]) => U | U[],
-    thisArg?: This
-  ): U[];
-};
-
-/**
- * Map each element using a mapping function, then flat the result into
- * a new array.
- * @param {Array.<*>} originalArray
- * @param {Function} fn
- */
-export default function flatMap<T, U>(
-  originalArray : T[],
-  fn: (arg: T) => U[]|U
-) : U[] {
-  /* eslint-disable @typescript-eslint/unbound-method */
-  if (typeof (Array.prototype as ArrayWithFlatMap<T>).flatMap === "function") {
-    return (originalArray as ArrayWithFlatMap<T>).flatMap(fn);
-  }
-  /* eslint-enable @typescript-eslint/unbound-method */
-
-  return originalArray.reduce((acc : U[], arg : T) : U[] => {
-    const r = fn(arg);
-    if (Array.isArray(r)) {
-      acc.push(...r);
-      return acc;
-    }
-    acc.push(r);
-    return acc;
-  }, []);
-}

package/src/utils/get_fuzzed_delay.ts

@@ -1,27 +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.
- */
-
-const FUZZ_FACTOR = 0.3;
-
-/**
- * Perform "fuzzing" on the delay given.
- * @param {Number} retryDelay
- * @returns {Number}
- */
-export default function getFuzzedDelay(retryDelay : number) : number {
-  const fuzzingFactor = ((Math.random() * 2) - 1) * FUZZ_FACTOR;
-  return retryDelay * (fuzzingFactor + 1); // Max 1.3 Min 0.7
-}

package/src/utils/hash_buffer.ts

@@ -1,42 +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.
- */
-
-/**
- * Convert given buffer to a 32bit integer hash
- *
- * This algorithm is the same one that Java `String.hashCode()` one which
- * is a fast hashing function adapted to short ASCII strings.
- * This consequently might not be the most adapted to buffers of various length
- * containing a various amount of data but still has the advantage of being
- * fast.
- *
- * As this function is used in persistent MediaKeySession storage, we probably
- * should keep this function somewhere as long as we want to support
- * MediaKeySessions persisted in old versions of the RxPlayer.
- *
- * @param {Array.<number>|TypedArray} buffer
- * @returns {number}
- */
-export default function hashBuffer(buffer : Uint8Array|number[]) : number {
-  let hash = 0;
-  let char;
-  for (let i = 0; i < buffer.length; i++) {
-    char = buffer[i];
-    hash = ((hash <<  5) - hash) + char;
-    hash = hash & hash; // Convert to 32bit integer
-  }
-  return hash;
-}