@masterportal/masterportalapi 2.1.1

package/src/defaults.js

@@ -0,0 +1,38 @@
+/**
+ * Since all functions are exported for users, all functions with defaults
+ * have to import this object themselves to use fallbacks.
+ * @type {object}
+ * @ignore
+ */
+export default {
+    target: "map",
+    epsg: "EPSG:25832",
+    backgroundImage: "",
+    extent: [510000.0, 5850000.0, 625000.4, 6000000.0],
+    options: [
+        {resolution: 66.14579761460263, scale: 250000, zoomLevel: 0},
+        {resolution: 26.458319045841044, scale: 100000, zoomLevel: 1},
+        {resolution: 15.874991427504629, scale: 60000, zoomLevel: 2},
+        {resolution: 10.583327618336419, scale: 40000, zoomLevel: 3},
+        {resolution: 5.2916638091682096, scale: 20000, zoomLevel: 4},
+        {resolution: 2.6458319045841048, scale: 10000, zoomLevel: 5},
+        {resolution: 1.3229159522920524, scale: 5000, zoomLevel: 6},
+        {resolution: 0.6614579761460262, scale: 2500, zoomLevel: 7},
+        {resolution: 0.2645831904584105, scale: 1000, zoomLevel: 8},
+        {resolution: 0.13229159522920521, scale: 500, zoomLevel: 9}
+    ],
+    namedProjections: [
+        ["EPSG:25832", "+proj=utm +zone=32 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs"]
+    ],
+    startResolution: 15.874991427504629,
+    startCenter: [565874, 5934140],
+    layerConf: "https://geodienste.hamburg.de/services-internet.json",
+    layers: [
+        {
+            "id": "453",
+            "visibility": true
+        }
+    ],
+    gazetteerUrl: "https://geodienste.hamburg.de/HH_WFS_GAGES?service=WFS&request=GetFeature&version=2.0.0",
+    showGeographicIdentifier: false
+};

package/src/index.js

@@ -0,0 +1,30 @@
+import {createMapView} from "./maps/mapView";
+import * as crs from "./crs";
+import * as rawLayerList from "./rawLayerList";
+import * as wms from "./layer/wms";
+import * as wfs from "./layer/wfs";
+import * as geojson from "./layer/geojson";
+import * as vectorBase from "./layer/vectorBase";
+import * as oaf from "./layer/oaf";
+import * as terrain from "./layer/terrain";
+import Tileset from "./layer/tileset";
+import * as layerLib from "./layer/lib";
+import {search, setGazetteerUrl} from "./searchAddress";
+import setBackgroundImage from "./lib/setBackgroundImage";
+
+export {
+    createMapView,
+    wms,
+    wfs,
+    geojson,
+    layerLib,
+    vectorBase,
+    oaf,
+    terrain,
+    Tileset,
+    setBackgroundImage,
+    setGazetteerUrl,
+    rawLayerList,
+    search,
+    crs
+};

package/src/layer/geojson/index.js

