@geospatial-sdk/core 0.0.5-dev.0 → 0.0.5-dev.0.sha-bfaf14b

package/lib/utils/hash.test.ts

@@ -0,0 +1,180 @@
+import { getHash } from "./hash.js";
+
+describe("getHash", () => {
+  it("generates a hash representing the deep value of an object", () => {
+    const hashA = getHash({ a: 1, b: 2, c: "abcd", d: ["a", "b", "c"] });
+    const hashB = getHash({ a: 1, b: 200, c: "abcd", d: ["a", "b", "c"] });
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("returns a stable hash regardless of properties order", () => {
+    const hashA = getHash({ a: 1, b: 2, c: "abcd" });
+    const hashB = getHash({ c: "abcd", b: 2, a: 1 });
+    expect(hashB).toEqual(hashA);
+  });
+  it("takes into account array order", () => {
+    const hashA = getHash({ a: ["a", "b", "c"] });
+    const hashB = getHash({ a: ["b", "a", "c"] });
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("ignores properties on demand", () => {
+    const hashA = getHash({ a: 1, b: 2, c: "abcd", d: ["a", "b", "c"] }, ["b"]);
+    const hashB = getHash({ c: "abcd", b: 2000, a: 1, d: ["a", "b", "c"] }, [
+      "b",
+    ]);
+    expect(hashB).toEqual(hashA);
+  });
+  it("stable for identical Date values", () => {
+    const hashA = getHash(new Date("2020-01-01T00:00:00.000Z"));
+    const hashB = getHash(new Date("2020-01-01T00:00:00.000Z"));
+    expect(hashB).toEqual(hashA);
+  });
+  it("different for different Date values", () => {
+    const hashA = getHash(new Date("2020-01-01T00:00:00.000Z"));
+    const hashB = getHash(new Date("2021-06-15T12:30:00.000Z"));
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("different when a nested Date value changes", () => {
+    const hashA = getHash({ time: new Date("2020-01-01T00:00:00.000Z") });
+    const hashB = getHash({ time: new Date("2021-06-15T12:30:00.000Z") });
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("stable for null", () => {
+    const hashA = getHash(null);
+    const hashB = getHash(null);
+    expect(hashB).toEqual(hashA);
+  });
+  it("different when casting null to string", () => {
+    const hashA = getHash(null);
+    const hashB = getHash("null");
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("stable with identical GeoJSON geometry", () => {
+    const hashA = getHash({
+      geometry: {
+        type: "Polygon",
+        properties: {},
+        coordinates: [
+          [
+            [-10, -10],
+            [-10, 20],
+            [10, 20],
+            [10, -10],
+            [-10, -10],
+          ],
+        ],
+      },
+    });
+    const hashB = getHash({
+      geometry: {
+        type: "Polygon",
+        properties: {},
+        coordinates: [
+          [
+            [-10, -10],
+            [-10, 20],
+            [10, 20],
+            [10, -10],
+            [-10, -10],
+          ],
+        ],
+      },
+    });
+    expect(hashB).toEqual(hashA);
+  });
+  it("stable with identical GeoJSON collection", () => {
+    const hashA = getHash({
+      geometry: {
+        type: "FeatureCollection",
+        features: [{ type: "Feature", properties: {}, geometry: null }],
+      },
+    });
+    const hashB = getHash({
+      geometry: {
+        type: "FeatureCollection",
+        features: [{ type: "Feature", properties: {}, geometry: null }],
+      },
+    });
+    expect(hashB).toEqual(hashA);
+  });
+  it("different if GeoJSON geometry properties are not in the same order", () => {
+    const hashA = getHash({
+      geometry: {
+        coordinates: [
+          [
+            [-10, -10],
+            [-10, 20],
+            [10, 20],
+            [10, -10],
+            [-10, -10],
+          ],
+        ],
+        type: "Polygon",
+        properties: {},
+      },
+    });
+    const hashB = getHash({
+      geometry: {
+        type: "Polygon",
+        properties: {},
+        coordinates: [
+          [
+            [-10, -10],
+            [-10, 20],
+            [10, 20],
+            [10, -10],
+            [-10, -10],
+          ],
+        ],
+      },
+    });
+    expect(hashB).not.toEqual(hashA);
+  });
+  it("stable with bigint values", () => {
+    const hashA = getHash({
+      aa: "bb",
+      cc: 9007199254740991n,
+    });
+    const hashB = getHash({
+      aa: "bb",
+      cc: 9007199254740991n,
+    });
+    expect(hashB).toEqual(hashA);
+  });
+  it("supports bigint in geojson", () => {
+    const hash = getHash({
+      type: "FeatureCollection",
+      features: [
+        {
+          type: "Feature",
+          properties: {
+            adresse: "Façade Esplanade",
+            code_insee: 59350n,
+            dtdate: 1785767040000,
+            etat: "OUVERT",
+            geom: "POINT (703523.791143476 7060856.34054855)",
+            latitude: 50.644637,
+            longitude: 3.049734,
+            nbr_libre: 138n,
+            nbr_total: 270n,
+            nom: "Petit Paradis",
+            txt_aff: "95",
+            ville: "LILLE",
+          },
+          geometry: {
+            coordinates: [
+              [
+                [2.789133, 50.49973],
+                [3.272498, 50.49973],
+                [3.272498, 50.794577],
+                [2.789133, 50.794577],
+                [2.789133, 50.49973],
+              ],
+            ],
+            type: "Polygon",
+          },
+        },
+      ],
+    });
+    expect(hash).toBeTruthy();
+  });
+});

package/lib/utils/hash.ts

@@ -0,0 +1,28 @@
+function isGeoJsonGeometry(object: object) {
+  return "type" in object && ("coordinates" in object || "features" in object);
+}
+
+const bigintReplacer = (key: string, value: unknown) =>
+  typeof value === "bigint" ? value.toString() : value;
+
+export function getHash(input: unknown, ignoreKeys: string[] = []): string {
+  if (input instanceof Date) {
+    return input.toISOString();
+  }
+  if (input instanceof Object && isGeoJsonGeometry(input)) {
+    return JSON.stringify(input, bigintReplacer); // do not compute an actual hash as it will take too long
+  } else if (input instanceof Object) {
+    const obj: Record<string, string> = {};
+    const keys = Object.keys(input).sort();
+    for (const key of keys) {
+      if (ignoreKeys.includes(key)) continue;
+      obj[key] = getHash(input[key as keyof typeof input]);
+    }
+    const hash = JSON.stringify(obj, bigintReplacer)
+      .split("")
+      .reduce((prev, curr) => (prev << 5) - prev + curr.charCodeAt(0), 0);
+    return (hash >>> 0).toString();
+  } else {
+    return JSON.stringify(input, bigintReplacer);
+  }
+}

package/lib/utils/index.ts

@@ -1,4 +1,20 @@
-export * from "./url";
-export * from "./freeze";
-export { computeMapContextDiff } from "./map-context-diff";
-export { getLayerPosition } from "./map-context";
+/**
+ * @group Utils
+ * @packageDocumentation
+ */
+
+export * from "./url.js";
+export * from "./freeze.js";
+export * from "./hash.js";
+export { computeMapContextDiff } from "./map-context-diff.js";
+export {
+  getLayerPosition,
+  addLayerToContext,
+  removeLayerFromContext,
+  replaceLayerInContext,
+  changeLayerPositionInContext,
+  updateLayerInContext,
+} from "./map-context.js";
+export { updateLayer } from "./map-context-layer.js";
+export { createViewFromLayer } from "./view.js";
+export * from "./style.js";

package/lib/utils/map-context-diff.test.ts

@@ -1,5 +1,5 @@
-import { MapContext, MapContextDiff, MapContextLayer } from "../model";
-import { computeMapContextDiff } from "./map-context-diff";
+import { MapContext, MapContextDiff, MapContextLayer } from "../model/index.js";
+import { computeMapContextDiff } from "./map-context-diff.js";
 import {
   SAMPLE_CONTEXT,
   SAMPLE_LAYER1,
@@ -7,7 +7,10 @@ import {
   SAMPLE_LAYER3,
   SAMPLE_LAYER4,
   SAMPLE_LAYER5,
-} from "../../fixtures/map-context.fixtures";
+  SAMPLE_LAYER6,
+  SAMPLE_LAYER7,
+} from "../../fixtures/map-context.fixtures.js";
+import { beforeEach, describe, expect, it } from "vitest";
 
 describe("Context diff utils", () => {
   describe("computeMapContextDiff", () => {
@@ -33,7 +36,6 @@ describe("Context diff utils", () => {
           layersChanged: [],
           layersRemoved: [],
           layersReordered: [],
-          viewChanges: {},
         });
       });
     });
@@ -65,7 +67,6 @@ describe("Context diff utils", () => {
           layersChanged: [],
           layersRemoved: [],
           layersReordered: [],
-          viewChanges: {},
         });
       });
     });
@@ -97,7 +98,6 @@ describe("Context diff utils", () => {
             },
           ],
           layersReordered: [],
-          viewChanges: {},
         });
       });
     });
