@meistrari/chat-nuxt 1.11.0 → 1.12.0

package/dist/runtime/composables/useConversationList.js

@@ -0,0 +1,553 @@
+import { useChatAuth } from "#chat-auth";
+import { filterConversationsByTitle } from "../utils/conversation-search.js";
+import { groupConversationsByGroup } from "../utils/conversation-groups.js";
+import { conversationListSkeletonRows } from "../utils/conversation-list-skeleton.js";
+import { exportConversationToMarkdown } from "../utils/export-conversation.js";
+import { resolveChatStateScope } from "../utils/tela-chat.js";
+const DRAG_OPEN_GROUP_DELAY_MS = 400;
+export function useConversationList(options) {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const { activeOrganization } = useChatAuth();
+  const { deleteConversation, renameConversation, duplicateConversation, moveConversationToGroup } = useConversations();
+  const { groups, fetchGroups, deleteGroup, renameGroup, error: groupError } = useConversationGroups();
+  const { setConversation } = useChat();
+  const route = useRoute();
+  const router = useRouter();
+  const conversationSearch = ref("");
+  const draggedConversationId = ref(null);
+  const dropTargetGroupId = ref(void 0);
+  const openGroupIds = ref(/* @__PURE__ */ new Set());
+  const groupsReady = ref(false);
+  const showDeleteGroupModal = ref(false);
+  const showDeleteGroupConversationsModal = ref(false);
+  const groupActionLoading = ref(false);
+  const deleteGroupTarget = ref(null);
+  const deleteGroupConversationsTarget = ref(null);
+  const renamingGroupId = ref(null);
+  const renameGroupName = ref("");
+  const renameGroupError = ref(null);
+  const renameGroupInputRef = ref(null);
+  const isIgnoringInitialGroupRenameBlur = ref(false);
+  let dragOpenGroupTimeout = null;
+  let dragOpenGroupId = null;
+  let groupRenameBlurTimer = null;
+  let groupRenameSelectionTimers = [];
+  const runtimeScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const openGroupsStorageKey = computed(() => `conversation-group-open:${runtimeScope.value}`);
+  const hasConversationSearchQuery = computed(() => conversationSearch.value.trim().length > 0);
+  const filteredConversations = computed(
+    () => filterConversationsByTitle(options.conversations, conversationSearch.value, {
+      fallbackTitle: "Nova conversa",
+      shouldInclude: (conversation) => !conversation.title && conversation.id === options.currentId
+    })
+  );
+  const filteredGroupedConversations = computed(() => groupConversationsByGroup(filteredConversations.value, groups.value));
+  const allGroupedConversations = computed(() => groupConversationsByGroup(options.conversations, groups.value));
+  const groupedConversations = computed(() => {
+    if (!hasConversationSearchQuery.value)
+      return filteredGroupedConversations.value;
+    const allItemsByGroupId = new Map(
+      allGroupedConversations.value.groups.map((groupBucket) => [groupBucket.group.id, groupBucket.items])
+    );
+    return {
+      groups: filteredGroupedConversations.value.groups.map(
+        (groupBucket) => doesGroupMatchSearch(groupBucket.group.name) ? {
+          ...groupBucket,
+          items: allItemsByGroupId.get(groupBucket.group.id) ?? []
+        } : groupBucket
+      ),
+      unfiled: filteredGroupedConversations.value.unfiled
+    };
+  });
+  const shouldShowSkeleton = computed(() => Boolean(options.loading) && options.conversations.length === 0);
+  const emptyConversationMessage = computed(
+    () => hasConversationSearchQuery.value ? "Nenhuma conversa encontrada" : "Nenhuma conversa ainda"
+  );
+  const activeGroupId = computed(() => {
+    const currentConversation = options.conversations.find((conversation) => conversation.id === options.currentId);
+    return currentConversation?.groupId ?? null;
+  });
+  onMounted(() => {
+    void Promise.resolve(fetchGroups()).finally(() => {
+      groupsReady.value = true;
+    });
+    try {
+      const stored = localStorage.getItem(openGroupsStorageKey.value);
+      if (stored) {
+        openGroupIds.value = new Set(JSON.parse(stored));
+      }
+    } catch {
+    }
+  });
+  watch(openGroupIds, (groupIds) => {
+    if (typeof localStorage === "undefined")
+      return;
+    try {
+      localStorage.setItem(openGroupsStorageKey.value, JSON.stringify([...groupIds]));
+    } catch {
+    }
+  });
+  watch(activeGroupId, (groupId) => {
+    if (groupId) {
+      setGroupOpen(groupId, true);
+    }
+  }, { immediate: true });
+  function isGroupOpen(groupId) {
+    return openGroupIds.value.has(groupId);
+  }
+  function setGroupOpen(groupId, open) {
+    const nextOpenGroupIds = new Set(openGroupIds.value);
+    if (open) {
+      nextOpenGroupIds.add(groupId);
+    } else {
+      nextOpenGroupIds.delete(groupId);
+    }
+    openGroupIds.value = nextOpenGroupIds;
+  }
+  function toggleGroup(groupId) {
+    setGroupOpen(groupId, !isGroupOpen(groupId));
+  }
+  function createGroupDeleteTarget(groupId, groupName, conversations) {
+    return {
+      id: groupId,
+      name: groupName,
+      conversationIds: conversations.map((conversation) => conversation.id),
+      conversationCount: conversations.length
+    };
+  }
+  function openDeleteGroupModal(groupId, groupName, conversations) {
+    deleteGroupTarget.value = createGroupDeleteTarget(groupId, groupName, conversations);
+    showDeleteGroupModal.value = true;
+  }
+  function openDeleteGroupConversationsModal(groupId, groupName, conversations) {
+    deleteGroupConversationsTarget.value = createGroupDeleteTarget(groupId, groupName, conversations);
+    showDeleteGroupConversationsModal.value = true;
+  }
+  function clearGroupRenameBlurTimer() {
+    if (groupRenameBlurTimer === null)
+      return;
+    clearTimeout(groupRenameBlurTimer);
+    groupRenameBlurTimer = null;
+  }
+  function clearGroupRenameSelectionTimers() {
+    if (groupRenameSelectionTimers.length === 0)
+      return;
+    for (const timer of groupRenameSelectionTimers) {
+      clearTimeout(timer);
+    }
+    groupRenameSelectionTimers = [];
+  }
+  function allowGroupRenameBlurSoon() {
+    clearGroupRenameBlurTimer();
+    groupRenameBlurTimer = setTimeout(() => {
+      isIgnoringInitialGroupRenameBlur.value = false;
+      groupRenameBlurTimer = null;
+    }, 100);
+  }
+  function selectRenameGroupInputText() {
+    const input = renameGroupInputRef.value;
+    if (!input)
+      return;
+    input.focus();
+    input.select();
+    input.setSelectionRange(0, input.value.length);
+  }
+  function scheduleRenameGroupTextSelection() {
+    clearGroupRenameSelectionTimers();
+    groupRenameSelectionTimers = [0, 50].map((delay) => setTimeout(() => {
+      selectRenameGroupInputText();
+    }, delay));
+  }
+  async function focusRenameGroupInput() {
+    await nextTick();
+    selectRenameGroupInputText();
+    scheduleRenameGroupTextSelection();
+    allowGroupRenameBlurSoon();
+  }
+  function setRenameGroupInputRef(element, groupId) {
+    if (groupId !== renamingGroupId.value)
+      return;
+    if (element && typeof element.focus === "function" && typeof element.select === "function" && typeof element.setSelectionRange === "function" && typeof element.value === "string") {
+      renameGroupInputRef.value = element;
+      return;
+    }
+    renameGroupInputRef.value = null;
+  }
+  function startRenameGroup(groupId, groupName) {
+    clearGroupRenameBlurTimer();
+    clearGroupRenameSelectionTimers();
+    renameGroupInputRef.value = null;
+    renamingGroupId.value = groupId;
+    renameGroupName.value = groupName;
+    renameGroupError.value = null;
+    isIgnoringInitialGroupRenameBlur.value = true;
+    void focusRenameGroupInput();
+  }
+  function getGroupMenuItems(groupId, groupName, conversations) {
+    return [
+      {
+        label: "Renomear pasta",
+        icon: "i-ph-pencil-simple",
+        click: () => startRenameGroup(groupId, groupName)
+      },
+      {
+        label: "Excluir pasta",
+        icon: "i-ph-folder-minus",
+        color: "negative",
+        click: () => openDeleteGroupModal(groupId, groupName, conversations)
+      },
+      {
+        label: "Excluir conversas",
+        icon: "i-ph-trash",
+        color: "negative",
+        disabled: conversations.length === 0,
+        click: () => openDeleteGroupConversationsModal(groupId, groupName, conversations)
+      }
+    ];
+  }
+  function doesGroupMatchSearch(groupName) {
+    const query = conversationSearch.value.trim().toLowerCase();
+    return query.length > 0 && groupName.toLowerCase().includes(query);
+  }
+  const groupItems = computed(() => groupedConversations.value.groups.filter((groupBucket) => {
+    if (!hasConversationSearchQuery.value)
+      return true;
+    return groupBucket.items.length > 0 || doesGroupMatchSearch(groupBucket.group.name);
+  }).map((groupBucket) => {
+    const open = isGroupOpen(groupBucket.group.id) || hasConversationSearchQuery.value && (groupBucket.items.length > 0 || doesGroupMatchSearch(groupBucket.group.name));
+    const dropTarget = isDropTarget(groupBucket.group.id);
+    return {
+      ...groupBucket,
+      open,
+      dropTarget,
+      folderIcon: open ? "i-ph-folder-open" : "i-ph-folder",
+      isRenaming: renamingGroupId.value === groupBucket.group.id,
+      conversationCountLabel: groupBucket.items.length > 0 ? String(groupBucket.items.length) : null,
+      showNewConversationAction: !hasConversationSearchQuery.value,
+      showSearchEmpty: hasConversationSearchQuery.value && groupBucket.items.length === 0,
+      menuItems: getGroupMenuItems(groupBucket.group.id, groupBucket.group.name, groupBucket.items)
+    };
+  }));
+  const ungroupedConversations = computed(() => groupedConversations.value.unfiled);
+  const ungroupedDropTarget = computed(() => isDropTarget(null));
+  const ungroupedConversationLabel = computed(() => `Conversas \xB7 ${ungroupedConversations.value.length}`);
+  const shouldShowUngroupedHeader = computed(() => groupItems.value.length > 0);
+  const showGroupCreationPrompt = computed(
+    () => groupsReady.value && !hasConversationSearchQuery.value && groups.value.length === 0
+  );
+  const hasConversationContent = computed(() => {
+    if (hasConversationSearchQuery.value)
+      return groupItems.value.length > 0 || ungroupedConversations.value.length > 0;
+    return showGroupCreationPrompt.value || groups.value.length > 0 || filteredConversations.value.length > 0;
+  });
+  const deleteGroupConfirmationMessage = computed(() => {
+    const target = deleteGroupTarget.value;
+    return `Tem certeza que deseja excluir a pasta "${target?.name ?? ""}"? ${groupConversationsMoveMessage(target?.conversationCount ?? 0)}`;
+  });
+  const deleteGroupConversationsConfirmationMessage = computed(() => {
+    const target = deleteGroupConversationsTarget.value;
+    return `Tem certeza que deseja excluir ${formatConversationCount(target?.conversationCount ?? 0)} da pasta "${target?.name ?? ""}"? A pasta ser\xE1 mantida.`;
+  });
+  function clearDeleteGroupTarget() {
+    if (groupActionLoading.value)
+      return;
+    deleteGroupTarget.value = null;
+    showDeleteGroupModal.value = false;
+  }
+  function clearDeleteGroupConversationsTarget() {
+    if (groupActionLoading.value)
+      return;
+    deleteGroupConversationsTarget.value = null;
+    showDeleteGroupConversationsModal.value = false;
+  }
+  function resetRenameGroupState() {
+    renamingGroupId.value = null;
+    renameGroupName.value = "";
+    renameGroupError.value = null;
+    renameGroupInputRef.value = null;
+    isIgnoringInitialGroupRenameBlur.value = false;
+    clearGroupRenameBlurTimer();
+    clearGroupRenameSelectionTimers();
+  }
+  function cancelRenameGroup() {
+    if (groupActionLoading.value)
+      return;
+    resetRenameGroupState();
+  }
+  function formatConversationCount(count) {
+    return `${count} ${count === 1 ? "conversa" : "conversas"}`;
+  }
+  function groupConversationsMoveMessage(count) {
+    return count === 1 ? "A conversa desta pasta ser\xE1 movida para Conversas." : "As conversas desta pasta ser\xE3o movidas para Conversas.";
+  }
+  function isActiveConversation(conversationId) {
+    return options.currentId === conversationId || route.params.id === conversationId;
+  }
+  function resetAfterActiveConversationDeleted() {
+    if (options.resetConversation) {
+      void options.resetConversation();
+    } else {
+      router.push("/");
+    }
+  }
+  async function confirmDeleteGroup() {
+    const target = deleteGroupTarget.value;
+    if (!target || groupActionLoading.value)
+      return;
+    groupActionLoading.value = true;
+    try {
+      const deleted = await deleteGroup(target.id);
+      if (deleted) {
+        setGroupOpen(target.id, false);
+        deleteGroupTarget.value = null;
+        showDeleteGroupModal.value = false;
+      }
+    } finally {
+      groupActionLoading.value = false;
+    }
+  }
+  async function confirmDeleteGroupConversations() {
+    const target = deleteGroupConversationsTarget.value;
+    if (!target || groupActionLoading.value)
+      return;
+    groupActionLoading.value = true;
+    let deletedActiveConversation = false;
+    const failedConversationIds = [];
+    try {
+      for (const conversationId of target.conversationIds) {
+        const deleted = await deleteConversation(conversationId);
+        if (!deleted) {
+          failedConversationIds.push(conversationId);
+          continue;
+        }
+        if (deleted && isActiveConversation(conversationId)) {
+          deletedActiveConversation = true;
+        }
+      }
+      if (failedConversationIds.length > 0) {
+        deleteGroupConversationsTarget.value = {
+          ...target,
+          conversationIds: failedConversationIds,
+          conversationCount: failedConversationIds.length
+        };
+        if (deletedActiveConversation) {
+          resetAfterActiveConversationDeleted();
+        }
+        return;
+      }
+      deleteGroupConversationsTarget.value = null;
+      showDeleteGroupConversationsModal.value = false;
+      if (deletedActiveConversation) {
+        resetAfterActiveConversationDeleted();
+      }
+    } finally {
+      groupActionLoading.value = false;
+    }
+  }
+  async function submitRenameGroup() {
+    const groupId = renamingGroupId.value;
+    const name = renameGroupName.value.trim();
+    const currentGroupName = groups.value.find((group) => group.id === groupId)?.name;
+    if (!groupId || groupActionLoading.value)
+      return;
+    if (!name || name === currentGroupName) {
+      cancelRenameGroup();
+      return;
+    }
+    renameGroupError.value = null;
+    groupActionLoading.value = true;
+    try {
+      const renamed = await renameGroup(groupId, name);
+      if (renamed) {
+        resetRenameGroupState();
+      } else {
+        renameGroupError.value = groupError.value || "Erro ao renomear pasta";
+      }
+    } finally {
+      groupActionLoading.value = false;
+    }
+  }
+  function handleRenameGroupBlur() {
+    if (isIgnoringInitialGroupRenameBlur.value)
+      return;
+    void submitRenameGroup();
+  }
+  async function handleDelete(id) {
+    const shouldResetConversation = options.currentId === id || route.params.id === id;
+    const deleted = await deleteConversation(id);
+    if (deleted && shouldResetConversation) {
+      resetAfterActiveConversationDeleted();
+    }
+  }
+  async function handleRename(id, title) {
+    await renameConversation(id, title);
+  }
+  async function handleDuplicate(id) {
+    const duplicated = await duplicateConversation(id);
+    if (duplicated) {
+      setConversation(duplicated);
+      if (options.selectConversation) {
+        void options.selectConversation(duplicated.id);
+      } else {
+        router.push(`/${duplicated.id}`);
+      }
+    }
+  }
+  async function handleExport(id) {
+    try {
+      const conversation = await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders()
+      );
+      exportConversationToMarkdown(conversation);
+    } catch (err) {
+      console.error("Failed to export conversation:", err);
+    }
+  }
+  function handleConversationDragStart(id) {
+    draggedConversationId.value = id;
+  }
+  function clearDragState() {
+    draggedConversationId.value = null;
+    dropTargetGroupId.value = void 0;
+    clearDragOpenGroup();
+  }
+  function clearDragOpenGroup() {
+    if (dragOpenGroupTimeout) {
+      clearTimeout(dragOpenGroupTimeout);
+    }
+    dragOpenGroupTimeout = null;
+    dragOpenGroupId = null;
+  }
+  function scheduleDragOpenGroup(groupId) {
+    if (!groupId || isGroupOpen(groupId)) {
+      clearDragOpenGroup();
+      return;
+    }
+    if (dragOpenGroupId === groupId)
+      return;
+    clearDragOpenGroup();
+    dragOpenGroupId = groupId;
+    dragOpenGroupTimeout = setTimeout(() => {
+      setGroupOpen(groupId, true);
+      clearDragOpenGroup();
+    }, DRAG_OPEN_GROUP_DELAY_MS);
+  }
+  function handleDragEnter(groupId) {
+    if (!draggedConversationId.value)
+      return;
+    dropTargetGroupId.value = groupId;
+    scheduleDragOpenGroup(groupId);
+  }
+  function handleDragOver(event, groupId) {
+    if (!draggedConversationId.value)
+      return;
+    if (event.dataTransfer) {
+      event.dataTransfer.dropEffect = "move";
+    }
+    dropTargetGroupId.value = groupId;
+    scheduleDragOpenGroup(groupId);
+  }
+  function handleDragLeave(event, groupId) {
+    const currentTarget = event.currentTarget;
+    const relatedTarget = event.relatedTarget;
+    if (currentTarget && relatedTarget && currentTarget.contains(relatedTarget))
+      return;
+    if (dropTargetGroupId.value === groupId) {
+      dropTargetGroupId.value = void 0;
+      clearDragOpenGroup();
+    }
+  }
+  function isDropTarget(groupId) {
+    return draggedConversationId.value !== null && dropTargetGroupId.value === groupId;
+  }
+  function getConversationItemProps(conversation) {
+    return {
+      conversation,
+      active: conversation.id === options.currentId,
+      draggable: true,
+      userImage: options.getMemberImage?.(conversation.userId),
+      selectConversation: options.selectConversation
+    };
+  }
+  async function handleConversationDrop(event, groupId) {
+    const conversationId = event.dataTransfer?.getData("text/plain") || draggedConversationId.value;
+    clearDragState();
+    if (!conversationId)
+      return;
+    await moveConversationToGroup(conversationId, groupId);
+  }
+  function startConversationInGroup(groupId) {
+    setGroupOpen(groupId, true);
+    if (options.startConversation) {
+      void options.startConversation(groupId);
+    } else if (options.resetConversation) {
+      void options.resetConversation();
+    }
+  }
+  onBeforeUnmount(() => {
+    clearDragOpenGroup();
+    clearGroupRenameBlurTimer();
+    clearGroupRenameSelectionTimers();
+  });
+  return {
+    conversationSearch,
+    groupedConversations,
+    hasConversationSearchQuery,
+    hasConversationContent,
+    shouldShowSkeleton,
+    emptyConversationMessage,
+    skeletonRows: conversationListSkeletonRows,
+    groupItems,
+    ungroupedConversations,
+    ungroupedDropTarget,
+    ungroupedConversationLabel,
+    shouldShowUngroupedHeader,
+    showGroupCreationPrompt,
+    showDeleteGroupModal,
+    showDeleteGroupConversationsModal,
+    groupActionLoading,
+    deleteGroupTarget,
+    deleteGroupConversationsTarget,
+    renamingGroupId,
+    renameGroupName,
+    renameGroupError,
+    deleteGroupConfirmationMessage,
+    deleteGroupConversationsConfirmationMessage,
+    isGroupOpen,
+    setGroupOpen,
+    toggleGroup,
+    openDeleteGroupModal,
+    openDeleteGroupConversationsModal,
+    startRenameGroup,
+    setRenameGroupInputRef,
+    getGroupMenuItems,
+    clearDeleteGroupTarget,
+    clearDeleteGroupConversationsTarget,
+    cancelRenameGroup,
+    formatConversationCount,
+    groupConversationsMoveMessage,
+    confirmDeleteGroup,
+    confirmDeleteGroupConversations,
+    submitRenameGroup,
+    handleRenameGroupBlur,
+    handleDelete,
+    handleRename,
+    handleDuplicate,
+    handleExport,
+    handleConversationDragStart,
+    clearDragState,
+    handleDragEnter,
+    handleDragOver,
+    handleDragLeave,
+    isDropTarget,
+    getConversationItemProps,
+    handleConversationDrop,
+    startConversationInGroup
+  };
+}

