videojs-mobile-ui 0.8.0 → 0.9.0-beta.3

package/dist/videojs-mobile-ui.js

@@ -1,68 +1,41 @@
-/*! @name videojs-mobile-ui @version 0.8.0 @license MIT */
+/*! @name videojs-mobile-ui @version 0.9.0-beta.3 @license MIT */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('video.js'), require('global/window')) :
-  typeof define === 'function' && define.amd ? define(['video.js', 'global/window'], 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 = "0.8.0";
+  var version = "0.9.0-beta.3";
 
-  function createCommonjsModule(fn, basedir, module) {
-  	return module = {
-  	  path: basedir,
-  	  exports: {},
-  	  require: function (path, base) {
-        return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-      }
-  	}, fn(module, module.exports), module.exports;
-  }
-
-  function commonjsRequire () {
-  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-  }
-
-  var setPrototypeOf = createCommonjsModule(function (module) {
-    function _setPrototypeOf(o, p) {
-      module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-      };
-
-      module.exports["default"] = module.exports, module.exports.__esModule = true;
-      return _setPrototypeOf(o, p);
-    }
-
-    module.exports = _setPrototypeOf;
-    module.exports["default"] = module.exports, module.exports.__esModule = true;
-  });
-
-  var inheritsLoose = createCommonjsModule(function (module) {
-    function _inheritsLoose(subClass, superClass) {
-      subClass.prototype = Object.create(superClass.prototype);
-      subClass.prototype.constructor = subClass;
-      setPrototypeOf(subClass, superClass);
-    }
+  /**
+   * @file touchOverlay.js
+   * Touch UI component
+   */
 
-    module.exports = _inheritsLoose;
-    module.exports["default"] = module.exports, module.exports.__esModule = true;
-  });
+  /** @import Player from 'video.js/dist/types/player' */
+
+  const Component = videojs__default["default"].getComponent('Component');
+  const dom = videojs__default["default"].dom || videojs__default["default"];
+  const debounce = (callback, wait) => {
+    let timeoutId = null;
+    return (...args) => {
+      window.clearTimeout(timeoutId);
+      timeoutId = window.setTimeout(() => {
+        callback.apply(null, args);
+      }, wait);
+    };
+  };
 
-  var Component = videojs__default['default'].getComponent('Component');
-  var dom = videojs__default['default'].dom || videojs__default['default'];
   /**
    * The `TouchOverlay` is an overlay to capture tap events.
    *
    * @extends Component
    */
