@masterportal/masterportalapi 2.1.1

package/src/layer/vectorBase.js

@@ -0,0 +1,39 @@
+
+import VectorLayer from "ol/layer/Vector.js";
+import VectorSource from "ol/source/Vector.js";
+
+/**
+ * Triggered by Layer to create a layerSource
+ * @returns {void}
+ */
+export function createLayerSource () {
+    return new VectorSource();
+}
+
+/**
+ * updates the source
+ * @param {module:ol/layer/Base~BaseLayer} layer The vector base layer that is to be updated.
+ * @param {module:ol/Feature~Feature[]} features The ol features.
+ * @returns {void}
+ */
+export function updateSource (layer, features) {
+    layer.getSource().clear(true);
+    layer.getSource().addFeatures(features);
+}
+
+/**
+ * creates an vector Base
+ * @param {Object} attrs  attributes of the layer
+ * @returns {Object} layer
+ */
+export function createLayer (attrs) {
+    const source = this.createLayerSource();
+
+    return new VectorLayer({
+        source: source,
+        name: attrs.name,
+        typ: attrs.typ,
+        gfiAttributes: attrs.gfiAttributes,
+        id: attrs.id
+    });
+}

package/src/layer/wfs.js

@@ -0,0 +1,218 @@
+import VectorLayer from "ol/layer/Vector.js";
+import {bbox} from "ol/loadingstrategy.js";
+import {WFS} from "ol/format.js";
+
+import {createVectorSource, createClusterVectorSource} from "./vector";
+import {getVersion, onError, onLoad} from "../lib/wfsUtil";
+
+/**
+ * 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} featureType - type of features
+ * @property {string} featureNS - the namespace URI used for features
+ * @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 {string} version - version of WFS requests. If not set, '1.1.0' 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} wfsFilter -  xml resource as wfs filter, the content of the filter file will be sent to the wfs server as POST request
+ * @property {function} doNotLoadInitially - default false, if set to true the layer will be initialized without network call, an empty array of features is promoted - this is useful to add features later on (e.g. by filtering) to a full functional but initially empty layer
+ * @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
+ */
+
+/**
+  * @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 {function | object} Returns the 'onError' function if response is not ok, otherwise the response object.
+  */
+function handleErrors (response, onErrorFn, options, failure) {
+    if (!response.ok) {
+        return onErrorFn(`Request to wfs-filter failed. Response status is ${response.status}`, options, failure);
+    }
+    return response;
+}
+
+/**
+ * Returns the parameters for the wfs filter request.
+ * @param {object} payload to set as body
+ * @returns {object} the parameters for the wfs filter request
+ */
+function getFilterRequestParams (payload) {
+    return {
+        method: "POST",
+        headers: {
+            "Content-Type": "text/xml"
+        },
+        body: payload
+    };
+}
+/**
+ * Loads the WFS.
+ * Filters the features after load, if options.featuresFilter is given.
+ * Adds the features to the source.
+ * Errors are thrown through onErrorFn or if a network issue occurs.
+ *
+ * @param {string} url url to load features from
+ * @param {object} params extra loading parameters
+ * @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
+ * @returns {void}
+ */
+function loadWFS (url, params, source, {onErrorFn, success, failure}, options) {
+    fetch(url, params)
+        .then((response) => handleErrors(response, onErrorFn, options, failure))
+        .then((response) => response.text())
+        .then(responseString => source.getFormat().readFeatures(responseString))
+        .then(features => onLoad(source, features, onErrorFn, success, failure, options))
+        .catch((error) => {
+            console.error(error);
+        });
+}
+/**
+ * Loads the WFS filter. The content of the filter file will be sent to the wfs server as POST request.
+ * Filters the features after load, if options.featuresFilter is given.
+ * Adds the features to the source.
+ * Errors are thrown through onErrorFn or if a network issue occurs.
+ *
+ * @param {string} filter xml resource as wfs filter
+ * @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
+ * @returns {void}
+ */
+function loadWFSFilter (filter, url, source, {onErrorFn, success, failure}, options) {
+    fetch(filter)
+        .then((response) => handleErrors(response, onErrorFn, options, failure))
+        .then((response) => response.text())
+        .then((payload) => loadWFS(url, getFilterRequestParams(payload), source, {onErrorFn, success, failure}, options))
+        .catch((error) => {
+            console.error(error);
+        });
+}
+
+/**
+ * Creates the url for request wfs.
+ * A distinction is made between the wfs versions.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {String} version version of wfs
+ * @param {String} projection projection of wfs
+ * @param {String} bboxParam bbox loading strategy
+ * @returns {string} the url
+ */
+function createUrl (rawLayer, version, projection, bboxParam) {
+    let url = `${rawLayer.url}?service=WFS&version=${version}&request=GetFeature&srsName=${projection.getCode()}${bboxParam}`;
+
+    if (version === "1.0.0" || version === "1.1.0") {
+        url = `${url}&typeName=${rawLayer.featureType}`;
+    }
+    else if (version === "2.0.0") {
+        url = `${url}&typeNames=${rawLayer.featureType}`;
+    }
+
+    return url;
+}
+
+/**
+ * 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
+ * {@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 version = getVersion(rawLayer, options),
+        format = new WFS({
+            featureNS: rawLayer.featureNS,
+            version: version
+        });
+    let source = null;
+
+    function loader (extent, resolution, projection, success, failure) {
+        if (options.doNotLoadInitially) {
+            onLoad(source, [], onError, success, failure, options);
+        }
+        else if (options.wfsFilter) {
+            loadWFSFilter(options.wfsFilter, rawLayer.url, source, {onErrorFn: onError, success, failure}, options);
+        }
+        else {
+            const bboxParam = options.loadingStrategy === bbox ? `&bbox=${extent.join(",")},${projection.getCode()}` : "";
+            let url = createUrl(rawLayer, version, projection, bboxParam);
+
+            if (options.loadingParams) {
+                for (const key in options.loadingParams) {
+                    const option = Array.isArray(options.loadingParams[key]) ? options.loadingParams[key].join(",") : options.loadingParams[key];
+
+                    if (option !== undefined && key === "bbox") {
+                        url += `&${key}=${option},${projection.getCode()}`;
+                    }
+                    else if (option !== undefined) {
+                        url += `&${key}=${option}`;
+                    }
+                }
+            }
+            loadWFS(url, {}, source, {onErrorFn: onError, success, failure}, options);
+        }
+    }
+    format.featureType = rawLayer.featureType;
+    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 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/wms.js

@@ -0,0 +1,185 @@
+import TileLayer from "ol/layer/Tile";
+import ImageLayer from "ol/layer/Image";
+import TileWMS from "ol/source/TileWMS.js";
+import TileGrid from "ol/tilegrid/TileGrid";
+import ImageWMS from "ol/source/ImageWMS.js";
+import {get as getProjection} from "ol/proj";
+
+import {getLayerWhere} from "../rawLayerList";
+
+/** @returns {number} random session id in range (0, 9999999) */
+export function generateSessionId () {
+    return Math.floor(Math.random() * 9999999);
+}
+
+/**
+ * Adds optional wms parameters to the given parameters.
+ * @param {object} params - the mandatory params of wms request url
+ * @param {object} rawLayer - layer specification as in services.json
+ * @param {boolean} [rawLayer.STYLES] - styles of the layer, if available
+ * @param {boolean} [rawLayer.TIME] - time attribute, if available
+ * @param {boolean} [rawLayer.CRS] - projection code, if available, else projection of map is used
+ * @returns {object} maps query extended parameter names to values
+ */
+export function addOptionalParams (params, rawLayer) {
+    const extendedParams = {...params},
+        rawLayerParams = {},
+        optionalParams = [
+            "STYLES",
+            "TIME",
+            "CRS"
+        ];
+
+    Object.keys(rawLayer).forEach(key => {
+        rawLayerParams[key.toUpperCase()] = rawLayer[key];
+    });
+
+    optionalParams.forEach(optionalParam => {
+        if (rawLayer[optionalParam]) {
+            extendedParams[optionalParam] = rawLayer[optionalParam];
+        }
+    });
+
+    return extendedParams;
+}
+
+/**
+ * Creates query parameters for webservice requests from rawLayer.
+ * @param {object} rawLayer - layer specification as in services.json
+ * @param {string} [rawLayer.format="image/png"] - format of images requested
+ * @param {string} rawLayer.layers - comma-separated list of requested layers
+ * @param {version} rawLayer.version - webservice version as string, e.g. "1.1.1"
+ * @param {boolean} rawLayer.transparent - whether tiles from this service should have transparency where no information is available
+ * @param {boolean} rawLayer.singleTile - whether only one tile shall be requested that fills the whole view
+ * @param {boolean} rawLayer.STYLES - styles of the layer, if available
+ * @param {(string|number)} rawLayer.tilesize - if singleTile is true, this is the requested tilesize
+ * @returns {object} maps query parameter names to values
+ */
+export function makeParams (rawLayer) {
+    let params = {};
+
+    params = Object.assign({
+        CACHEID: generateSessionId(),
+        FORMAT: rawLayer.format || "image/png",
+        LAYERS: rawLayer.layers,
+        VERSION: rawLayer.version,
+        TRANSPARENT: rawLayer.transparent,
+        SINGLETILE: rawLayer.singleTile
+    }, rawLayer.singleTile ? {} : {WIDTH: rawLayer.tilesize, HEIGHT: rawLayer.tilesize});
+
+    params = addOptionalParams(params, rawLayer);
+
+    return params;
+}
+
+/**
+ * Creates an ol/source element for the rawLayer.
+ * @param {object} rawLayer - layer specification as in services.json
+ * @param {string} [rawLayer.url] - WMS service URL
+ * @param {string} [rawLayer.serverType] - optional servertype definition: "geoserver" or "mapserver" or "qgis"
+ * @param {string} [rawLayer.gutter] - optional the size in pixels of the gutter around image tiles to ignore
+ * @param {function} [rawLayer.olAttribution] - optional function that takes a module:ol/PluggableMap~FrameState and returns a string or an array of strings representing source attributions
+ * @param {string|number} [rawLayer.tilesize] - optional needed to create the tileGrid
+ * @param {object} options - optional resolutions and origin to create the TileGrid
+ * @param {Array} [options.resolutions] - optional resolutions to create the TileGrid, must be in descending order
+ * @param {Array} [options.origin] - optional origin to create the TileGrid
+ * @param {string} [options.crs] - optional projection code, if not available, projection of map is used
+ * @returns {(ol.source.TileWMS|ol.source.ImageWMS)} TileWMS or ImageWMS, depending on whether singleTile is true.
+ */
+export function createLayerSource (rawLayer, options) {
+    const params = makeParams(rawLayer),
+        projection = rawLayer.crs ? getProjection(rawLayer.crs) : undefined;
+    let tileGrid = null;
+
+    if (rawLayer.singleTile) {
+        return new ImageWMS({
+            url: rawLayer.url,
+            params,
+            serverType: rawLayer.serverType,
+            projection: projection,
+            attributions: rawLayer.olAttribution
+        });
+    }
+    if (options && options.resolutions) {
+        tileGrid = new TileGrid({
+            resolutions: options.resolutions,
+            origin: options.origin ? options.origin : undefined,
+            tileSize: parseInt(rawLayer.tilesize, 10)
+        });
+    }
+    return new TileWMS({
+        url: rawLayer.url,
+        params,
+        gutter: rawLayer.gutter || 0,
+        tileGrid: tileGrid,
+        projection: projection,
+        attributions: rawLayer.olAttribution
+    });
+}
+
+/**
+ * Creates complete ol/Layer from rawLayer containing source and all required children.
+ * @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] - WMS service URL
+ * @param {string} [rawLayer.minScale] - optional the minimal resolution
+ * @param {string} [rawLayer.maxScale] - optional the maximal resolution
+ * @param {string} [rawLayer.serverType] - optional servertype definition: "geoserver" or "mapserver" or "qgis"
+ * @param {string} [rawLayer.gutter] - optional the size in pixels of the gutter around image tiles to ignore
+ * @param {function} [rawLayer.olAttribution] - optional function that takes a module:ol/PluggableMap~FrameState and returns a string or an array of strings representing source attributions
+ * @param {string|number} [rawLayer.tilesize] - optional needed to create the tileGrid
+ * @param {object} layerParams - additional layer params
+ * @param {object} options - optional resolutions and origin to create the TileGrid
+ * @param {Array} [options.resolutions] - optional resolutions to create the TileGrid, must be in descending order
+ * @param {Array} [options.origin] - optional origin to create the TileGrid
+ * @returns {ol.Layer} Layer that can be added to map.
+ */
+export function createLayer (rawLayer, layerParams = {}, options) {
+    const source = createLayerSource(rawLayer, options),
+        Layer = rawLayer.singleTile ? ImageLayer : TileLayer;
+
+    return new Layer(Object.assign({
+        source,
+        minResolution: rawLayer.minScale,
+        maxResolution: rawLayer.maxScale,
+        id: rawLayer.id
+    }, layerParams));
+}
+
+/**
+ * Forces an update by giving a layer a new sessionID.
+ * @param {ol.Layer} layer - the layer that is to be updated
+ * @returns {number} the new sessionID
+ */
+export function updateSource (layer) {
+    const oldSessionId = layer.getSource().getParams().SESSIONID;
+    let newSessionId = oldSessionId;
+
+    // to avoid rolling the same ID again; never happens except in your presentation
+    while (oldSessionId === newSessionId) {
+        newSessionId = generateSessionId();
+    }
+
+    layer.getSource().updateParams({SESSIONID: newSessionId});
+    return newSessionId;
+}
+
+/**
+ * Creates the gfiURL from clicked layer, map, and coordinate.
+ * @param {ol.Layer} layer - what to get the gfiURL for
+ * @param {ol.Map} map - needed for resolution/projection
+ * @param {ol.coordinate} coordinate - which point to get the gfiURL for
+ * @returns {(string|undefined)} the gfiURL, or undefined if it could not be constructed
+ */
+export function getGfiURL (layer, map, coordinate) {
+    const rawLayer = getLayerWhere({Id: layer.get("id")}),
+        resolution = map.getView().getResolution(),
+        projection = map.getView().getProjection(),
+        params = Object.assign({
+            INFO_FORMAT: (rawLayer && rawLayer.infoFormat) || "text/xml"
+        }, rawLayer && typeof rawLayer.featureCount !== "undefined"
+            ? {FEATURE_COUNT: rawLayer.featureCount}
+            : {});
+
+    return layer.getSource().getFeatureInfoUrl(coordinate, resolution, projection, params);
+}

