@meistrari/chat-nuxt 1.0.0

package/dist/runtime/composables/useConversationFilesPanel.js

@@ -0,0 +1,35 @@
+const MIN_PANEL_WIDTH = 320;
+const MAX_PANEL_WIDTH = 600;
+export function useConversationFilesPanel() {
+  const isOpen = useState("filesPanel:isOpen", () => false);
+  const conversationId = useState("filesPanel:conversationId", () => null);
+  const panelWidth = useState("filesPanel:width", () => 400);
+  function openPanel(id) {
+    conversationId.value = id;
+    isOpen.value = true;
+  }
+  function closePanel() {
+    isOpen.value = false;
+  }
+  function togglePanel(id) {
+    if (isOpen.value && conversationId.value === id) {
+      closePanel();
+    } else {
+      openPanel(id);
+    }
+  }
+  function setPanelWidth(width) {
+    panelWidth.value = Math.min(Math.max(width, MIN_PANEL_WIDTH), MAX_PANEL_WIDTH);
+  }
+  return {
+    isOpen: readonly(isOpen),
+    conversationId: readonly(conversationId),
+    panelWidth: readonly(panelWidth),
+    minPanelWidth: MIN_PANEL_WIDTH,
+    maxPanelWidth: MAX_PANEL_WIDTH,
+    openPanel,
+    closePanel,
+    togglePanel,
+    setPanelWidth
+  };
+}

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

@@ -0,0 +1,15 @@
+import type { DeepReadonly } from 'vue';
+import type { Conversation, ModelOption } from '../types/chat.js';
+export declare function useConversations(): {
+    conversations: any;
+    loading: any;
+    error: any;
+    fetchConversations: () => Promise<void>;
+    createConversation: (options?: {
+        model?: ModelOption | null;
+    }) => Promise<Conversation | null>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    renameConversation: (id: string, title: string) => Promise<boolean>;
+    duplicateConversation: (id: string) => Promise<Conversation | null>;
+    updateConversationInList: (updated: Conversation | DeepReadonly<Conversation>) => void;
+};

package/dist/runtime/composables/useConversations.js

