@tencentcloud/roomkit-electron-vue3 2.3.3

package/lib/services/manager/userManager.d.ts

@@ -0,0 +1,22 @@
+import { IRoomService } from '../types';
+
+interface IUserManager {
+    setSelfInfo(options: SelfInfoOptions): Promise<void>;
+    setCustomInfoForUser(options: CustomInfoForUser): Promise<void>;
+}
+export type CustomInfoForUser = {
+    userId: string;
+    customInfo: Record<string, string>;
+};
+export type SelfInfoOptions = {
+    userName?: string;
+    avatarUrl?: string;
+    customInfo?: Record<string, any>;
+};
+export declare class UserManager implements IUserManager {
+    private service;
+    constructor(service: IRoomService);
+    setSelfInfo(options: SelfInfoOptions): Promise<void>;
+    setCustomInfoForUser(options: CustomInfoForUser): Promise<any>;
+}
+export {};

package/lib/services/manager/userManager.js

@@ -0,0 +1,29 @@
+"use strict";
+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);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const TUIRoomEngine = require("@tencentcloud/tuiroom-engine-electron");
+class UserManager {
+  constructor(service) {
+    __publicField(this, "service");
+    this.service = service;
+  }
+  async setSelfInfo(options) {
+    const { avatarUrl, userName } = await TUIRoomEngine.getSelfInfo();
+    const info = {
+      userName: options.userName || userName,
+      avatarUrl: options.avatarUrl || avatarUrl
+    };
+    this.service.basicStore.setBasicInfo(info);
+    return TUIRoomEngine.setSelfInfo(info);
+  }
+  async setCustomInfoForUser(options) {
+    const roomEngine = this.service.roomEngine.instance;
+    return roomEngine == null ? void 0 : roomEngine.setCustomInfoForUser(options);
+  }
+}
+exports.UserManager = UserManager;

package/lib/services/roomService.d.ts

@@ -0,0 +1,80 @@
+import { VirtualBackground } from './function/virtualBackground';
+import { WaterMark } from './function/waterMark';
+import { JoinParams, RoomActionManager, StartParams } from './manager/roomActionManager';
+import { LifeCycleManager } from './manager/lifeCycleManager';
+import { SelfInfoOptions, UserManager } from './manager/userManager';
+import { ConfigManager, LanguageOption, ThemeOption } from './manager/configManager';
+import { ComponentConfig, ComponentManager, ComponentName } from './manager/componentManager';
+import { EventType, IRoomService, RoomInitData, RoomParam } from './types';
+
+export declare const roomEngine: Record<string, any>;
+export declare class RoomService implements IRoomService {
+    static instance?: RoomService;
+    private emitter;
+    componentManager: ComponentManager;
+    configManager: ConfigManager;
+    userManager: UserManager;
+    lifeCycleManager: LifeCycleManager;
+    roomActionManager: RoomActionManager;
+    waterMark: WaterMark;
+    virtualBackground: VirtualBackground;
+    roomEngine: Record<string, any>;
+    t: any;
+    get basicStore(): any;
+    get roomStore(): any;
+    get chatStore(): any;
+    constructor();
+    private initEventCtx;
+    static getInstance(): RoomService;
+    static destroyInstance(): void;
+    useExtension(extension: any): void;
+    getRoomContainer(): HTMLElement | Element;
+    initMediaDeviceList(): void;
+    bindRoomEngineEvents(): void;
+    unBindRoomEngineEvents(): void;
+    private onError;
+    private onRoomDismissed;
+    private onUserVoiceVolumeChanged;
+    private onUserNetworkQualityChanged;
+    private onKickedOutOfRoom;
+    private onSendMessageForUserDisableChanged;
+    private onUserSigExpired;
+    private onKickedOffLine;
+    private onAllUserCameraDisableChanged;
+    private handleVideoStateChange;
+    private onAllUserMicrophoneDisableChanged;
+    private onSendMessageForAllUserDisableChanged;
+    private handleMessageStateChange;
+    private handleAudioStateChange;
+    resetStore(): void;
+    private storeInit;
+    initRoomKit(option: RoomInitData): Promise<void>;
+    start(roomId: string, params?: StartParams): Promise<void>;
+    join(roomId: string, params?: JoinParams): Promise<void>;
+    createRoom(options: {
+        roomId: string;
+        roomName?: string;
+        roomMode: 'FreeToSpeak' | 'SpeakAfterTakingSeat';
+        roomParam?: RoomParam;
+    }): Promise<void>;
+    enterRoom(options: {
+        roomId: string;
+        roomParam?: RoomParam;
+    }): Promise<void>;
+    leaveRoom(): Promise<void>;
+    dismissRoom(): Promise<void>;
+    handleRoomEngineReady(): Promise<void>;
+    logOut(): void;
+    on(eventType: EventType, callback: (data?: any) => any): void;
+    off(eventType: EventType, callback: (data?: any) => void): void;
+    emit(eventType: EventType, data?: any): void;
+    getComponentConfig(name: ComponentName): {
+        [key: string]: any;
+        visible: boolean;
+    };
+    setComponentConfig(options: Partial<ComponentConfig>): boolean;
+    setTheme(theme: ThemeOption): void;
+    setLanguage(language: LanguageOption): void;
+    setSelfInfo(options: SelfInfoOptions): Promise<void>;
+}
+export declare const roomService: RoomService;

