@geospatial-sdk/maplibre 0.0.5-dev.41

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Camptocamp
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,11 @@
+# `maplibre`
+
+> TODO: description
+
+## Usage
+
+```
+const openlayers = require('maplibre');
+
+// TODO: DEMONSTRATE API
+```

package/dist/helpers/map.helpers.d.ts

@@ -0,0 +1,21 @@
+import { Map } from "maplibre-gl";
+import { Dataset, LayerContextWithStyle, LayerSpecificationWithSource } from "../maplibre.models";
+import { FeatureCollection, Geometry } from "geojson";
+import { MapContextLayer } from "@geospatial-sdk/core";
+/**
+ * Remove all layers from a given source in the map.
+ * @param map
+ * @param sourceId
+ */
+export declare function removeLayersFromSource(map: Map, sourceId: string): void;
+/**
+ * Create a Maplibre source and layers from a GeoJSON MapContextLayer and its style.
+ * @param layerModel
+ * @param geojson
+ * @param sourcePosition
+ */
+export declare function createDatasetFromGeoJsonLayer(layerModel: LayerContextWithStyle, geojson: FeatureCollection<Geometry | null> | string, sourcePosition: number): Dataset;
+export declare function getLayersAtPosition(map: Map, position: number): LayerSpecificationWithSource[];
+export declare function getBeforeId(map: Map, position: number): string | undefined;
+export declare function generateLayerId(layerModel: MapContextLayer): string;
+//# sourceMappingURL=map.helpers.d.ts.map

package/dist/helpers/map.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.helpers.d.ts","sourceRoot":"","sources":["../../lib/helpers/map.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAsB,MAAM,aAAa,CAAC;AACtD,OAAO,EACL,OAAO,EACP,qBAAqB,EAErB,4BAA4B,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,QAWhE;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE,iBAAiB,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,MAAM,EACpD,cAAc,EAAE,MAAM,GACrB,OAAO,CAuBT;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,4BAA4B,EAAE,CAUhC;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS1E;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,eAAe,UAS1D"}

package/dist/helpers/map.helpers.js

