@antmedia/web_player 2.8.0-SNAPSHOT

package/dist/videojs-contrib-quality-levels.es-ef3cec9e.js

@@ -0,0 +1,289 @@
+'use strict';
+
+var video_es = require('./video.es-72122d04.js');
+require('./_commonjsHelpers-ed042b00.js');
+
+/*! @name videojs-contrib-quality-levels @version 2.2.1 @license Apache-2.0 */
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+
+/**
+ * A single QualityLevel.
+ *
+ * interface QualityLevel {
+ *   readonly attribute DOMString id;
+ *            attribute DOMString label;
+ *   readonly attribute long width;
+ *   readonly attribute long height;
+ *   readonly attribute long bitrate;
+ *            attribute boolean enabled;
+ * };
+ *
+ * @class QualityLevel
+ */
+var QualityLevel =
+/**
+ * Creates a QualityLevel
+ *
+ * @param {Representation|Object} representation The representation of the quality level
+ * @param {string}   representation.id        Unique id of the QualityLevel
+ * @param {number=}  representation.width     Resolution width of the QualityLevel
+ * @param {number=}  representation.height    Resolution height of the QualityLevel
+ * @param {number}   representation.bandwidth Bitrate of the QualityLevel
+ * @param {number=}  representation.frameRate Frame-rate of the QualityLevel
+ * @param {Function} representation.enabled   Callback to enable/disable QualityLevel
+ */
+function QualityLevel(representation) {
+  var level = this; // eslint-disable-line
+
+  level.id = representation.id;
+  level.label = level.id;
+  level.width = representation.width;
+  level.height = representation.height;
+  level.bitrate = representation.bandwidth;
+  level.frameRate = representation.frameRate;
+  level.enabled_ = representation.enabled;
+  Object.defineProperty(level, 'enabled', {
+    /**
+     * Get whether the QualityLevel is enabled.
+     *
+     * @return {boolean} True if the QualityLevel is enabled.
+     */
+    get: function get() {
+      return level.enabled_();
+    },
+    /**
+     * Enable or disable the QualityLevel.
+     *
+     * @param {boolean} enable true to enable QualityLevel, false to disable.
+     */
+    set: function set(enable) {
+      level.enabled_(enable);
+    }
+  });
+  return level;
+};
+
+/**
+ * A list of QualityLevels.
+ *
+ * interface QualityLevelList : EventTarget {
+ *   getter QualityLevel (unsigned long index);
+ *   readonly attribute unsigned long length;
+ *   readonly attribute long selectedIndex;
+ *
+ *   void addQualityLevel(QualityLevel qualityLevel)
+ *   void removeQualityLevel(QualityLevel remove)
+ *   QualityLevel? getQualityLevelById(DOMString id);
+ *
+ *   attribute EventHandler onchange;
+ *   attribute EventHandler onaddqualitylevel;
+ *   attribute EventHandler onremovequalitylevel;
+ * };
+ *
+ * @extends videojs.EventTarget
+ * @class QualityLevelList
+ */
+
+var QualityLevelList = /*#__PURE__*/
+function (_videojs$EventTarget) {
+  _inheritsLoose(QualityLevelList, _videojs$EventTarget);
+  function QualityLevelList() {
+    var _this;
+    _this = _videojs$EventTarget.call(this) || this;
+    var list = _assertThisInitialized(_assertThisInitialized(_this)); // eslint-disable-line
+
+    list.levels_ = [];
+    list.selectedIndex_ = -1;
+    /**
+     * Get the index of the currently selected QualityLevel.
+     *
+     * @returns {number} The index of the selected QualityLevel. -1 if none selected.
+     * @readonly
+     */
+
+    Object.defineProperty(list, 'selectedIndex', {
+      get: function get() {
+        return list.selectedIndex_;
+      }
+    });
+    /**
+     * Get the length of the list of QualityLevels.
+     *
+     * @returns {number} The length of the list.
+     * @readonly
+     */
+
+    Object.defineProperty(list, 'length', {
+      get: function get() {
+        return list.levels_.length;
+      }
+    });
+    return list || _assertThisInitialized(_this);
+  }
+  /**
+   * Adds a quality level to the list.
+   *
+   * @param {Representation|Object} representation The representation of the quality level
+   * @param {string}   representation.id        Unique id of the QualityLevel
+   * @param {number=}  representation.width     Resolution width of the QualityLevel
+   * @param {number=}  representation.height    Resolution height of the QualityLevel
+   * @param {number}   representation.bandwidth Bitrate of the QualityLevel
+   * @param {number=}  representation.frameRate Frame-rate of the QualityLevel
+   * @param {Function} representation.enabled   Callback to enable/disable QualityLevel
+   * @return {QualityLevel} the QualityLevel added to the list
+   * @method addQualityLevel
+   */
+
+  var _proto = QualityLevelList.prototype;
+  _proto.addQualityLevel = function addQualityLevel(representation) {
+    var qualityLevel = this.getQualityLevelById(representation.id); // Do not add duplicate quality levels
+
+    if (qualityLevel) {
+      return qualityLevel;
+    }
+    var index = this.levels_.length;
+    qualityLevel = new QualityLevel(representation);
+    if (!('' + index in this)) {
+      Object.defineProperty(this, index, {
+        get: function get() {
+          return this.levels_[index];
+        }
+      });
+    }
+    this.levels_.push(qualityLevel);
+    this.trigger({
+      qualityLevel: qualityLevel,
+      type: 'addqualitylevel'
+    });
+    return qualityLevel;
+  };
+  /**
+   * Removes a quality level from the list.
+   *
+   * @param {QualityLevel} remove QualityLevel to remove to the list.
+   * @return {QualityLevel|null} the QualityLevel removed or null if nothing removed
+   * @method removeQualityLevel
+   */
+
+  _proto.removeQualityLevel = function removeQualityLevel(qualityLevel) {
+    var removed = null;
+    for (var i = 0, l = this.length; i < l; i++) {
+      if (this[i] === qualityLevel) {
+        removed = this.levels_.splice(i, 1)[0];
+        if (this.selectedIndex_ === i) {
+          this.selectedIndex_ = -1;
+        } else if (this.selectedIndex_ > i) {
+          this.selectedIndex_--;
+        }
+        break;
+      }
+    }
+    if (removed) {
+      this.trigger({
+        qualityLevel: qualityLevel,
+        type: 'removequalitylevel'
+      });
+    }
+    return removed;
+  };
+  /**
+   * Searches for a QualityLevel with the given id.
+   *
+   * @param {string} id The id of the QualityLevel to find.
+   * @return {QualityLevel|null} The QualityLevel with id, or null if not found.
+   * @method getQualityLevelById
+   */
+
+  _proto.getQualityLevelById = function getQualityLevelById(id) {
+    for (var i = 0, l = this.length; i < l; i++) {
+      var level = this[i];
+      if (level.id === id) {
+        return level;
+      }
+    }
+    return null;
+  };
+  /**
+   * Resets the list of QualityLevels to empty
+   *
+   * @method dispose
+   */
+
+  _proto.dispose = function dispose() {
+    this.selectedIndex_ = -1;
+    this.levels_.length = 0;
+  };
+  return QualityLevelList;
+}(video_es.videojs.EventTarget);
+/**
+ * change - The selected QualityLevel has changed.
+ * addqualitylevel - A QualityLevel has been added to the QualityLevelList.
+ * removequalitylevel - A QualityLevel has been removed from the QualityLevelList.
+ */
+
+QualityLevelList.prototype.allowedEvents_ = {
+  change: 'change',
+  addqualitylevel: 'addqualitylevel',
+  removequalitylevel: 'removequalitylevel'
+}; // emulate attribute EventHandler support to allow for feature detection
+
+for (var event in QualityLevelList.prototype.allowedEvents_) {
+  QualityLevelList.prototype['on' + event] = null;
+}
+var version = "2.2.1";
+var registerPlugin = video_es.videojs.registerPlugin || video_es.videojs.plugin;
+/**
+ * Initialization function for the qualityLevels plugin. Sets up the QualityLevelList and
+ * event handlers.
+ *
+ * @param {Player} player Player object.
+ * @param {Object} options Plugin options object.
+ * @function initPlugin
+ */
+
+var initPlugin = function initPlugin(player, options) {
+  var originalPluginFn = player.qualityLevels;
+  var qualityLevelList = new QualityLevelList();
+  var disposeHandler = function disposeHandler() {
+    qualityLevelList.dispose();
+    player.qualityLevels = originalPluginFn;
+    player.off('dispose', disposeHandler);
+  };
+  player.on('dispose', disposeHandler);
+  player.qualityLevels = function () {
+    return qualityLevelList;
+  };
+  player.qualityLevels.VERSION = version;
+  return qualityLevelList;
+};
+/**
+ * A video.js plugin.
+ *
+ * In the plugin function, the value of `this` is a video.js `Player`
+ * instance. You cannot rely on the player being in a "ready" state here,
+ * depending on how the plugin is invoked. This may or may not be important
+ * to you; if not, remove the wait for "ready"!
+ *
+ * @param {Object} options Plugin options object
+ * @function qualityLevels
+ */
+
+var qualityLevels = function qualityLevels(options) {
+  return initPlugin(this, video_es.videojs.mergeOptions({}, options));
+}; // Register the plugin with video.js.
+
+registerPlugin('qualityLevels', qualityLevels); // Include the version number.
+
+qualityLevels.VERSION = version;
+
+exports.default = qualityLevels;

