tuikit-atomicx-vue3 0.1.0

package/dist/states/LiveMonitorState/player/manager/playerManager.js

@@ -0,0 +1,47 @@
+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 { TRTCAdapter } from "../adapters/trtc.js";
+class PlayerManager {
+  constructor(account) {
+    __publicField(this, "account");
+    // key: liveId, value: player
+    __publicField(this, "playersMap", /* @__PURE__ */ new Map());
+    this.account = account;
+  }
+  createPlayer(liveId) {
+    const player = new TRTCAdapter(this.account);
+    this.playersMap.set(liveId, player);
+    return player;
+  }
+  createPlayers(liveIdList) {
+    const playerIds = [];
+    liveIdList.forEach((liveId) => {
+      const player = this.createPlayer(liveId);
+      playerIds.push(player.id);
+    });
+    return playerIds;
+  }
+  getPlayer(liveId) {
+    return this.playersMap.get(liveId) || null;
+  }
+  getAllPlayers() {
+    return Array.from(this.playersMap.values());
+  }
+  destroyPlayer(liveId) {
+    const player = this.getPlayer(liveId);
+    if (player) {
+      player.destroy();
+      this.playersMap.delete(liveId);
+    }
+  }
+  destroyAllPlayers() {
+    this.playersMap.forEach((player) => {
+      player.destroy();
+    });
+    this.playersMap.clear();
+  }
+}
+export {
+  PlayerManager
+};

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

@@ -0,0 +1,2 @@
+export * from './player';
+export * from './trtc';

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

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

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

@@ -0,0 +1,26 @@
+import { Account } from './trtc';
+
+export interface IPlayer {
+    readonly id: string;
+    on(event: PlayerEvents, callback: (...args: any[]) => void): void;
+    off(event: PlayerEvents, callback: (...args: any[]) => void): void;
+    play(liveId: string, viewId: string): Promise<void>;
+    stop(): Promise<void>;
+    muteAudio(mute: boolean): Promise<void>;
+    destroy(): Promise<void>;
+    getPlayerInfo(): PlayerInfo;
+}
+export type PlayerConstructor = new (account: Account) => IPlayer;
+export declare enum PlayerEvents {
+    OnStateChanged = "OnStateChanged",
+    OnReceiveSEI = "OnReceiveSEI",
+    OnUserAudioAvailable = "OnUserAudioAvailable"
+}
+export type PlayerInfo = {
+    id: string;
+    state: PlayerState;
+};
+export declare enum PlayerState {
+    Idle = "Idle",
+    Playing = "Playing"
+}

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

@@ -0,0 +1,15 @@
+var PlayerEvents = /* @__PURE__ */ ((PlayerEvents2) => {
+  PlayerEvents2["OnStateChanged"] = "OnStateChanged";
+  PlayerEvents2["OnReceiveSEI"] = "OnReceiveSEI";
+  PlayerEvents2["OnUserAudioAvailable"] = "OnUserAudioAvailable";
+  return PlayerEvents2;
+})(PlayerEvents || {});
+var PlayerState = /* @__PURE__ */ ((PlayerState2) => {
+  PlayerState2["Idle"] = "Idle";
+  PlayerState2["Playing"] = "Playing";
+  return PlayerState2;
+})(PlayerState || {});
+export {
+  PlayerEvents,
+  PlayerState
+};

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

@@ -0,0 +1,18 @@
+export declare enum TRTCRoleType {
+    TRTCRoleAnchor = 20,
+    TRTCRoleAudience = 21
+}
+export declare enum TRTCScene {
+    LIVE = 1
+}
+export declare enum TRTCVideoStreamType {
+    TRTCVideoStreamTypeBig = 0,
+    TRTCVideoStreamTypeSmall = 1,
+    TRTCVideoStreamTypeSub = 2
+}
+export type Account = {
+    sdkAppId: number;
+    userId: string;
+    password: string;
+};
+export declare const MIXED_STREAM_PAYLOAD_TYPE = 100;

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