@@ -0,0 +1,109 @@
+import VectorLayer from "ol/layer/Vector";
+import GeoJSON from "ol/format/GeoJSON.js";
+import style, {setCustomStyles} from "./style";
+
+
+import {createVectorSource, createClusterVectorSource} from "../vector";
+
+// forward import to export
+export {setCustomStyles};
+
+/**
+ * Creates the VectorSource for a GeoJSON layer. It will ensure each feature has the field id set to use with the other exported geojson functions.
+ * @param {object} rawLayer - rawLayer as specified in services.json
+ * @param {string} [rawLayer.url] - url to fetch geojson from; if no rawLayer.features given, this is required
+ * @param {object} [rawLayer.features] - if features are transmitted via rawLayer, they will be used instead of requesting an URL
+ * @param {object} options - options of the geojson layer
+ * @returns {ol.source.Vector} created VectorSource
+ */
+export function createLayerSource ({url, features, clusterDistance}, options) {
+    const format = new GeoJSON();
+    let source = null;
+
+    source = createVectorSource(url || features, options.loadingStrategy, format);
+
+    if (clusterDistance) {
+        return createClusterVectorSource(source, clusterDistance, options.clusterGeometryFunction);
+    }
+    return source;
+}
+
+/**
+ * Creates a layer for GeoJSON.
+ * @param {object} rawLayer - rawLayer as specified in services.json
+ * @param {object} [layerParams={}] - extra params of the layer
+ * @param {object} [options={}] - parameter object
+ * @param {ol.Map} [options.map] - map the geojson is to be projected on
+ * @param {ol.Style} [options.layerStyle] - optional style; if not given, default styling (modifiable by setCustomStyles) is used
+ * @returns {ol.layer.Vector} Layer with id and source specified in rawLayer
+ */
+export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
+    const layer = new VectorLayer(Object.assign({
+        id: rawLayer.id,
+        source: createLayerSource(rawLayer, options)
+    }, layerParams));
+
+    if (options.style) {
+        layer.setStyle(options.style);
+    }
+    else if (rawLayer.style) {
+        layer.setStyle(rawLayer.style);
+    }
+    else {
+        layer.setStyle(style);
+    }
+    return layer;
+}
+
+/**
+ * GeoJSON layer with an URL will be reloaded. All other layers will be refreshed.
+ * @param {ol.layer.Vector} layer - GeoJSON layer to update
+ * @returns {undefined}
+ */
+export function updateSource (layer) {
+    // openlayers named this "refresh", but it also means "reload" if an URL is set
+    layer.getSource().refresh();
+}
+
+/**
+ * Sets a style to all given features.
+ * @param {ol.Feature[]} features - openlayers features to be styled
+ * @param {ol.style.Style~StyleLike} featureStyle - style, array of styles, or style function
+ * @returns {undefined}
+ */
+export function setFeatureStyle (features, featureStyle) {
+    features.forEach(feature => feature.setStyle(featureStyle));
+}
+
+/**
+ * @param {ol.Layer} layer - layer to hide all features of
+ * @returns {undefined}
+ */
+export function hideAllFeatures (layer) {
+    // () => null is the "do not display" function for openlayers (overriding VectorLayer styles)
+    setFeatureStyle(layer.getSource().getFeatures(), () => null);
+}
+
+/**
+ * @param {ol.Layer} layer - layer to show all features of
+ * @returns {undefined}
+ */
+export function showAllFeatures (layer) {
+    // if feature has undefined style, openlayers will check containing VectorLayer for styles
+    setFeatureStyle(layer.getSource().getFeatures(), undefined);
+}
+
+/**
+ * @param {ol.Layer} layer - layer to show some features of
+ * @param {string[]} featureIdList - list of feature.id to show
+ * @returns {undefined}
+ */
+export function showFeaturesById (layer, featureIdList) {
+    const features = layer
+        .getSource()
+        .getFeatures()
+        .filter(feature => featureIdList.indexOf(feature.getId()) >= 0);
+
+    hideAllFeatures(layer);
+    setFeatureStyle(features, undefined);
+}

package/src/layer/geojson/style.js

@@ -0,0 +1,61 @@
+import {Style, Icon, Stroke, Fill} from "ol/style.js";
+import markerSvg from "../../../public/marker.svg";
+
+let customStyles = {};
+
+/**
+ * Allows setting custom styles. When available, they will be used.
+ * @param {object.<string, ol.Style>} styles - lookup from feature's geometry type (Point, LineString, ...) to style
+ * @returns {undefined}
+ */
+export function setCustomStyles (styles) {
+    customStyles = styles;
+}
+
+// // // STYLE PARTS
+const marker = new Icon({
+        src: markerSvg,
+        // center bottom of marker 📍 is intended to show the spot
+        anchor: [0.5, 1]
+    }),
+    stroke = new Stroke({
+        width: 2,
+        color: "#005CA9"
+    }),
+    fill = new Fill({
+        color: "#005CA915"
+    }),
+
+    // // // STYLES
+    pointStyle = new Style({image: marker}),
+    lineStyle = new Style({stroke}),
+    polygonStyle = new Style({stroke, fill}),
+    circleStyle = new Style({stroke, fill}),
+    geometryCollectionStyle = new Style({stroke, fill, image: marker}),
+
+    // // // DEFAULT STYLE LOOKUP
+    defaultStyles = {
+        Point: pointStyle,
+        LineString: lineStyle,
+        MultiLineString: lineStyle,
+        MultiPoint: pointStyle,
+        MultiPolygon: polygonStyle,
+        Polygon: polygonStyle,
+        GeometryCollection: geometryCollectionStyle,
+        Circle: circleStyle
+    };
+
+/**
+ * Style function according to https://openlayers.org/en/latest/apidoc/module-ol_style_Style.html#~StyleFunction.
+ * Will use custom values first, if set, and fall back on holes in definition.
+ * @param {ol.Feature} feature - to be styled
+ * @returns {ol.Style} style for feature
+ * @ignore
+ */
+function style (feature) {
+    const type = feature.getGeometry().getType();
+
+    return customStyles[type] || defaultStyles[type];
+}
+
+export default style;