package/src/lib/coordsToPairs.js

@@ -0,0 +1,15 @@
+/**
+ * Parses stramed coordinates to pairs of coordinates.
+ * @param {(string[]|number[])} coordinates - flat coordinates where two following belong together
+ * @returns {Array.<number[]>} array of coordinate pairs
+ */
+export default function coordsToPairs (coordinates) {
+    const floatCoords = coordinates.map(parseFloat),
+        result = [];
+
+    while (floatCoords.length) {
+        result.push(floatCoords.splice(0, 2));
+    }
+
+    return result;
+}

package/src/lib/getInitialLayers.js

@@ -0,0 +1,22 @@
+import defaults from "../defaults";
+
+/**
+ * Returns the layers to be initialized as soon as services are known.
+ * @param {object} config - configuration object
+ * @returns {object[]} array of layer initialization objects
+ * @ignore
+ */
+export default function (config) {
+    // user specified what to do => use that
+    if (Array.isArray(config.layers)) {
+        return config.layers;
+    }
+
+    // user didn't specify, layerConf is lgv services => use default for lgv services
+    if (typeof config.layerConf === "undefined" || config.layerConf === defaults.layerConf) {
+        return defaults.layers;
+    }
+
+    // user didn't specify, layerConf is not known => don't set anything initially
+    return [];
+}

