tuikit-atomicx-vue3 0.1.0

package/dist/states/LiveMonitorState/index.d.ts

@@ -0,0 +1,39 @@
+import { InitConfig, MonitorLiveInfo } from '../../types';
+
+export declare const useLiveMonitorState: () => {
+    monitorLiveInfoList: import('vue').ComputedRef<{
+        liveId: string;
+        liveName: string;
+        liveDescription: string;
+        regionList: {
+            liveId: string;
+            userInfo: {
+                userId: string;
+                userName?: string | undefined;
+                avatarUrl?: string | undefined;
+                microphoneStatus?: import('../..').MonitorDeviceStatus | undefined;
+                cameraStatus?: import('../..').MonitorDeviceStatus | undefined;
+            };
+            rect: {
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+            };
+        }[];
+        categoryList?: Array<number> | undefined;
+        coverUrl: string;
+        backgroundUrl: string;
+        liveOwner: string;
+        currentViewerCount: number;
+        createTime: number;
+        totalViewerCount: number;
+        customInfo?: Record<string, any> | undefined;
+    }[]>;
+    init: (config: InitConfig) => void;
+    getLiveList: (page: number, pageSize: number) => Promise<MonitorLiveInfo[]>;
+    closeRoom: (liveId: string) => Promise<void>;
+    startPlay: (liveId: string, viewId: string) => Promise<void>;
+    stopPlay: (liveId: string) => Promise<void>;
+    muteLiveAudio: (liveId: string, mute: boolean) => Promise<void>;
+};

package/dist/states/LiveMonitorState/index.js