@@ -0,0 +1,65 @@
+import { contextStyleToMaplibreLayers } from "./style.helpers";
+import { getHash } from "@geospatial-sdk/core/dist/utils/hash";
+/**
+ * Remove all layers from a given source in the map.
+ * @param map
+ * @param sourceId
+ */
+export function removeLayersFromSource(map, sourceId) {
+    const layers = map.getStyle().layers;
+    const layersWithSource = layers.filter((layer) => layer.type !== "background");
+    const layerIds = layersWithSource
+        .filter((layer) => layer.hasOwnProperty("source") && layer.source === sourceId)
+        .map((layer) => layer.id);
+    layerIds.forEach((layer) => map.removeLayer(layer));
+}
+/**
+ * Create a Maplibre source and layers from a GeoJSON MapContextLayer and its style.
+ * @param layerModel
+ * @param geojson
+ * @param sourcePosition
+ */
+export function createDatasetFromGeoJsonLayer(layerModel, geojson, sourcePosition) {
+    const sourceId = generateLayerId(layerModel);
+    const partialLayers = contextStyleToMaplibreLayers(layerModel.style);
+    const layers = partialLayers.map((layer) => (Object.assign(Object.assign({}, layer), { id: `${sourceId}-${layer.type}`, source: sourceId, layout: {
+            visibility: layerModel.visibility === false ? "none" : "visible",
+        }, metadata: {
+            sourcePosition,
+        } })));
+    return {
+        sources: {
+            [sourceId]: {
+                type: "geojson",
+                data: geojson,
+            },
+        },
+        layers,
+    };
+}
+export function getLayersAtPosition(map, position) {
+    const layers = map.getStyle().layers;
+    const layersWithSource = layers.filter((layer) => layer.type !== "background");
+    return layersWithSource.filter((layer) => {
+        var _a;
+        return ((_a = layer.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition) ===
+            position;
+    });
+}
+export function getBeforeId(map, position) {
+    const beforeLayer = map
+        .getStyle()
+        .layers.find((layer) => layer.metadata.sourcePosition ===
+        position + 1);
+    return beforeLayer ? beforeLayer.id : undefined;
+}
+export function generateLayerId(layerModel) {
+    return getHash(layerModel, [
+        "name",
+        "style",
+        "visibility",
+        "opacity",
+        "version",
+        "extras",
+    ]);
+}

package/dist/helpers/style.helpers.d.ts

@@ -0,0 +1,4 @@
+import { VectorStyle } from "@geospatial-sdk/core/dist/model/style";
+import { LayerSpecification } from "maplibre-gl";
+export declare function contextStyleToMaplibreLayers(style?: VectorStyle): Partial<LayerSpecification>[];
+//# sourceMappingURL=style.helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"style.helpers.d.ts","sourceRoot":"","sources":["../../lib/helpers/style.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAajD,wBAAgB,4BAA4B,CAC1C,KAAK,GAAE,WAAgB,GACtB,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAmD/B"}

package/dist/helpers/style.helpers.js

@@ -0,0 +1,54 @@
+const defaultOltStyle = {
+    "fill-color": "rgba(255,255,255,0.4)",
+    "stroke-color": "#3399CC",
+    "stroke-width": 1.25,
+    "circle-radius": 5,
+    "circle-fill-color": "rgba(255,255,255,0.4)",
+    "circle-stroke-width": 1.25,
+    "circle-stroke-color": "#3399CC",
+};
+export function contextStyleToMaplibreLayers(style = {}) {
+    const layers = [];
+    if (Array.isArray(style)) {
+        return style.flatMap((style_) => {
+            if (style_.hasOwnProperty("style")) {
+                console.warn("Rules in styles are not supported yet.");
+                return contextStyleToMaplibreLayers(style_.style);
+            }
+            return contextStyleToMaplibreLayers(style_);
+        });
+    }
+    style = Object.assign(Object.assign({}, defaultOltStyle), style);
+    if (style["fill-color"]) {
+        layers.push({
+            type: "fill",
+            paint: {
+                "fill-color": style["fill-color"],
+            },
+            filter: ["==", "$type", "Polygon"],
+        });
+    }
+    if (style["stroke-color"] || style["stroke-width"]) {
+        layers.push({
+            type: "line",
+            paint: Object.assign(Object.assign({ "line-color": style["stroke-color"] }, (style["stroke-width"] !== undefined && {
+                "line-width": style["stroke-width"],
+            })), (style["stroke-line-dash"] !== undefined && {
+                "line-dasharray": style["stroke-line-dash"],
+            })),
+        });
+    }
+    if (style["circle-radius"]) {
+        layers.push({
+            type: "circle",
+            paint: {
+                "circle-radius": style["circle-radius"],
+                "circle-stroke-color": style["circle-stroke-color"],
+                "circle-color": style["circle-fill-color"],
+                "circle-stroke-width": style["circle-stroke-width"],
+            },
+            filter: ["==", "$type", "Point"],
+        });
+    }
+    return layers;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./map";
+export * from "./maplibre.models";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./map";
+export * from "./maplibre.models";

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

@@ -0,0 +1,9 @@
+import { MapContextDiff } from "@geospatial-sdk/core";
+import { Map } from "maplibre-gl";
+/**
+ * Apply a context diff to an MapLibre map
+ * @param map
+ * @param contextDiff
+ */
+export declare function applyContextDiffToMap(map: Map, contextDiff: MapContextDiff): Promise<void>;
+//# sourceMappingURL=apply-context-diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply-context-diff.d.ts","sourceRoot":"","sources":["../../lib/map/apply-context-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AASlC;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,cAAc,GAC1B,OAAO,CAAC,IAAI,CAAC,CAsEf"}

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

@@ -0,0 +1,71 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createLayer } from "./create-map";
+import { generateLayerId, getBeforeId, getLayersAtPosition, removeLayersFromSource, } from "../helpers/map.helpers";
+/**
+ * Apply a context diff to an MapLibre map
+ * @param map
+ * @param contextDiff
+ */
+export function applyContextDiffToMap(map, contextDiff) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // removed layers (sorted by descending position)
+        if (contextDiff.layersRemoved.length > 0) {
+            const removed = contextDiff.layersRemoved.sort((a, b) => b.position - a.position);
+            for (const layerRemoved of removed) {
+                const mlLayers = getLayersAtPosition(map, layerRemoved.position);
+                if (mlLayers.length === 0) {
+                    console.warn(`[Warning] applyContextDiffToMap: no layer found at position ${layerRemoved.position} to remove.`);
+                    continue;
+                }
+                const sourceId = mlLayers[0].source;
+                mlLayers.forEach((layer) => {
+                    map.removeLayer(layer.id);
+                });
+                map.removeSource(sourceId);
+            }
+        }
+        // insert added layers
+        const newLayers = yield Promise.all(contextDiff.layersAdded.map((layerAdded) => createLayer(layerAdded.layer, layerAdded.position)));
+        newLayers.forEach((style, index) => {
+            const position = contextDiff.layersAdded[index].position;
+            const beforeId = getBeforeId(map, position);
+            Object.keys(style.sources).forEach((sourceId) => map.addSource(sourceId, style.sources[sourceId]));
+            style.layers.map((layer) => {
+                map.addLayer(layer, beforeId);
+            });
+        });
+        // recreate changed layers
+        for (const layerChanged of contextDiff.layersChanged) {
+            const { layer, position } = layerChanged;
+            const sourceId = generateLayerId(layer);
+            removeLayersFromSource(map, sourceId);
+            const beforeId = getBeforeId(map, position);
+            createLayer(layer, position).then((styleDiff) => {
+                styleDiff.layers.map((layer) => {
+                    map.addLayer(layer, beforeId);
+                });
+            });
+        }
+        if (typeof contextDiff.viewChanges !== "undefined") {
+            const { viewChanges } = contextDiff;
+            if (viewChanges && "extent" in viewChanges) {
+                const { extent } = viewChanges;
+                map.fitBounds([
+                    [extent[0], extent[1]],
+                    [extent[2], extent[3]],
+                ], {
+                    padding: 20,
+                    duration: 1000,
+                });
+            }
+        }
+    });
+}