@@ -123,16 +123,17 @@ describe("Context diff utils", () => {
           layersChanged: [
             {
               layer: contextNew.layers[0],
+              previousLayer: contextOld.layers[0],
               position: 0,
             },
             {
               layer: contextNew.layers[1],
+              previousLayer: contextOld.layers[1],
               position: 1,
             },
           ],
           layersRemoved: [],
           layersReordered: [],
-          viewChanges: {},
         });
       });
     });
@@ -167,7 +168,6 @@ describe("Context diff utils", () => {
                 previousPosition: 0,
               },
             ],
-            viewChanges: {},
           });
         });
       });
@@ -211,7 +211,122 @@ describe("Context diff utils", () => {
                 previousPosition: 0,
               },
             ],
-            viewChanges: {},
+          });
+        });
+      });
+    });
+
+    describe("view changes", () => {
+      describe("both values", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [0, 0],
+              zoom: 1,
+            },
+          };
+          contextNew = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [1, 1],
+              zoom: 2,
+            },
+          };
+        });
+        it("outputs the correct diff", () => {
+          diff = computeMapContextDiff(contextNew, contextOld);
+          expect(diff).toEqual({
+            layersAdded: [],
+            layersChanged: [],
+            layersRemoved: [],
+            layersReordered: [],
+            viewChanges: { ...contextNew.view },
+          });
+          expect(diff.viewChanges).not.toBe(contextNew.view); // the object reference should be different
+        });
+      });
+      describe("value to null", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [0, 0],
+              zoom: 1,
+            },
+          };
+          contextNew = {
+            ...SAMPLE_CONTEXT,
+            view: null,
+          };
+        });
+        it("outputs the correct diff", () => {
+          diff = computeMapContextDiff(contextNew, contextOld);
+          expect(diff).toEqual({
+            layersAdded: [],
+            layersChanged: [],
+            layersRemoved: [],
+            layersReordered: [],
+            viewChanges: null,
+          });
+        });
+      });
+      describe("null to value", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: null,
+          };
+          contextNew = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [0, 0],
+              zoom: 1,
+            },
+          };
+        });
+        it("outputs the correct diff", () => {
+          diff = computeMapContextDiff(contextNew, contextOld);
+          expect(diff).toEqual({
+            layersAdded: [],
+            layersChanged: [],
+            layersRemoved: [],
+            layersReordered: [],
+            viewChanges: {
+              center: [0, 0],
+              zoom: 1,
+            },
+          });
+        });
+      });
+      describe("same content but different reference", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [5, 10],
+              zoom: 3,
+            },
+          };
+          contextNew = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [5, 10],
+              zoom: 3,
+            },
+          };
+        });
+        it("output the correct diff", () => {
+          diff = computeMapContextDiff(contextNew, contextOld);
+          expect(diff).toEqual({
+            layersAdded: [],
+            layersChanged: [],
+            layersRemoved: [],
+            layersReordered: [],
+            viewChanges: {
+              center: [5, 10],
+              zoom: 3,
+            },
           });
         });
       });