package/src/lib/load3DScript.js

@@ -0,0 +1,22 @@
+/**
+ * Loads the specified JS and calls the given callback after the file has loaded. Modifies the DOM for loading.
+ * @param {String} fileName - The URL to Load
+ * @param {Function} callback - the Function to call after loading has completed
+ * @returns {undefined}
+ */
+export function load3DScript (fileName, callback) {
+    const head = document.getElementsByTagName("head")[0],
+        script = document.createElement("script");
+
+    script.type = "text/javascript";
+    script.src = fileName;
+
+    script.onload = callback;
+    script.onreadystatechange = function () {
+        if (this.readyState === "complete") {
+            return callback();
+        }
+        return null;
+    };
+    head.appendChild(script);
+}

package/src/lib/oafUtil.js

@@ -0,0 +1,22 @@
+/**
+ * Parsing the params object in to string for url
+ * @param {Object} params the paramters in object
+ * @returns {String} The url parameters in string format
+ */
+function getParamsUrl (params) {
+    if (!params || typeof params !== "object" || params.constructor !== Object || !Object.keys(params).length) {
+        return "";
+    }
+
+    let paramsUrl = "";
+
+    Object.entries(params).forEach(([key, value]) => {
+        paramsUrl += "&" + key + "=" + value;
+    });
+
+    return paramsUrl;
+}
+
+export {
+    getParamsUrl
+};

