tuikit-atomicx-vue3 0.1.0

package/dist/states/LiveState/index.js

@@ -0,0 +1,361 @@
+import { ref, watch, nextTick } from "vue";
+import TUIRoomEngine, { TUIRoomEvents, TUILiveListManagerEvents, TUILiveLayoutManagerEvents, TUILiveModifyFlag, TUIRoomType } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../../hooks/useRoomEngine.js";
+import { TUISeatMode } from "../../types/types.js";
+import { LiveType, LiveStatus } from "../../types/live.js";
+import { useConversationListState } from "../ConversationListState/ConversationListState.js";
+import { useLoginState } from "../LoginState.js";
+const { switchConversation } = useConversationListState();
+const roomEngine = useRoomEngine();
+const { loginUserInfo } = useLoginState();
+const liveList = ref([]);
+const hasMoreLive = ref(true);
+const isLoadingLiveList = ref(false);
+const currentCursor = ref("");
+const isLoadingMore = ref(false);
+const defaultLiveInfo = {
+  liveId: "",
+  liveName: "",
+  liveType: LiveType.kLive,
+  liveDescription: "",
+  categoryList: [],
+  coverUrl: "",
+  backgroundUrl: "",
+  liveOwner: {
+    userId: "",
+    userName: "",
+    avatarUrl: "",
+    customInfo: {}
+  },
+  currentViewerCount: 0,
+  totalViewerCount: 0,
+  createTime: 0,
+  isMessageDisable: false,
+  isGiftEnabled: false,
+  isPublicVisible: false,
+  isSeatEnabled: false,
+  seatMode: TUISeatMode.kFreeToTake,
+  maxSeatCount: 0,
+  layoutTemplate: 0,
+  customInfo: {}
+};
+const getLiveInfo = (liveInfo) => ({
+  liveId: liveInfo.roomId,
+  liveName: liveInfo.name,
+  liveType: LiveType.kLive,
+  // todo
+  liveDescription: "",
+  // todo
+  categoryList: liveInfo.categoryList,
+  coverUrl: liveInfo.coverUrl,
+  backgroundUrl: liveInfo.backgroundUrl,
+  liveOwner: {
+    userId: liveInfo.roomOwner || "",
+    userName: liveInfo.ownerName || "",
+    avatarUrl: liveInfo.ownerAvatarUrl || "",
+    customInfo: {}
+    // todo
+  },
+  currentViewerCount: liveInfo.totalViewers || 0,
+  totalViewerCount: liveInfo.totalViewers || 0,
+  createTime: liveInfo.createTime || 0,
+  isMessageDisable: liveInfo.isMessageDisableForAllUser,
+  isGiftEnabled: liveInfo.isGiftEnabled,
+  isPublicVisible: liveInfo.isPublicVisible,
+  isSeatEnabled: liveInfo.isSeatEnabled,
+  seatMode: liveInfo.seatMode,
+  maxSeatCount: liveInfo.maxSeatCount,
+  layoutTemplate: liveInfo.seatLayoutTemplateId,
+  customInfo: {}
+});
+const currentLive = ref({ ...defaultLiveInfo });
+const localLiveStatus = ref(LiveStatus.IDLE);
+const updateCurrentLive = (liveInfo) => {
+  currentLive.value = { ...getLiveInfo(liveInfo) };
+};
+const createLive = async (params) => {
+  var _a, _b;
+  if (!loginUserInfo.value) {
+    console.error("[liveState createLive] login user info not found");
+    throw new Error("[liveState createLive] login user info not found");
+  }
+  try {
+    console.log("[liveState createLive] create live", params);
+    const liveInfo = await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveListManager()) == null ? void 0 : _b.startLive({
+      roomId: params.liveId,
+      roomType: TUIRoomType.kLive,
+      name: params.liveName,
+      notice: params.notice,
+      isMessageDisableForAllUser: params.isMessageDisableForAllUser,
+      isGiftEnabled: params.isGiftEnabled,
+      isLikeEnabled: params.isLikeEnabled,
+      isPublicVisible: params.isPublicVisible,
+      isSeatEnabled: params.isSeatEnabled,
+      keepOwnerOnSeat: params.keepOwnerOnSeat,
+      seatLayoutTemplateId: params.seatLayoutTemplateId,
+      maxSeatCount: params.maxSeatCount,
+      seatMode: params.seatMode,
+      coverUrl: params.coverUrl,
+      backgroundUrl: params.backgroundUrl,
+      categoryList: params.categoryList,
+      activityStatus: params.activityStatus
+    }));
+    if (!liveInfo) {
+      throw new Error("[liveState createLive] create live failed");
+    }
+    updateCurrentLive(liveInfo);
+    localLiveStatus.value = LiveStatus.NotStarted;
+  } catch (error) {
+    console.error("[liveState createLive] error", error);
+    throw error;
+  }
+};
+const joinLive = async ({ liveId }) => {
+  var _a;
+  console.log("[liveState joinLive] enter room", liveId);
+  const liveListManager = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveListManager();
+  try {
+    const liveInfo = await (liveListManager == null ? void 0 : liveListManager.joinLive(liveId));
+    if (!liveInfo) {
+      throw new Error("[liveState joinLive] join live failed");
+    }
+    updateCurrentLive(liveInfo);
+    localLiveStatus.value = LiveStatus.Live;
+    switchConversation(`GROUP${liveId}`);
+  } catch (error) {
+    console.error("[liveState joinLive] error", error);
+    throw error;
+  }
+};
+const leaveLive = async () => {
+  var _a, _b;
+  try {
+    console.log("[liveState leaveLive] leave room");
+    await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveListManager()) == null ? void 0 : _b.leaveLive());
+    localLiveStatus.value = LiveStatus.IDLE;
+    currentLive.value = { ...defaultLiveInfo };
+  } catch (error) {
+    console.error("[liveState leaveLive] error", error);
+    throw error;
+  }
+};
+const endLive = async () => {
+  var _a, _b;
+  try {
+    console.log("[liveState endLive] destroy room");
+    await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveListManager()) == null ? void 0 : _b.stopLive());
+    currentLive.value = { ...defaultLiveInfo };
+    localLiveStatus.value = LiveStatus.IDLE;
+  } catch (error) {
+    console.error("[liveState endLive] error", error);
+    throw error;
+  }
+};
+const updateLiveInfo = async (params) => {
+  var _a;
+  try {
+    console.log("[liveState updateLiveInfo]", JSON.stringify(params));
+    const liveListManager = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveListManager();
+    await (liveListManager == null ? void 0 : liveListManager.setLiveInfo({
+      roomId: params.liveId,
+      activityStatus: params.activityStatus,
+      categoryList: params.categoryList,
+      coverUrl: params.coverUrl,
+      backgroundUrl: params.backgroundUrl,
+      isPublicVisible: params.isPublicVisible
+    }));
+    const liveInfo = await (liveListManager == null ? void 0 : liveListManager.getLiveInfo({ roomId: params.liveId }));
+    if (!liveInfo) {
+      throw new Error("[liveState updateLiveInfo] update live info failed");
+    }
+    updateCurrentLive(liveInfo);
+  } catch (error) {
+    console.error("[liveState updateLiveInfo] error", error);
+    throw error;
+  }
+};
+const fetchLiveList = async ({
+  category,
+  cursor = "",
+  count = 20,
+  append = false
+}) => {
+  if (!roomEngine.instance) {
+    console.error("[liveState fetchLiveList] RoomEngine instance is not ready");
+    return;
+  }
+  if (append) {
+    isLoadingMore.value = true;
+  } else {
+    isLoadingLiveList.value = true;
+  }
+  try {
+    const liveListManager = roomEngine.instance.getLiveListManager();
+    if (!liveListManager) {
+      console.error("[liveState fetchLiveList] get live list manager failed");
+      throw new Error("[liveState fetchLiveList] get live list manager failed");
+    }
+    const result = await liveListManager.fetchLiveList({
+      cursor: append ? currentCursor.value : cursor,
+      count
+    });
+    const convertedList = result.liveInfoList.map((tuiLiveInfo) => getLiveInfo(tuiLiveInfo));
+    if (append) {
+      liveList.value = [...liveList.value, ...convertedList];
+    } else {
+      liveList.value = convertedList;
+    }
+    currentCursor.value = result.cursor;
+    hasMoreLive.value = result.cursor !== "";
+  } catch (error) {
+    console.error("[liveState fetchLiveList] error", error);
+    throw error;
+  } finally {
+    isLoadingLiveList.value = false;
+    isLoadingMore.value = false;
+  }
+};
+watch(
+  () => roomEngine.instance,
+  (newVal) => {
+    if (newVal) {
+      console.log("[liveState] RoomEngine instance is ready, auto fetch first page live list");
+      fetchLiveList({});
+    }
+  },
+  { immediate: true }
+);
+const onRoomDismissed = async (roomId) => {
+  console.log("[liveState onRoomDismissed]", roomId);
+  localLiveStatus.value = LiveStatus.Ended;
+  currentLive.value = null;
+  await nextTick();
+  localLiveStatus.value = LiveStatus.IDLE;
+};
+const onRoomSeatModeChanged = ({ roomId, seatMode }) => {
+  if (currentLive.value && currentLive.value.liveId === roomId) {
+    currentLive.value.seatMode = seatMode;
+  }
+};
+const onLiveInfoChanged = ({ liveInfo, modifyFlag }) => {
+  console.log("[liveState onLiveInfoChanged]", liveInfo, modifyFlag);
+  if (!currentLive.value) {
+    return;
+  }
+  switch (modifyFlag) {
+    case TUILiveModifyFlag.kActivityStatus:
+      break;
+    case TUILiveModifyFlag.kBackgroundUrl:
+      currentLive.value.backgroundUrl = liveInfo.backgroundUrl;
+      break;
+    case TUILiveModifyFlag.kCategory:
+      break;
+    case TUILiveModifyFlag.kCoverUrl:
+      currentLive.value.coverUrl = liveInfo.coverUrl;
+      break;
+    case TUILiveModifyFlag.kEnableGift:
+      currentLive.value.isGiftEnabled = liveInfo.isGiftEnabled;
+      break;
+    case TUILiveModifyFlag.kEnableLike:
+      break;
+    case TUILiveModifyFlag.kNone:
+      break;
+    case TUILiveModifyFlag.kPublic:
+      currentLive.value.isPublicVisible = liveInfo.isPublicVisible;
+      break;
+  }
+};
+const onSeatLayoutChanged = (roomId, seatLayout) => {
+  var _a;
+  if (roomId !== ((_a = currentLive.value) == null ? void 0 : _a.liveId)) {
+    return;
+  }
+  if (currentLive.value) {
+    currentLive.value.layoutTemplate = seatLayout.templateId;
+  }
+};
+const onKickedOutOfRoom = () => {
+  localLiveStatus.value = LiveStatus.IDLE;
+  currentLive.value = null;
+};
+const onKickedOffLine = () => {
+  localLiveStatus.value = LiveStatus.IDLE;
+  currentLive.value = null;
+};
+const roomEvents = [
+  { event: TUIRoomEvents.onRoomDismissed, handler: onRoomDismissed },
+  { event: TUIRoomEvents.onKickedOutOfRoom, handler: onKickedOutOfRoom },
+  { event: TUIRoomEvents.onKickedOffLine, handler: onKickedOffLine },
+  {
+    event: TUIRoomEvents.onRoomSeatModeChanged,
+    handler: onRoomSeatModeChanged
+  }
+];
+const liveEvents = [
+  {
+    event: TUILiveListManagerEvents.onLiveInfoChanged,
+    handler: onLiveInfoChanged
+  }
+];
+const layoutEvents = [
+  {
+    event: TUILiveLayoutManagerEvents.onSeatLayoutChanged,
+    handler: onSeatLayoutChanged
+  }
+];
+const bindEvent = () => {
+  var _a, _b;
+  const liveLayoutManager = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveLayoutManager();
+  const liveListManager = (_b = roomEngine.instance) == null ? void 0 : _b.getLiveListManager();
+  roomEvents.forEach(({ event, handler }) => {
+    var _a2;
+    (_a2 = roomEngine.instance) == null ? void 0 : _a2.on(event, handler);
+  });
+  if (liveLayoutManager) {
+    layoutEvents.forEach(({ event, handler }) => {
+      liveLayoutManager.on(event, handler);
+    });
+  }
+  if (liveListManager) {
+    liveEvents.forEach(({ event, handler }) => {
+      liveListManager.on(event, handler);
+    });
+  }
+};
+const setLayoutTemplate = async (templateId) => {
+  var _a, _b;
+  if (!((_a = currentLive.value) == null ? void 0 : _a.liveId)) {
+    currentLive.value.layoutTemplate = templateId;
+    return;
+  }
+  const liveListManager = (_b = roomEngine.instance) == null ? void 0 : _b.getLiveListManager();
+  await (liveListManager == null ? void 0 : liveListManager.setLiveInfo({ roomId: currentLive.value.liveId, seatLayoutTemplateId: templateId }));
+  currentLive.value.layoutTemplate = templateId;
+};
+TUIRoomEngine.once("ready", () => {
+  bindEvent();
+});
+function useLiveState() {
+  return {
+    // 响应式数据
+    liveList,
+    hasMoreLive,
+    currentCursor,
+    isLoadingLiveList,
+    isLoadingMore,
+    currentLive,
+    localLiveStatus,
+    // 操作接口
+    fetchLiveList,
+    createLive,
+    joinLive,
+    leaveLive,
+    endLive,
+    updateLiveInfo,
+    setLayoutTemplate
+  };
+}
+export {
+  useLiveState as default,
+  useLiveState
+};

