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

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

@@ -1,303 +1,167 @@
 import { describe } from "vitest";
 import {
-  getLayerHash,
+  addLayerToContext,
+  changeLayerPositionInContext,
   getLayerPosition,
-  isLayerSame,
-  isLayerSameAndUnchanged,
-} from "./map-context";
-import { MapContext } from "../model";
+  removeLayerFromContext,
+  replaceLayerInContext,
+  updateLayerInContext,
+} from "./map-context.js";
+import { MapContext, MapContextLayer } from "../model/index.js";
 import {
   SAMPLE_CONTEXT,
   SAMPLE_LAYER1,
   SAMPLE_LAYER2,
-} from "../../fixtures/map-context.fixtures";
+  SAMPLE_LAYER3,
+} from "../../fixtures/map-context.fixtures.js";
 
 describe("Map context utils", () => {
-  describe("isLayerSame", () => {
-    describe("layers with id", () => {
-      it("compares non-strictly by id", () => {
-        expect(
-          isLayerSame(
-            { ...SAMPLE_LAYER1, id: "a" },
-            { ...SAMPLE_LAYER1, id: "b" },
-          ),
-        ).toBe(false);
-        expect(
-          isLayerSame(
-            { ...SAMPLE_LAYER1, id: "ab" },
-            { ...SAMPLE_LAYER2, id: "ab" },
-          ),
-        ).toBe(true);
-        expect(
-          isLayerSame(
-            { ...SAMPLE_LAYER1, id: 1 },
-            { ...SAMPLE_LAYER2, id: "01" },
-          ),
-        ).toBe(true);
-        expect(
-          isLayerSame({ ...SAMPLE_LAYER1, id: 1 }, { ...SAMPLE_LAYER2, id: 1 }),
-        ).toBe(true);
-        expect(
-          isLayerSame({ ...SAMPLE_LAYER1, id: 1 }, { ...SAMPLE_LAYER1, id: 2 }),
-        ).toBe(false);
-      });
+  describe("getLayerPosition", () => {
+    it("returns the index of the layer in the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      expect(getLayerPosition(context, SAMPLE_LAYER1)).toBe(0);
+      expect(getLayerPosition(context, SAMPLE_LAYER2)).toBe(1);
     });
-    describe("layers without id", () => {
-      it("compares by properties", () => {
-        expect(isLayerSame(SAMPLE_LAYER1, SAMPLE_LAYER1)).toBe(true);
-        expect(
-          isLayerSame(SAMPLE_LAYER1, { ...SAMPLE_LAYER1, name: "abc" }),
-        ).toBe(false);
-        expect(
-          isLayerSame(
-            {
-              ...SAMPLE_LAYER1,
-              url: "http://abc.org",
-              name: SAMPLE_LAYER1.name,
-            },
-            { ...SAMPLE_LAYER1, url: "http://abc.org" },
-          ),
-        ).toBe(true);
-        expect(isLayerSame(SAMPLE_LAYER1, SAMPLE_LAYER2)).toBe(false);
-      });
-      it("ignores extras prop", () => {
-        expect(
-          isLayerSame(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            extras: { otherProp: "abc" },
-          }),
-        ).toBe(true);
-        expect(
-          isLayerSame(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            extras: undefined,
-          }),
-        ).toBe(true);
-        const { extras, ...layer } = SAMPLE_LAYER1;
-        expect(isLayerSame(SAMPLE_LAYER1, layer)).toBe(true);
-      });
+  });
+  describe("addLayerToContext", () => {
+    it("adds a layer to the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1],
+      };
+      const newLayer = { ...SAMPLE_LAYER2, name: "newLayer" };
+      const newContext = addLayerToContext(context, newLayer);
+      expect(newContext.layers).toEqual([SAMPLE_LAYER1, newLayer]);
     });
-    describe("layers with and without id", () => {
-      it("compares by properties", () => {
-        expect(
-          isLayerSame(SAMPLE_LAYER1, { ...SAMPLE_LAYER1, id: "123" }),
-        ).toBe(false);
-        expect(
-          isLayerSame(
-            { ...SAMPLE_LAYER1, id: "123" },
-            { id: "123", ...SAMPLE_LAYER1, name: SAMPLE_LAYER1.name },
-          ),
-        ).toBe(true);
-      });
+    it("adds a layer at a specific position", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const newLayer = { ...SAMPLE_LAYER2, name: "newLayer" };
+      const newContext = addLayerToContext(context, newLayer, 1);
+      expect(newContext.layers).toEqual([
+        SAMPLE_LAYER1,
+        newLayer,
+        SAMPLE_LAYER2,
+      ]);
     });
   });
-
-  describe("isLayerSameAndUnchanged", () => {
-    describe("layers with id", () => {
-      it("compares non-strictly by id and version field", () => {
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: "a" },
-            { ...SAMPLE_LAYER1, id: "b" },
-          ),
-        ).toBe(false);
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: "a" },
-            { ...SAMPLE_LAYER2, id: "a" },
-          ),
-        ).toBe(true);
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: "ab", version: 2 },
-            { ...SAMPLE_LAYER2, id: "ab", version: 2 },
-          ),
-        ).toBe(true);
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: "ab", version: 2 },
-            { ...SAMPLE_LAYER1, id: "ab", version: 1 },
-          ),
-        ).toBe(false);
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: 1 },
-            { ...SAMPLE_LAYER1, id: "01", version: 3 },
-          ),
-        ).toBe(false);
-      });
+  describe("removeLayerFromContext", () => {
+    it("removes a layer from the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const newContext = removeLayerFromContext(context, SAMPLE_LAYER1);
+      expect(newContext.layers).toEqual([SAMPLE_LAYER2]);
     });
-    describe("layers without id", () => {
-      it("compares by properties, including extras", () => {
-        expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, SAMPLE_LAYER1)).toBe(
-          true,
-        );
-        expect(
-          isLayerSameAndUnchanged(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            name: "abc",
-          }),
-        ).toBe(false);
-        expect(
-          isLayerSameAndUnchanged(
-            {
-              ...SAMPLE_LAYER1,
-              url: "http://abc.org",
-              name: SAMPLE_LAYER1.name,
-            },
-            { ...SAMPLE_LAYER1, url: "http://abc.org" },
-          ),
-        ).toBe(true);
-        expect(
-          isLayerSameAndUnchanged(
-            {
-              ...SAMPLE_LAYER1,
-              opacity: 1,
-            },
-            SAMPLE_LAYER1,
-          ),
-        ).toBe(false);
-        expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, SAMPLE_LAYER2)).toBe(
-          false,
-        );
-      });
-      it("takes into account extras prop", () => {
-        expect(
-          isLayerSameAndUnchanged(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            extras: { otherProp: "abc" },
-          }),
-        ).toBe(false);
-        expect(
-          isLayerSameAndUnchanged(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            extras: undefined,
-          }),
-        ).toBe(false);
-        const { extras, ...layer } = SAMPLE_LAYER1;
-        expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, layer)).toBe(false);
-      });
+  });
+  describe("replaceLayerInContext", () => {
+    it("replaces a layer in the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const replacementLayer = { ...SAMPLE_LAYER3 };
+      const existingLayer = { ...SAMPLE_LAYER1 };
+      const newContext = replaceLayerInContext(
+        context,
+        existingLayer,
+        replacementLayer,
+      );
+      expect(newContext.layers).toEqual([replacementLayer, SAMPLE_LAYER2]);
     });
-    describe("layers with and without id", () => {
-      it("compares by properties", () => {
-        expect(
-          isLayerSameAndUnchanged(SAMPLE_LAYER1, {
-            ...SAMPLE_LAYER1,
-            id: "123",
-          }),
-        ).toBe(false);
-        expect(
-          isLayerSameAndUnchanged(
-            { ...SAMPLE_LAYER1, id: "123" },
-            { id: "123", ...SAMPLE_LAYER1, name: SAMPLE_LAYER1.name },
-          ),
-        ).toBe(true);
-      });
+  });
+  describe("changeLayerPositionInContext", () => {
+    it("changes the position of a layer in the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const newContext = changeLayerPositionInContext(
+        context,
+        SAMPLE_LAYER1,
+        1,
+      );
+      expect(newContext.layers).toEqual([SAMPLE_LAYER2, SAMPLE_LAYER1]);
     });
   });
 
