@masterportal/masterportalapi 2.21.0 → 2.23.0

package/CHANGELOG.md

@@ -3,13 +3,33 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
-## 2.21.0 - 2023-07-20
+## 2.23.0 - 2023-08-02
+### Added
+- VectorStyle: Add Styling rules for Geoemtries of type `Circle`.
+- Add Styling and zIndex to draw interactions and improve the draw behavior.
+- Add select and modify interactions for editing ol features.
+
+### Fixed
+- The legend for wfs is now created again via the Describefeaturetype.
+
+---
+
+## 2.22.0 - 2023-07-25
 ### Added
 - VectorStyle: Add Styling rules for Geoemtries of type `Circle`.
 - Add Styling and zIndex to draw interactions and improve the draw behavior.
 
 ### Changed
 - Changed peerDependency from cesium 1.106.0 to @cesium/engine 2.4.1.
+- WFS:
+    - Migrated writeTransaction and sendTransaction from masterportal the masterportalAPI.
+    - Exports in src/layer/wfs.js changed to export default {} to provide  ES-Syntax.
+### Deprecated
+
+### Removed
+
+### Fixed
+- WFS: fixed a bug that prevented parsing GeoServer responses.
 
 ---
 

package/package.json

@@ -1,64 +1,65 @@
-{
-  "name": "@masterportal/masterportalapi",
-  "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.21.0",
-  "license": "MIT",
-  "description": "Basic functions of the Masterportal as api",
-  "repository": {
-    "type": "git",
-    "url": "git+https://bitbucket.org/geowerkstatt-hamburg/masterportalapi.git"
-  },
-  "main": "src/index.js",
-  "scripts": {
-    "test": "jest .test.js --config ./jest.config.js --collectCoverage",
-    "test:trace": "node --trace-warnings node_modules/jest/bin/jest.js .test.js --config ./jest.config.js",
-    "test:watch": "jest .test.js --config ./jest.config.js --watch",
-    "example": "parcel example/index.html",
-    "generate-jsdoc": "jsdoc ./src -r -d ./docs/ -R ./README.md -c jsdoc.json",
-    "prePushHook": "eslint --max-warnings 0 \"./**/*.js\" && npm run test",
-    "prepare": "husky install"
-  },
-  "dependencies": {
-    "core-js": "^3.30.2",
-    "dayjs": "^1.11.7",
-    "ol": "7.4.0",
-    "olcs": "^2.14.0",
-    "proj4": "^2.9.0",
-    "xml2js": "^0.5.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.21.8",
-    "@babel/plugin-transform-modules-commonjs": "^7.21.5",
-    "@parcel/transformer-sass": "^2.8.3",
-    "buffer": "^5.7.1",
-    "canvas": "^2.11.2",
-    "eslint": "^8.40.0",
-    "events": "^3.3.0",
-    "husky": "^8.0.3",
-    "jest": "^29.5.0",
-    "jest-canvas-mock": "^2.5.0",
-    "jest-environment-jsdom": "^29.5.0",
-    "jsdoc": "^4.0.2",
-    "parcel": "^2.8.3",
-    "process": "^0.11.10",
-    "sass": "^1.62.1",
-    "stream-browserify": "^3.0.0",
-    "timers-browserify": "^2.0.12",
-    "use-resize-observer": "^9.1.0"
-  },
-  "peerDependencies": {
-    "@cesium/engine": "^2.4.1"
-  },
-  "engines": {
-    "node": "^16.13.2 || ^18.12.0",
-    "npm": "^8.1.2 || ^9.3.1"
-  },
-  "homepage": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi#readme",
-  "directories": {
-    "example": "example",
-    "test": "test"
-  },
-  "bugs": {
-    "url": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi/issues"
-  }
-}
+{
+  "name": "@masterportal/masterportalapi",
+  "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
+  "version": "2.23.0",
+  "license": "MIT",
+  "description": "Basic functions of the Masterportal as api",
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/geowerkstatt-hamburg/masterportalapi.git"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest .test.js --config ./jest.config.js --collectCoverage",
+    "test:trace": "node --trace-warnings node_modules/jest/bin/jest.js .test.js --config ./jest.config.js",
+    "test:watch": "jest .test.js --config ./jest.config.js --watch",
+    "example": "parcel example/index.html",
+    "generate-jsdoc": "jsdoc ./src -r -d ./docs/ -R ./README.md -c jsdoc.json",
+    "prePushHook": "eslint --max-warnings 0 \"./**/*.js\" && npm run test",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "core-js": "^3.30.2",
+    "dayjs": "^1.11.7",
+    "ol": "7.4.0",
+    "olcs": "^2.14.0",
+    "proj4": "^2.9.0",
+    "xml2js": "^0.5.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.21.8",
+    "@babel/plugin-transform-modules-commonjs": "^7.21.5",
+    "@parcel/transformer-sass": "^2.8.3",
+    "buffer": "^5.7.1",
+    "canvas": "^2.11.2",
+    "eslint": "^8.40.0",
+    "events": "^3.3.0",
+    "husky": "^8.0.3",
+    "jest": "^29.5.0",
+    "jest-canvas-mock": "^2.5.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "jest-fetch-mock": "^3.0.3",
+    "jsdoc": "^4.0.2",
+    "parcel": "^2.8.3",
+    "process": "^0.11.10",
+    "sass": "^1.62.1",
+    "stream-browserify": "^3.0.0",
+    "timers-browserify": "^2.0.12",
+    "use-resize-observer": "^9.1.0"
+  },
+  "peerDependencies": {
+    "@cesium/engine": "^2.4.1"
+  },
+  "engines": {
+    "node": "^16.13.2 || ^18.12.0",
+    "npm": "^8.1.2 || ^9.3.1"
+  },
+  "homepage": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi#readme",
+  "directories": {
+    "example": "example",
+    "test": "test"
+  },
+  "bugs": {
+    "url": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi/issues"
+  }
+}

