xgplayer 2.32.5 → 2.32.6

package/es/utils/database.d.ts

@@ -0,0 +1,31 @@
+export default INDEXDB;
+declare class INDEXDB {
+    constructor(mydb?: {
+        name: string;
+        version: number;
+        db: any;
+        ojstore: {
+            name: string;
+            keypath: string;
+        };
+    });
+    indexedDB: any;
+    IDBKeyRange: any;
+    myDB: {
+        name: string;
+        version: number;
+        db: any;
+        ojstore: {
+            name: string;
+            keypath: string;
+        };
+    };
+    openDB(callback: any): void;
+    deletedb(): void;
+    closeDB(): void;
+    addData(storename: any, data: any): void;
+    putData(storename: any, data: any): void;
+    getDataByKey(storename: any, key: any, callback: any): void;
+    deleteData(storename: any, key: any): void;
+    clearData(storename: any): void;
+}

package/es/utils/database.js

@@ -0,0 +1,107 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck } from "../_virtual/_rollupPluginBabelHelpers.js";
+var INDEXDB = /* @__PURE__ */ function() {
+  function INDEXDB2() {
+    var mydb = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+      name: "xgplayer",
+      version: 1,
+      db: null,
+      ojstore: {
+        name: "xg-m4a",
+        keypath: "vid"
+      }
+    };
+    _classCallCheck(this, INDEXDB2);
+    this.indexedDB = window.indexedDB || window.webkitindexedDB;
+    this.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange;
+    this.myDB = mydb;
+  }
+  _createClass(INDEXDB2, [{
+    key: "openDB",
+    value: function openDB(callback) {
+      var _this = this;
+      var self = this;
+      var version = this.myDB.version || 1;
+      var request = self.indexedDB.open(self.myDB.name, version);
+      request.onerror = function(e) {
+      };
+      request.onsuccess = function(e) {
+        _this.myDB.db = e.target.result;
+        callback.call(self);
+      };
+      request.onupgradeneeded = function(e) {
+        var db = e.target.result;
+        e.target.transaction;
+        if (!db.objectStoreNames.contains(self.myDB.ojstore.name)) {
+          db.createObjectStore(self.myDB.ojstore.name, {
+            keyPath: self.myDB.ojstore.keypath
+          });
+        }
+      };
+    }
+  }, {
+    key: "deletedb",
+    value: function deletedb() {
+      var self = this;
+      self.indexedDB.deleteDatabase(this.myDB.name);
+    }
+  }, {
+    key: "closeDB",
+    value: function closeDB() {
+      this.myDB.db.close();
+    }
+  }, {
+    key: "addData",
+    value: function addData(storename, data) {
+      var store = this.myDB.db.transaction(storename, "readwrite").objectStore(storename);
+      var request;
+      for (var i = 0; i < data.length; i++) {
+        request = store.add(data[i]);
+        request.onerror = function() {
+        };
+        request.onsuccess = function() {
+        };
+      }
+    }
+  }, {
+    key: "putData",
+    value: function putData(storename, data) {
+      var store = this.myDB.db.transaction(storename, "readwrite").objectStore(storename);
+      var request;
+      for (var i = 0; i < data.length; i++) {
+        request = store.put(data[i]);
+        request.onerror = function() {
+        };
+        request.onsuccess = function() {
+        };
+      }
+    }
+  }, {
+    key: "getDataByKey",
+    value: function getDataByKey(storename, key, callback) {
+      var self = this;
+      var store = this.myDB.db.transaction(storename, "readwrite").objectStore(storename);
+      var request = store.get(key);
+      request.onerror = function() {
+        callback.call(self, null);
+      };
+      request.onsuccess = function(e) {
+        var result = e.target.result;
+        callback.call(self, result);
+      };
+    }
+  }, {
+    key: "deleteData",
+    value: function deleteData(storename, key) {
+      var store = this.myDB.db.transaction(storename, "readwrite").objectStore(storename);
+      store.delete(key);
+    }
+  }, {
+    key: "clearData",
+    value: function clearData(storename) {
+      var store = this.myDB.db.transaction(storename, "readwrite").objectStore(storename);
+      store.clear();
+    }
+  }]);
+  return INDEXDB2;
+}();
+export { INDEXDB as default };

