cleanup

frontend/src/app/useDocumentPreview.js

@@ -0,0 +1,221 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+const useDocumentPreview = ({
+  routeDocumentId,
+  documents,
+  searchResults,
+  setDocuments,
+  selectedFolder,
+  assetManager,
+  api,
+  resolveApiPath,
+  notifyApiError,
+  navigate,
+  locationPathname,
+  locationSearch,
+  detailPanelControlRef,
+  setActivePreviewId,
+}) => {
+  const [previewEntries, setPreviewEntries] = useState(() => new Map());
+  const previewInflightRef = useRef(new Map());
+  const previewReturnPathRef = useRef(null);
+
+  const resetPreviewState = useCallback(() => {
+    setPreviewEntries(() => new Map());
+    previewInflightRef.current = new Map();
+    previewReturnPathRef.current = null;
+  }, []);
+
+  const removePreviewEntries = useCallback((ids) => {
+    if (!Array.isArray(ids) || ids.length === 0) {
+      return;
+    }
+    setPreviewEntries((prev) => {
+      if (!prev.size) {
+        return prev;
+      }
+      let changed = false;
+      const next = new Map(prev);
+      ids.forEach((id) => {
+        if (next.delete(id)) {
+          changed = true;
+        }
+        previewInflightRef.current.delete(id);
+      });
+      return changed ? next : prev;
+    });
+  }, []);
+
+  const ensurePreviewUrl = useCallback(
+    async (documentId, { force = false } = {}) => {
+      if (!documentId) return null;
+
+      const existing = previewEntries.get(documentId) || null;
+      const now = Date.now();
+      const expiresAt = typeof existing?.expiresAt === 'number' ? existing.expiresAt : null;
+      if (!force && existing && (!expiresAt || expiresAt > now)) {
+        return existing;
+      }
+
+      if (!force && previewInflightRef.current.has(documentId)) {
+        return previewInflightRef.current.get(documentId);
+      }
+
+      const request = (async () => {
+        try {
+          const docResponse = await api.get(`/documents/${documentId}`);
+          const downloadPath = docResponse.data?.document?.current_version?.download_path;
+          if (!downloadPath || !resolveApiPath) {
+            throw new Error('Document missing download path');
+          }
+
+          const href = resolveApiPath(downloadPath);
+          const entry = {
+            url: href,
+            contentType: docResponse.data?.document?.current_version?.version?.content_type || null,
+            filename: docResponse.data?.document?.filename,
+            expiresAt: Date.now() + 5 * 60 * 1000,
+          };
+          setPreviewEntries((prev) => {
+            const next = new Map(prev);
+            next.set(documentId, entry);
+            return next;
+          });
+          return entry;
+        } catch (error) {
+          notifyApiError(error, 'Unable to fetch document preview.');
+          throw error;
+        } finally {
+          previewInflightRef.current.delete(documentId);
+        }
+      })();
+
+      previewInflightRef.current.set(documentId, request);
+      return request;
+    },
+    [previewEntries, api, resolveApiPath, notifyApiError, setPreviewEntries],
+  );
+
+  const ensurePreviewData = useCallback(
+    async (documentId) => {
+      if (!documentId) return null;
+
+      const findInCache = () => {
+        const pool = searchResults ?? documents;
+        return pool.find((item) => item.id === documentId) || null;
+      };
+
+      let doc = findInCache();
+
+      if (!doc) {
+        const { data } = await api.get(`/documents/${documentId}`);
+        const hydratedDetail = assetManager.hydrateDetail(data);
+        const fetched = hydratedDetail?.document || data.document || data;
+        doc = fetched ? assetManager.hydrateDocument(fetched) : null;
+        if (!doc) {
+          throw new Error('Document metadata unavailable.');
+        }
+
+        setDocuments((prev) => {
+          if (prev.some((item) => item.id === doc.id)) {
+            return prev;
+          }
+          return [doc, ...prev];
+        });
+      }
+
+      if (!previewReturnPathRef.current) {
+        const fallbackFolderId = doc?.folder_id || 'root';
+        previewReturnPathRef.current =
+          fallbackFolderId === 'root' ? '/documents' : `/documents/folder/${fallbackFolderId}`;
+      }
+
+      await ensurePreviewUrl(documentId, { force: false });
+      setActivePreviewId(documentId);
+      return doc;
+    },
+    [
+      searchResults,
+      documents,
+      assetManager,
+      setDocuments,
+      ensurePreviewUrl,
+      setActivePreviewId,
+      api,
+    ],
+  );
+
+  const openDocumentPreview = useCallback(
+    (documentId, { replace = false } = {}) => {
+      if (!documentId) return;
+      detailPanelControlRef.current.close();
+      previewReturnPathRef.current = `${locationPathname}${locationSearch}`;
+      navigate(`/documents/${documentId}`, { replace });
+    },
+    [navigate, locationPathname, locationSearch, detailPanelControlRef],
+  );
+
+  const closeDocumentPreview = useCallback(
+    (folderId = null) => {
+      const fallbackPath = previewReturnPathRef.current;
+      previewReturnPathRef.current = null;
+
+      if (fallbackPath) {
+        navigate(fallbackPath, { replace: false });
+        return;
+      }
+
+      const targetId = folderId || selectedFolder || 'root';
+      const path = targetId === 'root' ? '/documents' : `/documents/folder/${targetId}`;
+      navigate(path, { replace: false });
+    },
+    [navigate, selectedFolder],
+  );
+
+  useEffect(() => {
+    if (!routeDocumentId) {
+      return undefined;
+    }
+
+    const handleKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        closeDocumentPreview();
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [routeDocumentId, closeDocumentPreview]);
+
+  useEffect(() => {
+    if (!routeDocumentId) {
+      return undefined;
+    }
+
+    let cancelled = false;
+
+    ensurePreviewData(routeDocumentId).catch((error) => {
+      if (cancelled) {
+        return;
+      }
+      notifyApiError(error, 'Failed to open document preview.');
+      closeDocumentPreview();
+    });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [routeDocumentId, ensurePreviewData, notifyApiError, closeDocumentPreview]);
+
+  return {
+    previewEntries,
+    ensurePreviewUrl,
+    ensurePreviewData,
+    openDocumentPreview,
+    closeDocumentPreview,
+    resetPreviewState,
+    removePreviewEntries,
+  };
+};
+
+export default useDocumentPreview;