videojs-mobile-ui 1.2.0-alpha.0 → 1.2.1

package/dist/videojs-mobile-ui.es.js

@@ -1,13 +1,16 @@
-/*! @name videojs-mobile-ui @version 1.2.0-alpha.0 @license MIT */
+/*! @name videojs-mobile-ui @version 1.2.1 @license MIT */
 import videojs from 'video.js';
-import window from '@ungap/global-this';
+import window from 'global/window';
 
-var version = "1.2.0-alpha.0";
+var version = "1.2.1";
 
 /**
  * @file touchOverlay.js
  * Touch UI component
  */
+
+/** @import Player from 'video.js/dist/types/player' */
+
 const Component = videojs.getComponent('Component');
 const dom = videojs.dom || videojs;
 
@@ -23,7 +26,7 @@ class TouchOverlay extends Component {
   * @param  {Player} player
   *         The `Player` that this class should be attached to.
   *
-  * @param  {Object} [options]
+  * @param  {options} [options]
   *         The key/value store of player options.
   */
   constructor(player, options) {
@@ -112,7 +115,9 @@ class TouchOverlay extends Component {
     if (event.target !== this.el_) {
       return;
     }
-    event.preventDefault();
+    if (event.cancelable) {
+      event.preventDefault();
+    }
     this.taps += 1;
     if (this.taps === 1) {
       this.removeClass('skip');
@@ -138,13 +143,184 @@ class TouchOverlay extends Component {
 }
 Component.registerComponent('TouchOverlay', TouchOverlay);
 
-// Default options for the plugin.
+/** @import Player from 'video.js/dist/types/player' */
+/** @import Plugin from 'video.js/dist/types/plugin' */
+/** @import {MobileUiOptions} from './plugin' */
+
+/**
+ * Sets up swiping to enter and exit fullscreen.
+ *
+ * @this {Plugin}
+ * @param {Player} player
+ *  The player to initialise on.
+ * @param {MobileUiOptions} pluginOptions
+ *  The options used by the mobile ui plugin.
+ */
+const initSwipe = (player, pluginOptions) => {
+  const {
+    swipeToFullscreen,
+    swipeFromFullscreen
+  } = pluginOptions.fullscreen;
+  if (swipeToFullscreen) {
+    player.addClass('using-fs-swipe-up');
+  }
+  if (swipeFromFullscreen) {
+    player.addClass('using-fs-swipe-down');
+  }
+  let touchStartY = 0;
+  let couldBeSwiping = false;
+  const swipeThreshold = 30;
+
+  /**
+   * Monitor the possible start of a swipe
+   *
+   * @param {TouchEvent} e Triggering touch event
+   */
+  const onStart = e => {
+    const isFullscreen = player.isFullscreen();
+    if (!isFullscreen && !swipeToFullscreen || isFullscreen && !swipeFromFullscreen) {
+      couldBeSwiping = false;
+      return;
+    }
+    touchStartY = e.changedTouches[0].clientY;
+    couldBeSwiping = true;
+    player.tech_.el().style.transition = '';
+  };
+
+  /**
+   * Monitor the movement of a swipe
+   *
+   * @param {TouchEvent} e Triggering touch event
+   */
+  const onMove = e => {
+    if (!couldBeSwiping) {
+      return;
+    }
+    const currentY = e.touches[0].clientY;
+    const deltaY = touchStartY - currentY;
+    const isFullscreen = player.isFullscreen();
+    let scale = 1;
+    if (!isFullscreen && deltaY > 0) {
+      // Swiping up to enter fullscreen: Zoom in (Max 1.1)
+      scale = 1 + Math.min(0.1, deltaY / 500);
+      player.tech_.el().style.transform = `scale(${scale})`;
+    } else if (isFullscreen && deltaY < 0) {
+      // Swiping down to exit fullscreen: Zoom out (Min 0.9)
+      scale = 1 - Math.min(0.1, Math.abs(deltaY) / 500);
+      player.tech_.el().style.transform = `scale(${scale})`;
+    }
+  };
+
+  /**
+   * Monitor the touch end to determine a valid swipe
+   *
+   * @param {TouchEvent} e Triggering touch event
+   */
+  const onEnd = e => {
+    if (!couldBeSwiping) {
+      return;
+    }
+    couldBeSwiping = false;
+    player.tech_.el().style.transition = 'transform 0.3s ease-out';
+    player.tech_.el().style.transform = 'scale(1)';
+    if (e.type === 'touchcancel') {
+      return;
+    }
+    const touchEndY = e.changedTouches[0].clientY;
+    const deltaY = touchStartY - touchEndY;
+    if (deltaY > swipeThreshold && !player.isFullscreen()) {
+      player.requestFullscreen().catch(err => {
+        player.log.warn('Browser refused fullscreen', err);
+      });
+    } else if (deltaY < -swipeThreshold && player.isFullscreen()) {
+      player.exitFullscreen();
+    }
+  };
+  player.el().addEventListener('touchstart', onStart, {
+    passive: true
+  });
+  player.el().addEventListener('touchmove', onMove, {
+    passive: true
+  });
+  player.el().addEventListener('touchend', onEnd, {
+    passive: true
+  });
+  player.el().addEventListener('touchcancel', onEnd, {
+    passive: true
+  });
+  player.on('dispose', () => {
+    player.el().removeEventListener('touchstart', onStart, {
+      passive: true
+    });
+    player.el().removeEventListener('touchmove', onMove, {
+      passive: true
+    });
+    player.el().removeEventListener('touchend', onEnd, {
+      passive: true
+    });
+    player.el().removeEventListener('touchcancel', onEnd, {
+      passive: true
+    });
+    player.tech_.el().style.transform = '';
+    player.tech_.el().style.transition = '';
+  });
+};
+
+/**
+ * @typedef {Object} MobileUiOptions
+ * @property {Object} [fullscreen]
+ *  Options for fullscreen behaviours.
+ * @property {boolean} [fullscreen.enterOnRotate]
+ *  If the device is rotated, enter fullscreen.
+ *  Default `true`.
+ * @property {boolean} [fullscreen.exitOnRotate]
+ *  If the device is rotated, exit fullscreen, unless `lockOnRotate` is used.
+ *  Default `true`.
+ * @property {boolean} [fullscreen.lockOnRotate]
+ *  When going fullscreen in response to rotation (`enterOnRotate`), also lock the orientation (not supported by iOS).
+ *  Default `true`.
+ * @property {boolean} [fullscreen.lockToLandscapeOnEnter]
+ *  When fullscreen is entered by any means, lock the orientation (not supported by iOS).
+ *  Default `false`.
+ * @property {boolean} [fullscreen.swipeToFullscreen]
+ *  Swipe up to enter fullscreen.
+ *  Default `false`.
+ * @property {boolean} [fullscreen.swipeFromFullscreen]
+ *  Swipe down to exit fullscreen.
+ *  Won't do anything on iOS native fullscreen, which has its own swipe down exit gesture.
+ *  Default `false`.
+ * @property {boolean} [fullscreen.disabled]
+ *  All fullscreen functionality provided by this plugin disabled.
+ *  Default `false`.
+ * @property {Object} [touchControls]
+ *  Options for tap overlay.
+ * @property {number} [touchControls.seekSeconds]
+ *  Increment to seek in seconds.
+ *  Default `10`.
+ * @property {number} [touchControls.tapTimeout]
+ *  Timeout to consider multiple taps as double rather than two single.
+ *  Default `300`.
+ * @property {boolean} [touchControls.disableOnEnd]
+ *  Disable the touch overlay when the video ends.
+ *  Useful if an end screen overlay is used to avoid conflict.
+ *  Default `false`.
+ * @property {boolean} [touchControls.disabled]
+ *  All tap overlay functionality provided by this plugin disabled.
+ *  Default `false`.
+ * @internal
+ * @property {boolean} [forceForTesting]
+ *  Used in unit tests
+ */
+
+/** @type {MobileUiOptions} */
 const defaults = {
   fullscreen: {
     enterOnRotate: true,
     exitOnRotate: true,
     lockOnRotate: true,
     lockToLandscapeOnEnter: false,
+    swipeToFullscreen: false,
+    swipeFromFullscreen: false,
     disabled: false
   },
   touchControls: {
@@ -187,7 +363,7 @@ const getOrientation = () => {
  * @param    {Player} player
  *           A Video.js player object.
  *
- * @param    {Object} [options={}]
+ * @param    {MobileUiOptions} [options={}]
  *           A plain object containing options for the plugin.
  */
 const onPlayerReady = (player, options) => {
@@ -204,17 +380,22 @@ const onPlayerReady = (player, options) => {
   if (options.fullscreen.disabled) {
     return;
   }
+  if (options.fullscreen.swipeToFullscreen || options.fullscreen.swipeFromFullscreen) {
+    initSwipe(player, options);
+  }
   let locked = false;
   const rotationHandler = () => {
     const currentOrientation = getOrientation();
     if (currentOrientation === 'landscape' && options.fullscreen.enterOnRotate) {
-      if (player.paused() === false) {
-        player.requestFullscreen();
+      if (!player.paused() && !player.isFullscreen()) {
+        player.requestFullscreen().catch(err => {
+          player.log.warn('Browser refused fullscreen request:', err);
+        });
         if ((options.fullscreen.lockOnRotate || options.fullscreen.lockToLandscapeOnEnter) && screen.orientation && screen.orientation.lock) {
           screen.orientation.lock('landscape').then(() => {
             locked = true;
-          }).catch(e => {
-            videojs.log('Browser refused orientation lock:', e);
+          }).catch(err => {
+            videojs.log.warn('Browser refused orientation lock:', err);
           });
         }
       }
@@ -239,6 +420,7 @@ const onPlayerReady = (player, options) => {
     }
   }
   player.on('fullscreenchange', _ => {
+    player.log('fullscreenchange', player.isFullscreen(), options.fullscreen.lockToLandscapeOnEnter, getOrientation());
     if (player.isFullscreen() && options.fullscreen.lockToLandscapeOnEnter && getOrientation() === 'portrait') {
       screen.orientation.lock('landscape').then(() => {
         locked = true;
@@ -259,40 +441,10 @@ const onPlayerReady = (player, options) => {
 };
 
 /**
- * A video.js plugin.
- *
- * Adds a monile UI for player control, and fullscreen orientation control
+ * Adds a mobile UI for player control, and fullscreen orientation control
  *
  * @function mobileUi
- * @param    {Object} [options={}]
- *           Plugin options.
- * @param    {boolean} [options.forceForTesting=false]
- *           Enables the display regardless of user agent, for testing purposes
- * @param    {Object} [options.fullscreen={}]
- *           Fullscreen options.
- * @param    {boolean} [options.fullscreen.disabled=false]
- *           If true no fullscreen handling except the *deprecated* iOS fullwindow hack
- * @param    {boolean} [options.fullscreen.enterOnRotate=true]
- *           Whether to go fullscreen when rotating to landscape
- * @param    {boolean} [options.fullscreen.exitOnRotate=true]
- *           Whether to leave fullscreen when rotating to portrait (if not locked)
- * @param    {boolean} [options.fullscreen.lockOnRotate=true]
- *           Whether to lock orientation when rotating to landscape
- *           Unlocked when exiting fullscreen or on 'ended
- * @param    {boolean} [options.fullscreen.lockToLandscapeOnEnter=false]
- *           Whether to always lock orientation to landscape on fullscreen mode
- *           Unlocked when exiting fullscreen or on 'ended'
- * @param    {Object} [options.touchControls={}]
- *           Touch UI options.
- * @param    {boolean} [options.touchControls.disabled=false]
- *           If true no touch controls are added.
- * @param    {int} [options.touchControls.seekSeconds=10]
- *           Number of seconds to seek on double-tap
- * @param    {int} [options.touchControls.tapTimeout=300]
- *           Interval in ms to be considered a doubletap
- * @param    {boolean} [options.touchControls.disableOnEnd=false]
- *           Whether to disable when the video ends (e.g., if there is an endscreen)
- *           Never shows if the endscreen plugin is present
+ * @param    {MobileUiOptions} [options={}] Plugin options
  */
 const mobileUi = function (options = {}) {
   if (options.forceForTesting || videojs.browser.IS_ANDROID || videojs.browser.IS_IOS) {

package/dist/videojs-mobile-ui.js

@@ -1,21 +1,23 @@
-/*! @name videojs-mobile-ui @version 1.2.0-alpha.0 @license MIT */
+/*! @name videojs-mobile-ui @version 1.2.1 @license MIT */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('video.js'), require('@ungap/global-this')) :
-  typeof define === 'function' && define.amd ? define(['video.js', '@ungap/global-this'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.videojsMobileUi = factory(global.videojs, global.window));
-})(this, (function (videojs, window) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('video.js')) :
+  typeof define === 'function' && define.amd ? define(['video.js'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.videojsMobileUi = factory(global.videojs));
+})(this, (function (videojs) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   var videojs__default = /*#__PURE__*/_interopDefaultLegacy(videojs);
-  var window__default = /*#__PURE__*/_interopDefaultLegacy(window);
 
-  var version = "1.2.0-alpha.0";
+  var version = "1.2.1";
 
   /**
    * @file touchOverlay.js
    * Touch UI component
    */
+
+  /** @import Player from 'video.js/dist/types/player' */
+
   const Component = videojs__default["default"].getComponent('Component');
   const dom = videojs__default["default"].dom || videojs__default["default"];
 
@@ -31,7 +33,7 @@
     * @param  {Player} player
     *         The `Player` that this class should be attached to.
     *
-    * @param  {Object} [options]
+    * @param  {options} [options]
     *         The key/value store of player options.
     */
     constructor(player, options) {
@@ -86,7 +88,7 @@
         // Remove and readd class to trigger animation
         this.setAttribute('data-skip-text', `${increment} ${this.localize('seconds')}`);
         this.removeClass('skip');
-        window__default["default"].requestAnimationFrame(() => {
+        window.requestAnimationFrame(() => {
           this.addClass('skip');
         });
       }, this.tapTimeout);
@@ -120,7 +122,9 @@
       if (event.target !== this.el_) {
         return;
       }
-      event.preventDefault();
+      if (event.cancelable) {
+        event.preventDefault();
+      }
       this.taps += 1;
       if (this.taps === 1) {
         this.removeClass('skip');
@@ -146,13 +150,184 @@
   }
   Component.registerComponent('TouchOverlay', TouchOverlay);
 
-  // Default options for the plugin.
+  /** @import Player from 'video.js/dist/types/player' */
+  /** @import Plugin from 'video.js/dist/types/plugin' */
+  /** @import {MobileUiOptions} from './plugin' */
+
+  /**
+   * Sets up swiping to enter and exit fullscreen.
+   *
+   * @this {Plugin}
+   * @param {Player} player
+   *  The player to initialise on.
+   * @param {MobileUiOptions} pluginOptions
+   *  The options used by the mobile ui plugin.
+   */
+  const initSwipe = (player, pluginOptions) => {
+    const {
+      swipeToFullscreen,
+      swipeFromFullscreen
+    } = pluginOptions.fullscreen;
+    if (swipeToFullscreen) {
+      player.addClass('using-fs-swipe-up');
+    }
+    if (swipeFromFullscreen) {
+      player.addClass('using-fs-swipe-down');
+    }
+    let touchStartY = 0;
+    let couldBeSwiping = false;
+    const swipeThreshold = 30;
+
+    /**
+     * Monitor the possible start of a swipe
+     *
+     * @param {TouchEvent} e Triggering touch event
+     */
+    const onStart = e => {
+      const isFullscreen = player.isFullscreen();
+      if (!isFullscreen && !swipeToFullscreen || isFullscreen && !swipeFromFullscreen) {
+        couldBeSwiping = false;
+        return;
+      }
+      touchStartY = e.changedTouches[0].clientY;
+      couldBeSwiping = true;
+      player.tech_.el().style.transition = '';
+    };
+
+    /**
+     * Monitor the movement of a swipe
+     *
+     * @param {TouchEvent} e Triggering touch event
+     */
+    const onMove = e => {
+      if (!couldBeSwiping) {
+        return;
+      }
+      const currentY = e.touches[0].clientY;
+      const deltaY = touchStartY - currentY;
+      const isFullscreen = player.isFullscreen();
+      let scale = 1;
+      if (!isFullscreen && deltaY > 0) {
+        // Swiping up to enter fullscreen: Zoom in (Max 1.1)
+        scale = 1 + Math.min(0.1, deltaY / 500);
+        player.tech_.el().style.transform = `scale(${scale})`;
+      } else if (isFullscreen && deltaY < 0) {
+        // Swiping down to exit fullscreen: Zoom out (Min 0.9)
+        scale = 1 - Math.min(0.1, Math.abs(deltaY) / 500);
+        player.tech_.el().style.transform = `scale(${scale})`;
+      }
+    };
+
+    /**
+     * Monitor the touch end to determine a valid swipe
+     *
+     * @param {TouchEvent} e Triggering touch event
+     */
+    const onEnd = e => {
+      if (!couldBeSwiping) {
+        return;
+      }
+      couldBeSwiping = false;
+      player.tech_.el().style.transition = 'transform 0.3s ease-out';
+      player.tech_.el().style.transform = 'scale(1)';
+      if (e.type === 'touchcancel') {
+        return;
+      }
+      const touchEndY = e.changedTouches[0].clientY;
+      const deltaY = touchStartY - touchEndY;
+      if (deltaY > swipeThreshold && !player.isFullscreen()) {
+        player.requestFullscreen().catch(err => {
+          player.log.warn('Browser refused fullscreen', err);
+        });
+      } else if (deltaY < -swipeThreshold && player.isFullscreen()) {
+        player.exitFullscreen();
+      }
+    };
+    player.el().addEventListener('touchstart', onStart, {
+      passive: true
+    });
+    player.el().addEventListener('touchmove', onMove, {
+      passive: true
+    });
+    player.el().addEventListener('touchend', onEnd, {
+      passive: true
+    });
+    player.el().addEventListener('touchcancel', onEnd, {
+      passive: true
+    });
+    player.on('dispose', () => {
+      player.el().removeEventListener('touchstart', onStart, {
+        passive: true
+      });
+      player.el().removeEventListener('touchmove', onMove, {
+        passive: true
+      });
+      player.el().removeEventListener('touchend', onEnd, {
+        passive: true
+      });
+      player.el().removeEventListener('touchcancel', onEnd, {
+        passive: true
+      });
+      player.tech_.el().style.transform = '';
+      player.tech_.el().style.transition = '';
+    });
+  };
+
+  /**
+   * @typedef {Object} MobileUiOptions
+   * @property {Object} [fullscreen]
+   *  Options for fullscreen behaviours.
+   * @property {boolean} [fullscreen.enterOnRotate]
+   *  If the device is rotated, enter fullscreen.
+   *  Default `true`.
+   * @property {boolean} [fullscreen.exitOnRotate]
+   *  If the device is rotated, exit fullscreen, unless `lockOnRotate` is used.
+   *  Default `true`.
+   * @property {boolean} [fullscreen.lockOnRotate]
+   *  When going fullscreen in response to rotation (`enterOnRotate`), also lock the orientation (not supported by iOS).
+   *  Default `true`.
+   * @property {boolean} [fullscreen.lockToLandscapeOnEnter]
+   *  When fullscreen is entered by any means, lock the orientation (not supported by iOS).
+   *  Default `false`.
+   * @property {boolean} [fullscreen.swipeToFullscreen]
+   *  Swipe up to enter fullscreen.
+   *  Default `false`.
+   * @property {boolean} [fullscreen.swipeFromFullscreen]
+   *  Swipe down to exit fullscreen.
+   *  Won't do anything on iOS native fullscreen, which has its own swipe down exit gesture.
+   *  Default `false`.
+   * @property {boolean} [fullscreen.disabled]
+   *  All fullscreen functionality provided by this plugin disabled.
+   *  Default `false`.
+   * @property {Object} [touchControls]
+   *  Options for tap overlay.
+   * @property {number} [touchControls.seekSeconds]
+   *  Increment to seek in seconds.
+   *  Default `10`.
+   * @property {number} [touchControls.tapTimeout]
+   *  Timeout to consider multiple taps as double rather than two single.
+   *  Default `300`.
+   * @property {boolean} [touchControls.disableOnEnd]
+   *  Disable the touch overlay when the video ends.
+   *  Useful if an end screen overlay is used to avoid conflict.
+   *  Default `false`.
+   * @property {boolean} [touchControls.disabled]
+   *  All tap overlay functionality provided by this plugin disabled.
+   *  Default `false`.
+   * @internal
+   * @property {boolean} [forceForTesting]
+   *  Used in unit tests
+   */
+
+  /** @type {MobileUiOptions} */
   const defaults = {
     fullscreen: {
       enterOnRotate: true,
       exitOnRotate: true,
       lockOnRotate: true,
       lockToLandscapeOnEnter: false,
+      swipeToFullscreen: false,
+      swipeFromFullscreen: false,
       disabled: false
     },
     touchControls: {
@@ -162,7 +337,7 @@
       disabled: false
     }
   };
-  const screen = window__default["default"].screen;
+  const screen = window.screen;
 
   /**
    * Gets 'portrait' or 'lanscape' from the two orientation APIs
@@ -179,8 +354,8 @@
     }
 
     // iOS only supports window.orientation
-    if (typeof window__default["default"].orientation === 'number') {
-      if (window__default["default"].orientation === 0 || window__default["default"].orientation === 180) {
+    if (typeof window.orientation === 'number') {
+      if (window.orientation === 0 || window.orientation === 180) {
         return 'portrait';
       }
       return 'landscape';
@@ -195,7 +370,7 @@
    * @param    {Player} player
    *           A Video.js player object.
    *
-   * @param    {Object} [options={}]
+   * @param    {MobileUiOptions} [options={}]
    *           A plain object containing options for the plugin.
    */
   const onPlayerReady = (player, options) => {
@@ -212,17 +387,22 @@
     if (options.fullscreen.disabled) {
       return;
     }
+    if (options.fullscreen.swipeToFullscreen || options.fullscreen.swipeFromFullscreen) {
+      initSwipe(player, options);
+    }
     let locked = false;
     const rotationHandler = () => {
       const currentOrientation = getOrientation();
       if (currentOrientation === 'landscape' && options.fullscreen.enterOnRotate) {
-        if (player.paused() === false) {
-          player.requestFullscreen();
+        if (!player.paused() && !player.isFullscreen()) {
+          player.requestFullscreen().catch(err => {
+            player.log.warn('Browser refused fullscreen request:', err);
+          });
           if ((options.fullscreen.lockOnRotate || options.fullscreen.lockToLandscapeOnEnter) && screen.orientation && screen.orientation.lock) {
             screen.orientation.lock('landscape').then(() => {
               locked = true;
-            }).catch(e => {
-              videojs__default["default"].log('Browser refused orientation lock:', e);
+            }).catch(err => {
+              videojs__default["default"].log.warn('Browser refused orientation lock:', err);
             });
           }
         }
@@ -234,9 +414,9 @@
     };
     if (options.fullscreen.enterOnRotate || options.fullscreen.exitOnRotate) {
       if (videojs__default["default"].browser.IS_IOS) {
-        window__default["default"].addEventListener('orientationchange', rotationHandler);
+        window.addEventListener('orientationchange', rotationHandler);
         player.on('dispose', () => {
-          window__default["default"].removeEventListener('orientationchange', rotationHandler);
+          window.removeEventListener('orientationchange', rotationHandler);
         });
       } else if (screen.orientation) {
         // addEventListener('orientationchange') is not a user interaction on Android
@@ -247,6 +427,7 @@
       }
     }
     player.on('fullscreenchange', _ => {
+      player.log('fullscreenchange', player.isFullscreen(), options.fullscreen.lockToLandscapeOnEnter, getOrientation());
       if (player.isFullscreen() && options.fullscreen.lockToLandscapeOnEnter && getOrientation() === 'portrait') {
         screen.orientation.lock('landscape').then(() => {
           locked = true;
@@ -267,40 +448,10 @@
   };
 
   /**
-   * A video.js plugin.
-   *
-   * Adds a monile UI for player control, and fullscreen orientation control
+   * Adds a mobile UI for player control, and fullscreen orientation control
    *
    * @function mobileUi
-   * @param    {Object} [options={}]
-   *           Plugin options.
-   * @param    {boolean} [options.forceForTesting=false]
-   *           Enables the display regardless of user agent, for testing purposes
-   * @param    {Object} [options.fullscreen={}]
-   *           Fullscreen options.
-   * @param    {boolean} [options.fullscreen.disabled=false]
-   *           If true no fullscreen handling except the *deprecated* iOS fullwindow hack
-   * @param    {boolean} [options.fullscreen.enterOnRotate=true]
-   *           Whether to go fullscreen when rotating to landscape
-   * @param    {boolean} [options.fullscreen.exitOnRotate=true]
-   *           Whether to leave fullscreen when rotating to portrait (if not locked)
-   * @param    {boolean} [options.fullscreen.lockOnRotate=true]
-   *           Whether to lock orientation when rotating to landscape
-   *           Unlocked when exiting fullscreen or on 'ended
-   * @param    {boolean} [options.fullscreen.lockToLandscapeOnEnter=false]
-   *           Whether to always lock orientation to landscape on fullscreen mode
-   *           Unlocked when exiting fullscreen or on 'ended'
-   * @param    {Object} [options.touchControls={}]
-   *           Touch UI options.
-   * @param    {boolean} [options.touchControls.disabled=false]
-   *           If true no touch controls are added.
-   * @param    {int} [options.touchControls.seekSeconds=10]
-   *           Number of seconds to seek on double-tap
-   * @param    {int} [options.touchControls.tapTimeout=300]
-   *           Interval in ms to be considered a doubletap
-   * @param    {boolean} [options.touchControls.disableOnEnd=false]
-   *           Whether to disable when the video ends (e.g., if there is an endscreen)
-   *           Never shows if the endscreen plugin is present
+   * @param    {MobileUiOptions} [options={}] Plugin options
    */
   const mobileUi = function (options = {}) {
     if (options.forceForTesting || videojs__default["default"].browser.IS_ANDROID || videojs__default["default"].browser.IS_IOS) {