xgplayer 2.32.5 → 2.32.6

package/es/plugin/basePlugin.d.ts

@@ -0,0 +1,180 @@
+export type Player = import('../player').default;
+export type IPlayerOptions = import('../defaultConfig').IPlayerOptions;
+export type IBasePluginOptions = {
+    [propName: string]: any;
+    index?: number;
+    player: Player;
+    pluginName: string;
+    config: {
+        [propName: string]: any;
+    };
+};
+/**
+ * @typedef { import ('../player').default } Player
+ */
+/**
+ * @typedef { import ('../defaultConfig').IPlayerOptions } IPlayerOptions
+ */
+/**
+  * @typedef {{
+  * index?: number,
+  * player: Player,
+  * pluginName: string,
+  * config: {
+  *   [propName: string]: any
+  * },
+  * [propName: string]: any;
+  * }} IBasePluginOptions
+ */
+declare class BasePlugin {
+    static defineGetterOrSetter(Obj: any, map: any): void;
+    /**
+     * @type { { [propName: string]: any } }
+     */
+    static get defaultConfig(): {
+        [propName: string]: any;
+    };
+    /**
+     * @type { string }
+     */
+    static get pluginName(): string;
+    /**
+     * @param { IBasePluginOptions } args
+     */
+    constructor(args: IBasePluginOptions);
+    /**
+     * @private
+     */
+    private __args;
+    /**
+     * @private
+     */
+    private __events;
+    __onceEvents: {};
+    config: {
+        [propName: string]: any;
+    };
+    /**
+     * @readonly
+     * @type { Player }
+     */
+    readonly player: Player;
+    /**
+       * @readonly
+       * @type { IPlayerOptions }
+       */
+    readonly playerConfig: IPlayerOptions;
+    /**
+       * @readonly
+       * @type {string}
+       */
+    readonly pluginName: string;
+    /**
+     * @param { IBasePluginOptions } args
+     */
+    beforeCreate(args: IBasePluginOptions): void;
+    afterCreate(): void;
+    beforePlayerInit(): void;
+    onPluginsReady(): void;
+    afterPlayerInit(): void;
+    destroy(): void;
+    /**
+     * @private
+     * @param { any } args
+     */
+    private __init;
+    logger: any;
+    /**
+     * 更新语言
+     * @param { string } lang
+     */
+    updateLang(lang: string): void;
+    /**
+     * @type { string }
+     */
+    get lang(): string;
+    get i18n(): import("../lang/i18n").IXGI18nText;
+    get i18nKeys(): {
+        [propName: string]: string;
+    };
+    /**
+     * @description当前支持的事件类型
+     * @type { 'touch' | 'mouse' }
+     */
+    get domEventType(): "touch" | "mouse";
+    /**
+     *
+     * @param { string | Array<string> } event
+     * @param { Function } callback
+     * @returns
+     */
+    on(event: string | Array<string>, callback: Function): void;
+    /**
+     *
+     * @param { string } event
+     * @param { Function } callback
+     * @returns
+     */
+    once(event: string, callback: Function): void;
+    /**
+     *
+     * @param { string } event
+     * @param { Function } callback
+     * @returns
+     */
+    off(event: string, callback: Function): void;
+    offAll(): void;
+    /**
+     *
+     * @param { string } event
+     * @param  {...any} res
+     * @returns
+     */
+    emit(event: string, ...res: any[]): void;
+    emitUserAction(event: any, action: any, params?: {}): void;
+    /**
+     * @param { string } hookName
+     * @param { Function } handler
+     * @param { {pre: Function| null , next: Function | null} } preset
+     * @returns
+     */
+    hook(hookName: string, handler: Function, preset?: {
+        pre: Function | null;
+        next: Function | null;
+    }, ...args: any[]): any;
+    /**
+     * @param { string } hookName
+     * @param { (plugin: any, ...args) => boolean | Promise<any> } handler
+     * @param  {...any} args
+     * @returns { boolean } isSuccess
+     */
+    useHooks(hookName: string, handler: (plugin: any, ...args: any[]) => boolean | Promise<any>, ...args: any[]): boolean;
+    /**
+     * @param { string } hookName
+     * @param { (plugin: any, ...args) => boolean | Promise<any> } handler
+     * @param  {...any} args
+     * @returns { boolean } isSuccess
+     */
+    removeHooks(hookName: string, handler: (plugin: any, ...args: any[]) => boolean | Promise<any>, ...args: any[]): boolean;
+    /**
+     * 注册子插件
+     * @param { any } plugin
+     * @param { any } [options]
+     * @param { string } [name]
+     * @returns { any }
+     */
+    registerPlugin(plugin: any, options?: any, name?: string): any;
+    /**
+     *
+     * @param { string } name
+     * @returns { any | null }
+     */
+    getPlugin(name: string): any | null;
+    __destroy(): void;
+}
+import Util from "../utils/util";
+import Sniffer from "../utils/sniffer";
+import Errors from "../error";
+import * as Events from "../events";
+import XG_DEBUG from "../utils/debug";
+export { BasePlugin as default, Util, Sniffer, Errors, Events, XG_DEBUG };

