@geospatial-sdk/core 0.0.5-dev.0.sha-7ea9c6a → 0.0.5-dev.0.sha-9c03c7f

package/lib/utils/crs.test.ts

@@ -0,0 +1,128 @@
+import proj4 from "proj4";
+import {
+  ensureContextCrsReady,
+  ensureCrsRegistered,
+  ensureDiffCrsReady,
+  getContextCrsCodes,
+  getDiffCrsCodes,
+  getViewCrsCodes,
+} from "./crs.js";
+import { MapContextDiff } from "../model/map-context-diff.js";
+
+const emptyDiff: MapContextDiff = {
+  layersAdded: [],
+  layersRemoved: [],
+  layersChanged: [],
+  layersReordered: [],
+};
+
+describe("crs utils", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  describe("scanning", () => {
+    it("scans a view", () => {
+      expect(
+        getViewCrsCodes({
+          center: [1, 2, "EPSG:2154"],
+          zoom: 3,
+          projection: "EPSG:3857",
+          maxExtent: [0, 0, 1, 1, "EPSG:32631"],
+        }),
+      ).toEqual(new Set(["EPSG:2154", "EPSG:3857", "EPSG:32631"]));
+    });
+
+    it("scans a context", () => {
+      expect(
+        getContextCrsCodes({
+          layers: [],
+          view: { extent: [0, 0, 1, 1, "EPSG:2154"], projection: "EPSG:3857" },
+        }),
+      ).toEqual(new Set(["EPSG:2154", "EPSG:3857"]));
+      expect(getContextCrsCodes({ layers: [], view: null })).toEqual(new Set());
+    });
+
+    it("scans a diff", () => {
+      expect(
+        getDiffCrsCodes({
+          ...emptyDiff,
+          viewChanges: {
+            center: [0, 0, "EPSG:2154"],
+            zoom: 1,
+            projection: "EPSG:3857",
+          },
+        }),
+      ).toEqual(new Set(["EPSG:2154", "EPSG:3857"]));
+      expect(getDiffCrsCodes(emptyDiff)).toEqual(new Set());
+      expect(getDiffCrsCodes({ ...emptyDiff, viewChanges: null })).toEqual(
+        new Set(),
+      );
+    });
+  });
+
+  describe("registration", () => {
+    it("does not fetch known CRS", async () => {
+      const fetchMock = vi.fn();
+      vi.stubGlobal("fetch", fetchMock);
+      proj4.defs("EPSG:2154", "+proj=longlat +datum=WGS84 +no_defs");
+      await ensureCrsRegistered(
+        new Set(["EPSG:3857", "EPSG:4326", "EPSG:2154"]),
+      );
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it("fetches and registers a missing CRS", async () => {
+      const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve("+proj=longlat +datum=WGS84 +no_defs"),
+      });
+      vi.stubGlobal("fetch", fetchMock);
+      await ensureCrsRegistered(new Set(["EPSG:9999001"]));
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://spatialreference.org/ref/epsg/9999001/ogcwkt/",
+      );
+      expect(proj4.defs("EPSG:9999001")).toBeTruthy();
+    });
+
+    it("throws if the response is not ok", async () => {
+      vi.stubGlobal(
+        "fetch",
+        vi.fn().mockResolvedValue({ ok: false, status: 404 }),
+      );
+      await expect(
+        ensureCrsRegistered(new Set(["EPSG:9999002"])),
+      ).rejects.toThrow(/Could not find a definition for CRS "EPSG:9999002"/);
+    });
+
+    it("throws if the request fails", async () => {
+      vi.stubGlobal("fetch", () => Promise.reject(new Error("offline")));
+      await expect(
+        ensureCrsRegistered(new Set(["EPSG:9999003"])),
+      ).rejects.toThrow(/EPSG:9999003.*offline/);
+    });
+
+    it("throws on an invalid code", async () => {
+      await expect(ensureCrsRegistered(new Set(["foo"]))).rejects.toThrow(
+        /Could not find a definition for CRS "foo"/,
+      );
+    });
+
+    it("checks the CRS of a context and of a diff", async () => {
+      vi.stubGlobal("fetch", () => Promise.reject(new Error("offline")));
+      await expect(
+        ensureContextCrsReady({
+          layers: [],
+          view: { center: [0, 0], zoom: 1, projection: "EPSG:9999004" },
+        }),
+      ).rejects.toThrow(/EPSG:9999004/);
+      await expect(
+        ensureDiffCrsReady({
+          ...emptyDiff,
+          viewChanges: { center: [0, 0], zoom: 1, projection: "EPSG:9999005" },
+        }),
+      ).rejects.toThrow(/EPSG:9999005/);
+      await expect(ensureDiffCrsReady(emptyDiff)).resolves.toBeUndefined();
+    });
+  });
+});