package/dist/states/LoginState.d.ts

@@ -0,0 +1,31 @@
+import { TUILoginUserInfo } from '@tencentcloud/tuiroom-engine-js';
+
+declare function login(options: {
+    userId: string;
+    userSig: string;
+    sdkAppId: number;
+    testEnv?: boolean;
+}): Promise<void>;
+declare function setSelfInfo(options: {
+    userName?: string;
+    avatarUrl?: string;
+    customInfo?: Record<string, any>;
+}): Promise<void>;
+declare function logout(): Promise<void>;
+export declare function useLoginState(): {
+    loginUserInfo: import('vue').Ref<{
+        userId: string;
+        userName: string;
+        avatarUrl: string;
+        customInfo: Record<string, any>;
+    } | null, TUILoginUserInfo | {
+        userId: string;
+        userName: string;
+        avatarUrl: string;
+        customInfo: Record<string, any>;
+    } | null>;
+    login: typeof login;
+    logout: typeof logout;
+    setSelfInfo: typeof setSelfInfo;
+};
+export default useLoginState;

package/dist/states/LoginState.js

@@ -0,0 +1,64 @@
+import { TUILogin } from "@tencentcloud/tui-core";
+import TUIRoomEngine from "@tencentcloud/tuiroom-engine-js";
+import { ref } from "vue";
+const loginUserInfo = ref(null);
+async function login(options) {
+  if (!options.userId || !options.userSig || !options.sdkAppId) {
+    throw new Error("login 参数错误");
+  }
+  await TUILogin.login({
+    SDKAppID: options.sdkAppId,
+    userID: options.userId,
+    userSig: options.userSig,
+    // @ts-ignore
+    testEnv: options.testEnv
+  });
+  const { chat } = TUILogin.getContext();
+  await TUIRoomEngine.login({
+    userId: options.userId,
+    userSig: options.userSig,
+    sdkAppId: options.sdkAppId,
+    tim: chat
+  });
+  const result = await chat.getUserProfile({ userIDList: [options.userId] });
+  const localUserInfo = result.data[0];
+  loginUserInfo.value = {
+    userId: localUserInfo.userID,
+    userName: localUserInfo.nick,
+    avatarUrl: localUserInfo.avatar,
+    customInfo: localUserInfo.profileCustomField
+  };
+}
+async function setSelfInfo(options) {
+  const { avatarUrl, userName, customInfo } = await TUIRoomEngine.getSelfInfo();
+  const info = {
+    userName: options.userName || userName,
+    avatarUrl: options.avatarUrl || avatarUrl,
+    customInfo: options.customInfo || customInfo
+  };
+  await TUIRoomEngine.setSelfInfo(info);
+  const currentSelfInfo = await TUIRoomEngine.getSelfInfo();
+  if (loginUserInfo.value) {
+    loginUserInfo.value = Object.assign(loginUserInfo.value, {
+      userName: currentSelfInfo.userName,
+      avatarUrl: currentSelfInfo.avatarUrl,
+      customInfo: currentSelfInfo.customInfo
+    });
+  }
+}
+async function logout() {
+  await TUIRoomEngine.logout();
+  loginUserInfo.value = null;
+}
+function useLoginState() {
+  return {
+    loginUserInfo,
+    login,
+    logout,
+    setSelfInfo
+  };
+}
+export {
+  useLoginState as default,
+  useLoginState
+};