package/es/plugin/basePlugin.js

@@ -0,0 +1,259 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, objectSpread2 as _objectSpread2 } from "../_virtual/_rollupPluginBabelHelpers.js";
+import util from "../utils/util.js";
+export { default as Util } from "../utils/util.js";
+import XG_DEBUG from "../utils/debug.js";
+export { default as XG_DEBUG } from "../utils/debug.js";
+import hooksDescriptor, { hook, useHooks, removeHooks, delHooksDescriptor } from "./hooksDescriptor.js";
+function showErrorMsg(pluginName, msg) {
+  XG_DEBUG.logError("[".concat(pluginName, "] event or callback cant be undefined or null when call ").concat(msg));
+}
+var BasePlugin = /* @__PURE__ */ function() {
+  function BasePlugin2(args) {
+    _classCallCheck(this, BasePlugin2);
+    if (util.checkIsFunction(this.beforeCreate)) {
+      this.beforeCreate(args);
+    }
+    hooksDescriptor(this);
+    this.__args = args;
+    this.__events = {};
+    this.__onceEvents = {};
+    this.config = args.config || {};
+    this.player = null;
+    this.playerConfig = {};
+    this.pluginName = "";
+    this.__init(args);
+  }
+  _createClass(BasePlugin2, [{
+    key: "beforeCreate",
+    value: function beforeCreate(args) {
+    }
+  }, {
+    key: "afterCreate",
+    value: function afterCreate() {
+    }
+  }, {
+    key: "beforePlayerInit",
+    value: function beforePlayerInit() {
+    }
+  }, {
+    key: "onPluginsReady",
+    value: function onPluginsReady() {
+    }
+  }, {
+    key: "afterPlayerInit",
+    value: function afterPlayerInit() {
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+    }
+  }, {
+    key: "__init",
+    value: function __init(args) {
+      this.player = args.player;
+      this.playerConfig = args.player && args.player.config;
+      this.pluginName = args.pluginName ? args.pluginName.toLowerCase() : this.constructor.pluginName.toLowerCase();
+      this.logger = args.player && args.player.logger;
+    }
+  }, {
+    key: "updateLang",
+    value: function updateLang(lang) {
+      if (!lang) {
+        lang = this.lang;
+      }
+    }
+  }, {
+    key: "lang",
+    get: function get() {
+      return this.player.lang;
+    }
+  }, {
+    key: "i18n",
+    get: function get() {
+      return this.player.i18n;
+    }
+  }, {
+    key: "i18nKeys",
+    get: function get() {
+      return this.player.i18nKeys;
+    }
+  }, {
+    key: "domEventType",
+    get: function get() {
+      var _e = util.checkTouchSupport() ? "touch" : "mouse";
+      if (this.playerConfig && (this.playerConfig.domEventType === "touch" || this.playerConfig.domEventType === "mouse")) {
+        _e = this.playerConfig.domEventType;
+      }
+      return _e;
+    }
+  }, {
+    key: "on",
+    value: function on(event, callback) {
+      var _this = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.on(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        this.__events[event] = callback;
+        this.player.on(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          _this.__events[item] = callback;
+          _this.player.on(item, callback);
+        });
+      }
+    }
+  }, {
+    key: "once",
+    value: function once(event, callback) {
+      var _this2 = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.once(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        this.__onceEvents[event] = callback;
+        this.player.once(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          _this2.__onceEvents[item] = callback;
+          _this2.player.once(event, callback);
+        });
+      }
+    }
+  }, {
+    key: "off",
+    value: function off(event, callback) {
+      var _this3 = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.off(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        delete this.__events[event];
+        this.player.off(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          delete _this3.__events[event];
+          _this3.player.off(item, callback);
+        });
+      }
+    }
+  }, {
+    key: "offAll",
+    value: function offAll() {
+      var _this4 = this;
+      ["__events", "__onceEvents"].forEach(function(key) {
+        Object.keys(_this4[key]).forEach(function(item) {
+          _this4[key][item] && _this4.off(item, _this4[key][item]);
+          item && delete _this4[key][item];
+        });
+      });
+      this.__events = {};
+      this.__onceEvents = {};
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      var _this$player;
+      if (!this.player) {
+        return;
+      }
+      for (var _len = arguments.length, res = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        res[_key - 1] = arguments[_key];
+      }
+      (_this$player = this.player).emit.apply(_this$player, [event].concat(res));
+    }
+  }, {
+    key: "emitUserAction",
+    value: function emitUserAction(event, action) {
+      var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      if (!this.player) {
+        return;
+      }
+      var nParams = _objectSpread2(_objectSpread2({}, params), {}, {
+        pluginName: this.pluginName
+      });
+      this.player.emitUserAction(event, action, nParams);
+    }
+  }, {
+    key: "hook",
+    value: function hook$1(hookName, handler) {
+      return hook.call.apply(hook, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "useHooks",
+    value: function useHooks$1(hookName, handler) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      return useHooks.call.apply(useHooks, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "removeHooks",
+    value: function removeHooks$1(hookName, handler) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+        args[_key3 - 2] = arguments[_key3];
+      }
+      return removeHooks.call.apply(removeHooks, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "registerPlugin",
+    value: function registerPlugin(plugin) {
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var name = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+      if (!this.player) {
+        return;
+      }
+      name && (options.pluginName = name);
+      return this.player.registerPlugin({
+        plugin,
+        options
+      });
+    }
+  }, {
+    key: "getPlugin",
+    value: function getPlugin(name) {
+      return this.player ? this.player.getPlugin(name) : null;
+    }
+  }, {
+    key: "__destroy",
+    value: function __destroy() {
+      var _this5 = this;
+      var player = this.player;
+      var pluginName = this.pluginName;
+      this.offAll();
+      util.clearAllTimers(this);
+      if (util.checkIsFunction(this.destroy)) {
+        this.destroy();
+      }
+      ["player", "playerConfig", "pluginName", "logger", "__args", "__hooks"].map(function(item) {
+        _this5[item] = null;
+      });
+      player.unRegisterPlugin(pluginName);
+      delHooksDescriptor(this);
+    }
+  }], [{
+    key: "defineGetterOrSetter",
+    value: function defineGetterOrSetter(Obj, map) {
+      for (var key in map) {
+        if (Object.prototype.hasOwnProperty.call(map, key)) {
+          Object.defineProperty(Obj, key, map[key]);
+        }
+      }
+    }
+  }, {
+    key: "defaultConfig",
+    get: function get() {
+      return {};
+    }
+  }, {
+    key: "pluginName",
+    get: function get() {
+      return "pluginName";
+    }
+  }]);
+  return BasePlugin2;
+}();
+export { BasePlugin as default };

