xgplayer 2.32.5 → 2.32.6

package/es/plugins/stats/index.d.ts

@@ -0,0 +1,38 @@
+export default class Stats extends BasePlugin {
+    static get defaultConfig(): {};
+    _recordUserActions: (actionData: any) => void;
+    _getTime(): {
+        timestamp: number;
+        timeFormat: string;
+    };
+    _onReset: () => void;
+    _recordInfo: (data: any) => void;
+    _downloadStats: () => void;
+    downloadStats(): void;
+    /**
+     * @params type
+     */
+    info(data: any): void;
+    _info(data: any): void;
+    _infoProfile(data: any): void;
+    reset(): void;
+    _stats: {
+        info: any[];
+        media: {};
+    };
+    getStats(): {
+        raw: {
+            info: any[];
+            media: {};
+        };
+        timestat: string[];
+        profile: {
+            traceEvents: any[];
+        };
+    };
+    _getTimeStats(): string[];
+    _getProfile(): {
+        traceEvents: any[];
+    };
+}
+import { BasePlugin } from "../../plugin";

package/es/plugins/stats/index.js

@@ -0,0 +1,194 @@
+import { inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, defineProperty as _defineProperty, objectSpread2 as _objectSpread2, assertThisInitialized as _assertThisInitialized, createClass as _createClass } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import "../../utils/util.js";
+import { USER_ACTION, STATS_EVENTS as STATS_EVENTS$1 } from "../../events.js";
+import BasePlugin from "../../plugin/basePlugin.js";
+import "delegate";
+var INFO = "info";
+var STATS_EVENTS = STATS_EVENTS$1;
+var Stats = /* @__PURE__ */ function(_BasePlugin) {
+  _inherits(Stats2, _BasePlugin);
+  var _super = _createSuper(Stats2);
+  function Stats2() {
+    var _this;
+    _classCallCheck(this, Stats2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "_recordUserActions", function(actionData) {
+      var time = _this._getTime();
+      var payload = Object.assign({}, actionData, {
+        msg: actionData.msg || actionData.action
+      });
+      _this._stats[INFO].push(_objectSpread2(_objectSpread2({
+        type: "userAction"
+      }, time), {}, {
+        payload
+      }));
+    });
+    _defineProperty(_assertThisInitialized(_this), "_onReset", function() {
+      _this.reset();
+    });
+    _defineProperty(_assertThisInitialized(_this), "_recordInfo", function(data) {
+      _this.info(data);
+    });
+    _defineProperty(_assertThisInitialized(_this), "_downloadStats", function() {
+      var stats = _this.getStats();
+      var blob = new Blob([JSON.stringify(stats)], {
+        type: "application/json"
+      });
+      var downloadUrl = window.URL.createObjectURL(blob);
+      var link = document.createElement("a");
+      link.style.display = "none";
+      link.href = downloadUrl;
+      link.download = "player.txt";
+      link.disabled = false;
+      link.click();
+    });
+    return _this;
+  }
+  _createClass(Stats2, [{
+    key: "_getTime",
+    value: function _getTime() {
+      return {
+        timestamp: Date.now(),
+        timeFormat: new Date().toISOString()
+      };
+    }
+  }, {
+    key: "afterCreate",
+    value: function afterCreate() {
+      this.reset();
+      this.on(USER_ACTION, this._recordUserActions);
+      this.on(STATS_EVENTS.STATS_INFO, this._recordInfo);
+      this.on(STATS_EVENTS.STATS_DOWNLOAD, this._downloadStats);
+      this.on(STATS_EVENTS.STATS_RESET, this._onReset);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.offAll();
+    }
+  }, {
+    key: "downloadStats",
+    value: function downloadStats() {
+      this._downloadStats();
+    }
+  }, {
+    key: "info",
+    value: function info(data) {
+      if (data.profile) {
+        this._infoProfile(data);
+      } else {
+        this._info(data);
+      }
+    }
+  }, {
+    key: "_info",
+    value: function _info(data) {
+      var time = this._getTime();
+      this._stats[INFO].push(_objectSpread2(_objectSpread2({}, time), {}, {
+        payload: data
+      }));
+    }
+  }, {
+    key: "_infoProfile",
+    value: function _infoProfile(data) {
+      if (data && data.startMs) {
+        var endMs = Date.now();
+        var dur = endMs - data.startMs;
+        var profile = _objectSpread2({
+          cat: "function",
+          dur,
+          name: data.name || data.msg,
+          ph: "X",
+          pid: 0,
+          tid: 0,
+          ts: data.startMs,
+          profile: true
+        }, data);
+        this._info(profile);
+      } else {
+        console.warn("infoProfile need object data, include startMs");
+      }
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      var _this$_stats;
+      this._stats = (_this$_stats = {}, _defineProperty(_this$_stats, INFO, []), _defineProperty(_this$_stats, "media", {}), _this$_stats);
+    }
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      var player = this.player;
+      var mediaElem = player.media;
+      var buffered = [];
+      for (var i = 0; i < mediaElem.buffered.length; i++) {
+        buffered.push({
+          start: mediaElem.buffered.start(i),
+          end: mediaElem.buffered.end(i)
+        });
+      }
+      var mediaInfo = {
+        currentTime: mediaElem.currentTime,
+        readyState: mediaElem.readyState,
+        buffered,
+        paused: mediaElem.paused,
+        ended: mediaElem.ended
+      };
+      this._stats.media = mediaInfo;
+      return {
+        raw: this._stats,
+        timestat: this._getTimeStats(),
+        profile: this._getProfile()
+      };
+    }
+  }, {
+    key: "_getTimeStats",
+    value: function _getTimeStats() {
+      var allStat = this._stats[INFO];
+      var msgs = allStat.map(function(stat) {
+        var data = stat.payload.data;
+        var msg = "";
+        try {
+          if (data instanceof Error) {
+            msg = data.msg;
+          } else if (data !== void 0) {
+            msg = JSON.stringify(data);
+          }
+        } catch (error) {
+          console.log("err", error);
+        }
+        return "[".concat(stat.timeFormat, "] : ").concat(stat.payload.msg, " ").concat(msg, " ");
+      });
+      return msgs;
+    }
+  }, {
+    key: "_getProfile",
+    value: function _getProfile() {
+      var profile = {
+        traceEvents: []
+      };
+      var allStat = this._stats[INFO];
+      allStat.forEach(function(stat) {
+        if (stat.payload.profile) {
+          profile.traceEvents.push(stat.payload);
+        }
+      });
+      return profile;
+    }
+  }], [{
+    key: "pluginName",
+    get: function get() {
+      return "stats";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function get() {
+      return {};
+    }
+  }]);
+  return Stats2;
+}(BasePlugin);
+export { Stats as default };