package/dist/states/MessageActionState/MessageActionState.d.ts

@@ -0,0 +1,96 @@
+import { Ref } from 'vue';
+import { IMessageModel } from '@tencentcloud/chat-uikit-engine';
+
+/**
+ * Message action state interface
+ * @interface IMessageActionState
+ */
+interface IMessageActionState {
+    /** Forward message ID list */
+    forwardMessageIDList: Ref<string[]>;
+    /** Flag indicating whether message selection is done */
+    isForwardMessageSelectionDone: Ref<boolean>;
+    /** Forward target conversation ID list */
+    forwardConversationIDList: Ref<string[]>;
+    /** Current quoted message */
+    quotedMessage: Ref<IMessageModel | undefined>;
+}
+/**
+ * Message action interface
+ * @interface IMessageActionAction
+ */
+interface IMessageActionAction {
+    /**
+     * Set forward message ID list
+     * @param messageIDList - Message IDs to forward
+     */
+    setForwardMessageIDList: (messageIDList: string[]) => void;
+    /**
+     * Set message selection completion status
+     * @param isSelectionDone - Boolean indicating whether message selection is complete
+     */
+    setIsForwardMessageSelectionDone: (isSelectionDone: boolean) => void;
+    /**
+     * Set forward target conversation ID list
+     * @param conversationIDList - Conversation IDs to forward to
+     */
+    setForwardConversationIDList: (conversationIDList: string[]) => void;
+    /**
+     * Forward messages to specified conversations
+     * @param params - Forward message parameters
+     * @returns Results of the forward operation
+     */
+    forwardMessage: (params: IForwardMessageParams) => Promise<Array<PromiseSettledResult<unknown>>>;
+    /**
+     * Quote a message
+     * @param message - Message to quote
+     */
+    quoteMessage: (message: IMessageModel | undefined) => void;
+    /**
+     * Clear quoted message
+     */
+    clearQuotedMessage: () => void;
+    /**
+     * Copy text message content to clipboard
+     * @param message - Message to copy
+     * @returns Result of the copy operation
+     */
+    copyTextMessage: (message: IMessageModel) => Promise<boolean>;
+    /**
+     * Delete a message
+     * @param message - Message to delete
+     * @returns Result of the delete operation
+     */
+    deleteMessage: (message: IMessageModel) => Promise<unknown>;
+    /**
+     * Revoke a message
+     * @param message - Message to revoke
+     * @returns Result of the revoke operation
+     */
+    recallMessage: (message: IMessageModel) => Promise<unknown>;
+    /**
+     * Reset message action state
+     */
+    resetMessageActionState: () => void;
+}
+/**
+ * Forward message parameters interface
+ * @interface IForwardMessageParams
+ */
+interface IForwardMessageParams {
+    /** Whether to merge forward */
+    isMergeForward: boolean;
+    /** Message IDs to forward */
+    messageIDList: string[];
+    /** Conversation IDs to forward to */
+    conversationIDList: string[];
+    /** Whether to use offline push */
+    useOfflinePush?: boolean;
+}
+/**
+ * Use message action store
+ * For managing message-related operations such as forwarding, quoting, copying, etc.
+ */
+declare function useMessageActionState(): IMessageActionState & IMessageActionAction;
+export { useMessageActionState };
+export type { IForwardMessageParams, IMessageActionState, IMessageActionAction };

