@geospatial-sdk/core 0.0.5-dev.0.sha-9f850cf → 0.0.5-dev.0.sha-ba0cd0b

package/dist/utils/map-context-diff.js

@@ -1,4 +1,5 @@
 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
  * and determining whether they have been added, removed, changed or reordered.
@@ -76,6 +77,15 @@ export function computeMapContextDiff(nextContext, previousContext) {
     let viewChanges = 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 {
         layersAdded,

package/dist/utils/view.d.ts

@@ -1,7 +1,7 @@
 import { MapContextLayer, MapContextView } from "../model/index.js";
 /**
- * Creates a view from a layer by extracting its geographic extent. The returned extent is
- * always expressed in EPSG:4326 (longitude/latitude) coordinates.
+ * Creates a view from a layer by extracting its extent. The returned extent is preferably
+ * returned in EPSG:4326; if not available, it will be returned in a CRS available for this layer
  *
  * @param layer - The map context layer to extract the extent from
  * @returns A Promise resolving to a `ViewByExtent` object, or `null` if the extent cannot be determined

package/dist/utils/view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../lib/utils/view.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,eAAe,EAKf,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAK3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAchC"}
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../lib/utils/view.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,eAAe,EAKf,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAI3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAgBhC"}

package/dist/utils/view.js

@@ -1,14 +1,11 @@
-import { transformExtent } from "ol/proj.js";
 import { WfsEndpoint, WmsEndpoint, WmtsEndpoint } from "@camptocamp/ogc-client";
 import { LONLAT_CRS_CODES } from "../constant/projections.js";
-import { fromEPSGCode } from "ol/proj/proj4.js";
-import GeoJSON from "ol/format/GeoJSON.js";
-import { extend } from "ol/extent.js";
 import GeoTIFF from "ol/source/GeoTIFF.js";
-const GEOJSON = new GeoJSON();
+import { ensureGeojson, getExtentFromGeojson } from "./geojson.js";
+import { setCrs, transform } from "./coordinates.js";
 /**
- * Creates a view from a layer by extracting its geographic extent. The returned extent is
- * always expressed in EPSG:4326 (longitude/latitude) coordinates.
+ * Creates a view from a layer by extracting its extent. The returned extent is preferably
+ * returned in EPSG:4326; if not available, it will be returned in a CRS available for this layer
  *
  * @param layer - The map context layer to extract the extent from
  * @returns A Promise resolving to a `ViewByExtent` object, or `null` if the extent cannot be determined
@@ -36,7 +33,9 @@ export async function createViewFromLayer(layer) {
         return await getWmtsLayerExtent(layer);
     }
     else if (layer.type === "geojson" && layer.data) {
-        return computeExtentFromGeojson(layer.data);
+        return {
+            extent: getExtentFromGeojson(ensureGeojson(layer.data)),
+        };
     }
     else if (layer.type === "wfs") {
         return await getWfsLayerExtent(layer);
@@ -48,19 +47,6 @@ export async function createViewFromLayer(layer) {
         throw new Error(`Unsupported layer type: ${layer.type}`);
     }
 }
-function computeExtentFromGeojson(data) {
-    const geojson = typeof data === "string" ? JSON.parse(data) : data;
-    const features = GEOJSON.readFeatures(geojson);
-    const extent = features.reduce((prev, curr) => {
-        const geom = curr.getGeometry();
-        if (!geom)
-            return prev;
-        return extend(prev, geom.getExtent());
-    }, [Infinity, Infinity, -Infinity, -Infinity]);
-    return {
-        extent,
-    };
-}
 async function getWmsLayerExtent(layer) {
     const endpoint = await new WmsEndpoint(layer.url).isReady();
     const { boundingBoxes } = endpoint.getLayerByName(layer.name);
@@ -68,18 +54,17 @@ async function getWmsLayerExtent(layer) {
         return null;
     }
     const lonLatCRS = Object.keys(boundingBoxes).find((crs) => LONLAT_CRS_CODES.includes(crs));
+    // give priority to lon/lat bounding boxes
     if (lonLatCRS) {
         return {
             extent: boundingBoxes[lonLatCRS],
         };
     }
-    else {
-        const availableEPSGCode = Object.keys(boundingBoxes)[0];
-        const proj = await fromEPSGCode(availableEPSGCode);
-        return {
-            extent: transformExtent(boundingBoxes[availableEPSGCode], proj, "EPSG:4326"),
-        };
-    }
+    // otherwise take the first extent and apply its CRS
+    const availableEPSGCode = Object.keys(boundingBoxes)[0];
+    return {
+        extent: [...boundingBoxes[availableEPSGCode], availableEPSGCode],
+    };
 }
 async function getWmtsLayerExtent(layer) {
     const endpoint = await new WmtsEndpoint(layer.url).isReady();
@@ -102,6 +87,7 @@ async function getWfsLayerExtent(layer) {
         extent: boundingBox,
     };
 }
+// TODO: DO NOT RELY ON OL FOR THIS!
 async function getGeotiffLayerExtent(layer) {
     const source = new GeoTIFF({
         sources: [{ url: layer.url }],
@@ -115,7 +101,8 @@ async function getGeotiffLayerExtent(layer) {
                     resolve(null);
                     return;
                 }
-                const extent = transformExtent(tileGrid.getExtent(), projection, "EPSG:4326");
+                const projectionCode = projection.getCode();
+                const extent = transform(setCrs(tileGrid.getExtent(), projectionCode), "EPSG:4326");
                 resolve({ extent });
             }
             else if (source.getState() === "error") {

package/lib/constant/projections.ts

@@ -1 +1,11 @@
 export const LONLAT_CRS_CODES = ["EPSG:4326", "CRS:84"];
+
+/**
+ * This CRS is considered if no CRS is specified in a coordinate or extent
+ */
+export const DEFAULT_CRS = "EPSG:4326";
+
+/**
+ * This CRS is considered if no CRS is specified in a map view context
+ */
+export const DEFAULT_MAP_VIEW_CRS = "EPSG:3857";

package/lib/model/events.ts

@@ -1,12 +1,11 @@
 import { EndpointError } from "@camptocamp/ogc-client";
 import { Feature } from "geojson";
-import BaseEvent from "ol/events/Event.js";
-import type { Extent } from "ol/extent.js";
 import {
   ResolvedMapLayerState,
   ResolvedMapState,
   ResolvedMapViewState,
 } from "./resolved-map-state.js";
+import { Extent } from "./map-context.js";
 
 export type FeaturesByLayerIndex = Map<number, Feature[]>;
 
@@ -78,11 +77,12 @@ export interface MapExtentChangeEvent {
  * Use the MapLayerStateChangeEvent and LayerLoadingErrorEvent instead
  */
 export const SourceLoadErrorType = "source-load-error";
-export class SourceLoadErrorEvent extends BaseEvent {
+export class SourceLoadErrorEvent {
+  type: typeof SourceLoadErrorType;
   message: string;
   httpStatus?: number;
   constructor(error: EndpointError | Error | Response) {
-    super(SourceLoadErrorType);
+    this.type = SourceLoadErrorType;
     if (error instanceof Response) {
       this.message = error.statusText;
       this.httpStatus = error.status;

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

@@ -27,6 +27,13 @@ export interface MapContextLayerChanged {
   position: number;
 }
 
+/**
+ * If the `projection` field is omitted, it means that the view projection should not be changed.
+ * A return to the default map view projection should be explicitly stated in the `projection` property.
+ * `null` means reset to the default view.
+ */
+export type MapContextViewDiff = MapContextView | null;
+
 /**
  * Describes a delta between two contexts, in order to be
  * applied to an existing map.
@@ -42,5 +49,5 @@ export interface MapContextDiff {
   layersReordered: MapContextLayerReordered[];
   layersRemoved: MapContextLayerPositioned[];
   layersAdded: MapContextLayerPositioned[];
-  viewChanges?: MapContextView | null; // this is both optional (meaning no view change) and nullable (meaning reset to default view)
+  viewChanges?: MapContextViewDiff; // if this property is omitted, the view hasn't changed
 }

package/lib/model/map-context.ts

@@ -237,15 +237,24 @@ export type MapContextLayer =
   | MapContextLayerMapLibreStyle
   | MapContextLayerGeotiff;
 
-export type Coordinate = [number, number];
+export type CrsIdentifier = string;
 
 /**
- * Array components are respectively: minX, minY, maxX, maxY
+ * Array components are respectively: x, y and optionally a CRS identifier
+ * (e.g. `"EPSG:2154"`). Without a CRS, coordinates are expressed in longitude/latitude.
  */
-export type Extent = [number, number, number, number];
+export type Coordinate = [number, number] | [number, number, CrsIdentifier];
 
 /**
- * @property center Expressed in longitude/latitude
+ * Array components are respectively: minX, minY, maxX, maxY and optionally a CRS identifier
+ * (e.g. `"EPSG:2154"`). Without a CRS, the extent is expressed in longitude/latitude.
+ */
+export type Extent =
+  | [number, number, number, number]
+  | [number, number, number, number, CrsIdentifier];
+
+/**
+ * @property center Expressed in longitude/latitude unless a CRS identifier is given as third element
  * @property zoom
  */
 export interface ViewByZoomAndCenter {
@@ -254,7 +263,7 @@ export interface ViewByZoomAndCenter {
 }
 
 /**
- * @property extent Expressed in longitude/latitude
+ * @property extent Expressed in longitude/latitude unless a CRS identifier is given as fifth element
  */
 export interface ViewByExtent {
   extent: Extent;
@@ -280,6 +289,11 @@ export type MapContextView = (
 ) & {
   maxZoom?: number;
   maxExtent?: Extent;
+
+  /**
+   * CRS in which the map is displayed (e.g. `"EPSG:2154"`); defaults to `"EPSG:3857"`.
+   */
+  projection?: CrsIdentifier;
 };
 
 /**

package/lib/model/resolved-map-state.ts

@@ -43,7 +43,7 @@ export interface ResolvedMapViewState {
   /** View center in longitude/latitude */
   center: Coordinate;
 
-  /** Actual view extent in longitude/latitude */
+  /** Actual view extent in the current view projection */
   extent: Extent;
 
   /** Map units per pixel */

package/lib/utils/coordinates.test.ts

@@ -0,0 +1,172 @@
+import {
+  equals,
+  extend,
+  getCrs,
+  setCrs,
+  toGeographic,
+  transform,
+} from "./coordinates.js";
+import { Coordinate, Extent } from "../model/index.js";
+
+describe("crs utils", () => {
+  describe("getCrs", () => {
+    it("defaults to EPSG:4326 when no CRS is given", () => {
+      expect(getCrs([1, 2])).toBe("EPSG:4326");
+      expect(getCrs([1, 2, 3, 4])).toBe("EPSG:4326");
+    });
+    it("reads the CRS from the last element", () => {
+      expect(getCrs([1, 2, "EPSG:2154"])).toBe("EPSG:2154");
+      expect(getCrs([1, 2, 3, 4, "EPSG:2154"])).toBe("EPSG:2154");
+    });
+  });
+
+  describe("setCrs", () => {
+    it("applies the CRS to a coordinate without transforming it", () => {
+      expect(setCrs([2.3, 48.8], "EPSG:3857")).toEqual([
+        2.3,
+        48.8,
+        "EPSG:3857",
+      ]);
+    });
+
+    it("applies the CRS to an extent without transforming it", () => {
+      expect(setCrs([1, 2, 3, 4], "EPSG:3857")).toEqual([
+        1,
+        2,
+        3,
+        4,
+        "EPSG:3857",
+      ]);
+    });
+
+    it("replaces the CRS when one is already present", () => {
+      expect(setCrs([2.3, 48.8, "EPSG:4326"], "EPSG:3857")).toEqual([
+        2.3,
+        48.8,
+        "EPSG:3857",
+      ]);
+      expect(setCrs([1, 2, 3, 4, "EPSG:4326"], "EPSG:3857")).toEqual([
+        1,
+        2,
+        3,
+        4,
+        "EPSG:3857",
+      ]);
+    });
+
+    it("returns the original value when its CRS is unchanged", () => {
+      const coordinate = [2.3, 48.8, "EPSG:4326"] as Coordinate;
+      const extent = [1, 2, 3, 4, "EPSG:4326"] as Extent;
+
+      expect(setCrs(coordinate, "EPSG:4326")).toBe(coordinate);
+      expect(setCrs(extent, "EPSG:4326")).toBe(extent);
+    });
+  });
+
+  describe("extend", () => {
+    it("expands the first extent to include the second", () => {
+      const extent = [1, 2, 3, 4] as [number, number, number, number];
+
+      expect(extend(extent, [-1, 3, 2, 8])).toBe(extent);
+      expect(extent).toEqual([-1, 2, 3, 8]);
+    });
+
+    it("throws when extents use different CRSs", () => {
+      expect(() => extend([1, 2, 3, 4], [5, 6, 7, 8, "EPSG:3857"])).toThrow(
+        "Cannot combine extents with different CRS",
+      );
+    });
+  });
+
+  describe("transform", () => {
+    it("returns the input unchanged when it is already in the target CRS", () => {
+      const coordinate = [2.3, 48.8, "EPSG:4326"] as Coordinate;
+      expect(transform(coordinate, "EPSG:4326")).toBe(coordinate);
+    });
+
+    it("transforms a coordinate to the target CRS", () => {
+      const result = transform([1, 1], "EPSG:3857");
+
+      expect(result[0]).toBeCloseTo(111319.4908);
+      expect(result[1]).toBeCloseTo(111325.1429);
+      expect(result[2]).toBe("EPSG:3857");
+    });
+
+    it("transforms an extent to the target CRS", () => {
+      const result = transform([0, 0, 1, 1], "EPSG:3857");
+
+      expect(result[0]).toBeCloseTo(0);
+      expect(result[1]).toBeCloseTo(0);
+      expect(result[2]).toBeCloseTo(111319.4908);
+      expect(result[3]).toBeCloseTo(111325.1429);
+      expect(result[4]).toBe("EPSG:3857");
+    });
+
+    it("throws an error when the CRS cannot be converted", () => {
+      expect(() => transform([1, 2, "EPSG:999999"], "EPSG:4326")).toThrow(
+        "Cannot convert from EPSG:999999 to EPSG:4326",
+      );
+    });
+  });
+
+  describe("toGeographic", () => {
+    it("returns coordinates and extents in EPSG:4326 and strips the CRS identifier", () => {
+      expect(toGeographic([2.3, 48.8])).toEqual([2.3, 48.8]);
+      expect(toGeographic([2.3, 48.8, "EPSG:4326"])).toEqual([2.3, 48.8]);
+      expect(toGeographic([2.3, 48.8, 3.3, 49.8])).toEqual([
+        2.3, 48.8, 3.3, 49.8,
+      ]);
+      expect(toGeographic([2.3, 48.8, 3.3, 49.8, "EPSG:4326"])).toEqual([
+        2.3, 48.8, 3.3, 49.8,
+      ]);
+    });
+
+    it("converts a coordinate from its declared CRS to EPSG:4326", () => {
+      const result = toGeographic([
+        111319.49079327357,
+        111325.1428663851,
+        "EPSG:3857",
+      ]);
+
+      expect(result[0]).toBeCloseTo(1);
+      expect(result[1]).toBeCloseTo(1);
+    });
+
+    it("converts an extent from its declared CRS to EPSG:4326", () => {
+      const result = toGeographic([
+        0,
+        0,
+        111319.49079327357,
+        111325.1428663851,
+        "EPSG:3857",
+      ]);
+
+      expect(result[0]).toBeCloseTo(0);
+      expect(result[1]).toBeCloseTo(0);
+      expect(result[2]).toBeCloseTo(1);
+      expect(result[3]).toBeCloseTo(1);
+    });
+
+    it("throws an error when the CRS cannot be converted", () => {
+      expect(() => toGeographic([1, 2, "EPSG:999999"])).toThrow(
+        "Cannot convert from EPSG:999999 to EPSG:4326",
+      );
+    });
+  });
+
+  describe("equals", () => {
+    it("compares coordinates and their CRS", () => {
+      expect(equals([2.3, 48.8], [2.3, 48.8])).toBe(true);
+      expect(equals([2.3, 48.8], [2.3, 48.8, "EPSG:4326"])).toBe(true);
+      expect(equals([2.3, 48.8], [2.4, 48.8])).toBe(false);
+      expect(equals([2.3, 48.8], [2.3, 48.8, "EPSG:3857"])).toBe(false);
+    });
+
+    it("compares extents and their CRS", () => {
+      expect(equals([1, 2, 3, 4], [1, 2, 3, 4])).toBe(true);
+      expect(equals([1, 2, 3, 4], [1, 2, 3, 4, "EPSG:4326"])).toBe(true);
+      expect(equals([1, 2, 3, 4], [1, 2, 3, 5])).toBe(false);
+      expect(equals([1, 2, 3, 4], [1, 2, 3, 4, "EPSG:3857"])).toBe(false);
+    });
+  });
+});

package/lib/utils/coordinates.ts

@@ -0,0 +1,157 @@
+import { DEFAULT_CRS } from "../constant/projections.js";
+import { Coordinate, CrsIdentifier, Extent } from "../model/map-context.js";
+import proj4 from "proj4";
+
+function isCoordinate(value: Coordinate | Extent): value is Coordinate {
+  return value.length < 4;
+}
+
+/**
+ * Returns the CRS of a coordinate or extent; defaults to EPSG:4326 (longitude/latitude)
+ */
+export function getCrs(value: Coordinate | Extent): string {
+  const last = value[value.length - 1];
+  return typeof last === "string" ? last : DEFAULT_CRS;
+}
+
+/**
+ * Apply a CRS identifier to a coordinate; THIS DOES NOT TRANSFORM COORDINATES
+ * @param value
+ * @param crs
+ */
+export function setCrs(value: Coordinate, crs: CrsIdentifier): Coordinate;
+/**
+ * Apply a CRS identifier to an extent; THIS DOES NOT TRANSFORM COORDINATES
+ * @param value
+ * @param crs
+ */
+export function setCrs(value: Extent, crs: CrsIdentifier): Extent;
+export function setCrs(
+  value: Coordinate | Extent,
+  crs: CrsIdentifier,
+): Coordinate | Extent {
+  const currentCrs = getCrs(value);
+  if (currentCrs === crs) {
+    return value;
+  }
+  if (isCoordinate(value)) {
+    return [...value.slice(0, 2), crs] as Coordinate;
+  }
+  return [...value.slice(0, 4), crs] as Extent;
+}
+
+export function equals(value1: Coordinate, value2: Coordinate): boolean;
+export function equals(value1: Extent, value2: Extent): boolean;
+export function equals(
+  value1: Coordinate | Extent,
+  value2: Coordinate | Extent,
+): boolean {
+  const crs1 = getCrs(value1);
+  const crs2 = getCrs(value2);
+  const isCoordinate = value1.length < 4;
+  if (isCoordinate) {
+    return crs1 === crs2 && value1[0] === value2[0] && value1[1] === value2[1];
+  }
+  return (
+    crs1 === crs2 &&
+    value1[0] === value2[0] &&
+    value1[2] === value2[2] &&
+    value1[1] === value2[1] &&
+    value1[3] === value2[3]
+  );
+}
+
+/**
+ * first extent will be modified
+ * @param extent1
+ * @param extent2
+ */
+export function extend(extent1: Extent, extent2: Extent): Extent {
+  const crs1 = getCrs(extent1);
+  const crs2 = getCrs(extent2);
+  if (crs1 !== crs2) {
+    throw new Error(
+      `Cannot combine extents with different CRS: ${crs1} and ${crs2}`,
+    );
+  }
+  if (extent2[0] < extent1[0]) {
+    extent1[0] = extent2[0];
+  }
+  if (extent2[2] > extent1[2]) {
+    extent1[2] = extent2[2];
+  }
+  if (extent2[1] < extent1[1]) {
+    extent1[1] = extent2[1];
+  }
+  if (extent2[3] > extent1[3]) {
+    extent1[3] = extent2[3];
+  }
+  return extent1;
+}
+
+/**
+ * Project an extent into another CRS
+ * @param value
+ * @param toCrs
+ */
+export function transform(value: Extent, toCrs: CrsIdentifier): Extent;
+/**
+ * Project a coordinate into another CRS
+ * @param value
+ * @param toCrs
+ */
+export function transform(value: Coordinate, toCrs: CrsIdentifier): Coordinate;
+export function transform(
+  value: Coordinate | Extent,
+  toCrs: CrsIdentifier,
+): Coordinate | Extent {
+  const crs = getCrs(value);
+  if (crs === toCrs) {
+    return value;
+  }
+  // convert using proj4
+  try {
+    if (isCoordinate(value)) {
+      const coordinate = value.slice(0, 2) as [number, number];
+      return setCrs(proj4(crs, toCrs, coordinate), toCrs);
+    } else {
+      const [minX, minY, maxX, maxY] = value.slice(0, 4) as [
+        number,
+        number,
+        number,
+        number,
+      ];
+      // TODO: use finer logic for transforming extents, currently this can lead very often to wrong results
+      const [lonMin, latMin] = proj4(crs, toCrs, [minX, minY]);
+      const [lonMax, latMax] = proj4(crs, toCrs, [maxX, maxY]);
+      return setCrs([lonMin, latMin, lonMax, latMax], toCrs);
+    }
+  } catch (e) {
+    throw new Error(
+      `Cannot convert from ${crs} to ${toCrs}: ${(e as Error)?.message ?? e}`,
+    );
+  }
+}
+
+/**
+ * Returns another extent which is in geographic coordinates (EPSG:4326)
+ * @param value
+ */
+export function toGeographic(value: Extent): Extract<Extent, { length: 4 }>;
+/**
+ * Returns another coordinate which is in geographic coordinates (EPSG:4326)
+ * @param value
+ */
+export function toGeographic(
+  value: Coordinate,
+): Extract<Coordinate, { length: 2 }>;
+export function toGeographic(
+  value: Coordinate | Extent,
+): Extract<Coordinate, { length: 2 }> | Extract<Extent, { length: 4 }> {
+  if (isCoordinate(value)) {
+    const transformed = transform(value, "EPSG:4326") as Coordinate;
+    return transformed.slice(0, 2) as [number, number];
+  }
+  const transformed = transform(value as Extent, "EPSG:4326") as Extent;
+  return transformed.slice(0, 4) as [number, number, number, number];
+}