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

package/lib/utils/view.test.ts

@@ -0,0 +1,146 @@
+import { createViewFromLayer } from "./view.js";
+import {
+  MapContextLayerGeojson,
+  MapContextLayerWfs,
+  MapContextLayerWms,
+  MapContextLayerWmts,
+} from "../model/index.js";
+
+vitest.mock("@camptocamp/ogc-client", () => ({
+  WmsEndpoint: class {
+    constructor() {}
+    isReady() {
+      return Promise.resolve({
+        getLayerByName: (name: string) => {
+          if (name.includes("error")) {
+            throw new Error("Something went wrong");
+          }
+          let boundingBoxes;
+          if (name.includes("nobbox")) {
+            boundingBoxes = {};
+          } else if (name.includes("4326")) {
+            boundingBoxes = {
+              "EPSG:4326": [1, 2.6, 3.3, 4.2],
+              "CRS:84": [2.3, 50.6, 2.8, 50.9],
+            };
+          } else if (name.includes("2154")) {
+            boundingBoxes = {
+              "EPSG:2154": [650796.4, 7060330.6, 690891.3, 7090402.2],
+            };
+          } else {
+            boundingBoxes = {
+              "CRS:84": [2.3, 50.6, 2.8, 50.9],
+              "EPSG:2154": [650796.4, 7060330.6, 690891.3, 7090402.2],
+            };
+          }
+          return {
+            name,
+            boundingBoxes,
+          };
+        },
+      });
+    }
+  },
+  WmtsEndpoint: class {
+    constructor() {}
+    isReady() {
+      return Promise.resolve({
+        getSingleLayerName: () => "layerName",
+        getLayerByName: () => ({
+          latLonBoundingBox: [1, 2.6, 3.3, 4.2],
+        }),
+      });
+    }
+  },
+  WfsEndpoint: class {
+    constructor(private url: string) {}
+    isReady() {
+      return Promise.resolve({
+        getFeatureTypeSummary: (featureType: string) => {
+          return {
+            name: featureType,
+            boundingBox: [1.33, 48.81, 4.3, 51.1],
+          };
+        },
+      });
+    }
+  },
+}));
+
+describe("view", () => {
+  describe("createViewFromLayer", () => {
+    it("should return view for WMS layer", async () => {
+      const layer = {
+        type: "wms",
+        name: "mock_4326",
+        url: "http://mock/wms",
+      } as MapContextLayerWms;
+      const view = await createViewFromLayer(layer);
+      expect(view).toEqual({
+        extent: [1, 2.6, 3.3, 4.2],
+      });
+    });
+
+    it("should return view for WMTS layer", async () => {
+      const layer = {
+        type: "wmts",
+        name: "mock",
+        url: "http://mock/wmts",
+      } as MapContextLayerWmts;
+      const view = await createViewFromLayer(layer);
+      expect(view).toEqual({
+        extent: [1, 2.6, 3.3, 4.2],
+      });
+    });
+
+    it("should return view for WFS layer", async () => {
+      const layer = {
+        type: "wfs",
+        featureType: "mock",
+        url: "http://mock/wfs",
+      } as MapContextLayerWfs;
+      const view = await createViewFromLayer(layer);
+      expect(view).toEqual({
+        extent: [1.33, 48.81, 4.3, 51.1],
+      });
+    });
+
+    it("should return view for GeoJSON layer", async () => {
+      const layer = {
+        type: "geojson",
+        data: {
+          type: "FeatureCollection",
+          features: [
+            {
+              type: "Feature",
+              properties: {},
+              geometry: {
+                type: "Point",
+                coordinates: [125.6, 10.1],
+              },
+            },
+            {
+              type: "Feature",
+              properties: {},
+              geometry: {
+                type: "Point",
+                coordinates: [100, 200],
+              },
+            },
+          ],
+        },
+      } as MapContextLayerGeojson;
+      const view = await createViewFromLayer(layer);
+      expect(view).toEqual({
+        extent: [100, 10.1, 125.6, 200],
+      });
+    });
+
+    it("should throw error for unsupported layer type", async () => {
+      const layer = { type: "unsupported" } as any;
+      await expect(createViewFromLayer(layer)).rejects.toThrow(
+        "Unsupported layer type: unsupported",
+      );
+    });
+  });
+});

package/lib/utils/view.ts