package/dist/states/MessageActionState/MessageActionState.js

@@ -0,0 +1,133 @@
+import { ref } from "vue";
+import { TUIStore, StoreName, TUIChatService } from "@tencentcloud/chat-uikit-engine";
+import "../../utils/env.js";
+import { copyTextToClipboard } from "../../utils/copyText.js";
+import { transformTextWithEmojiKeyToName } from "../../utils/emoji.js";
+const forwardMessageIDListRef = ref([]);
+const isForwardMessageSelectionDoneRef = ref(false);
+const forwardConversationIDListRef = ref([]);
+const quotedMessageRef = ref(void 0);
+function forwardMessage(params) {
+  const { messageIDList, conversationIDList, isMergeForward } = params;
+  if (messageIDList.length === 0 || conversationIDList.length === 0 || isMergeForward === void 0) {
+    throw new Error("Invalid forward message parameters");
+  }
+  const selectedConversationList = conversationIDList.map((ID) => TUIStore.getConversationModel(ID));
+  const selectedMessageListSortedByTime = messageIDList.map((messageID) => TUIStore.getMessageModel(messageID)).sort((a, b) => a.time - b.time);
+  const forwardPromises = selectedConversationList.map(
+    (conversation) => TUIChatService.sendForwardMessage(
+      [conversation],
+      selectedMessageListSortedByTime,
+      {
+        needMerge: isMergeForward,
+        params: {
+          // Determine whether read receipt is needed based on configuration
+          needReadReceipt: false
+        }
+      }
+    )
+  );
+  return Promise.allSettled(forwardPromises);
+}
+function useMessageActionState() {
+  return {
+    // State
+    forwardMessageIDList: forwardMessageIDListRef,
+    isForwardMessageSelectionDone: isForwardMessageSelectionDoneRef,
+    forwardConversationIDList: forwardConversationIDListRef,
+    quotedMessage: quotedMessageRef,
+    // Action methods
+    /**
+     * Set forward message ID list
+     * @param messageIDList - Message IDs to forward
+     */
+    setForwardMessageIDList(messageIDList) {
+      forwardMessageIDListRef.value = [
+        .../* @__PURE__ */ new Set([...forwardMessageIDListRef.value, ...messageIDList])
+      ];
+    },
+    /**
+     * Set message selection completion status
+     * @param isSelectionDone - Boolean indicating whether message selection is complete
+     */
+    setIsForwardMessageSelectionDone(isSelectionDone) {
+      isForwardMessageSelectionDoneRef.value = isSelectionDone;
+    },
+    /**
+     * Set forward target conversation ID list
+     * @param conversationIDList - Conversation IDs to forward to
+     */
+    setForwardConversationIDList(conversationIDList) {
+      forwardConversationIDListRef.value = [
+        .../* @__PURE__ */ new Set([...forwardConversationIDListRef.value, ...conversationIDList])
+      ];
+    },
+    /**
+     * Forward messages to specified conversations
+     * @param params - Forward message parameters
+     * @returns Results of the forward operation
+     */
+    forwardMessage(params) {
+      return forwardMessage(params);
+    },
+    /**
+     * Quote a message
+     * @param message - Message to quote
+     */
+    quoteMessage(message) {
+      TUIStore.update(StoreName.CHAT, "quoteMessage", {
+        message,
+        type: "quote"
+      });
+      quotedMessageRef.value = message;
+    },
+    /**
+     * Clear quoted message
+     */
+    clearQuotedMessage() {
+      TUIStore.update(StoreName.CHAT, "quoteMessage", {
+        message: void 0,
+        type: "quote"
+      });
+      quotedMessageRef.value = void 0;
+    },
+    /**
+     * Copy text message content to clipboard
+     * @param message - Message to copy
+     * @returns Result of the copy operation
+     */
+    copyTextMessage(message) {
+      return copyTextToClipboard(
+        transformTextWithEmojiKeyToName(message.payload.text || "")
+      );
+    },
+    /**
+     * Delete a message
+     * @param message - Message to delete
+     * @returns Result of the delete operation
+     */
+    deleteMessage(message) {
+      return message.deleteMessage();
+    },
+    /**
+     * Revoke a message
+     * @param message - Message to revoke
+     * @returns Result of the revoke operation
+     */
+    recallMessage(message) {
+      return message.revokeMessage();
+    },
+    /**
+     * Reset message action state
+     */
+    resetMessageActionState() {
+      this.clearQuotedMessage();
+      forwardMessageIDListRef.value = [];
+      isForwardMessageSelectionDoneRef.value = false;
+      forwardConversationIDListRef.value = [];
+    }
+  };
+}
+export {
+  useMessageActionState
+};

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

@@ -0,0 +1 @@
+export * from './MessageActionState';

package/dist/states/MessageActionState/index.js

@@ -0,0 +1,4 @@
+import { useMessageActionState } from "./MessageActionState.js";
+export {
+  useMessageActionState
+};