package/src/layer/lib.js

@@ -0,0 +1,32 @@
+/**
+ * @param {ol.Layer} layer - layer to check
+ * @param {number} params - parameter object
+ * @param {number} [params.resolution] - resolution to check; if not given, map is required
+ * @param {object} [params.map] - map to check; if not given, resolution is required
+ * @returns {boolean} whether layer is visible in given resolution
+ */
+export function isLayerVisibleInResolution (layer, {resolution, map}) {
+    const r = typeof resolution === "undefined"
+        ? map.getView().getResolution()
+        : resolution;
+
+    return layer.getMaxResolution() >= r && r >= layer.getMinResolution();
+}
+
+/**
+ * Generates an array of URLs that are supposed to hold legend graphics.
+ *
+ * @param {*} rawLayer - layer specification as in services.json
+ * @param {string} [rawLayer.layers=""] - comma separated list of service layers
+ * @returns {string[]} URLs of legend graphics for the rawLayer.
+ */
+export function getLegendURLs ({legendURL, layers = "", url, typ, format, version}) {
+    if (legendURL) {
+        return legendURL === "ignore" ? [] : [legendURL];
+    }
+
+    return layers
+        .split(",")
+        .filter(x => x /* filters empty string since it's falsy */)
+        .map(layerName => `${url}?SERVICE=${typ}&REQUEST=GetLegendGraphic&FORMAT=${format || "image/png"}&VERSION=${version}&LAYER=${layerName}`);
+}

package/src/layer/oaf.js

