Revert "cache "Visning" og prøv å forenkle det hele"

This reverts commit 86eae8e.

Author: bdahle

xp-archive/client/content/Content.tsx

@@ -55,77 +55,88 @@ export const Content = () => {
         }
     }, [data, selectedContentId, selectedLocale, selectedVersion]);
 
-    // Calculate derived properties
-    const isWebpage = !!data?.html && !data?.json?.attachment;
-    const hasAttachment = !!data?.json?.attachment;
-
-    // State for view selector
-    const [selectedView, setSelectedView] = useState<ViewVariant | undefined>(() =>
+    const isWebpage = !!data?.html && !data.json.attachment;
+    const hasAttachment = !!data?.json.attachment;
+    const [selectedView, setSelectedView] = useState<ViewVariant | undefined>(
         getDefaultView(isWebpage, hasAttachment)
     );
 
-    // Update view when content type changes
-    useEffect(() => {
-        setSelectedView(getDefaultView(isWebpage, hasAttachment));
-    }, [isWebpage, hasAttachment, selectedContentId]);
-
-    // Single cache for content-related data
-    const [contentCache, setContentCache] = useState(() => ({
-        // Version selector
-        versions: getCachedVersionSelector(selectedContentId ?? '').versions,
-        versionComponent: getCachedVersionSelector(selectedContentId ?? '').component,
-        isVersionPanelOpen: getCachedVersionSelector(selectedContentId ?? '').isOpen,
+    const [versionSelectorCache, setVersionSelectorCache] = useState(() => {
+        const cache = getCachedVersionSelector(selectedContentId ?? '');
+        return {
+            component: cache.component,
+            versions: cache.versions,
+            isOpen: cache.isOpen,
+        };
+    });
 
-        // Display data
+    // Add this new state to cache display values
+    const [cachedDisplayData, setCachedDisplayData] = useState({
         displayName: '',
         path: '',
-    }));
+    });
 
-    // Update cache when content changes
+    // Update this useEffect to also cache display data when data loads
     useEffect(() => {
         if (prevContentIdRef.current && prevContentIdRef.current !== selectedContentId) {
             clearCachedVersionSelector(prevContentIdRef.current);
         }
 
         if (data?.versions && selectedContentId) {
-            setContentCache((prev) => ({
-                ...prev,
+            setVersionSelectorCache((prev) => ({
+                component: null,
                 versions: data.versions,
-                versionComponent: null,
-                displayName: data.json?.displayName || prev.displayName,
-                path: data.json?._path || prev.path,
+                isOpen: prev.isOpen,
             }));
+
+            // Cache display data when it's available
+            if (data.json?.displayName || data.json?._path) {
+                setCachedDisplayData({
+                    displayName: data.json.displayName || '',
+                    path: data.json._path || '',
+                });
+            }
         }
 
         prevContentIdRef.current = selectedContentId;
     }, [selectedContentId, data?.versions, data?.json]);
 
-    // Helper functions to get data with fallbacks
+    useEffect(() => {
+        setSelectedView(getDefaultView(isWebpage, hasAttachment));
+    }, [isWebpage, hasAttachment, selectedContentId]);
+
+    const htmlPath = `${xpArchiveConfig.basePath}/html/${selectedContentId}/${selectedLocale}/${
+        data?.json._versionKey
+    }`;
+
     const getVersionDisplay = () => {
-        if (selectedVersion && contentCache.versions.length > 0) {
-            const cachedVersion = contentCache.versions.find(
+        // First check if we have the version in our cache
+        if (selectedVersion && versionSelectorCache.versions.length > 0) {
+            const cachedVersion = versionSelectorCache.versions.find(
                 (v) => v.versionId === selectedVersion
             );
             if (cachedVersion?.timestamp) {
                 return formatTimestamp(cachedVersion.timestamp);
             }
         }
 
+        // Fall back to data if cache doesn't have it
         if (selectedVersion && data?.versions) {
             return formatTimestamp(
                 data.versions.find((v) => v.versionId === selectedVersion)?.timestamp ?? ''
             );
         }
-
         return 'Laster...';
     };
 
-    const getDisplayName = () => data?.json?.displayName || contentCache.displayName || 'Laster...';
-    const getPath = () => data?.json?._path || contentCache.path || '';
+    // Add helper functions to get title and URL with fallbacks
+    const getDisplayName = () => {
+        return data?.json.displayName || cachedDisplayData.displayName || 'Laster...';
+    };
 
-    const htmlPath = `${xpArchiveConfig.basePath}/html/${selectedContentId}/${selectedLocale}/${
-        data?.json._versionKey
-    }`;
+    const getPath = () => {
+        return data?.json._path || cachedDisplayData.path || '';
+    };
 
     if (!selectedContentId) {
         return <EmptyState />;
@@ -143,45 +154,40 @@ export const Content = () => {
                             icon={<SidebarRightIcon />}
                             iconPosition={'right'}
                             onClick={() => {
-                                setContentCache((prev) => ({
+                                setVersionSelectorCache((prev) => ({
                                     ...prev,
-                                    isVersionPanelOpen: true,
+                                    isOpen: true,
                                 }));
                             }}
                         >
                             {getVersionDisplay()}
                         </Button>
 
-                        {contentCache.versionComponent ? (
-                            contentCache.versionComponent
+                        {versionSelectorCache.component ? (
+                            versionSelectorCache.component
                         ) : (
                             <VersionSelector
                                 versions={
-                                    contentCache.versions.length > 0
-                                        ? contentCache.versions
+                                    versionSelectorCache.versions.length > 0
+                                        ? versionSelectorCache.versions
                                         : data?.versions || []
                                 }
-                                isOpen={contentCache.isVersionPanelOpen}
+                                isOpen={versionSelectorCache.isOpen}
                                 onClose={() => {
-                                    setContentCache((prev) => ({
+                                    setVersionSelectorCache((prev) => ({
                                         ...prev,
-                                        isVersionPanelOpen: false,
+                                        isOpen: false,
                                     }));
                                 }}
                                 onMount={(component) => {
                                     setCachedVersionSelector(
                                         selectedContentId ?? '',
                                         component,
-                                        contentCache.versions.length > 0
-                                            ? contentCache.versions
+                                        versionSelectorCache.versions.length > 0
+                                            ? versionSelectorCache.versions
                                             : data?.versions || [],
-                                        contentCache.isVersionPanelOpen
+                                        versionSelectorCache.isOpen
                                     );
-
-                                    setContentCache((prev) => ({
-                                        ...prev,
-                                        versionComponent: component,
-                                    }));
                                 }}
                             />
                         )}