fix(layout): persist Browser and Comments panel toggles (#1940)

* fix(layout): persist Browser and Comments panel toggles

The Settings -> Layout toggles for the Browser and Comments right panels
acted only on the live right-panel registry. Nothing was written to
`desktopSettings.layout`, and both registration hooks unconditionally
opened their panel on mount, so every launch reopened a panel the user
had turned off. Startup mode made no difference: reopening the last
project restores layers and the camera, never these panels.

Both panels now have a persisted `layout.browserPanelVisible` /
`layout.commentsPanelVisible` setting (defaulting to on, so settings
saved before the keys existed keep today's behavior), the registration
hooks seed from it, and the Settings toggles write it. The toggles apply
live rather than on Save, so they patch the dialog draft as well; the
draft is snapshotted when the dialog opens and Save writes it wholesale,
which would otherwise revert the toggle the user just made. Reset moves
the panels too, since those two rows render the live registry state.

Fixes #1935

* fix(layout): give the panel rows the dialog's draft semantics

Review follow-up. The Browser/Comments rows in the Layout dialog applied
live while the other four rows waited for Save, which left two seams:
Reset followed by Cancel stuck those two flags while reverting the rest,
and the rows rendered live registry state that Save did not write, so
closing a panel from its own header showed an unchecked box the dialog
then saved back as visible.

Both rows are now draft-backed like their neighbours. The draft seeds
them from the live registry when the dialog opens, so a panel closed
from its header still shows unchecked and Save persists exactly what was
displayed; Reset and Cancel behave as they do for every other row. Save
applies the committed values to the registry, skipping panels already in
the requested state so saving an untouched dialog cannot collapse an
expanded panel. The Settings dropdown keeps applying on the spot and
persisting in one step, since it has no Save to wait for.

* fix(layout): mirror panel visibility instead of persisting it on Save

Review follow-up. Seeding the dialog draft from the live registry fixed
the checkbox lying about what Save would write, but it moved the seam
rather than closing it: a panel closed from its own header stayed a
session-only state that an unrelated Save then converted into a
permanent preference.

Both directions now go through one place. `registerPersistedRightPanel`
seeds the panel from its setting at registration and subscribes to the
registry afterwards, writing every later visibility change back. For
these panels closing is not a transient collapse, it removes the rail
entry entirely and only Settings can restore it, so it is a preference
however it was reached. With the setting and the registry always in
step, the checkbox cannot disagree with either, and there is no
session-only state left for a Save to silently promote.

Two registry events are deliberately not mirrored: the emit from
registration (the panel is legitimately not visible yet, so the
subscription is attached after the seed) and the emit from unregistering
on unmount, which would otherwise persist false on every teardown. Being
displaced by another panel is not a close, so it writes nothing.

The dialog rows keep the draft semantics of the previous commit, and
Save re-applies them to the registry, skipping a panel already in the
requested state. `tests/persisted-right-panel.test.ts` covers the seed,
the header close, the collapse and displacement non-events, and the
teardown guard; the module imports the registry subpath so it stays a
leaf the suite can load without the plugin barrel.

Author: giswqs

apps/geolibre-desktop/src/components/layout/SettingsDialog.tsx

@@ -11,7 +11,6 @@ import {
   type ProjectPreferences,
   type RuntimeEnvironmentVariable,
 } from "@geolibre/core";
-import { closeRightPanel, collapseRightPanel, openRightPanel } from "@geolibre/plugins";
 import {
   Button,
   Dialog,
@@ -91,6 +90,7 @@ import { COMMENTS_PANEL_ID } from "../../hooks/useRegisterCommentsPanel";
 import { useRightPanelState } from "../../hooks/useRightPanels";
 import type { ThemeMode } from "../../hooks/useThemeMode";
 import { isTauri } from "../../lib/is-tauri";
+import { applyRightPanelVisibility } from "../../lib/persisted-right-panel";
 import { COORDINATE_FORMATS, normalizeCoordinateFormat } from "../../lib/coordinate-format";
 import { THEME_SCHEMES, normalizeHexColor, type ThemeScheme } from "../../lib/theme-schemes";
 import { IS_MAS_BUILD } from "../../lib/build-flags";
@@ -417,33 +417,17 @@ export function SettingsDialog({
   const showSettingsItem = (id: string) => isMenuItemVisible(desktopSettings.uiProfile, id);
   const [open, setOpen] = useState(false);
   const [section, setSection] = useState<SettingsSection>("map");
-  // The Browser is a dockable right panel (open/close via the registry), not a
-  // persisted layout preference, so its Layout toggle acts on the live registry
-  // state directly rather than through the draft settings.
+  // Browser and Comments are dockable right panels: the registry owns whether
+  // they are on screen and `registerPersistedRightPanel` mirrors that into
+  // `layout.browserPanelVisible` / `layout.commentsPanelVisible`, so the toggle
+  // no longer resets on every launch (#1935). Because the mirror is the single
+  // writer, moving the panel is all these controls have to do: the setting
+  // follows, so the two can never disagree about what the checkbox should say.
   const rightPanelState = useRightPanelState();
   const browserPanelOpen = rightPanelState.visibleIds.includes(BROWSER_PANEL_ID);
   const commentsPanelOpen = rightPanelState.visibleIds.includes(COMMENTS_PANEL_ID);
-  // Show it collapsed on the shared Layers rail, matching its default state, so
-  // re-enabling from Settings doesn't jump to an expanded panel that buries the
-  // Layers panel.
-  const toggleBrowserPanel = (show: boolean) => {
-    if (show) {
-      openRightPanel(BROWSER_PANEL_ID);
-      collapseRightPanel(BROWSER_PANEL_ID);
-    } else {
-      closeRightPanel(BROWSER_PANEL_ID);
-    }
-  };
-  // Collapsed for the same reason as Browser above, and to match the state
-  // Comments registers itself in on mount.
-  const toggleCommentsPanel = (show: boolean) => {
-    if (show) {
-      openRightPanel(COMMENTS_PANEL_ID);
-      collapseRightPanel(COMMENTS_PANEL_ID);
-    } else {
-      closeRightPanel(COMMENTS_PANEL_ID);
-    }
-  };
+  const toggleBrowserPanel = (show: boolean) => applyRightPanelVisibility(BROWSER_PANEL_ID, show);
+  const toggleCommentsPanel = (show: boolean) => applyRightPanelVisibility(COMMENTS_PANEL_ID, show);
   // A field a deep-link asked us to focus once its section renders; cleared
   // after the focus lands so a later open without a focus request stays put.
   const [pendingFocus, setPendingFocus] = useState<SettingsFocusTarget | null>(null);
@@ -1205,6 +1189,12 @@ export function SettingsDialog({
       updates: draftDesktopSettings.updates,
       startup: draftDesktopSettings.startup,
     });
+    // The dockable panels are the one layout row nothing renders from the store:
+    // the registry owns what is on screen, so move it to match what was just
+    // saved (a no-op for a panel already there, so an untouched Save cannot
+    // collapse one the user had expanded).
+    applyRightPanelVisibility(BROWSER_PANEL_ID, draftDesktopSettings.layout.browserPanelVisible);
+    applyRightPanelVisibility(COMMENTS_PANEL_ID, draftDesktopSettings.layout.commentsPanelVisible);
     setOpen(false);
   };
 
@@ -1827,8 +1817,12 @@ export function SettingsDialog({
                       <input
                         className="h-4 w-4"
                         type="checkbox"
-                        checked={browserPanelOpen}
-                        onChange={(event) => toggleBrowserPanel(event.target.checked)}
+                        checked={draftDesktopSettings.layout.browserPanelVisible}
+                        onChange={(event) =>
+                          updateDraftLayoutSettings({
+                            browserPanelVisible: event.target.checked,
+                          })
+                        }
                       />
                       <FolderTree className="h-4 w-4 text-muted-foreground" />
                       <span>{t("settings.layout.showBrowserPanel")}</span>
@@ -1837,8 +1831,12 @@ export function SettingsDialog({
                       <input
                         className="h-4 w-4"
                         type="checkbox"
-                        checked={commentsPanelOpen}
-                        onChange={(event) => toggleCommentsPanel(event.target.checked)}
+                        checked={draftDesktopSettings.layout.commentsPanelVisible}
+                        onChange={(event) =>
+                          updateDraftLayoutSettings({
+                            commentsPanelVisible: event.target.checked,
+                          })
+                        }
                       />
                       <MessageSquare className="h-4 w-4 text-muted-foreground" />
                       <span>{t("settings.layout.showCommentsPanel")}</span>

apps/geolibre-desktop/src/hooks/useDesktopSettings.ts

@@ -110,6 +110,17 @@ export interface UpdateSettings {
 }
 
 export interface DesktopLayoutSettings {
+  /**
+   * Whether the Browser (Data Source Manager) right panel is registered as
+   * visible. Unlike {@link layerPanelVisible} this does not describe a fixed
+   * dock slot: the Browser is a dockable right panel, so the flag is the
+   * persisted seed its registration hook applies on mount (open + collapsed onto
+   * its rail, or closed). Without it the panel reopened on every launch no
+   * matter what the Settings toggle said (#1935).
+   */
+  browserPanelVisible: boolean;
+  /** Same as {@link browserPanelVisible}, for the Comments right panel. */
+  commentsPanelVisible: boolean;
   layerPanelVisible: boolean;
   showProjectInfo: boolean;
   stylePanelVisible: boolean;
@@ -157,6 +168,8 @@ interface DesktopSettingsState {
 }
 
 export const DEFAULT_DESKTOP_LAYOUT_SETTINGS: DesktopLayoutSettings = {
+  browserPanelVisible: true,
+  commentsPanelVisible: true,
   layerPanelVisible: true,
   showProjectInfo: true,
   stylePanelVisible: true,
@@ -410,6 +423,14 @@ function normalizeDesktopLayoutSettings(layout: unknown): DesktopLayoutSettings
   // cannot smuggle non-boolean values into the layout settings.
   const candidate = layout as Partial<DesktopLayoutSettings>;
   return {
+    browserPanelVisible:
+      typeof candidate.browserPanelVisible === "boolean"
+        ? candidate.browserPanelVisible
+        : DEFAULT_DESKTOP_LAYOUT_SETTINGS.browserPanelVisible,
+    commentsPanelVisible:
+      typeof candidate.commentsPanelVisible === "boolean"
+        ? candidate.commentsPanelVisible
+        : DEFAULT_DESKTOP_LAYOUT_SETTINGS.commentsPanelVisible,
     layerPanelVisible:
       typeof candidate.layerPanelVisible === "boolean"
         ? candidate.layerPanelVisible

apps/geolibre-desktop/src/hooks/useRegisterBrowserPanel.ts

@@ -1,6 +1,6 @@
-import { collapseRightPanel, openRightPanel, registerRightPanel } from "@geolibre/plugins";
 import { useEffect } from "react";
 import i18n from "../i18n";
+import { registerPersistedRightPanel } from "../lib/persisted-right-panel";
 
 /** Stable id of the Browser (Data Source Manager) right panel. */
 export const BROWSER_PANEL_ID = "browser";
@@ -24,23 +24,26 @@ export const BROWSER_PANEL_ID = "browser";
  * The panel is **on by default but collapsed** onto the shared Layers rail: on
  * mount it is opened and immediately collapsed, so it shows as a rail entry
  * beside Layers rather than covering the map. The user expands it from that
- * rail (or toggles it off in Settings → Layout). It reopens collapsed on the
- * next load, matching the "on by default" behavior of the Layout toggle.
+ * rail (or toggles it off in Settings → Layout). "By default" means the default
+ * of the persisted `layout.browserPanelVisible` setting, which
+ * {@link registerPersistedRightPanel} seeds from and then keeps in step with the
+ * panel: turning it off stays off across restarts instead of the toggle silently
+ * resetting on every launch (#1935).
  */
 export function useRegisterBrowserPanel(): void {
-  useEffect(() => {
-    // i18n.t (not the useTranslation hook) so registration carries no
-    // render-time dependency; the body still localizes live via useTranslation.
-    const dispose = registerRightPanel({
-      id: BROWSER_PANEL_ID,
-      title: () => i18n.t("browser.title"),
-      dock: "replace-layers",
-      render: () => {},
-    });
-    // Default on, but docked collapsed to the Layers rail (open then collapse),
-    // so it is present without burying the map on first load.
-    openRightPanel(BROWSER_PANEL_ID);
-    collapseRightPanel(BROWSER_PANEL_ID);
-    return dispose;
-  }, []);
+  useEffect(
+    () =>
+      registerPersistedRightPanel(
+        {
+          id: BROWSER_PANEL_ID,
+          // i18n.t (not the useTranslation hook) so registration carries no
+          // render-time dependency; the body localizes live via useTranslation.
+          title: () => i18n.t("browser.title"),
+          dock: "replace-layers",
+          render: () => {},
+        },
+        "browserPanelVisible",
+      ),
+    [],
+  );
 }

apps/geolibre-desktop/src/hooks/useRegisterCommentsPanel.ts

@@ -1,6 +1,6 @@
-import { collapseRightPanel, openRightPanel, registerRightPanel } from "@geolibre/plugins";
 import { useEffect } from "react";
 import i18n from "../i18n";
+import { registerPersistedRightPanel } from "../lib/persisted-right-panel";
 
 /** Stable id of the Comments right panel. */
 export const COMMENTS_PANEL_ID = "comments";
@@ -10,20 +10,26 @@ export const COMMENTS_PANEL_ID = "comments";
  * sidebar's rail (`replace-style`).
  *
  * Comments is enabled by default but collapsed onto the Style rail, so it is
- * discoverable without taking map space.
+ * discoverable without taking map space. "By default" means the default of the
+ * persisted `layout.commentsPanelVisible` setting, which
+ * {@link registerPersistedRightPanel} seeds from and then keeps in step with the
+ * panel: turning it off stays off across restarts instead of the toggle silently
+ * resetting on every launch (#1935).
  */
 export function useRegisterCommentsPanel(): void {
-  useEffect(() => {
-    // i18n.t (not the useTranslation hook) so registration carries no
-    // render-time dependency; the rail entry re-resolves the getter on render.
-    const dispose = registerRightPanel({
-      id: COMMENTS_PANEL_ID,
-      title: () => i18n.t("comments.title"),
-      dock: "replace-style",
-      render: () => {},
-    });
-    openRightPanel(COMMENTS_PANEL_ID);
-    collapseRightPanel(COMMENTS_PANEL_ID);
-    return dispose;
-  }, []);
+  useEffect(
+    () =>
+      registerPersistedRightPanel(
+        {
+          id: COMMENTS_PANEL_ID,
+          // i18n.t (not the useTranslation hook) so registration carries no
+          // render-time dependency; the rail entry re-resolves it on render.
+          title: () => i18n.t("comments.title"),
+          dock: "replace-style",
+          render: () => {},
+        },
+        "commentsPanelVisible",
+      ),
+    [],
+  );
 }

apps/geolibre-desktop/src/lib/persisted-right-panel.ts

@@ -0,0 +1,98 @@
+// The registry subpath rather than the package barrel: this module is a leaf the
+// test suite imports directly, and the barrel pulls in the whole built-in plugin
+// registry (including CSS imports Node cannot load). See CLAUDE.md on testing
+// against a leaf module.
+import {
+  collapseRightPanel,
+  closeRightPanel,
+  getRightPanel,
+  isRightPanelVisible,
+  openRightPanel,
+  registerRightPanel,
+  subscribeRightPanels,
+} from "@geolibre/plugins/right-panel-registry";
+import type { GeoLibreRightPanelRegistration } from "@geolibre/plugins";
+import { useDesktopSettingsStore, type DesktopLayoutSettings } from "../hooks/useDesktopSettings";
+
+/**
+ * Layout settings that persist a dockable right panel's visibility. The Browser
+ * and Comments panels are the two built-in panels that work this way; plugin
+ * panels are owned by their plugin and are not persisted here.
+ */
+export type PersistedPanelKey = Extract<
+  keyof DesktopLayoutSettings,
+  "browserPanelVisible" | "commentsPanelVisible"
+>;
+
+/** Read a panel's persisted visibility, bypassing React so callers can seed. */
+export function isPanelVisibleInSettings(key: PersistedPanelKey): boolean {
+  return useDesktopSettingsStore.getState().desktopSettings.layout[key];
+}
+
+/** Persist a panel's visibility. A no-op when the value already matches. */
+export function setPanelVisibleInSettings(key: PersistedPanelKey, visible: boolean): void {
+  const { desktopSettings, setDesktopSettings } = useDesktopSettingsStore.getState();
+  if (desktopSettings.layout[key] === visible) return;
+  setDesktopSettings({
+    ...desktopSettings,
+    layout: { ...desktopSettings.layout, [key]: visible },
+  });
+}
+
+/**
+ * Move a panel to `visible`, showing it collapsed on its rail so re-enabling it
+ * does not jump to an expanded panel that buries its neighbour. Bails out when
+ * the panel is already where it is being asked to go, so a caller re-applying an
+ * unchanged value cannot collapse a panel the user had expanded.
+ */
+export function applyRightPanelVisibility(panelId: string, visible: boolean): void {
+  if (isRightPanelVisible(panelId) === visible) return;
+  if (visible) {
+    openRightPanel(panelId);
+    collapseRightPanel(panelId);
+  } else {
+    closeRightPanel(panelId);
+  }
+}
+
+/**
+ * Register a dockable right panel whose visibility is a persisted layout
+ * setting, and keep the two in step. Returns a disposer that unsubscribes
+ * before unregistering.
+ *
+ * Visibility is seeded from the setting at registration, so a panel the user
+ * turned off stays off across restarts instead of reopening on every launch
+ * (GeoLibre#1935). From then on the setting mirrors the registry, which matters
+ * because the panel can be closed from its own header as well as from Settings
+ * → Layout: for these panels closing is not a transient collapse, it removes
+ * the rail entry entirely and only Settings can bring it back, so it is a
+ * preference either way. Mirroring is what keeps the Settings checkbox, the
+ * panel on screen, and the stored value from ever disagreeing.
+ *
+ * Two registry events are deliberately *not* mirrored:
+ *
+ * - The `emit` from registration itself, because the panel is legitimately not
+ *   visible yet. The subscription is therefore attached after the seed.
+ * - The `emit` from unregistering on unmount, which would otherwise persist
+ *   `false` every time the shell tears down. `unregisterRightPanel` removes the
+ *   panel from the registry before it emits, so the `getRightPanel` guard
+ *   catches it; the disposer unsubscribing first makes that belt-and-braces.
+ *
+ * Being displaced by another panel is not a close (the registry keeps a
+ * displaced panel in `visibleIds`), so it correctly writes nothing.
+ */
+export function registerPersistedRightPanel(
+  registration: GeoLibreRightPanelRegistration,
+  key: PersistedPanelKey,
+): () => void {
+  const dispose = registerRightPanel(registration);
+  applyRightPanelVisibility(registration.id, isPanelVisibleInSettings(key));
+  const unsubscribe = subscribeRightPanels(() => {
+    if (!getRightPanel(registration.id)) return;
+    setPanelVisibleInSettings(key, isRightPanelVisible(registration.id));
+  });
+  return () => {
+    unsubscribe();
+    dispose();
+  };
+}

packages/plugins/package.json

@@ -12,6 +12,7 @@
     "./local-netcdf": "./src/plugins/local-netcdf.ts",
     "./maplibre-graticule": "./src/plugins/maplibre-graticule.ts",
     "./raster-symbology": "./src/plugins/raster-symbology.ts",
+    "./right-panel-registry": "./src/right-panel-registry.ts",
     "./zarr-time-axis": "./src/plugins/zarr-time-axis.ts"
   },
   "dependencies": {

tests/layout-panel-settings.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  DEFAULT_DESKTOP_LAYOUT_SETTINGS,
+  normalizeDesktopSettings,
+} from "../apps/geolibre-desktop/src/hooks/useDesktopSettings";
+
+// The Browser and Comments right panels used to be session-only: their Settings
+// → Layout toggles moved the panel registry but nothing was persisted, so every
+// launch reopened them (GeoLibre#1935). They are now layout settings like the
+// Layers/Style panels, which means they have to round-trip through
+// normalizeDesktopSettings and keep defaulting to on for existing users whose
+// stored settings predate the keys.
+describe("dockable panel layout settings", () => {
+  it("defaults both dockable panels to visible", () => {
+    assert.equal(DEFAULT_DESKTOP_LAYOUT_SETTINGS.browserPanelVisible, true);
+    assert.equal(DEFAULT_DESKTOP_LAYOUT_SETTINGS.commentsPanelVisible, true);
+  });
+
+  it("keeps a disabled panel disabled across a load", () => {
+    const layout = normalizeDesktopSettings({
+      layout: { browserPanelVisible: false, commentsPanelVisible: false },
+    }).layout;
+    assert.equal(layout.browserPanelVisible, false);
+    assert.equal(layout.commentsPanelVisible, false);
+  });
+
+  it("falls back to the defaults for settings saved before the keys existed", () => {
+    const layout = normalizeDesktopSettings({
+      layout: { layerPanelVisible: false, stylePanelVisible: true, toolbarLabels: true },
+    }).layout;
+    assert.equal(layout.layerPanelVisible, false);
+    assert.equal(layout.browserPanelVisible, true);
+    assert.equal(layout.commentsPanelVisible, true);
+  });
+
+  it("rejects non-boolean values from tampered storage", () => {
+    const layout = normalizeDesktopSettings({
+      layout: { browserPanelVisible: "no", commentsPanelVisible: 0 },
+    }).layout;
+    assert.equal(layout.browserPanelVisible, true);
+    assert.equal(layout.commentsPanelVisible, true);
+  });
+});