package/dist/map/create-map.d.ts

@@ -0,0 +1,17 @@
+import { MapContext, MapContextLayer } from "@geospatial-sdk/core";
+import { Map, MapOptions } from "maplibre-gl";
+import { PartialStyleSpecification } from "../maplibre.models";
+export declare function createLayer(layerModel: MapContextLayer, sourcePosition: number): Promise<PartialStyleSpecification>;
+/**
+ * Create an Maplibre map from a context; optionally specify a target (root element) for the map
+ * @param context
+ * @param target
+ */
+export declare function createMapFromContext(context: MapContext, mapOptions: MapOptions): Promise<Map>;
+/**
+ * Resets a Maplibre map from a context; existing content will be cleared
+ * @param map
+ * @param context
+ */
+export declare function resetMapFromContext(map: Map, context: MapContext): Promise<Map>;
+//# sourceMappingURL=create-map.d.ts.map

package/dist/map/create-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-map.d.ts","sourceRoot":"","sources":["../../lib/map/create-map.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,eAAe,EAGhB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,GAAG,EACH,UAAU,EAEX,MAAM,aAAa,CAAC;AAWrB,OAAO,EAAW,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAOxE,wBAAsB,WAAW,CAC/B,UAAU,EAAE,eAAe,EAC3B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,yBAAyB,CAAC,CAgGpC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC,CAGd;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,GAAG,CAAC,CAoBd"}

package/dist/map/create-map.js