@@ -0,0 +1,167 @@
+import { ref, computed } from "vue";
+import { fetchLiveList, destroyRoom, getRoomInfo } from "./api/http.js";
+import { PlayerManager } from "./player/manager/playerManager.js";
+import { PlayerEvents } from "./player/types/player.js";
+import { MIXED_STREAM_PAYLOAD_TYPE } from "./player/types/trtc.js";
+import { safelyParse } from "../../utils/utils.js";
+import { transformRoomInfoToLiveInfo, getLiveIdFromMixedStreamUserId } from "./utils/index.js";
+let initConfig = null;
+let playerManager = null;
+const prepareCancelTaskMap = ref(/* @__PURE__ */ new Map());
+const monitorLiveInfoMap = ref(/* @__PURE__ */ new Map());
+const monitorLiveInfoList = computed(() => {
+  return Array.from(monitorLiveInfoMap.value.values());
+});
+const init = (config) => {
+  initConfig = config;
+  playerManager = new PlayerManager(config.account);
+};
+const getLiveList = async (page, pageSize) => {
+  if (!(initConfig == null ? void 0 : initConfig.baseUrl)) {
+    throw new Error("Please call init() first!");
+  }
+  if (page < 1) {
+    page = 1;
+  }
+  const { code, data } = await fetchLiveList(initConfig.baseUrl, {
+    next: String((page - 1) * pageSize),
+    count: pageSize
+  });
+  const liveList = [];
+  if (code === 0 && data.RoomList) {
+    data.RoomList.forEach((item) => {
+      const liveInfo = transformRoomInfoToLiveInfo(item);
+      liveList.push(liveInfo);
+    });
+  }
+  return liveList;
+};
+const closeRoom = async (liveId) => {
+  if (!(initConfig == null ? void 0 : initConfig.baseUrl)) {
+    throw new Error("Please call init() first!");
+  }
+  const response = await destroyRoom(initConfig.baseUrl, {
+    roomId: liveId
+  });
+  if (response.code === 0) {
+    monitorLiveInfoMap.value.delete(liveId);
+  }
+};
+const startPlay = async (liveId, viewId) => {
+  if (!initConfig || !playerManager) throw new Error("Please call init() first!");
+  if (!monitorLiveInfoMap.value.has(liveId)) {
+    const liveInfo = await getMonitorLiveInfo(liveId);
+    if (!isBeCanceled(liveId)) {
+      monitorLiveInfoMap.value.set(liveId, liveInfo);
+      const player = playerManager.createPlayer(liveId);
+      player.on(PlayerEvents.OnReceiveSEI, handleOnReceiveSEI);
+      player.on(PlayerEvents.OnUserAudioAvailable, handleOnUserAudioAvailable);
+      await player.play(liveId, viewId);
+    }
+  }
+};
+const isBeCanceled = (liveId) => {
+  const cancelTask = prepareCancelTaskMap.value.get(liveId);
+  let result = false;
+  if (cancelTask) {
+    if (Date.now() - cancelTask.timestamp < cancelTask.duration) {
+      result = true;
+    } else {
+      prepareCancelTaskMap.value.delete(liveId);
+    }
+  }
+  return result;
+};
+const stopPlay = async (liveId) => {
+  if (!initConfig || !playerManager) throw new Error("Please call init() first!");
+  if (monitorLiveInfoMap.value.has(liveId)) {
+    monitorLiveInfoMap.value.delete(liveId);
+    const player = playerManager.getPlayer(liveId);
+    player == null ? void 0 : player.off(PlayerEvents.OnReceiveSEI, handleOnReceiveSEI);
+    player == null ? void 0 : player.off(PlayerEvents.OnUserAudioAvailable, handleOnUserAudioAvailable);
+    playerManager.destroyPlayer(liveId);
+  } else {
+    prepareCancelTaskMap.value.set(liveId, {
+      timestamp: Date.now(),
+      duration: 1e3
+    });
+  }
+};
+const handleOnUserAudioAvailable = (liveId, available) => {
+  if (available) {
+    muteLiveAudio(liveId, true);
+  }
+};
+const getMonitorLiveInfo = async (liveId) => {
+  const response = await getRoomInfo(initConfig.baseUrl, { roomId: liveId });
+  if (response.code !== 0) {
+    if (monitorLiveInfoMap.value.has(liveId)) {
+      monitorLiveInfoMap.value.delete(liveId);
+    }
+    throw {
+      code: response.code,
+      message: response.data
+    };
+  }
+  return transformRoomInfoToLiveInfo(response.data.RoomInfo);
+};
+const handleOnReceiveSEI = (userId, data) => {
+  const { payloadType } = safelyParse(data.app_data);
+  if (payloadType === MIXED_STREAM_PAYLOAD_TYPE) {
+    const liveId = getLiveIdFromMixedStreamUserId(userId);
+    updateRegionList(liveId, data);
+  }
+};
+const updateRegionList = async (liveId, data) => {
+  var _a;
+  if (!((_a = data.regions) == null ? void 0 : _a.length)) return;
+  const regionList = await Promise.all(
+    data.regions.map(async (region) => {
+      let liveInfo2 = null;
+      try {
+        const result = await getRoomInfo(initConfig.baseUrl, { roomId: `live_${region.uid}` });
+        if (result.code === 0) {
+          liveInfo2 = transformRoomInfoToLiveInfo(result.data.RoomInfo);
+        }
+      } catch (error) {
+        liveInfo2 = null;
+      }
+      return {
+        liveId: (liveInfo2 == null ? void 0 : liveInfo2.liveId) || liveId,
+        userInfo: {
+          userId: region.uid,
+          volume: region.volume
+        },
+        rect: {
+          x: region.x / data.canvas.w,
+          y: region.y / data.canvas.h,
+          w: region.w / data.canvas.w,
+          h: region.h / data.canvas.h
+        }
+      };
+    })
+  );
+  const liveInfo = monitorLiveInfoMap.value.get(liveId);
+  if (liveInfo) {
+    liveInfo.regionList = regionList;
+    monitorLiveInfoMap.value.set(liveId, { ...liveInfo });
+  }
+};
+const muteLiveAudio = async (liveId, mute) => {
+  const player = playerManager == null ? void 0 : playerManager.getPlayer(liveId);
+  player == null ? void 0 : player.muteAudio(mute);
+};
+const useLiveMonitorState = () => {
+  return {
+    monitorLiveInfoList,
+    init,
+    getLiveList,
+    closeRoom,
+    startPlay,
+    stopPlay,
+    muteLiveAudio
+  };
+};
+export {
+  useLiveMonitorState
+};