package/es/plugin/hooksDescriptor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * hook decorator, add hooks props for for an instance
+ * @param { any } instance
+ * @param { Array<string> } [hookNames]
+ */
+declare function hooksDescriptor(instance: any, presetHooks?: any[]): void;
+/**
+ * 给某个处理函数添加hook能力
+ * @param { string } hookName
+ * @param { Function } handler
+ * @param { { pre?: any, next?:any } } preset
+ * {
+ *   pre: () => { // run beafore hook},
+ *   next: () => { // run after hook return}
+ * }
+ */
+export function hook(hookName: string, handler: Function, preset?: {
+    pre?: any;
+    next?: any;
+}): any;
+export class hook {
+    /**
+     * 给某个处理函数添加hook能力
+     * @param { string } hookName
+     * @param { Function } handler
+     * @param { { pre?: any, next?:any } } preset
+     * {
+     *   pre: () => { // run beafore hook},
+     *   next: () => { // run after hook return}
+     * }
+     */
+    constructor(hookName: string, handler: Function, preset?: {
+        pre?: any;
+        next?: any;
+    });
+    __hooks: {};
+}
+/**
+ * add hooks
+ * @param { string } hookName
+ * @param { Function } handler
+ */
+export function useHooks(hookName: string, handler: Function): boolean;
+/**
+ * Add hooks to a plugin
+ * @param { string } pluginName
+ * @param  {...any} args
+ */
+export function usePluginHooks(pluginName: string, ...args: any[]): any;
+export function removePluginHooks(pluginName: any, ...args: any[]): any;
+/**
+ * remove hook
+ * @param { string } hookName
+ * @param { (plugin: any, ..args) => {} } handler
+ * @returns void
+ */
+export function removeHooks(hookName: string, handler: (plugin: any, args: any) => {}): void;
+export function delHooksDescriptor(instance: any): void;
+export function runHooks(obj: any, hookName: any, handler: any, ...args: any[]): any;
+export { hooksDescriptor as default };