@@ -0,0 +1,22 @@
+var TRTCRoleType = /* @__PURE__ */ ((TRTCRoleType2) => {
+  TRTCRoleType2[TRTCRoleType2["TRTCRoleAnchor"] = 20] = "TRTCRoleAnchor";
+  TRTCRoleType2[TRTCRoleType2["TRTCRoleAudience"] = 21] = "TRTCRoleAudience";
+  return TRTCRoleType2;
+})(TRTCRoleType || {});
+var TRTCScene = /* @__PURE__ */ ((TRTCScene2) => {
+  TRTCScene2[TRTCScene2["LIVE"] = 1] = "LIVE";
+  return TRTCScene2;
+})(TRTCScene || {});
+var TRTCVideoStreamType = /* @__PURE__ */ ((TRTCVideoStreamType2) => {
+  TRTCVideoStreamType2[TRTCVideoStreamType2["TRTCVideoStreamTypeBig"] = 0] = "TRTCVideoStreamTypeBig";
+  TRTCVideoStreamType2[TRTCVideoStreamType2["TRTCVideoStreamTypeSmall"] = 1] = "TRTCVideoStreamTypeSmall";
+  TRTCVideoStreamType2[TRTCVideoStreamType2["TRTCVideoStreamTypeSub"] = 2] = "TRTCVideoStreamTypeSub";
+  return TRTCVideoStreamType2;
+})(TRTCVideoStreamType || {});
+const MIXED_STREAM_PAYLOAD_TYPE = 100;
+export {
+  MIXED_STREAM_PAYLOAD_TYPE,
+  TRTCRoleType,
+  TRTCScene,
+  TRTCVideoStreamType
+};

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

@@ -0,0 +1,43 @@
+import { LiveType } from '../../../types';
+
+export type RoomInfo = {
+    RoomId: string;
+    RoomName: string;
+    RoomType: LiveType;
+    Owner_Account: string;
+    IsSeatEnabled: boolean;
+    TakeSeatMode: string;
+    MaxMemberCount: number;
+    MaxSeatCount: number;
+    IsMessageDisabled: boolean;
+    CoverURL: string;
+    IsGiftEnabled: boolean;
+    IsLikeEnabled: boolean;
+    ActivityStatus: number;
+    IsPublicVisible: boolean;
+    CreateTime: number;
+    ViewCount: number;
+    Popularity: number;
+    BackgroundURL: '';
+    IsUnlimitedRoomEnabled: boolean;
+    LifetimeAfterNoUsers: number;
+    LifetimeAfterOwnerLeave: number;
+    LifetimeAfterOwnerOffline: number;
+    KeepOwnerOnSeat: boolean;
+};
+export type Response = {
+    code: number;
+    data: any;
+};
+export type ResponseRegionInfo = {
+    uid: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    volume: number;
+};
+export type PrepareCancelTask = {
+    timestamp: number;
+    duration: number;
+};

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,6 @@
+import { MonitorLiveInfo } from '../../../types';
+import { RoomInfo } from '../types';
+
+declare const transformRoomInfoToLiveInfo: (roomInfo: RoomInfo) => MonitorLiveInfo;
+declare const getLiveIdFromMixedStreamUserId: (userId: string) => string;
+export { transformRoomInfoToLiveInfo, getLiveIdFromMixedStreamUserId };

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

@@ -0,0 +1,24 @@
+const transformRoomInfoToLiveInfo = (roomInfo) => {
+  return {
+    liveId: roomInfo.RoomId,
+    liveName: roomInfo.RoomName,
+    liveDescription: "",
+    // The return result of the getRoomInfo interface does not describe the relevant fields
+    categoryList: [],
+    coverUrl: roomInfo.CoverURL,
+    backgroundUrl: roomInfo.BackgroundURL,
+    liveOwner: roomInfo.Owner_Account,
+    currentViewerCount: roomInfo.ViewCount,
+    // Can't get it for the time being
+    totalViewerCount: roomInfo.ViewCount,
+    createTime: roomInfo.CreateTime,
+    regionList: []
+  };
+};
+const getLiveIdFromMixedStreamUserId = (userId) => {
+  return userId.split("_").splice(3).join("_");
+};
+export {
+  getLiveIdFromMixedStreamUserId,
+  transformRoomInfoToLiveInfo
+};

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

