@parhelia/core 0.1.12909 → 0.1.12911

package/dist/editor/client/EditorShell.js

@@ -22,6 +22,7 @@ import "react-json-view-lite/dist/index.css";
 import { MediaSelector, } from "../media-selector/MediaSelector";
 import { getComponentCommands } from "../commands/componentCommands";
 import { getLanguagesAndVersions, } from "../services/contentService";
+import { getEditorSettings } from "../services/systemService";
 import { getAllFavorites } from "../services/favouritesService";
 import ConfirmationDialog from "../ConfirmationDialog";
 import { getItemDescriptor } from "../utils";
@@ -67,12 +68,37 @@ import { useGlobalEditorKeyDown } from "./hooks/useGlobalEditorKeyDown";
 import { useStartupChecks } from "../settings/status/index";
 import { EditorLoadingOverlay } from "../EditorLoadingOverlay";
 import { FeatureGate, LicenseFeatures, LicenseProvider, LicenseOverlay, } from "../../licensing";
+const GLOBAL_SESSION_HISTORY_LIMIT = 200;
+const GLOBAL_HISTORY_LIMIT = 200;
+const GLOBAL_SESSION_HISTORY_LOAD_MORE_INCREMENT = 50;
+const GLOBAL_HISTORY_LOAD_MORE_INCREMENT = 100;
+function getInitialGlobalHistoryLimit(filterBySession) {
+    return filterBySession ? GLOBAL_SESSION_HISTORY_LIMIT : GLOBAL_HISTORY_LIMIT;
+}
+function getGlobalHistoryLoadMoreIncrement(filterBySession) {
+    return filterBySession
+        ? GLOBAL_SESSION_HISTORY_LOAD_MORE_INCREMENT
+        : GLOBAL_HISTORY_LOAD_MORE_INCREMENT;
+}
 // Sentinel written to the `sidebar` URL param when the user has explicitly closed
 // every sidebar. Distinguishes "no preference yet" (param absent) from "user wants
 // nothing open" (param present with this value) so reload can honor the user's intent.
 const SIDEBAR_NONE_SENTINEL = "none";
+const PARHELIA_SETTINGS_ITEM_ID = "a2f3c168bb2841ff9673ee7f3cc624af";
+const PARHELIA_SETTINGS_ITEM_PATH = "/sitecore/system/parhelia/settings";
+const PARHELIA_SHOW_MINIMAP_FIELD_ID = "e75976d2179e4578b4140147b7525fa5";
 const sidebarUrlValue = (ids) => ids.length ? ids.join(",") : SIDEBAR_NONE_SENTINEL;
 // moved to hooks/useQuota
