@meistrari/chat-nuxt 1.11.0 → 1.13.0

package/dist/runtime/components/chat/topbar.vue.d.ts

@@ -19,11 +19,11 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     rename: () => any;
     duplicate: () => any;
     export: () => any;
+    copyLink: () => any;
     "update:isEditing": (value: boolean) => any;
     "update:editTitle": (value: string) => any;
     saveTitle: () => any;
     cancelEditing: () => any;
-    copyLink: () => any;
     debug: () => any;
     tabChange: (tab: TopbarTab) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
@@ -31,11 +31,11 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onRename?: (() => any) | undefined;
     onDuplicate?: (() => any) | undefined;
     onExport?: (() => any) | undefined;
+    onCopyLink?: (() => any) | undefined;
     "onUpdate:isEditing"?: ((value: boolean) => any) | undefined;
     "onUpdate:editTitle"?: ((value: string) => any) | undefined;
     onSaveTitle?: (() => any) | undefined;
     onCancelEditing?: (() => any) | undefined;
-    onCopyLink?: (() => any) | undefined;
     onDebug?: (() => any) | undefined;
     onTabChange?: ((tab: TopbarTab) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,12 @@
+import type { ConversationGroup } from '../types/chat.js';
+export declare function useConversationGroups(): {
+    groups: any;
+    loading: any;
+    error: any;
+    fetchGroups: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    createGroup: (name: string) => Promise<ConversationGroup | null>;
+    renameGroup: (groupId: string, name: string) => Promise<boolean>;
+    deleteGroup: (groupId: string) => Promise<boolean>;
+};

package/dist/runtime/composables/useConversationGroups.js

@@ -0,0 +1,160 @@
+import * as Sentry from "@sentry/nuxt";
+import { useChatAuth } from "#chat-auth";
+import { resolveChatStateScope } from "../utils/tela-chat.js";
+function sortConversationGroups(groups) {
+  return [...groups].sort((a, b) => {
+    const createdDelta = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+    if (createdDelta !== 0)
+      return createdDelta;
+    return a.name.localeCompare(b.name);
+  });
+}
+export function useConversationGroups() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const { activeOrganization } = useChatAuth();
+  const groupBuckets = useState("conversation-groups", () => ({}));
+  const loadingBuckets = useState("conversation-groups-loading", () => ({}));
+  const fetchedBuckets = useState("conversation-groups-fetched", () => ({}));
+  const errorBuckets = useState("conversation-groups-error", () => ({}));
+  const runtimeScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const groups = computed({
+    get: () => groupBuckets.value[runtimeScope.value] ?? [],
+    set: (value) => {
+      groupBuckets.value = {
+        ...groupBuckets.value,
+        [runtimeScope.value]: sortConversationGroups(value)
+      };
+    }
+  });
+  const loading = computed({
+    get: () => loadingBuckets.value[runtimeScope.value] ?? false,
+    set: (value) => {
+      loadingBuckets.value = {
+        ...loadingBuckets.value,
+        [runtimeScope.value]: value
+      };
+    }
+  });
+  const error = computed({
+    get: () => errorBuckets.value[runtimeScope.value] ?? null,
+    set: (value) => {
+      errorBuckets.value = {
+        ...errorBuckets.value,
+        [runtimeScope.value]: value
+      };
+    }
+  });
+  function setFetched(value) {
+    fetchedBuckets.value = {
+      ...fetchedBuckets.value,
+      [runtimeScope.value]: value
+    };
+  }
+  function upsertGroup(group) {
+    groups.value = [
+      group,
+      ...groups.value.filter((item) => item.id !== group.id)
+    ];
+  }
+  function removeGroup(groupId) {
+    groups.value = groups.value.filter((group) => group.id !== groupId);
+  }
+  const fetchGroups = async (options = {}) => {
+    if (loading.value || fetchedBuckets.value[runtimeScope.value] && !options.force) {
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      groups.value = await $fetch(
+        chatApi.path("/conversations/groups"),
+        chatApi.withChatHeaders()
+      );
+      setFetched(true);
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : "Erro ao carregar pastas";
+      Sentry.captureException(err);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const createGroup = async (name) => {
+    error.value = null;
+    try {
+      const group = await $fetch(
+        chatApi.path("/conversations/groups"),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: { name }
+        })
+      );
+      upsertGroup(group);
+      setFetched(true);
+      return group;
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : "Erro ao criar pasta";
+      Sentry.captureException(err);
+      return null;
+    }
+  };
+  const renameGroup = async (groupId, name) => {
+    error.value = null;
+    const previousGroups = groups.value;
+    const group = groups.value.find((item) => item.id === groupId);
+    if (!group)
+      return false;
+    upsertGroup({ ...group, name, updatedAt: /* @__PURE__ */ new Date() });
+    try {
+      const updated = await $fetch(
+        chatApi.path(`/conversations/groups/${groupId}`),
+        chatApi.withChatHeaders({
+          method: "PATCH",
+          body: { name }
+        })
+      );
+      upsertGroup(updated);
+      return true;
+    } catch (err) {
+      groups.value = previousGroups;
+      error.value = err instanceof Error ? err.message : "Erro ao renomear pasta";
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const deleteGroup = async (groupId) => {
+    error.value = null;
+    const previousGroups = groups.value;
+    const { clearGroupFromConversations } = useConversations();
+    removeGroup(groupId);
+    const restoreConversations = clearGroupFromConversations(groupId);
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/groups/${groupId}`),
+        chatApi.withChatHeaders({
+          method: "DELETE"
+        })
+      );
+      return true;
+    } catch (err) {
+      groups.value = previousGroups;
+      restoreConversations();
+      error.value = err instanceof Error ? err.message : "Erro ao excluir pasta";
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  return {
+    groups: readonly(groups),
+    loading: readonly(loading),
+    error: readonly(error),
+    fetchGroups,
+    createGroup,
+    renameGroup,
+    deleteGroup
+  };
+}

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

@@ -0,0 +1,48 @@
+import type { DeepReadonly } from 'vue';
+import type { Conversation } from '../types/chat.js';
+export type ConversationItemOptions = {
+    conversation: DeepReadonly<Conversation>;
+    active: boolean;
+    draggable?: boolean;
+    userImage?: string;
+    selectConversation?: (id: string) => void | Promise<void>;
+};
+export type ConversationItemEmit = {
+    (e: 'delete', id: string): void;
+    (e: 'rename', id: string, title: string): void;
+    (e: 'duplicate', id: string): void;
+    (e: 'export', id: string): void;
+    (e: 'dragStart', id: string): void;
+    (e: 'dragEnd'): void;
+};
+export declare function useConversationItem(options: ConversationItemOptions, emit: ConversationItemEmit): {
+    isRenamingInline: any;
+    renameTitle: any;
+    renameInputRef: any;
+    showDeleteModal: any;
+    menuButtonRef: any;
+    isMenuOpen: any;
+    conversationPath: any;
+    displayTitle: any;
+    menuItems: ({
+        label: string;
+        icon: string;
+        click: () => void;
+        color?: undefined;
+    } | {
+        label: string;
+        icon: string;
+        color: "negative";
+        click: () => boolean;
+    })[];
+    confirmDelete: () => void;
+    cancelDelete: () => void;
+    handleConversationClick: (event: MouseEvent) => void;
+    startRename: () => void;
+    handleConversationDoubleClick: () => void;
+    handleConversationDragStart: (event: DragEvent) => void;
+    handleConversationDragEnd: () => void;
+    cancelRename: () => void;
+    submitRename: () => void;
+    handleRenameBlur: () => void;
+};

package/dist/runtime/composables/useConversationItem.js

@@ -0,0 +1,176 @@
+import { useMagicKeys, useMutationObserver } from "@vueuse/core";
+import { resolveConversationRenameTitle } from "../utils/conversation-title.js";
+import { capitalizeFirst } from "../utils/string.js";
+const conversationNavigationDelayMs = 250;
+export function useConversationItem(options, emit) {
+  const isRenamingInline = ref(false);
+  const renameTitle = ref("");
+  const renameInputRef = ref(null);
+  const isIgnoringInitialRenameBlur = ref(false);
+  const showDeleteModal = ref(false);
+  const menuButtonRef = ref(null);
+  const isMenuOpen = ref(false);
+  const conversationPath = computed(() => `/${options.conversation.id}`);
+  const displayTitle = computed(() => capitalizeFirst(options.conversation.title));
+  const { escape } = useMagicKeys();
+  let conversationNavigationTimer = null;
+  let renameBlurTimer = null;
+  watch(() => escape?.value, (pressed) => {
+    if (pressed && isRenamingInline.value) {
+      cancelRename();
+    }
+    if (pressed && showDeleteModal.value) {
+      cancelDelete();
+    }
+  });
+  useMutationObserver(menuButtonRef, (mutations) => {
+    for (const mutation of mutations) {
+      if (mutation.attributeName === "data-state") {
+        isMenuOpen.value = menuButtonRef.value?.getAttribute("data-state") === "open";
+      }
+    }
+  }, { attributes: true });
+  function clearPendingConversationNavigation() {
+    if (conversationNavigationTimer === null)
+      return;
+    clearTimeout(conversationNavigationTimer);
+    conversationNavigationTimer = null;
+  }
+  function clearRenameBlurTimer() {
+    if (renameBlurTimer === null)
+      return;
+    clearTimeout(renameBlurTimer);
+    renameBlurTimer = null;
+  }
+  function allowRenameBlurSoon() {
+    clearRenameBlurTimer();
+    renameBlurTimer = setTimeout(() => {
+      isIgnoringInitialRenameBlur.value = false;
+      renameBlurTimer = null;
+    }, 100);
+  }
+  function confirmDelete() {
+    showDeleteModal.value = false;
+    emit("delete", options.conversation.id);
+  }
+  function cancelDelete() {
+    showDeleteModal.value = false;
+  }
+  function handleConversationClick(event) {
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+      return;
+    event.preventDefault();
+    clearPendingConversationNavigation();
+    if (event.detail > 1)
+      return;
+    conversationNavigationTimer = setTimeout(() => {
+      if (options.selectConversation) {
+        void options.selectConversation(options.conversation.id);
+      } else {
+        navigateTo(conversationPath.value);
+      }
+      conversationNavigationTimer = null;
+    }, conversationNavigationDelayMs);
+  }
+  async function focusRenameInput() {
+    await nextTick();
+    renameInputRef.value?.focus();
+    renameInputRef.value?.select();
+    allowRenameBlurSoon();
+  }
+  function startRename() {
+    isMenuOpen.value = false;
+    clearPendingConversationNavigation();
+    clearRenameBlurTimer();
+    renameTitle.value = options.conversation.title;
+    isIgnoringInitialRenameBlur.value = true;
+    isRenamingInline.value = true;
+    void focusRenameInput();
+  }
+  function handleConversationDoubleClick() {
+    clearPendingConversationNavigation();
+    startRename();
+  }
+  function handleConversationDragStart(event) {
+    if (!options.draggable)
+      return;
+    event.dataTransfer?.setData("text/plain", options.conversation.id);
+    if (event.dataTransfer) {
+      event.dataTransfer.effectAllowed = "move";
+    }
+    emit("dragStart", options.conversation.id);
+  }
+  function handleConversationDragEnd() {
+    emit("dragEnd");
+  }
+  function cancelRename() {
+    isRenamingInline.value = false;
+    isIgnoringInitialRenameBlur.value = false;
+    renameTitle.value = "";
+    clearRenameBlurTimer();
+  }
+  function submitRename() {
+    if (!isRenamingInline.value)
+      return;
+    const title = resolveConversationRenameTitle(renameTitle.value, options.conversation.title);
+    if (!title) {
+      cancelRename();
+      return;
+    }
+    emit("rename", options.conversation.id, title);
+    cancelRename();
+  }
+  function handleRenameBlur() {
+    if (isIgnoringInitialRenameBlur.value)
+      return;
+    submitRename();
+  }
+  const menuItems = [
+    {
+      label: "Renomear",
+      icon: "i-ph-pencil-simple",
+      click: () => startRename()
+    },
+    {
+      label: "Duplicar",
+      icon: "i-ph-copy",
+      click: () => emit("duplicate", options.conversation.id)
+    },
+    {
+      label: "Exportar",
+      icon: "i-ph-download-simple",
+      click: () => emit("export", options.conversation.id)
+    },
+    {
+      label: "Excluir",
+      icon: "i-ph-trash",
+      color: "negative",
+      click: () => showDeleteModal.value = true
+    }
+  ];
+  onBeforeUnmount(() => {
+    clearPendingConversationNavigation();
+    clearRenameBlurTimer();
+  });
+  return {
+    isRenamingInline,
+    renameTitle,
+    renameInputRef,
+    showDeleteModal,
+    menuButtonRef,
+    isMenuOpen,
+    conversationPath,
+    displayTitle,
+    menuItems,
+    confirmDelete,
+    cancelDelete,
+    handleConversationClick,
+    startRename,
+    handleConversationDoubleClick,
+    handleConversationDragStart,
+    handleConversationDragEnd,
+    cancelRename,
+    submitRename,
+    handleRenameBlur
+  };
+}

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

@@ -0,0 +1,128 @@
+import type { DeepReadonly } from 'vue';
+import type { Conversation } from '../types/chat.js';
+export type ConversationListOptions = {
+    conversations: DeepReadonly<Conversation[]>;
+    currentId?: string;
+    getMemberImage?: (userId: string) => string | undefined;
+    selectConversation?: (id: string) => void | Promise<void>;
+    resetConversation?: () => void | Promise<void>;
+    startConversation?: (groupId?: string | null) => void | Promise<void>;
+    loading?: boolean;
+};
+export type GroupDeleteTarget = {
+    id: string;
+    name: string;
+    conversationIds: string[];
+    conversationCount: number;
+};
+export declare function useConversationList(options: ConversationListOptions): {
+    conversationSearch: any;
+    groupedConversations: any;
+    hasConversationSearchQuery: any;
+    hasConversationContent: any;
+    shouldShowSkeleton: any;
+    emptyConversationMessage: any;
+    skeletonRows: readonly [{
+        readonly id: "row-1";
+        readonly width: "72%";
+    }, {
+        readonly id: "row-2";
+        readonly width: "54%";
+    }, {
+        readonly id: "row-3";
+        readonly width: "64%";
+    }, {
+        readonly id: "row-4";
+        readonly width: "46%";
+    }, {
+        readonly id: "row-5";
+        readonly width: "78%";
+    }, {
+        readonly id: "row-6";
+        readonly width: "58%";
+    }, {
+        readonly id: "row-7";
+        readonly width: "69%";
+    }, {
+        readonly id: "row-8";
+        readonly width: "51%";
+    }, {
+        readonly id: "row-9";
+        readonly width: "74%";
+    }, {
+        readonly id: "row-10";
+        readonly width: "62%";
+    }];
+    groupItems: any;
+    ungroupedConversations: any;
+    ungroupedDropTarget: any;
+    ungroupedConversationLabel: any;
+    shouldShowUngroupedHeader: any;
+    showGroupCreationPrompt: any;
+    showDeleteGroupModal: any;
+    showDeleteGroupConversationsModal: any;
+    groupActionLoading: any;
+    deleteGroupTarget: any;
+    deleteGroupConversationsTarget: any;
+    renamingGroupId: any;
+    renameGroupName: any;
+    renameGroupError: any;
+    deleteGroupConfirmationMessage: any;
+    deleteGroupConversationsConfirmationMessage: any;
+    isGroupOpen: (groupId: string) => any;
+    setGroupOpen: (groupId: string, open: boolean) => void;
+    toggleGroup: (groupId: string) => void;
+    openDeleteGroupModal: (groupId: string, groupName: string, conversations: readonly Pick<Conversation, "id">[]) => void;
+    openDeleteGroupConversationsModal: (groupId: string, groupName: string, conversations: readonly Pick<Conversation, "id">[]) => void;
+    startRenameGroup: (groupId: string, groupName: string) => void;
+    setRenameGroupInputRef: (element: unknown, groupId: string) => void;
+    getGroupMenuItems: (groupId: string, groupName: string, conversations: readonly Pick<Conversation, "id">[]) => ({
+        label: string;
+        icon: string;
+        click: () => void;
+        color?: undefined;
+        disabled?: undefined;
+    } | {
+        label: string;
+        icon: string;
+        color: "negative";
+        click: () => void;
+        disabled?: undefined;
+    } | {
+        label: string;
+        icon: string;
+        color: "negative";
+        disabled: boolean;
+        click: () => void;
+    })[];
+    clearDeleteGroupTarget: () => void;
+    clearDeleteGroupConversationsTarget: () => void;
+    cancelRenameGroup: () => void;
+    formatConversationCount: (count: number) => string;
+    groupConversationsMoveMessage: (count: number) => "A conversa desta pasta será movida para Conversas." | "As conversas desta pasta serão movidas para Conversas.";
+    confirmDeleteGroup: () => Promise<void>;
+    confirmDeleteGroupConversations: () => Promise<void>;
+    submitRenameGroup: () => Promise<void>;
+    handleRenameGroupBlur: () => void;
+    handleDelete: (id: string) => Promise<void>;
+    handleRename: (id: string, title: string) => Promise<void>;
+    handleDuplicate: (id: string) => Promise<void>;
+    handleExport: (id: string) => Promise<void>;
+    handleConversationDragStart: (id: string) => void;
+    clearDragState: () => void;
+    handleDragEnter: (groupId: string | null) => void;
+    handleDragOver: (event: DragEvent, groupId: string | null) => void;
+    handleDragLeave: (event: DragEvent, groupId: string | null) => void;
+    isDropTarget: (groupId: string | null) => boolean;
+    getConversationItemProps: (conversation: DeepReadonly<Conversation>) => {
+        conversation: {
+            readonly [x: string]: any;
+        };
+        active: boolean;
+        draggable: boolean;
+        userImage: string | undefined;
+        selectConversation: ((id: string) => void | Promise<void>) | undefined;
+    };
+    handleConversationDrop: (event: DragEvent, groupId: string | null) => Promise<void>;
+    startConversationInGroup: (groupId: string) => void;
+};