package/dist/videojs-hls-quality-selector.es-562309df.js

@@ -0,0 +1,393 @@
+'use strict';
+
+var video_es = require('./video.es-72122d04.js');
+require('./_commonjsHelpers-ed042b00.js');
+
+var version = "1.1.4";
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+  return typeof obj;
+} : function (obj) {
+  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+};
+var classCallCheck = function (instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+};
+var inherits = function (subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+};
+var possibleConstructorReturn = function (self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+};
+var VideoJsButtonClass = video_es.videojs.getComponent('MenuButton');
+var VideoJsMenuClass = video_es.videojs.getComponent('Menu');
+var VideoJsComponent = video_es.videojs.getComponent('Component');
+var Dom = video_es.videojs.dom;
+
+/**
+ * Convert string to title case.
+ *
+ * @param {string} string - the string to convert
+ * @return {string} the returned titlecase string
+ */
+function toTitleCase(string) {
+  if (typeof string !== 'string') {
+    return string;
+  }
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+/**
+ * Extend vjs button class for quality button.
+ */
+
+var ConcreteButton = function (_VideoJsButtonClass) {
+  inherits(ConcreteButton, _VideoJsButtonClass);
+
+  /**
+   * Button constructor.
+   *
+   * @param {Player} player - videojs player instance
+   */
+  function ConcreteButton(player) {
+    classCallCheck(this, ConcreteButton);
+    return possibleConstructorReturn(this, _VideoJsButtonClass.call(this, player, {
+      title: player.localize('Quality'),
+      name: 'QualityButton'
+    }));
+  }
+
+  /**
+   * Creates button items.
+   *
+   * @return {Array} - Button items
+   */
+
+  ConcreteButton.prototype.createItems = function createItems() {
+    return [];
+  };
+
+  /**
+   * Create the menu and add all items to it.
+   *
+   * @return {Menu}
+   *         The constructed menu
+   */
+
+  ConcreteButton.prototype.createMenu = function createMenu() {
+    var menu = new VideoJsMenuClass(this.player_, {
+      menuButton: this
+    });
+    this.hideThreshold_ = 0;
+
+    // Add a title list item to the top
+    if (this.options_.title) {
+      var titleEl = Dom.createEl('li', {
+        className: 'vjs-menu-title',
+        innerHTML: toTitleCase(this.options_.title),
+        tabIndex: -1
+      });
+      var titleComponent = new VideoJsComponent(this.player_, {
+        el: titleEl
+      });
+      this.hideThreshold_ += 1;
+      menu.addItem(titleComponent);
+    }
+    this.items = this.createItems();
+    if (this.items) {
+      // Add menu items to the menu
+      for (var i = 0; i < this.items.length; i++) {
+        menu.addItem(this.items[i]);
+      }
+    }
+    return menu;
+  };
+  return ConcreteButton;
+}(VideoJsButtonClass);
+
+// Concrete classes
+var VideoJsMenuItemClass = video_es.videojs.getComponent('MenuItem');
+
+/**
+ * Extend vjs menu item class.
+ */
+
+var ConcreteMenuItem = function (_VideoJsMenuItemClass) {
+  inherits(ConcreteMenuItem, _VideoJsMenuItemClass);
+
+  /**
+   * Menu item constructor.
+   *
+   * @param {Player} player - vjs player
+   * @param {Object} item - Item object
+   * @param {ConcreteButton} qualityButton - The containing button.
+   * @param {HlsQualitySelectorPlugin} plugin - This plugin instance.
+   */
+  function ConcreteMenuItem(player, item, qualityButton, plugin) {
+    classCallCheck(this, ConcreteMenuItem);
+    var _this = possibleConstructorReturn(this, _VideoJsMenuItemClass.call(this, player, {
+      label: item.label,
+      selectable: true,
+      selected: item.selected || false
+    }));
+    _this.item = item;
+    _this.qualityButton = qualityButton;
+    _this.plugin = plugin;
+    return _this;
+  }
+
+  /**
+   * Click event for menu item.
+   */
+
+  ConcreteMenuItem.prototype.handleClick = function handleClick() {
+    // Reset other menu items selected status.
+    for (var i = 0; i < this.qualityButton.items.length; ++i) {
+      this.qualityButton.items[i].selected(false);
+    }
+
+    // Set this menu item to selected, and set quality.
+    this.plugin.setQuality(this.item.value);
+    this.selected(true);
+  };
+  return ConcreteMenuItem;
+}(VideoJsMenuItemClass);
+
+// Default options for the plugin.
+var defaults = {};
+
+// Cross-compatibility for Video.js 5 and 6.
+var registerPlugin = video_es.videojs.registerPlugin || video_es.videojs.plugin;
+// const dom = videojs.dom || videojs;
+
+/**
+ * VideoJS HLS Quality Selector Plugin class.
+ */
+
+var HlsQualitySelectorPlugin = function () {
+  /**
+   * Plugin Constructor.
+   *
+   * @param {Player} player - The videojs player instance.
+   * @param {Object} options - The plugin options.
+   */
+  function HlsQualitySelectorPlugin(player, options) {
+    classCallCheck(this, HlsQualitySelectorPlugin);
+    this.player = player;
+    this.config = options;
+
+    // If there is quality levels plugin and the HLS tech exists
+    // then continue.
+    if (this.player.qualityLevels && this.getHls()) {
+      // Create the quality button.
+      this.createQualityButton();
+      this.bindPlayerEvents();
+    }
+  }
+
+  /**
+   * Returns HLS Plugin
+   *
+   * @return {*} - videojs-hls-contrib plugin.
+   */
+
+  HlsQualitySelectorPlugin.prototype.getHls = function getHls() {
+    return this.player.tech({
+      IWillNotUseThisInPlugins: true
+    }).hls;
+  };
+
+  /**
+   * Binds listener for quality level changes.
+   */
+
+  HlsQualitySelectorPlugin.prototype.bindPlayerEvents = function bindPlayerEvents() {
+    this.player.qualityLevels().on('addqualitylevel', this.onAddQualityLevel.bind(this));
+  };
+
+  /**
+   * Adds the quality menu button to the player control bar.
+   */
+
+  HlsQualitySelectorPlugin.prototype.createQualityButton = function createQualityButton() {
+    var player = this.player;
+    this._qualityButton = new ConcreteButton(player);
+    var placementIndex = player.controlBar.children().length - 2;
+    var concreteButtonInstance = player.controlBar.addChild(this._qualityButton, {
+      componentClass: 'qualitySelector'
+    }, this.config.placementIndex || placementIndex);
+    concreteButtonInstance.addClass('vjs-quality-selector');
+    if (!this.config.displayCurrentQuality) {
+      var icon = ' ' + (this.config.vjsIconClass || 'vjs-icon-hd');
+      concreteButtonInstance.menuButton_.$('.vjs-icon-placeholder').className += icon;
+    } else {
+      this.setButtonInnerText('auto');
+    }
+    concreteButtonInstance.removeClass('vjs-hidden');
+  };
+
+  /**
+   *Set inner button text.
+   *
+   * @param {string} text - the text to display in the button.
+   */
+
+  HlsQualitySelectorPlugin.prototype.setButtonInnerText = function setButtonInnerText(text) {
+    this._qualityButton.menuButton_.$('.vjs-icon-placeholder').innerHTML = text;
+  };
+
+  /**
+   * Builds individual quality menu items.
+   *
+   * @param {Object} item - Individual quality menu item.
+   * @return {ConcreteMenuItem} - Menu item
+   */
+
+  HlsQualitySelectorPlugin.prototype.getQualityMenuItem = function getQualityMenuItem(item) {
+    var player = this.player;
+    return new ConcreteMenuItem(player, item, this._qualityButton, this);
+  };
+
+  /**
+   * Executed when a quality level is added from HLS playlist.
+   */
+
+  HlsQualitySelectorPlugin.prototype.onAddQualityLevel = function onAddQualityLevel() {
+    var _this = this;
+    var player = this.player;
+    var qualityList = player.qualityLevels();
+    var levels = qualityList.levels_ || [];
+    var levelItems = [];
+    var _loop = function _loop(i) {
+      if (!levelItems.filter(function (_existingItem) {
+        return _existingItem.item && _existingItem.item.value === levels[i].height;
+      }).length) {
+        var levelItem = _this.getQualityMenuItem.call(_this, {
+          label: levels[i].height + 'p',
+          value: levels[i].height
+        });
+        levelItems.push(levelItem);
+      }
+    };
+    for (var i = 0; i < levels.length; ++i) {
+      _loop(i);
+    }
+    levelItems.sort(function (current, next) {
+      if ((typeof current === 'undefined' ? 'undefined' : _typeof(current)) !== 'object' || (typeof next === 'undefined' ? 'undefined' : _typeof(next)) !== 'object') {
+        return -1;
+      }
+      if (current.item.value < next.item.value) {
+        return -1;
+      }
+      if (current.item.value > next.item.value) {
+        return 1;
+      }
+      return 0;
+    });
+    levelItems.push(this.getQualityMenuItem.call(this, {
+      label: player.localize('Auto'),
+      value: 'auto',
+      selected: true
+    }));
+    if (this._qualityButton) {
+      this._qualityButton.createItems = function () {
+        return levelItems;
+      };
+      this._qualityButton.update();
+    }
+  };
+
+  /**
+   * Sets quality (based on media height)
+   *
+   * @param {number} height - A number representing HLS playlist.
+   */
+
+  HlsQualitySelectorPlugin.prototype.setQuality = function setQuality(height) {
+    var qualityList = this.player.qualityLevels();
+
+    // Set quality on plugin
+    this._currentQuality = height;
+    if (this.config.displayCurrentQuality) {
+      this.setButtonInnerText(height === 'auto' ? height : height + 'p');
+    }
+    for (var i = 0; i < qualityList.length; ++i) {
+      var quality = qualityList[i];
+      quality.enabled = quality.height === height || height === 'auto';
+    }
+    this._qualityButton.unpressButton();
+  };
+
+  /**
+   * Return the current set quality or 'auto'
+   *
+   * @return {string} the currently set quality
+   */
+
+  HlsQualitySelectorPlugin.prototype.getCurrentQuality = function getCurrentQuality() {
+    return this._currentQuality || 'auto';
+  };
+  return HlsQualitySelectorPlugin;
+}();
+
+/**
+ * Function to invoke when the player is ready.
+ *
+ * This is a great place for your plugin to initialize itself. When this
+ * function is called, the player will have its DOM and child components
+ * in place.
+ *
+ * @function onPlayerReady
+ * @param    {Player} player
+ *           A Video.js player object.
+ *
+ * @param    {Object} [options={}]
+ *           A plain object containing options for the plugin.
+ */
+
+var onPlayerReady = function onPlayerReady(player, options) {
+  player.addClass('vjs-hls-quality-selector');
+  player.hlsQualitySelector = new HlsQualitySelectorPlugin(player, options);
+};
+
+/**
+ * A video.js plugin.
+ *
+ * In the plugin function, the value of `this` is a video.js `Player`
+ * instance. You cannot rely on the player being in a "ready" state here,
+ * depending on how the plugin is invoked. This may or may not be important
+ * to you; if not, remove the wait for "ready"!
+ *
+ * @function hlsQualitySelector
+ * @param    {Object} [options={}]
+ *           An object of options left to the plugin author to define.
+ */
+var hlsQualitySelector = function hlsQualitySelector(options) {
+  var _this2 = this;
+  this.ready(function () {
+    onPlayerReady(_this2, video_es.videojs.mergeOptions(defaults, options));
+  });
+};
+
+// Register the plugin with video.js.
+registerPlugin('hlsQualitySelector', hlsQualitySelector);
+
+// Include the version number.
+hlsQualitySelector.VERSION = version;
+
+exports.default = hlsQualitySelector;

package/dist/videojs-webrtc-plugin-d30c3e7a.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var videojsWebrtcPlugin = "/*! @name @antmedia/videojs-webrtc-plugin @version 1.2.1 @license MIT */\n.vjs-custom-spinner{position:absolute;top:50%;transform:translateY(-50%) translateX(-50%);left:50%;width:80px;height:80px}.vjs-custom-spinner:after{content:\" \";display:block;width:64px;height:64px;margin:8px;border-radius:50%;border:6px solid #fff;border-color:#fff transparent;-webkit-animation:vjs-spinner-spin 1.1s cubic-bezier(.6,.2,0,.8) infinite,vjs-spinner-fade 1.1s linear infinite;animation:vjs-spinner-spin 1.1s cubic-bezier(.6,.2,0,.8) infinite,vjs-spinner-fade 1.1s linear infinite}";
+
+exports.default = videojsWebrtcPlugin;