rx-player 3.33.0 → 3.33.1

package/src/compat/event_listeners.ts

@@ -1,566 +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 config from "../config";
-import log from "../log";
-import { IEventEmitter } from "../utils/event_emitter";
-import isNonEmptyString from "../utils/is_non_empty_string";
-import isNullOrUndefined from "../utils/is_null_or_undefined";
-import noop from "../utils/noop";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../utils/reference";
-import { CancellationSignal } from "../utils/task_canceller";
-import {
-  ICompatDocument,
-  ICompatHTMLMediaElement,
-  ICompatPictureInPictureWindow,
-} from "./browser_compatibility_types";
-import isNode from "./is_node";
-
-const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
-
-const pixelRatio = isNode ||
-                   window.devicePixelRatio == null ||
-                   window.devicePixelRatio === 0 ? 1 :
-                                                   window.devicePixelRatio;
-
-/**
- * Find the first supported event from the list given.
- * @param {HTMLElement} element
- * @param {string} eventNameSuffix
- * @returns {Boolean}
- */
-function isEventSupported(
-  element : HTMLElement,
-  eventNameSuffix : string
-) : boolean {
-  const clone = document.createElement(element.tagName);
-  const eventName = "on" + eventNameSuffix;
-  if (eventName in clone) {
-    return true;
-  } else {
-    clone.setAttribute(eventName, "return;");
-    return typeof (
-      clone as HTMLElement & Partial<Record<string, unknown>>
-    )[eventName] === "function";
-  }
-}
-
-/**
- * Find the first supported event from the list given.
- * @param {HTMLElement} element
- * @param {Array.<string>} eventNames
- * @returns {string|undefined}
- */
-function findSupportedEvent(
-  element : HTMLElement,
-  eventNames : string[]
-) : string|undefined {
-  return eventNames
-    .filter((name) => isEventSupported(element, name))[0];
-}
-
-/**
- * @param {Array.<string>} eventNames
- * @param {Array.<string>|undefined} prefixes
- * @returns {Array.<string>}
- */
-function eventPrefixed(eventNames : string[], prefixes? : string[]) : string[] {
-  return eventNames.reduce((parent : string[], name : string) =>
-    parent.concat((prefixes === undefined ? BROWSER_PREFIXES :
-                                            prefixes)
-      .map((p) => p + name)), []);
-}
-
-export interface IEventEmitterLike {
-  addEventListener : (eventName: string, handler: () => void) => void;
-  removeEventListener: (eventName: string, handler: () => void) => void;
-}
-
-export type IEventTargetLike = HTMLElement |
-                               IEventEmitterLike |
-                               IEventEmitter<unknown>;
-
-/**
- * Returns a function allowing to add event listeners for particular event(s)
- * optionally automatically adding browser prefixes if needed.
- * @param {Array.<string>} eventNames - The event(s) to listen to. If multiple
- * events are set, the event listener will be triggered when any of them emits.
- * @param {Array.<string>|undefined} [prefixes] - Optional vendor prefixes with
- * which the event might also be sent. If not defined, default prefixes might be
- * tested.
- * @returns {Function} - Returns function allowing to easily add a callback to
- * be triggered when that event is emitted on a given event target.
- */
-function createCompatibleEventListener(
-  eventNames : string[],
-  prefixes? : string[]
-) :
-  (
-    element : IEventTargetLike,
-    listener : (event? : unknown) => void,
-    cancelSignal: CancellationSignal
-  ) => void
-{
-  let mem : string|undefined;
-  const prefixedEvents = eventPrefixed(eventNames, prefixes);
-
-  return (
-    element : IEventTargetLike,
-    listener: (event? : unknown) => void,
-    cancelSignal: CancellationSignal
-  ) => {
-    if (cancelSignal.isCancelled()) {
-      return;
-    }
-
-    // if the element is a HTMLElement we can detect
-    // the supported event, and memoize it in `mem`
-    if (element instanceof HTMLElement) {
-      if (typeof mem === "undefined") {
-        mem = findSupportedEvent(element, prefixedEvents);
-      }
-
-      if (isNonEmptyString(mem)) {
-        element.addEventListener(mem, listener);
-        cancelSignal.register(() => {
-          if (mem !== undefined) {
-            element.removeEventListener(mem, listener);
-          }
-        });
-      } else {
-        if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
-          log.warn(`compat: element ${element.tagName}` +
-                   " does not support any of these events: " +
-                   prefixedEvents.join(", "));
-        }
-        return ;
-      }
-    }
-
-    prefixedEvents.forEach(eventName => {
-      let hasSetOnFn = false;
-      if (typeof element.addEventListener === "function") {
-        (element as IEventEmitterLike).addEventListener(eventName, listener);
-      } else {
-        hasSetOnFn = true;
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-        (element as any)["on" + eventName] = listener;
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      }
-      cancelSignal.register(() => {
-        if (typeof element.removeEventListener === "function") {
-          (element as IEventEmitterLike).removeEventListener(eventName, listener);
-        }
-        if (hasSetOnFn) {
-          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-          /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-          delete (element as any)["on" + eventName];
-          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-        }
-      });
-    });
-  };
-
-}
-
-/**
- * Returns a reference:
- *   - set to `true` when the document is visible
- *   - set to `false` when the document is hidden
- * @param {Object} stopListening - `CancellationSignal` allowing to free the
- * ressources allocated to update this value.
- * @returns {Object}
- */
-function getDocumentVisibilityRef(
-  stopListening : CancellationSignal
-) : IReadOnlySharedReference<boolean> {
-  let prefix : string|undefined;
-
-  const doc = document as ICompatDocument;
-  if (doc.hidden != null) {
-    prefix = "";
-  } else if (doc.mozHidden != null) {
-    prefix = "moz";
-  } else if (doc.msHidden != null) {
-    prefix = "ms";
-  } else if (doc.webkitHidden != null) {
-    prefix = "webkit";
-  }
-
-  const hidden = isNonEmptyString(prefix) ? prefix + "Hidden" :
-                                            "hidden";
-  const visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
-                                                           "visibilitychange";
-
-  const isHidden = document[hidden as "hidden"];
-  const ref = new SharedReference(!isHidden, stopListening);
-
-  addEventListener(document, visibilityChangeEvent, () => {
-    const isVisible = !(document[hidden as "hidden"]);
-    ref.setValueIfChanged(isVisible);
-  }, stopListening);
-
-  return ref;
-}
-
-/**
- * Returns a reference:
- *   - Set to `true` when the current page is considered visible and active.
- *   - Set to `false` otherwise.
- * @param {Object} stopListening - `CancellationSignal` allowing to free the
- * resources allocated to update this value.
- * @returns {Object}
- */
-function getPageActivityRef(
-  stopListening : CancellationSignal
-) : IReadOnlySharedReference<boolean> {
-  const isDocVisibleRef = getDocumentVisibilityRef(stopListening);
-  let currentTimeout : number | undefined;
-  const ref = new SharedReference(true, stopListening);
-  stopListening.register(() => {
-    clearTimeout(currentTimeout);
-    currentTimeout = undefined;
-  });
-
-  isDocVisibleRef.onUpdate(function onDocVisibilityChange(isVisible : boolean) : void {
-    clearTimeout(currentTimeout); // clear potential previous timeout
-    currentTimeout = undefined;
-    if (!isVisible) {
-      const { INACTIVITY_DELAY } = config.getCurrent();
-      currentTimeout = window.setTimeout(() => {
-        ref.setValueIfChanged(false);
-      }, INACTIVITY_DELAY);
-    }
-    ref.setValueIfChanged(true);
-  }, { clearSignal: stopListening, emitCurrentValue: true });
-
-  return ref;
-}
-
-/**
- * Get video width from Picture-in-Picture window
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} pipWindow
- * @returns {number}
- */
-function getVideoWidthFromPIPWindow(
-  mediaElement: HTMLMediaElement,
-  pipWindow: ICompatPictureInPictureWindow
-): number {
-  const { width, height } = pipWindow;
-  const videoRatio = mediaElement.clientHeight / mediaElement.clientWidth;
-  const calcWidth = height / videoRatio;
-  return Math.min(width, calcWidth);
-}
-
-export interface IPictureInPictureEvent {
-  isEnabled : boolean;
-  pipWindow : ICompatPictureInPictureWindow | null;
-}
-
-/**
- * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} elt
- * @param {Object} stopListening
- * @returns {Object}
- */
-function getPictureOnPictureStateRef(
-  elt: HTMLMediaElement,
-  stopListening: CancellationSignal
-): IReadOnlySharedReference<IPictureInPictureEvent> {
-  const mediaElement = elt as ICompatHTMLMediaElement;
-  if (mediaElement.webkitSupportsPresentationMode === true &&
-      typeof mediaElement.webkitSetPresentationMode === "function")
-  {
-    const isWebKitPIPEnabled =
-      mediaElement.webkitPresentationMode === "picture-in-picture";
-    const ref = new SharedReference<IPictureInPictureEvent>({
-      isEnabled: isWebKitPIPEnabled,
-      pipWindow: null,
-    }, stopListening);
-    addEventListener(mediaElement, "webkitpresentationmodechanged", () => {
-      const isEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
-      ref.setValue({ isEnabled, pipWindow: null });
-    }, stopListening);
-    return ref;
-  }
-
-  const isPIPEnabled = (
-    (document as ICompatDocument).pictureInPictureElement === mediaElement
-  );
-  const ref = new SharedReference<IPictureInPictureEvent>({ isEnabled: isPIPEnabled,
-                                                            pipWindow: null },
-                                                          stopListening);
-  addEventListener(mediaElement, "enterpictureinpicture", (evt) => {
-    ref.setValue({
-      isEnabled: true,
-      pipWindow: (evt as Event & {
-        pictureInPictureWindow? : ICompatPictureInPictureWindow;
-      }).pictureInPictureWindow ?? null,
-    });
-  }, stopListening);
-  addEventListener(mediaElement, "leavepictureinpicture", () => {
-    ref.setValue({ isEnabled: false, pipWindow: null });
-  }, stopListening);
-  return ref;
-}
-
-/**
- * Returns a reference:
- *   - Set to `true` when video is considered as visible (the page is visible
- *     and/or the Picture-In-Picture is activated).
- *   - Set to `false` otherwise.
- * @param {Object} pipStatus
- * @param {Object} stopListening - `CancellationSignal` allowing to free the
- * resources reserved to listen to video visibility change.
- * @returns {Object}
- */
-function getVideoVisibilityRef(
-  pipStatus : IReadOnlySharedReference<IPictureInPictureEvent>,
-  stopListening : CancellationSignal
-) : IReadOnlySharedReference<boolean> {
-  const isDocVisibleRef = getDocumentVisibilityRef(stopListening);
-  let currentTimeout : number | undefined;
-  const ref = new SharedReference(true, stopListening);
-  stopListening.register(() => {
-    clearTimeout(currentTimeout);
-    currentTimeout = undefined;
-  });
-
-  isDocVisibleRef.onUpdate(checkCurrentVisibility,
-                           { clearSignal: stopListening });
-  pipStatus.onUpdate(checkCurrentVisibility,
-                     { clearSignal: stopListening });
-  checkCurrentVisibility();
-  return ref;
-
-  function checkCurrentVisibility() : void {
-    clearTimeout(currentTimeout);
-    currentTimeout = undefined;
-    if (pipStatus.getValue().isEnabled || isDocVisibleRef.getValue()) {
-      ref.setValueIfChanged(true);
-    } else {
-      const { INACTIVITY_DELAY } = config.getCurrent();
-      currentTimeout = window.setTimeout(() => {
-        ref.setValueIfChanged(false);
-      }, INACTIVITY_DELAY);
-    }
-  }
-}
-
-/**
- * Get video width from HTML video element, or video estimated dimensions
- * when Picture-in-Picture is activated.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} pipStatusRef
- * @param {Object} stopListening
- * @returns {Object}
- */
-function getVideoWidthRef(
-  mediaElement : HTMLMediaElement,
-  pipStatusRef : IReadOnlySharedReference<IPictureInPictureEvent>,
-  stopListening : CancellationSignal
-) : IReadOnlySharedReference<number> {
-  const ref = new SharedReference<number>(mediaElement.clientWidth * pixelRatio,
-                                          stopListening);
-  let clearPreviousEventListener = noop;
-  pipStatusRef.onUpdate(checkVideoWidth, { clearSignal: stopListening });
-  addEventListener(window, "resize", checkVideoWidth, stopListening);
-  const interval = window.setInterval(checkVideoWidth, 20000);
-
-  checkVideoWidth();
-
-  stopListening.register(function stopUpdatingVideoWidthRef() {
-    clearPreviousEventListener();
-    clearInterval(interval);
-  });
-  return ref;
-
-  function checkVideoWidth() {
-    clearPreviousEventListener();
-    const pipStatus = pipStatusRef.getValue();
-    if (!pipStatus.isEnabled) {
-      ref.setValueIfChanged(mediaElement.clientWidth * pixelRatio);
-    } else if (!isNullOrUndefined(pipStatus.pipWindow)) {
-      const { pipWindow } = pipStatus;
-      const firstWidth = getVideoWidthFromPIPWindow(mediaElement, pipWindow);
-      const onPipResize = () => {
-        ref.setValueIfChanged(
-          getVideoWidthFromPIPWindow(mediaElement, pipWindow) * pixelRatio
-        );
-      };
-      pipWindow.addEventListener("resize", onPipResize);
-      clearPreviousEventListener = () => {
-        pipWindow.removeEventListener("resize", onPipResize);
-        clearPreviousEventListener = noop;
-      };
-      ref.setValueIfChanged(firstWidth * pixelRatio);
-    } else {
-      ref.setValueIfChanged(Infinity);
-    }
-  }
-}
-
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onLoadedMetadata = createCompatibleEventListener(["loadedmetadata"]);
-
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onTimeUpdate = createCompatibleEventListener(["timeupdate"]);
-
-/**
- * @param {HTMLElement} element
- */
-const onFullscreenChange = createCompatibleEventListener(
-  ["fullscreenchange", "FullscreenChange"],
-
-  // On IE11, fullscreen change events is called MSFullscreenChange
-  BROWSER_PREFIXES.concat("MS")
-);
-
-/**
- * @param {TextTrackList} textTrackList
- */
-const onTextTrackAdded = createCompatibleEventListener(["addtrack"]);
-
-/**
- * @param {TextTrackList} textTrackList
- */
-const onTextTrackRemoved = createCompatibleEventListener(["removetrack"]);
-
-/**
- * @param {MediaSource} mediaSource
- * @param {Function} listener
- * @param {Object} cancelSignal
- */
-const onSourceOpen = createCompatibleEventListener(["sourceopen", "webkitsourceopen"]);
-
-/**
- * @param {MediaSource} mediaSource
- * @param {Function} listener
- * @param {Object} cancelSignal
- */
-const onSourceClose = createCompatibleEventListener(["sourceclose", "webkitsourceclose"]);
-
-/**
- * @param {MediaSource} mediaSource
- * @param {Function} listener
- * @param {Object} cancelSignal
- */
-const onSourceEnded = createCompatibleEventListener(["sourceended", "webkitsourceended"]);
-
-/**
- * @param {MediaSource} mediaSource
- * @param {Function} listener
- * @param {Object} cancelSignal
- */
-const onSourceBufferUpdate = createCompatibleEventListener(["update"]);
-
-/**
- * @param {SourceBufferList} sourceBuffers
- * @param {Function} listener
- * @param {Object} cancelSignal
- */
-const onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
-
-/**
- * @param {MediaKeySession} mediaKeySession
- */
-const onKeyMessage = createCompatibleEventListener(["keymessage", "message"]);
-
-/**
- * @param {MediaKeySession} mediaKeySession
- */
-const onKeyAdded = createCompatibleEventListener(["keyadded", "ready"]);
-
-/**
- * @param {MediaKeySession} mediaKeySession
- */
-const onKeyError = createCompatibleEventListener(["keyerror", "error"]);
-
-/**
- * @param {MediaKeySession} mediaKeySession
- */
-const onKeyStatusesChange = createCompatibleEventListener(["keystatuseschange"]);
-
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onSeeking = createCompatibleEventListener(["seeking"]);
-
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onSeeked = createCompatibleEventListener(["seeked"]);
-
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onEnded = createCompatibleEventListener(["ended"]);
-
-/**
- * Utilitary function allowing to add an event listener and remove it
- * automatically once the given `CancellationSignal` emits.
- * @param {EventTarget} elt - The element on which should be attached the event
- * listener.
- * @param {string} evt - The event you wish to listen to
- * @param {Function} listener - The listener function
- * @param {Object} stopListening - Removes the event listener once this signal
- * emits
- */
-function addEventListener(
-  elt : IEventEmitterLike,
-  evt : string,
-  listener : (x? : unknown) => void,
-  stopListening : CancellationSignal
-) : void {
-  elt.addEventListener(evt, listener);
-  stopListening.register(() => {
-    elt.removeEventListener(evt, listener);
-  });
-}
-
-export {
-  addEventListener,
-  createCompatibleEventListener,
-  getPageActivityRef,
-  getPictureOnPictureStateRef,
-  getVideoVisibilityRef,
-  getVideoWidthRef,
-  onEnded,
-  onFullscreenChange,
-  onKeyAdded,
-  onKeyError,
-  onKeyMessage,
-  onKeyStatusesChange,
-  onLoadedMetadata,
-  onRemoveSourceBuffers,
-  onSeeked,
-  onSeeking,
-  onSourceClose,
-  onSourceEnded,
-  onSourceOpen,
-  onTimeUpdate,
-  onSourceBufferUpdate,
-  onTextTrackAdded,
-  onTextTrackRemoved,
-};

