qwc2
Version:
QGIS Web Client
1,164 lines (1,161 loc) • 66.2 kB
JavaScript
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
/**
* Copyright 2016-2024 Sourcepole AG
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
import isEmpty from 'lodash.isempty';
import isEqual from 'lodash.isequal';
import url from 'url';
import { v4 as uuidv4 } from 'uuid';
import { LayerRole } from '../actions/layers';
import ConfigUtils from './ConfigUtils';
import CoordinatesUtils from './CoordinatesUtils';
import MapUtils from './MapUtils';
import VectorLayerUtils from './VectorLayerUtils';
var LayerUtils = {
restoreLayerParams: function restoreLayerParams(themeLayer, layerConfigs, permalinkLayers, externalLayers) {
var exploded = LayerUtils.explodeLayers([themeLayer]);
// Restore theme layer configuration
var _iterator = _createForOfIteratorHelper(exploded),
_step;
try {
var _loop = function _loop() {
var entry = _step.value;
var layerConfig = layerConfigs.find(function (layer) {
return layer.type === 'theme' && layer.name === entry.sublayer.name;
});
if (layerConfig) {
entry.sublayer.opacity = layerConfig.opacity;
entry.sublayer.visibility = layerConfig.visibility || layerConfig.tristate;
entry.sublayer.tristate = layerConfig.tristate;
entry.sublayer.style = layerConfig.style || entry.sublayer.style;
} else {
entry.sublayer.visibility = false;
}
};
for (_iterator.s(); !(_step = _iterator.n()).done;) {
_loop();
}
// Create placeholders for external layers to be added in front
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
var external = [];
var _iterator2 = _createForOfIteratorHelper(layerConfigs),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var layerConfig = _step2.value;
if (layerConfig.type === 'separator') {
// No point restoring separators
} else if (layerConfig.type !== 'theme') {
external = external.concat(LayerUtils.createExternalLayerPlaceholder(layerConfig, externalLayers, layerConfig.id));
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
exploded = [].concat(_toConsumableArray(external), _toConsumableArray(exploded));
LayerUtils.insertPermalinkLayers(exploded, permalinkLayers);
var layers = LayerUtils.implodeLayers(exploded);
LayerUtils.setGroupVisiblities(layers);
return layers;
},
restoreOrderedLayerParams: function restoreOrderedLayerParams(themeLayer, layerConfigs, permalinkLayers, externalLayers) {
var exploded = LayerUtils.explodeLayers([themeLayer]);
var reordered = [];
// Iterate over layer configs and reorder items accordingly, create external layer placeholders as neccessary
var _iterator3 = _createForOfIteratorHelper(layerConfigs),
_step3;
try {
var _loop2 = function _loop2() {
var layerConfig = _step3.value;
if (layerConfig.type === 'theme') {
var entry = exploded.find(function (e) {
return e.sublayer.name === layerConfig.name;
});
if (entry) {
entry.sublayer.opacity = layerConfig.opacity;
entry.sublayer.visibility = layerConfig.visibility || layerConfig.tristate;
entry.sublayer.tristate = layerConfig.tristate;
entry.sublayer.style = layerConfig.style || entry.sublayer.style;
reordered.push(entry);
}
} else if (layerConfig.type === 'separator') {
reordered = reordered.concat(LayerUtils.createSeparatorLayer(layerConfig.name));
} else {
reordered = reordered.concat(LayerUtils.createExternalLayerPlaceholder(layerConfig, externalLayers, layerConfig.id));
}
};
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
_loop2();
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
LayerUtils.insertPermalinkLayers(reordered, permalinkLayers);
var layers = LayerUtils.implodeLayers(reordered);
LayerUtils.setGroupVisiblities(layers);
return layers;
},
setGroupVisiblities: function setGroupVisiblities(layers) {
var parentVisible = false;
var parentInvisible = false;
var _iterator4 = _createForOfIteratorHelper(layers),
_step4;
try {
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
var layer = _step4.value;
if (!isEmpty(layer.sublayers)) {
layer.visibility = LayerUtils.setGroupVisiblities(layer.sublayers);
}
parentInvisible = parentInvisible || layer.tristate;
delete layer.tristate;
parentVisible = parentVisible || layer.visibility;
}
} catch (err) {
_iterator4.e(err);
} finally {
_iterator4.f();
}
return parentVisible && !parentInvisible;
},
createSeparatorLayer: function createSeparatorLayer(title) {
return LayerUtils.explodeLayers([{
type: "separator",
title: title,
role: LayerRole.USERLAYER,
id: uuidv4()
}]);
},
createExternalLayerPlaceholder: function createExternalLayerPlaceholder(layerConfig, externalLayers, id) {
var key = layerConfig.type + ":" + layerConfig.url;
(externalLayers[key] = externalLayers[key] || []).push({
id: id,
name: layerConfig.name,
opacity: layerConfig.opacity,
visibility: layerConfig.visibility,
style: layerConfig.style,
params: layerConfig.params
});
return LayerUtils.explodeLayers([{
id: id,
type: "placeholder",
name: layerConfig.name,
opacity: layerConfig.opacity,
visibility: layerConfig.visibility,
style: layerConfig.style,
title: layerConfig.name,
role: LayerRole.USERLAYER,
loading: true
}]);
},
insertPermalinkLayers: function insertPermalinkLayers(exploded, layers) {
var _iterator5 = _createForOfIteratorHelper(layers || []),
_step5;
try {
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
var layer = _step5.value;
var insLayer = LayerUtils.explodeLayers([layer])[0];
if (insLayer.layer.role !== LayerRole.USERLAYER || insLayer.layer.type !== 'vector') {
continue;
}
delete insLayer.layer.pos;
exploded.splice(layer.pos, 0, insLayer);
}
} catch (err) {
_iterator5.e(err);
} finally {
_iterator5.f();
}
},
collectWMSSublayerParams: function collectWMSSublayerParams(sublayer, layerNames, opacities, styles, queryable, visibilities, parentVisibility) {
var layerVisibility = sublayer.visibility === undefined ? true : sublayer.visibility;
var visibility = layerVisibility && parentVisibility;
if (visibility || visibilities) {
if (!isEmpty(sublayer.sublayers)) {
// Is group
sublayer.sublayers.map(function (sublyr) {
LayerUtils.collectWMSSublayerParams(sublyr, layerNames, opacities, styles, queryable, visibilities, visibility);
});
} else {
layerNames.push(sublayer.name);
opacities.push(Number.isInteger(sublayer.opacity) ? sublayer.opacity : 255);
styles.push(sublayer.style || "");
if (sublayer.queryable && !sublayer.omitFromQueryLayers) {
queryable.push(sublayer.name);
}
if (visibilities) {
// eslint-disable-next-line
visibilities.push(layerVisibility ? parentVisibility ? 1 : 0.5 : 0);
}
}
}
},
buildWMSLayerParams: function buildWMSLayerParams(layer) {
var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var params = layer.params || {};
var newParams = {};
var queryLayers = [];
var initialOpacities = undefined;
if (!Array.isArray(layer.sublayers)) {
var _ref, _layer$initialOpaciti, _layer$opacity, _ref2, _layer$style;
var layers = (params.LAYERS || layer.name).split(",").filter(Boolean);
// Background layers may just contain layer.params.OPACITIES
// User layers will be controlled with layer.opacity, and value will be replicated in layer.params.OPACITIES
// => Store the initial layer.params.OPACITIES as initialOpacities, compute actual opacities
// by multipliying layer.opacity with initialOpacities
initialOpacities = (_ref = (_layer$initialOpaciti = layer.initialOpacities) !== null && _layer$initialOpaciti !== void 0 ? _layer$initialOpaciti : params.OPACITIES) !== null && _ref !== void 0 ? _ref : "";
var opacities = initialOpacities.split(",").filter(Boolean);
var opacityMult = ((_layer$opacity = layer.opacity) !== null && _layer$opacity !== void 0 ? _layer$opacity : 255) / 255;
newParams = _objectSpread({
LAYERS: layers.join(","),
STYLES: (_ref2 = (_layer$style = layer.style) !== null && _layer$style !== void 0 ? _layer$style : params.STYLES) !== null && _ref2 !== void 0 ? _ref2 : layers.map(function () {
return "";
}).join(","),
OPACITIES: layers.map(function (x, i) {
var _opacities$i;
return Math.round(((_opacities$i = opacities[i]) !== null && _opacities$i !== void 0 ? _opacities$i : "255") * opacityMult);
}).map(Math.round).join(",")
}, layer.dimensionValues);
queryLayers = layer.queryable && !layer.omitFromQueryLayers ? [layer.name] : [];
} else {
var layerNames = [];
var _opacities = [];
var styles = [];
layer.sublayers.map(function (sublayer) {
LayerUtils.collectWMSSublayerParams(sublayer, layerNames, _opacities, styles, queryLayers, null, layer.visibility);
});
layerNames.reverse();
_opacities.reverse();
styles.reverse();
if (layer.drawingOrder && layer.drawingOrder.length > 0) {
var indices = layer.drawingOrder.map(function (lyr) {
return layerNames.indexOf(lyr);
}).filter(function (idx) {
return idx >= 0;
});
layerNames = indices.map(function (idx) {
return layerNames[idx];
});
_opacities = indices.map(function (idx) {
return _opacities[idx];
});
styles = indices.map(function (idx) {
return styles[idx];
});
}
newParams = _objectSpread({
LAYERS: layerNames.join(","),
OPACITIES: _opacities.map(Math.round).join(","),
STYLES: styles.join(",")
}, layer.dimensionValues);
}
if (filter.filterParams) {
newParams.FILTER = Object.entries(filter.filterParams).reduce(function (res, _ref3) {
var _ref4 = _slicedToArray(_ref3, 2),
layername = _ref4[0],
filters = _ref4[1];
if (!newParams.LAYERS.split(",").includes(layername)) {
return res;
}
return [].concat(_toConsumableArray(res), [layername + ":" + filters.map(function (expr) {
return Array.isArray(expr) ? LayerUtils.formatFilterExpr(expr) : "AND";
}).join(" ")]);
}, []).join(";");
}
if (filter.filterGeom) {
newParams.FILTER_GEOM = VectorLayerUtils.geoJSONGeomToWkt(filter.filterGeom);
}
return {
params: newParams,
queryLayers: queryLayers,
initialOpacities: initialOpacities
};
},
formatFilterExpr: function formatFilterExpr(expr) {
var _this = this;
if (expr.length === 3 && typeof expr[0] === "string") {
var op = expr[1].toUpperCase();
if (typeof expr[2] === "number") {
return "\"".concat(expr[0], "\" ").concat(op, " ").concat(expr[2]);
} else if (expr[2] === null) {
return "\"".concat(expr[0], "\" ").concat(op, " NULL");
} else if (Array.isArray(expr[2])) {
return "\"".concat(expr[0], "\" ").concat(op, " ( ").concat(expr[2].join(' , '), " )");
} else {
return "\"".concat(expr[0], "\" ").concat(op, " '").concat(expr[2], "'");
}
} else {
return "( " + expr.map(function (entry) {
return Array.isArray(entry) ? _this.formatFilterExpr(entry) : entry.toUpperCase();
}).join(" ") + " )";
}
},
buildWMSLayerUrlParam: function buildWMSLayerUrlParam(layers) {
var layernames = [];
var opacities = [];
var styles = [];
var visibilities = [];
var queryable = [];
var _iterator6 = _createForOfIteratorHelper(layers),
_step6;
try {
var _loop3 = function _loop3() {
var layer = _step6.value;
if (layer.role === LayerRole.THEME && !isEmpty(layer.sublayers)) {
LayerUtils.collectWMSSublayerParams(layer, layernames, opacities, styles, queryable, visibilities, layer.visibility);
} else if (layer.role === LayerRole.USERLAYER && layer.type === "wms") {
var sublayernames = [];
LayerUtils.collectWMSSublayerParams(layer, sublayernames, opacities, styles, queryable, visibilities, layer.visibility);
var layerurl = layer.url;
if (layer.extwmsparams) {
layerurl += (layerurl.includes('?') ? '&' : '?') + Object.entries(layer.extwmsparams || {}).map(function (_ref5) {
var _ref6 = _slicedToArray(_ref5, 2),
key = _ref6[0],
value = _ref6[1];
return 'extwms.' + key + "=" + value;
}).join('&');
}
layernames.push.apply(layernames, _toConsumableArray(sublayernames.map(function (name) {
return "wms:" + layerurl + "#" + name;
})));
} else if (layer.role === LayerRole.USERLAYER && (layer.type === "wfs" || layer.type === "wmts")) {
layernames.push(layer.type + ':' + (layer.capabilitiesUrl || layer.url) + "#" + layer.name);
opacities.push(layer.opacity);
styles.push(layer.style);
visibilities.push(layer.visibility);
} else if (layer.role === LayerRole.USERLAYER && layer.type === "separator") {
layernames.push("sep:" + layer.title);
opacities.push(255);
styles.push('');
visibilities.push(true);
}
};
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
_loop3();
}
} catch (err) {
_iterator6.e(err);
} finally {
_iterator6.f();
}
var result = layernames.map(function (layername, idx) {
var param = layername;
if (opacities[idx] < 255) {
param += "[" + (100 - Math.round(opacities[idx] / 255 * 100)) + "]";
}
if (styles[idx] && styles[idx] !== "default") {
param += "{" + styles[idx] + "}";
}
if (visibilities[idx] === 0 || visibilities[idx] === false) {
param += '!';
} else if (visibilities[idx] === 0.5) {
param += '~';
}
return param;
});
if (ConfigUtils.getConfigProp("urlReverseLayerOrder")) {
result.reverse();
}
return result.join(",");
},
splitLayerUrlParam: function splitLayerUrlParam(entry) {
var opacityPattern = /\[(\d+)\]/;
var stylePattern = /{([^}]+)}/;
var extPattern = /^(\w+):(.*)#([^#]+)$/;
var id = uuidv4();
var type = 'theme';
var layerUrl = null;
var opacity = 255;
var style = '';
var visibility = true;
var tristate = false;
if (entry.endsWith('!')) {
visibility = false;
entry = entry.slice(0, -1);
} else if (entry.endsWith('~')) {
visibility = false;
tristate = true;
entry = entry.slice(0, -1);
}
var m = null;
if (m = entry.match(opacityPattern)) {
opacity = Math.round(255 - parseFloat(m[1]) / 100 * 255);
entry = entry.slice(0, m.index) + entry.slice(m.index + m[0].length);
}
if (m = entry.match(stylePattern)) {
style = m[1];
entry = entry.slice(0, m.index) + entry.slice(m.index + m[0].length);
}
var name = entry;
if (m = entry.match(extPattern)) {
type = m[1];
layerUrl = m[2];
name = m[3];
} else if (name.startsWith('sep:')) {
type = 'separator';
name = name.slice(4);
}
return {
id: id,
type: type,
url: layerUrl,
name: name,
opacity: opacity,
style: style,
visibility: visibility,
tristate: tristate
};
},
pathEqualOrBelow: function pathEqualOrBelow(parent, child) {
return isEqual(child.slice(0, parent.length), parent);
},
removeLayer: function removeLayer(layers, layer, sublayerpath) {
// Extract foreground layers
var fglayers = layers.filter(function (lyr) {
return lyr.role !== LayerRole.BACKGROUND;
});
// Explode layers (one entry for every single sublayer)
var exploded = LayerUtils.explodeLayers(fglayers);
// Remove matching entries
exploded = exploded.filter(function (entry) {
return entry.layer.id !== layer.id || !LayerUtils.pathEqualOrBelow(sublayerpath, entry.path);
});
// Re-assemble layers
var newlayers = LayerUtils.implodeLayers(exploded);
// Ensure theme layer is never removed
if (!newlayers.find(function (lyr) {
return lyr.role === LayerRole.THEME;
})) {
var oldThemeLayer = layers.find(function (lyr) {
return lyr.role === LayerRole.THEME;
});
if (oldThemeLayer) {
newlayers.push(_objectSpread(_objectSpread({}, oldThemeLayer), {}, {
sublayers: []
}));
}
}
// Re-add background layers
return [].concat(_toConsumableArray(newlayers), _toConsumableArray(layers.filter(function (lyr) {
return lyr.role === LayerRole.BACKGROUND;
})));
},
insertSeparator: function insertSeparator(layers, title, beforelayerId, beforesublayerpath) {
// Extract foreground layers
var fglayers = layers.filter(function (layer) {
return layer.role !== LayerRole.BACKGROUND;
});
// Explode layers (one entry for every single sublayer)
var exploded = LayerUtils.explodeLayers(fglayers);
// Remove matching entries
var pos = exploded.findIndex(function (entry) {
return entry.layer.id === beforelayerId && isEqual(beforesublayerpath, entry.path);
});
if (pos !== -1) {
// Add separator
exploded.splice(pos, 0, LayerUtils.createSeparatorLayer(title)[0]);
}
// Re-assemble layers, re-add background layers
return [].concat(_toConsumableArray(LayerUtils.implodeLayers(exploded)), _toConsumableArray(layers.filter(function (layer) {
return layer.role === LayerRole.BACKGROUND;
})));
},
reorderLayer: function reorderLayer(layers, movelayer, sublayerpath, delta, preventSplittingGroups) {
// Extract foreground layers
var fglayers = layers.filter(function (layer) {
return layer.role !== LayerRole.BACKGROUND;
});
// Explode layers (one entry for every single sublayer)
var exploded = LayerUtils.explodeLayers(fglayers);
// Find entry to move
if (movelayer) {
var indices = exploded.reduce(function (result, entry, index) {
if (entry.layer.id === movelayer.id && LayerUtils.pathEqualOrBelow(sublayerpath, entry.path)) {
return [].concat(_toConsumableArray(result), [index]);
}
return result;
}, []);
if (isEmpty(indices)) {
return layers;
}
indices.sort(function (a, b) {
return a - b;
});
if (delta < 0 && indices[0] <= 0 || delta > 0 && indices[indices.length - 1] >= exploded.length - 1) {
return layers;
}
if (preventSplittingGroups) {
// Prevent moving an entry out of a containing group
var idx = delta < 0 ? indices[0] : indices[indices.length - 1];
var level = sublayerpath.length;
if (level > exploded[idx + delta].path.length || level > 0 && !isEqual(exploded[idx + delta].path.slice(0, level - 1), sublayerpath.slice(0, -1))) {
return layers;
}
// Avoid splitting sibling groups when reordering
var group = sublayerpath.slice(0, -1).reduce(function (sublayer, i) {
return sublayer.sublayers[i];
}, movelayer);
// Compute move offset
var dir = delta > 0 ? 1 : -1;
var oldIndex = sublayerpath[sublayerpath.length - 1];
var newIndex = oldIndex + delta;
var offset = 0;
for (var i = oldIndex + dir; dir * i <= dir * newIndex; i += dir) {
offset += LayerUtils.layerTreeCount(group.sublayers[i]) * dir;
}
delta = offset;
}
// Reorder layer
if (delta < 0) {
var _iterator7 = _createForOfIteratorHelper(indices),
_step7;
try {
for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
var _idx = _step7.value;
exploded.splice(_idx + delta, 0, exploded.splice(_idx, 1)[0]);
}
} catch (err) {
_iterator7.e(err);
} finally {
_iterator7.f();
}
} else {
var _iterator8 = _createForOfIteratorHelper(indices.reverse()),
_step8;
try {
for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
var _idx2 = _step8.value;
exploded.splice(_idx2 + delta, 0, exploded.splice(_idx2, 1)[0]);
}
} catch (err) {
_iterator8.e(err);
} finally {
_iterator8.f();
}
}
}
// Re-assemble layers
var newlayers = LayerUtils.implodeLayers(exploded);
// Re-add background layers
return [].concat(_toConsumableArray(newlayers), _toConsumableArray(layers.filter(function (layer) {
return layer.role === LayerRole.BACKGROUND;
})));
},
replacePlaceholderLayer: function replacePlaceholderLayer(layers, layerid, newlayer) {
var filter = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
var newLayers = layers;
if (newlayer) {
newLayers = layers.map(function (layer) {
if (layer.type === 'placeholder' && layer.id === layerid) {
var _layer$attribution, _layer$opacity2, _layer$visibility, _layer$tristate, _layer$style2;
var newLayer = _objectSpread(_objectSpread(_objectSpread({}, layer), newlayer), {}, {
attribution: (_layer$attribution = layer.attribution) !== null && _layer$attribution !== void 0 ? _layer$attribution : newlayer.attribution,
opacity: (_layer$opacity2 = layer.opacity) !== null && _layer$opacity2 !== void 0 ? _layer$opacity2 : newlayer.opacity,
visibility: (_layer$visibility = layer.visibility) !== null && _layer$visibility !== void 0 ? _layer$visibility : newlayer.visibility,
tristate: (_layer$tristate = layer.tristate) !== null && _layer$tristate !== void 0 ? _layer$tristate : newlayer.tristate,
style: (_layer$style2 = layer.style) !== null && _layer$style2 !== void 0 ? _layer$style2 : newlayer.style,
role: layer.role,
id: layer.id
});
// For background layers, preserve any custom name/title/attribution/opacity
if (layer.role === LayerRole.BACKGROUND) {
var _layer$name, _layer$title;
newLayer.name = (_layer$name = layer.name) !== null && _layer$name !== void 0 ? _layer$name : newlayer.name;
newLayer.title = (_layer$title = layer.title) !== null && _layer$title !== void 0 ? _layer$title : newlayer.title;
}
delete newLayer.loading;
if (newLayer.type === "wms") {
Object.assign(newLayer, LayerUtils.buildWMSLayerParams(newLayer, filter));
}
return newLayer;
} else {
return layer;
}
});
} else {
newLayers = newLayers.filter(function (layer) {
return !(layer.type === 'placeholder' && layer.id === layerid);
});
}
return newLayers;
},
explodeLayers: function explodeLayers(layers) {
// Return array with one entry for every single sublayer)
var exploded = [];
var _iterator9 = _createForOfIteratorHelper(layers),
_step9;
try {
for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
var layer = _step9.value;
if (!isEmpty(layer.sublayers)) {
this.explodeSublayers(layer, layer, exploded);
} else {
var newLayer = _objectSpread({}, layer);
exploded.push({
layer: newLayer,
path: [],
sublayer: newLayer
});
}
}
} catch (err) {
_iterator9.e(err);
} finally {
_iterator9.f();
}
return exploded;
},
explodeSublayers: function explodeSublayers(layer, parent, exploded) {
var parentpath = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
for (var idx = 0; idx < parent.sublayers.length; ++idx) {
var path = [].concat(_toConsumableArray(parentpath), [idx]);
if (parent.sublayers[idx].sublayers) {
LayerUtils.explodeSublayers(layer, parent.sublayers[idx], exploded, path);
} else {
// Reduced layer with one single sublayer per level, up to leaf
var redLayer = _objectSpread({}, layer);
var group = redLayer;
var _iterator10 = _createForOfIteratorHelper(path),
_step10;
try {
for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
var jdx = _step10.value;
group.sublayers = [_objectSpread({}, group.sublayers[jdx])];
group = group.sublayers[0];
}
} catch (err) {
_iterator10.e(err);
} finally {
_iterator10.f();
}
exploded.push({
layer: redLayer,
path: path,
sublayer: group
});
}
}
},
implodeLayers: function implodeLayers(exploded) {
var newlayers = [];
var usedIds = new Set();
// Merge all possible items of an exploded layer array
var _iterator11 = _createForOfIteratorHelper(exploded),
_step11;
try {
for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
var entry = _step11.value;
var _layer2 = entry.layer;
// Attempt to merge with previous if possible
var target = newlayers.length > 0 ? newlayers[newlayers.length - 1] : null;
var source = _layer2;
if (target && target.sublayers && target.url === _layer2.url) {
var innertarget = target.sublayers[target.sublayers.length - 1];
var innersource = source.sublayers[0]; // Exploded entries have only one entry per sublayer level
while (innertarget && innertarget.sublayers && innertarget.name === innersource.name) {
target = innertarget;
source = innersource;
innertarget = target.sublayers[target.sublayers.length - 1];
innersource = source.sublayers[0]; // Exploded entries have only one entry per sublayer level
}
target.sublayers.push(source.sublayers[0]);
} else {
if (usedIds.has(_layer2.id)) {
newlayers.push(_objectSpread(_objectSpread({}, _layer2), {}, {
id: uuidv4()
}));
} else {
newlayers.push(_layer2);
}
usedIds.add(_layer2.id);
}
}
// Ensure mutually exclusive groups have exactly one visible layer
} catch (err) {
_iterator11.e(err);
} finally {
_iterator11.f();
}
for (var _i = 0, _newlayers = newlayers; _i < _newlayers.length; _i++) {
var layer = _newlayers[_i];
LayerUtils.ensureMutuallyExclusive(layer);
}
for (var _i2 = 0, _newlayers2 = newlayers; _i2 < _newlayers2.length; _i2++) {
var _layer = _newlayers2[_i2];
if (_layer.type === "wms") {
Object.assign(_layer, LayerUtils.recomputeLayerBBox(_layer));
}
}
return newlayers;
},
insertLayer: function insertLayer(layers, newlayer, attr, val) {
var after = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
var exploded = LayerUtils.explodeLayers(layers);
var explodedAdd = LayerUtils.explodeLayers([newlayer]);
var index = exploded.findIndex(function (entry) {
return entry.sublayer[attr] === val;
});
if (index !== -1) {
if (after) {
index += 1;
}
exploded.splice.apply(exploded, [index, 0].concat(_toConsumableArray(explodedAdd)));
} else {
exploded.unshift.apply(exploded, _toConsumableArray(explodedAdd));
}
return LayerUtils.implodeLayers(exploded);
},
ensureMutuallyExclusive: function ensureMutuallyExclusive(group) {
if (!isEmpty(group.sublayers)) {
if (group.mutuallyExclusive) {
var tristateSublayer = group.sublayers.find(function (sublayer) {
return sublayer.tristate === true;
});
var visibleSublayer = tristateSublayer || group.sublayers.find(function (sublayer) {
return sublayer.visibility === true;
}) || group.sublayers[0];
var _iterator12 = _createForOfIteratorHelper(group.sublayers),
_step12;
try {
for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
var sublayer = _step12.value;
sublayer.visibility = sublayer === visibleSublayer;
}
} catch (err) {
_iterator12.e(err);
} finally {
_iterator12.f();
}
}
var _iterator13 = _createForOfIteratorHelper(group.sublayers),
_step13;
try {
for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
var _sublayer = _step13.value;
LayerUtils.ensureMutuallyExclusive(_sublayer);
}
} catch (err) {
_iterator13.e(err);
} finally {
_iterator13.f();
}
}
},
layerTreeCount: function layerTreeCount(layer) {
return isEmpty(layer.sublayers) ? 1 : layer.sublayers.reduce(function (sum, sublayer) {
return sum + LayerUtils.layerTreeCount(sublayer);
}, 0);
},
getSublayerNames: function getSublayerNames(layer) {
var _this2 = this;
var toplevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var filter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
return [toplevel && layer.sublayers || filter && !filter(layer) ? null : layer.name].concat((layer.sublayers || []).reduce(function (list, sublayer) {
return list.concat(_toConsumableArray(_this2.getSublayerNames(sublayer, false, filter)));
}, [])).filter(function (x) {
return x;
});
},
mergeSubLayers: function mergeSubLayers(baselayer, addlayer) {
addlayer = _objectSpread(_objectSpread({}, baselayer), {}, {
sublayers: addlayer.sublayers
});
addlayer.externalLayerMap = _objectSpread({}, addlayer.externalLayerMap);
LayerUtils.extractExternalLayersFromSublayers(addlayer, addlayer);
if (isEmpty(addlayer.sublayers)) {
return _objectSpread({}, baselayer);
}
if (isEmpty(baselayer.sublayers)) {
return addlayer;
}
var explodedBase = LayerUtils.explodeLayers([baselayer]);
var existing = explodedBase.map(function (entry) {
return entry.sublayer.name;
});
var explodedAdd = LayerUtils.explodeLayers([addlayer]);
explodedAdd = explodedAdd.filter(function (entry) {
return !existing.includes(entry.sublayer.name);
});
return LayerUtils.implodeLayers(explodedAdd.concat(explodedBase))[0];
},
searchSubLayer: function searchSubLayer(layer, attr, value) {
var path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
if (layer.sublayers) {
var idx = 0;
var _iterator14 = _createForOfIteratorHelper(layer.sublayers),
_step14;
try {
for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
var sublayer = _step14.value;
var match = sublayer[attr] === value ? sublayer : LayerUtils.searchSubLayer(sublayer, attr, value, path);
if (match) {
path.unshift(idx);
return match;
}
idx += 1;
}
} catch (err) {
_iterator14.e(err);
} finally {
_iterator14.f();
}
} else {
if (layer[attr] === value) {
return layer;
}
}
return null;
},
matchSubLayer: function matchSubLayer(layer, func) {
var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
if (layer.sublayers) {
var idx = 0;
var _iterator15 = _createForOfIteratorHelper(layer.sublayers),
_step15;
try {
for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
var sublayer = _step15.value;
var match = func(sublayer) ? sublayer : LayerUtils.matchSubLayer(sublayer, func, path);
if (match) {
path.unshift(idx);
return match;
}
idx += 1;
}
} catch (err) {
_iterator15.e(err);
} finally {
_iterator15.f();
}
} else {
if (func(layer)) {
return layer;
}
}
return null;
},
searchLayer: function searchLayer(layers, attr, value, subattr, subval) {
var match = null;
layers.find(function (layer) {
var sublayer = null;
var path = [];
if (layer[attr] === value && (sublayer = LayerUtils.searchSubLayer(layer, subattr, subval, path))) {
match = {
layer: layer,
sublayer: sublayer,
path: path
};
return true;
}
return false;
});
return match;
},
sublayerVisible: function sublayerVisible(layer, sublayerpath) {
var visible = layer.visibility !== false;
var sublayer = layer;
var _iterator16 = _createForOfIteratorHelper(sublayerpath),
_step16;
try {
for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
var index = _step16.value;
sublayer = sublayer.sublayers[index];
visible &= sublayer.visibility !== false;
if (!visible) {
return false;
}
}
} catch (err) {
_iterator16.e(err);
} finally {
_iterator16.f();
}
return true;
},
computeLayerVisibility: function computeLayerVisibility(layer) {
if (isEmpty(layer.sublayers) || layer.visibility === false) {
return layer.visibility ? 1 : 0;
}
var visible = 0;
layer.sublayers.map(function (sublayer) {
var _sublayer$visibility;
var sublayervisibility = (_sublayer$visibility = sublayer.visibility) !== null && _sublayer$visibility !== void 0 ? _sublayer$visibility : true;
if (sublayer.sublayers && sublayervisibility) {
visible += LayerUtils.computeLayerVisibility(sublayer);
} else {
visible += sublayervisibility ? 1 : 0;
}
});
return visible / layer.sublayers.length;
},
computeLayerOpacity: function computeLayerOpacity(layer) {
if (isEmpty(layer.sublayers)) {
var _layer$opacity3;
return (_layer$opacity3 = layer.opacity) !== null && _layer$opacity3 !== void 0 ? _layer$opacity3 : 255;
}
var opacity = 0;
layer.sublayers.map(function (sublayer) {
opacity += LayerUtils.computeLayerOpacity(sublayer);
});
return opacity / layer.sublayers.length;
},
computeLayerQueryable: function computeLayerQueryable(layer) {
var queryable = 0;
layer.sublayers.map(function (sublayer) {
var _sublayer$omitFromQue;
var sublayerqueryable = (_sublayer$omitFromQue = !sublayer.omitFromQueryLayers) !== null && _sublayer$omitFromQue !== void 0 ? _sublayer$omitFromQue : true;
if (sublayer.sublayers && sublayerqueryable) {
queryable += LayerUtils.computeLayerQueryable(sublayer);
} else {
queryable += sublayerqueryable ? 1 : 0;
}
});
return queryable / layer.sublayers.length;
},
hasQueryableSublayers: function hasQueryableSublayers(layer) {
return layer.sublayers.find(function (sublayer) {
return sublayer.sulayers ? LayerUtils.hasQueryableSublayers(sublayer) : sublayer.queryable;
});
},
cloneLayer: function cloneLayer(layer, sublayerpath) {
var newlayer = _objectSpread({}, layer);
var cur = newlayer;
for (var i = 0; i < sublayerpath.length; ++i) {
var idx = sublayerpath[i];
cur.sublayers = [].concat(_toConsumableArray(cur.sublayers.slice(0, idx)), [_objectSpread({}, cur.sublayers[idx])], _toConsumableArray(cur.sublayers.slice(idx + 1)));
cur = cur.sublayers[idx];
}
return {
newlayer: newlayer,
newsublayer: cur
};
},
collectGroupLayers: function collectGroupLayers(layer, parentGroups, groupLayers) {
if (!isEmpty(layer.sublayers)) {
var _iterator17 = _createForOfIteratorHelper(layer.sublayers),
_step17;
try {
for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
var sublayer = _step17.value;
LayerUtils.collectGroupLayers(sublayer, parentGroups.concat(layer.name), groupLayers);
}
} catch (err) {
_iterator17.e(err);
} finally {
_iterator17.f();
}
} else {
var _iterator18 = _createForOfIteratorHelper(parentGroups),
_step18;
try {
for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
var group = _step18.value;
groupLayers[group] = (groupLayers[group] || []).concat(layer.name);
}
} catch (err) {
_iterator18.e(err);
} finally {
_iterator18.f();
}
}
},
replaceLayerGroups: function replaceLayerGroups(layerConfigs, layer) {
var groupLayers = {};
LayerUtils.collectGroupLayers(layer, [], groupLayers);
var newLayerConfigs = [];
var _iterator19 = _createForOfIteratorHelper(layerConfigs),
_step19;
try {
var _loop4 = function _loop4() {
var layerConfig = _step19.value;
if (layerConfig.name in groupLayers) {
newLayerConfigs.push.apply(newLayerConfigs, _toConsumableArray(groupLayers[layerConfig.name].map(function (name) {
return _objectSpread(_objectSpread({}, layerConfig), {}, {
name: name
});
})));
} else {
newLayerConfigs.push(layerConfig);
}
};
for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
_loop4();
}
} catch (err) {
_iterator19.e(err);
} finally {
_iterator19.f();
}
return newLayerConfigs;
},
extractExternalLayersFromSublayers: function extractExternalLayersFromSublayers(toplayer, layer) {
if (layer.sublayers) {
layer.sublayers = layer.sublayers.map(function (sublayer) {
if (sublayer.externalLayer) {
var externalLayer = _objectSpread({}, sublayer.externalLayer);
LayerUtils.completeExternalLayer(externalLayer, sublayer, toplayer.mapCrs);
toplayer.externalLayerMap[sublayer.name] = externalLayer;
sublayer = _objectSpread({}, sublayer);
delete sublayer.externalLayer;
}
if (sublayer.sublayers) {
LayerUtils.extractExternalLayersFromSublayers(toplayer, sublayer);
}
return sublayer;
});
}
},
completeExternalLayer: function completeExternalLayer(externalLayer, sublayer, mapCrs) {
externalLayer.title = externalLayer.title || (sublayer || {}).title || externalLayer.name;
externalLayer.id = uuidv4();
if (externalLayer.type === "wms" || externalLayer.params) {
externalLayer.version = externalLayer.version || "1.3.0";
externalLayer.featureInfoUrl = externalLayer.featureInfoUrl || externalLayer.url;
externalLayer.legendUrl = externalLayer.legendUrl || externalLayer.url;
externalLayer.queryLayers = externalLayer.queryLayers || externalLayer.params.LAYERS.split(",");
var externalLayerFeatureInfoFormats = ConfigUtils.getConfigProp("externalLayerFeatureInfoFormats") || {};
for (var _i3 = 0, _Object$keys = Object.keys(externalLayerFeatureInfoFormats); _i3 < _Object$keys.length; _i3++) {
var entry = _Object$keys[_i3];
if (externalLayer.featureInfoUrl.toLowerCase().includes(entry.toLowerCase())) {
externalLayer.infoFormats = [externalLayerFeatureInfoFormats[entry]];
break;
}
}
} else if (externalLayer.type === "mvt") {
externalLayer.projection = mapCrs;
if (externalLayer.tileGridName) {
externalLayer.tileGridConfig = (ConfigUtils.getConfigProp("mvtTileGrids") || {})[externalLayer.tileGridName];
if (!externalLayer.tileGridConfig) {
/* eslint-disable-next-line */
console.warn("Tile grid config not found: " + externalLayer.tileGridName);
}
}
}
},
getLegendUrl: function getLegendUrl(layer, sublayer, scale, map, bboxDependentLegend, scaleDependentLegend, extraLegendParameters) {
if (layer.type !== "wms") {
return layer.legendUrl || "";
}
var requestParams = {
SERVICE: "WMS",
REQUEST: "GetLegendGraphic",
FORMAT: "image/png",
CRS: map.projection,
SRS: map.projection,
SLD_VERSION: "1.1.0",
WIDTH: 200,
HEIGHT: 200
};
if (extraLegendParameters) {
Object.assign(requestParams, Object.fromEntries(extraLegendParameters.split("&").map(function (entry) {
return entry.split("=");
})));
}
if (scaleDependentLegend === true || scaleDependentLegend === "theme" && layer.role === LayerRole.THEME) {
requestParams.SCALE = Math.round(scale);
}
if (bboxDependentLegend === true || bboxDependentLegend === "theme" && layer.role === LayerRole.THEME) {
var bounds = map.bbox.bounds;
if (CoordinatesUtils.getAxisOrder(map.projection).substr(0, 2) === 'ne' && layer.version === '1.3.0') {
requestParams.BBOX = [bounds[1], bounds[0], bounds[3], bounds[2]].join(",");
} else {
requestParams.BBOX = bounds.join(",");
}
}
if (layer.externalLayerMap && layer.externalLayerMap[sublayer.name]) {
var externalLayer = layer.externalLayerMap[sublayer.name];
if (externalLayer.type !== "wms") {
return externalLayer.legendUrl || "";
}
var urlParts = url.parse(externalLayer.legendUrl, true);
urlParts.query = Object.keys(urlParts.query).filter(function (key) {
// Filter service, request, version
return !["service", "request", "version"].includes(key.toLowerCase());
}).reduce(function (res, key) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, key, urlParts.query[key]));
}, {});
urlParts.query = _objectSpread(_objectSpread(_objectSpread({
VERSION: layer.version
}, urlParts.query), requestParams), {}, {
LAYER: externalLayer.params.LAYERS
});
delete urlParts.search;
return url.format(urlParts);
} else {
var _layer$params$FILTER;
var layername = layer === sublayer ? layer.params.LAYERS.split(",").reverse().join(",") : sublayer.name;
var style = layer === sublayer ? layer.params.STYLES.split(",").reverse().join(",") : sublayer.style;
var _urlParts = url.parse(layer.legendUrl, true);
_urlParts.query = Object.keys(_urlParts.query).filter(function (key) {
// Filter service, request, version
return !["service", "request", "version"].includes(key.toLowerCase());
}).reduce(function (res, key) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, key, _urlParts.query[key]));
}, {});
_urlParts.query = _objectSpread(_objectSpread(_objectSpread({
VERSION: layer.version
}, _urlParts.query), requestParams), {}, {
LAYER: layername,
STYLES: style,
FILTER: (_layer$params$FILTER = layer.params.FILTER) !== null && _layer$params$FILTER !== void 0 ? _layer$params$FILTER : ''
});
delete _urlParts.search;
return url.format(_urlParts);
}
},
layerScaleInRange: function layerScaleInRange(layer, mapScale) {
return (layer.minScale === undefined || mapScale >= layer.minScale) && (layer.maxScale === undefined || mapScale < layer.maxScale);
},
addExternalLayerPrintParams: function addExternalLayerPrintParams(layer, params, printCrs, counterRef) {
var qgisServerVersion = ConfigUtils.getConfigProp("qgisServerVersion", null, 3);
if (qgisServerVersion >= 3) {
if (layer.type === "wms") {
var layerUrl = layer.url;
var urlParts = url.parse(layerUrl, true);
// Resolve relative urls
if (!urlParts.host) {
var locationParts = url.parse(window.location.href);
urlParts.protocol = locationParts.protocol;
urlParts.host = locationParts.host;
delete urlParts.search;
layerUrl = url.format(urlParts);
}
var identifier = String.fromCharCode(65 + counterRef[0]++);
params.LAYERS.push("EXTERNAL_WMS:" + identifier);
params.STYLES.push("");
params.COLORS.push("");
params[identifier + ":url"] = layerUrl;
params[identifier + ":layers"] = layer.params.LAYERS;
params[identifier + ":styles"] = layer.params.STYLES;
params[identifier + ":format"] = "image/png";
if (layer.serverType === 'qgis' && layer.params.FILTER) {
params[identifier + ":filter"] = layer.params.FILTER;
}
params[identifier + ":crs"] = printC