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

package/dist/utils/hash.js

@@ -0,0 +1,28 @@
+function isGeoJsonGeometry(object) {
+    return "type" in object && ("coordinates" in object || "features" in object);
+}
+const bigintReplacer = (key, value) => typeof value === "bigint" ? value.toString() : value;
+export function getHash(input, ignoreKeys = []) {
+    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 = {};
+        const keys = Object.keys(input).sort();
+        for (const key of keys) {
+            if (ignoreKeys.includes(key))
+                continue;
+            obj[key] = getHash(input[key]);
+        }
+        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/dist/utils/index.d.ts

@@ -1,5 +1,13 @@
-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";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,cAAc,YAAY,CAAC"}

package/dist/utils/index.js

@@ -1,4 +1,12 @@
-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/dist/utils/map-context-diff.d.ts

@@ -1,4 +1,4 @@
-import { MapContext, MapContextDiff } from "../model";
+import { MapContext, MapContextDiff } from "../model/index.js";
 /**
  * The following logic is produced by identifying layers in both context
  * and determining whether they have been added, removed, changed or reordered.

package/dist/utils/map-context-diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map-context-diff.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,cAAc,EAKf,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EACvB,eAAe,EAAE,UAAU,GAC1B,cAAc,CAqEhB"}
+{"version":3,"file":"map-context-diff.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,cAAc,EAKf,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EACvB,eAAe,EAAE,UAAU,GAC1B,cAAc,CA8EhB"}

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

@@ -1,4 +1,4 @@
-import { isLayerSame, isLayerSameAndUnchanged } from "./map-context";
+import { isLayerSame, isLayerSameAndUnchanged } from "./map-context-layer.js";
 /**
  * The following logic is produced by identifying layers in both context
  * and determining whether they have been added, removed, changed or reordered.
@@ -31,7 +31,6 @@ export function computeMapContextDiff(nextContext, previousContext) {
     const layersReordered = [];
     const layersRemoved = [];
     const layersAdded = [];
-    const viewChanges = {};
     // loop on prev context layers (for removed layers)
     for (let i = 0; i < previousContext.layers.length; i++) {
         const layer = previousContext.layers[i];
@@ -51,29 +50,38 @@ export function computeMapContextDiff(nextContext, previousContext) {
         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((l) => !layersRemoved.find(({ layer }) => l === layer));
-    const nextLayersFiltered = 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);
+    // look for moved layers (ignore removed and added ones)
+    const movedLayersInPrevious = previousContext.layers.filter((l) => !layersRemoved.find(({ layer }) => l === layer));
+    const movedLayersInNext = nextContext.layers.filter((l) => !layersAdded.find(({ layer }) => l === layer));
+    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 }),
     };
 }

package/dist/utils/map-context-layer.d.ts

@@ -0,0 +1,13 @@
+import { MapContextLayer } from "../model/index.js";
+export declare function getLayerHash(layer: MapContextLayer, includeExtras?: boolean): string;
+export declare function isLayerSame(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
+export declare function isLayerSameAndUnchanged(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
+/**
+ * Applies the `updates` partial to the given layer. The layer will also be
+ * adjusted depending on the presence of the `id` and `version` fields.
+ * Note: any property set to `undefined` in `updates` will be removed from the resulting layer.
+ * @param layer
+ * @param updates
+ */
+export declare function updateLayer(layer: MapContextLayer, updates: Partial<MapContextLayer>): MapContextLayer;
+//# sourceMappingURL=map-context-layer.d.ts.map

package/dist/utils/map-context-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-context-layer.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,aAAa,UAAQ,GACpB,MAAM,CAER;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAST;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAChC,eAAe,CAqBjB"}

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

@@ -0,0 +1,44 @@
+import { getHash } from "./hash.js";
+export function getLayerHash(layer, includeExtras = false) {
+    return getHash(layer, includeExtras ? [] : ["extras"]);
+}
+export function isLayerSame(layerA, layerB) {
+    if ("id" in layerA && "id" in layerB) {
+        return layerA.id == layerB.id;
+    }
+    return getLayerHash(layerA) === getLayerHash(layerB);
+}
+export function isLayerSameAndUnchanged(layerA, layerB) {
+    if ("id" in layerA &&
+        "id" in layerB &&
+        ("version" in layerA || "version" in layerB)) {
+        return layerA.id == layerB.id && layerA.version == layerB.version;
+    }
+    return getLayerHash(layerA, true) === getLayerHash(layerB, true);
+}
+/**
+ * Applies the `updates` partial to the given layer. The layer will also be
+ * adjusted depending on the presence of the `id` and `version` fields.
+ * Note: any property set to `undefined` in `updates` will be removed from the resulting layer.
+ * @param layer
+ * @param updates
+ */
+export function updateLayer(layer, updates) {
+    const updatedLayer = {
+        ...layer,
+        ...updates,
+    };
+    const versionExplicitlyUpdated = "version" in updates && updates.version !== undefined;
+    if ("id" in updatedLayer &&
+        "version" in updatedLayer &&
+        typeof updatedLayer.version === "number" &&
+        !versionExplicitlyUpdated) {
+        updatedLayer.version = updatedLayer.version + 1;
+    }
+    for (const key in updatedLayer) {
+        if (updatedLayer[key] === undefined) {
+            delete updatedLayer[key];
+        }
+    }
+    return updatedLayer;
+}

package/dist/utils/map-context.d.ts