-  describe("getLayerHash", () => {
-    it("works with serializable entities", () => {
-      expect(
-        getLayerHash({
-          ...SAMPLE_LAYER1,
-          extras: {
-            array: [11, 22, null, undefined],
-            object: {},
-            undef: undefined,
-          },
-        }),
-      ).toBeTypeOf("string");
+  describe("updateLayerInContext", () => {
+    it("updates properties of a layer in the context (without id)", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const newContext = updateLayerInContext(context, SAMPLE_LAYER1, {
+        opacity: 0.8,
+        visibility: false,
+      });
+      expect(newContext.layers).toHaveLength(2);
+      expect(newContext.layers[0]).toEqual({
+        ...SAMPLE_LAYER1,
+        opacity: 0.8,
+        visibility: false,
+      });
+      expect(newContext.layers[1]).toBe(SAMPLE_LAYER2);
     });
-    it("ignores extra property by default", () => {
-      expect(
-        getLayerHash({
-          ...SAMPLE_LAYER1,
-          extras: {
-            array: [11, 22, null, undefined],
-            object: {},
-          },
-        }),
-      ).toEqual(
-        getLayerHash({
-          ...SAMPLE_LAYER1,
-          extras: { hello: "world" },
-        }),
-      );
+    it("does not modify the original context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
+      };
+      const newContext = updateLayerInContext(context, SAMPLE_LAYER1, {
+        opacity: 0.8,
+        visibility: false,
+      });
+      expect(newContext).not.toBe(context);
+      expect(newContext.layers).not.toBe(context.layers);
     });
-    it("works with non-serializable entities (but they are ignored)", () => {
-      const hash = getLayerHash(
+    it("updates properties of a layer with id in the context", () => {
+      const context: MapContext = {
+        ...SAMPLE_CONTEXT,
+        layers: [
+          SAMPLE_LAYER1,
+          SAMPLE_LAYER2,
+          { ...SAMPLE_LAYER3, id: "myLayer", version: 3 },
+        ],
+      };
+      const newContext = updateLayerInContext(
+        context,
+        // this is an empty layer that should not be used because we should track the layer by id in the context
+        {
+          id: "myLayer",
+        } as MapContextLayer,
         {
-          ...SAMPLE_LAYER1,
-          extras: {
-            func: () => 123,
-            canvas: document.createElement("canvas"),
-          },
+          opacity: 0.8,
+          visibility: false,
         },
-        true,
-      );
-      expect(hash).toBeTypeOf("string");
-      expect(hash).toEqual(
-        getLayerHash(
-          {
-            ...SAMPLE_LAYER1,
-            extras: {
-              func: () => 456,
-              canvas: document.createElement("div"),
-            },
-          },
-          true,
-        ),
-      );
-      expect(hash).not.toEqual(
-        getLayerHash(
-          {
-            ...SAMPLE_LAYER1,
-            extras: {},
-          },
-          true,
-        ),
-      );
-    });
-    it("does not take into account properties order", () => {
-      expect(
-        getLayerHash(
-          {
-            type: "wms",
-            url: "http://abc.org/wms",
-            name: "myLayer",
-            extras: {
-              array: [1, 2, 3],
-              object: {},
-            },
-          },
-          true,
-        ),
-      ).toEqual(
-        getLayerHash(
-          {
-            extras: {
-              array: [1, 2, 3],
-              object: {},
-            },
-            url: "http://abc.org/wms",
-            type: "wms",
-            name: "myLayer",
-          },
-          true,
-        ),
       );
+      expect(newContext.layers).toHaveLength(3);
+      expect(newContext.layers[2]).toEqual({
+        ...SAMPLE_LAYER3,
+        id: "myLayer",
+        version: 4,
+        opacity: 0.8,
+        visibility: false,
+      });
+      expect(newContext.layers[0]).toBe(SAMPLE_LAYER1);
+      expect(newContext.layers[1]).toBe(SAMPLE_LAYER2);
     });
-  });
-
-  describe("getLayerPosition", () => {
-    it("returns the index of the layer in the context", () => {
+    it("changes the context ref even if the layer is not found (the layers array is untouched)", () => {
       const context: MapContext = {
         ...SAMPLE_CONTEXT,
         layers: [SAMPLE_LAYER1, SAMPLE_LAYER2],
       };
-      expect(getLayerPosition(context, SAMPLE_LAYER1)).toBe(0);
-      expect(getLayerPosition(context, SAMPLE_LAYER2)).toBe(1);
+      const newContext = updateLayerInContext(context, SAMPLE_LAYER3, {
+        opacity: 0.8,
+      });
+      expect(newContext).not.toBe(context);
+      expect(newContext.layers).toBe(context.layers);
     });
   });
 });

package/lib/utils/map-context.ts

@@ -1,51 +1,120 @@
-import { MapContext, MapContextLayer } from "../model";
-
-export function getLayerHash(
-  layer: MapContextLayer,
-  includeExtras = false,
-): string {
-  function getHash(input: unknown): string {
-    if (input instanceof Object) {
-      const obj: Record<string, string> = {};
-      const keys = Object.keys(input).sort();
-      for (const key of keys) {
-        if (!includeExtras && key === "extras") continue;
-        obj[key] = getHash(input[key as keyof typeof input]);
-      }
-      const hash = JSON.stringify(obj)
-        .split("")
-        .reduce((prev, curr) => (prev << 5) - prev + curr.charCodeAt(0), 0);
-      return (hash >>> 0).toString();
-    } else {
-      return JSON.stringify(input);
-    }
+import { MapContext, MapContextLayer } from "../model/index.js";
+import { isLayerSame, updateLayer } from "./map-context-layer.js";
+
+export function getLayerPosition(
+  context: MapContext,
+  layerModel: MapContextLayer,
+): number {
+  return context.layers.findIndex((l) => isLayerSame(layerModel, l));
+}
+
+/**
+ * Adds a layer to the context at a specific position or at the end if no position is specified.
+ *
+ * @param context The current map context.
+ * @param layerModel The layer to be added.
+ * @param [position] The position at which to add the layer. If not specified, the layer is added at the end.
+ * @returns The new map context with the added layer.
+ */
+
+export function addLayerToContext(
+  context: MapContext,
+  layerModel: MapContextLayer,
+  position?: number,
+): MapContext {
+  const newContext = { ...context, layers: [...context.layers] };
+  if (position !== undefined) {
+    newContext.layers.splice(position, 0, layerModel);
+  } else {
+    newContext.layers.push(layerModel);
   }
-  return getHash(layer);
+  return newContext;
 }
 
-export function isLayerSame(
-  layerA: MapContextLayer,
-  layerB: MapContextLayer,
-): boolean {
-  if ("id" in layerA && "id" in layerB) {
-    return layerA.id == layerB.id;
+/**
+ * Removes a layer from the context.
+ *
+ * @param context The current map context.
+ * @param layerModel The layer to be removed.
+ * @returns The new map context without the removed layer.
+ */
+
+export function removeLayerFromContext(
+  context: MapContext,
+  layerModel: MapContextLayer,
+): MapContext {
+  const newContext = { ...context, layers: [...context.layers] };
+  const position = getLayerPosition(context, layerModel);
+  if (position >= 0) {
+    newContext.layers.splice(position, 1);
   }
-  return getLayerHash(layerA) === getLayerHash(layerB);
+  return newContext;
 }
 
-export function isLayerSameAndUnchanged(
-  layerA: MapContextLayer,
-  layerB: MapContextLayer,
-): boolean {
-  if ("id" in layerA && "id" in layerB) {
-    return layerA.id == layerB.id && layerA.version == layerB.version;
+/**
+ * Replaces a layer in the context with a new layer.
+ *
+ * @param context The current map context.
+ * @param layerModel The layer to be replaced.
+ * @param replacement The new layer that will replace the old one.
+ * @returns The new map context with the replaced layer.
+ */
+
+export function replaceLayerInContext(
+  context: MapContext,
+  layerModel: MapContextLayer,
+  replacement: MapContextLayer,
+): MapContext {
+  const newContext = { ...context, layers: [...context.layers] };
+  const position = getLayerPosition(context, layerModel);
+  if (position >= 0) {
+    newContext.layers.splice(position, 1, replacement);
   }
-  return getLayerHash(layerA, true) === getLayerHash(layerB, true);
+  return newContext;
 }
 
-export function getLayerPosition(
+/**
+ * Updates an existing layer in the context by applying partial changes.
+ *
+ * Note: setting a property to `undefined` in the partial layer updates will remove that
+ * property from the existing layer.
+ *
+ * @param context The current map context.
+ * @param layerModel The layer to be updated.
+ * @param layerUpdates A partial layer object containing the properties to update on the existing layer.
+ * @returns The new map context with the updated layer.
+ */
+
+export function updateLayerInContext(
   context: MapContext,
   layerModel: MapContextLayer,
-): number {
-  return context.layers.findIndex((l) => isLayerSame(layerModel, l));
+  layerUpdates: Partial<MapContextLayer>,
+): MapContext {
+  const position = getLayerPosition(context, layerModel);
+  if (position >= 0) {
+    const existing = context.layers[position];
+    const updated = updateLayer(existing, layerUpdates);
+    return replaceLayerInContext(context, layerModel, updated);
+  }
+  // we're building a new context so that the reference is changed anyway; this is done to be
+  // consistent with other utilities that always change the context reference even if the layer wasn't found
+  return { ...context };
+}
+
+/**
+ * Changes the position of a layer in the context.
+ *
+ * @param context The current map context.
+ * @param layerModel The layer whose position is to be changed.
+ * @param position The new position for the layer.
+ * @returns The new map context with the layer moved to the new position.
+ */
+
+export function changeLayerPositionInContext(
+  context: MapContext,
+  layerModel: MapContextLayer,
+  position: number,
+): MapContext {
+  const newContext = removeLayerFromContext(context, layerModel);
+  return addLayerToContext(newContext, layerModel, position);
 }

package/lib/utils/style.ts

@@ -0,0 +1,71 @@
+import type { FlatStyleLike } from "ol/style/flat.js";
+
+const color = "rgb(0, 0, 255)";
+const fillColor = "rgba(0, 0, 255, 0.25)";
+export const defaultStyle: FlatStyleLike = [
+  {
+    filter: ["==", ["geometry-type"], "LineString"],
+    style: [
+      {
+        "stroke-color": "white",
+        "stroke-width": 6,
+      },
+      {
+        "stroke-color": color,
+        "stroke-width": 2,
+      },
+    ],
+  },
+  {
+    filter: ["==", ["geometry-type"], "Polygon"],
+    style: {
+      "stroke-color": "white",
+      "stroke-width": 2,
+      "fill-color": fillColor,
+    },
+  },
+  {
+    filter: ["==", ["geometry-type"], "Point"],
+    style: {
+      "circle-fill-color": color,
+      "circle-radius": 7,
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 2,
+    },
+  },
+];
+
+const hlColor = "rgb(0, 0, 255)";
+const hlFillColor = "rgba(0, 0, 255, 0.25)";
+export const defaultHighlightStyle: FlatStyleLike = [
+  {
+    filter: ["==", ["geometry-type"], "LineString"],
+    style: [
+      {
+        "stroke-color": "white",
+        "stroke-width": 8,
+      },
+      {
+        "stroke-color": hlColor,
+        "stroke-width": 3,
+      },
+    ],
+  },
+  {
+    filter: ["==", ["geometry-type"], "Polygon"],
+    style: {
+      "stroke-color": "white",
+      "stroke-width": 3,
+      "fill-color": hlFillColor,
+    },
+  },
+  {
+    filter: ["==", ["geometry-type"], "Point"],
+    style: {
+      "circle-fill-color": hlColor,
+      "circle-radius": 8,
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 3,
+    },
+  },
+];

package/lib/utils/url.test.ts

@@ -1,4 +1,4 @@
-import { removeSearchParams } from "./url";
+import { removeSearchParams } from "./url.js";
 
 describe("URL utils", () => {
   describe("removeSearchParams", () => {