package/lib/services/roomService.js

@@ -0,0 +1,366 @@
+"use strict";
+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);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mitt = require("mitt");
+const useRoomEngine = require("../hooks/useRoomEngine.js");
+const types = require("./types.js");
+const TUIRoomEngine = require("@tencentcloud/tuiroom-engine-electron");
+const basic = require("../stores/basic.js");
+const room = require("../stores/room.js");
+const chat = require("../stores/chat.js");
+const useDeviceManager = require("../hooks/useDeviceManager.js");
+const index$1 = require("../utils/common/logger/index.js");
+const environment = require("../utils/environment.js");
+const index = require("../locales/index.js");
+const message = require("../constants/message.js");
+const componentManager = require("./manager/componentManager.js");
+const configManager = require("./manager/configManager.js");
+const userManager = require("./manager/userManager.js");
+const lifeCycleManager = require("./manager/lifeCycleManager.js");
+const roomActionManager = require("./manager/roomActionManager.js");
+const waterMark = require("./function/waterMark.js");
+const virtualBackground = require("./function/virtualBackground.js");
+const { t } = index.default.global;
+const logPrefix = "[RoomService]";
+const roomEngine = useRoomEngine.default();
+const _RoomService = class _RoomService {
+  constructor() {
+    __publicField(this, "emitter", mitt());
+    __publicField(this, "componentManager", new componentManager.ComponentManager(this));
+    __publicField(this, "configManager", new configManager.ConfigManager(this));
+    __publicField(this, "userManager", new userManager.UserManager(this));
+    __publicField(this, "lifeCycleManager", new lifeCycleManager.LifeCycleManager(this));
+    __publicField(this, "roomActionManager", new roomActionManager.RoomActionManager(this));
+    __publicField(this, "waterMark", new waterMark.WaterMark(this));
+    __publicField(this, "virtualBackground", new virtualBackground.VirtualBackground(this));
+    __publicField(this, "roomEngine", roomEngine);
+    __publicField(this, "t", t);
+    this.lifeCycleManager.start();
+    this.initEventCtx();
+    TUIRoomEngine.once("ready", () => {
+      this.bindRoomEngineEvents();
+      this.handleRoomEngineReady();
+    });
+  }
+  get basicStore() {
+    return basic.useBasicStore();
+  }
+  get roomStore() {
+    return room.useRoomStore();
+  }
+  get chatStore() {
+    return chat.useChatStore();
+  }
+  initEventCtx() {
+    this.onError = this.onError.bind(this);
+    this.onRoomDismissed = this.onRoomDismissed.bind(this);
+    this.onUserVoiceVolumeChanged = this.onUserVoiceVolumeChanged.bind(this);
+    this.onUserNetworkQualityChanged = this.onUserNetworkQualityChanged.bind(this);
+    this.onKickedOutOfRoom = this.onKickedOutOfRoom.bind(this);
+    this.onSendMessageForUserDisableChanged = this.onSendMessageForUserDisableChanged.bind(this);
+    this.onUserSigExpired = this.onUserSigExpired.bind(this);
+    this.onKickedOffLine = this.onKickedOffLine.bind(this);
+    this.onAllUserCameraDisableChanged = this.onAllUserCameraDisableChanged.bind(this);
+    this.onAllUserMicrophoneDisableChanged = this.onAllUserMicrophoneDisableChanged.bind(this);
+    this.onSendMessageForAllUserDisableChanged = this.onSendMessageForAllUserDisableChanged.bind(this);
+  }
+  static getInstance() {
+    if (!_RoomService.instance) {
+      _RoomService.instance = new _RoomService();
+    }
+    return _RoomService.instance;
+  }
+  static destroyInstance() {
+    if (!_RoomService.instance)
+      return;
+    _RoomService.instance.lifeCycleManager.stop();
+    _RoomService.instance.unBindRoomEngineEvents();
+    _RoomService.instance.waterMark.dispose();
+    _RoomService.instance.virtualBackground.dispose();
+    _RoomService.instance = void 0;
+  }
+  useExtension(extension) {
+    extension._bind(this);
+  }
+  getRoomContainer() {
+    return document.fullscreenElement || document.getElementById("roomContainer") || document.body;
+  }
+  initMediaDeviceList() {
+    useDeviceManager.default({ listenForDeviceChange: true });
+  }
+  bindRoomEngineEvents() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    (_a = roomEngine.instance) == null ? void 0 : _a.on(TUIRoomEngine.TUIRoomEvents.onError, this.onError);
+    (_b = roomEngine.instance) == null ? void 0 : _b.on(TUIRoomEngine.TUIRoomEvents.onRoomDismissed, this.onRoomDismissed);
+    (_c = roomEngine.instance) == null ? void 0 : _c.on(TUIRoomEngine.TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
+    (_d = roomEngine.instance) == null ? void 0 : _d.on(TUIRoomEngine.TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
+    (_e = roomEngine.instance) == null ? void 0 : _e.on(TUIRoomEngine.TUIRoomEvents.onKickedOutOfRoom, this.onKickedOutOfRoom);
+    (_f = roomEngine.instance) == null ? void 0 : _f.on(
+      TUIRoomEngine.TUIRoomEvents.onSendMessageForUserDisableChanged,
+      this.onSendMessageForUserDisableChanged
+    );
+    (_g = roomEngine.instance) == null ? void 0 : _g.on(TUIRoomEngine.TUIRoomEvents.onUserSigExpired, this.onUserSigExpired);
+    (_h = roomEngine.instance) == null ? void 0 : _h.on(TUIRoomEngine.TUIRoomEvents.onKickedOffLine, this.onKickedOffLine);
+    (_i = roomEngine.instance) == null ? void 0 : _i.on(TUIRoomEngine.TUIRoomEvents.onAllUserCameraDisableChanged, this.onAllUserCameraDisableChanged);
+    (_j = roomEngine.instance) == null ? void 0 : _j.on(TUIRoomEngine.TUIRoomEvents.onAllUserMicrophoneDisableChanged, this.onAllUserMicrophoneDisableChanged);
+    (_k = roomEngine.instance) == null ? void 0 : _k.on(
+      TUIRoomEngine.TUIRoomEvents.onSendMessageForAllUserDisableChanged,
+      this.onSendMessageForAllUserDisableChanged
+    );
+  }
+  unBindRoomEngineEvents() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    (_a = roomEngine.instance) == null ? void 0 : _a.off(TUIRoomEngine.TUIRoomEvents.onError, this.onError);
+    (_b = roomEngine.instance) == null ? void 0 : _b.off(TUIRoomEngine.TUIRoomEvents.onRoomDismissed, this.onRoomDismissed);
+    (_c = roomEngine.instance) == null ? void 0 : _c.off(TUIRoomEngine.TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
+    (_d = roomEngine.instance) == null ? void 0 : _d.off(TUIRoomEngine.TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
+    (_e = roomEngine.instance) == null ? void 0 : _e.off(TUIRoomEngine.TUIRoomEvents.onKickedOutOfRoom, this.onKickedOutOfRoom);
+    (_f = roomEngine.instance) == null ? void 0 : _f.off(TUIRoomEngine.TUIRoomEvents.onSendMessageForUserDisableChanged, this.onSendMessageForUserDisableChanged);
+    (_g = roomEngine.instance) == null ? void 0 : _g.off(TUIRoomEngine.TUIRoomEvents.onUserSigExpired, this.onUserSigExpired);
+    (_h = roomEngine.instance) == null ? void 0 : _h.off(TUIRoomEngine.TUIRoomEvents.onKickedOffLine, this.onKickedOffLine);
+    (_i = roomEngine.instance) == null ? void 0 : _i.off(TUIRoomEngine.TUIRoomEvents.onAllUserCameraDisableChanged, this.onAllUserCameraDisableChanged);
+    (_j = roomEngine.instance) == null ? void 0 : _j.off(TUIRoomEngine.TUIRoomEvents.onAllUserMicrophoneDisableChanged, this.onAllUserMicrophoneDisableChanged);
+    (_k = roomEngine.instance) == null ? void 0 : _k.off(
+      TUIRoomEngine.TUIRoomEvents.onSendMessageForAllUserDisableChanged,
+      this.onSendMessageForAllUserDisableChanged
+    );
+  }
+  onError(error) {
+    index$1.default.error("roomEngine.onError: ", error);
+    if (error.message === "enter trtc room failed , error code : -1") {
+      this.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        type: "warning",
+        message: t("Failed to enter the meeting"),
+        callback: () => {
+          this.emit(types.EventType.ROOM_ERROR);
+          this.resetStore();
+        }
+      });
+    }
+  }
+  onRoomDismissed(eventInfo) {
+    const { roomId } = eventInfo;
+    index$1.default.log(`${logPrefix}onRoomDismissed:`, roomId);
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+      title: t("Note"),
+      message: t("The host closed the room."),
+      confirmButtonText: t("Sure"),
+      callback: async () => {
+        this.emit(types.EventType.ROOM_DISMISS, {});
+        this.resetStore();
+      }
+    });
+  }
+  onUserVoiceVolumeChanged(eventInfo) {
+    const { userVolumeList } = eventInfo;
+    this.roomStore.setAudioVolume(userVolumeList);
+  }
+  onUserNetworkQualityChanged(eventInfo) {
+    this.basicStore.setLocalQuality(eventInfo.userNetworkList);
+  }
+  async onKickedOutOfRoom(eventInfo) {
+    const { roomId, reason, message: message2 } = eventInfo;
+    try {
+      let notice = "";
+      switch (reason) {
+        case TUIRoomEngine.TUIKickedOutOfRoomReason.kKickedByAdmin:
+          notice = t("kicked out of the room by the host");
+          break;
+        case TUIRoomEngine.TUIKickedOutOfRoomReason.kKickedByLoggedOnOtherDevice:
+          notice = t("kicked out of the room by other device");
+          break;
+        case TUIRoomEngine.TUIKickedOutOfRoomReason.kKickedByServer:
+          notice = t("kicked out of the room by serve");
+          break;
+      }
+      this.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        title: t("Note"),
+        message: notice,
+        confirmButtonText: t("Sure"),
+        callback: async () => {
+          this.emit(types.EventType.KICKED_OUT, { roomId, reason, message: message2 });
+          this.resetStore();
+        }
+      });
+    } catch (error) {
+      index$1.default.error(`${logPrefix}onKickedOutOfRoom error:`, error);
+    }
+  }
+  onSendMessageForUserDisableChanged(data) {
+    const { userId, isDisable } = data;
+    if (userId === this.roomStore.localUser.userId) {
+      const tipMessage = isDisable ? t("You have been banned from text chat") : t("You are allowed to text chat");
+      this.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
+        code: -1,
+        type: "warning",
+        message: tipMessage,
+        duration: message.MESSAGE_DURATION.NORMAL
+      });
+      this.chatStore.setSendMessageDisableChanged(isDisable);
+    }
+    this.roomStore.setMuteUserChat(userId, isDisable);
+  }
+  onUserSigExpired() {
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+      title: t("Note"),
+      message: t("userSig has expired"),
+      confirmButtonText: t("Sure"),
+      callback: () => {
+        this.emit(types.EventType.USER_SIG_EXPIRED, {});
+      }
+    });
+  }
+  onKickedOffLine(eventInfo) {
+    const { message: message2 } = eventInfo;
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+      title: t("Note"),
+      message: t("The system has detected that your account has been kicked offline"),
+      confirmButtonText: t("Sure"),
+      callback: async () => {
+        this.emit(types.EventType.KICKED_OFFLINE, { message: message2 });
+      }
+    });
+  }
+  async onAllUserCameraDisableChanged(eventInfo) {
+    const { isDisable } = eventInfo;
+    if (isDisable !== this.roomStore.isCameraDisableForAllUser && this.roomStore.localUser.userRole === TUIRoomEngine.TUIRole.kGeneralUser) {
+      this.roomStore.setCanControlSelfVideo(!isDisable);
+    }
+    this.handleVideoStateChange(isDisable);
+    this.roomStore.setDisableCameraForAllUserByAdmin(isDisable);
+  }
+  async handleVideoStateChange(isDisableVideo) {
+    var _a;
+    const tipMessage = isDisableVideo ? t("All videos disabled") : t("All videos enabled");
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
+      type: "success",
+      message: tipMessage,
+      duration: message.MESSAGE_DURATION.NORMAL
+    });
+    if (isDisableVideo && this.roomStore.localUser.userRole === TUIRoomEngine.TUIRole.kGeneralUser) {
+      await ((_a = roomEngine.instance) == null ? void 0 : _a.closeLocalCamera());
+    }
+  }
+  async onAllUserMicrophoneDisableChanged(eventInfo) {
+    const { isDisable } = eventInfo;
+    if (isDisable !== this.roomStore.isMicrophoneDisableForAllUser && this.roomStore.localUser.userRole === TUIRoomEngine.TUIRole.kGeneralUser) {
+      this.roomStore.setCanControlSelfAudio(!isDisable);
+    }
+    this.handleAudioStateChange(isDisable);
+    this.roomStore.setDisableMicrophoneForAllUserByAdmin(isDisable);
+  }
+  async onSendMessageForAllUserDisableChanged(eventInfo) {
+    const { isDisable } = eventInfo;
+    if (isDisable !== this.roomStore.isMessageDisableForAllUser && this.roomStore.localUser.userRole === TUIRoomEngine.TUIRole.kGeneralUser) {
+      this.handleMessageStateChange(isDisable);
+    }
+    this.roomStore.setDisableMessageAllUserByAdmin(isDisable);
+  }
+  async handleMessageStateChange(isDisableMessage) {
+    const tipMessage = isDisableMessage ? t("Disabling text chat for all is enabled") : t("Unblocked all text chat");
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
+      type: "success",
+      message: tipMessage,
+      duration: message.MESSAGE_DURATION.NORMAL
+    });
+  }
+  async handleAudioStateChange(isDisableAudio) {
+    var _a;
+    const tipMessage = isDisableAudio ? t("All audios disabled") : t("All audios enabled");
+    this.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
+      type: "success",
+      message: tipMessage,
+      duration: message.MESSAGE_DURATION.NORMAL
+    });
+    if (isDisableAudio && this.roomStore.localUser.userRole === TUIRoomEngine.TUIRole.kGeneralUser) {
+      await ((_a = roomEngine.instance) == null ? void 0 : _a.muteLocalAudio());
+    }
+  }
+  resetStore() {
+    this.basicStore.reset();
+    this.chatStore.reset();
+    this.roomStore.reset();
+  }
+  storeInit(option) {
+    this.basicStore.setBasicInfo(option);
+    this.roomStore.setLocalUser(option);
+  }
+  async initRoomKit(option) {
+    this.storeInit(option);
+    const { sdkAppId, userId, userSig, userName = userId, avatarUrl = "" } = option;
+    await TUIRoomEngine.login({ sdkAppId, userId, userSig });
+    await TUIRoomEngine.setSelfInfo({ userName, avatarUrl });
+  }
+  async start(roomId, params) {
+    return this.roomActionManager.start(roomId, params);
+  }
+  async join(roomId, params) {
+    return this.roomActionManager.join(roomId, params);
+  }
+  async createRoom(options) {
+    await this.roomActionManager.createRoom(options);
+  }
+  async enterRoom(options) {
+    await this.roomActionManager.enterRoom(options);
+  }
+  async leaveRoom() {
+    await this.roomActionManager.leaveRoom();
+  }
+  async dismissRoom() {
+    await this.roomActionManager.dismissRoom();
+  }
+  async handleRoomEngineReady() {
+    var _a;
+    const storageCurrentTheme = localStorage.getItem("tuiRoom-currentTheme");
+    storageCurrentTheme && this.basicStore.setDefaultTheme(storageCurrentTheme);
+    const trtcCloud = (_a = roomEngine.instance) == null ? void 0 : _a.getTRTCCloud();
+    const mirrorType = environment.isMobile ? TUIRoomEngine.TRTCVideoMirrorType.TRTCVideoMirrorType_Auto : this.basicStore.isLocalStreamMirror ? TUIRoomEngine.TRTCVideoMirrorType.TRTCVideoMirrorType_Enable : TUIRoomEngine.TRTCVideoMirrorType.TRTCVideoMirrorType_Disable;
+    await (trtcCloud == null ? void 0 : trtcCloud.setLocalRenderParams({
+      mirrorType,
+      rotation: TUIRoomEngine.TRTCVideoRotation.TRTCVideoRotation0,
+      fillMode: TUIRoomEngine.TRTCVideoFillMode.TRTCVideoFillMode_Fill
+    }));
+  }
+  logOut() {
+    this.emit(types.EventType.USER_LOGOUT);
+    this.resetStore();
+  }
+  on(eventType, callback) {
+    this.emitter.on(eventType, callback);
+  }
+  off(eventType, callback) {
+    this.emitter.off(eventType, callback);
+  }
+  emit(eventType, data) {
+    this.emitter.emit(eventType, data);
+  }
+  // Component Manager
+  getComponentConfig(name) {
+    return this.componentManager.getComponentConfig(name);
+  }
+  setComponentConfig(options) {
+    return this.componentManager.setComponentConfig(options);
+  }
+  // Config Manager
+  setTheme(theme) {
+    return this.configManager.setTheme(theme);
+  }
+  setLanguage(language) {
+    return this.configManager.setLanguage(language);
+  }
+  // User Manager
+  setSelfInfo(options) {
+    return this.userManager.setSelfInfo(options);
+  }
+};
+__publicField(_RoomService, "instance");
+let RoomService = _RoomService;
+const roomService = RoomService.getInstance();
+exports.RoomService = RoomService;
+exports.roomEngine = roomEngine;
+exports.roomService = roomService;