package/src/lib/setBackgroundImage.js

@@ -0,0 +1,23 @@
+import defaults from "../defaults";
+
+/**
+ * Sets the configured background image to the div the map is to be rendered in.
+ * @param {object} [config={}] - user configuration
+ * @param {string} [config.target] - id of map div
+ * @param {string} [config.backgroundImage] - image URL to set; "" means none, undefined means default
+ * @returns {undefined}
+ */
+function setBackgroundImage ({backgroundImage, target} = {}) {
+    const div = document.getElementById(target || defaults.target);
+
+    if (div) {
+        const urlString = `url(${
+            // keep "" as explicit none
+            typeof backgroundImage === "string" ? backgroundImage : defaults.backgroundImage
+        })`;
+
+        div.style.backgroundImage = urlString;
+    }
+}
+
+export default setBackgroundImage;

package/src/lib/wfsUtil.js

@@ -0,0 +1,75 @@
+
+/**
+ * Checks the version of the wfs against allowed versions and returns the version.
+ * If the version is not allowed, 1.1.0 is returned.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {options} [options] additional options
+ * @returns {String} The allowed version.
+ */
+function getVersion (rawLayer, options) {
+    const allowedVersions = ["1.0.0", "1.1.0", "2.0.0"];
+    let version = options.version || rawLayer.version;
+
+    if (!allowedVersions.includes(version)) {
+        version = allowedVersions[1];
+        console.warn(`The "${rawLayer.typ}" layer with the id: "${rawLayer.id}" is configured in version: ${version}.`
+            + ` OpenLayers accepts "${rawLayer.typ}" only in the versions: ${allowedVersions},`
+            + ` It tries to load the layer with the id: "${rawLayer.id}" in version ${allowedVersions[1]}!`);
+    }
+
+    return version;
+}
+
+/**
+ * Logs and throws an Error.
+ * @param {string} error error message
+ * @param {object} [options] additional options
+ * @param {function} [options.onLoadingError] additional option, called with param error
+ * @param {function} failure failure callback to ol.VectorLayer, fires 'featuresloaderror' event
+ * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure: see}
+ * @returns {void}
+ */
+function onError (error, options = {}, failure) {
+    if (options.onLoadingError) {
+        options.onLoadingError(error);
+    }
+    failure(error);
+    throw Error(error);
+}
+
+/**
+ * Called after features are loaded. Calls options.featuresFilter, success-callback and options.afterLoading.
+ * Features are added to source.
+ * @param {ol.source.VectorSource} source the vector source
+ * @param {Array.<module:ol/Feature~Feature>} features loaded features
+ * @param {function} onErrorFn  Calls options.onLoadingError and 'featuresloaderror' event will be fired by using failure callback.
+ * @param {function} success  callback: 'featuresloadend' event will be fired
+ * @param {function} failure failure callback to ol.VectorLayer, fires 'featuresloaderror' event
+ * @param {options} [options] additional options
+ * @returns {void}
+ */
+function onLoad (source, features, onErrorFn, success, failure, options = {}) {
+    let filteredFeatures = features;
+
+    try {
+        if (options.featuresFilter) {
+            filteredFeatures = options.featuresFilter(features);
+        }
+        source.addFeatures(filteredFeatures);
+        if (options.afterLoading) {
+            options.afterLoading(filteredFeatures);
+        }
+        // success: see https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html
+        success(filteredFeatures);
+    }
+    catch (error) {
+        console.error(error);
+        onErrorFn(error, options, failure);
+    }
+}
+
+export {
+    getVersion,
+    onError,
+    onLoad
+};