@@ -0,0 +1,191 @@
+import * as Sentry from "@sentry/nuxt";
+export function useConversations() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const conversationBuckets = useState("conversations", () => ({}));
+  const loadingBuckets = useState("conversations-loading", () => ({}));
+  const errorBuckets = useState("conversations-error", () => ({}));
+  const workspaceScope = computed(() => embedConfig?.workspaceId.value.trim() || "default");
+  const conversations = computed({
+    get: () => conversationBuckets.value[workspaceScope.value] ?? [],
+    set: (value) => {
+      conversationBuckets.value = {
+        ...conversationBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const loading = computed({
+    get: () => loadingBuckets.value[workspaceScope.value] ?? false,
+    set: (value) => {
+      loadingBuckets.value = {
+        ...loadingBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const error = computed({
+    get: () => errorBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      errorBuckets.value = {
+        ...errorBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  function cloneAppliedSettingsSnapshot(snapshot) {
+    if (!snapshot)
+      return null;
+    return JSON.parse(JSON.stringify(snapshot));
+  }
+  const fetchConversations = async () => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await $fetch(
+        chatApi.path("/conversations"),
+        chatApi.withChatHeaders()
+      );
+      conversations.value = data;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao carregar conversas";
+      error.value = message;
+      Sentry.captureException(err);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const createConversation = async (options) => {
+    error.value = null;
+    try {
+      const conversation = await $fetch(
+        chatApi.path("/conversations"),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: options?.model ? { model: options.model } : void 0
+        })
+      );
+      conversations.value = [conversation, ...conversations.value];
+      return conversation;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao criar conversa";
+      error.value = message;
+      return null;
+    }
+  };
+  const deleteConversation = async (id) => {
+    error.value = null;
+    const statusToast = useStatusToast();
+    const deletedConversation = conversations.value.find((c) => c.id === id);
+    conversations.value = conversations.value.filter((c) => c.id !== id);
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders({
+          method: "DELETE"
+        })
+      );
+      statusToast.update({
+        text: "Conversa exclu\xEDda",
+        icon: "i-ph-check"
+      });
+      return true;
+    } catch (err) {
+      if (deletedConversation) {
+        conversations.value = [...conversations.value, deletedConversation].sort(
+          (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+        );
+      }
+      const message = err instanceof Error ? err.message : "Erro ao deletar conversa";
+      error.value = message;
+      statusToast.update({
+        text: "Erro ao excluir conversa",
+        icon: "i-ph-warning"
+      });
+      return false;
+    }
+  };
+  const updateConversationInList = (updated) => {
+    const index = conversations.value.findIndex((c) => c.id === updated.id);
+    if (index !== -1) {
+      const nextConversations = [...conversations.value];
+      nextConversations[index] = {
+        id: updated.id,
+        workspaceId: updated.workspaceId,
+        userId: updated.userId,
+        title: updated.title,
+        threadSessionId: updated.threadSessionId,
+        model: updated.model,
+        appliedSettingsAt: updated.appliedSettingsAt,
+        appliedSettingsSnapshot: cloneAppliedSettingsSnapshot(updated.appliedSettingsSnapshot),
+        createdBy: updated.createdBy,
+        createdAt: updated.createdAt,
+        updatedAt: updated.updatedAt
+      };
+      conversations.value = nextConversations.sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+    }
+  };
+  const renameConversation = async (id, title) => {
+    error.value = null;
+    const conversation = conversations.value.find((c) => c.id === id);
+    if (!conversation)
+      return false;
+    const previousTitle = conversation.title;
+    updateConversationInList({ ...conversation, title, updatedAt: /* @__PURE__ */ new Date() });
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders({
+          method: "PATCH",
+          body: { title }
+        })
+      );
+      return true;
+    } catch (err) {
+      updateConversationInList({ ...conversation, title: previousTitle });
+      const message = err instanceof Error ? err.message : "Erro ao renomear conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const duplicateConversation = async (id) => {
+    error.value = null;
+    const statusToast = useStatusToast();
+    try {
+      const duplicated = await $fetch(
+        chatApi.path(`/conversations/${id}/duplicate`),
+        chatApi.withChatHeaders({
+          method: "POST"
+        })
+      );
+      conversations.value = [duplicated, ...conversations.value];
+      statusToast.update({
+        text: "Conversa duplicada",
+        icon: "i-ph-check"
+      });
+      return duplicated;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao duplicar conversa";
+      error.value = message;
+      statusToast.update({
+        text: "Erro ao duplicar conversa",
+        icon: "i-ph-warning"
+      });
+      return null;
+    }
+  };
+  return {
+    conversations: readonly(conversations),
+    loading: readonly(loading),
+    error: readonly(error),
+    fetchConversations,
+    createConversation,
+    deleteConversation,
+    renameConversation,
+    duplicateConversation,
+    updateConversationInList
+  };
+}

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

@@ -0,0 +1,11 @@
+export declare function useDiagramExport(diagramSource: Ref<string>, renderedSvg: Ref<string>, svgContainerRef: Ref<HTMLElement | null>, svgSize: Ref<{
+    width: number;
+    height: number;
+}>): {
+    copyState: any;
+    exportState: any;
+    copyLabel: any;
+    exportLabel: any;
+    handleCopy: () => Promise<void>;
+    handleDownloadJpeg: () => Promise<void>;
+};

package/dist/runtime/composables/useDiagramExport.js

@@ -0,0 +1,186 @@
+import { useClipboard } from "@vueuse/core";
+const EXPORT_PADDING = 24;
+const EXPORT_MIN_LONGEST_EDGE = 2400;
+const EXPORT_MAX_SCALE = 4;
+function withSvgNamespace(svgMarkup) {
+  if (svgMarkup.includes("xmlns=")) {
+    return svgMarkup;
+  }
+  return svgMarkup.replace("<svg", '<svg xmlns="http://www.w3.org/2000/svg"');
+}
+function buildExportableSvg(container) {
+  const svgElement = container?.querySelector("svg");
+  if (!svgElement) {
+    return null;
+  }
+  const exportSvg = svgElement.cloneNode(true);
+  exportSvg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  exportSvg.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
+  exportSvg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  exportSvg.style.background = "#ffffff";
+  exportSvg.style.maxWidth = "none";
+  exportSvg.style.height = "auto";
+  try {
+    const box = svgElement.getBBox();
+    if (box.width > 0 && box.height > 0) {
+      const width2 = Math.ceil(box.width + EXPORT_PADDING * 2);
+      const height2 = Math.ceil(box.height + EXPORT_PADDING * 2);
+      const minX = Math.floor(box.x - EXPORT_PADDING);
+      const minY = Math.floor(box.y - EXPORT_PADDING);
+      exportSvg.setAttribute("viewBox", `${minX} ${minY} ${width2} ${height2}`);
+      exportSvg.setAttribute("width", `${width2}`);
+      exportSvg.setAttribute("height", `${height2}`);
+      return {
+        markup: withSvgNamespace(new XMLSerializer().serializeToString(exportSvg)),
+        width: width2,
+        height: height2
+      };
+    }
+  } catch {
+  }
+  const viewBox = svgElement.viewBox?.baseVal;
+  if (viewBox && viewBox.width > 0 && viewBox.height > 0) {
+    const width2 = Math.ceil(viewBox.width);
+    const height2 = Math.ceil(viewBox.height);
+    exportSvg.setAttribute("viewBox", `${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}`);
+    exportSvg.setAttribute("width", `${width2}`);
+    exportSvg.setAttribute("height", `${height2}`);
+    return {
+      markup: withSvgNamespace(new XMLSerializer().serializeToString(exportSvg)),
+      width: width2,
+      height: height2
+    };
+  }
+  const width = Number.parseFloat(svgElement.getAttribute("width") ?? "");
+  const height = Number.parseFloat(svgElement.getAttribute("height") ?? "");
+  if (Number.isFinite(width) && width > 0 && Number.isFinite(height) && height > 0) {
+    exportSvg.setAttribute("width", `${width}`);
+    exportSvg.setAttribute("height", `${height}`);
+    return {
+      markup: withSvgNamespace(new XMLSerializer().serializeToString(exportSvg)),
+      width,
+      height
+    };
+  }
+  return null;
+}
+function extractDiagramTitle(source) {
+  const frontMatterMatch = source.match(/^---\s*\n[\s\S]*?title\s*:\s*(.+?)\s*\n[\s\S]*?---/i);
+  if (frontMatterMatch?.[1]) {
+    return frontMatterMatch[1];
+  }
+  const titleMatch = source.match(/^\s*title\s+(.+)$/m);
+  if (titleMatch?.[1]) {
+    return titleMatch[1].trim();
+  }
+  const accTitleMatch = source.match(/^\s*accTitle\s*:\s*(.+)$/m);
+  if (accTitleMatch?.[1]) {
+    return accTitleMatch[1].trim();
+  }
+  return null;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+export function useDiagramExport(diagramSource, renderedSvg, svgContainerRef, svgSize) {
+  const { copy } = useClipboard();
+  const statusToast = useStatusToast();
+  const copyState = ref("idle");
+  const exportState = ref("idle");
+  const downloadFilename = computed(() => {
+    const title = extractDiagramTitle(diagramSource.value);
+    return title ? `${slugify(title)}.jpg` : "diagram.jpg";
+  });
+  const copyLabel = computed(() => copyState.value === "done" ? "Copiado" : "Copiar c\xF3digo");
+  const exportLabel = computed(() => {
+    if (exportState.value === "running") {
+      return "Exportando...";
+    }
+    if (exportState.value === "done") {
+      return "Baixado";
+    }
+    return "Baixar JPEG";
+  });
+  async function handleCopy() {
+    if (!diagramSource.value || !import.meta.client) {
+      return;
+    }
+    try {
+      await copy(diagramSource.value);
+      copyState.value = "done";
+      statusToast.update({ text: "C\xF3digo copiado", icon: "i-ph-check" });
+    } catch {
+      copyState.value = "error";
+      statusToast.update({ text: "Erro ao copiar c\xF3digo", icon: "i-ph-warning" });
+    } finally {
+      window.setTimeout(() => {
+        copyState.value = "idle";
+      }, 1600);
+    }
+  }
+  async function handleDownloadJpeg() {
+    if (!renderedSvg.value || !import.meta.client || exportState.value === "running") {
+      return;
+    }
+    exportState.value = "running";
+    try {
+      const exportSvg = buildExportableSvg(svgContainerRef.value);
+      const svgMarkup = exportSvg?.markup ?? withSvgNamespace(renderedSvg.value);
+      const svgBlob = new Blob([svgMarkup], { type: "image/svg+xml;charset=utf-8" });
+      const svgUrl = URL.createObjectURL(svgBlob);
+      try {
+        const image = await new Promise((resolve, reject) => {
+          const img = new Image();
+          img.onload = () => resolve(img);
+          img.onerror = () => reject(new Error("Unable to load SVG for export"));
+          img.src = svgUrl;
+        });
+        const baseWidth = Math.max(1, Math.round(exportSvg?.width || image.naturalWidth || svgSize.value.width));
+        const baseHeight = Math.max(1, Math.round(exportSvg?.height || image.naturalHeight || svgSize.value.height));
+        const longestEdge = Math.max(baseWidth, baseHeight);
+        const scale = Math.min(
+          EXPORT_MAX_SCALE,
+          Math.max(window.devicePixelRatio || 1, EXPORT_MIN_LONGEST_EDGE / longestEdge)
+        );
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.round(baseWidth * scale));
+        canvas.height = Math.max(1, Math.round(baseHeight * scale));
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("Canvas export is not available");
+        }
+        context.scale(scale, scale);
+        context.fillStyle = "#ffffff";
+        context.fillRect(0, 0, baseWidth, baseHeight);
+        context.drawImage(image, 0, 0, baseWidth, baseHeight);
+        const jpegBlob = await new Promise((resolve) => canvas.toBlob(resolve, "image/jpeg", 0.94));
+        if (!jpegBlob) {
+          throw new Error("JPEG export failed");
+        }
+        const downloadUrl = URL.createObjectURL(jpegBlob);
+        const anchor = document.createElement("a");
+        anchor.href = downloadUrl;
+        anchor.download = downloadFilename.value;
+        anchor.click();
+        URL.revokeObjectURL(downloadUrl);
+        exportState.value = "done";
+      } finally {
+        URL.revokeObjectURL(svgUrl);
+      }
+    } catch {
+      exportState.value = "error";
+    } finally {
+      window.setTimeout(() => {
+        exportState.value = "idle";
+      }, 1800);
+    }
+  }
+  return {
+    copyState,
+    exportState,
+    copyLabel,
+    exportLabel,
+    handleCopy,
+    handleDownloadJpeg
+  };
+}

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

@@ -0,0 +1,13 @@
+import type { DeepReadonly, Ref } from 'vue';
+import type { WorkspaceSettings } from './useWorkspaceSettings.js';
+export type EmbedConfig = {
+    workspaceId: Ref<string>;
+    workspaceSettings: Ref<DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null | undefined>;
+    hideSidebar: Ref<boolean>;
+};
+export declare function provideEmbedConfig(props: {
+    workspaceId: string;
+    workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
+    hideSidebar?: boolean;
+}): void;
+export declare function useEmbedConfig(): EmbedConfig | null;

package/dist/runtime/composables/useEmbedConfig.js

@@ -0,0 +1,11 @@
+const EMBED_CONFIG_KEY = "embed-config";
+export function provideEmbedConfig(props) {
+  provide(EMBED_CONFIG_KEY, {
+    workspaceId: computed(() => props.workspaceId),
+    workspaceSettings: toRef(props, "workspaceSettings"),
+    hideSidebar: computed(() => props.hideSidebar ?? true)
+  });
+}
+export function useEmbedConfig() {
+  return inject(EMBED_CONFIG_KEY, null);
+}

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

@@ -0,0 +1,19 @@
+import type { FeatureFlagKey } from '../types/feature-flags.js';
+type AuthUser = {
+    id: string;
+    email: string;
+    name: string;
+    image?: string | null;
+};
+type Workspace = {
+    id: string;
+    name?: string | null;
+};
+export declare function initPosthog(publicKey: string, host: string, defaults: string): Promise<void>;
+export declare function identifyPosthogUser(user: AuthUser): void;
+export declare function resetPosthogIdentity(): void;
+export declare function setPosthogWorkspace(workspace: Workspace): void;
+export declare function useFeatureFlags(): {
+    isFeatureEnabled: (flag: FeatureFlagKey) => boolean;
+};
+export {};

package/dist/runtime/composables/useFeatureFlags.js

@@ -0,0 +1,67 @@
+const posthogClient = shallowRef(null);
+const flagsVersion = ref(0);
+let identifiedUserFingerprint = null;
+export async function initPosthog(publicKey, host, defaults) {
+  if (posthogClient.value)
+    return;
+  try {
+    const { default: posthog } = await import("posthog-js");
+    const client = posthog.init(publicKey, {
+      api_host: host,
+      defaults,
+      person_profiles: "identified_only",
+      loaded: (c) => {
+        if (import.meta.dev)
+          c.debug();
+        c.onFeatureFlags(() => {
+          flagsVersion.value++;
+        });
+      }
+    }) ?? null;
+    posthogClient.value = client;
+  } catch (error) {
+    console.error("PostHog initialization failed:", error);
+  }
+}
+export function identifyPosthogUser(user) {
+  const client = posthogClient.value;
+  if (!client)
+    return;
+  const fingerprint = [user.id, user.email, user.name, user.image].filter(Boolean).join("|");
+  if (!fingerprint || identifiedUserFingerprint === fingerprint)
+    return;
+  client.identify(user.id, {
+    email: user.email,
+    name: user.name,
+    avatar_url: user.image ?? void 0
+  });
+  identifiedUserFingerprint = fingerprint;
+}
+export function resetPosthogIdentity() {
+  posthogClient.value?.reset();
+  identifiedUserFingerprint = null;
+}
+export function setPosthogWorkspace(workspace) {
+  const client = posthogClient.value;
+  if (!client)
+    return;
+  client.group("workspace", workspace.id, {
+    name: workspace.name ?? workspace.id
+  });
+}
+export function useFeatureFlags() {
+  const isFeatureEnabled = (flag) => {
+    void flagsVersion.value;
+    try {
+      const client = posthogClient.value;
+      if (!client)
+        return false;
+      return client.isFeatureEnabled(flag) ?? false;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    isFeatureEnabled
+  };
+}

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

@@ -0,0 +1,17 @@
+export declare function useFileDrop(options?: {
+    maxFiles?: number;
+    maxFileSize?: number;
+    onDrop?: (files: File[]) => void;
+    onFilesRejected?: (rejectedFiles: {
+        file: File;
+        reason: 'size' | 'limit';
+    }[]) => void;
+}): {
+    isDragging: any;
+    rejectedFiles: any;
+    setupDropZone: (element: Ref<HTMLElement | null>) => void;
+    handleDragEnter: (e: DragEvent) => void;
+    handleDragLeave: (e: DragEvent) => void;
+    handleDragOver: (e: DragEvent) => void;
+    handleDrop: (e: DragEvent) => void;
+};

package/dist/runtime/composables/useFileDrop.js

@@ -0,0 +1,89 @@
+export function useFileDrop(options = {}) {
+  const {
+    maxFiles = 5,
+    maxFileSize = 10 * 1024 * 1024,
+    onDrop,
+    onFilesRejected
+  } = options;
+  const isDragging = ref(false);
+  const dragCounter = ref(0);
+  const rejectedFiles = ref([]);
+  function validateFiles(files) {
+    const rejected = [];
+    const valid = [];
+    for (const file of files) {
+      if (file.size > maxFileSize) {
+        console.warn(`File ${file.name} exceeds max size of ${maxFileSize} bytes`);
+        rejected.push({ file, reason: "size" });
+      } else if (valid.length >= maxFiles) {
+        rejected.push({ file, reason: "limit" });
+      } else {
+        valid.push(file);
+      }
+    }
+    if (rejected.length > 0) {
+      rejectedFiles.value = rejected;
+      onFilesRejected?.(rejected);
+    }
+    return valid;
+  }
+  function handleDragEnter(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    dragCounter.value++;
+    if (e.dataTransfer?.types.includes("Files")) {
+      isDragging.value = true;
+    }
+  }
+  function handleDragLeave(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    dragCounter.value--;
+    if (dragCounter.value === 0) {
+      isDragging.value = false;
+    }
+  }
+  function handleDragOver(e) {
+    e.preventDefault();
+    e.stopPropagation();
+  }
+  function handleDrop(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    isDragging.value = false;
+    dragCounter.value = 0;
+    const files = Array.from(e.dataTransfer?.files ?? []);
+    if (files.length === 0)
+      return;
+    const validFiles = validateFiles(files);
+    if (validFiles.length > 0 && onDrop) {
+      onDrop(validFiles);
+    }
+  }
+  function setupDropZone(element) {
+    watchEffect((onCleanup) => {
+      const el = element.value;
+      if (!el)
+        return;
+      el.addEventListener("dragenter", handleDragEnter);
+      el.addEventListener("dragleave", handleDragLeave);
+      el.addEventListener("dragover", handleDragOver);
+      el.addEventListener("drop", handleDrop);
+      onCleanup(() => {
+        el.removeEventListener("dragenter", handleDragEnter);
+        el.removeEventListener("dragleave", handleDragLeave);
+        el.removeEventListener("dragover", handleDragOver);
+        el.removeEventListener("drop", handleDrop);
+      });
+    });
+  }
+  return {
+    isDragging: readonly(isDragging),
+    rejectedFiles: readonly(rejectedFiles),
+    setupDropZone,
+    handleDragEnter,
+    handleDragLeave,
+    handleDragOver,
+    handleDrop
+  };
+}

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

@@ -0,0 +1,30 @@
+import type { DetectedFile } from '../utils/file.js';
+export type FilePreviewData = {
+    file: DetectedFile;
+    resolvedUrl?: string;
+    cachedBase64?: string;
+    originalFileName?: string;
+    resolvedMimeType?: string;
+    fileSize?: number;
+    pdfTotalPages?: number;
+    csvInfo?: {
+        totalRows: number;
+        totalColumns: number;
+    };
+    textInfo?: {
+        totalLines: number;
+    };
+};
+export declare function useFilePreviewPanel(): {
+    isOpen: any;
+    isLoading: any;
+    currentFile: any;
+    panelWidth: any;
+    minPanelWidth: number;
+    maxPanelWidth: number;
+    openPreview: (data: FilePreviewData) => void;
+    updatePreview: (data: Partial<FilePreviewData>) => void;
+    setError: () => void;
+    closePreview: () => void;
+    setPanelWidth: (width: number) => void;
+};