package/lib/services/types.d.ts

@@ -0,0 +1,52 @@
+import { LifeCycleManager } from './manager/lifeCycleManager';
+import { useChatStore } from '../stores/chat';
+import { useRoomStore } from '../stores/room';
+import { useBasicStore } from '../stores/basic';
+import { ChatSDK } from '@tencentcloud/chat';
+
+export interface IRoomService {
+    t: any;
+    roomEngine: Record<string, any>;
+    basicStore: ReturnType<typeof useBasicStore>;
+    roomStore: ReturnType<typeof useRoomStore>;
+    chatStore: ReturnType<typeof useChatStore>;
+    lifeCycleManager: LifeCycleManager;
+    on: (eventType: EventType, callback: (data?: any) => any) => void;
+    off: (eventType: EventType, callback: (data?: any) => void) => void;
+    emit: (eventType: EventType, data?: any) => void;
+    resetStore: () => void;
+}
+export interface RoomInitData {
+    sdkAppId: number;
+    userId: string;
+    userSig: string;
+    userName?: string;
+    avatarUrl?: string;
+    showHeaderTool?: boolean;
+    tim?: ChatSDK;
+    theme?: {
+        defaultTheme?: 'black' | 'white';
+        isSupportSwitchTheme: boolean;
+    };
+}
+export interface RoomParam {
+    isOpenCamera: boolean;
+    isOpenMicrophone: boolean;
+    defaultCameraId?: string;
+    defaultMicrophoneId?: string;
+    defaultSpeakerId?: string;
+}
+export declare enum EventType {
+    ROOM_CONTAINER_RESIZE = "RoomContainerResize",
+    ROOM_NOTICE_MESSAGE = "RoomNoticeMessage",
+    ROOM_NOTICE_MESSAGE_BOX = "RoomNoticeMessageBox",
+    ROOM_START = "RoomStart",
+    ROOM_JOIN = "RoomJoin",
+    ROOM_LEAVE = "RoomLeave",
+    ROOM_DISMISS = "RoomDestroy",
+    ROOM_ERROR = "RoomError",
+    KICKED_OUT = "KickedOut",
+    KICKED_OFFLINE = "KickedOffline",
+    USER_SIG_EXPIRED = "UserSigExpired",
+    USER_LOGOUT = "UserLogout"
+}

package/lib/services/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["ROOM_CONTAINER_RESIZE"] = "RoomContainerResize";
+  EventType2["ROOM_NOTICE_MESSAGE"] = "RoomNoticeMessage";
+  EventType2["ROOM_NOTICE_MESSAGE_BOX"] = "RoomNoticeMessageBox";
+  EventType2["ROOM_START"] = "RoomStart";
+  EventType2["ROOM_JOIN"] = "RoomJoin";
+  EventType2["ROOM_LEAVE"] = "RoomLeave";
+  EventType2["ROOM_DISMISS"] = "RoomDestroy";
+  EventType2["ROOM_ERROR"] = "RoomError";
+  EventType2["KICKED_OUT"] = "KickedOut";
+  EventType2["KICKED_OFFLINE"] = "KickedOffline";
+  EventType2["USER_SIG_EXPIRED"] = "UserSigExpired";
+  EventType2["USER_LOGOUT"] = "UserLogout";
+  return EventType2;
+})(EventType || {});
+exports.EventType = EventType;

package/lib/stores/basic.d.ts

@@ -0,0 +1 @@
+export declare const useBasicStore: any;