@@ -0,0 +1,37 @@
+export declare function useLiveSeatState(): {
+    seatList: import('vue').Ref<import('../..').SeatInfo[], import('../..').SeatInfo[]>;
+    canvas: import('vue').Ref<{
+        width: number;
+        height: number;
+        background: string;
+    }, import('../..').LiveCanvas | {
+        width: number;
+        height: number;
+        background: string;
+    }>;
+    speakingUsers: import('vue').Ref<Map<string, number> & Omit<Map<string, number>, keyof Map<any, any>>, Map<string, number> | (Map<string, number> & Omit<Map<string, number>, keyof Map<any, any>>)>;
+    networkQualities: import('vue').Ref<Map<string, {
+        userId: string;
+        quality: import('../..').TUINetworkQuality;
+        upLoss: number;
+        downLoss: number;
+        delay: number;
+    }> & Omit<Map<string, import('../..').TUINetwork>, keyof Map<any, any>>, Map<string, import('../..').TUINetwork> | (Map<string, {
+        userId: string;
+        quality: import('../..').TUINetworkQuality;
+        upLoss: number;
+        downLoss: number;
+        delay: number;
+    }> & Omit<Map<string, import('../..').TUINetwork>, keyof Map<any, any>>)>;
+    startPlayStream: ({ view }: {
+        view: string;
+    }) => Promise<void>;
+    stopPlayStream: () => Promise<void>;
+    lockSeat: ({ seatIndex, isLocked }: {
+        seatIndex: number;
+        isLocked: boolean;
+    }) => Promise<any>;
+    moveToSeat: ({ targetSeatIndex }: {
+        targetSeatIndex: number;
+    }) => Promise<void | undefined>;
+};

package/dist/states/LiveSeatState/index.js

@@ -0,0 +1,21 @@
+import { useSeatStore } from "./store.js";
+import SeatManager from "./seatManager.js";
+import SeatEventManager from "./seatEventManager.js";
+const seatManager = new SeatManager();
+new SeatEventManager();
+function useLiveSeatState() {
+  const { seatList, canvas, speakingUsers, networkQualities } = useSeatStore();
+  return {
+    seatList,
+    canvas,
+    speakingUsers,
+    networkQualities,
+    startPlayStream: seatManager.startPlayStream,
+    stopPlayStream: seatManager.stopPlayStream,
+    lockSeat: seatManager.lockSeat,
+    moveToSeat: seatManager.moveToSeat
+  };
+}
+export {
+  useLiveSeatState
+};

package/dist/states/LiveSeatState/seatEventManager.d.ts

@@ -0,0 +1,12 @@
+declare class SeatEventManager {
+    static instance: SeatEventManager;
+    constructor();
+    private getNewSeatUserInfo;
+    private getNewSeatInfo;
+    private onSeatLayoutChanged;
+    private onUserNetworkQualityChanged;
+    private onUserVoiceVolumeChanged;
+    private bindEvent;
+    private unbindEvent;
+}
+export default SeatEventManager;

package/dist/states/LiveSeatState/seatEventManager.js