@@ -0,0 +1,144 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { removeSearchParams, } from "@geospatial-sdk/core";
+import { Map, } from "maplibre-gl";
+import { OgcApiEndpoint, WfsEndpoint, WmsEndpoint, } from "@camptocamp/ogc-client";
+import { createDatasetFromGeoJsonLayer, generateLayerId, } from "../helpers/map.helpers";
+const featureCollection = {
+    type: "FeatureCollection",
+    features: [],
+};
+export function createLayer(layerModel, sourcePosition) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { type } = layerModel;
+        switch (type) {
+            case "wms": {
+                const layerId = generateLayerId(layerModel);
+                const sourceId = layerId;
+                const endpoint = yield new WmsEndpoint(layerModel.url).isReady();
+                let url = endpoint.getMapUrl([layerModel.name], {
+                    widthPx: 256,
+                    heightPx: 256,
+                    extent: [0, 0, 0, 0], // will be replaced by maplibre-gl
+                    outputFormat: "image/png",
+                    crs: "EPSG:3857",
+                });
+                url = removeSearchParams(url, ["bbox"]);
+                url = `${url.toString()}&BBOX={bbox-epsg-3857}`;
+                const dataset = {
+                    sources: {
+                        [sourceId]: {
+                            type: "raster",
+                            tiles: [url],
+                            tileSize: 256,
+                        },
+                    },
+                    layers: [
+                        {
+                            id: layerId,
+                            type: "raster",
+                            source: sourceId,
+                            paint: {},
+                            metadata: {
+                                sourcePosition,
+                            },
+                        },
+                    ],
+                };
+                return dataset;
+            }
+            case "wfs": {
+                const entryPoint = yield new WfsEndpoint(layerModel.url).isReady();
+                const url = entryPoint.getFeatureUrl(layerModel.featureType, {
+                    asJson: true,
+                    outputCrs: "EPSG:4326",
+                });
+                return createDatasetFromGeoJsonLayer(layerModel, url, sourcePosition);
+            }
+            case "geojson": {
+                let geojson;
+                if (layerModel.url !== undefined) {
+                    geojson = layerModel.url;
+                }
+                else {
+                    const data = layerModel.data;
+                    if (typeof data === "string") {
+                        try {
+                            geojson = JSON.parse(data);
+                        }
+                        catch (e) {
+                            console.warn("A layer could not be created", layerModel, e);
+                            geojson = featureCollection;
+                        }
+                    }
+                    else {
+                        geojson = data;
+                    }
+                }
+                return createDatasetFromGeoJsonLayer(layerModel, geojson, sourcePosition);
+            }
+            case "ogcapi": {
+                const ogcEndpoint = new OgcApiEndpoint(layerModel.url);
+                let layerUrl;
+                if (layerModel.useTiles) {
+                    console.warn("[Warning] OGC API - Tiles not yet implemented.");
+                }
+                else {
+                    layerUrl = yield ogcEndpoint.getCollectionItemsUrl(layerModel.collection, Object.assign(Object.assign({}, layerModel.options), { asJson: true }));
+                    return createDatasetFromGeoJsonLayer(layerModel, layerUrl, sourcePosition);
+                }
+                break;
+            }
+            case "maplibre-style": {
+                console.warn("[Warning] Maplibre style - Not yet fully implemented.");
+                const style = yield fetch(layerModel.styleUrl).then((res) => res.json());
+                (_a = style.layers) === null || _a === void 0 ? void 0 : _a.forEach((layer) => (layer.metadata = { sourcePosition }));
+                return style;
+            }
+        }
+        return {};
+    });
+}
+/**
+ * Create an Maplibre map from a context; optionally specify a target (root element) for the map
+ * @param context
+ * @param target
+ */
+export function createMapFromContext(context, mapOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const map = new Map(mapOptions);
+        return yield resetMapFromContext(map, context);
+    });
+}
+/**
+ * Resets a Maplibre map from a context; existing content will be cleared
+ * @param map
+ * @param context
+ */
+export function resetMapFromContext(map, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        map.setZoom(context.view.zoom);
+        map.setCenter(context.view.center);
+        for (let i = 0; i < context.layers.length; i++) {
+            const layerModel = context.layers[i];
+            const partialMLStyle = yield createLayer(layerModel, i);
+            if (partialMLStyle.glyphs) {
+                map.setGlyphs(partialMLStyle.glyphs);
+            }
+            if (partialMLStyle.sprite) {
+                map.setSprite(partialMLStyle.sprite);
+            }
+            Object.keys(partialMLStyle.sources).forEach((sourceId) => map.addSource(sourceId, partialMLStyle.sources[sourceId]));
+            partialMLStyle.layers.map((layer) => map.addLayer(layer));
+        }
+        return map;
+    });
+}

package/dist/map/index.d.ts

@@ -0,0 +1,3 @@
+export { createMapFromContext, resetMapFromContext } from "./create-map";
+export { applyContextDiffToMap } from "./apply-context-diff";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/map/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/map/index.js

@@ -0,0 +1,2 @@
+export { createMapFromContext, resetMapFromContext } from "./create-map";
+export { applyContextDiffToMap } from "./apply-context-diff";

package/dist/maplibre.models.d.ts

