tuikit-atomicx-vue3 0.1.0

package/dist/hooks/useRoomActions/index.js

@@ -0,0 +1,18 @@
+import useRoomAudioAction from "./useRoomAudioAction.js";
+import useRoomVideoAction from "./useRoomVideoAction.js";
+import useRoomScreenAction from "./useRoomScreenAction.js";
+import { RoomAction } from "../../types/room.js";
+function useRoomActions(options) {
+  const roomActionObj = {
+    [RoomAction.AudioAction]: useRoomAudioAction(),
+    [RoomAction.VideoAction]: useRoomVideoAction(),
+    [RoomAction.ScreenAction]: useRoomScreenAction()
+  };
+  if (options && options.actionList && options.actionList.length > 0) {
+    return options.actionList.map((action) => roomActionObj[action]);
+  }
+  return Object.values(roomActionObj);
+}
+export {
+  useRoomActions as default
+};

package/dist/hooks/useRoomActions/useRoomAudioAction.d.ts

@@ -0,0 +1,8 @@
+import { RoomAction } from '../../types';
+
+export default function useRoomAudioAction(): {
+    key: RoomAction;
+    icon: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    label: any;
+    handler: () => void;
+};

package/dist/hooks/useRoomActions/useRoomAudioAction.js

@@ -0,0 +1,60 @@
+import { TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
+import { RoomAction } from "../../types/room.js";
+import { useI18n } from "../../locales/index.js";
+import MessageBox from "../../baseComp/MessageBox/index.js";
+import { TUIToast, TOAST_TYPE } from "@tencentcloud/uikit-base-component-vue3";
+import { useRoomEngine } from "../useRoomEngine.js";
+import { reactive, computed, defineComponent } from "vue";
+import { useRoomState } from "../../states/RoomState.js";
+const { currentRoom } = useRoomState();
+function useRoomAudioAction() {
+  const { t } = useI18n();
+  const roomEngine = useRoomEngine();
+  let stateForAllAudio = false;
+  function toggleRoomAudio() {
+    var _a, _b, _c;
+    stateForAllAudio = !((_a = currentRoom.value) == null ? void 0 : _a.isMicrophoneDisableForAllUser);
+    MessageBox({
+      title: ((_b = currentRoom.value) == null ? void 0 : _b.isMicrophoneDisableForAllUser) ? t("Enable all audios") : t("All current and new members will be muted"),
+      message: ((_c = currentRoom.value) == null ? void 0 : _c.isMicrophoneDisableForAllUser) ? t("After unlocking, users can freely turn on the microphone") : t("Members will not be able to open the microphone"),
+      confirmButtonText: t("Confirm"),
+      cancelButtonText: t("Cancel"),
+      callback: async (action) => {
+        if (action === "confirm") {
+          doToggleRoomAudio();
+        }
+      }
+    });
+  }
+  async function doToggleRoomAudio() {
+    var _a, _b;
+    if (((_a = currentRoom.value) == null ? void 0 : _a.isMicrophoneDisableForAllUser) === stateForAllAudio) {
+      const tipMessage = stateForAllAudio ? t("All audios disabled") : t("All audios enabled");
+      TUIToast({
+        type: TOAST_TYPE.SUCCESS,
+        message: tipMessage
+        // duration: MESSAGE_DURATION.NORMAL,
+      });
+      return;
+    }
+    await ((_b = roomEngine.instance) == null ? void 0 : _b.disableDeviceForAllUserByAdmin({
+      isDisable: stateForAllAudio,
+      device: TUIMediaDevice.kMicrophone
+    }));
+  }
+  const roomAudioAction = reactive({
+    key: RoomAction.AudioAction,
+    icon: defineComponent({}),
+    label: computed(
+      () => {
+        var _a;
+        return ((_a = currentRoom.value) == null ? void 0 : _a.isMicrophoneDisableForAllUser) ? t("Lift all mute") : t("All mute");
+      }
+    ),
+    handler: toggleRoomAudio
+  });
+  return roomAudioAction;
+}
+export {
+  useRoomAudioAction as default
+};

package/dist/hooks/useRoomActions/useRoomScreenAction.d.ts

@@ -0,0 +1,3 @@
+import { ActionType, RoomAction } from '../../types';
+
+export default function useRoomScreenAction(): ActionType<RoomAction>;

package/dist/hooks/useRoomActions/useRoomScreenAction.js

@@ -0,0 +1,70 @@
+import { reactive, computed } from "vue";
+import { TUIRole, TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
+import { IconAllMembersShareScreen, IconHostShareScreen } from "@tencentcloud/uikit-base-component-vue3";
+import { RoomAction } from "../../types/room.js";
+import { useI18n } from "../../locales/index.js";
+import { useRoomEngine } from "../useRoomEngine.js";
+import { useUserState } from "../../states/UserState/index.js";
+import { useRoomState } from "../../states/RoomState.js";
+const { userWithScreenOn } = useUserState();
+const { currentRoom } = useRoomState();
+function useRoomScreenAction() {
+  const { t } = useI18n();
+  const roomEngine = useRoomEngine();
+  let stateForScreenShare = false;
+  async function toggleAllScreenShare() {
+    var _a;
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.disableDeviceForAllUserByAdmin({
+      isDisable: stateForScreenShare,
+      device: TUIMediaDevice.kScreen
+    }));
+  }
+  function toggleRoomScreen() {
+    var _a;
+    stateForScreenShare = !((_a = currentRoom.value) == null ? void 0 : _a.isScreenShareDisableForAllUser);
+    if (!userWithScreenOn.value || userWithScreenOn.value.userRole !== TUIRole.kGeneralUser) {
+      toggleAllScreenShare();
+      return;
+    }
+    TUIMessageBox({
+      title: t(
+        "Is it turned on that only the host/admin can share the screen?"
+      ),
+      message: t(
+        "Other member is sharing the screen is now, the member's sharing will be terminated after you turning on"
+      ),
+      confirmButtonText: t("Confirm"),
+      cancelButtonText: t("Cancel"),
+      callback: async (action) => {
+        var _a2, _b;
+        if (action === "confirm") {
+          await ((_b = roomEngine.instance) == null ? void 0 : _b.closeRemoteDeviceByAdmin({
+            userId: (_a2 = userWithScreenOn.value) == null ? void 0 : _a2.userId,
+            device: TUIMediaDevice.kScreen
+          }));
+          toggleAllScreenShare();
+        }
+      }
+    });
+  }
+  const roomScreenAction = reactive({
+    key: RoomAction.ScreenAction,
+    label: computed(
+      () => {
+        var _a;
+        return ((_a = currentRoom.value) == null ? void 0 : _a.isScreenShareDisableForAllUser) ? t("All members can share screen") : t("Screen sharing for host/admin only");
+      }
+    ),
+    icon: computed(
+      () => {
+        var _a;
+        return ((_a = currentRoom.value) == null ? void 0 : _a.isScreenShareDisableForAllUser) ? IconAllMembersShareScreen : IconHostShareScreen;
+      }
+    ),
+    handler: toggleRoomScreen
+  });
+  return roomScreenAction;
+}
+export {
+  useRoomScreenAction as default
+};

package/dist/hooks/useRoomActions/useRoomVideoAction.d.ts

@@ -0,0 +1,8 @@
+import { RoomAction } from '../../types';
+
+export default function useRoomVideoAction(): {
+    key: RoomAction;
+    icon: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    label: any;
+    handler: () => void;
+};

package/dist/hooks/useRoomActions/useRoomVideoAction.js

@@ -0,0 +1,60 @@
+import { TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
+import { RoomAction } from "../../types/room.js";
+import { useI18n } from "../../locales/index.js";
+import { useRoomState } from "../../states/RoomState.js";
+import MessageBox from "../../baseComp/MessageBox/index.js";
+import { TUIToast, TOAST_TYPE } from "@tencentcloud/uikit-base-component-vue3";
+import { useRoomEngine } from "../useRoomEngine.js";
+import { reactive, computed, defineComponent } from "vue";
+function useRoomVideoAction() {
+  const { t } = useI18n();
+  const { currentRoom } = useRoomState();
+  const roomEngine = useRoomEngine();
+  let stateForAllVideo = false;
+  function toggleRoomVideo() {
+    var _a, _b, _c;
+    stateForAllVideo = !((_a = currentRoom.value) == null ? void 0 : _a.isCameraDisableForAllUser);
+    MessageBox({
+      title: ((_b = currentRoom.value) == null ? void 0 : _b.isCameraDisableForAllUser) ? t("Enable all videos") : t("All and new members will be banned from the camera"),
+      message: ((_c = currentRoom.value) == null ? void 0 : _c.isCameraDisableForAllUser) ? t("After unlocking, users can freely turn on the camera") : t("Members will not be able to open the camera"),
+      confirmButtonText: t("Confirm"),
+      cancelButtonText: t("Cancel"),
+      callback: async (action) => {
+        if (action === "confirm") {
+          doToggleRoomVideo();
+        }
+      }
+    });
+  }
+  async function doToggleRoomVideo() {
+    var _a, _b;
+    if (((_a = currentRoom.value) == null ? void 0 : _a.isCameraDisableForAllUser) === stateForAllVideo) {
+      const tipMessage = stateForAllVideo ? t("All videos disabled") : t("All videos enabled");
+      TUIToast({
+        type: TOAST_TYPE.SUCCESS,
+        message: tipMessage
+        // duration: MESSAGE_DURATION.NORMAL,
+      });
+      return;
+    }
+    await ((_b = roomEngine.instance) == null ? void 0 : _b.disableDeviceForAllUserByAdmin({
+      isDisable: stateForAllVideo,
+      device: TUIMediaDevice.kCamera
+    }));
+  }
+  const roomVideoAction = reactive({
+    key: RoomAction.VideoAction,
+    icon: defineComponent({}),
+    label: computed(
+      () => {
+        var _a;
+        return ((_a = currentRoom.value) == null ? void 0 : _a.isCameraDisableForAllUser) ? t("Lift stop all video") : t("All stop video");
+      }
+    ),
+    handler: toggleRoomVideo
+  });
+  return roomVideoAction;
+}
+export {
+  useRoomVideoAction as default
+};

package/dist/hooks/useRoomEngine.d.ts

@@ -0,0 +1,7 @@
+import { default as TUIRoomEngine, TUIRoomDeviceManager } from '@tencentcloud/tuiroom-engine-js';
+
+export declare function useDeviceManager(): {
+    instance: TUIRoomDeviceManager | null | undefined;
+};
+export declare function useRoomEngine(): Record<string, TUIRoomEngine | null>;
+export default useRoomEngine;

package/dist/hooks/useRoomEngine.js

@@ -0,0 +1,29 @@
+import TUIRoomEngine, { TRTCCloud } from "@tencentcloud/tuiroom-engine-js";
+const roomEngine = { instance: null };
+const deviceManager = {
+  instance: null
+};
+TUIRoomEngine.once("ready", () => {
+  var _a;
+  TRTCCloud.callExperimentalAPI(
+    JSON.stringify({
+      api: "enableSEI",
+      params: {
+        enable: true
+      }
+    })
+  );
+  roomEngine.instance = new TUIRoomEngine();
+  deviceManager.instance = (_a = roomEngine.instance) == null ? void 0 : _a.getMediaDeviceManager();
+});
+function useDeviceManager() {
+  return deviceManager;
+}
+function useRoomEngine() {
+  return roomEngine;
+}
+export {
+  useRoomEngine as default,
+  useDeviceManager,
+  useRoomEngine
+};

package/dist/hooks/useScroll.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Scroll related hook
+ * Provides functions to scroll to bottom and scroll to specific messages
+ */
+/**
+ * Scroll options interface
+ * @interface ScrollOptions
+ * @property {('auto' | 'smooth' | 'instant')} [behavior] - Scroll behavior, auto for immediate scroll, smooth for smooth scroll, instant as alias for immediate scroll
+ * @property {('start' | 'center' | 'end' | 'nearest')} [block] - Scroll alignment
+ */
+interface ScrollOptions {
+    behavior?: 'auto' | 'smooth' | 'instant';
+    block?: 'start' | 'center' | 'end' | 'nearest';
+}
+/**
+ * Options for scrolling to specific message, extends ScrollOptions
+ * @interface ScrollToMessageOptions
+ * @extends ScrollOptions
+ * @property {boolean} [skipIfVisible] - Skip scrolling if message is already visible in viewport
+ */
+interface ScrollToMessageOptions extends ScrollOptions {
+    skipIfVisible?: boolean;
+}
+/**
+ * Scroll related hook
+ * @returns {Object} Scroll related methods
+ * @property {Function} scrollToBottom - Method to scroll to bottom
+ * @property {Function} scrollToMessage - Method to scroll to specific message
+ */
+export declare const useScroll: () => {
+    scrollToBottom: (options?: ScrollOptions) => Promise<void>;
+    scrollToMessage: (messageID: string, options?: ScrollToMessageOptions) => Promise<void>;
+};
+export {};

package/dist/hooks/useScroll.js

@@ -0,0 +1,108 @@
+const isElementVisible = (element, container) => {
+  const elementRect = element.getBoundingClientRect();
+  const containerRect = container.getBoundingClientRect();
+  const topVisible = elementRect.top >= containerRect.top && elementRect.top <= containerRect.bottom;
+  const bottomVisible = elementRect.bottom >= containerRect.top && elementRect.bottom <= containerRect.bottom;
+  const elementContainsContainer = elementRect.top <= containerRect.top && elementRect.bottom >= containerRect.bottom;
+  return topVisible || bottomVisible || elementContainsContainer;
+};
+const useScroll = () => {
+  const scrollToBottom = (options = {}) => new Promise((resolve) => {
+    const scrollableContainer = document.querySelector("#messageScrollList");
+    if (!scrollableContainer) {
+      resolve();
+      return;
+    }
+    const defaultOptions = {
+      behavior: "instant",
+      block: "end"
+    };
+    const mergedOptions = { ...defaultOptions, ...options };
+    const behavior = mergedOptions.behavior === "instant" ? "auto" : mergedOptions.behavior || "auto";
+    requestAnimationFrame(() => {
+      scrollableContainer.scrollTo({
+        top: scrollableContainer.scrollHeight,
+        behavior
+      });
+      if (behavior === "smooth") {
+        const onScrollEnd = () => {
+          scrollableContainer.removeEventListener("scrollend", onScrollEnd);
+          setTimeout(() => {
+            scrollableContainer.scrollTo({
+              top: scrollableContainer.scrollHeight,
+              behavior: "auto"
+            });
+            resolve();
+          }, 100);
+        };
+        if ("onscrollend" in window) {
+          scrollableContainer.addEventListener("scrollend", onScrollEnd);
+        } else {
+          setTimeout(() => {
+            scrollableContainer.scrollTo({
+              top: scrollableContainer.scrollHeight,
+              behavior: "auto"
+            });
+            resolve();
+          }, 500);
+        }
+      } else {
+        resolve();
+      }
+    });
+  });
+  const scrollToMessage = (messageID, options = {}) => new Promise((resolve, reject) => {
+    const targetMessageDom = document.querySelector(`[data-message-id="${messageID}"]`);
+    const scrollableContainer = document.querySelector("#messageScrollList");
+    if (!targetMessageDom || !scrollableContainer) {
+      reject(new Error("Target message or scrollable container not found"));
+      return;
+    }
+    if (options.skipIfVisible && isElementVisible(targetMessageDom, scrollableContainer)) {
+      resolve();
+      return;
+    }
+    const defaultOptions = {
+      behavior: "smooth",
+      block: "center"
+    };
+    const mergedOptions = { ...defaultOptions, ...options };
+    const behavior = mergedOptions.behavior === "instant" ? "auto" : mergedOptions.behavior;
+    const targetTop = targetMessageDom.offsetTop;
+    let scrollTop = targetTop;
+    if (mergedOptions.block === "center") {
+      scrollTop = targetTop - (scrollableContainer.clientHeight - targetMessageDom.clientHeight) / 2;
+    } else if (mergedOptions.block === "end") {
+      scrollTop = targetTop + targetMessageDom.clientHeight - scrollableContainer.clientHeight;
+    }
+    scrollTop = Math.max(0, Math.min(scrollTop, scrollableContainer.scrollHeight - scrollableContainer.clientHeight));
+    requestAnimationFrame(() => {
+      scrollableContainer.scrollTo({
+        top: scrollTop,
+        behavior
+      });
+      if (behavior === "smooth") {
+        const onScrollEnd = () => {
+          scrollableContainer.removeEventListener("scrollend", onScrollEnd);
+          resolve();
+        };
+        if ("onscrollend" in window) {
+          scrollableContainer.addEventListener("scrollend", onScrollEnd);
+        } else {
+          setTimeout(() => {
+            resolve();
+          }, 500);
+        }
+      } else {
+        resolve();
+      }
+    });
+  });
+  return {
+    scrollToBottom,
+    scrollToMessage
+  };
+};
+export {
+  useScroll
+};

package/dist/hooks/useUserActions/index.d.ts

@@ -0,0 +1,40 @@
+import { UserInfo, UserAction, ActionType } from '../../types';
+
+export declare function useUserActions(option: {
+    userInfo: UserInfo;
+    actionList?: UserAction[];
+}): {
+    userActions: import('vue').ComputedRef<(ActionType<UserAction> | {
+        key: UserAction;
+        icon: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            size: {
+                type: import('vue').PropType<string | number>;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            size: {
+                type: import('vue').PropType<string | number>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        label: any;
+        handler: () => void;
+    })[]>;
+    isTargetUserAnchor: import('vue').ComputedRef<boolean>;
+    isTargetUserAudience: import('vue').ComputedRef<boolean>;
+    isUserApplyingToAnchor: import('vue').ComputedRef<boolean>;
+    agreeOrDenyStageList: import('vue').ComputedRef<ActionType<UserAction>[]>;
+    inviteStageList: import('vue').ComputedRef<ActionType<UserAction>[]>;
+    onStageControlList: import('vue').ComputedRef<(ActionType<UserAction> | {
+        key: UserAction;
+        icon: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            size: {
+                type: import('vue').PropType<string | number>;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            size: {
+                type: import('vue').PropType<string | number>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        label: any;
+        handler: () => Promise<void>;
+    })[]>;
+};

package/dist/hooks/useUserActions/index.js

@@ -0,0 +1,130 @@
+import { computed, watch } from "vue";
+import { TUIRole } from "@tencentcloud/tuiroom-engine-js";
+import useAudioControl from "./useAudioAction.js";
+import useChatAction from "./useChatAction.js";
+import useVideoAction from "./useVideoAction.js";
+import useTransferOwnerAction from "./useTransferOwnerAction.js";
+import useNameCardAction from "./useChangeNameCardAction/index.js";
+import useKickUserAction from "./useKickUserAction.js";
+import useSeatAction from "./useSeatAction.js";
+import useAdminAction from "./useAdminAction.js";
+import { SeatStatus, UserRoomStatus } from "../../types/user.js";
+import { useRoomState } from "../../states/RoomState.js";
+import { useUserState } from "../../states/UserState/index.js";
+const { currentRoom } = useRoomState();
+const { localUser } = useUserState();
+function useUserActions(option) {
+  const { userInfo, actionList } = option;
+  const isTargetUserMySelf = computed(
+    () => {
+      var _a;
+      return ((_a = localUser.value) == null ? void 0 : _a.userId) === userInfo.userId;
+    }
+  );
+  const isTargetUserRoomOwner = computed(
+    () => userInfo.userRole === TUIRole.kRoomOwner
+  );
+  const isTargetUserGeneral = computed(
+    () => userInfo.userRole === TUIRole.kGeneralUser
+  );
+  const isTargetUserAnchor = computed(() => (userInfo == null ? void 0 : userInfo.seatStatus) === SeatStatus.On);
+  const isTargetUserAudience = computed(() => (userInfo == null ? void 0 : userInfo.seatStatus) !== SeatStatus.On);
+  const isCanOperateCurrentUser = computed(
+    () => {
+      var _a, _b;
+      return ((_a = localUser.value) == null ? void 0 : _a.userRole) === TUIRole.kRoomOwner && !isTargetUserRoomOwner.value || ((_b = localUser.value) == null ? void 0 : _b.userRole) === TUIRole.kAdministrator && isTargetUserGeneral.value || isTargetUserMySelf.value;
+    }
+  );
+  const audioAction = useAudioControl(userInfo);
+  const videoAction = useVideoAction(userInfo);
+  const chatAction = useChatAction(userInfo);
+  const transferOwnerAction = useTransferOwnerAction(userInfo);
+  const adminAction = useAdminAction(userInfo);
+  const nameCardAction = useNameCardAction(userInfo);
+  const kickUserAction = useKickUserAction(userInfo);
+  const { inviteUserOnSeat, agreeUserOnSeat, denyUserOnSeat, kickUserOffSeat } = useSeatAction(userInfo);
+  const isUserApplyingToAnchor = computed(() => {
+    return userInfo.seatStatus === SeatStatus.OffApplicationPending;
+  });
+  const agreeOrDenyStageList = computed(() => isUserApplyingToAnchor.value ? [agreeUserOnSeat, denyUserOnSeat] : []);
+  const inviteStageList = computed(() => isTargetUserAudience.value && !isUserApplyingToAnchor.value ? [inviteUserOnSeat] : []);
+  const onStageControlList = computed(
+    () => isTargetUserAnchor.value ? [audioAction, videoAction, kickUserOffSeat] : []
+  );
+  watch(() => JSON.stringify(userInfo), (newVal) => {
+    console.error("lixin-debug aaa isTargetUserAnchor", newVal);
+  });
+  const controlListObj = computed(() => {
+    var _a;
+    if ((_a = currentRoom.value) == null ? void 0 : _a.isSeatEnabled) {
+      return {
+        [TUIRole.kRoomOwner]: [
+          ...inviteStageList.value,
+          ...onStageControlList.value,
+          ...agreeOrDenyStageList.value,
+          adminAction,
+          transferOwnerAction,
+          chatAction,
+          kickUserAction,
+          nameCardAction
+        ],
+        [TUIRole.kAdministrator]: [
+          ...inviteStageList.value,
+          ...onStageControlList.value,
+          ...agreeOrDenyStageList.value,
+          chatAction,
+          nameCardAction
+        ]
+      };
+    } else {
+      return {
+        [TUIRole.kRoomOwner]: [
+          audioAction,
+          videoAction,
+          chatAction,
+          adminAction,
+          transferOwnerAction,
+          kickUserAction,
+          nameCardAction
+        ],
+        [TUIRole.kAdministrator]: [
+          audioAction,
+          videoAction,
+          chatAction,
+          nameCardAction
+        ]
+      };
+    }
+  });
+  const controlList = computed(() => {
+    var _a;
+    if (!userInfo || userInfo.userRoomStatus === UserRoomStatus.NotInRoom) {
+      return [];
+    }
+    if (!isCanOperateCurrentUser.value) {
+      return [];
+    }
+    if (isTargetUserMySelf.value) {
+      return [nameCardAction];
+    }
+    return controlListObj.value[(_a = localUser.value) == null ? void 0 : _a.userRole] || [];
+  });
+  watch(
+    [inviteStageList, onStageControlList, agreeOrDenyStageList],
+    () => {
+    },
+    { deep: true }
+  );
+  return {
+    userActions: controlList,
+    isTargetUserAnchor,
+    isTargetUserAudience,
+    isUserApplyingToAnchor,
+    agreeOrDenyStageList,
+    inviteStageList,
+    onStageControlList
+  };
+}
+export {
+  useUserActions
+};

package/dist/hooks/useUserActions/useAdminAction.d.ts

@@ -0,0 +1,3 @@
+import { UserInfo, UserAction, ActionType } from '../../types';
+
+export default function useAdminAction(userInfo: UserInfo): ActionType<UserAction>;

package/dist/hooks/useUserActions/useAdminAction.js

@@ -0,0 +1,43 @@
+import { reactive, computed } from "vue";
+import { TUIRole, TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
+import { IconRevokeAdmin, IconSetAdmin, TUIToast, TOAST_TYPE } from "@tencentcloud/uikit-base-component-vue3";
+import { useRoomEngine } from "../useRoomEngine.js";
+import { useI18n } from "../../locales/index.js";
+import { DeviceStatus } from "../../types/device.js";
+import { UserAction } from "../../types/user.js";
+import { useUserState } from "../../states/UserState/index.js";
+const roomEngine = useRoomEngine();
+const { t } = useI18n();
+const { getDisplayName } = useUserState();
+function useAdminAction(userInfo) {
+  async function handleSetOrRevokeAdmin() {
+    var _a, _b;
+    const newRole = userInfo.userRole === TUIRole.kGeneralUser ? TUIRole.kAdministrator : TUIRole.kGeneralUser;
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.changeUserRole({
+      userId: userInfo.userId,
+      userRole: newRole
+    }));
+    const tipMessage = newRole === TUIRole.kAdministrator ? `${t("sb has been set as administrator", { name: getDisplayName(userInfo) })}` : `${t("The administrator status of sb has been withdrawn", { name: getDisplayName(userInfo) })}`;
+    TUIToast({ type: TOAST_TYPE.SUCCESS, message: tipMessage });
+    if (newRole === TUIRole.kGeneralUser && userInfo.screenStatus === DeviceStatus.On) {
+      await ((_b = roomEngine.instance) == null ? void 0 : _b.closeRemoteDeviceByAdmin({
+        userId: userInfo.userId,
+        device: TUIMediaDevice.kScreen
+      }));
+    }
+  }
+  const setOrRevokeAdmin = reactive({
+    key: UserAction.AdministratorAction,
+    icon: computed(
+      () => userInfo.userRole === TUIRole.kAdministrator ? IconRevokeAdmin : IconSetAdmin
+    ),
+    label: computed(
+      () => userInfo.userRole === TUIRole.kAdministrator ? t("Remove administrator") : t("Set as administrator")
+    ),
+    handler: handleSetOrRevokeAdmin
+  });
+  return setOrRevokeAdmin;
+}
+export {
+  useAdminAction as default
+};

package/dist/hooks/useUserActions/useAudioAction.d.ts

@@ -0,0 +1,3 @@
+import { UserInfo, UserAction, ActionType } from '../../types';
+
+export default function useAudioControl(userInfo: UserInfo): ActionType<UserAction>;