package/es/utils/debug.d.ts

@@ -0,0 +1,10 @@
+declare namespace XG_DEBUG {
+    namespace config {
+        const debug: number;
+    }
+    function logInfo(message: any, ...optionalParams: any[]): void;
+    function logWarn(message: any, ...optionalParams: any[]): void;
+    function logError(message: any, ...optionalParams: any[]): void;
+}
+export function bindDebug(player: any): void;
+export { XG_DEBUG as default };

package/es/utils/debug.js

@@ -0,0 +1,43 @@
+var XG_DEBUG_OPEN = typeof window !== "undefined" && window.location && window.location.href.indexOf("xgplayerdebugger=1") > -1;
+var STYLE = {
+  info: "color: #525252; background-color: #90ee90;",
+  error: "color: #525252; background-color: red;",
+  warn: "color: #525252; background-color: yellow; "
+};
+var XGTAG = "%c[xgplayer]";
+var XG_DEBUG = {
+  config: {
+    debug: XG_DEBUG_OPEN ? 3 : 0
+  },
+  logInfo: function logInfo(message) {
+    var _console;
+    for (var _len = arguments.length, optionalParams = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      optionalParams[_key - 1] = arguments[_key];
+    }
+    this.config.debug >= 3 && (_console = console).log.apply(_console, [XGTAG, STYLE.info, message].concat(optionalParams));
+  },
+  logWarn: function logWarn(message) {
+    var _console2;
+    for (var _len2 = arguments.length, optionalParams = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      optionalParams[_key2 - 1] = arguments[_key2];
+    }
+    this.config.debug >= 1 && (_console2 = console).warn.apply(_console2, [XGTAG, STYLE.warn, message].concat(optionalParams));
+  },
+  logError: function logError(message) {
+    var _console3;
+    if (this.config.debug < 1) {
+      return;
+    }
+    var _fun = this.config.debug >= 2 ? "trace" : "error";
+    for (var _len3 = arguments.length, optionalParams = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      optionalParams[_key3 - 1] = arguments[_key3];
+    }
+    (_console3 = console)[_fun].apply(_console3, [XGTAG, STYLE.error, message].concat(optionalParams));
+  }
+};
+function bindDebug(player) {
+  player.logInfo = XG_DEBUG.logInfo.bind(player);
+  player.logWarn = XG_DEBUG.logWarn.bind(player);
+  player.logError = XG_DEBUG.logError.bind(player);
+}
+export { bindDebug, XG_DEBUG as default };

package/es/utils/draggabilly.d.ts

@@ -0,0 +1,54 @@
+export default class Draggabilly {
+    constructor(root: any, options?: {});
+    isEnabled: boolean;
+    isDragging: boolean;
+    isDown: boolean;
+    position: {};
+    downPoint: {};
+    dragPoint: {
+        x: number;
+        y: number;
+    };
+    startPos: {
+        x: number;
+        y: number;
+    };
+    _root: any;
+    _handlerDom: any;
+    _bindStartEvent(): void;
+    _startKey: string;
+    _unbindStartEvent(): void;
+    _bindPostStartEvents(event: any): void;
+    _boundPointerEvents: any;
+    _unbindPostStartEvents(): void;
+    enable(): void;
+    disable(): void;
+    onDocUp(e: any): void;
+    animate(): void;
+    positionDrag(): void;
+    setLeftTop(): void;
+    onmousedown(e: any): void;
+    onmousemove(e: any): void;
+    onmouseup(e: any): void;
+    ontouchstart(e: any): void;
+    touchIdentifier: any;
+    ontouchmove(e: any): void;
+    ontouchend(e: any): void;
+    ontouchcancel(e: any): void;
+    dragStart(e: any, pointer: any): void;
+    dragRealStart(e: any, pointer: any): void;
+    dragEnd(e: any, pointer: any): void;
+    _dragPointerMove(e: any, pointer: any): {
+        x: number;
+        y: number;
+    };
+    dragMove(e: any, pointer: any): void;
+    dragCancel(e: any, pointer: any): void;
+    presetInfo(): void;
+    destroy(): void;
+    hasDragStarted(moveVector: any): boolean;
+    checkContain(axis: any, drag: any, grid: any): any;
+    _getPosition(): void;
+    _addTransformPosition(style: any): void;
+    _getPositionCoord(styleSide: any, measure: any): number;
+}