@@ -0,0 +1,13 @@
+import { BackgroundLayerSpecification, LayerSpecification, StyleSpecification } from "maplibre-gl";
+import { MapContextLayerGeojson, MapContextLayerOgcApi, MapContextLayerWfs } from "@geospatial-sdk/core";
+export type LayerSpecificationWithSource = Exclude<LayerSpecification, BackgroundLayerSpecification>;
+export interface LayerMetadataSpecification {
+    sourcePosition: number;
+}
+export type LayerContextWithStyle = MapContextLayerWfs | MapContextLayerOgcApi | MapContextLayerGeojson;
+export type Dataset = Pick<StyleSpecification, "sources" | "layers">;
+export type PartialStyleSpecification = Dataset & {
+    glyphs?: StyleSpecification["glyphs"];
+    sprite?: StyleSpecification["sprite"];
+};
+//# sourceMappingURL=maplibre.models.d.ts.map

package/dist/maplibre.models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maplibre.models.d.ts","sourceRoot":"","sources":["../lib/maplibre.models.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,kBAAkB,EAClB,4BAA4B,CAC7B,CAAC;AAEF,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,qBAAqB,GAC7B,kBAAkB,GAClB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAC;AAErE,MAAM,MAAM,yBAAyB,GAAG,OAAO,GAAG;IAChD,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IACtC,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;CACvC,CAAC"}

package/dist/maplibre.models.js

@@ -0,0 +1 @@
+export {};

package/lib/helpers/map.helpers.ts

@@ -0,0 +1,101 @@
+import { Map, StyleSpecification } from "maplibre-gl";
+import {
+  Dataset,
+  LayerContextWithStyle,
+  LayerMetadataSpecification,
+  LayerSpecificationWithSource,
+} from "../maplibre.models";
+import { FeatureCollection, Geometry } from "geojson";
+import { contextStyleToMaplibreLayers } from "./style.helpers";
+import { getHash } from "@geospatial-sdk/core/dist/utils/hash";
+import { MapContextLayer } from "@geospatial-sdk/core";
+
+/**
+ * Remove all layers from a given source in the map.
+ * @param map
+ * @param sourceId
+ */
+export function removeLayersFromSource(map: Map, sourceId: string) {
+  const layers = map.getStyle().layers;
+  const layersWithSource = layers.filter(
+    (layer) => layer.type !== "background",
+  ) as LayerSpecificationWithSource[];
+  const layerIds = layersWithSource
+    .filter(
+      (layer) => layer.hasOwnProperty("source") && layer.source === sourceId,
+    )
+    .map((layer) => layer.id);
+  layerIds.forEach((layer) => map.removeLayer(layer));
+}
+
+/**
+ * Create a Maplibre source and layers from a GeoJSON MapContextLayer and its style.
+ * @param layerModel
+ * @param geojson
+ * @param sourcePosition
+ */
+export function createDatasetFromGeoJsonLayer(
+  layerModel: LayerContextWithStyle,
+  geojson: FeatureCollection<Geometry | null> | string,
+  sourcePosition: number,
+): Dataset {
+  const sourceId = generateLayerId(layerModel);
+  const partialLayers = contextStyleToMaplibreLayers(layerModel.style);
+  const layers = partialLayers.map((layer) => ({
+    ...layer,
+    id: `${sourceId}-${layer.type}`,
+    source: sourceId,
+    layout: {
+      visibility: layerModel.visibility === false ? "none" : "visible",
+    },
+    metadata: {
+      sourcePosition,
+    },
+  }));
+  return {
+    sources: {
+      [sourceId]: {
+        type: "geojson",
+        data: geojson,
+      },
+    },
+    layers,
+  } as StyleSpecification;
+}
+
+export function getLayersAtPosition(
+  map: Map,
+  position: number,
+): LayerSpecificationWithSource[] {
+  const layers = map.getStyle().layers;
+  const layersWithSource = layers.filter(
+    (layer) => layer.type !== "background", //TODO background layers is not managed
+  ) as LayerSpecificationWithSource[];
+  return layersWithSource.filter(
+    (layer) =>
+      (layer.metadata as LayerMetadataSpecification)?.sourcePosition ===
+      position,
+  );
+}
+
+export function getBeforeId(map: Map, position: number): string | undefined {
+  const beforeLayer = map
+    .getStyle()
+    .layers.find(
+      (layer) =>
+        (layer.metadata as LayerMetadataSpecification).sourcePosition ===
+        position + 1,
+    );
+  return beforeLayer ? beforeLayer.id : undefined;
+}
+
+export function generateLayerId(layerModel: MapContextLayer) {
+  return getHash(layerModel, [
+    "name",
+    "style",
+    "visibility",
+    "opacity",
+    "version",
+    "extras",
+  ]);
+}