package/es/plugin/hooksDescriptor.js

@@ -0,0 +1,149 @@
+import { toConsumableArray as _toConsumableArray } from "../_virtual/_rollupPluginBabelHelpers.js";
+function callHandler(obj, handler, next) {
+  for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+    args[_key - 3] = arguments[_key];
+  }
+  var ret = handler.call.apply(handler, [obj].concat(args));
+  if (!next || typeof next !== "function") {
+    return;
+  }
+  if (ret && ret.then) {
+    ret.then(function() {
+      for (var _len2 = arguments.length, args2 = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args2[_key2] = arguments[_key2];
+      }
+      next.call.apply(next, [obj].concat(args2));
+    });
+  } else {
+    next.call.apply(next, [obj].concat(args));
+  }
+}
+function hook(hookName, handler) {
+  var preset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+    pre: null,
+    next: null
+  };
+  if (!this.__hooks) {
+    this.__hooks = {};
+  }
+  !this.__hooks[hookName] && (this.__hooks[hookName] = null);
+  return function() {
+    var _arguments = arguments, _this = this;
+    if (preset.pre) {
+      try {
+        var _preset$pre;
+        (_preset$pre = preset.pre).call.apply(_preset$pre, [this].concat(Array.prototype.slice.call(arguments)));
+      } catch (e) {
+        e.message = "[pluginName: ".concat(this.pluginName, ":").concat(hookName, ":pre error] >> ").concat(e.message);
+        throw e;
+      }
+    }
+    if (this.__hooks && this.__hooks[hookName]) {
+      try {
+        var _this$__hooks$hookNam;
+        var preRet = (_this$__hooks$hookNam = this.__hooks[hookName]).call.apply(_this$__hooks$hookNam, [this, this].concat(Array.prototype.slice.call(arguments)));
+        if (preRet) {
+          if (preRet.then) {
+            preRet.then(function(isContinue) {
+              if (isContinue !== false) {
+                callHandler.apply(void 0, [_this, handler, preset.next].concat(_toConsumableArray(_arguments)));
+              }
+            }).catch(function(e) {
+              throw e;
+            });
+          } else {
+            callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+          }
+        } else if (preRet === void 0) {
+          callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+        }
+      } catch (e) {
+        e.message = "[pluginName: ".concat(this.pluginName, ":").concat(hookName, "] >> ").concat(e.message);
+        throw e;
+      }
+    } else {
+      callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+    }
+  }.bind(this);
+}
+function useHooks(hookName, handler) {
+  var __hooks = this.__hooks;
+  if (!__hooks) {
+    return;
+  }
+  if (!__hooks.hasOwnProperty(hookName)) {
+    console.warn("has no supported hook which name [".concat(hookName, "]"));
+    return false;
+  }
+  __hooks && (__hooks[hookName] = handler);
+  return true;
+}
+function removeHooks(hookName, handler) {
+  var __hooks = this.__hooks;
+  if (!__hooks) {
+    return;
+  }
+  delete __hooks[hookName];
+}
+function usePluginHooks(pluginName) {
+  if (!this.plugins || !this.plugins[pluginName.toLowerCase()]) {
+    return;
+  }
+  var plugin = this.plugins[pluginName.toLowerCase()];
+  for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+    args[_key3 - 1] = arguments[_key3];
+  }
+  return plugin.useHooks && plugin.useHooks.apply(plugin, args);
+}
+function removePluginHooks(pluginName) {
+  if (!this.plugins || !this.plugins[pluginName.toLowerCase()]) {
+    return;
+  }
+  var plugin = this.plugins[pluginName.toLowerCase()];
+  if (plugin) {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+    return plugin.removeHooks && plugin.removeHooks.apply(plugin, args);
+  }
+}
+function hooksDescriptor(instance) {
+  var presetHooks = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  instance.__hooks = {};
+  presetHooks && presetHooks.map(function(item) {
+    instance.__hooks[item] = null;
+  });
+  Object.defineProperty(instance, "hooks", {
+    get: function get() {
+      return instance.__hooks && Object.keys(instance.__hooks).map(function(key) {
+        if (instance.__hooks[key]) {
+          return key;
+        }
+      });
+    }
+  });
+}
+function delHooksDescriptor(instance) {
+  instance.__hooks = null;
+}
+function runHooks(obj, hookName, handler) {
+  for (var _len5 = arguments.length, args = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
+    args[_key5 - 3] = arguments[_key5];
+  }
+  if (obj.__hooks && obj.__hooks[hookName]) {
+    var _obj$__hooks$hookName;
+    var ret = (_obj$__hooks$hookName = obj.__hooks[hookName]).call.apply(_obj$__hooks$hookName, [obj, obj].concat(args));
+    if (ret && ret.then) {
+      ret.then(function(data) {
+        return data === false ? null : handler.call.apply(handler, [obj, obj].concat(args));
+      }).catch(function(e) {
+        console.warn("[runHooks]".concat(hookName, " reject"), e.message);
+      });
+    } else if (ret !== false) {
+      return handler.call.apply(handler, [obj, obj].concat(args));
+    }
+  } else {
+    return handler.call.apply(handler, [obj, obj].concat(args));
+  }
+}
+export { hooksDescriptor as default, delHooksDescriptor, hook, removeHooks, removePluginHooks, runHooks, useHooks, usePluginHooks };

package/es/plugin/index.d.ts

@@ -0,0 +1,13 @@
+import pluginsManager from "./pluginsManager";
+import BasePlugin from "./basePlugin";
+import hooksDescriptor from "./hooksDescriptor";
+import STATE_CLASS from "../stateClassMap";
+import { POSITIONS } from "./plugin";
+import { ROOT_TYPES } from "./plugin";
+import Sniffer from "../utils/sniffer";
+import Errors from "../error";
+import Util from "../utils/util";
+import * as Events from "../events";
+import { STATES } from "../state";
+import Plugin from "./plugin";
+export { pluginsManager, BasePlugin, hooksDescriptor, STATE_CLASS, POSITIONS, ROOT_TYPES, Sniffer, Errors, Util, Events, STATES, Plugin as default };