fix: scrub widgets, comments, and legend when layers disappear (#1627)

* fix: scrub widgets, comments, and legend when layers disappear

Drop dangling dashboard/widget, feature-comment, and legend keys on
layer/group delete and when applying a project with orphan refs.

* style: auto-format (ruff + oxfmt) [pre-commit.ci]

* fix: efficient override scan and separate customEntries changed flag

Use base-id extraction (key.includes("::") ? key.slice(…) : key) for
override lookups instead of spreading the removed Set per key.  Track
customEntries changes with a separate flag so an unrelated order/override
change does not needlessly rebuild the customEntries object.

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: Ayush7614

packages/core/src/index.ts

@@ -22,6 +22,11 @@ export * from "./layer-defaults";
 export * from "./layer-style-clipboard";
 export * from "./layer-groups";
 export { createSampleStoryMap } from "./storymap-sample";
+export {
+  scrubWidgetsForRemovedLayers,
+  scrubCommentsForRemovedLayers,
+  scrubLegendForRemovedLayers,
+} from "./layer-ref-scrub";
 export {
   serializeStoryMapJson,
   parseStoryMapJson,

packages/core/src/layer-ref-scrub.ts

@@ -0,0 +1,98 @@
+import type { DashboardWidget, LegendConfig, ProjectComment } from "./types";
+
+/**
+ * Normalize the removed-layer-ids argument into a Set for uniform lookup.
+ */
+export function removedLayerIdSet(layerIds: string | Iterable<string>): Set<string> {
+  if (typeof layerIds === "string") return new Set([layerIds]);
+  if (layerIds instanceof Set) return layerIds as Set<string>;
+  return new Set(layerIds);
+}
+
+/**
+ * Filter out dashboard widgets whose `layerId` references a removed layer.
+ * Returns the same array reference when nothing changes.
+ */
+export function scrubWidgetsForRemovedLayers(
+  widgets: DashboardWidget[],
+  layerIds: string | Iterable<string>,
+): DashboardWidget[] {
+  const removed = removedLayerIdSet(layerIds);
+  if (removed.size === 0 || widgets.length === 0) return widgets;
+  const filtered = widgets.filter((w) => !removed.has(w.layerId));
+  return filtered.length === widgets.length ? widgets : filtered;
+}
+
+/**
+ * Drop comments whose anchor is a feature on a removed layer.
+ * Point-anchored comments are always kept.
+ * Returns the same array reference when nothing changes.
+ */
+export function scrubCommentsForRemovedLayers(
+  comments: ProjectComment[],
+  layerIds: string | Iterable<string>,
+): ProjectComment[] {
+  const removed = removedLayerIdSet(layerIds);
+  if (removed.size === 0 || comments.length === 0) return comments;
+  const filtered = comments.filter(
+    (c) => !(c.anchor.type === "feature" && removed.has(c.anchor.layerId)),
+  );
+  return filtered.length === comments.length ? comments : filtered;
+}
+
+/**
+ * Scrub legend config of references to removed layers:
+ * - `order`: filter out removed layer ids
+ * - `overrides`: drop keys that equal a removed id OR start with `${id}::`
+ * - `customEntries`: drop keys that equal a removed layer id but KEEP keys
+ *   starting with `custom:`
+ *
+ * Returns the same reference when nothing changes.
+ */
+export function scrubLegendForRemovedLayers(
+  legend: LegendConfig,
+  layerIds: string | Iterable<string>,
+): LegendConfig {
+  const removed = removedLayerIdSet(layerIds);
+  if (removed.size === 0) return legend;
+
+  let changed = false;
+
+  // --- order ---
+  const order = legend.order.filter((id) => !removed.has(id));
+  if (order.length !== legend.order.length) changed = true;
+
+  // --- overrides ---
+  const overrides: Record<string, (typeof legend.overrides)[string]> = {};
+  for (const [key, value] of Object.entries(legend.overrides)) {
+    const base = key.includes("::") ? key.slice(0, key.indexOf("::")) : key;
+    if (removed.has(base)) {
+      changed = true;
+    } else {
+      overrides[key] = value;
+    }
+  }
+
+  // --- customEntries ---
+  let customEntries = legend.customEntries;
+  if (customEntries) {
+    let customEntriesChanged = false;
+    const nextCustom: Record<string, (typeof customEntries)[string]> = {};
+    for (const [key, value] of Object.entries(customEntries)) {
+      if (key.startsWith("custom:")) {
+        nextCustom[key] = value;
+      } else if (removed.has(key)) {
+        customEntriesChanged = true;
+      } else {
+        nextCustom[key] = value;
+      }
+    }
+    if (customEntriesChanged) {
+      customEntries = Object.keys(nextCustom).length > 0 ? nextCustom : undefined;
+      changed = true;
+    }
+  }
+
+  if (!changed) return legend;
+  return { ...legend, order, overrides, customEntries };
+}

packages/core/src/project.ts

@@ -52,6 +52,11 @@ import {
 import { DEFAULT_LAYER_GROUP_OPACITY, normalizeGroupContiguity } from "./layer-groups";
 import { normalizeStyleLibraryEntries } from "./style-library";
 import { getEllipsoid } from "./ellipsoids";
+import {
+  scrubWidgetsForRemovedLayers,
+  scrubCommentsForRemovedLayers,
+  scrubLegendForRemovedLayers,
+} from "./layer-ref-scrub";
 
 /** Placeholder name a project carries before the user names it. */
 export const DEFAULT_PROJECT_NAME = "Untitled Project";
@@ -1499,6 +1504,41 @@ export function applyProjectToStore(project: GeoLibreProject): {
     normalizeSecondaryMapViews(project.secondaryMapViews),
     { mapView },
   );
+
+  // Scrub cross-references that point at layers not present in the loaded
+  // project (orphans from hand-editing or a partial project file).
+  const existingLayerIds = new Set(normalizedLayers.map((l) => l.id));
+  const widgets = normalizeWidgets(project.widgets) ?? [];
+  const comments = normalizeProjectComments(project.comments);
+  const legend = normalizeLegendConfig(project.legend) ?? {
+    ...DEFAULT_LEGEND_CONFIG,
+  };
+
+  const allReferencedIds = new Set<string>();
+  for (const w of widgets) allReferencedIds.add(w.layerId);
+  for (const c of comments) {
+    if (c.anchor.type === "feature") allReferencedIds.add(c.anchor.layerId);
+  }
+  for (const id of legend.order) allReferencedIds.add(id);
+  for (const key of Object.keys(legend.overrides)) {
+    const base = key.includes("::") ? key.slice(0, key.indexOf("::")) : key;
+    allReferencedIds.add(base);
+  }
+  if (legend.customEntries) {
+    for (const key of Object.keys(legend.customEntries)) {
+      if (!key.startsWith("custom:")) allReferencedIds.add(key);
+    }
+  }
+
+  const orphanIds = new Set([...allReferencedIds].filter((id) => !existingLayerIds.has(id)));
+
+  const scrubbedWidgets =
+    orphanIds.size > 0 ? scrubWidgetsForRemovedLayers(widgets, orphanIds) : widgets;
+  const scrubbedComments =
+    orphanIds.size > 0 ? scrubCommentsForRemovedLayers(comments, orphanIds) : comments;
+  const scrubbedLegend =
+    orphanIds.size > 0 ? scrubLegendForRemovedLayers(legend, orphanIds) : legend;
+
   return {
     projectName: project.name,
     mapView,
@@ -1509,19 +1549,17 @@ export function applyProjectToStore(project: GeoLibreProject): {
     layerGroups,
     preferences: normalizeProjectPreferences(project.preferences),
     projectPlugins: normalizeProjectPlugins(project.plugins),
-    legend: normalizeLegendConfig(project.legend) ?? {
-      ...DEFAULT_LEGEND_CONFIG,
-    },
+    legend: scrubbedLegend,
     storymap: normalizeStoryMap(project.storymap),
     models: normalizeModels(project.models) ?? [],
     processingHistory: normalizeProcessingHistory(project.processingHistory) ?? [],
-    widgets: normalizeWidgets(project.widgets) ?? [],
+    widgets: scrubbedWidgets,
     dashboardColumns: normalizeDashboardColumns(project.dashboardColumns),
     mapLayout,
     secondaryMapViews,
     primaryMapLabel: normalizeString(project.primaryMapLabel),
     projectStyleLibrary: normalizeStyleLibraryEntries(project.styleLibrary),
-    comments: normalizeProjectComments(project.comments),
+    comments: scrubbedComments,
     metadata: project.metadata,
   };
 }

packages/core/src/store.ts

@@ -63,6 +63,12 @@ import {
   type CommentReply,
   type ProjectComment,
 } from "./types";
+import {
+  removedLayerIdSet,
+  scrubWidgetsForRemovedLayers,
+  scrubCommentsForRemovedLayers,
+  scrubLegendForRemovedLayers,
+} from "./layer-ref-scrub";
 import { hasSimpleStyleProperties } from "./vector-color";
 import {
   applyCopiedLayerStyle,
@@ -747,12 +753,6 @@ function sameCamera(a: MapViewState, b: MapViewState): boolean {
   );
 }
 
-function removedLayerIdSet(layerIds: string | Iterable<string>): Set<string> {
-  if (typeof layerIds === "string") return new Set([layerIds]);
-  if (layerIds instanceof Set) return layerIds;
-  return new Set(layerIds);
-}
-
 /**
  * Strip storymap chapter enter/exit opacity rows that reference any of the
  * removed layer ids. Returns the same reference when nothing changes so
@@ -1618,6 +1618,9 @@ export const useAppStore = create<AppState>()(
           // Drop storymap chapter enter/exit opacity rows that pointed at the
           // removed layer so they do not keep a dangling id across save/reload.
           storymap: scrubStorymapLayerRefs(s.storymap, id),
+          widgets: scrubWidgetsForRemovedLayers(s.widgets, id),
+          comments: scrubCommentsForRemovedLayers(s.comments, id),
+          legend: scrubLegendForRemovedLayers(s.legend, id),
           selectedLayerId:
             s.selectedLayerId === id
               ? (s.layers.find((l) => l.id !== id)?.id ?? null)
@@ -1953,6 +1956,13 @@ export const useAppStore = create<AppState>()(
               ? scrubSecondaryPaneLayerVisibility(s.secondaryMapViews, removedIds)
               : s.secondaryMapViews,
             storymap: removeChildren ? scrubStorymapLayerRefs(s.storymap, removedIds) : s.storymap,
+            widgets: removeChildren
+              ? scrubWidgetsForRemovedLayers(s.widgets, removedIds)
+              : s.widgets,
+            comments: removeChildren
+              ? scrubCommentsForRemovedLayers(s.comments, removedIds)
+              : s.comments,
+            legend: removeChildren ? scrubLegendForRemovedLayers(s.legend, removedIds) : s.legend,
             selectedLayerId: selectionRemoved
               ? (layers[layers.length - 1]?.id ?? null)
               : s.selectedLayerId,