feat(layers): show a tiled archive as a group of its source layers

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

@@ -703,6 +703,9 @@ export function BasemapExtractPanel({ open, onClose, mapControllerRef }: Basemap
         setBasemapStyleUrl(registerOfflineBasemapStyle(layerId, style));
         trackStyledBasemap(layerId, `${layerId}.pmtiles`);
       } else {
+        // One layer, deliberately: an extract is a backdrop to draw over, not the thing being
+        // inspected, so it stays a single row rather than being split per source layer the way an
+        // archive added from the PMTiles control or a STAC asset is.
         addLayer(
           createPMTilesStoreLayer({
             id: layerId,

packages/map/src/headless.ts

@@ -9,7 +9,7 @@
  */
 import type { GeoLibreLayer } from "@geolibre/core";
 import type * as maplibregl from "maplibre-gl";
-import { removeLayerFromMap, syncLayer } from "./layer-sync";
+import { externalSourceIdsFor, removeLayerFromMap, syncLayer } from "./layer-sync";
 import { installMapTransformCompat as _installMapTransformCompat } from "./map-transform-compat";
 export { installMapTransformCompat } from "./map-transform-compat";
 
@@ -36,8 +36,13 @@ export function createLayerSync(map: maplibregl.Map): LayerSync {
     sync(layers) {
       const nextIds = new Set(layers.map((layer) => layer.id));
       const previousById = new Map(synced.map((layer) => [layer.id, layer]));
+      // Every layer in `layers` is on the map when this sync ends — including the ones the reorder
+      // loop below takes off and puts straight back — so a source any of them draws from stays.
+      const survivingSourceIds = externalSourceIdsFor(layers);
       for (const previous of synced) {
-        if (!nextIds.has(previous.id)) removeLayerFromMap(map, previous.id, previous);
+        if (!nextIds.has(previous.id)) {
+          removeLayerFromMap(map, previous.id, previous, survivingSourceIds);
+        }
       }
 
       // Input order is bottom-to-top: each addLayer without an anchor lands on
@@ -60,7 +65,7 @@ export function createLayerSync(map: maplibregl.Map): LayerSync {
       }
       for (let index = rebuildFrom; index < layers.length; index += 1) {
         const previous = previousById.get(layers[index].id);
-        if (previous) removeLayerFromMap(map, layers[index].id, previous);
+        if (previous) removeLayerFromMap(map, layers[index].id, previous, survivingSourceIds);
       }
 
       for (const layer of layers) syncLayer(map, layer);

packages/map/src/layer-sync.ts

@@ -1,20 +1,25 @@
 import {
   controlRendersLayer,
   DEFAULT_LAYER_STYLE,
-  type GeoLibreLayer,
-  type ExternalNativePaintBridge,
   generatorCircleRadiusValue,
   geojsonHasZCoordinates,
   getExternalNativePaintBridge,
-  type LayerStyle,
   pluginOwnsPaint,
   proportionalRadiusExpression,
   ruleBasedVisibilityFilter,
   shouldUseTiledRendering,
   styleValue,
+  type ExternalNativePaintBridge,
+  type GeoLibreLayer,
+  type LayerStyle,
   validateMapExpression,
 } from "@geolibre/core";
-import { normalizePMTilesUrl, PMTILES_PROTOCOL, pmtilesVectorLayerId } from "./pmtiles-layer";
+import {
+  normalizePMTilesUrl,
+  PMTILES_PROTOCOL,
+  pmtilesLayerKinds,
+  pmtilesVectorLayerId,
+} from "./pmtiles-layer";
 import { encodeVectorTileLayerPart } from "./vector-tile-layer-ids";
 import { addProtocol, config } from "maplibre-gl";
 import type { GeoJSON } from "geojson";
@@ -1127,7 +1132,7 @@ function hasPMTilesNativeSourceLayer(
   sourceId: string,
   sourceLayer: string,
 ): boolean {
-  return ["fill", "line", "circle"].some((kind) =>
+  return pmtilesLayerKinds.some((kind) =>
     nativeLayerIds.includes(pmtilesVectorLayerId(sourceId, sourceLayer, kind)),
   );
 }
@@ -3629,10 +3634,16 @@ function moveLayer(map: maplibregl.Map, id: string, beforeId?: string): void {
   }
 }
 
+/** The external sources a set of layers draws from — what a removal must not pull out from under. */
+export function externalSourceIdsFor(layers: readonly GeoLibreLayer[]): Set<string> {
+  return new Set(layers.flatMap((layer) => getExternalSourceIds(layer)));
+}
+
 export function removeLayerFromMap(
   map: maplibregl.Map,
   layerId: string,
   layer?: GeoLibreLayer,
+  survivingSourceIds?: ReadonlySet<string>,
 ): void {
   // Drop cached paint-bridge state so a later layer reusing this id never
   // skips a fresh opacity/visibility apply against a new bridge.
@@ -3667,14 +3678,35 @@ export function removeLayerFromMap(
   ]) {
     if (map.getLayer(id)) map.removeLayer(id);
   }
+  // An archive's source layers share one source, so it goes only once nothing draws from it. The
+  // store half covers a layer that survives this sync; the map half covers its siblings inside one
+  // — deleting a folder removes its children in a single pass, and MapLibre reports removing a
+  // source still under a style layer as an error the user can do nothing about.
+  const stillInUse = survivingSourceIds ?? new Set<string>();
+  // Only an external source can be shared — the derived ids below are this layer's alone — so the
+  // map is asked at most once, and only when a shareable source is actually up for removal. Walked
+  // layer by layer rather than read from `getStyle()`, which serializes the whole document.
+  const shareable = new Set(getExternalSourceIds(layer));
+  let drawnSources: Set<string> | undefined;
+  const stillDrawn = (src: string): boolean => {
+    drawnSources ??= new Set(
+      map
+        .getLayersOrder()
+        .map((styleLayerId) => map.getLayer(styleLayerId)?.source)
+        .filter((source): source is string => typeof source === "string"),
+    );
+    return drawnSources.has(src);
+  };
   for (const src of [
     ...getExternalSourceIds(layer),
     sourceId(layerId),
     labelSourceId(layerId),
     invertedSourceId(layerId),
     generatorSourceId(layerId),
   ]) {
-    if (src && map.getSource(src)) map.removeSource(src);
+    if (!src || stillInUse.has(src) || !map.getSource(src)) continue;
+    if (shareable.has(src) && stillDrawn(src)) continue;
+    map.removeSource(src);
   }
   // Drop radius-override tracking for the removed layer's native ids so a
   // later layer reusing an id never inherits a stale restore.

packages/map/src/map-controller.ts

@@ -45,6 +45,7 @@ import {
 } from "./geojson-loader";
 import {
   mbtilesStyleLayerIds,
+  externalSourceIdsFor,
   removeLayerFromMap,
   styleValuesEqual,
   syncLayer,
@@ -1242,9 +1243,11 @@ export class MapController {
     const nextIds = layers.map((l) => l.id);
     const nextIdSet = new Set(nextIds);
     const previousLayers = new Map(this.syncedLayers.map((layer) => [layer.id, layer]));
+    // Built once for the whole pass: every removal below asks the same question of the same list.
+    const survivingSourceIds = externalSourceIdsFor(layers);
     for (const id of this.layerIds) {
       if (!nextIdSet.has(id)) {
-        removeLayerFromMap(map, id, previousLayers.get(id));
+        removeLayerFromMap(map, id, previousLayers.get(id), survivingSourceIds);
       }
     }
 

packages/map/src/pmtiles-layer.ts

@@ -19,6 +19,9 @@ export function normalizePMTilesUrl(url: string): string {
   return url.startsWith(`${PMTILES_PROTOCOL}://`) ? url : `${PMTILES_PROTOCOL}://${url}`;
 }
 
+/** The MapLibre layers one source layer is drawn with. */
+export const pmtilesLayerKinds = ["fill", "line", "circle"] as const;
+
 export function pmtilesVectorLayerId(sourceId: string, sourceLayer: string, kind: string): string {
   return `${sourceId}-${encodeVectorTileLayerPart(sourceLayer)}-${kind}`;
 }
@@ -39,7 +42,7 @@ export function pmtilesNativeLayerIds(
     return [`${sourceId}-raster`];
   }
   return sourceLayers.flatMap((sourceLayer) =>
-    ["fill", "line", "circle"].map((kind) => pmtilesVectorLayerId(sourceId, sourceLayer, kind)),
+    pmtilesLayerKinds.map((kind) => pmtilesVectorLayerId(sourceId, sourceLayer, kind)),
   );
 }
 
@@ -61,6 +64,8 @@ export interface PMTilesStoreLayerOptions {
   sourceLayerColors?: Record<string, string>;
   /** The MapLibre ids a control created itself; derived from the naming scheme otherwise. */
   nativeLayerIds?: readonly string[];
+  /** The MapLibre source to draw from, when it is not this layer's own — a shared archive. */
+  sourceId?: string;
 }
 
 /**
@@ -70,6 +75,7 @@ export interface PMTilesStoreLayerOptions {
  */
 export function createPMTilesStoreLayer(options: PMTilesStoreLayerOptions): GeoLibreLayer {
   const { id, name, tileType } = options;
+  const sourceId = options.sourceId ?? id;
   const sourceLayers = [...options.sourceLayers];
   const url = normalizePMTilesUrl(options.url);
   const fillColor =
@@ -81,7 +87,7 @@ export function createPMTilesStoreLayer(options: PMTilesStoreLayerOptions): GeoL
     name,
     type: "pmtiles",
     source: {
-      sourceId: id,
+      sourceId,
       sourceLayers,
       tileType,
       type: tileType === "raster" ? "raster" : "vector",
@@ -104,18 +110,67 @@ export function createPMTilesStoreLayer(options: PMTilesStoreLayerOptions): GeoL
     metadata: {
       externalNativeLayer: true,
       nativeLayerIds: [
-        ...(options.nativeLayerIds ?? pmtilesNativeLayerIds(id, tileType, sourceLayers)),
+        ...(options.nativeLayerIds ?? pmtilesNativeLayerIds(sourceId, tileType, sourceLayers)),
       ],
       pickable: options.pickable ?? true,
-      sourceId: id,
+      sourceId,
       sourceKind: "pmtiles-url",
-      ...(options.sourceLayerColors ? { sourceLayerColors: options.sourceLayerColors } : {}),
       sourceLayers,
       tileType,
     },
   };
 }
 
+/**
+ * One layer per source layer in a vector archive, so the Layers panel can show, reorder, style and
+ * hide them with the machinery it already has. Raster, or a single source layer, stays one layer.
+ *
+ * All of them name the archive's one MapLibre source, so removing one must not remove it —
+ * `removeLayerFromMap` refcounts it against the survivors. That id doubles as the refcount key;
+ * anything needing the two to differ needs its own field rather than a third reader of this one.
+ */
+export function createPMTilesArchiveLayers(options: PMTilesStoreLayerOptions): GeoLibreLayer[] {
+  // Keyed by the id each source layer would take, not by its name: `encodeVectorTileLayerPart` is
+  // not injective (`a/b` and `a_2Fb` both encode to `a_2Fb`), and an archive's metadata can repeat
+  // a name outright. Either way a second layer would carry the first one's id.
+  if (options.tileType === "raster") {
+    // Raster tiles never split, so the id math below means nothing for them.
+    return [createPMTilesStoreLayer(options)];
+  }
+  const parts = new Map<string, string>();
+  for (const sourceLayer of options.sourceLayers) {
+    const id = `${options.id}-${encodeVectorTileLayerPart(sourceLayer)}`;
+    const taken = parts.get(id);
+    if (taken === undefined) {
+      parts.set(id, sourceLayer);
+    } else if (taken !== sourceLayer) {
+      // Two different names, one id: the second's features would draw nowhere. Reported rather
+      // than dropped in silence — the Diagnostics panel is where a user can see it.
+      console.warn(
+        `PMTiles archive "${options.id}": source layer "${sourceLayer}" collides with "${taken}" and is not drawn.`,
+      );
+    }
+  }
+  if (parts.size < 2) {
+    // Deduped here too, so one layer never carries the same source layer twice.
+    return [
+      createPMTilesStoreLayer({ ...options, sourceLayers: [...new Set(options.sourceLayers)] }),
+    ];
+  }
+  return [...parts].map(([id, sourceLayer]) =>
+    createPMTilesStoreLayer({
+      ...options,
+      id,
+      name: sourceLayer,
+      sourceLayers: [sourceLayer],
+      // The archive's source, and so the archive's ids: a layer deriving its own would name ids
+      // nothing on the map answers to.
+      sourceId: options.id,
+      nativeLayerIds: undefined,
+    }),
+  );
+}
+
 /** Facts about a PMTiles archive needed to build a GeoLibre layer for it. */
 export interface PMTilesArchiveInfo {
   tileType: "vector" | "raster";