@@ -228,6 +343,9 @@ describe("Context diff utils", () => {
         contextNew = {
           ...SAMPLE_CONTEXT,
           layers: [SAMPLE_LAYER2, changedLayer, SAMPLE_LAYER5],
+          view: {
+            extent: [0, 1, 2, 3],
+          },
         };
       });
       it("outputs the correct diff", () => {
@@ -242,6 +360,7 @@ describe("Context diff utils", () => {
           layersChanged: [
             {
               layer: changedLayer,
+              previousLayer: SAMPLE_LAYER3,
               position: 1,
             },
           ],
@@ -267,7 +386,118 @@ describe("Context diff utils", () => {
               previousPosition: 1,
             },
           ],
-          viewChanges: {},
+          viewChanges: {
+            extent: [0, 1, 2, 3],
+          },
+        });
+      });
+    });
+
+    describe("combined changes (2)", () => {
+      beforeEach(() => {
+        contextOld = {
+          ...SAMPLE_CONTEXT,
+          layers: [
+            SAMPLE_LAYER1,
+            SAMPLE_LAYER5,
+            SAMPLE_LAYER3,
+            SAMPLE_LAYER4,
+            SAMPLE_LAYER6,
+          ],
+        };
+        contextNew = {
+          ...SAMPLE_CONTEXT,
+          layers: [SAMPLE_LAYER3, SAMPLE_LAYER1],
+        };
+      });
+      it("outputs the correct diff", async () => {
+        diff = computeMapContextDiff(contextNew, contextOld);
+        expect(diff).toEqual({
+          layersAdded: [],
+          layersChanged: [],
+          layersRemoved: [
+            {
+              layer: SAMPLE_LAYER5,
+              position: 1,
+            },
+            {
+              layer: SAMPLE_LAYER4,
+              position: 3,
+            },
+            {
+              layer: SAMPLE_LAYER6,
+              position: 4,
+            },
+          ],
+          layersReordered: [
+            {
+              layer: SAMPLE_LAYER3,
+              newPosition: 0,
+              previousPosition: 1,
+            },
+            {
+              layer: SAMPLE_LAYER1,
+              newPosition: 1,
+              previousPosition: 0,
+            },
+          ],
+        });
+      });
+    });
+
+    describe("combined changes (3)", () => {
+      beforeEach(() => {
+        contextOld = {
+          ...SAMPLE_CONTEXT,
+          layers: [SAMPLE_LAYER5, SAMPLE_LAYER1, SAMPLE_LAYER2],
+        };
+        contextNew = {
+          ...SAMPLE_CONTEXT,
+          layers: [
+            SAMPLE_LAYER2,
+            SAMPLE_LAYER3,
+            SAMPLE_LAYER6,
+            SAMPLE_LAYER1,
+            SAMPLE_LAYER7,
+          ],
+        };
+      });
+      it("outputs the correct diff", async () => {
+        diff = computeMapContextDiff(contextNew, contextOld);
+        expect(diff).toEqual({
+          layersAdded: [
+            {
+              layer: SAMPLE_LAYER3,
+              position: 1,
+            },
+            {
+              layer: SAMPLE_LAYER6,
+              position: 2,
+            },
+            {
+              layer: SAMPLE_LAYER7,
+              position: 4,
+            },
+          ],
+          layersChanged: [],
+          layersRemoved: [
+            {
+              layer: SAMPLE_LAYER5,
+              position: 0,
+            },
+          ],
+          layersReordered: [
+            {
+              layer: SAMPLE_LAYER2,
+              previousPosition: 3,
+              newPosition: 0,
+            },
+            {
+              layer: SAMPLE_LAYER1,
+              previousPosition: 0,
+              newPosition: 3,
+            },
+          ],
         });
       });
     });