@@ -1,6 +1,50 @@
-import { MapContext, MapContextLayer } from "../model";
-export declare function getLayerHash(layer: MapContextLayer, includeExtras?: boolean): string;
-export declare function isLayerSame(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
-export declare function isLayerSameAndUnchanged(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
+import { MapContext, MapContextLayer } from "../model/index.js";
 export declare function getLayerPosition(context: MapContext, layerModel: MapContextLayer): number;
+/**
+ * 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 declare function addLayerToContext(context: MapContext, layerModel: MapContextLayer, position?: number): MapContext;
+/**
+ * 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 declare function removeLayerFromContext(context: MapContext, layerModel: MapContextLayer): MapContext;
+/**
+ * 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 declare function replaceLayerInContext(context: MapContext, layerModel: MapContextLayer, replacement: MapContextLayer): MapContext;
+/**
+ * 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 declare function updateLayerInContext(context: MapContext, layerModel: MapContextLayer, layerUpdates: Partial<MapContextLayer>): MapContext;
+/**
+ * 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 declare function changeLayerPositionInContext(context: MapContext, layerModel: MapContextLayer, position: number): MapContext;
 //# sourceMappingURL=map-context.d.ts.map

package/dist/utils/map-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map-context.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEvD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,aAAa,UAAQ,GACpB,MAAM,CAkBR;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAKT;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,GAC1B,MAAM,CAER"}
+{"version":3,"file":"map-context.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGhE,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,GAC1B,MAAM,CAER;AAED;;;;;;;GAOG;AAEH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,UAAU,CAQZ;AAED;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,GAC1B,UAAU,CAOZ;AAED;;;;;;;GAOG;AAEH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,EAC3B,WAAW,EAAE,eAAe,GAC3B,UAAU,CAOZ;AAED;;;;;;;;;;GAUG;AAEH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,EAC3B,YAAY,EAAE,OAAO,CAAC,eAAe,CAAC,GACrC,UAAU,CAUZ;AAED;;;;;;;GAOG;AAEH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,EAC3B,QAAQ,EAAE,MAAM,GACf,UAAU,CAGZ"}

package/dist/utils/map-context.js

@@ -1,36 +1,87 @@
-export function getLayerHash(layer, includeExtras = false) {
-    function getHash(input) {
-        if (input instanceof Object) {
-            const obj = {};
-            const keys = Object.keys(input).sort();
-            for (const key of keys) {
-                if (!includeExtras && key === "extras")
-                    continue;
-                obj[key] = getHash(input[key]);
-            }
-            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 { isLayerSame, updateLayer } from "./map-context-layer.js";
+export function getLayerPosition(context, layerModel) {
+    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, layerModel, position) {
+    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, layerB) {
-    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, layerModel) {
+    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, layerB) {
-    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, layerModel, replacement) {
+    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(context, layerModel) {
-    return context.layers.findIndex((l) => isLayerSame(layerModel, l));
+/**
+ * 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, layerModel, layerUpdates) {
+    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, layerModel, position) {
+    const newContext = removeLayerFromContext(context, layerModel);
+    return addLayerToContext(newContext, layerModel, position);
 }

package/dist/utils/style.d.ts

@@ -0,0 +1,4 @@
+import type { FlatStyleLike } from "ol/style/flat.js";
+export declare const defaultStyle: FlatStyleLike;
+export declare const defaultHighlightStyle: FlatStyleLike;
+//# sourceMappingURL=style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../lib/utils/style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,eAAO,MAAM,YAAY,EAAE,aA+B1B,CAAC;AAIF,eAAO,MAAM,qBAAqB,EAAE,aA+BnC,CAAC"}

package/dist/utils/style.js

@@ -0,0 +1,68 @@
+const color = "rgb(0, 0, 255)";
+const fillColor = "rgba(0, 0, 255, 0.25)";
+export const defaultStyle = [
+    {
+        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 = [
+    {
+        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/dist/utils/view.d.ts

@@ -0,0 +1,25 @@
+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.
+ *
+ * @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 declare function createViewFromLayer(layer: MapContextLayer): Promise<MapContextView | null>;
+//# sourceMappingURL=view.d.ts.map

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

@@ -0,0 +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"}

package/dist/utils/view.js

@@ -0,0 +1,126 @@
+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();
+/**
+ * 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) {
+    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) {
+    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);
+    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],
+        };
+    }
+    else {
+        const availableEPSGCode = Object.keys(boundingBoxes)[0];
+        const proj = await fromEPSGCode(availableEPSGCode);
+        return {
+            extent: transformExtent(boundingBoxes[availableEPSGCode], proj, "EPSG:4326"),
+        };
+    }
+}
+async function getWmtsLayerExtent(layer) {
+    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,
+        }
+        : null;
+}
+async function getWfsLayerExtent(layer) {
+    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) {
+    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");
+                resolve({ extent });
+            }
+            else if (source.getState() === "error") {
+                resolve(null);
+            }
+        });
+    });
+}

package/lib/constant/projections.ts

@@ -0,0 +1 @@
+export const LONLAT_CRS_CODES = ["EPSG:4326", "CRS:84"];

package/lib/index.ts

@@ -1,3 +1,8 @@
-// PUBLIC API
-export * from "./utils";
-export * from "./model";
+/**
+ * {@include ../README.md#body}
+ *
+ * @module 📦 core
+ */
+
+export * from "./utils/index.js";
+export * from "./model/index.js";