@@ -0,0 +1,207 @@
+import VectorLayer from "ol/layer/Vector.js";
+import {bbox} from "ol/loadingstrategy.js";
+import GeoJSON from "ol/format/GeoJSON.js";
+import {createVectorSource, createClusterVectorSource} from "./vector";
+import {onError, onLoad} from "../lib/wfsUtil";
+import {getParamsUrl} from "../lib/oafUtil";
+
+/**
+ * Layer specification as in services.json.
+ * @typedef {Object} rawLayer
+ * @property {string} id - id of the layer
+ * @property {string} url - url to load features from
+ * @property {string} collection - name of the oaf collection
+ * @property {number} clusterDistance - pixel radius, within this radius, all features are "clustered" into one feature - if available, a cluster source is created.
+ * @property {function} style - style function to style the layer if options.style is not set
+ */
+
+/**
+ * Additional options used to create and load the layer source.
+ * @typedef {Object} options
+ * @property {module:ol.source.Vector~LoadingStrategy} loadingStrategy - the loading strategy to use, if not set 'bbox' is used
+ * @property {function} onLoadingError - function called on loading error, gets parameter error
+ * @property {function} beforeLoading - function called before loading
+ * @property {function} afterLoading - function called after loading, gets parameter features
+ * @property {function} featuresFilter - function called after loading to filter features, gets parameter features
+ * @property {function} clusterGeometryFunction -  used in cluster source. Returns the geometry of the cluster, gets parameter feature
+ * @property {function} style - style function to style the layer
+ * @property {object} loadingParams - added as params to url
+ */
+
+/**
+ * Returns the 'onError' function if response is not ok
+ * @param {object} response of the request
+ * @param {function} onErrorFn Calls options.onLoadingError and 'featuresloaderror' event will be fired by using failure callback.
+ * @param {options} [options] additional options
+ * @param {function} failure failure callback to ol.VectorLayer, fires 'featuresloaderror' event
+ * @returns {void}
+ */
+function handleErrors (response, onErrorFn, options, failure) {
+    if (!response.ok) {
+        return onErrorFn(`Request to wfs-filter failed. Response status is ${response.statusText}`, options, failure);
+    }
+    return response;
+}
+
+
+/**
+* Parses the given feature collection for the next nextLink.
+* @param {Object} featureCollection the feature collection
+* @returns {String|Boolean} the next link or false if no next link exists
+*/
+function getNextLinkFromFeatureCollection (featureCollection) {
+    if (typeof featureCollection !== "object" || featureCollection === null || !Array.isArray(featureCollection.links)) {
+        return false;
+    }
+    for (let i = 0; i < featureCollection.links.length; i++) {
+        if (
+            typeof featureCollection.links[i] === "object" && featureCollection.links[i] !== null
+            && typeof featureCollection.links[i].href === "string"
+            && featureCollection.links[i].title === "next page"
+        ) {
+            return featureCollection.links[i].href;
+        }
+    }
+    return false;
+}
+
+/**
+ * Loads the Layer Source (Geojson).
+ * Iterates over all collection pages and collect it.
+ * Filters the features after load, if options.featuresFilter is given.
+ * Adds the features to the source.
+ * @param {string} url url to load features from
+ * @param {ol.source.VectorSource} source the vector source
+ * @param {object} errorAndSuccessFns functions to handle error and success
+ * @param {function} errorAndSuccessFns.onErrorFn  Calls options.onLoadingError and 'featuresloaderror' event will be fired by using failure callback.
+ * @param {function} errorAndSuccessFns.success  callback: 'featuresloadend' event will be fired
+ * @param {function} errorAndSuccessFns.failure failure callback to ol.VectorLayer, fires 'featuresloaderror' event
+ * @param {options} [options] optional additional options
+ * @param {Object[]} collectedFeatures the features from previous calls
+ * @returns {void}
+ */
+function loadSource (url, source, {onErrorFn, success, failure}, options, collectedFeatures = []) {
+    const params = {
+        headers: {
+            Accept: "application/geo+json"
+        },
+        method: "GET"
+    };
+
+    fetch(url, params)
+        .then((response) => handleErrors(response, onErrorFn, options, failure))
+        .then((response) => response.json())
+        .then(responseJson => {
+            const nextLink = getNextLinkFromFeatureCollection(responseJson);
+
+            responseJson.features.forEach(feature => collectedFeatures.push(feature));
+            if (typeof nextLink === "string") {
+                loadSource(nextLink, source, {onErrorFn: onError, success, failure}, options, collectedFeatures);
+                return;
+            }
+            responseJson.features = collectedFeatures;
+            responseJson.numberReturned = responseJson.numberMatched;
+            onLoad(source, source.getFormat().readFeatures(responseJson), onErrorFn, success, failure, options);
+        })
+        .catch((error) => {
+            onErrorFn(error, options, failure);
+        });
+}
+
+/**
+ * Creates an ol/source element for the rawLayer by using a loader.
+ * The 'featuresloadend' and 'featuresloaderror' events will be fired by using success and failure callbacks of the loader.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {options} [options] additional options
+ * @param {String} url the parsed url
+ * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure/success see}
+ * @returns {(ol.source.VectorSource|ol.source.Cluster)} VectorSource or Cluster, depending on whether clusterDistance is set.
+ */
+function getLayerSource (rawLayer, options, url) {
+    const format = new GeoJSON();
+    let source = null;
+
+    function loader (extent, resolution, projection, success, failure) {
+        loadSource(url, source, {onErrorFn: onError, success, failure}, options);
+    }
+    source = createVectorSource(loader, options.loadingStrategy, format);
+
+    if (options.beforeLoading) {
+        source.once("featuresloadstart", () => options.beforeLoading());
+    }
+
+    if (rawLayer.clusterDistance) {
+        return createClusterVectorSource(source, rawLayer.clusterDistance, options.clusterGeometryFunction);
+    }
+    return source;
+}
+
+/**
+ * Creates the url for OAF request.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @returns {string} the url
+ */
+function createUrl (rawLayer) {
+    let url = rawLayer.url,
+        appendingString;
+    const crsDefault = "";
+
+    url += typeof rawLayer.collection === "string" ? "/collections/" + rawLayer.collection + "/items?" : "";
+    url += typeof rawLayer.limit === "number" ? "limit=" + rawLayer.limit + "&" : "";
+    if (Array.isArray(rawLayer.bbox) && rawLayer.bbox.length === 4) {
+        appendingString = "";
+
+        rawLayer.bbox.forEach((bboxEntry, i) => {
+            appendingString += i !== rawLayer.bbox.length - 1 ? bboxEntry + "," : bboxEntry;
+        });
+        url += "bbox=" + appendingString + "&";
+    }
+    url += typeof rawLayer.bboxCrs === "string" && rawLayer.bboxCrs !== "" ? "bbox-crs=" + encodeURIComponent(rawLayer.bboxCrs) + "&" : "";
+    url += "crs=" + encodeURIComponent(typeof rawLayer.crs === "string" && rawLayer.crs !== "" ? rawLayer.crs : crsDefault) + "&";
+    url += typeof rawLayer.datetime === "string" && rawLayer.datetime !== "" ? "datetime=" + rawLayer.datetime + "&" : "";
+    url += getParamsUrl(rawLayer.params);
+
+    return url;
+}
+
+/**
+ * Creates an ol/source element for the rawLayer by OAF (XML or Geojson)
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {options} [options] additional options
+ * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure/success see}
+ * @returns {(ol.source.VectorSource|ol.source.Cluster)} VectorSource or Cluster, depending on whether clusterDistance is set.
+ */
+export function createLayerSource (rawLayer, options = {}) {
+    if (!options.loadingStrategy) {
+        options.loadingStrategy = bbox;
+    }
+
+    const url = createUrl(rawLayer),
+        source = getLayerSource(rawLayer, options, url);
+
+    return source;
+}
+
+/**
+ * Creates complete ol/Layer from rawLayer containing all required children.
+ * @param {rawLayer} rawLayer - layer specification as in services.json
+ * @param {object} [optionalParams] - optional params
+ * @param {object} [optionalParams.layerParams] - additional layer params
+ * @param {options} [optionalParams.options] - additional options
+ * @returns {ol.Layer} Layer that can be added to map.
+ */
+export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
+    const source = createLayerSource(rawLayer, options),
+        layer = new VectorLayer(Object.assign({
+            source,
+            id: rawLayer.id
+        }, layerParams));
+
+    if (options.style) {
+        layer.setStyle(options.style);
+    }
+    else if (rawLayer.style) {
+        layer.setStyle(rawLayer.style);
+    }
+    return layer;
+}