package/lib/utils/map-context-diff.ts

@@ -2,11 +2,11 @@ import {
   MapContext,
   MapContextDiff,
   MapContextLayer,
+  MapContextLayerChanged,
   MapContextLayerPositioned,
   MapContextLayerReordered,
-  MapContextView,
-} from "../model";
-import { isLayerSame, isLayerSameAndUnchanged } from "./map-context";
+} from "../model/index.js";
+import { isLayerSame, isLayerSameAndUnchanged } from "./map-context-layer.js";
 
 /**
  * The following logic is produced by identifying layers in both context
@@ -43,11 +43,10 @@ export function computeMapContextDiff(
     return -1;
   }
 
-  const layersChanged: MapContextLayerPositioned[] = [];
+  const layersChanged: MapContextLayerChanged[] = [];
   const layersReordered: MapContextLayerReordered[] = [];
   const layersRemoved: MapContextLayerPositioned[] = [];
   const layersAdded: MapContextLayerPositioned[] = [];
-  const viewChanges: MapContextView = {};
 
   // loop on prev context layers (for removed layers)
   for (let i = 0; i < previousContext.layers.length; i++) {
@@ -68,35 +67,45 @@ export function computeMapContextDiff(
     } else {
       const prevLayer = previousContext.layers[prevPosition];
       if (!isLayerSameAndUnchanged(layer, prevLayer)) {
-        layersChanged.push({ layer, position: i });
+        layersChanged.push({ layer, previousLayer: prevLayer, position: i });
       }
     }
   }
 
-  // look for moved layers
-  const prevLayersFiltered = previousContext.layers.filter(
+  // look for moved layers (ignore removed and added ones)
+  const movedLayersInPrevious = previousContext.layers.filter(
     (l) => !layersRemoved.find(({ layer }) => l === layer),
   );
-  const nextLayersFiltered = nextContext.layers.filter(
+  const movedLayersInNext = nextContext.layers.filter(
     (l) => !layersAdded.find(({ layer }) => l === layer),
   );
-  for (let i = 0; i < nextLayersFiltered.length; i++) {
-    const layer = nextLayersFiltered[i];
-    const prevPosition = getLayerPosition(layer, prevLayersFiltered);
+  for (let i = 0; i < movedLayersInNext.length; i++) {
+    const layer = movedLayersInNext[i];
+    let prevPosition = getLayerPosition(layer, movedLayersInPrevious);
     if (i !== prevPosition) {
+      // shift prevPosition of a move layer when others layers were added before them
+      for (const { position: addedPos } of layersAdded) {
+        if (addedPos <= prevPosition) prevPosition++;
+      }
       layersReordered.push({
         layer,
         newPosition: getLayerPosition(layer, nextContext.layers),
-        previousPosition: getLayerPosition(layer, previousContext.layers),
+        previousPosition: prevPosition,
       });
     }
   }
 
+  let viewChanges =
+    nextContext.view !== previousContext.view ? nextContext.view : undefined;
+  if (viewChanges !== null && viewChanges !== undefined) {
+    viewChanges = { ...viewChanges }; // copy the view to avoid unexpected mutations
+  }
+
   return {
     layersAdded,
     layersChanged,
     layersRemoved,
     layersReordered,
-    viewChanges,
+    ...(viewChanges !== undefined && { viewChanges }),
   };
 }