package/es/utils/draggabilly.js

@@ -0,0 +1,410 @@
+import { inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, possibleConstructorReturn as _possibleConstructorReturn, createClass as _createClass, typeof as _typeof } from "../_virtual/_rollupPluginBabelHelpers.js";
+import EventEmitter from "eventemitter3";
+function getStyleSize(value) {
+  var num = parseFloat(value);
+  var isValid = value.indexOf("%") === -1 && !Number.isNaN(num);
+  return isValid && num;
+}
+var measurements = ["paddingLeft", "paddingRight", "paddingTop", "paddingBottom", "marginLeft", "marginRight", "marginTop", "marginBottom", "borderLeftWidth", "borderRightWidth", "borderTopWidth", "borderBottomWidth"];
+var measurementsLength = measurements.length;
+function getZeroSize() {
+  var size = {
+    width: 0,
+    height: 0,
+    innerWidth: 0,
+    innerHeight: 0,
+    outerWidth: 0,
+    outerHeight: 0
+  };
+  for (var i = 0; i < measurementsLength; i++) {
+    var measurement = measurements[i];
+    size[measurement] = 0;
+  }
+  return size;
+}
+function getStyle(elem) {
+  var style = window.getComputedStyle(elem);
+  return style;
+}
+function getSize(elem) {
+  if (typeof elem === "string") {
+    elem = document.querySelector(elem);
+  }
+  if (!elem || _typeof(elem) !== "object" || !elem.nodeType) {
+    return;
+  }
+  var style = getStyle(elem);
+  if (style.display === "none") {
+    return getZeroSize();
+  }
+  var size = {};
+  size.width = elem.offsetWidth;
+  size.height = elem.offsetHeight;
+  var isBorderBox = size.isBorderBox = style.boxSizing === "border-box";
+  for (var i = 0; i < measurementsLength; i++) {
+    var measurement = measurements[i];
+    var value = style[measurement];
+    var num = parseFloat(value);
+    size[measurement] = !Number.isNaN(num) ? num : 0;
+  }
+  var paddingWidth = size.paddingLeft + size.paddingRight;
+  var paddingHeight = size.paddingTop + size.paddingBottom;
+  var marginWidth = size.marginLeft + size.marginRight;
+  var marginHeight = size.marginTop + size.marginBottom;
+  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
+  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
+  var isBorderBoxSizeOuter = isBorderBox;
+  var styleWidth = getStyleSize(style.width);
+  if (styleWidth !== false) {
+    size.width = styleWidth + (isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth);
+  }
+  var styleHeight = getStyleSize(style.height);
+  if (styleHeight !== false) {
+    size.height = styleHeight + (isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight);
+  }
+  size.innerWidth = size.width - (paddingWidth + borderWidth);
+  size.innerHeight = size.height - (paddingHeight + borderHeight);
+  size.outerWidth = size.width + marginWidth;
+  size.outerHeight = size.height + marginHeight;
+  return size;
+}
+function getTouch(touches, dentifier) {
+  for (var i = 0; i < touches.length; i++) {
+    var touch = touches[i];
+    if (touch.identifier === dentifier) {
+      return touch;
+    }
+  }
+}
+var EVENTS = {
+  START: "dragStart",
+  MOVE: "dragMove",
+  ENDED: "dragEnded"
+};
+var POST_START_EVENTS = {
+  mousedown: ["mousemove", "mouseup"],
+  touchstart: ["touchmove", "touchend", "touchcancel"],
+  pointerdown: ["pointermove", "pointerup", "pointercancel"]
+};
+var Draggabilly = /* @__PURE__ */ function(_EventEmitter) {
+  _inherits(Draggabilly2, _EventEmitter);
+  var _super = _createSuper(Draggabilly2);
+  function Draggabilly2(root) {
+    var _this;
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    _classCallCheck(this, Draggabilly2);
+    _this = _super.call(this);
+    _this.isEnabled = true;
+    _this.isDragging = false;
+    _this.isDown = false;
+    _this.position = {};
+    _this.downPoint = {};
+    _this.dragPoint = {
+      x: 0,
+      y: 0
+    };
+    _this.startPos = {
+      x: 0,
+      y: 0
+    };
+    _this._root = root instanceof Element ? root : document.querySelector(root);
+    _this._handlerDom = options.handle instanceof Element ? options.handle : document.querySelector(options.handle);
+    if (!_this._root || !_this._handlerDom) {
+      return _possibleConstructorReturn(_this);
+    }
+    _this._bindStartEvent();
+    return _this;
+  }
+  _createClass(Draggabilly2, [{
+    key: "_bindStartEvent",
+    value: function _bindStartEvent() {
+      var _this2 = this;
+      if ("ontouchstart" in window) {
+        this._startKey = "touchstart";
+      } else {
+        this._startKey = "mousedown";
+      }
+      this["on".concat(this._startKey)] = this["on".concat(this._startKey)].bind(this);
+      this._handlerDom.addEventListener(this._startKey, this["on".concat(this._startKey)]);
+      POST_START_EVENTS[this._startKey].map(function(key) {
+        _this2["on".concat(key)] = _this2["on".concat(key)].bind(_this2);
+      });
+    }
+  }, {
+    key: "_unbindStartEvent",
+    value: function _unbindStartEvent() {
+      this._handlerDom.removeEventListener(this._startKey, this["on".concat(this._startKey)]);
+    }
+  }, {
+    key: "_bindPostStartEvents",
+    value: function _bindPostStartEvents(event) {
+      var _this3 = this;
+      if (!event) {
+        return;
+      }
+      var events = POST_START_EVENTS[this._startKey];
+      events.map(function(eventName) {
+        window.addEventListener(eventName, _this3["on".concat(eventName)]);
+      });
+      this._boundPointerEvents = events;
+    }
+  }, {
+    key: "_unbindPostStartEvents",
+    value: function _unbindPostStartEvents() {
+      var _this4 = this;
+      if (!this._boundPointerEvents) {
+        return;
+      }
+      this._boundPointerEvents.map(function(eventName) {
+        window.removeEventListener(eventName, _this4["on".concat(eventName)]);
+      });
+      delete this._boundPointerEvents;
+    }
+  }, {
+    key: "enable",
+    value: function enable() {
+      this.isEnabled = true;
+    }
+  }, {
+    key: "disable",
+    value: function disable() {
+      this.isEnabled = false;
+      if (this.isDragging) {
+        this.onUp();
+      }
+    }
+  }, {
+    key: "onDocUp",
+    value: function onDocUp(e) {
+      this.onUp();
+    }
+  }, {
+    key: "animate",
+    value: function animate() {
+      var _this5 = this;
+      if (!this.isDragging) {
+        return;
+      }
+      this.positionDrag();
+      window.requestAnimationFrame(function() {
+        _this5.animate();
+      });
+    }
+  }, {
+    key: "positionDrag",
+    value: function positionDrag() {
+      var transform = "translate3d(".concat(this.dragPoint.x, "px, ").concat(this.dragPoint.y, "px, 0)");
+      this._root.style.transform = transform;
+      this._root.style.webKitTransform = transform;
+    }
+  }, {
+    key: "setLeftTop",
+    value: function setLeftTop() {
+      this._root.style.left = this.position.x + "px";
+      this._root.style.top = this.position.y + "px";
+    }
+  }, {
+    key: "onmousedown",
+    value: function onmousedown(e) {
+      this.dragStart(e, e);
+    }
+  }, {
+    key: "onmousemove",
+    value: function onmousemove(e) {
+      this.dragMove(e, e);
+    }
+  }, {
+    key: "onmouseup",
+    value: function onmouseup(e) {
+      this.dragEnd(e, e);
+    }
+  }, {
+    key: "ontouchstart",
+    value: function ontouchstart(e) {
+      var touch = e.changedTouches[0];
+      this.dragStart(e, touch);
+      this.touchIdentifier = touch.pointerId !== void 0 ? touch.pointerId : touch.identifier;
+      e.preventDefault();
+    }
+  }, {
+    key: "ontouchmove",
+    value: function ontouchmove(e) {
+      var touch = getTouch(e.changedTouches, this.touchIdentifier);
+      if (touch) {
+        this.dragMove(e, touch);
+      }
+    }
+  }, {
+    key: "ontouchend",
+    value: function ontouchend(e) {
+      var touch = getTouch(e.changedTouches, this.touchIdentifier);
+      if (touch) {
+        this.dragEnd(e, touch);
+      }
+      e.preventDefault();
+    }
+  }, {
+    key: "ontouchcancel",
+    value: function ontouchcancel(e) {
+      var touch = getTouch(e.changedTouches, this.touchIdentifier);
+      if (touch) {
+        this.dragCancel(e, touch);
+      }
+    }
+  }, {
+    key: "dragStart",
+    value: function dragStart(e, pointer) {
+      if (!this._root || this.isDown || !this.isEnabled) {
+        return;
+      }
+      this.downPoint = pointer;
+      this.dragPoint.x = 0;
+      this.dragPoint.y = 0;
+      this._getPosition();
+      var size = getSize(this._root);
+      this.startPos.x = this.position.x;
+      this.startPos.y = this.position.y;
+      this.startPos.maxY = window.innerHeight - size.height;
+      this.startPos.maxX = window.innerWidth - size.width;
+      this.setLeftTop();
+      this.isDown = true;
+      this._bindPostStartEvents(e);
+    }
+  }, {
+    key: "dragRealStart",
+    value: function dragRealStart(e, pointer) {
+      this.isDragging = true;
+      this.animate();
+      this.emit(EVENTS.START, this.startPos);
+    }
+  }, {
+    key: "dragEnd",
+    value: function dragEnd(e, pointer) {
+      if (!this._root) {
+        return;
+      }
+      this._unbindPostStartEvents();
+      if (this.isDragging) {
+        this._root.style.transform = "";
+        this.setLeftTop();
+        this.emit(EVENTS.ENDED);
+      }
+      this.presetInfo();
+    }
+  }, {
+    key: "_dragPointerMove",
+    value: function _dragPointerMove(e, pointer) {
+      var moveVector = {
+        x: pointer.pageX - this.downPoint.pageX,
+        y: pointer.pageY - this.downPoint.pageY
+      };
+      if (!this.isDragging && this.hasDragStarted(moveVector)) {
+        this.dragRealStart(e, pointer);
+      }
+      return moveVector;
+    }
+  }, {
+    key: "dragMove",
+    value: function dragMove(e, pointer) {
+      e = e || window.event;
+      if (!this.isDown) {
+        return;
+      }
+      var _this$startPos = this.startPos, x = _this$startPos.x, y = _this$startPos.y;
+      var moveVector = this._dragPointerMove(e, pointer);
+      var dragX = moveVector.x;
+      var dragY = moveVector.y;
+      dragX = this.checkContain("x", dragX, x);
+      dragY = this.checkContain("y", dragY, y);
+      this.position.x = x + dragX;
+      this.position.y = y + dragY;
+      this.dragPoint.x = dragX;
+      this.dragPoint.y = dragY;
+      this.emit(EVENTS.MOVE, this.position);
+    }
+  }, {
+    key: "dragCancel",
+    value: function dragCancel(e, pointer) {
+      this.dragEnd(e, pointer);
+    }
+  }, {
+    key: "presetInfo",
+    value: function presetInfo() {
+      this.isDragging = false;
+      this.startPos = {
+        x: 0,
+        y: 0
+      };
+      this.dragPoint = {
+        x: 0,
+        y: 0
+      };
+      this.isDown = false;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._unbindStartEvent();
+      this._unbindPostStartEvents();
+      if (this.isDragging) {
+        this.dragEnd();
+      }
+      this.removeAllListeners();
+      this._handlerDom = null;
+    }
+  }, {
+    key: "hasDragStarted",
+    value: function hasDragStarted(moveVector) {
+      return Math.abs(moveVector.x) > 3 || Math.abs(moveVector.y) > 3;
+    }
+  }, {
+    key: "checkContain",
+    value: function checkContain(axis, drag, grid) {
+      if (drag + grid < 0) {
+        return 0 - grid;
+      }
+      if (axis === "x" && drag + grid > this.startPos.maxX) {
+        return this.startPos.maxX - grid;
+      }
+      if (axis === "y" && drag + grid > this.startPos.maxY) {
+        return this.startPos.maxY - grid;
+      }
+      return drag;
+    }
+  }, {
+    key: "_getPosition",
+    value: function _getPosition() {
+      var style = window.getComputedStyle(this._root);
+      var x = this._getPositionCoord(style.left, "width");
+      var y = this._getPositionCoord(style.top, "height");
+      this.position.x = Number.isNaN(x) ? 0 : x;
+      this.position.y = Number.isNaN(y) ? 0 : y;
+      this._addTransformPosition(style);
+    }
+  }, {
+    key: "_addTransformPosition",
+    value: function _addTransformPosition(style) {
+      var transform = style.transform;
+      if (transform.indexOf("matrix") !== 0) {
+        return;
+      }
+      var matrixValues = transform.split(",");
+      var xIndex = transform.indexOf("matrix3d") === 0 ? 12 : 4;
+      var translateX = parseInt(matrixValues[xIndex], 10);
+      var translateY = parseInt(matrixValues[xIndex + 1], 10);
+      this.position.x += translateX;
+      this.position.y += translateY;
+    }
+  }, {
+    key: "_getPositionCoord",
+    value: function _getPositionCoord(styleSide, measure) {
+      if (styleSide.indexOf("%") !== -1) {
+        var parentSize = getSize(this._root.parentNode);
+        return !parentSize ? 0 : parseFloat(styleSide) / 100 * parentSize[measure];
+      }
+      return parseInt(styleSide, 10);
+    }
+  }]);
+  return Draggabilly2;
+}(EventEmitter);
+export { Draggabilly as default };

package/es/utils/sniffer.d.ts

@@ -0,0 +1,28 @@
+export default sniffer;
+export type ICheckResult = {
+    isSupport: boolean;
+    mime: string;
+};
+export type ISniffer = {
+    device: 'pc' | 'mobile';
+    browser: 'ie' | 'firefox' | 'chrome' | 'opera' | 'safari';
+    os: {
+        isTablet: boolean;
+        isPhone: boolean;
+        isIpad: boolean;
+        isIos: boolean;
+        isAndroid: boolean;
+        isPc: boolean;
+        isSymbian: boolean;
+        isWindowsPhone: boolean;
+        isFireFox: boolean;
+    };
+    isWeixin: boolean;
+    isSupportMP4(): ICheckResult;
+    isHevcSupported(): boolean;
+    probeConfigSupported(info: MediaDecodingConfiguration): Promise<MediaCapabilitiesDecodingInfo>;
+};
+/**
+ * @type ISniffer
+ */
+declare const sniffer: ISniffer;