package/dist/runtime/composables/useConversations.d.ts

@@ -13,8 +13,10 @@ export declare function useConversations(): {
     }) => Promise<Conversation | null>;
     deleteConversation: (id: string) => Promise<boolean>;
     renameConversation: (id: string, title: string) => Promise<boolean>;
+    moveConversationToGroup: (id: string, groupId: string | null) => Promise<boolean>;
     duplicateConversation: (id: string) => Promise<ConversationWithMessages | null>;
     conversationCreatorFilter: any;
     conversationCreatorFilterCounts: any;
     updateConversationInList: (updated: Conversation | DeepReadonly<Conversation>) => void;
+    clearGroupFromConversations: (groupId: string) => (() => void);
 };

package/dist/runtime/composables/useConversations.js

@@ -298,6 +298,7 @@ export function useConversations() {
     const optimisticConversation = {
       id: createOptimisticConversationId(),
       workspaceId: embedConfig?.workspaceId.value || activeOrganization.value?.id || "",
+      groupId: null,
       userId: authUser.value?.id ?? "",
       title: "Nova conversa",
       threadSessionId: null,
@@ -371,6 +372,47 @@ export function useConversations() {
   const updateConversationInList = (updated) => {
     updateConversationInLoadedBuckets(updated);
   };
+  const moveConversationToGroup = async (id, groupId) => {
+    error.value = null;
+    const requestRuntimeScope = runtimeScope.value;
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(requestRuntimeScope);
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    const conversation = findConversationInLoadedBuckets(id, requestRuntimeScope);
+    if (!conversation)
+      return false;
+    updateConversationInLoadedBuckets({ ...conversation, groupId }, requestRuntimeScope);
+    try {
+      const updated = await $fetch(
+        chatApi.path(`/conversations/${id}/group`),
+        chatApi.withChatHeaders({
+          method: "PATCH",
+          body: { groupId }
+        })
+      );
+      updateConversationInLoadedBuckets(updated, requestRuntimeScope);
+      return true;
+    } catch (err) {
+      restoreConversationBuckets(conversationSnapshot, id);
+      const message = err instanceof Error ? err.message : "Erro ao mover conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const clearGroupFromConversations = (groupId) => {
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(runtimeScope.value).filter((scope) => bucketValue(conversationBuckets, scope, []).some((conversation) => conversation.groupId === groupId));
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    for (const scope of affectedScopes) {
+      const currentConversations = bucketValue(conversationBuckets, scope, []);
+      commitConversationsToScope(
+        scope,
+        currentConversations.map(
+          (conversation) => conversation.groupId === groupId ? { ...conversation, groupId: null } : conversation
+        )
+      );
+    }
+    return () => restoreConversationBuckets(conversationSnapshot);
+  };
   const renameConversation = async (id, title) => {
     error.value = null;
     const requestRuntimeScope = runtimeScope.value;
@@ -434,9 +476,11 @@ export function useConversations() {
     createConversation,
     deleteConversation,
     renameConversation,
+    moveConversationToGroup,
     duplicateConversation,
     conversationCreatorFilter,
     conversationCreatorFilterCounts,
-    updateConversationInList
+    updateConversationInList,
+    clearGroupFromConversations
   };
 }

package/dist/runtime/composables/usePendingConversationGroup.d.ts

@@ -0,0 +1,5 @@
+export declare function usePendingConversationGroup(): {
+    pendingConversationGroupId: any;
+    setPendingConversationGroup: (groupId?: string | null) => void;
+    clearPendingConversationGroup: () => void;
+};

package/dist/runtime/composables/usePendingConversationGroup.js

@@ -0,0 +1,33 @@
+import { useChatAuth } from "#chat-auth";
+import { resolveChatStateScope } from "../utils/tela-chat.js";
+const PENDING_CONVERSATION_GROUP_STATE_KEY = "chat-pending-conversation-group";
+export function usePendingConversationGroup() {
+  const embedConfig = useEmbedConfig();
+  const { activeOrganization } = useChatAuth();
+  const pendingConversationGroups = useState(
+    PENDING_CONVERSATION_GROUP_STATE_KEY,
+    () => ({})
+  );
+  const runtimeScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const pendingConversationGroupId = computed(
+    () => pendingConversationGroups.value[runtimeScope.value] ?? null
+  );
+  function setPendingConversationGroup(groupId) {
+    pendingConversationGroups.value = {
+      ...pendingConversationGroups.value,
+      [runtimeScope.value]: groupId ?? null
+    };
+  }
+  function clearPendingConversationGroup() {
+    setPendingConversationGroup(null);
+  }
+  return {
+    pendingConversationGroupId,
+    setPendingConversationGroup,
+    clearPendingConversationGroup
+  };
+}

package/dist/runtime/embed/components/ChatConfigurationModal.d.vue.ts

@@ -18,8 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onSave?: ((payload: ChatConfigurationSavePayload) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
-    initialTab: ChatConfigurationTab;
     saving: boolean;
+    initialTab: ChatConfigurationTab;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/embed/components/ChatConfigurationModal.vue.d.ts

@@ -18,8 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onSave?: ((payload: ChatConfigurationSavePayload) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
-    initialTab: ChatConfigurationTab;
     saving: boolean;
+    initialTab: ChatConfigurationTab;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;