tuikit-atomicx-vue3 0.1.0

package/dist/states/SeatStore.js

@@ -0,0 +1,252 @@
+import { computed, ref, watch } from "vue";
+import TUIRoomEngine, { TUIMediaDevice, TUIRoomEvents, TUILiveConnectionManagerEvents, TUIRequestAction } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../hooks/useRoomEngine.js";
+import { DeviceStatus } from "../types/device.js";
+import { LiveStatus } from "../types/live.js";
+import { useLiveState } from "./LiveState/index.js";
+import { useLoginState } from "./LoginState.js";
+const { localLiveStatus, currentLive } = useLiveState();
+const { loginUserInfo } = useLoginState();
+const roomEngine = useRoomEngine();
+const liveOwnerUserId = computed(() => {
+  var _a, _b;
+  return ((_b = (_a = currentLive.value) == null ? void 0 : _a.liveOwner) == null ? void 0 : _b.userId) || "";
+});
+const localUserId = computed(() => {
+  var _a;
+  return ((_a = loginUserInfo.value) == null ? void 0 : _a.userId) || "";
+});
+const sentDeviceRequestMap = ref(/* @__PURE__ */ new Map());
+const receivedDeviceRequestMap = ref(/* @__PURE__ */ new Map());
+const userInfoMap = ref(/* @__PURE__ */ new Map());
+const seatListCache = ref([]);
+const coHostUserListCache = ref([]);
+const userNetworkListCache = ref([]);
+const userVideoOpenSet = ref(/* @__PURE__ */ new Set());
+const userAudioOpenSet = ref(/* @__PURE__ */ new Set());
+const getUserInfo = async (userId) => {
+  var _a;
+  const userInfo = await ((_a = roomEngine.instance) == null ? void 0 : _a.getUserInfo({
+    userId
+  }));
+  const audienceInfo = {
+    userId,
+    userName: userInfo.userName,
+    avatarUrl: userInfo.avatarUrl,
+    customInfo: userInfo.roomCustomInfo,
+    userRole: userInfo.userRole,
+    isMessageDisabled: userInfo.isMessageDisabled
+  };
+  return audienceInfo;
+};
+const convertUserInfoToAudienceInfo = (userInfo) => ({
+  userId: userInfo.userId,
+  userName: userInfo.userName,
+  avatarUrl: userInfo.avatarUrl,
+  customInfo: userInfo.roomCustomInfo,
+  userRole: userInfo.userRole,
+  isMessageDisabled: userInfo.isMessageDisabled
+});
+const getDeviceStatus = (userId, deviceType) => {
+  const isDeviceOpen = userAudioOpenSet.value.has(userId) || userVideoOpenSet.value.has(userId);
+  const hasPendingRequest = receivedDeviceRequestMap.value.has(`${liveOwnerUserId.value}-${deviceType}`) || sentDeviceRequestMap.value.has(`${userId}-${deviceType}`);
+  if (hasPendingRequest) {
+    return DeviceStatus.AdminInviting;
+  }
+  return isDeviceOpen ? DeviceStatus.On : DeviceStatus.Off;
+};
+const seatList = computed(() => seatListCache.value.map((seat) => {
+  const hasUser = seat.userId !== "";
+  return {
+    index: seat.index,
+    isLocked: seat.isLocked,
+    isVideoLocked: seat.isVideoLocked,
+    isAudioLocked: seat.isAudioLocked,
+    userInfo: hasUser ? {
+      roomId: "",
+      userId: seat.userId,
+      userName: seat.userName,
+      avatarUrl: seat.avatarUrl,
+      microphoneStatus: getDeviceStatus(seat.userId, TUIMediaDevice.kMicrophone),
+      cameraStatus: getDeviceStatus(seat.userId, TUIMediaDevice.kCamera),
+      onSeatTimestamp: 0,
+      customInfo: {}
+    } : void 0
+  };
+}));
+const coHostUserList = computed(() => coHostUserListCache.value.map((seat) => {
+  const userInfo = userInfoMap.value.get(seat.userId);
+  return {
+    index: 0,
+    // todo engine 未提供
+    isLocked: false,
+    // todo engine 未提供
+    isVideoLocked: false,
+    // todo engine 未提供
+    isAudioLocked: false,
+    // todo engine 未提供
+    userInfo: userInfo ? {
+      roomId: seat.roomId,
+      userId: userInfo.userId,
+      userName: userInfo.userName,
+      avatarUrl: userInfo.avatarUrl,
+      microphoneStatus: getDeviceStatus(userInfo.userId, TUIMediaDevice.kMicrophone),
+      cameraStatus: getDeviceStatus(userInfo.userId, TUIMediaDevice.kCamera),
+      onSeatTimestamp: seat.joinConnectionTime,
+      networkQuality: void 0,
+      customInfo: userInfo.customInfo
+    } : void 0
+  };
+}));
+const onRequestReceived = async ({ request }) => {
+  const { userId, requestAction } = request;
+  userInfoMap.value.set(userId, await getUserInfo(userId));
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToOpenRemoteCamera:
+    case TUIRequestAction.kRequestToOpenRemoteMicrophone:
+      receivedDeviceRequestMap.value.set(`${liveOwnerUserId.value}-${requestAction}`, request);
+      break;
+    case TUIRequestAction.kApplyToAdminToOpenLocalCamera:
+    case TUIRequestAction.kApplyToAdminToOpenLocalMicrophone:
+      receivedDeviceRequestMap.value.set(`${userId}-${requestAction}`, request);
+      break;
+  }
+};
+const onRequestProcessed = ({
+  requestId,
+  userId,
+  request,
+  userInfo
+}) => {
+  const { requestAction } = request;
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToOpenRemoteCamera:
+    case TUIRequestAction.kRequestToOpenRemoteMicrophone:
+      receivedDeviceRequestMap.value.delete(`${liveOwnerUserId.value}-${requestAction}`);
+      break;
+    case TUIRequestAction.kApplyToAdminToOpenLocalCamera:
+    case TUIRequestAction.kApplyToAdminToOpenLocalMicrophone:
+      receivedDeviceRequestMap.value.delete(`${userId}-${requestAction}`);
+      break;
+  }
+};
+const onRequestCancelled = ({
+  requestId,
+  userId,
+  request,
+  userInfo
+}) => {
+  const { requestAction } = request;
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToOpenRemoteCamera:
+    case TUIRequestAction.kRequestToOpenRemoteMicrophone:
+      receivedDeviceRequestMap.value.delete(`${liveOwnerUserId.value}-${requestAction}`);
+      break;
+    case TUIRequestAction.kApplyToAdminToOpenLocalCamera:
+    case TUIRequestAction.kApplyToAdminToOpenLocalMicrophone:
+      receivedDeviceRequestMap.value.delete(`${userId}-${requestAction}`);
+      break;
+  }
+};
+const onSeatListChanged = async (options) => {
+  seatListCache.value = options.seatList;
+};
+const onUserNetworkQualityChanged = ({ userNetworkList }) => {
+  userNetworkListCache.value = userNetworkList;
+};
+const onUserVideoStateChanged = ({
+  userId,
+  streamType,
+  hasVideo,
+  reason
+}) => {
+  if (hasVideo) {
+    userVideoOpenSet.value.add(userId);
+  } else {
+    userVideoOpenSet.value.delete(userId);
+  }
+};
+const onUserAudioStateChanged = ({
+  userId,
+  hasAudio,
+  reason
+}) => {
+  if (hasAudio) {
+    userAudioOpenSet.value.add(userId);
+  } else {
+    userAudioOpenSet.value.delete(userId);
+  }
+};
+const onConnectionUserListChanged = (options) => {
+  const connectedList = options.connectedList.map((user) => JSON.parse(user));
+  options.joinedList.map((user) => JSON.parse(user));
+  options.leavedList.map((user) => JSON.parse(user));
+  Promise.all(
+    connectedList.map(async (user) => {
+      if (!userInfoMap.value.has(user.userId)) {
+        const userInfo = await getUserInfo(user.userId);
+        userInfoMap.value.set(user.userId, userInfo);
+      }
+    })
+  );
+  coHostUserListCache.value = connectedList;
+};
+const roomEvents = [
+  { event: TUIRoomEvents.onRequestReceived, handler: onRequestReceived },
+  { event: TUIRoomEvents.onRequestProcessed, handler: onRequestProcessed },
+  { event: TUIRoomEvents.onRequestCancelled, handler: onRequestCancelled },
+  { event: TUIRoomEvents.onSeatListChanged, handler: onSeatListChanged },
+  { event: TUIRoomEvents.onUserNetworkQualityChanged, handler: onUserNetworkQualityChanged },
+  { event: TUIRoomEvents.onUserVideoStateChanged, handler: onUserVideoStateChanged },
+  { event: TUIRoomEvents.onUserAudioStateChanged, handler: onUserAudioStateChanged }
+];
+const liveConnectionManagerEvents = [
+  { event: TUILiveConnectionManagerEvents.onConnectionUserListChanged, handler: onConnectionUserListChanged }
+];
+const bindEvent = () => {
+  roomEvents.forEach(({ event, handler }) => {
+    var _a;
+    (_a = roomEngine.instance) == null ? void 0 : _a.on(event, handler);
+  });
+  liveConnectionManagerEvents.forEach(({ event, handler }) => {
+    var _a, _b;
+    (_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.on(event, handler);
+  });
+};
+const reset = () => {
+  sentDeviceRequestMap.value.clear();
+  receivedDeviceRequestMap.value.clear();
+  userInfoMap.value.clear();
+  seatListCache.value = [];
+  coHostUserListCache.value = [];
+  userNetworkListCache.value = [];
+  userVideoOpenSet.value.clear();
+  userAudioOpenSet.value.clear();
+};
+watch(localLiveStatus, async (newVal) => {
+  var _a;
+  if (newVal === LiveStatus.Live) {
+    seatListCache.value = await ((_a = roomEngine.instance) == null ? void 0 : _a.getSeatList()) || [];
+  } else {
+    reset();
+  }
+});
+TUIRoomEngine.once("ready", () => {
+  bindEvent();
+});
+function useSeatStore() {
+  return {
+    liveOwnerUserId,
+    localUserId,
+    seatList,
+    coHostUserList,
+    sentDeviceRequestMap,
+    receivedDeviceRequestMap,
+    userInfoMap,
+    getUserInfo,
+    convertUserInfoToAudienceInfo
+  };
+}
+export {
+  useSeatStore
+};

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

@@ -0,0 +1,5 @@
+import { IUserState } from './store';
+import { IUserManager } from './userManager';
+
+export declare function useUserState(): IUserState & IUserManager;
+export default useUserState;

package/dist/states/UserState/index.js

@@ -0,0 +1,55 @@
+import useUserStore, { innerUserStore } from "./store.js";
+import UserManager from "./userManager.js";
+import { watch } from "vue";
+import { LocalRoomStatus } from "../../types/room.js";
+import { useRoomState } from "../RoomState.js";
+import { useLoginState } from "../LoginState.js";
+const store = useUserStore();
+const manager = new UserManager();
+const { loginUserInfo } = useLoginState();
+const { localRoomStatus } = useRoomState();
+watch(loginUserInfo, async (newVal, oldVal) => {
+  var _a, _b, _c;
+  if (!(oldVal == null ? void 0 : oldVal.userId) && (newVal == null ? void 0 : newVal.userId)) {
+    innerUserStore.addUserInfo({
+      userId: (_a = loginUserInfo.value) == null ? void 0 : _a.userId,
+      userName: (_b = loginUserInfo.value) == null ? void 0 : _b.userName,
+      avatarUrl: (_c = loginUserInfo.value) == null ? void 0 : _c.avatarUrl
+    });
+  }
+}, { immediate: true });
+watch(localRoomStatus, async (newVal, oldVal) => {
+  var _a, _b, _c;
+  if (oldVal === newVal) {
+    return;
+  }
+  if (oldVal === LocalRoomStatus.IDLE) {
+    innerUserStore.addUserInfo({
+      userId: ((_a = loginUserInfo.value) == null ? void 0 : _a.userId) || "",
+      userName: (_b = loginUserInfo.value) == null ? void 0 : _b.userName,
+      avatarUrl: (_c = loginUserInfo.value) == null ? void 0 : _c.avatarUrl
+    });
+  }
+  if (newVal === LocalRoomStatus.JOINED) {
+    await manager.initUserList();
+  }
+  if (newVal === LocalRoomStatus.IDLE) {
+    innerUserStore.resetUserList();
+  }
+}, { immediate: true });
+function useUserState() {
+  const userState = {
+    ...store
+  };
+  const proto = Object.getPrototypeOf(manager);
+  Object.getOwnPropertyNames(proto).forEach((key) => {
+    if (key !== "constructor" && typeof proto[key] === "function") {
+      userState[key] = proto[key].bind(manager);
+    }
+  });
+  return userState;
+}
+export {
+  useUserState as default,
+  useUserState
+};

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

@@ -0,0 +1,272 @@
+import { ConnectionStatus, DeviceStatus, SeatStatus, StreamPlayStatus, UserInfo, UserRoomStatus } from '../../types';
+import { Ref, ComputedRef } from 'vue';
+
+export declare const receivedDeviceRequestList: Ref<(string | {
+    readonly cache: RequestCache;
+    readonly credentials: RequestCredentials;
+    readonly destination: RequestDestination;
+    readonly headers: {
+        append: (name: string, value: string) => void;
+        delete: (name: string) => void;
+        get: (name: string) => string | null;
+        getSetCookie: () => string[];
+        has: (name: string) => boolean;
+        set: (name: string, value: string) => void;
+        forEach: (callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any) => void;
+        entries: () => HeadersIterator<[string, string]>;
+        keys: () => HeadersIterator<string>;
+        values: () => HeadersIterator<string>;
+        [Symbol.iterator]: () => HeadersIterator<[string, string]>;
+    };
+    readonly integrity: string;
+    readonly keepalive: boolean;
+    readonly method: string;
+    readonly mode: RequestMode;
+    readonly redirect: RequestRedirect;
+    readonly referrer: string;
+    readonly referrerPolicy: ReferrerPolicy;
+    readonly signal: {
+        readonly aborted: boolean;
+        onabort: ((this: AbortSignal, ev: Event) => any) | null;
+        readonly reason: any;
+        throwIfAborted: {
+            (): void;
+            (): void;
+        };
+        addEventListener: {
+            <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        any: (signals: Iterable<AbortSignal>) => AbortSignal;
+        dispatchEvent: (event: Event) => boolean;
+    };
+    readonly url: string;
+    clone: () => Request;
+    readonly body: {
+        readonly locked: boolean;
+        cancel: (reason?: any) => Promise<void>;
+        getReader: {
+            (options: {
+                mode: "byob";
+            }): ReadableStreamBYOBReader;
+            (): ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>;
+            (options?: ReadableStreamGetReaderOptions): ReadableStreamReader<Uint8Array<ArrayBufferLike>>;
+        };
+        pipeThrough: <T>(transform: ReadableWritablePair<T, Uint8Array<ArrayBufferLike>>, options?: StreamPipeOptions) => ReadableStream<T>;
+        pipeTo: (destination: WritableStream<Uint8Array<ArrayBufferLike>>, options?: StreamPipeOptions) => Promise<void>;
+        tee: () => [ReadableStream<Uint8Array<ArrayBufferLike>>, ReadableStream<Uint8Array<ArrayBufferLike>>];
+    } | null;
+    readonly bodyUsed: boolean;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    blob: () => Promise<Blob>;
+    bytes: () => Promise<Uint8Array>;
+    formData: () => Promise<FormData>;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+})[], RequestInfo[] | (string | {
+    readonly cache: RequestCache;
+    readonly credentials: RequestCredentials;
+    readonly destination: RequestDestination;
+    readonly headers: {
+        append: (name: string, value: string) => void;
+        delete: (name: string) => void;
+        get: (name: string) => string | null;
+        getSetCookie: () => string[];
+        has: (name: string) => boolean;
+        set: (name: string, value: string) => void;
+        forEach: (callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any) => void;
+        entries: () => HeadersIterator<[string, string]>;
+        keys: () => HeadersIterator<string>;
+        values: () => HeadersIterator<string>;
+        [Symbol.iterator]: () => HeadersIterator<[string, string]>;
+    };
+    readonly integrity: string;
+    readonly keepalive: boolean;
+    readonly method: string;
+    readonly mode: RequestMode;
+    readonly redirect: RequestRedirect;
+    readonly referrer: string;
+    readonly referrerPolicy: ReferrerPolicy;
+    readonly signal: {
+        readonly aborted: boolean;
+        onabort: ((this: AbortSignal, ev: Event) => any) | null;
+        readonly reason: any;
+        throwIfAborted: {
+            (): void;
+            (): void;
+        };
+        addEventListener: {
+            <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        any: (signals: Iterable<AbortSignal>) => AbortSignal;
+        dispatchEvent: (event: Event) => boolean;
+    };
+    readonly url: string;
+    clone: () => Request;
+    readonly body: {
+        readonly locked: boolean;
+        cancel: (reason?: any) => Promise<void>;
+        getReader: {
+            (options: {
+                mode: "byob";
+            }): ReadableStreamBYOBReader;
+            (): ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>;
+            (options?: ReadableStreamGetReaderOptions): ReadableStreamReader<Uint8Array<ArrayBufferLike>>;
+        };
+        pipeThrough: <T>(transform: ReadableWritablePair<T, Uint8Array<ArrayBufferLike>>, options?: StreamPipeOptions) => ReadableStream<T>;
+        pipeTo: (destination: WritableStream<Uint8Array<ArrayBufferLike>>, options?: StreamPipeOptions) => Promise<void>;
+        tee: () => [ReadableStream<Uint8Array<ArrayBufferLike>>, ReadableStream<Uint8Array<ArrayBufferLike>>];
+    } | null;
+    readonly bodyUsed: boolean;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    blob: () => Promise<Blob>;
+    bytes: () => Promise<Uint8Array>;
+    formData: () => Promise<FormData>;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+})[]>;
+export declare const remoteUserList: ComputedRef<UserInfo[]>;
+export declare function getNewUserInfo(userId: string): UserInfo;
+export declare function addUserInfo(userInfo: Pick<UserInfo, 'userId'> & Partial<UserInfo>): void;
+export declare function updateUserInfo(userInfo: Pick<UserInfo, 'userId'> & Partial<UserInfo>): void;
+export declare function removeUserInfo(userId: string): void;
+export declare const updateUserStatus: (userId: string, status: Partial<UserInfo>) => void;
+export declare function getUserInfo(options: {
+    userId: string;
+}): {
+    userId: string;
+    userName: string;
+    avatarUrl: string;
+    nameCard: string;
+    roomCustomInfo: Record<string, any>;
+    userRole: import('../..').TUIRole;
+    isMessageDisabled: boolean;
+    joinedTimestamp: number;
+    seatStatus: SeatStatus;
+    onSeatTimestamp: number;
+    microphoneStatus: DeviceStatus;
+    cameraStatus: DeviceStatus;
+    screenStatus: DeviceStatus;
+    audioVolume: number;
+    videoPlayStatus: StreamPlayStatus;
+    screenPlayStatus: StreamPlayStatus;
+    networkQuality: import('../..').TUINetworkQuality;
+    roomId: string;
+    userRoomStatus: UserRoomStatus;
+    hostConnectionStatus: ConnectionStatus;
+} | undefined;
+export declare function getDisplayName(options: {
+    userId: string;
+}): string;
+export declare function setUserListCursor(nextSequence: number): void;
+export declare function resetUserList(): void;
+export interface IUserState {
+    userList: ComputedRef<UserInfo[]>;
+    userListOnSeat: Ref<UserInfo[]>;
+    userListCursor: Ref<number>;
+    localUser: ComputedRef<UserInfo | undefined>;
+    remoteUserList: ComputedRef<UserInfo[]>;
+    userListWithCameraOn: ComputedRef<UserInfo[]>;
+    userWithScreenOn: ComputedRef<UserInfo | null>;
+    receivedDeviceRequestList: Ref<RequestInfo[]>;
+    getUserInfo: (options: {
+        userId: string;
+    }) => UserInfo | undefined;
+    getDisplayName: (options: {
+        userId: string;
+    }) => string;
+}
+export default function useUserStore(): IUserState;
+export declare const innerUserStore: {
+    userInfoMap: Map<string, {
+        userId: string;
+        userName: string;
+        avatarUrl: string;
+        nameCard: string;
+        roomCustomInfo: Record<string, any>;
+        userRole: import('../..').TUIRole;
+        isMessageDisabled: boolean;
+        joinedTimestamp: number;
+        seatStatus: SeatStatus;
+        onSeatTimestamp: number;
+        microphoneStatus: DeviceStatus;
+        cameraStatus: DeviceStatus;
+        screenStatus: DeviceStatus;
+        audioVolume: number;
+        videoPlayStatus: StreamPlayStatus;
+        screenPlayStatus: StreamPlayStatus;
+        networkQuality: import('../..').TUINetworkQuality;
+        roomId: string;
+        userRoomStatus: UserRoomStatus;
+        hostConnectionStatus: ConnectionStatus;
+    }> & Omit<Map<string, UserInfo>, keyof Map<any, any>>;
+    mixUserInfo: {
+        userId: string;
+        userName: string;
+        avatarUrl: string;
+        nameCard: string;
+        roomCustomInfo: Record<string, any>;
+        userRole: import('../..').TUIRole;
+        isMessageDisabled: boolean;
+        joinedTimestamp: number;
+        seatStatus: SeatStatus;
+        onSeatTimestamp: number;
+        microphoneStatus: DeviceStatus;
+        cameraStatus: DeviceStatus;
+        screenStatus: DeviceStatus;
+        audioVolume: number;
+        videoPlayStatus: StreamPlayStatus;
+        screenPlayStatus: StreamPlayStatus;
+        networkQuality: import('../..').TUINetworkQuality;
+        roomId: string;
+        userRoomStatus: UserRoomStatus;
+        hostConnectionStatus: ConnectionStatus;
+    } | undefined;
+    userListOnSeat: {
+        userId: string;
+        userName: string;
+        avatarUrl: string;
+        nameCard: string;
+        roomCustomInfo: Record<string, any>;
+        userRole: import('../..').TUIRole;
+        isMessageDisabled: boolean;
+        joinedTimestamp: number;
+        seatStatus: SeatStatus;
+        onSeatTimestamp: number;
+        microphoneStatus: DeviceStatus;
+        cameraStatus: DeviceStatus;
+        screenStatus: DeviceStatus;
+        audioVolume: number;
+        videoPlayStatus: StreamPlayStatus;
+        screenPlayStatus: StreamPlayStatus;
+        networkQuality: import('../..').TUINetworkQuality;
+        roomId: string;
+        userRoomStatus: UserRoomStatus;
+        hostConnectionStatus: ConnectionStatus;
+    }[];
+    setUserListCursor: typeof setUserListCursor;
+    addUserInfo: typeof addUserInfo;
+    getUserInfo: typeof getUserInfo;
+    removeUserInfo: typeof removeUserInfo;
+    updateUserInfo: typeof updateUserInfo;
+    resetUserList: typeof resetUserList;
+    userList: UserInfo[];
+    userListCursor: number;
+    localUser: UserInfo | undefined;
+    remoteUserList: UserInfo[];
+    userListWithCameraOn: UserInfo[];
+    userWithScreenOn: UserInfo | null;
+    receivedDeviceRequestList: RequestInfo[];
+    getDisplayName: (options: {
+        userId: string;
+    }) => string;
+};