package/src/lib/zoomTo.js

@@ -0,0 +1,40 @@
+import Polygon from "ol/geom/Polygon";
+import Point from "ol/geom/Point";
+
+import coordsToPairs from "./coordsToPairs";
+
+/**
+ * Zooms the map to a geometry.
+ * @param {ol/Map} map map object to zoom
+ * @param {(ol/geom/SimpleGeometry|ol/extent)} geometryOrExtent the geometry or extent to zoom to
+ * @param {object} [params={}] forwarded to ol/View.fit, may e.g. specify duration of animation {@link https://openlayers.org/en/latest/apidoc/module-ol_View.html#~FitOptions}
+ * @returns {void}
+ */
+export default function zoomTo (map, geometryOrExtent, params = {}) {
+    map.getView().fit(geometryOrExtent, params);
+}
+
+/**
+ * Zooms the map to a searchResult.
+ * @param {ol/Map} map map object to zoom
+ * @param {SearchResult} searchResult result from searchAddress
+ * @param {object} [params={}] forwarded to ol/View.fit, may e.g. specify duration of animation {@link https://openlayers.org/en/latest/apidoc/module-ol_View.html#~FitOptions}
+ * @returns {void}
+ */
+export function zoomToSearchResult (map, searchResult, params = {}) {
+    let geom;
+
+    switch (searchResult.geometry.type) {
+        case "Polygon":
+            geom = new Polygon([coordsToPairs(searchResult.geometry.coordinates)]);
+            break;
+        case "Point":
+            geom = new Point(searchResult.geometry.coordinates.map(parseFloat));
+            break;
+        default:
+            console.warn(`ZoomTo for type ${searchResult.geometry.type} not implemented.`);
+            return;
+    }
+
+    zoomTo(map, geom, params);
+}

package/src/maps/api.js

@@ -0,0 +1,5 @@
+import {default as map} from "./map.js";
+
+export default {
+    map
+};