package/src/layer/terrain.js

@@ -0,0 +1,72 @@
+/**
+ * Creates a terrain provider with the cesiumTerrainProviderOptions, if not exists.
+ * @param {Object} rawLayer  attributes of the layer
+ * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
+ * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+ * @returns {void}
+ */
+function createTerrainProvider (rawLayer) {
+    const options = {};
+
+    if (rawLayer.cesiumTerrainProviderOptions) {
+        Object.assign(options, rawLayer.cesiumTerrainProviderOptions);
+    }
+    options.url = rawLayer.url;
+    /* eslint-disable no-undef */
+    return new Cesium.CesiumTerrainProvider(options);
+}
+
+/**
+ * Sets the layers visibility by setting the terrain provider at Cesium scene.
+ * @param {boolean} value  if true, terrainProvider is set to map and terrain will be visible
+ * @param {Object} rawLayer  attributes of the layer
+ * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
+ * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+ * @param {OLCesium} map ol cesium map
+ * @returns {void}
+ */
+export function setVisible (value, rawLayer, map) {
+    if (map && typeof map.getCesiumScene === "function") {
+        if (value) {
+            map.getCesiumScene().terrainProvider = createTerrainProvider(rawLayer);
+        }
+        else {
+            /* eslint-disable no-undef */
+            map.getCesiumScene().terrainProvider = new Cesium.EllipsoidTerrainProvider({});
+        }
+    }
+}
+
+/**
+ * Creates an terrain layer to use in ol-Cesium map.
+ * @param {Object} rawLayer - layer specification as in services.json
+ * @param {string} [rawLayer.id] - optional id of the layer, passed to help identification in services.json
+ * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
+ * @param {string} [rawLayer.isSelected] - if true, terrain is created and shown
+ * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+ * @param {OLCesium} map ol cesium map
+ * @returns {Object} layer
+ */
+export function createLayer (rawLayer, map) {
+    this.values = {
+        name: rawLayer.name,
+        id: rawLayer.id,
+        typ: rawLayer.typ
+    };
+    if (rawLayer.isSelected && map && typeof map.getCesiumScene === "function") {
+        setVisible(true, rawLayer, map);
+    }
+    return this;
+}
+/**
+ * Returns the value for the given key of the rawlayer.
+ * @param {String} key to get the value for
+ * @returns {*} the value to the key
+ */
+export function get (key) {
+    if (!this.values) {
+        return undefined;
+    }
+    return this.values[key];
+}
+

