fix(processing): preserve dissolve attribute groups (#1978)

* fix(processing): preserve dissolve attribute groups

* Address Claude review feedback

- Preserve each dissolve field value's original type across connected and disconnected groups.
- Cover numeric group values and no-field disconnected dissolves.

* Address Claude review feedback

- Carry the first source feature's whole attribute set through Dissolve instead
  of rebuilding properties from just the dissolve field, so attributes no longer
  disappear when a group is merged (matching the sidecar's GeoPandas
  `dissolve`, aggfunc="first"). The field's original value/type still wins
  because it comes from that same source feature.
- Copy the properties object so the result layer never aliases the input layer's.
- Extend the dissolve tests to assert a non-dissolve attribute survives, both
  with and without a dissolve field.

Author: giswqs

packages/processing/src/vector-tools.ts

@@ -94,6 +94,42 @@ function explodeToPolygons(features: Feature[]): Feature<Polygon>[] {
   return result;
 }
 
+/** Reassemble Turf dissolve parts into one Polygon/MultiPolygon per group. */
+function collectDissolveParts(
+  dissolved: FeatureCollection<Polygon>,
+  field?: string,
+  originalProperties?: ReadonlyMap<string, GeoJsonProperties>,
+): FeatureCollection<Polygon | MultiPolygon> {
+  const groups = new Map<string, Feature<Polygon>[]>();
+  for (const feature of dissolved.features) {
+    const key = field ? String(feature.properties?.[field]) : "";
+    const group = groups.get(key);
+    if (group) group.push(feature);
+    else groups.set(key, [feature]);
+  }
+
+  const features: Feature<Polygon | MultiPolygon>[] = [...groups.entries()].map(([key, parts]) => {
+    // Mirror GeoPandas' `dissolve` (aggfunc="first"): every merged feature keeps
+    // the first source feature's whole attribute set, so the dissolve field keeps
+    // its original type and the other attributes survive the merge — whether or
+    // not the group happened to stay connected.
+    const source = originalProperties?.get(key) ?? parts[0].properties;
+    const properties: GeoJsonProperties = source ? { ...source } : {};
+    if (parts.length === 1) {
+      return { ...parts[0], properties };
+    }
+    return {
+      type: "Feature" as const,
+      properties,
+      geometry: {
+        type: "MultiPolygon" as const,
+        coordinates: parts.map((part) => part.geometry.coordinates),
+      },
+    };
+  });
+  return featureCollection(features);
+}
+
 /** Merge all polygons of a collection into a single (multi)polygon feature. */
 function mergePolygons(fc: FeatureCollection): Feature<Polygon | MultiPolygon> | null {
   const polys = polygonFeatures(fc);
@@ -266,9 +302,17 @@ export const dissolveTool: ProcessingAlgorithm = {
       return;
     }
     const field = (ctx.parameters.field as string)?.trim();
-    const dissolved = dissolve(featureCollection(polys), {
+    // Remember the first source feature of each group so the merged output can
+    // carry its attributes through, the way the sidecar's GeoPandas dissolve does.
+    const originalProperties = new Map<string, GeoJsonProperties>();
+    for (const polygon of polys) {
+      const key = field ? String(polygon.properties?.[field]) : "";
+      if (!originalProperties.has(key)) originalProperties.set(key, polygon.properties);
+    }
+    const dissolvedParts = dissolve(featureCollection(polys), {
       propertyName: field || undefined,
     });
+    const dissolved = collectDissolveParts(dissolvedParts, field || undefined, originalProperties);
     ctx.log(`Dissolved ${polys.length} polygon(s) into ${dissolved.features.length} feature(s)`);
     ctx.addResultLayer?.("Dissolve", dissolved);
   },

tests/processing.test.ts

@@ -52,6 +52,113 @@ describe("processing registry", () => {
     assert.deepEqual(messages, ["Feature count: 2"]);
   });
 
+  it("dissolves disconnected polygons into one feature per attribute value", () => {
+    const square = (x: number, group: string | number, name = `square-${x}`) => ({
+      type: "Feature" as const,
+      properties: { group, name },
+      geometry: {
+        type: "Polygon" as const,
+        coordinates: [
+          [
+            [x, 0],
+            [x + 1, 0],
+            [x + 1, 1],
+            [x, 1],
+            [x, 0],
+          ],
+        ],
+      },
+    });
+    const polygons: GeoLibreLayer = {
+      ...layer,
+      id: "polygons",
+      geojson: {
+        type: "FeatureCollection",
+        features: [square(0, 5), square(3, 5), square(6, "B")],
+      },
+    };
+    const messages: string[] = [];
+    let result: FeatureCollection | null = null;
+
+    getVectorTool("dissolve")!.run({
+      layers: [polygons],
+      parameters: { layer: "polygons", field: "group" },
+      log: (message) => messages.push(message),
+      addResultLayer: (_name, geojson) => {
+        result = geojson;
+      },
+    });
+
+    assert.equal(result!.features.length, 2);
+    const numericGroup = result!.features.find((feature) => feature.properties?.group === 5);
+    assert.equal(numericGroup?.properties?.group, 5);
+    assert.equal(numericGroup?.geometry.type, "MultiPolygon");
+    // Merged groups keep the first source feature's other attributes, matching
+    // the sidecar's GeoPandas dissolve.
+    assert.equal(numericGroup?.properties?.name, "square-0");
+    const connectedGroup = result!.features.find((feature) => feature.properties?.group === "B");
+    assert.equal(connectedGroup?.properties?.name, "square-6");
+    assert.deepEqual(messages, ["Dissolved 3 polygon(s) into 2 feature(s)"]);
+  });
+
+  it("dissolves all disconnected polygons into one feature without a field", () => {
+    const polygons: GeoLibreLayer = {
+      ...layer,
+      id: "polygons",
+      geojson: {
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            properties: { name: "first" },
+            geometry: {
+              type: "Polygon",
+              coordinates: [
+                [
+                  [0, 0],
+                  [1, 0],
+                  [1, 1],
+                  [0, 1],
+                  [0, 0],
+                ],
+              ],
+            },
+          },
+          {
+            type: "Feature",
+            properties: { name: "second" },
+            geometry: {
+              type: "Polygon",
+              coordinates: [
+                [
+                  [3, 0],
+                  [4, 0],
+                  [4, 1],
+                  [3, 1],
+                  [3, 0],
+                ],
+              ],
+            },
+          },
+        ],
+      },
+    };
+    let result: FeatureCollection | null = null;
+
+    getVectorTool("dissolve")!.run({
+      layers: [polygons],
+      parameters: { layer: "polygons" },
+      log: () => {},
+      addResultLayer: (_name, geojson) => {
+        result = geojson;
+      },
+    });
+
+    assert.equal(result!.features.length, 1);
+    assert.equal(result!.features[0].geometry.type, "MultiPolygon");
+    assert.equal(result!.features[0].properties?.name, "first");
+  });
+
   it("spatially joins zone attributes onto points", () => {
     const zone: GeoLibreLayer = {
       ...layer,