package/src/compat/fullscreen.ts

@@ -1,87 +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 {
-  ICompatDocument,
-  ICompatHTMLMediaElement,
-} from "./browser_compatibility_types";
-
-/**
- * Request fullScreen action on a given element.
- * @param {HTMLElement} elt
- */
-function requestFullscreen(element : HTMLMediaElement) : void {
-  if (!isFullscreen()) {
-    const elt = element as ICompatHTMLMediaElement;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof elt.requestFullscreen === "function") {
-    /* eslint-enable @typescript-eslint/unbound-method */
-      /* eslint-disable @typescript-eslint/no-floating-promises */
-      elt.requestFullscreen();
-      /* eslint-enable @typescript-eslint/no-floating-promises */
-    } else if (typeof elt.msRequestFullscreen === "function") {
-      elt.msRequestFullscreen();
-    } else if (typeof elt.mozRequestFullScreen === "function") {
-      elt.mozRequestFullScreen();
-    } else if (typeof elt.webkitRequestFullscreen === "function") {
-      (
-        elt.webkitRequestFullscreen as (allowKeybordInput? : boolean) => void
-      )((Element as { ALLOW_KEYBOARD_INPUT? : boolean }).ALLOW_KEYBOARD_INPUT);
-    }
-  }
-}
-
-/**
- * Exit fullscreen if an element is currently in fullscreen.
- */
-function exitFullscreen() : void {
-  if (isFullscreen()) {
-    const doc = document as ICompatDocument;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof doc.exitFullscreen === "function") {
-    /* eslint-enable @typescript-eslint/unbound-method */
-      /* eslint-disable @typescript-eslint/no-floating-promises */
-      doc.exitFullscreen();
-      /* eslint-enable @typescript-eslint/no-floating-promises */
-    } else if (typeof doc.msExitFullscreen === "function") {
-      doc.msExitFullscreen();
-    } else if (typeof doc.mozCancelFullScreen === "function") {
-      doc.mozCancelFullScreen();
-    } else if (typeof doc.webkitExitFullscreen === "function") {
-      doc.webkitExitFullscreen();
-    }
-  }
-}
-
-/**
- * Returns true if an element in the document is being displayed in fullscreen
- * mode;
- * otherwise it's false.
- * @returns {boolean}
- */
-function isFullscreen() : boolean {
-  const doc = document as ICompatDocument;
-  return (doc.fullscreenElement != null ||
-          doc.mozFullScreenElement != null ||
-          doc.webkitFullscreenElement != null ||
-          doc.msFullscreenElement != null);
-}
-
-export {
-  requestFullscreen,
-  exitFullscreen,
-  isFullscreen,
-};

package/src/compat/get_start_date.ts

@@ -1,48 +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.
- */
-
-/**
- * Calculating a live-offseted media position necessitate to obtain first an
- * offset, and then adding that offset to the wanted position.
- *
- * That offset is in most case present inside the Manifest file, yet in cases
- * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
- * won't know that offset.
- *
- * Thankfully Safari declares a `getStartDate` method allowing to obtain that
- * offset when available. This logic is mainly useful when playing HLS contents
- * in directfile mode on Safari.
- * @param {HTMLMediaElement} mediaElement
- * @returns {number|undefined}
- */
-export default function getStartDate(
-  mediaElement : HTMLMediaElement
-) : number | undefined {
-  const _mediaElement : HTMLMediaElement & {
-    getStartDate? : () => number | Date | null | undefined;
-  } = mediaElement;
-  if (typeof _mediaElement.getStartDate === "function") {
-    const startDate = _mediaElement.getStartDate();
-    if (typeof startDate === "object" && startDate !== null) {
-      const startDateNum = +startDate;
-      if (!isNaN(startDateNum)) {
-        return startDateNum / 1000;
-      }
-    } else if (typeof startDate === "number" && !isNaN(startDate)) {
-      return startDate;
-    }
-  }
-}