+function isParheliaSettingsSnapshotChange(changes) {
+    return changes.some((change) => {
+        const changedItemId = cleanId(change.item?.id);
+        const changedItemPath = change.item?.path?.toLowerCase();
+        const changedFieldIds = change.changes.fields?.map((fieldId) => cleanId(fieldId));
+        return (changedItemId === PARHELIA_SETTINGS_ITEM_ID ||
+            changedItemPath === PARHELIA_SETTINGS_ITEM_PATH ||
+            changedFieldIds?.includes(PARHELIA_SHOW_MINIMAP_FIELD_ID));
+    });
+}
 function getInitialOpenSidebars(configuration, workspaceId) {
     const workspace = configuration.editor.workspaces?.find((candidate) => candidate.id === workspaceId);
     if (workspace?.supportsSidebars && workspace.defaultSidebars?.length) {
@@ -143,6 +169,10 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const router = useRouter();
     const pathname = usePathname();
     const searchParams = useSearchParams();
+    const [effectiveParheliaSettings, setEffectiveParheliaSettings] = useState(parheliaSettings);
+    const [effectiveParheliaSettingsLoaded, setEffectiveParheliaSettingsLoaded] = useState(parheliaSettingsLoaded === true);
+    const parheliaSettingsRefreshInFlightRef = useRef(null);
+    const minimapEnabledInSettings = effectiveParheliaSettings?.showMinimap !== false;
     const [selection, setSelection] = useState([]);
     const [contentTreeSelection, setContentTreeSelection] = useState([]);
     const [selectedForInsertion, setSelectedForInsertion] = useState("");
@@ -159,6 +189,34 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const confirmationDialogRef = useRef(null);
     const contextMenuRef = useRef(null);
     const editContextRef = useRef(undefined);
+    useEffect(() => {
+        setEffectiveParheliaSettings(parheliaSettings);
+        setEffectiveParheliaSettingsLoaded(parheliaSettingsLoaded === true);
+    }, [parheliaSettings, parheliaSettingsLoaded]);
+    const refreshParheliaSettings = useCallback(async () => {
+        if (parheliaSettingsRefreshInFlightRef.current) {
+            return parheliaSettingsRefreshInFlightRef.current;
+        }
+        const refresh = getEditorSettings()
+            .then((result) => {
+            if (result.type === "success" && result.data) {
+                setEffectiveParheliaSettings(result.data);
+                setEffectiveParheliaSettingsLoaded(true);
+                return;
+            }
+            console.warn("Failed to refresh Parhelia settings:", result.summary || result.details);
+        })
+            .catch((error) => {
+            console.error("Failed to refresh Parhelia settings:", error);
+        });
+        parheliaSettingsRefreshInFlightRef.current = refresh;
+        void refresh.finally(() => {
+            if (parheliaSettingsRefreshInFlightRef.current === refresh) {
+                parheliaSettingsRefreshInFlightRef.current = null;
+            }
+        });
+        return refresh;
+    }, []);
     const [currentOverlay, setCurrentOverlay] = useState();
     const [contextMenuSource, setContextMenuSource] = useState();
     const [item, setItem] = useState();
@@ -192,6 +250,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [showOnlyMyChanges, setShowOnlyMyChanges] = useState(true);
     const [filterByCurrentLanguage, setFilterByCurrentLanguage] = useState(true);
     const [historySearchQuery, setHistorySearchQuery] = useState("");
+    const [isHistoryLoading, setIsHistoryLoading] = useState(false);
+    const [isHistoryLoadingMore, setIsHistoryLoadingMore] = useState(false);
+    const [canLoadMoreHistory, setCanLoadMoreHistory] = useState(false);
+    const [globalHistoryLimit, setGlobalHistoryLimit] = useState(GLOBAL_SESSION_HISTORY_LIMIT);
+    const historyLoadingRequestCountRef = useRef(0);
+    const historyLoadingMoreRequestCountRef = useRef(0);
     const [recentEdits, setRecentEdits] = useState([]);
     const addRecentEdit = useCallback((edit) => {
         setRecentEdits((prevEditedFields) => {
@@ -696,6 +760,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [editorFormHintVisible, setEditorFormHintVisible] = useState(false);
     const editorFormToggleButtonRef = useRef(null);
     const [showMinimap, setShowMinimap] = useState(userPreferences.showMinimap ?? true);
+    const effectiveShowMinimap = minimapEnabledInSettings && showMinimap;
     const [showHelpTerminal, setShowHelpTerminal] = useState(false);
     const [helpTerminalInitialPrompt, setHelpTerminalInitialPrompt] = useState(undefined);
     const [helpTerminalProfileName, setHelpTerminalProfileName] = useState(undefined);
@@ -803,13 +868,29 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [currentPageItem, setCurrentPageItem] = useState();
     // Create itemsRepository with current page item (will be updated when page loads)
     const itemsRepository = useItemsRepository(addRecentEdit, currentPageItem, getFieldModificationStores);
+    // The fallback is a null-object: it backs activePageViewContext only when no slot
+    // context is registered (the startup gap, or all slots closed). Its *resolved page* is
+    // rendered on screen ONLY by the fullscreen branch (the <PageViewerFrame> in the
+    // `fullscreen ? (...)` render); in non-fullscreen the visible iframe comes from the
+    // slot's own primaryPageViewContext. So only feed it a descriptor when it is actually
+    // the render source — otherwise it pointlessly re-resolves the page the slot already
+    // resolves, producing a duplicate /parhelia/resolve at startup.
+    const hasActiveSlotContext = !!(activeSlotId && slotContexts.get(activeSlotId));
     const fallbackPageViewContext = usePageViewContext({
-        pageItemDescriptor: currentItemDescriptor,
+        pageItemDescriptor: fullscreen && !hasActiveSlotContext ? currentItemDescriptor : undefined,
         itemsRepository,
         configuration,
-        parheliaSettings,
+        parheliaSettings: effectiveParheliaSettings,
         layoutMode,
     });
+    useEffect(() => {
+        return itemsRepository.subscribeItemsChanged((changes) => {
+            const persistedChanges = changes.filter((change) => change.source !== "local-field-update");
+            if (isParheliaSettingsSnapshotChange(persistedChanges)) {
+                void refreshParheliaSettings();
+            }
+        });
+    }, [itemsRepository, refreshParheliaSettings]);
     const registerSlotContext = useCallback((slotId, ctx) => {
         setSlotContexts((prev) => {
             if (prev.get(slotId) === ctx)
@@ -1929,6 +2010,34 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         }
         return [];
     }, []);
+    const getEditHistoryWithLoading = useCallback(async (options, loadingMode = "initial") => {
+        const loadingMore = loadingMode === "more";
+        if (loadingMore) {
+            historyLoadingMoreRequestCountRef.current += 1;
+            setIsHistoryLoadingMore(true);
+        }
+        else {
+            historyLoadingRequestCountRef.current += 1;
+            setIsHistoryLoading(true);
+        }
+        try {
+            return await getEditHistory(options);
+        }
+        finally {
+            if (loadingMore) {
+                historyLoadingMoreRequestCountRef.current = Math.max(0, historyLoadingMoreRequestCountRef.current - 1);
+                if (historyLoadingMoreRequestCountRef.current === 0) {
+                    setIsHistoryLoadingMore(false);
+                }
+            }
+            else {
+                historyLoadingRequestCountRef.current = Math.max(0, historyLoadingRequestCountRef.current - 1);
+                if (historyLoadingRequestCountRef.current === 0) {
+                    setIsHistoryLoading(false);
+                }
+            }
+        }
+    }, []);
     useEffect(() => {
         // Read fresh page from the mutable slot context ref chain.
         // The slot context uses a stable ref that is mutated in-place (see editorSlotContext.ts),
@@ -1949,11 +2058,19 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const loadHistory = useDebouncedCallback(async () => {
         if (!sessionId)
             return;
-        const result = await getEditHistory({ sessionId });
+        const requestedLimit = GLOBAL_SESSION_HISTORY_LIMIT;
+        const result = await getEditHistoryWithLoading({
+            sessionId,
+            limit: requestedLimit + 1,
+        });
         if (handleErrorResult(result, ui, state))
             return;
+        const nextOperations = normalizeEditHistoryPayload(result.data);
+        const limitedOperations = nextOperations.slice(0, requestedLimit);
+        setGlobalHistoryLimit(requestedLimit);
+        setCanLoadMoreHistory(nextOperations.length > requestedLimit);
         setEditHistory((prev) => {
-            const next = normalizeEditHistoryPayload(result.data);
+            const next = limitedOperations;
             if (!prev.length)
                 return sortEditHistoryByDateDesc(next);
             if (!next.length)
@@ -2004,7 +2121,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             return sortEditHistoryByDateDesc(merged);
         });
     }, 600);
-    const refreshHistory = useCallback(async (mode, filterBySession, filterByLanguage) => {
+    const refreshHistory = useCallback(async (mode, filterBySession, filterByLanguage, historyLimitOverride, loadingMode = "initial") => {
         const currentMode = mode || historyMode;
         // Use showOnlyMyChanges state if filterBySession not explicitly provided
         const shouldFilterBySession = filterBySession !== undefined ? filterBySession : showOnlyMyChanges;
@@ -2045,14 +2162,16 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         if (currentMode === "global") {
             // Global mode: optionally filter by session and/or language
             const currentLanguage = item?.descriptor?.language || currentItemDescriptor?.language;
-            const result = await getEditHistory({
+            const requestedLimit = historyLimitOverride ??
+                getInitialGlobalHistoryLimit(shouldFilterBySession);
+            const result = await getEditHistoryWithLoading({
                 sessionId: shouldFilterBySession ? sessionId : undefined,
-                limit: shouldFilterBySession ? 100 : 500,
+                limit: requestedLimit + 1,
                 language: shouldFilterByLanguage && currentLanguage
                     ? currentLanguage
                     : undefined,
                 query: historyQuery,
-            });
+            }, loadingMode);
             if (handleErrorResult(result, ui, state)) {
                 console.error("[EditorShell] Failed to load history:", result);
                 return;
@@ -2060,8 +2179,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             if (isStaleHistoryResponse()) {
                 return;
             }
+            const nextOperations = normalizeEditHistoryPayload(result.data);
+            const limitedOperations = nextOperations.slice(0, requestedLimit);
+            setGlobalHistoryLimit(requestedLimit);
+            setCanLoadMoreHistory(nextOperations.length > requestedLimit);
             setEditHistory((prev) => {
-                const next = normalizeEditHistoryPayload(result.data);
+                const next = limitedOperations;
                 const scope = {
                     mode: currentMode,
                     filterBySession: shouldFilterBySession,
@@ -2130,19 +2253,24 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             if (!currentItem) {
                 console.warn(`[EditorShell] Cannot load ${currentMode} history: no item loaded`);
                 setEditHistory([]);
+                setCanLoadMoreHistory(false);
                 return;
             }
             // For page-centric/timeline: fetch all versions (itemId + language only)
             // For current-version: fetch specific version (itemId + language + version)
             const itemFilter = currentMode === "page-centric" || currentMode === "timeline"
-                ? { id: currentItem.id, language: currentItem.language, version: 0 } // version 0 signals "all versions" to backend
+                ? {
+                    id: currentItem.id,
+                    language: currentItem.language,
+                    version: 0,
+                } // version 0 signals "all versions" to backend
                 : currentItem;
             // Request item-scoped history, optionally filtered by session
-            const result = await getEditHistory({
+            const result = await getEditHistoryWithLoading({
                 item: itemFilter,
                 sessionId: shouldFilterBySession ? sessionId : undefined,
                 query: historyQuery,
-            });
+            }, loadingMode);
             if (handleErrorResult(result, ui, state)) {
                 console.error("[EditorShell] Failed to load item history:", result);
                 return;
@@ -2150,6 +2278,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             if (isStaleHistoryResponse()) {
                 return;
             }
+            setCanLoadMoreHistory(false);
             let operations = normalizeEditHistoryPayload(result.data);
             // Client-side version filtering for current-version mode
             if (currentMode === "current-version") {
@@ -2232,10 +2361,26 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         historySearchQuery,
         item,
         currentItemDescriptor,
+        getEditHistoryWithLoading,
         matchesHistoryScope,
         normalizeEditHistoryPayload,
         sortEditHistoryByDateDesc,
     ]);
+    const loadMoreHistory = useCallback(async () => {
+        if (historyMode !== "global" || isHistoryLoading || isHistoryLoadingMore) {
+            return;
+        }
+        const nextLimit = globalHistoryLimit + getGlobalHistoryLoadMoreIncrement(showOnlyMyChanges);
+        await refreshHistory("global", showOnlyMyChanges, filterByCurrentLanguage, nextLimit, "more");
+    }, [
+        filterByCurrentLanguage,
+        globalHistoryLimit,
+        historyMode,
+        isHistoryLoading,
+        isHistoryLoadingMore,
+        refreshHistory,
+        showOnlyMyChanges,
+    ]);
     // Debounced history refresh to avoid hammering `/parhelia/editHistory` on rapid UI changes.
     const debouncedRefreshHistory = useDebouncedCallback((mode) => {
         void refreshHistory(mode);
@@ -2289,11 +2434,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         // from being displayed while the new data is loading
         if (prevHistoryModeRef.current !== historyMode) {
             setEditHistory([]);
+            setCanLoadMoreHistory(false);
             prevHistoryModeRef.current = historyMode;
         }
         // Cancel any in-flight scheduled refresh before deciding what to do next.
         debouncedRefreshHistoryRef.current.cancel();
         if (historyMode === "global" && sessionId) {
+            setGlobalHistoryLimit(getInitialGlobalHistoryLimit(showOnlyMyChanges));
+            setCanLoadMoreHistory(false);
             // Use refreshHistory for immediate load on first initialization; debounce thereafter.
             if (!historyInitialLoadDoneRef.current) {
                 historyInitialLoadDoneRef.current = true;
@@ -2304,6 +2452,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
         }
         else if (historyMode !== "global" && currentItemDescriptor) {
+            setCanLoadMoreHistory(false);
             // Always load immediately for page-centric/current-version/timeline so we don't show
             // an empty history list for the debounce window (e.g. 600ms). The effect only runs on
             // mode or item id/lang/version change, not on every keystroke, so this avoids flaky
@@ -2316,6 +2465,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         else if (historyMode !== "global" && !currentItemDescriptor) {
             // Clear history if no item loaded in page-centric modes
             setEditHistory([]);
+            setCanLoadMoreHistory(false);
         }
         // Note: refreshHistory and debouncedRefreshHistory are accessed via refs to avoid
         // re-running this effect when contentEditorItem changes (which would happen on every keystroke).
@@ -3150,9 +3300,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         requestQuota: requestQuotaAndUpdate,
         sendClientInfo,
         setSocketDiagnostics,
-        enableWebSocketTransport: parheliaSettings?.enableWebSocketTransport ?? true,
-        enableSseFallback: parheliaSettings?.enableSseFallback ?? true,
-        transportSettingsReady: parheliaSettingsLoaded === true,
+        enableWebSocketTransport: effectiveParheliaSettings?.enableWebSocketTransport ?? true,
+        enableSseFallback: effectiveParheliaSettings?.enableSseFallback ?? true,
+        transportSettingsReady: effectiveParheliaSettingsLoaded === true,
     });
     useEffect(() => {
         const hasMySession = activeSessions.some((s) => s.sessionId === sessionId);
@@ -4692,6 +4842,10 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setHistorySearchQuery,
         refreshHistory,
         isRefreshing,
+        isHistoryLoading,
+        canLoadMoreHistory,
+        isHistoryLoadingMore,
+        loadMoreHistory,
         activeSessions,
         remoteCarets,
         unlockField: async () => {
@@ -4950,7 +5104,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         showEditorFormHint,
         dismissEditorFormHint,
         editorFormToggleButtonRef,
-        showMinimap,
+        showMinimap: effectiveShowMinimap,
         setShowMinimap: handleSetShowMinimap,
         showHelpTerminal,
         setShowHelpTerminal: handleSetShowHelpTerminal,
@@ -4979,7 +5133,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         webSocketMessages,
         clearWebSocketMessages: () => setWebSocketMessages([]),
         userInfo: userInfo,
-        parheliaSettings,
+        parheliaSettings: effectiveParheliaSettings,
         setUserPreferences,
         currentWizardId,
         setCurrentWizardId,
@@ -5094,9 +5248,13 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         showResolvedComments,
         reviews,
         userInfo,
-        parheliaSettings,
+        effectiveParheliaSettings,
         setUserPreferences,
         isRefreshing,
+        isHistoryLoading,
+        canLoadMoreHistory,
+        isHistoryLoadingMore,
+        loadMoreHistory,
         favorites,
         loadFavorites,
         refreshFavorites,
@@ -5143,7 +5301,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         showEditorFormHint,
         dismissEditorFormHint,
         editorFormToggleButtonRef,
-        showMinimap,
+        effectiveShowMinimap,
         handleSetShowMinimap,
         showHelpTerminal,
         toggleHelpTerminal,