package/lib/utils/crs.ts

@@ -0,0 +1,102 @@
+import proj4 from "proj4";
+import { DEFAULT_MAP_VIEW_CRS } from "../constant/projections.js";
+import {
+  CrsIdentifier,
+  MapContext,
+  MapContextView,
+} from "../model/map-context.js";
+import { MapContextDiff } from "../model/map-context-diff.js";
+import { getCrs } from "./coordinates.js";
+
+/**
+ * Returns the CRS codes referenced by a view (display CRS, center, extent, max extent)
+ */
+export function getViewCrsCodes(view: MapContextView): Set<CrsIdentifier> {
+  const codes = new Set<CrsIdentifier>([
+    view.projection ?? DEFAULT_MAP_VIEW_CRS,
+  ]);
+  if ("center" in view && view.center) codes.add(getCrs(view.center));
+  if ("extent" in view && view.extent) codes.add(getCrs(view.extent));
+  if (view.maxExtent) codes.add(getCrs(view.maxExtent));
+  return codes;
+}
+
+/**
+ * Returns all the CRS codes used in a map context
+ */
+export function getContextCrsCodes(context: MapContext): Set<CrsIdentifier> {
+  // TODO: check for geometries (e.g. GeoJSON)
+
+  if (!context.view) return new Set();
+  return getViewCrsCodes(context.view);
+}
+
+/**
+ * Returns all the CRS codes used in a map context diff
+ */
+export function getDiffCrsCodes(diff: MapContextDiff): Set<CrsIdentifier> {
+  // TODO: check for geometries (e.g. GeoJSON)
+
+  if (!diff.viewChanges) return new Set();
+  return getViewCrsCodes(diff.viewChanges);
+}
+
+function isRegistered(code: CrsIdentifier): boolean {
+  // consider Web Mercator and Geographic as known
+  if (code === "EPSG:3857" || code === "EPSG:4326") return true;
+  return !!proj4.defs(code);
+}
+
+async function registerCrs(code: CrsIdentifier): Promise<void> {
+  if (typeof code !== "string" || !code.includes(":")) {
+    throw new Error(`Invalid code`);
+  }
+  const [authority, num] = code.toLowerCase().split(":", 2);
+  const response = await fetch(
+    `https://spatialreference.org/ref/${authority}/${num}/ogcwkt/`,
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Unexpected response from spatialreference.org: ${response.status}`,
+    );
+  }
+  const def = await response.text();
+  proj4.defs(code, def);
+}
+
+/**
+ * Makes sure all given CRS codes are registered, looking up the missing ones.
+ * @throws Error if the definition of a CRS cannot be fetched
+ */
+export async function ensureCrsRegistered(
+  codes: Set<CrsIdentifier>,
+): Promise<void> {
+  const missing = Array.from(codes).filter((code) => !isRegistered(code));
+  await Promise.all(
+    missing.map(async (code) => {
+      try {
+        await registerCrs(code);
+      } catch (e) {
+        throw new Error(
+          `Could not find a definition for CRS "${code}": ${(e as Error)?.message ?? e}`,
+        );
+      }
+    }),
+  );
+}
+
+/**
+ * Makes sure all CRS used in a map context are registered
+ * @throws Error if the definition of a CRS cannot be fetched
+ */
+export function ensureContextCrsReady(context: MapContext): Promise<void> {
+  return ensureCrsRegistered(getContextCrsCodes(context));
+}
+
+/**
+ * Makes sure all CRS used in a map context diff are registered
+ * @throws Error if the definition of a CRS cannot be fetched
+ */
+export function ensureDiffCrsReady(diff: MapContextDiff): Promise<void> {
+  return ensureCrsRegistered(getDiffCrsCodes(diff));
+}

package/lib/utils/geojson.test.ts

@@ -0,0 +1,208 @@
+import {
+  ensureGeojson,
+  getExtentFromGeojson,
+  getExtentFromGeometry,
+} from "./geojson.js";
+import type {
+  Feature,
+  FeatureCollection,
+  Geometry,
+  GeometryCollection,
+  LineString,
+  MultiLineString,
+  MultiPoint,
+  MultiPolygon,
+  Point,
+  Polygon,
+} from "geojson";
+
+describe("geojson utils", () => {
+  describe("ensureGeojson", () => {
+    it("should return the same object if it is a valid GeoJSON", () => {
+      const geojson = {
+        type: "FeatureCollection",
+        features: [],
+      } as FeatureCollection;
+      expect(ensureGeojson(geojson)).toBe(geojson);
+    });
+
+    it("should parse a GeoJSON string into an object", () => {
+      const geojsonString = JSON.stringify({
+        type: "FeatureCollection",
+        features: [],
+      });
+      expect(ensureGeojson(geojsonString)).toEqual({
+        type: "FeatureCollection",
+        features: [],
+      });
+    });
+
+    it("should throw if the geojson string is invalid", () => {
+      const invalidGeojson = "hello: world";
+      expect(() => ensureGeojson(invalidGeojson)).toThrow(
+        "Invalid GeoJSON string: SyntaxError: Unexpected token 'h', \"hello: world\" is not valid JSON",
+      );
+    });
+  });
+
+  describe("getExtentFromGeometry", () => {
+    const polygon: Polygon = {
+      type: "Polygon",
+      coordinates: [
+        [
+          [1, 1],
+          [1, 4],
+          [4, 4],
+          [4, 1],
+          [1, 1],
+        ],
+        [
+          [2, 2],
+          [2, 3],
+          [130, 3],
+          [130, 2],
+          [2, 2],
+        ],
+      ],
+    };
+    const lineString: LineString = {
+      type: "LineString",
+      coordinates: [
+        [10, 20],
+        [20, 20],
+        [50, 10],
+        [100, -5],
+        [-100, -100],
+      ],
+    };
+    const point: Point = {
+      type: "Point",
+      coordinates: [50, -200],
+    };
+
+    it("computes the bounding box correctly for a Polygon", () => {
+      const bbox = getExtentFromGeometry(polygon);
+      expect(bbox).toEqual([1, 1, 130, 4]);
+    });
+    it("computes the bounding box correctly for a LineString", () => {
+      const bbox = getExtentFromGeometry(lineString);
+      expect(bbox).toEqual([-100, -100, 100, 20]);
+    });
+    it("computes the bounding box correctly for a Point", () => {
+      const bbox = getExtentFromGeometry(point);
+      expect(bbox).toEqual([50, -200, 50, -200]);
+    });
+    it("computes the bounding box correctly for a MultiPolygon", () => {
+      const multiPolygon: MultiPolygon = {
+        type: "MultiPolygon",
+        coordinates: [
+          polygon.coordinates,
+          [
+            [
+              [-20, -20],
+              [-20, 30],
+              [20, 30],
+              [20, -20],
+              [-20, -20],
+            ],
+          ],
+        ],
+      };
+      const bbox = getExtentFromGeometry(multiPolygon);
+      expect(bbox).toEqual([-20, -20, 130, 30]);
+    });
+    it("computes the bounding box correctly for a MultiLineString", () => {
+      const multiLineString: MultiLineString = {
+        type: "MultiLineString",
+        coordinates: [
+          lineString.coordinates,
+          [
+            [-2, -2],
+            [2, 3],
+            [150, 200],
+            [100, 10],
+          ],
+        ],
+      };
+      const bbox = getExtentFromGeometry(multiLineString);
+      expect(bbox).toEqual([-100, -100, 150, 200]);
+    });
+    it("computes the bounding box correctly for a MultiPoint", () => {
+      const multiPoint: MultiPoint = {
+        type: "MultiPoint",
+        coordinates: [point.coordinates, [200, 300]],
+      };
+      const bbox = getExtentFromGeometry(multiPoint);
+      expect(bbox).toEqual([50, -200, 200, 300]);
+    });
+    it("computes the bounding box correctly for a GeometryCollection", () => {
+      const geom: GeometryCollection = {
+        type: "GeometryCollection",
+        geometries: [lineString, polygon, point],
+      };
+      const bbox = getExtentFromGeometry(geom);
+      expect(bbox).toEqual([-100, -200, 130, 20]);
+    });
+  });
+
+  describe("getExtentFromGeoJSON", () => {
+    it("computes the combined extent of a FeatureCollection", () => {
+      const geojson: FeatureCollection<Geometry | null> = {
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            properties: {},
+            geometry: { type: "Point", coordinates: [5, 10] },
+          },
+          {
+            type: "Feature",
+            properties: {},
+            geometry: { type: "Point", coordinates: [-2, 20] },
+          },
+          {
+            type: "Feature",
+            properties: {},
+            geometry: null,
+          },
+        ],
+      };
+
+      expect(getExtentFromGeojson(geojson)).toEqual([-2, 10, 5, 20]);
+    });
+
+    it("computes the extent of a Feature", () => {
+      const feature: Feature<Point> = {
+        type: "Feature",
+        properties: {},
+        geometry: { type: "Point", coordinates: [5, 10] },
+      };
+
+      expect(getExtentFromGeojson(feature)).toEqual([5, 10, 5, 10]);
+    });
+
+    it("computes the extent of a Geometry", () => {
+      const geometry: Point = {
+        type: "Point",
+        coordinates: [-2, 20],
+      };
+
+      expect(getExtentFromGeojson(geometry)).toEqual([-2, 20, -2, 20]);
+    });
+
+    it("returns an empty extent for a Feature with no geometry", () => {
+      const feature: Feature<null> = {
+        type: "Feature",
+        properties: {},
+        geometry: null,
+      };
+
+      expect(getExtentFromGeojson(feature)).toEqual([
+        Infinity,
+        Infinity,
+        -Infinity,
+        -Infinity,
+      ]);
+    });
+  });
+});

package/lib/utils/geojson.ts

@@ -0,0 +1,133 @@
+import type { Feature, FeatureCollection, Geometry, Position } from "geojson";
+import { Extent } from "../model/index.js";
+import { extend } from "./coordinates.js";
+
+export function ensureGeojson(
+  value: FeatureCollection<Geometry | null> | string,
+): FeatureCollection<Geometry | null> {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value) as FeatureCollection;
+    } catch (e) {
+      throw new Error(`Invalid GeoJSON string: ${e}`);
+    }
+  }
+  return value;
+}
+
+/**
+ * This assumes the geometry is in EPSG:4326
+ * TODO: support other CRSs
+ * @param geometry
+ */
+export function getExtentFromGeometry(geometry: Geometry): Extent {
+  // use the bounding box if specified in the GeoJSON object
+  if (geometry.bbox) {
+    return geometry.bbox.length > 5
+      ? [
+          geometry.bbox[0],
+          geometry.bbox[1],
+          geometry.bbox[3],
+          geometry.bbox[4] as number,
+        ]
+      : (geometry.bbox as Extent);
+  }
+
+  const coordinatesReducer = (prev: Extent, coords: Position) => {
+    if (coords[0] < prev[0]) {
+      prev[0] = coords[0];
+    }
+    if (coords[1] < prev[1]) {
+      prev[1] = coords[1];
+    }
+    if (coords[0] > prev[2]) {
+      prev[2] = coords[0];
+    }
+    if (coords[1] > prev[3]) {
+      prev[3] = coords[1];
+    }
+    return prev;
+  };
+  const coordinatesArrayReducer = (prev: Extent, coordsArray: Position[]) => {
+    const bbox = coordsArray.reduce(coordinatesReducer, [
+      Infinity,
+      Infinity,
+      -Infinity,
+      -Infinity,
+    ]);
+    return extend(prev, bbox);
+  };
+
+  const initialExtent = [Infinity, Infinity, -Infinity, -Infinity] as Extent;
+
+  switch (geometry.type) {
+    case "MultiPolygon":
+      return geometry.coordinates.reduce((prev, polygonCoords) => {
+        const bbox = polygonCoords.reduce(coordinatesArrayReducer, [
+          Infinity,
+          Infinity,
+          -Infinity,
+          -Infinity,
+        ]);
+        return extend(prev, bbox);
+      }, initialExtent);
+    case "GeometryCollection":
+      return geometry.geometries.reduce((prev, geom) => {
+        const bbox = getExtentFromGeometry(geom);
+        return extend(prev, bbox);
+      }, initialExtent);
+    case "Polygon":
+    case "MultiLineString":
+      return geometry.coordinates.reduce(coordinatesArrayReducer, [
+        Infinity,
+        Infinity,
+        -Infinity,
+        -Infinity,
+      ]);
+    case "LineString":
+    case "MultiPoint":
+      return geometry.coordinates.reduce<Extent>(coordinatesReducer, [
+        Infinity,
+        Infinity,
+        -Infinity,
+        -Infinity,
+      ]);
+    case "Point":
+      return coordinatesReducer(
+        [Infinity, Infinity, -Infinity, -Infinity],
+        geometry.coordinates,
+      );
+  }
+}
+
+/**
+ * This assumes the geometry is in EPSG:4326
+ * TODO: support other CRSs
+ * @param geojson
+ */
+export function getExtentFromGeojson(
+  geojson:
+    FeatureCollection<Geometry | null> | Feature<Geometry | null> | Geometry,
+): Extent {
+  const empty = [Infinity, Infinity, -Infinity, -Infinity] as Extent;
+  if ("type" in geojson) {
+    switch (geojson.type) {
+      case "FeatureCollection":
+        return geojson.features.reduce((prev, feature) => {
+          if (feature.geometry) {
+            const bbox = getExtentFromGeometry(feature.geometry);
+            return extend(prev, bbox);
+          }
+          return prev;
+        }, empty);
+      case "Feature":
+        if (geojson.geometry) {
+          return getExtentFromGeometry(geojson.geometry);
+        }
+        return empty;
+      default:
+        return getExtentFromGeometry(geojson);
+    }
+  }
+  return empty;
+}

package/lib/utils/index.ts

@@ -6,6 +6,14 @@
 export * from "./url.js";
 export * from "./freeze.js";
 export * from "./hash.js";
+export {
+  getCrs,
+  setCrs,
+  transform,
+  toGeographic,
+  equals,
+  extend,
+} from "./coordinates.js";
 export { computeMapContextDiff } from "./map-context-diff.js";
 export {
   getLayerPosition,
@@ -18,3 +26,9 @@ export {
 export { updateLayer } from "./map-context-layer.js";
 export { createViewFromLayer } from "./view.js";
 export * from "./style.js";
+export {
+  ensureGeojson,
+  getExtentFromGeojson,
+  getExtentFromGeometry,
+} from "./geojson.js";
+export { ensureContextCrsReady, ensureDiffCrsReady } from "./crs.js";

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

@@ -10,7 +10,7 @@ import {
   SAMPLE_LAYER6,
   SAMPLE_LAYER7,
 } from "../../fixtures/map-context.fixtures.js";
-import { beforeEach, describe, expect, it } from "vitest";
+import { DEFAULT_MAP_VIEW_CRS } from "../constant/projections.js";
 
 describe("Context diff utils", () => {
   describe("computeMapContextDiff", () => {
@@ -330,6 +330,73 @@ describe("Context diff utils", () => {
           });
         });
       });
+
+      describe("changing projection from default to custom", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [5, 10],
+              zoom: 3,
+            },
+          };
+          contextNew = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [5, 10],
+              zoom: 3,
+              projection: "EPSG:1234",
+            },
+          };
+        });
+        it("output the correct diff", () => {
+          diff = computeMapContextDiff(contextNew, contextOld);
+          expect(diff).toEqual({
+            layersAdded: [],
+            layersChanged: [],
+            layersRemoved: [],
+            layersReordered: [],
+            viewChanges: {
+              center: [5, 10],
+              zoom: 3,
+              projection: "EPSG:1234",
+            },
+          });
+        });
+      });
+      describe("changing projection from custom to default", () => {
+        beforeEach(() => {
+          contextOld = {
+            ...SAMPLE_CONTEXT,
+            view: {
+              center: [5, 10],
+              zoom: 3,
+              projection: "EPSG:1234",
+            },
+          };
+          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,
+              projection: DEFAULT_MAP_VIEW_CRS,
+            },
+          });
+        });
+      });
     });
 
     describe("combined changes", () => {

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

@@ -7,6 +7,7 @@ import {
   MapContextLayerReordered,
 } from "../model/index.js";
 import { isLayerSame, isLayerSameAndUnchanged } from "./map-context-layer.js";
+import { DEFAULT_MAP_VIEW_CRS } from "../constant/projections.js";
 
 /**
  * The following logic is produced by identifying layers in both context
@@ -99,6 +100,16 @@ export function computeMapContextDiff(
     nextContext.view !== previousContext.view ? nextContext.view : undefined;
   if (viewChanges !== null && viewChanges !== undefined) {
     viewChanges = { ...viewChanges }; // copy the view to avoid unexpected mutations
+
+    // only keep the projection if it changed between the two contexts
+    const prevProjection =
+      previousContext.view?.projection ?? DEFAULT_MAP_VIEW_CRS;
+    const nextProjection = nextContext.view?.projection ?? DEFAULT_MAP_VIEW_CRS;
+    if (nextProjection === prevProjection) {
+      delete viewChanges.projection;
+    } else {
+      viewChanges.projection = nextProjection;
+    }
   }
 
   return {