@@ -0,0 +1,163 @@
+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 type Feature from "ol/Feature.js";
+import GeoTIFF from "ol/source/GeoTIFF.js";
+import {
+  Extent,
+  MapContextLayer,
+  MapContextLayerGeotiff,
+  MapContextLayerWfs,
+  MapContextLayerWms,
+  MapContextLayerWmts,
+  MapContextView,
+  ViewByExtent,
+} from "../model/index.js";
+import { FeatureCollection, Geometry } from "geojson";
+
+const GEOJSON = new GeoJSON();
+
+/**
+ * Creates a view from a layer by extracting its geographic extent. The returned extent is
+ * always expressed in EPSG:4326 (longitude/latitude) coordinates.
+ *
+ * @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
+ * @throws {Error} If the layer type is not supported
+ *
+ * @example
+ * ```typescript
+ * const wmsLayer: MapContextLayerWms = {
+ *   type: 'wms',
+ *   url: 'https://example.com/wms',
+ *   name: 'myLayer'
+ * };
+ *
+ * const view = await createViewFromLayer(wmsLayer);
+ * if (view) {
+ *   console.log('Extent:', view.extent); // [minX, minY, maxX, maxY] in EPSG:4326
+ * }
+ * ```
+ */
+export async function createViewFromLayer(
+  layer: MapContextLayer,
+): Promise<MapContextView | null> {
+  if (layer.type === "wms") {
+    return await getWmsLayerExtent(layer);
+  } else if (layer.type === "wmts") {
+    return await getWmtsLayerExtent(layer);
+  } else if (layer.type === "geojson" && layer.data) {
+    return computeExtentFromGeojson(layer.data);
+  } else if (layer.type === "wfs") {
+    return await getWfsLayerExtent(layer);
+  } else if (layer.type === "geotiff") {
+    return await getGeotiffLayerExtent(layer);
+  } else {
+    throw new Error(`Unsupported layer type: ${layer.type}`);
+  }
+}
+
+function computeExtentFromGeojson(
+  data: FeatureCollection<Geometry | null> | string,
+): ViewByExtent {
+  const geojson = typeof data === "string" ? JSON.parse(data) : data;
+  const features = GEOJSON.readFeatures(geojson) as Feature[];
+  const extent = features.reduce(
+    (prev, curr) => {
+      const geom = curr.getGeometry();
+      if (!geom) return prev;
+      return extend(prev, geom.getExtent()) as Extent;
+    },
+    [Infinity, Infinity, -Infinity, -Infinity] as Extent,
+  ) as Extent;
+  return {
+    extent,
+  };
+}
+
+async function getWmsLayerExtent(
+  layer: MapContextLayerWms,
+): Promise<ViewByExtent | null> {
+  const endpoint = await new WmsEndpoint(layer.url).isReady();
+  const { boundingBoxes } = endpoint.getLayerByName(layer.name);
+  if (!Object.keys(boundingBoxes).length) {
+    return null;
+  }
+  const lonLatCRS = Object.keys(boundingBoxes).find((crs) =>
+    LONLAT_CRS_CODES.includes(crs),
+  );
+  if (lonLatCRS) {
+    return {
+      extent: boundingBoxes[lonLatCRS] as Extent,
+    };
+  } else {
+    const availableEPSGCode = Object.keys(boundingBoxes)[0];
+    const proj = await fromEPSGCode(availableEPSGCode);
+    return {
+      extent: transformExtent(
+        boundingBoxes[availableEPSGCode],
+        proj,
+        "EPSG:4326",
+      ) as Extent,
+    };
+  }
+}
+
+async function getWmtsLayerExtent(
+  layer: MapContextLayerWmts,
+): Promise<ViewByExtent | null> {
+  const endpoint = await new WmtsEndpoint(layer.url).isReady();
+  const layerName = endpoint.getSingleLayerName() ?? layer.name;
+  const wmtsLayer = endpoint.getLayerByName(layerName);
+  return wmtsLayer.latLonBoundingBox
+    ? {
+        extent: wmtsLayer.latLonBoundingBox as Extent,
+      }
+    : null;
+}
+
+async function getWfsLayerExtent(
+  layer: MapContextLayerWfs,
+): Promise<ViewByExtent | null> {
+  const endpoint = await new WfsEndpoint(layer.url).isReady();
+  const featureTypeSummary = endpoint.getFeatureTypeSummary(layer.featureType);
+  const boundingBox = featureTypeSummary?.boundingBox;
+  if (!boundingBox) {
+    return null;
+  }
+  return {
+    extent: boundingBox,
+  };
+}
+
+async function getGeotiffLayerExtent(
+  layer: MapContextLayerGeotiff,
+): Promise<ViewByExtent | null> {
+  const source = new GeoTIFF({
+    sources: [{ url: layer.url }],
+  });
+
+  return new Promise((resolve) => {
+    source.on("change", () => {
+      if (source.getState() === "ready") {
+        const tileGrid = source.getTileGrid();
+        const projection = source.getProjection();
+        if (!tileGrid || !projection) {
+          resolve(null);
+          return;
+        }
+        const extent = transformExtent(
+          tileGrid.getExtent(),
+          projection,
+          "EPSG:4326",
+        ) as Extent;
+        resolve({ extent });
+      } else if (source.getState() === "error") {
+        resolve(null);
+      }
+    });
+  });
+}

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@geospatial-sdk/core",
-  "version": "0.0.5-dev.0+97d2685",
+  "version": "0.0.5-dev.0.sha-5830a6a",
   "description": "Core functions and models for the SDK",
+  "keywords": [
+    "geospatial",
+    "sdk"
+  ],
   "author": "Olivia <olivia.guyot@camptocamp.com>",
-  "homepage": "",
+  "homepage": "https://github.com/camptocamp/geospatial-sdk#readme",
   "license": "BSD-3-Clause",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -18,9 +22,22 @@
     "lib",
     "dist"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/camptocamp/geospatial-sdk.git"
+  },
   "scripts": {
     "test": "vitest",
     "build": "tsc"
   },
-  "gitHead": "97d2685498a9b6208d833a15480a5a9ca804e12f"
+  "dependencies": {
+    "proj4": "^2.9.2"
+  },
+  "devDependencies": {
+    "ol": "^10.7.0"
+  },
+  "peerDependencies": {
+    "ol": ">9.x"
+  },
+  "gitHead": "5830a6a9360dc444c59307aa7304214a2082381d"
 }