package/dist/states/LiveMonitorState/player/adapters/trtc.d.ts

@@ -0,0 +1,27 @@
+import { BasePlayer } from '../base/basePlayer';
+import { Account } from '../types';
+
+export declare class TRTCAdapter extends BasePlayer {
+    private trtc;
+    private account;
+    private currentPlayableUserId;
+    private viewId;
+    private liveId;
+    constructor(account: Account);
+    private initTRTC;
+    private bindEvents;
+    private unbindEvents;
+    private getEnterRoomParams;
+    private getViewElement;
+    doPlay(liveId: string, viewId: string): Promise<void>;
+    doStop(): Promise<void>;
+    doDestroy(): Promise<void>;
+    doMuteAudio(mute: boolean): Promise<void>;
+    private handleUserVideoAvailable;
+    private handleUserAudioAvailable;
+    private handleOnReceiveSEI;
+    private onError;
+    private getPlayableUserId;
+    private isCurrentLiveMixedStreamUser;
+    private isMixedStreamUser;
+}

package/dist/states/LiveMonitorState/player/adapters/trtc.js

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { TRTCCloud } from "@tencentcloud/tuiroom-engine-js";
+import { BasePlayer } from "../base/basePlayer.js";
+import { PlayerState, PlayerEvents } from "../types/player.js";
+import { TRTCRoleType, TRTCScene, TRTCVideoStreamType } from "../types/trtc.js";
+import { safelyParse } from "../../../../utils/utils.js";
+class TRTCAdapter extends BasePlayer {
+  constructor(account) {
+    super();
+    __publicField(this, "trtc");
+    __publicField(this, "account");
+    __publicField(this, "currentPlayableUserId");
+    __publicField(this, "viewId");
+    __publicField(this, "liveId");
+    __publicField(this, "handleUserVideoAvailable", async (userId, available) => {
+      this.log("onUserVideoAvailable", { userId, available });
+      if (available) {
+        this.currentPlayableUserId = this.getPlayableUserId(userId);
+        const view = this.getViewElement();
+        if (view && this.currentPlayableUserId) {
+          await this.trtc.startRemoteView(this.currentPlayableUserId, view, TRTCVideoStreamType.TRTCVideoStreamTypeBig);
+          this.updatePlayerState(PlayerState.Playing);
+        }
+      }
+    });
+    __publicField(this, "handleUserAudioAvailable", (userId, available) => {
+      this.log("onUserAudioAvailable", { userId, available });
+      if (available) {
+        if (!userId.includes("livekit_")) {
+          this.trtc.muteRemoteAudio(userId, true);
+        } else {
+          this.currentPlayableUserId = this.getPlayableUserId(userId);
+          if (this.isMixedStreamUser(userId) && !userId.includes(this.liveId)) {
+            this.trtc.muteRemoteAudio(userId, true);
+          }
+          this.emit(PlayerEvents.OnUserAudioAvailable, this.liveId, available);
+        }
+      }
+    });
+    __publicField(this, "handleOnReceiveSEI", (userId, data) => {
+      const parsedData = safelyParse(data);
+      const result = safelyParse(parsedData.stringData);
+      if (Object.keys(result).includes("regions")) {
+        this.emit(PlayerEvents.OnReceiveSEI, userId, result);
+      }
+    });
+    __publicField(this, "onError", (error) => {
+      throw error;
+    });
+    this.currentPlayableUserId = "";
+    this.viewId = "";
+    this.liveId = "";
+    this.account = account;
+    this.initTRTC();
+  }
+  initTRTC() {
+    if (this.trtc) return;
+    TRTCCloud.callExperimentalAPI(
+      JSON.stringify({
+        api: "enableSEI",
+        params: {
+          enable: true
+        }
+      })
+    );
+    this.trtc = new TRTCCloud();
+    this.bindEvents();
+  }
+  bindEvents() {
+    this.trtc.on("onUserVideoAvailable", this.handleUserVideoAvailable);
+    this.trtc.on("onUserAudioAvailable", this.handleUserAudioAvailable);
+    this.trtc.on("onRecvSEIMsg", this.handleOnReceiveSEI);
+    this.trtc.on("onError", this.onError);
+  }
+  unbindEvents() {
+    this.trtc.off("onUserVideoAvailable", this.handleUserVideoAvailable);
+    this.trtc.off("onUserAudioAvailable", this.handleUserAudioAvailable);
+    this.trtc.off("onRecvSEIMsg", this.handleOnReceiveSEI);
+    this.trtc.off("onError", this.onError);
+  }
+  getEnterRoomParams() {
+    return {
+      sdkAppId: this.account.sdkAppId,
+      userId: this.account.userId,
+      userSig: this.account.password,
+      strRoomId: this.liveId,
+      role: TRTCRoleType.TRTCRoleAudience,
+      autoReceiveVideo: true,
+      autoReceiveAudio: false
+    };
+  }
+  getViewElement() {
+    return document.getElementById(this.viewId);
+  }
+  async doPlay(liveId, viewId) {
+    try {
+      this.liveId = liveId;
+      this.viewId = viewId;
+      const params = this.getEnterRoomParams();
+      await this.trtc.enterRoom(params, TRTCScene.LIVE);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async doStop() {
+    try {
+      await this.trtc.stopRemoteView(this.currentPlayableUserId, TRTCVideoStreamType.TRTCVideoStreamTypeBig);
+      this.updatePlayerState(PlayerState.Idle);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async doDestroy() {
+    try {
+      if (this.trtc) {
+        await this.trtc.exitRoom();
+        this.unbindEvents();
+        this.trtc.destroy();
+        this.log(`player ${this.id} destroy success!`);
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      this.trtc = null;
+      this.viewId = "";
+      this.liveId = "";
+      this.currentPlayableUserId = "";
+    }
+  }
+  async doMuteAudio(mute) {
+    if (this.trtc && this.currentPlayableUserId) {
+      await this.trtc.muteRemoteAudio(this.currentPlayableUserId, mute);
+    }
+  }
+  getPlayableUserId(userId) {
+    if (this.isCurrentLiveMixedStreamUser(userId)) {
+      return userId;
+    }
+    if (this.isMixedStreamUser(userId)) {
+      return this.currentPlayableUserId;
+    }
+    if (this.isCurrentLiveMixedStreamUser(this.currentPlayableUserId)) {
+      return this.currentPlayableUserId;
+    }
+    return userId;
+  }
+  isCurrentLiveMixedStreamUser(userId) {
+    return this.isMixedStreamUser(userId) && userId.includes(this.liveId);
+  }
+  isMixedStreamUser(userId) {
+    return userId.startsWith("livekit_");
+  }
+}
+export {
+  TRTCAdapter
+};

package/dist/states/LiveMonitorState/player/base/basePlayer.d.ts

@@ -0,0 +1,24 @@
+import { IPlayer, PlayerEvents, PlayerInfo, PlayerState } from '../types';
+
+export declare abstract class BasePlayer implements IPlayer {
+    readonly id: string;
+    private eventEmitter;
+    protected readonly LOG_TAG: string;
+    protected state: PlayerState;
+    constructor();
+    private generateId;
+    on(event: PlayerEvents, callback: (state: PlayerState) => void): void;
+    off(event: PlayerEvents, callback: (state: PlayerState) => void): void;
+    getPlayerInfo(): PlayerInfo;
+    play(liveId: string, viewId: string): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+    muteAudio(mute: boolean): Promise<void>;
+    protected updatePlayerState(state: PlayerState): void;
+    protected log(message: string, data?: any): void;
+    protected emit(event: PlayerEvents, ...args: any[]): void;
+    abstract doPlay(liveId: string, viewId: string): Promise<void>;
+    abstract doStop(): Promise<void>;
+    abstract doDestroy(): Promise<void>;
+    abstract doMuteAudio(mute: boolean): Promise<void>;
+}

package/dist/states/LiveMonitorState/player/base/basePlayer.js

@@ -0,0 +1,218 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { g as getDefaultExportFromCjs } from "../../../../_commonjsHelpers-CUmg6egw.js";
+import { PlayerState, PlayerEvents } from "../types/player.js";
+var eventemitter3 = { exports: {} };
+(function(module) {
+  var has = Object.prototype.hasOwnProperty, prefix = "~";
+  function Events() {
+  }
+  if (Object.create) {
+    Events.prototype = /* @__PURE__ */ Object.create(null);
+    if (!new Events().__proto__) prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+    else emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0) emitter._events = new Events();
+    else delete emitter._events[evt];
+  }
+  function EventEmitter2() {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+  EventEmitter2.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0) return names;
+    for (name in events = this._events) {
+      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter2.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers) return [];
+    if (handlers.fn) return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners) return 0;
+    if (listeners.fn) return 1;
+    return listeners.length;
+  };
+  EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1); i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0; i < length; i++) {
+        if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+              args[j - 1] = arguments[j];
+            }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter2.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter2.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+      else clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt]) clearEvent(this, evt);
+    } else {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+  EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+  EventEmitter2.prefixed = prefix;
+  EventEmitter2.EventEmitter = EventEmitter2;
+  {
+    module.exports = EventEmitter2;
+  }
+})(eventemitter3);
+var eventemitter3Exports = eventemitter3.exports;
+const EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+class BasePlayer {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "LOG_TAG");
+    __publicField(this, "state");
+    this.id = this.generateId();
+    this.state = PlayerState.Idle;
+    this.LOG_TAG = `[Player]`;
+    this.eventEmitter = new EventEmitter();
+  }
+  generateId() {
+    return `player__${Date.now()}_${Math.ceil(Math.random() * 1e5)}`;
+  }
+  on(event, callback) {
+    this.eventEmitter.on(event, callback);
+  }
+  off(event, callback) {
+    this.eventEmitter.off(event, callback);
+  }
+  getPlayerInfo() {
+    return {
+      id: this.id,
+      state: this.state
+    };
+  }
+  async play(liveId, viewId) {
+    await this.doPlay(liveId, viewId);
+  }
+  async stop() {
+    await this.doStop();
+  }
+  async destroy() {
+    await this.doDestroy();
+  }
+  async muteAudio(mute) {
+    await this.doMuteAudio(mute);
+  }
+  updatePlayerState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.eventEmitter.emit(PlayerEvents.OnStateChanged, this.state);
+    }
+  }
+  log(message, data) {
+    console.log(`${this.LOG_TAG} ${message}`, data || "");
+  }
+  emit(event, ...args) {
+    this.eventEmitter.emit(event, ...args);
+  }
+}
+export {
+  BasePlayer
+};