-
-  var TouchOverlay = /*#__PURE__*/function (_Component) {
-    inheritsLoose(TouchOverlay, _Component);
-
+  class TouchOverlay extends Component {
     /**
     * Creates an instance of the this class.
     *
@@ -72,46 +45,80 @@
     * @param  {Object} [options]
     *         The key/value store of player options.
     */
-    function TouchOverlay(player, options) {
-      var _this;
-
-      _this = _Component.call(this, player, options) || this;
-      _this.seekSeconds = options.seekSeconds;
-      _this.tapTimeout = options.tapTimeout; // Add play toggle overlay
-
-      _this.addChild('playToggle', {}); // Clear overlay when playback starts or with control fade
-
-
-      player.on(['playing', 'userinactive'], function (e) {
-        _this.removeClass('show-play-toggle');
-      }); // A 0 inactivity timeout won't work here
+    constructor(player, options) {
+      super(player, options);
+      this.seekSeconds = options.seekSeconds;
+      this.tapTimeout = options.tapTimeout;
+      this.taps = 0;
+
+      // Add play toggle overlay
+      this.addChild('playToggle', {});
+
+      // Clear overlay when playback starts or with control fade
+      player.on(['playing', 'userinactive'], e => {
+        this.removeClass('show-play-toggle');
+      });
 
-      if (_this.player_.options_.inactivityTimeout === 0) {
-        _this.player_.options_.inactivityTimeout = 5000;
+      // A 0 inactivity timeout won't work here
+      if (this.player_.options_.inactivityTimeout === 0) {
+        this.player_.options_.inactivityTimeout = 5000;
       }
 
-      _this.enable();
+      /**
+       * Debounced tap handler.
+       * Seeks number of (taps - 1) * configured seconds to skip.
+       * One tap is a non-op
+       *
+       * @param {Event} event
+       */
+      this.handleTaps_ = debounce(event => {
+        const increment = (this.taps - 1) * this.seekSeconds;
+        this.taps = 0;
+        if (increment < 1) {
+          return;
+        }
+        const rect = this.el_.getBoundingClientRect();
+        const x = event.changedTouches[0].clientX - rect.left;
+
+        // Check if double tap is in left or right area
+        if (x < rect.width * 0.4) {
+          this.player_.currentTime(Math.max(0, this.player_.currentTime() - increment));
+          this.addClass('reverse');
+        } else if (x > rect.width - rect.width * 0.4) {
+          this.player_.currentTime(Math.min(this.player_.duration(), this.player_.currentTime() + increment));
+          this.removeClass('reverse');
+        } else {
+          return;
+        }
 
-      return _this;
+        // Remove play toggle if showing
+        this.removeClass('show-play-toggle');
+
+        // Remove and readd class to trigger animation
+        this.setAttribute('data-skip-text', `${increment} ${this.localize('seconds')}`);
+        this.removeClass('skip');
+        window.requestAnimationFrame(() => {
+          this.addClass('skip');
+        });
+      }, this.tapTimeout);
+      this.enable();
     }
+
     /**
      * Builds the DOM element.
      *
      * @return {Element}
      *         The DOM element.
      */
-
-
-    var _proto = TouchOverlay.prototype;
-
-    _proto.createEl = function createEl() {
-      var el = dom.createEl('div', {
+    createEl() {
+      const el = dom.createEl('div', {
         className: 'vjs-touch-overlay',
         // Touch overlay is not tabbable.
         tabIndex: -1
       });
       return el;
     }
+
     /**
     * Debounces to either handle a delayed single tap, or a double tap
      *
@@ -119,111 +126,166 @@
      *        The touch event
      *
      */
-    ;
-
-    _proto.handleTap = function handleTap(event) {
-      var _this2 = this;
-
+    handleTap(event) {
       // Don't handle taps on the play button
       if (event.target !== this.el_) {
         return;
       }
-
-      event.preventDefault();
-
-      if (this.firstTapCaptured) {
-        this.firstTapCaptured = false;
-
-        if (this.timeout) {
-          window__default['default'].clearTimeout(this.timeout);
-        }
-
-        this.handleDoubleTap(event);
-      } else {
-        this.firstTapCaptured = true;
-        this.timeout = window__default['default'].setTimeout(function () {
-          _this2.firstTapCaptured = false;
-
-          _this2.handleSingleTap(event);
-        }, this.tapTimeout);
+      if (event.cancelable) {
+        event.preventDefault();
       }
+      this.taps += 1;
+      if (this.taps === 1) {
+        this.removeClass('skip');
+        this.toggleClass('show-play-toggle');
+      }
+      this.handleTaps_(event);
     }
+
     /**
-     * Toggles display of play toggle
-     *
-     * @param {Event} event
-     *        The touch event
-     *
+     * Enables touch handler
      */
-    ;
-
-    _proto.handleSingleTap = function handleSingleTap(event) {
-      this.removeClass('skip');
-      this.toggleClass('show-play-toggle');
+    enable() {
+      this.firstTapCaptured = false;
+      this.on('touchend', this.handleTap);
     }
+
     /**
-     * Seeks by configured number of seconds if left or right part of video double tapped
-     *
-     * @param {Event} event
-     *        The touch event
-     *
+     * Disables touch handler
      */
-    ;
-
-    _proto.handleDoubleTap = function handleDoubleTap(event) {
-      var _this3 = this;
+    disable() {
+      this.off('touchend', this.handleTap);
+    }
+  }
+  Component.registerComponent('TouchOverlay', TouchOverlay);
 
-      var rect = this.el_.getBoundingClientRect();
-      var x = event.changedTouches[0].clientX - rect.left; // Check if double tap is in left or right area
+  /**
+   * Sets up swiping to enter and exit fullscreen.
+   *
+   * @param {Object} player
+   *  The player to initialise on.
+   * @param {Object} 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;
 
-      if (x < rect.width * 0.4) {
-        this.player_.currentTime(Math.max(0, this.player_.currentTime() - this.seekSeconds));
-        this.addClass('reverse');
-      } else if (x > rect.width - rect.width * 0.4) {
-        this.player_.currentTime(Math.min(this.player_.duration(), this.player_.currentTime() + this.seekSeconds));
-        this.removeClass('reverse');
-      } else {
+    /**
+     * 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;
-      } // Remove play toggle if showing
-
-
-      this.removeClass('show-play-toggle'); // Remove and readd class to trigger animation
+      }
+      touchStartY = e.changedTouches[0].clientY;
+      couldBeSwiping = true;
+      player.tech_.el().style.transition = '';
+    };
 
-      this.removeClass('skip');
-      window__default['default'].requestAnimationFrame(function () {
-        _this3.addClass('skip');
-      });
-    }
     /**
-     * Enables touch handler
+     * 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})`;
+      }
+    };
 
-    _proto.enable = function enable() {
-      this.firstTapCaptured = false;
-      this.on('touchend', this.handleTap);
-    }
     /**
-     * Disables touch handler
+     * Monitor the touch end to determine a valid swipe
+     *
+     * @param {TouchEvent} e Triggering touch event
      */
-    ;
-
-    _proto.disable = function disable() {
-      this.off('touchend', this.handleTap);
+    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 = '';
+    });
+  };
 
-    return TouchOverlay;
-  }(Component);
-
-  Component.registerComponent('TouchOverlay', TouchOverlay);
-
-  var defaults = {
+  // Default options for the plugin.
+  const defaults = {
     fullscreen: {
       enterOnRotate: true,
       exitOnRotate: true,
       lockOnRotate: true,
       lockToLandscapeOnEnter: false,
-      iOS: false,
+      swipeToFullscreen: false,
+      swipeFromFullscreen: false,
       disabled: false
     },
     touchControls: {
@@ -233,37 +295,33 @@
       disabled: false
     }
   };
-  var screen = window__default['default'].screen;
+  const screen = window.screen;
+  const registerPlugin = videojs__default["default"].registerPlugin || videojs__default["default"].plugin;
+
   /**
    * Gets 'portrait' or 'lanscape' from the two orientation APIs
    *
    * @return {string} orientation
    */
-
-  var getOrientation = function getOrientation() {
+  const getOrientation = () => {
     if (screen) {
       // Prefer the string over angle, as 0° can be landscape on some tablets
-      var orientationString = ((screen.orientation || {}).type || screen.mozOrientation || screen.msOrientation || '').split('-')[0];
-
+      const orientationString = ((screen.orientation || {}).type || screen.mozOrientation || screen.msOrientation || '').split('-')[0];
       if (orientationString === 'landscape' || orientationString === 'portrait') {
         return orientationString;
       }
-    } // iOS only supports window.orientation
-
+    }
 
-    if (typeof window__default['default'].orientation === 'number') {
-      if (window__default['default'].orientation === 0 || window__default['default'].orientation === 180) {
+    // iOS only supports window.orientation
+    if (typeof window.orientation === 'number') {
+      if (window.orientation === 0 || window.orientation === 180) {
         return 'portrait';
       }
-
       return 'landscape';
     }
-
     return 'portrait';
-  }; // Cross-compatibility for Video.js 5 and 6.
-
+  };
 
-  var registerPlugin = videojs__default['default'].registerPlugin || videojs__default['default'].plugin;
   /**
    * Add UI and event listeners
    *
@@ -271,63 +329,49 @@
    * @param    {Player} player
    *           A Video.js player object.
    *
-   * @param    {Object} [options={}]
+   * @param    {MobileUiOptions} [options={}]
    *           A plain object containing options for the plugin.
    */
-
-  var onPlayerReady = function onPlayerReady(player, options) {
+  const onPlayerReady = (player, options) => {
     player.addClass('vjs-mobile-ui');
-
-    if (options.fullscreen.iOS) {
-      videojs__default['default'].log.warn('videojs-mobile-ui: `fullscreen.iOS` is deprecated. Use Video.js option `preferFullWindow` instead.');
-
-      if (videojs__default['default'].browser.IS_IOS && videojs__default['default'].browser.IOS_VERSION > 9 && !player.el_.ownerDocument.querySelector('.bc-iframe')) {
-        player.tech_.el_.setAttribute('playsinline', 'playsinline');
-
-        player.tech_.supportsFullScreen = function () {
-          return false;
-        };
-      }
-    }
-
     if (!options.touchControls.disabled) {
       if (options.touchControls.disableOnEnd || typeof player.endscreen === 'function') {
         player.addClass('vjs-mobile-ui-disable-end');
-      } // Insert before the control bar
-
+      }
 
-      var controlBarIdx;
-      var versionParts = videojs__default['default'].VERSION.split('.');
-      var major = parseInt(versionParts[0], 10);
-      var minor = parseInt(versionParts[1], 10); // Video.js < 7.7.0 doesn't account for precedding components that don't have elements
+      // Insert before the control bar
+      let controlBarIdx;
+      const versionParts = videojs__default["default"].VERSION.split('.');
+      const major = parseInt(versionParts[0], 10);
+      const minor = parseInt(versionParts[1], 10);
 
+      // Video.js < 7.7.0 doesn't account for precedding components that don't have elements
       if (major < 7 || major === 7 && minor < 7) {
         controlBarIdx = Array.prototype.indexOf.call(player.el_.children, player.getChild('ControlBar').el_);
       } else {
         controlBarIdx = player.children_.indexOf(player.getChild('ControlBar'));
       }
-
       player.touchOverlay = player.addChild('TouchOverlay', options.touchControls, controlBarIdx);
     }
-
     if (options.fullscreen.disabled) {
       return;
     }
-
-    var locked = false;
-
-    var rotationHandler = function rotationHandler() {
-      var currentOrientation = getOrientation();
-
+    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(function () {
+            screen.orientation.lock('landscape').then(() => {
               locked = true;
-            }).catch(function (e) {
-              videojs__default['default'].log('Browser refused orientation lock:', e);
+            }).catch(err => {
+              videojs__default["default"].log.warn('Browser refused orientation lock:', err);
             });
           }
         }
@@ -337,100 +381,60 @@
         }
       }
     };
-
     if (options.fullscreen.enterOnRotate || options.fullscreen.exitOnRotate) {
-      if (videojs__default['default'].browser.IS_IOS) {
-        window__default['default'].addEventListener('orientationchange', rotationHandler);
-        player.on('dispose', function () {
-          window__default['default'].removeEventListener('orientationchange', rotationHandler);
+      if (videojs__default["default"].browser.IS_IOS) {
+        window.addEventListener('orientationchange', rotationHandler);
+        player.on('dispose', () => {
+          window.removeEventListener('orientationchange', rotationHandler);
         });
       } else if (screen.orientation) {
         // addEventListener('orientationchange') is not a user interaction on Android
         screen.orientation.onchange = rotationHandler;
-        player.on('dispose', function () {
+        player.on('dispose', () => {
           screen.orientation.onchange = null;
         });
       }
     }
-
-    player.on('fullscreenchange', function (_) {
+    player.on('fullscreenchange', _ => {
       if (player.isFullscreen() && options.fullscreen.lockToLandscapeOnEnter && getOrientation() === 'portrait') {
-        screen.orientation.lock('landscape').then(function () {
+        screen.orientation.lock('landscape').then(() => {
           locked = true;
-        }).catch(function (e) {
-          videojs__default['default'].log('Browser refused orientation lock:', e);
+        }).catch(e => {
+          videojs__default["default"].log('Browser refused orientation lock:', e);
         });
       } else if (!player.isFullscreen() && locked) {
         screen.orientation.unlock();
         locked = false;
       }
     });
-    player.on('ended', function (_) {
+    player.on('ended', _ => {
       if (locked === true) {
         screen.orientation.unlock();
         locked = false;
       }
     });
   };
+
   /**
-   * 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    {boolean} [options.fullscreen.iOS=false]
-   *           Deprecated: Whether to disable iOS's native fullscreen so controls can work
-   * @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    {Object} [options={}] Plugin options
    */
-
-
-  var mobileUi = function mobileUi(options) {
-    var _this = this;
-
-    if (options === void 0) {
-      options = {};
-    }
-
-    if (options.forceForTesting || videojs__default['default'].browser.IS_ANDROID || videojs__default['default'].browser.IS_IOS) {
-      this.ready(function () {
-        onPlayerReady(_this, videojs__default['default'].mergeOptions(defaults, options));
+  const mobileUi = function (options = {}) {
+    if (options.forceForTesting || videojs__default["default"].browser.IS_ANDROID || videojs__default["default"].browser.IS_IOS) {
+      this.ready(() => {
+        onPlayerReady(this, videojs__default["default"].mergeOptions(defaults, options));
       });
     }
-  }; // Register the plugin with video.js.
-
+  };
 
-  registerPlugin('mobileUi', mobileUi); // Include the version number.
+  // Register the plugin with video.js.
+  registerPlugin('mobileUi', mobileUi);
 
+  // Include the version number.
   mobileUi.VERSION = version;
 
   return mobileUi;
 
-})));
+}));