package/src/index.js

@@ -1,10 +1,9 @@
 import {createMapView} from "./maps/mapView";
 import crs from "./crs";
-import drawInteractions from "./maps/interactions/drawInteractions";
 import rawLayerList from "./rawLayerList";
 import * as wms from "./layer/wms";
 import wmts from "./layer/wmts";
-import * as wfs from "./layer/wfs";
+import wfs from "./layer/wfs";
 import * as geojson from "./layer/geojson";
 import * as vectorBase from "./layer/vectorBase";
 import * as vectorTile from "./layer/vectorTile";
@@ -37,6 +36,5 @@ export {
     ping,
     search,
     crs,
-    drawInteractions,
     webgl
 };

package/src/layer/wfs.js

@@ -154,7 +154,7 @@ function createUrl (rawLayer, version, projection, bboxParam) {
  * {@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 = {}) {
+function createLayerSource (rawLayer, options = {}) {
     if (!options.loadingStrategy) {
         options.loadingStrategy = bbox;
     }
@@ -175,10 +175,15 @@ export function createLayerSource (rawLayer, options = {}) {
         }
         else {
             const bboxParam = options.loadingStrategy === bbox ? `&bbox=${extent.join(",")},${projection.getCode()}` : "";
-            let url = createUrl(rawLayer, version, projection, bboxParam);
+            let url = createUrl(rawLayer, version, projection, bboxParam),
+                params = {};
 
             if (options.loadingParams) {
                 for (const key in options.loadingParams) {
+                    if (key === "xhrParameters") {
+                        params = options.loadingParams.xhrParameters;
+                        continue;
+                    }
                     const option = Array.isArray(options.loadingParams[key]) ? options.loadingParams[key].join(",") : options.loadingParams[key];
 
                     if (option !== undefined && key === "bbox") {
@@ -189,7 +194,7 @@ export function createLayerSource (rawLayer, options = {}) {
                     }
                 }
             }
-            loadWFS(url, {}, source, {onErrorFn: onError, success, failure}, options);
+            loadWFS(url, params, source, {onErrorFn: onError, success, failure}, options);
         }
     }
     format.featureType = rawLayer.featureType;
@@ -224,7 +229,7 @@ export function createLayerSource (rawLayer, options = {}) {
  * @param {options} [optionalParams.options] - additional options
  * @returns {ol.Layer} Layer that can be added to map.
  */
-export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
+function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
     let layer, source;
 
     // use WebGL render pipeline, if specified
@@ -260,13 +265,227 @@ export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {
     return layer;
 }
 
+/**
+ * Writes a wfs transaction including the given feature for given layer
+ * inserting, updated or deleting the feature depending on the given selectedInteraction.
+ *
+ * @param {ol/Feature} feature Feature to be inserted, updated or deleted.
+ * @param {Object} transactionOptions Information about the layer to be manipulated.
+ * @param {string} transactionMethod Which transaction to perform. Possible values are: "insert"|"delete"|"selectedUpdate"
+ * @param {string} srsName EPSG code currently used by the map.
+ * @returns {string} WFS Transaction as an XML Node as String.
+ */
+
+function writeTransactionBody (feature, transactionOptions, transactionMethod, version = "1.1.0") {
+    const transactionPosition = {
+            insert: 0,
+            selectedUpdate: 1,
+            delete: 2
+        },
+        transaction = [[], [], []];
+
+    if (transactionMethod !== "insert" && transactionMethod !== "delete" && transactionMethod !== "selectedUpdate") {
+        throw new Error("transactionMethod has to be \"insert\", \"selectedUpdate\" or \"delete\".");
+    }
+
+    transaction[transactionPosition[transactionMethod]].push(feature);
+    return new XMLSerializer()
+        .serializeToString(new WFS({version})
+            .writeTransaction(...transaction, transactionOptions));
+}
+
+/**
+ * Checks if it is an unknown or special error and returns the code and the error message
+ *
+ * @param {Object} xmlDocument with the error
+ * @returns {Object} the code and the specific or unknown error looking like this {code, message}
+ */
+function getExceptionFromTransactionResponse (xmlDocument) {
+    const response = {code: null, message: "genericFailedTransaction"},
+        exception = xmlDocument.getElementsByTagName(`${xmlDocument.getElementsByTagName("Exception").length === 0 ? "ows:" : ""}Exception`)[0],
+        exceptionText = exception.getElementsByTagName(`${xmlDocument.getElementsByTagName("ExceptionText").length === 0 ? "ows:" : ""}ExceptionText`)[0];
+
+    if (exceptionText !== undefined) {
+        response.message = exceptionText.textContent;
+        console.error("WfsTransaction: An error occurred when sending the transaction to the service.", exceptionText.textContent);
+    }
+    else {
+        response.message = "WfsTransaction: An unkown error occurred when sending the transaction to the service.";
+        console.error(response.message);
+    }
+    if (exception?.attributes.getNamedItem("code") || exception?.attributes.getNamedItem("exceptionCode")) {
+        response.code = exception.attributes.getNamedItem(`${exception?.attributes.getNamedItem("code") ? "c" : "exceptionC"}ode`).textContent;
+    }
+
+    return response;
+}
+
+
+/**
+ * Sends a transaction to the service and returns the feature.
+ *
+ * @param {string} srsName of the coordinate reference system
+ * @param {ol/Feature} feature Feature to by inserted / updated / deleted.
+ * @param {string} url of the wfs-t service
+ * @param {Object} layer the configured representation of the layer in the Masterportal
+ * @param {string} transactionMethod which transaction to perform. Possible values are: "insert"|"delete"|"selectedUpdate"
+ * @returns {ol/Feature} the given feature
+ * @throws {Error} error if occurs
+ */
+async function sendTransaction (srsName, feature, url, layer, transactionMethod) {
+    let exception,
+        response,
+        xmlDocument = null,
+        transactionSummary = null,
+        data = null;
+
+    const {featureNS, featurePrefix, featureType, version} = layer;
+
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: {"Content-Type": "text/xml"},
+            credentials: layer.isSecured ? "include" : "omit",
+            body: writeTransactionBody(feature,
+                {featureNS, featurePrefix, featureType, version, srsName},
+                transactionMethod,
+                version),
+            responseType: "text"
+        });
+
+        data = await response.text();
+
+        xmlDocument = new DOMParser().parseFromString(data, "text/xml");
+        transactionSummary = xmlDocument.getElementsByTagName("wfs:TransactionSummary");
+
+        // NOTE: WFS-T services respond errors with the transaction as an XML response, even though it's the http code indicates different...
+        if (transactionSummary.length === 0) {
+            exception = getExceptionFromTransactionResponse(xmlDocument);
+            throw new Error(exception.code ? exception.code + ": " + exception.message : exception.message);
+        }
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+
+    return feature;
+}
+
+/**
+ * Parses the response of a DescribeFeatureType request
+ * and prepares its values for later use as an input value for the user.
+ *
+ * @param {string} responseData XML response data
+ * @param {string} featureType Name of the feature type of the service.
+ * @returns {Array} If an <element> with a name of the featureType is present, an array of prepared feature properties; else an empty Array.
+ */
+function parseDescribeFeatureTypeResponse (responseData, featureType) {
+
+    const parsedResponse = new DOMParser().parseFromString(responseData, "application/xml");
+
+    let prefix = "",
+        foundElement = null;
+
+    if (parsedResponse.getElementsByTagName("xsd:element").length > 0) {
+        prefix = "xsd:";
+    }
+    else if (parsedResponse.getElementsByTagName("xs:element").length > 0) {
+        prefix = "xs";
+    }
+
+    // Check if featureType applies to the response
+    foundElement = Object.values(parsedResponse.getElementsByTagName(prefix + "element")).find(element => element.getAttribute("name") === featureType);
+
+    if (foundElement) {
+        let sequenceElements;
+
+        if (foundElement.hasChildNodes()) {
+            sequenceElements = Object.values(foundElement.getElementsByTagName(prefix + "sequence"));
+        }
+        else {
+            sequenceElements = Object.values(parsedResponse.getElementsByTagName(prefix + "sequence"));
+        }
+
+        const elements = [];
+
+        sequenceElements.forEach(sequenceElement => {
+            elements.push(...Object.values(sequenceElement.getElementsByTagName(prefix + "element")));
+        });
+
+        return elements.map(el => Object.values(el.attributes).reduce((obj, att) => {
+            if (att.localName === "minOccurs") {
+                obj.required = att.value === "1";
+            }
+            else if (att.localName === "type") {
+                if (att.value.trim().startsWith("gml")) {
+                    obj.type = "geometry";
+                }
+                else {
+                    let value = att.value;
+
+                    if (prefix.length > 0) {
+                        value = value.replace(prefix, "");
+                    }
+
+                    switch (value) {
+                        case "long":
+                            obj.type = "integer";
+                            break;
+                        default:
+                            obj.type = value;
+                    }
+                }
+            }
+            else if (att.localName === "name") {
+                obj.label = obj.key = att.value;
+            }
+            return obj;
+        }, {
+            label: "",
+            key: "",
+            value: null,
+            type: "string",
+            required: false
+        }));
+    }
+    return [];
+}
+
+/**
+ * Requests the possible properties of a feature and further values;
+ * for more {@see FeatureProperty}.
+ *
+ * @param {string} url from the WFS-T
+ * @param {string} version of the WFS-T
+ * @param {string} featureType Name of the FeatureType according to the capabilities document
+ * @param {boolean} isSecured Whether the layer is secured by BasicAuth and should include or omit the credentials prompt
+ * @returns {Promise<Array>} If the request is successful, an array of prepared feature properties.
+ */
+async function receivePossibleProperties (url, version, featureType, isSecured) {
+    const baseUrl = `${url}?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=${version}&TYPENAME=${featureType}`;
+    let response;
+
+    try {
+        response = await fetch(baseUrl, {
+            responseType: "text/xml",
+            credentials: isSecured ? "include" : "omit"
+        });
+        return parseDescribeFeatureTypeResponse(await response.text(), featureType);
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+}
+
 /**
  * Load the features manually.
  * @param {Object} layerAttributes raw layer attributes.
  * @param {module:ol/vector/Source} layerSource - the source of the layer
  * @returns {void}
  */
-export function loadFeaturesManually (layerAttributes, layerSource) {
+function loadFeaturesManually (layerAttributes, layerSource) {
     const getUrl = createUrl(layerAttributes, layerAttributes.version, {getCode: () => layerAttributes.crs}, "");
 
     fetch(getUrl, layerSource)
@@ -278,3 +497,5 @@ export function loadFeaturesManually (layerAttributes, layerSource) {
             console.error(error);
         });
 }
+
+export default {createLayerSource, createLayer, sendTransaction, receivePossibleProperties, parseDescribeFeatureTypeResponse, writeTransactionBody, loadFeaturesManually};

package/src/maps/interactions/modifyInteraction.js

@@ -0,0 +1,18 @@
+import {Modify} from "ol/interaction.js";
+
+/**
+ * Create the modify interaction.
+ * @param {ol/source} source The vector layer source containing the features to be modified.
+ * @returns {ol/interaction/Modify} The modify interaction.
+ */
+function createModifyInteraction (source) {
+    const modifyInteraction = new Modify({
+        source: source
+    });
+
+    return modifyInteraction;
+}
+
+export default {
+    createModifyInteraction
+};

package/src/maps/interactions/selectInteraction.js

@@ -0,0 +1,35 @@
+import {Select} from "ol/interaction.js";
+
+/**
+ * Remove the selected feature.
+ * @param {ol/interaction/Select} selectInteraction The select interaction.
+ * @param {ol/source} source The vector layer source containing the features to be selected.
+ * @returns {void}
+ */
+function removeSelectedFeature (selectInteraction, source) {
+    selectInteraction.on("select", event => {
+        source.removeFeature(event.selected[0]);
+        event.target.getFeatures().clear();
+    });
+}
+
+/**
+ * Create the select interaction.
+ * @param {ol/layer|ol/layer[]} layers The vector layers for select features.
+ * @param {ol/events/condition} [condition] The ol condition. Default from ol is "singleClick".
+ * @returns {ol/interaction/Select} The select interaction.
+ */
+function createSelectInteraction (layers, condition) {
+    const selectInteraction = new Select({
+        condition: condition,
+        layers: Array.isArray(layers) ? layers : [layers],
+        hitTolerance: 10
+    });
+
+    return selectInteraction;
+}
+
+export default {
+    createSelectInteraction,
+    removeSelectedFeature
+};

package/src/maps/ol/olMap.js

@@ -6,7 +6,7 @@ import defaults from "../../defaults";
 import * as wms from "../../layer/wms";
 import wmts from "../../layer/wmts";
 import * as geojson from "../../layer/geojson";
-import * as wfs from "../../layer/wfs";
+import wfs from "../../layer/wfs";
 import * as vectorBase from "../../layer/vectorBase";
 import * as vectortile from "../../layer/vectorTile";
 import * as oaf from "../../layer/oaf";

package/src/vectorStyle/lib/createLegendInfo.js

@@ -1,4 +1,5 @@
 import createStyle from "../createStyle";
+
 /**
  * Creates the style objects for the layer
  * @param   {object[]} rules styling rules from the styleObject
@@ -8,22 +9,29 @@ import createStyle from "../createStyle";
  */
 export function createLegendInfo (rules, geometryType, wfsImgPath) {
     let styleObject,
-        simpleGeom;
+        simpleGeom,
+        legendInfos = [];
 
     geometryType.forEach(geom => rules.forEach(rule => {
         if (geom === "MultiSurface") {
             simpleGeom = "Polygon";
             styleObject = createStyle.getSimpleGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
-            return styleObject;
+            legendInfos = legendInfos.concat(styleObject.legendInfos);
         }
         else if (geom.includes("Multi")) {
             simpleGeom = geom.replace("Multi", "");
             styleObject = createStyle.getMultiGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
-            return styleObject;
-        }
 
-        simpleGeom = geom;
-        styleObject = createStyle.getSimpleGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
-        return styleObject;
+            styleObject.forEach(singleStyleObject => {
+                legendInfos = legendInfos.concat(singleStyleObject.legendInfos);
+            });
+        }
+        else {
+            simpleGeom = geom;
+            styleObject = createStyle.getSimpleGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
+            legendInfos = legendInfos.concat(styleObject.legendInfos);
+        }
     }));
-}
+
+    return legendInfos;
+}

package/src/vectorStyle/lib/getGeometryTypeFromService.js

@@ -7,15 +7,15 @@ import {createLegendInfo} from "./createLegendInfo";
  * @returns {object[]} subElements of the xml element
  */
 function getSubelementsFromXMLOtherStructure (xml, featureType) {
-    const elements = xml ? Array.from(xml.getElementsByTagName("element")) : [];
+    const elements = xml ? Array.from(xml.getElementsByTagNameNS("*", "element")) : [];
     let subElements = [];
 
     elements.forEach(element => {
         if (element.getAttribute("name") === featureType) {
             const sibling = element.nextElementSibling;
 
-            if (sibling && sibling.tagName === "complexType" && sibling.hasAttribute("name")) {
-                subElements = Array.from(sibling.getElementsByTagName("element"));
+            if (sibling && sibling.tagName.endsWith("complexType") && sibling.hasAttribute("name")) {
+                subElements = Array.from(sibling.getElementsByTagNameNS("*", "element"));
             }
         }
     });
@@ -29,7 +29,8 @@ function getSubelementsFromXMLOtherStructure (xml, featureType) {
  * @returns {object[]} subElements of the xml element
  */
 function getSubelementsFromXML (xml, featureType) {
-    const elements = xml ? Array.from(xml.getElementsByTagName("element")) : [];
+    const elements = xml ? Array.from(xml.getElementsByTagNameNS("*", "element")) : [];
+
     let subElements = [],
         featureTypeWithoutNamespace = featureType;
 
@@ -39,9 +40,10 @@ function getSubelementsFromXML (xml, featureType) {
 
     elements.forEach(element => {
         if (element.getAttribute("name") === featureTypeWithoutNamespace) {
-            subElements = Array.from(element.getElementsByTagName("element"));
+            subElements = Array.from(element.getElementsByTagNameNS("*", "element"));
         }
     });
+
     if (subElements.length === 0) {
         subElements = getSubelementsFromXMLOtherStructure(xml, featureTypeWithoutNamespace);
     }
@@ -105,7 +107,7 @@ function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeome
     url = url.slice(0, -1);
 
 
-    fetch(url, {
+    return fetch(url, {
         method: "get",
         withCredentials: isSecured,
         responseType: "text"
@@ -115,7 +117,7 @@ function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeome
             const subElements = getSubelementsFromXML(responseXML, featureType),
                 geometryTypes = getTypeAttributesFromSubelements(subElements, styleGeometryType);
 
-            createLegendInfo(rules, geometryTypes, wfsImgPath);
+            return createLegendInfo(rules, geometryTypes, wfsImgPath);
         }).catch(error => {
             return callback(error);
         });
@@ -152,4 +154,4 @@ function getGeometryTypeFromOAF (rules, oafURL, collection, wfsImgPath, callback
 export default {
     getGeometryTypeFromWFS,
     getGeometryTypeFromOAF
-};
+};