package/dist/states/LiveMonitorState/player/index.d.ts

@@ -0,0 +1,4 @@
+import { PlayerManager } from './manager/playerManager';
+
+export * from './types';
+export { PlayerManager };

package/dist/states/LiveMonitorState/player/index.js

@@ -0,0 +1,12 @@
+import { PlayerManager } from "./manager/playerManager.js";
+import { PlayerEvents, PlayerState } from "./types/player.js";
+import { MIXED_STREAM_PAYLOAD_TYPE, TRTCRoleType, TRTCScene, TRTCVideoStreamType } from "./types/trtc.js";
+export {
+  MIXED_STREAM_PAYLOAD_TYPE,
+  PlayerEvents,
+  PlayerManager,
+  PlayerState,
+  TRTCRoleType,
+  TRTCScene,
+  TRTCVideoStreamType
+};

package/dist/states/LiveMonitorState/player/manager/playerManager.d.ts

@@ -0,0 +1,13 @@
+import { IPlayer, Account } from '../types';
+
+export declare class PlayerManager {
+    private account;
+    private playersMap;
+    constructor(account: Account);
+    createPlayer(liveId: string): IPlayer;
+    createPlayers(liveIdList: string[]): string[];
+    getPlayer(liveId: string): IPlayer | null;
+    getAllPlayers(): IPlayer[];
+    destroyPlayer(liveId: string): void;
+    destroyAllPlayers(): void;
+}