@@ -0,0 +1,103 @@
+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 { DeviceStatus } from "../../types/device.js";
+import TUIRoomEngine, { TUIRoomEvents, TUILiveLayoutManagerEvents } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../../hooks/useRoomEngine.js";
+import { useLiveState } from "../LiveState/index.js";
+import { useSeatStore } from "./store.js";
+const { currentLive } = useLiveState();
+const roomEngine = useRoomEngine();
+const { canvas, seatList, speakingUsers, networkQualities } = useSeatStore();
+const _SeatEventManager = class _SeatEventManager {
+  constructor() {
+    if (!_SeatEventManager.instance) {
+      _SeatEventManager.instance = this;
+    }
+    this.onSeatLayoutChanged = this.onSeatLayoutChanged.bind(this);
+    this.onUserVoiceVolumeChanged = this.onUserVoiceVolumeChanged.bind(this);
+    this.bindEvent();
+  }
+  getNewSeatUserInfo(seatRegion) {
+    var _a;
+    return {
+      userId: seatRegion.userId,
+      roomId: ((_a = currentLive.value) == null ? void 0 : _a.liveId) || "",
+      userName: seatRegion.userName,
+      avatarUrl: seatRegion.userAvatar,
+      microphoneStatus: seatRegion.isUserMicrophoneOpened ? DeviceStatus.On : DeviceStatus.Off,
+      cameraStatus: seatRegion.isUserCameraOpened ? DeviceStatus.On : DeviceStatus.Off,
+      onSeatTimestamp: Date.now(),
+      customInfo: {}
+    };
+  }
+  getNewSeatInfo(seatRegion) {
+    return {
+      index: seatRegion.seatIndex,
+      isLocked: seatRegion.isSeatLocked,
+      userInfo: this.getNewSeatUserInfo(seatRegion),
+      region: {
+        x: seatRegion.x,
+        y: seatRegion.y,
+        w: seatRegion.width,
+        h: seatRegion.height,
+        zOrder: seatRegion.zorder
+      }
+    };
+  }
+  onSeatLayoutChanged(roomId, seatLayout) {
+    var _a;
+    if (roomId !== ((_a = currentLive.value) == null ? void 0 : _a.liveId)) {
+      return;
+    }
+    canvas.value = {
+      width: seatLayout.canvasWidth,
+      height: seatLayout.canvasHeight,
+      background: "#000000"
+    };
+    seatList.value = seatLayout.regions.map((region) => {
+      return this.getNewSeatInfo(region);
+    });
+  }
+  onUserNetworkQualityChanged({ userNetworkList }) {
+    Object.keys(networkQualities.value).forEach((userId) => {
+      if (!userNetworkList.some((userNetwork) => userNetwork.userId === userId)) {
+        networkQualities.value.delete(userId);
+      }
+    });
+    userNetworkList.forEach((userNetwork) => {
+      networkQualities.value.set(userNetwork.userId, userNetwork);
+    });
+  }
+  onUserVoiceVolumeChanged({ userVolumeList }) {
+    Object.keys(speakingUsers.value).forEach((userId) => {
+      if (!userVolumeList.some((userVolume) => userVolume.userId === userId)) {
+        speakingUsers.value.delete(userId);
+      }
+    });
+    userVolumeList.forEach((userVolume) => {
+      speakingUsers.value.set(userVolume.userId, userVolume.volume);
+    });
+  }
+  bindEvent() {
+    TUIRoomEngine.once("ready", () => {
+      var _a, _b, _c;
+      (_a = roomEngine.instance) == null ? void 0 : _a.on(TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
+      (_b = roomEngine.instance) == null ? void 0 : _b.on(TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
+      const liveLayoutManager = (_c = roomEngine.instance) == null ? void 0 : _c.getLiveLayoutManager();
+      liveLayoutManager == null ? void 0 : liveLayoutManager.on(TUILiveLayoutManagerEvents.onSeatLayoutChanged, this.onSeatLayoutChanged);
+    });
+  }
+  unbindEvent() {
+    var _a, _b, _c;
+    (_a = roomEngine.instance) == null ? void 0 : _a.off(TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
+    (_b = roomEngine.instance) == null ? void 0 : _b.off(TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
+    const liveLayoutManager = (_c = roomEngine.instance) == null ? void 0 : _c.getLiveLayoutManager();
+    liveLayoutManager == null ? void 0 : liveLayoutManager.off(TUILiveLayoutManagerEvents.onSeatLayoutChanged, this.onSeatLayoutChanged);
+  }
+};
+__publicField(_SeatEventManager, "instance");
+let SeatEventManager = _SeatEventManager;
+export {
+  SeatEventManager as default
+};

package/dist/states/LiveSeatState/seatManager.d.ts

@@ -0,0 +1,16 @@
+declare class SeatManager {
+    static instance: SeatManager;
+    constructor();
+    lockSeat: ({ seatIndex, isLocked }: {
+        seatIndex: number;
+        isLocked: boolean;
+    }) => Promise<any>;
+    moveToSeat({ targetSeatIndex }: {
+        targetSeatIndex: number;
+    }): Promise<void | undefined>;
+    startPlayStream({ view }: {
+        view: string;
+    }): Promise<void>;
+    stopPlayStream(): Promise<void>;
+}
+export default SeatManager;

package/dist/states/LiveSeatState/seatManager.js

@@ -0,0 +1,47 @@
+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 { useRoomEngine } from "../../hooks/useRoomEngine.js";
+import { usePlayStream } from "./usePlayStream/index.js";
+const roomEngine = useRoomEngine();
+const { startPlayStream, stopPlayStream } = usePlayStream();
+const _SeatManager = class _SeatManager {
+  constructor() {
+    __publicField(this, "lockSeat", async ({ seatIndex, isLocked }) => {
+      var _a, _b;
+      const seatList = await ((_a = roomEngine.instance) == null ? void 0 : _a.getSeatList());
+      const seat = seatList == null ? void 0 : seatList.find((seat2) => seat2.index === seatIndex);
+      if (!seat) {
+        return;
+      }
+      return await ((_b = roomEngine.instance) == null ? void 0 : _b.lockSeatByAdmin({
+        seatIndex,
+        lockParams: {
+          lockSeat: isLocked,
+          lockVideo: seat.isVideoLocked,
+          lockAudio: seat.isAudioLocked
+        }
+      }));
+    });
+    if (!_SeatManager.instance) {
+      _SeatManager.instance = this;
+    }
+  }
+  async moveToSeat({ targetSeatIndex }) {
+    var _a;
+    return await ((_a = roomEngine.instance) == null ? void 0 : _a.moveToSeat({
+      targetSeatIndex
+    }));
+  }
+  async startPlayStream({ view }) {
+    return await startPlayStream({ view });
+  }
+  async stopPlayStream() {
+    return await stopPlayStream();
+  }
+};
+__publicField(_SeatManager, "instance");
+let SeatManager = _SeatManager;
+export {
+  SeatManager as default
+};

package/dist/states/LiveSeatState/store.d.ts

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+import { SeatInfo, LiveCanvas, TUINetwork } from '../../types';
+
+export declare function useSeatStore(): {
+    canvas: Ref<{
+        width: number;
+        height: number;
+        background: string;
+    }, LiveCanvas | {
+        width: number;
+        height: number;
+        background: string;
+    }>;
+    seatList: Ref<SeatInfo[], SeatInfo[]>;
+    speakingUsers: Ref<Map<string, number> & Omit<Map<string, number>, keyof Map<any, any>>, Map<string, number> | (Map<string, number> & Omit<Map<string, number>, keyof Map<any, any>>)>;
+    networkQualities: Ref<Map<string, {
+        userId: string;
+        quality: import('../..').TUINetworkQuality;
+        upLoss: number;
+        downLoss: number;
+        delay: number;
+    }> & Omit<Map<string, TUINetwork>, keyof Map<any, any>>, Map<string, TUINetwork> | (Map<string, {
+        userId: string;
+        quality: import('../..').TUINetworkQuality;
+        upLoss: number;
+        downLoss: number;
+        delay: number;
+    }> & Omit<Map<string, TUINetwork>, keyof Map<any, any>>)>;
+};

package/dist/states/LiveSeatState/store.js

@@ -0,0 +1,33 @@
+import { ref, watch } from "vue";
+import { LiveStatus } from "../../types/live.js";
+import { useLiveState } from "../LiveState/index.js";
+const { localLiveStatus } = useLiveState();
+const canvas = ref({
+  width: 0,
+  height: 0,
+  background: ""
+});
+const seatList = ref([]);
+const speakingUsers = ref(/* @__PURE__ */ new Map());
+const networkQualities = ref(/* @__PURE__ */ new Map());
+watch(localLiveStatus, (newVal, oldVal) => {
+  if (oldVal && newVal === LiveStatus.IDLE) {
+    canvas.value = {
+      width: 0,
+      height: 0,
+      background: ""
+    };
+    seatList.value = [];
+  }
+}, { immediate: true });
+function useSeatStore() {
+  return {
+    canvas,
+    seatList,
+    speakingUsers,
+    networkQualities
+  };
+}
+export {
+  useSeatStore
+};

package/dist/states/LiveSeatState/usePlayStream/MixStreamPlayer.d.ts

@@ -0,0 +1,17 @@
+import { DeviceStatus } from '../../../types';
+
+export declare class MixStreamPlayer {
+    private isPlayingMixStream;
+    private mixUserInfo;
+    static MixStreamPlayer: MixStreamPlayer | null;
+    constructor();
+    start(options: {
+        view: string;
+        userInfo: {
+            userId: string;
+            cameraStatus: DeviceStatus;
+        };
+    }): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/states/LiveSeatState/usePlayStream/MixStreamPlayer.js

@@ -0,0 +1,67 @@
+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 { TUIVideoStreamType } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../../../hooks/useRoomEngine.js";
+import { DeviceStatus } from "../../../types/device.js";
+const roomEngine = useRoomEngine();
+const _MixStreamPlayer = class _MixStreamPlayer {
+  constructor() {
+    __publicField(this, "isPlayingMixStream", false);
+    __publicField(this, "mixUserInfo", {
+      userId: "",
+      cameraStatus: DeviceStatus.Off
+    });
+    if (_MixStreamPlayer.MixStreamPlayer) {
+      return _MixStreamPlayer.MixStreamPlayer;
+    }
+    _MixStreamPlayer.MixStreamPlayer = this;
+  }
+  async start(options) {
+    var _a, _b;
+    console.log("MixStreamPlayer.startPlay: ", options);
+    const {
+      view,
+      userInfo: { userId, cameraStatus }
+    } = options;
+    this.mixUserInfo.userId = userId;
+    this.mixUserInfo.cameraStatus = cameraStatus;
+    if (this.isPlayingMixStream) {
+      return;
+    }
+    if (userId && cameraStatus === DeviceStatus.On) {
+      (_a = roomEngine.instance) == null ? void 0 : _a.setRemoteVideoView({
+        userId,
+        streamType: TUIVideoStreamType.kCameraStream,
+        view
+      });
+      await ((_b = roomEngine.instance) == null ? void 0 : _b.startPlayRemoteVideo({
+        userId,
+        streamType: TUIVideoStreamType.kCameraStream
+      }));
+      this.isPlayingMixStream = true;
+    }
+  }
+  async stop() {
+    var _a;
+    console.log("MixStreamPlayer.stop: ", this.mixUserInfo);
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.stopPlayRemoteVideo({
+      userId: this.mixUserInfo.userId,
+      streamType: TUIVideoStreamType.kCameraStream
+    }));
+    this.isPlayingMixStream = false;
+    this.mixUserInfo.userId = "";
+    this.mixUserInfo.cameraStatus = DeviceStatus.Off;
+  }
+  async destroy() {
+    if (this.isPlayingMixStream) {
+      await this.stop();
+    }
+    _MixStreamPlayer.MixStreamPlayer = null;
+  }
+};
+__publicField(_MixStreamPlayer, "MixStreamPlayer", null);
+let MixStreamPlayer = _MixStreamPlayer;
+export {
+  MixStreamPlayer
+};

package/dist/states/LiveSeatState/usePlayStream/RTCStreamManager.d.ts

@@ -0,0 +1,28 @@
+import { DeviceStatus } from '../../../types';
+
+export type UserPlayOption = {
+    userId: string;
+    cameraStatus: DeviceStatus;
+    rect: {
+        left: string;
+        top: string;
+        width: string;
+        height: string;
+        zIndex: number;
+    };
+};
+export declare class RTCStreamManager {
+    static rtcStreamManager: RTCStreamManager | null;
+    private containerView;
+    private view;
+    private playerMap;
+    constructor();
+    start(options: {
+        view: string;
+        userList: UserPlayOption[];
+    }): Promise<void>;
+    update(options: {
+        userList: UserPlayOption[];
+    }): Promise<void>;
+    stop(): Promise<void>;
+}