package/es/plugins/testspeed/index.d.ts

@@ -0,0 +1,26 @@
+export default class TestSpeed extends BasePlugin {
+    static get defaultConfig(): {
+        openSpeed: boolean;
+        testCnt: number;
+        loadSize: number;
+        testTimeStep: number;
+        url: string;
+        saveSpeedMax: number;
+        addSpeedTypeList: any[];
+    };
+    getSpeed: (type?: string) => number;
+    timer: NodeJS.Timeout;
+    cnt: number;
+    xhr: XMLHttpRequest;
+    startTimer: () => void;
+    initSpeedList: () => void;
+    speedListCache: {};
+    _onRealSpeedChange: (data: any) => void;
+    testSpeed: () => void;
+    appendList: (speed: any, type?: string) => void;
+    getSpeedName(namePrefix: any, type: any): string;
+    updateSpeed: (type?: string) => void;
+    set openSpeed(arg: any);
+    get openSpeed(): any;
+}
+import BasePlugin from "../../plugin";

package/es/plugins/testspeed/index.js

@@ -0,0 +1,207 @@
+import { inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, defineProperty as _defineProperty, assertThisInitialized as _assertThisInitialized, createClass as _createClass, toConsumableArray as _toConsumableArray } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import util from "../../utils/util.js";
+import { DOWNLOAD_SPEED_CHANGE, LOADED_DATA, REPLAY } from "../../events.js";
+import "../../utils/debug.js";
+import Plugin from "../../plugin/plugin.js";
+var DEFAULT_SPEED_TYPE = "cdn";
+var SPEED_TYPE = ["cdn"];
+var TestSpeed = /* @__PURE__ */ function(_BasePlugin) {
+  _inherits(TestSpeed2, _BasePlugin);
+  var _super = _createSuper(TestSpeed2);
+  function TestSpeed2() {
+    var _this;
+    _classCallCheck(this, TestSpeed2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "getSpeed", function() {
+      var type = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SPEED_TYPE;
+      if (!_this.speedListCache || !_this.speedListCache[type])
+        return 0;
+      if (_this.speedListCache[type].length <= 0)
+        return 0;
+      var total = 0;
+      _this.speedListCache[type].map(function(item) {
+        total += item;
+      });
+      return Math.floor(total / _this.speedListCache[type].length);
+    });
+    _defineProperty(_assertThisInitialized(_this), "startTimer", function() {
+      if (util.isMSE(_this.player.video)) {
+        return;
+      }
+      _this.initSpeedList();
+      _this.cnt = 0;
+      _this.timer = setTimeout(_this.testSpeed, _this.config.testTimeStep);
+    });
+    _defineProperty(_assertThisInitialized(_this), "initSpeedList", function() {
+      _this.speedListCache = {};
+      SPEED_TYPE.forEach(function(type) {
+        _this.speedListCache[type] = [];
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "_onRealSpeedChange", function(data) {
+      data.speed && _this.appendList(data.speed, data.type || DEFAULT_SPEED_TYPE);
+    });
+    _defineProperty(_assertThisInitialized(_this), "testSpeed", function() {
+      clearTimeout(_this.timer);
+      _this.timer = null;
+      if (!_this.player || !_this.config.openSpeed)
+        return;
+      var _this$config = _this.config, url = _this$config.url, loadSize = _this$config.loadSize, testCnt = _this$config.testCnt, testTimeStep = _this$config.testTimeStep;
+      var testSpeedUrl = url + (url.indexOf("?") < 0 ? "?testst=" : "&testst=") + Date.now();
+      if (_this.cnt >= testCnt) {
+        return;
+      }
+      _this.cnt++;
+      try {
+        var start = new Date().getTime();
+        var end = null;
+        var xhr = new XMLHttpRequest();
+        _this.xhr = xhr;
+        xhr.open("GET", testSpeedUrl);
+        var headers = {};
+        var random = Math.floor(Math.random() * 10);
+        headers.Range = "bytes=" + random + "-" + (loadSize + random);
+        if (headers) {
+          Object.keys(headers).forEach(function(k) {
+            xhr.setRequestHeader(k, headers[k]);
+          });
+        }
+        xhr.onreadystatechange = function() {
+          if (xhr.readyState === 4) {
+            _this.xhr = null;
+            end = new Date().getTime();
+            var size = xhr.getResponseHeader("Content-Length") / 1024 * 8;
+            var speed = Math.round(size * 1e3 / (end - start));
+            _this.appendList(speed);
+            _this.timer = setTimeout(_this.testSpeed, testTimeStep);
+          }
+        };
+        xhr.send();
+      } catch (e) {
+        console.error(e);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "appendList", function(speed) {
+      var type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_SPEED_TYPE;
+      if (!_this.speedListCache || !_this.speedListCache[type])
+        return;
+      var saveSpeedMax = _this.config.saveSpeedMax;
+      if (_this.speedListCache[type].length >= saveSpeedMax) {
+        _this.speedListCache[type].shift();
+      }
+      _this.speedListCache[type].push(speed);
+      var _assertThisInitialize = _assertThisInitialized(_this), player = _assertThisInitialize.player;
+      if (player) {
+        type === DEFAULT_SPEED_TYPE ? player.realTimeSpeed = speed : player[_this.getSpeedName("realTime", type)] = speed;
+      }
+      _this.updateSpeed(type);
+    });
+    _defineProperty(_assertThisInitialized(_this), "updateSpeed", function() {
+      var type = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SPEED_TYPE;
+      var speed = _this.getSpeed(type);
+      var _assertThisInitialize2 = _assertThisInitialized(_this), player = _assertThisInitialize2.player;
+      if (player) {
+        if (type === DEFAULT_SPEED_TYPE) {
+          if (!player.avgSpeed || speed !== player.avgSpeed) {
+            player.avgSpeed = speed;
+            player.emit(DOWNLOAD_SPEED_CHANGE, {
+              speed,
+              realTimeSpeed: player.realTimeSpeed
+            });
+          }
+        } else {
+          var speedName = _this.getSpeedName("avg", type);
+          if (!player[speedName] || speed !== player[speedName]) {
+            player[speedName] = speed;
+            player.emit(DOWNLOAD_SPEED_CHANGE, {
+              speed,
+              realTimeSpeed: player.realTimeSpeed
+            });
+          }
+        }
+      }
+    });
+    return _this;
+  }
+  _createClass(TestSpeed2, [{
+    key: "afterCreate",
+    value: function afterCreate() {
+      var _this$config2 = this.config, openSpeed = _this$config2.openSpeed, addSpeedTypeList = _this$config2.addSpeedTypeList;
+      if ((addSpeedTypeList === null || addSpeedTypeList === void 0 ? void 0 : addSpeedTypeList.length) > 0) {
+        SPEED_TYPE.push.apply(SPEED_TYPE, _toConsumableArray(addSpeedTypeList));
+      }
+      this.initSpeedList();
+      this.on("real_time_speed", this._onRealSpeedChange);
+      this.timer = null;
+      this.cnt = 0;
+      this.xhr = null;
+      if (!openSpeed) {
+        return;
+      }
+      this.on([LOADED_DATA, REPLAY], this.startTimer);
+    }
+  }, {
+    key: "getSpeedName",
+    value: function getSpeedName(namePrefix, type) {
+      return namePrefix + "Speed" + type.toUpperCase();
+    }
+  }, {
+    key: "openSpeed",
+    get: function get() {
+      return this.config.openSpeed;
+    },
+    set: function set(value) {
+      this.config.openSpeed = value;
+      if (!value && this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+        return;
+      }
+      if (this.config.openSpeed) {
+        if (this.timer)
+          return;
+        this.timer = setTimeout(this.testSpeed, this.config.testTimeStep);
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this2 = this;
+      this.off("real_time_speed", this._onRealSpeedChange);
+      this.off([LOADED_DATA, REPLAY], this.startTimer);
+      SPEED_TYPE.forEach(function(type) {
+        _this2.speedListCache && _this2.speedListCache[type] && (_this2.speedListCache[type] = []);
+      });
+      this.speedListCache && (this.speedListCache = {});
+      clearTimeout(this.timer);
+      this.timer = null;
+      if (this.xhr && this.xhr.readyState !== 4) {
+        this.xhr.cancel && this.xhr.cancel();
+        this.xhr = null;
+      }
+    }
+  }], [{
+    key: "pluginName",
+    get: function get() {
+      return "testspeed";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function get() {
+      return {
+        openSpeed: false,
+        testCnt: 3,
+        loadSize: 200 * 1024,
+        testTimeStep: 3e3,
+        url: "",
+        saveSpeedMax: 5,
+        addSpeedTypeList: []
+      };
+    }
+  }]);
+  return TestSpeed2;
+}(Plugin);
+export { TestSpeed as default };

package/es/plugins/time/index.css

@@ -0,0 +1,46 @@
+.xgplayer .xgplayer-time {
+  min-width: 40px;
+  font-size: 14px;
+  font-family: PingFangSC-Semibold;
+  color: #fff;
+  text-align: center;
+  display: inline-block;
+  line-height: 40px;
+}
+.xgplayer .xgplayer-time span {
+  display: inline-block;
+  line-height: 40px;
+  height: 40px;
+}
+.xgplayer .xgplayer-time span .time-min-width {
+  text-align: center;
+  min-width: 2ch;
+}
+.xgplayer .xgplayer-time span .time-min-width:first-child {
+  text-align: right;
+}
+.xgplayer .xgplayer-time span .time-min-width:last-child {
+  text-align: left;
+}
+.xgplayer .xgplayer-time .time-duration {
+  color: rgba(255, 255, 255, 0.5);
+}
+.xgplayer .xgplayer-time .time-live-tag {
+  display: none;
+}
+.xgplayer .xgplayer-time.xg-time-left {
+  margin-left: 0;
+}
+.xgplayer .xgplayer-time.xg-time-right {
+  margin-right: 0;
+}
+.xgplayer.xgplayer-mobile .xgplayer-time {
+  min-width: 30px;
+  font-size: 12px;
+}
+.xgplayer.xgplayer-mobile .xgplayer-time.xg-time-left {
+  margin-right: 8px;
+}
+.xgplayer.xgplayer-mobile .xgplayer-time.xg-time-right {
+  margin-left: 8px;
+}

package/es/plugins/time/index.d.ts

@@ -0,0 +1,28 @@
+export default Time;
+declare class Time extends Plugin {
+    static get defaultConfig(): {
+        position: string;
+        index: number;
+        disable: boolean;
+    };
+    constructor(args: any);
+    isActiving: boolean;
+    get duration(): number;
+    get currentTime(): any;
+    get timeOffset(): number;
+    mode: string;
+    durationDom: HTMLElement;
+    timeDom: HTMLElement;
+    show(): void;
+    onTimeUpdate(isEnded: any): void;
+    onReset(): void;
+    createCenterTime(): void;
+    centerCurDom: HTMLElement;
+    centerDurDom: HTMLElement;
+    changeLiveState(isLive: any): void;
+    updateTime(time: any): void;
+    minWidthTime(timeStr: any): any;
+    resetActive(): void;
+    render(): string;
+}
+import Plugin from "../../plugin";