package/src/layer/tileset.js

@@ -0,0 +1,71 @@
+/**
+ * Creates the tileset.
+ * @param {Object} rawLayer  attributes of the layer
+ * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
+ * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+ * @returns {Cesium.Cesium3DTileset} the tileset
+ */
+function createTileSet (rawLayer) {
+    const url = rawLayer.url.split("?")[0] + "/tileset.json",
+        options = {};
+
+    if (rawLayer.cesium3DTilesetOptions) {
+        Object.assign(options, rawLayer.cesium3DTilesetOptions);
+    }
+    options.url = url;
+    /* eslint-disable no-undef */
+    return new Cesium.Cesium3DTileset(options);
+}
+/**
+ * Creates an terrain layer to use in ol-Cesium map. Sets the id of the rawlayer to tileset.layerReferenceId.
+ * @param {Object} rawLayer - layer specification as in services.json
+ * @param {string} [rawLayer.id] - optional id of the layer, passed to help identification in services.json
+ * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
+ * @param {string} [rawLayer.isSelected] - if true, terrain is created and shown
+ * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+ * @param {OLCesium} map ol cesium map
+ * @returns {void}
+ */
+export default function Tileset (rawLayer, map) {
+    this.values = {
+        name: rawLayer.name,
+        id: rawLayer.id,
+        typ: rawLayer.typ
+    };
+    this.tileset = createTileSet(rawLayer);
+    this.tileset.layerReferenceId = rawLayer.id;
+
+    if (rawLayer.isSelected && map && typeof map.getCesiumScene === "function") {
+        this.setVisible(true, map);
+    }
+}
+/**
+ *
+ * @param {boolean} value  if true, terrainProvider is set to map and terrain will be visible
+ * @param {OLCesium} map ol cesium map
+ * @returns {void}
+ */
+Tileset.prototype.setVisible = function (value, map) {
+    if (map && typeof map.getCesiumScene === "function") {
+        if (value) {
+            if (!map.getCesiumScene().primitives.contains(this.tileset)) {
+                map.getCesiumScene().primitives.add(this.tileset);
+            }
+            this.tileset.show = true;
+        }
+        else {
+            this.tileset.show = false;
+        }
+    }
+};
+/**
+ * Returns the value for the given key of the rawlayer.
+ * @param {String} key to get the value for
+ * @returns {*} the value to the key
+ */
+Tileset.prototype.get = function (key) {
+    if (!this.values) {
+        return undefined;
+    }
+    return this.values[key];
+};

package/src/layer/vector.js

@@ -0,0 +1,48 @@
+import VectorSource from "ol/source/Vector.js";
+import Cluster from "ol/source/Cluster.js";
+
+/**
+ * Creates a VectorSource.
+ * @param {function|string} urlOrLoader loader-function to load the features or an url to load them
+ * @param {module:ol.source.Vector~LoadingStrategy} strategy The loading strategy to use.
+ * @param {module:ol.Format} format to parse the response with
+ * @returns {(module:ol.source.VectorSource|module:ol.source.Cluster)} the VectorSource
+ */
+export function createVectorSource (urlOrLoader, strategy, format) {
+    let loader,
+        url,
+        features;
+
+    if (typeof urlOrLoader === "string") {
+        url = urlOrLoader;
+    }
+    else if (typeof urlOrLoader === "function") {
+        loader = urlOrLoader;
+    }
+    else if (typeof urlOrLoader === "object") {
+        features = format.readFeatures(urlOrLoader, {
+            dataProjection: "EPSG:4326",
+            featureProjection: "EPSG:25832"
+        });
+    }
+    return new VectorSource({
+        loader,
+        features,
+        url,
+        strategy,
+        format
+    });
+}
+/**
+ * Creates a Cluster.
+ * @param {module:ol.source.VectorSource} source the source of the layer
+ * @param {number} distance - Pixel radius, within this radius, all features are "clustered" into one feature. If available, a cluster source is created.
+ * @param {function | undefined} geometryFunction - returns the geometry of the cluster, gets parameter feature. When a feature should not be considered for clustering, the function should return null.
+ * @returns {module:ol.source.Cluster} the Cluster
+ */
+export function createClusterVectorSource (source, distance, geometryFunction) {
+    return new Cluster({
+        source,
+        distance,
+        geometryFunction});
+}