Browse Source

update des libs

pull/23/head
b_b 11 months ago
parent
commit
535e40dc4a
  1. 532
      lib/leaflet/plugins/Control.FullScreen.js
  2. 1203
      lib/leaflet/plugins/Leaflet.GoogleMutant.js
  3. 155
      lib/leaflet/plugins/leaflet-providers.js
  4. 4356
      lib/leaflet/plugins/leaflet.markercluster-src.js

532
lib/leaflet/plugins/Control.FullScreen.js vendored

@ -1,228 +1,344 @@
(function () {
L.Control.FullScreen = L.Control.extend({
options: {
position: 'topleft',
title: 'Full Screen',
titleCancel: 'Exit Full Screen',
forceSeparateButton: false,
forcePseudoFullscreen: false,
fullscreenElement: false
},
onAdd: function (map) {
var className = 'leaflet-control-zoom-fullscreen', container, content = '';
if (map.zoomControl && !this.options.forceSeparateButton) {
container = map.zoomControl._container;
} else {
container = L.DomUtil.create('div', 'leaflet-bar');
}
if (this.options.content) {
content = this.options.content;
} else {
className += ' fullscreen-icon';
}
/*!
* Based on package 'screenfull'
* v5.1.0 - 2020-12-24
* (c) Sindre Sorhus; MIT License
* Added definition for using screenfull as an amd module
* Must be placed before the definition of leaflet.fullscreen
* as it is required by that
*/
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
define('screenfull', factory);
} else if (typeof module === 'object' && module.exports) {
module.exports.screenfull = factory();
} else {
// Save 'screenfull' into global window variable
root.screenfull = factory();
}
}(this, function () {
'use strict';
this._createButton(this.options.title, className, content, container, this.toggleFullScreen, this);
this._map.fullscreenControl = this;
this._map.on('enterFullscreen exitFullscreen', this._toggleTitle, this);
return container;
},
onRemove: function (map) {
L.DomEvent
.off(this.link, 'click', L.DomEvent.stopPropagation)
.off(this.link, 'click', L.DomEvent.preventDefault)
.off(this.link, 'click', this.toggleFullScreen, this);
L.DomEvent
.off(this._container, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
.off(this._container, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
.off(this._container, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, this);
L.DomEvent
.off(document, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
.off(document, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
.off(document, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, this);
},
_createButton: function (title, className, content, container, fn, context) {
this.link = L.DomUtil.create('a', className, container);
this.link.href = '#';
this.link.title = title;
this.link.innerHTML = content;
this.link.setAttribute('role', 'button');
this.link.setAttribute('aria-label', title);
L.DomEvent
.on(this.link, 'click', L.DomEvent.stopPropagation)
.on(this.link, 'click', L.DomEvent.preventDefault)
.on(this.link, 'click', fn, context);
L.DomEvent
.on(container, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
.on(container, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
.on(container, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, context);
L.DomEvent
.on(document, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
.on(document, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
.on(document, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, context);
return this.link;
},
toggleFullScreen: function () {
var map = this._map;
map._exitFired = false;
if (map._isFullscreen) {
if (fullScreenApi.supportsFullScreen && !this.options.forcePseudoFullscreen) {
fullScreenApi.cancelFullScreen();
} else {
L.DomUtil.removeClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
var document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};
var fn = (function () {
var val;
var fnMap = [
[
'requestFullscreen',
'exitFullscreen',
'fullscreenElement',
'fullscreenEnabled',
'fullscreenchange',
'fullscreenerror'
],
// New WebKit
[
'webkitRequestFullscreen',
'webkitExitFullscreen',
'webkitFullscreenElement',
'webkitFullscreenEnabled',
'webkitfullscreenchange',
'webkitfullscreenerror'
],
// Old WebKit
[
'webkitRequestFullScreen',
'webkitCancelFullScreen',
'webkitCurrentFullScreenElement',
'webkitCancelFullScreen',
'webkitfullscreenchange',
'webkitfullscreenerror'
],
[
'mozRequestFullScreen',
'mozCancelFullScreen',
'mozFullScreenElement',
'mozFullScreenEnabled',
'mozfullscreenchange',
'mozfullscreenerror'
],
[
'msRequestFullscreen',
'msExitFullscreen',
'msFullscreenElement',
'msFullscreenEnabled',
'MSFullscreenChange',
'MSFullscreenError'
]
];
var i = 0;
var l = fnMap.length;
var ret = {};
for (; i < l; i++) {
val = fnMap[i];
if (val && val[1] in document) {
for (i = 0; i < val.length; i++) {
ret[fnMap[0][i]] = val[i];
}
return ret;
}
map.fire('exitFullscreen');
map._exitFired = true;
map._isFullscreen = false;
}
else {
if (fullScreenApi.supportsFullScreen && !this.options.forcePseudoFullscreen) {
fullScreenApi.requestFullScreen(this.options.fullscreenElement ? this.options.fullscreenElement : map._container);
} else {
L.DomUtil.addClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
return false;
})();
var eventNameMap = {
change: fn.fullscreenchange,
error: fn.fullscreenerror
};
var screenfull = {
request: function (element, options) {
return new Promise(function (resolve, reject) {
var onFullScreenEntered = function () {
this.off('change', onFullScreenEntered);
resolve();
}.bind(this);
this.on('change', onFullScreenEntered);
element = element || document.documentElement;
var returnPromise = element[fn.requestFullscreen](options);
if (returnPromise instanceof Promise) {
returnPromise.then(onFullScreenEntered).catch(reject);
}
}.bind(this));
},
exit: function () {
return new Promise(function (resolve, reject) {
if (!this.isFullscreen) {
resolve();
return;
}
var onFullScreenExit = function () {
this.off('change', onFullScreenExit);
resolve();
}.bind(this);
this.on('change', onFullScreenExit);
var returnPromise = document[fn.exitFullscreen]();
if (returnPromise instanceof Promise) {
returnPromise.then(onFullScreenExit).catch(reject);
}
}.bind(this));
},
toggle: function (element, options) {
return this.isFullscreen ? this.exit() : this.request(element, options);
},
onchange: function (callback) {
this.on('change', callback);
},
onerror: function (callback) {
this.on('error', callback);
},
on: function (event, callback) {
var eventName = eventNameMap[event];
if (eventName) {
document.addEventListener(eventName, callback, false);
}
map.fire('enterFullscreen');
map._isFullscreen = true;
}
},
_toggleTitle: function () {
this.link.title = this._map._isFullscreen ? this.options.title : this.options.titleCancel;
},
_handleFullscreenChange: function () {
var map = this._map;
map.invalidateSize();
if (!fullScreenApi.isFullScreen() && !map._exitFired) {
map.fire('exitFullscreen');
map._exitFired = true;
map._isFullscreen = false;
}
}
});
},
off: function (event, callback) {
var eventName = eventNameMap[event];
if (eventName) {
document.removeEventListener(eventName, callback, false);
}
},
raw: fn
};
L.Map.include({
toggleFullscreen: function () {
this.fullscreenControl.toggleFullScreen();
if (!fn) {
return {isEnabled: false};
} else {
Object.defineProperties(screenfull, {
isFullscreen: {
get: function () {
return Boolean(document[fn.fullscreenElement]);
}
},
element: {
enumerable: true,
get: function () {
return document[fn.fullscreenElement];
}
},
isEnabled: {
enumerable: true,
get: function () {
// Coerce to boolean in case of old WebKit
return Boolean(document[fn.fullscreenEnabled]);
}
}
});
return screenfull;
}
});
}));
L.Map.addInitHook(function () {
if (this.options.fullscreenControl) {
this.addControl(L.control.fullscreen(this.options.fullscreenControlOptions));
/*!
* leaflet.fullscreen
*/
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
// define an AMD module that requires 'leaflet' and 'screenfull'
// and resolve to an object containing leaflet and screenfull
define('leafletFullScreen', ['leaflet', 'screenfull'], factory);
} else if (typeof module === 'object' && module.exports) {
// define a CommonJS module that requires 'leaflet' and 'screenfull'
module.exports = factory(require('leaflet'), require('screenfull'));
} else {
// Assume 'leaflet' and 'screenfull' are loaded into global variable already
factory(root.L, root.screenfull);
}
});
}(this, function (leaflet, screenfull) {
'use strict';
L.control.fullscreen = function (options) {
return new L.Control.FullScreen(options);
};
leaflet.Control.FullScreen = leaflet.Control.extend({
options: {
position: 'topleft',
title: 'Full Screen',
titleCancel: 'Exit Full Screen',
forceSeparateButton: false,
forcePseudoFullscreen: false,
fullscreenElement: false
},
/*
Native FullScreen JavaScript API
-------------
Assumes Mozilla naming conventions instead of W3C for now
_screenfull: screenfull,
source : http://johndyer.name/native-fullscreen-javascript-api-plus-jquery-plugin/
onAdd: function (map) {
var className = 'leaflet-control-zoom-fullscreen', container, content = '';
*/
if (map.zoomControl && !this.options.forceSeparateButton) {
container = map.zoomControl._container;
} else {
container = leaflet.DomUtil.create('div', 'leaflet-bar');
}
if (this.options.content) {
content = this.options.content;
} else {
className += ' fullscreen-icon';
}
this._createButton(this.options.title, className, content, container, this.toggleFullScreen, this);
this._map.fullscreenControl = this;
this._map.on('enterFullscreen exitFullscreen', this._toggleTitle, this);
var
fullScreenApi = {
supportsFullScreen: false,
isFullScreen: function () { return false; },
requestFullScreen: function () {},
cancelFullScreen: function () {},
fullScreenEventName: '',
prefix: ''
return container;
},
browserPrefixes = 'webkit moz o ms khtml'.split(' ');
// check for native support
if (typeof document.exitFullscreen !== 'undefined') {
fullScreenApi.supportsFullScreen = true;
} else {
// check for fullscreen support by vendor prefix
for (var i = 0, il = browserPrefixes.length; i < il; i++) {
fullScreenApi.prefix = browserPrefixes[i];
if (typeof document[fullScreenApi.prefix + 'CancelFullScreen'] !== 'undefined') {
fullScreenApi.supportsFullScreen = true;
break;
onRemove: function () {
leaflet.DomEvent
.off(this.link, 'click', leaflet.DomEvent.stopPropagation)
.off(this.link, 'click', leaflet.DomEvent.preventDefault)
.off(this.link, 'click', this.toggleFullScreen, this);
leaflet.DomEvent
.off(this._container, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.stopPropagation)
.off(this._container, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.preventDefault)
.off(this._container, this._screenfull.raw.fullscreenchange, this._handleFullscreenChange, this);
leaflet.DomEvent
.off(document, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.stopPropagation)
.off(document, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.preventDefault)
.off(document, this._screenfull.raw.fullscreenchange, this._handleFullscreenChange, this);
},
_createButton: function (title, className, content, container, fn, context) {
this.link = leaflet.DomUtil.create('a', className, container);
this.link.href = '#';
this.link.title = title;
this.link.innerHTML = content;
this.link.setAttribute('role', 'button');
this.link.setAttribute('aria-label', title);
leaflet.DomEvent
.on(this.link, 'click', leaflet.DomEvent.stopPropagation)
.on(this.link, 'click', leaflet.DomEvent.preventDefault)
.on(this.link, 'click', fn, context);
leaflet.DomEvent
.on(container, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.stopPropagation)
.on(container, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.preventDefault)
.on(container, this._screenfull.raw.fullscreenchange, this._handleFullscreenChange, context);
leaflet.DomEvent
.on(document, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.stopPropagation)
.on(document, this._screenfull.raw.fullscreenchange, leaflet.DomEvent.preventDefault)
.on(document, this._screenfull.raw.fullscreenchange, this._handleFullscreenChange, context);
return this.link;
},
toggleFullScreen: function () {
var map = this._map;
map._exitFired = false;
if (map._isFullscreen) {
if (this._screenfull.isEnabled && !this.options.forcePseudoFullscreen) {
this._screenfull.exit();
} else {
leaflet.DomUtil.removeClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
map.invalidateSize();
}
map.fire('exitFullscreen');
map._exitFired = true;
map._isFullscreen = false;
}
else {
if (this._screenfull.isEnabled && !this.options.forcePseudoFullscreen) {
this._screenfull.request(this.options.fullscreenElement ? this.options.fullscreenElement : map._container);
} else {
leaflet.DomUtil.addClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
map.invalidateSize();
}
map.fire('enterFullscreen');
map._isFullscreen = true;
}
},
_toggleTitle: function () {
this.link.title = this._map._isFullscreen ? this.options.title : this.options.titleCancel;
},
_handleFullscreenChange: function () {
var map = this._map;
map.invalidateSize();
if (!this._screenfull.isFullscreen && !map._exitFired) {
map.fire('exitFullscreen');
map._exitFired = true;
map._isFullscreen = false;
}
}
if (typeof document['msExitFullscreen'] !== 'undefined') {
fullScreenApi.prefix = 'ms';
fullScreenApi.supportsFullScreen = true;
});
leaflet.Map.include({
toggleFullscreen: function () {
this.fullscreenControl.toggleFullScreen();
}
}
// update methods to do something useful
if (fullScreenApi.supportsFullScreen) {
if (fullScreenApi.prefix === 'ms') {
fullScreenApi.fullScreenEventName = 'MSFullscreenChange';
} else {
fullScreenApi.fullScreenEventName = fullScreenApi.prefix + 'fullscreenchange';
});
leaflet.Map.addInitHook(function () {
if (this.options.fullscreenControl) {
this.addControl(leaflet.control.fullscreen(this.options.fullscreenControlOptions));
}
fullScreenApi.isFullScreen = function () {
switch (this.prefix) {
case '':
return document.fullscreen;
case 'webkit':
return document.webkitIsFullScreen;
case 'ms':
return document.msFullscreenElement;
default:
return document[this.prefix + 'FullScreen'];
}
};
fullScreenApi.requestFullScreen = function (el) {
switch (this.prefix) {
case '':
return el.requestFullscreen();
case 'ms':
return el.msRequestFullscreen();
default:
return el[this.prefix + 'RequestFullScreen']();
}
};
fullScreenApi.cancelFullScreen = function () {
switch (this.prefix) {
case '':
return document.exitFullscreen();
case 'ms':
return document.msExitFullscreen();
default:
return document[this.prefix + 'CancelFullScreen']();
}
};
}
});
// jQuery plugin
if (typeof jQuery !== 'undefined') {
jQuery.fn.requestFullScreen = function () {
return this.each(function () {
var el = jQuery(this);
if (fullScreenApi.supportsFullScreen) {
fullScreenApi.requestFullScreen(el);
}
});
};
}
leaflet.control.fullscreen = function (options) {
return new leaflet.Control.FullScreen(options);
};
// export api
window.fullScreenApi = fullScreenApi;
})();
// must return an object containing also screenfull to make screenfull
// available outside of this package, if used as an amd module,
// as webpack cannot handle amd define with moduleid
return {leaflet: leaflet, screenfull: screenfull};
}));

1203
lib/leaflet/plugins/Leaflet.GoogleMutant.js

File diff suppressed because it is too large Load Diff

155
lib/leaflet/plugins/leaflet-providers.js

@ -102,7 +102,7 @@
url: 'https://{s}.tile.openstreetmap.fr/osmfr/{z}/{x}/{y}.png',
options: {
maxZoom: 20,
attribution: '&copy; Openstreetmap France | {attribution.OpenStreetMap}'
attribution: '&copy; OpenStreetMap France | {attribution.OpenStreetMap}'
}
},
HOT: {
@ -129,11 +129,11 @@
attribution: 'Map data: &copy; <a href="http://www.openseamap.org">OpenSeaMap</a> contributors'
}
},
OpenPtMap: {
url: 'http://openptmap.org/tiles/{z}/{x}/{y}.png',
OPNVKarte: {
url: 'https://tileserver.memomaps.de/tilegen/{z}/{x}/{y}.png',
options: {
maxZoom: 17,
attribution: 'Map data: &copy; <a href="http://www.openptmap.org">OpenPtMap</a> contributors'
maxZoom: 18,
attribution: 'Map <a href="https://memomaps.de/">memomaps.de</a> <a href="http://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>, map data {attribution.OpenStreetMap}'
}
},
OpenTopoMap: {
@ -219,7 +219,7 @@
}
},
CyclOSM: {
url: 'https://dev.{s}.tile.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png',
url: 'https://{s}.tile-cyclosm.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png',
options: {
maxZoom: 20,
attribution: '<a href="https://github.com/cyclosm/cyclosm-cartocss-style/releases" title="CyclOSM - Open Bicycle render">CyclOSM</a> | Map data: {attribution.OpenStreetMap}'
@ -250,7 +250,7 @@
variant: 'jawg-terrain',
// Get your own Jawg access token here : https://www.jawg.io/lab/
// NB : this is a demonstration key that comes with no guarantee
accessToken: 'PyTJUlEU1OPJwCJlW1k0NC8JIt2CALpyuj7uc066O7XbdZCjWEL3WYJIk6dnXtps',
accessToken: '<insert your access token here>',
},
variants: {
Streets: 'jawg-streets',
@ -479,7 +479,7 @@
options: {
maxZoom: 19,
attribution: 'Map data &copy; <a href="http://openweathermap.org">OpenWeatherMap</a>',
apiKey:'<insert your api key here>',
apiKey: '<insert your api key here>',
opacity: 0.5
},
variants: {
@ -724,11 +724,11 @@
}
},
FreeMapSK: {
url: 'http://t{s}.freemap.sk/T/{z}/{x}/{y}.jpeg',
url: 'https://{s}.freemap.sk/T/{z}/{x}/{y}.jpeg',
options: {
minZoom: 8,
maxZoom: 16,
subdomains: '1234',
subdomains: 'abcd',
bounds: [[47.204642, 15.996093], [49.830896, 22.576904]],
attribution:
'{attribution.OpenStreetMap}, vizualization CC-By-SA 2.0 <a href="http://freemap.sk">Freemap.sk</a>'
@ -746,7 +746,7 @@
options: {
attribution: '{attribution.OpenStreetMap} &copy; <a href="https://carto.com/attributions">CARTO</a>',
subdomains: 'abcd',
maxZoom: 19,
maxZoom: 20,
variant: 'light_all'
},
variants: {
@ -834,14 +834,14 @@
minZoom: 6,
maxZoom: 19,
bounds: [[50.5, 3.25], [54, 7.6]],
attribution: 'Kaartgegevens &copy; <a href="kadaster.nl">Kadaster</a>'
attribution: 'Kaartgegevens &copy; <a href="https://www.kadaster.nl">Kadaster</a>'
},
variants: {
'standaard': 'brtachtergrondkaart',
'pastel': 'brtachtergrondkaartpastel',
'grijs': 'brtachtergrondkaartgrijs',
'luchtfoto': {
'url': 'https://geodata.nationaalgeoregister.nl/luchtfoto/rgb/wmts/2018_ortho25/EPSG:3857/{z}/{x}/{y}.png',
'url': 'https://service.pdok.nl/hwh/luchtfotorgb/wmts/v1_0/Actueel_ortho25/EPSG:3857/{z}/{x}/{y}.jpeg',
}
}
},
@ -877,7 +877,7 @@
},
ModisTerraSnowCover: {
options: {
variant: 'MODIS_Terra_Snow_Cover',
variant: 'MODIS_Terra_NDSI_Snow_Cover',
format: 'png',
maxZoom: 8,
opacity: 0.75
@ -923,7 +923,7 @@
// Justice Map (http://www.justicemap.org/)
// Visualize race and income data for your community, county and country.
// Includes tools for data journalists, bloggers and community activists.
url: 'http://www.justicemap.org/tile/{size}/{variant}/{z}/{x}/{y}.png',
url: 'https://www.justicemap.org/tile/{size}/{variant}/{z}/{x}/{y}.png',
options: {
attribution: '<a href="http://www.justicemap.org/terms.php">Justice Map</a>',
// one of 'county', 'tract', 'block'
@ -943,14 +943,6 @@
plurality: 'plural'
}
},
Wikimedia: {
url: 'https://maps.wikimedia.org/osm-intl/{z}/{x}/{y}{r}.png',
options: {
attribution: '<a href="https://wikimediafoundation.org/wiki/Maps_Terms_of_Use">Wikimedia</a>',
minZoom: 1,
maxZoom: 19
}
},
GeoportailFrance: {
url: 'https://wxs.ign.fr/{apikey}/geoportail/wmts?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&STYLE={style}&TILEMATRIXSET=PM&FORMAT={format}&LAYER={variant}&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}',
options: {
@ -961,24 +953,23 @@
// Get your own geoportail apikey here : http://professionnels.ign.fr/ign/contrats/
// NB : 'choisirgeoportail' is a demonstration key that comes with no guarantee
apikey: 'choisirgeoportail',
format: 'image/jpeg',
style : 'normal',
variant: 'GEOGRAPHICALGRIDSYSTEMS.MAPS.SCAN-EXPRESS.STANDARD'
format: 'image/png',
style: 'normal',
variant: 'GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2'
},
variants: {
plan: 'GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2',
parcels: {
options : {
variant: 'CADASTRALPARCELS.PARCELS',
maxZoom: 20,
style : 'bdparcellaire',
format: 'image/png'
options: {
variant: 'CADASTRALPARCELS.PARCELLAIRE_EXPRESS',
style: 'PCI vecteur',
maxZoom: 20
}
},
ignMaps: 'GEOGRAPHICALGRIDSYSTEMS.MAPS',
maps: 'GEOGRAPHICALGRIDSYSTEMS.MAPS.SCAN-EXPRESS.STANDARD',
orthos: {
options: {
maxZoom: 19,
format: 'image/jpeg',
variant: 'ORTHOIMAGERY.ORTHOPHOTOS'
}
}
@ -1000,6 +991,104 @@
Grey: 'Grey',
LandLot: 'LandLot'
}
},
USGS: {
url: 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/tile/{z}/{y}/{x}',
options: {
maxZoom: 20,
attribution: 'Tiles courtesy of the <a href="https://usgs.gov/">U.S. Geological Survey</a>'
},
variants: {
USTopo: {},
USImagery: {
url: 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}'
},
USImageryTopo: {
url: 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryTopo/MapServer/tile/{z}/{y}/{x}'
}
}
},
WaymarkedTrails: {
url: 'https://tile.waymarkedtrails.org/{variant}/{z}/{x}/{y}.png',
options: {
maxZoom: 18,
attribution: 'Map data: {attribution.OpenStreetMap} | Map style: &copy; <a href="https://waymarkedtrails.org">waymarkedtrails.org</a> (<a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-SA</a>)'
},
variants: {
hiking: 'hiking',
cycling: 'cycling',
mtb: 'mtb',
slopes: 'slopes',
riding: 'riding',
skating: 'skating'
}
},
OpenAIP: {
url: 'https://{s}.tile.maps.openaip.net/geowebcache/service/tms/1.0.0/openaip_basemap@EPSG%3A900913@png/{z}/{x}/{y}.{ext}',
options: {
attribution: '<a href="https://www.openaip.net/">openAIP Data</a> (<a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-NC-SA</a>)',
ext: 'png',
minZoom: 4,
maxZoom: 14,
tms: true,
detectRetina: true,
subdomains: '12'
}
},
OpenSnowMap: {
url: 'https://tiles.opensnowmap.org/{variant}/{z}/{x}/{y}.png',
options: {
minZoom: 9,
maxZoom: 18,
attribution: 'Map data: {attribution.OpenStreetMap} & ODbL, &copy; <a href="https://www.opensnowmap.org/iframes/data.html">www.opensnowmap.org</a> <a href="https://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>'
},
variants: {
pistes: 'pistes',
}
},
AzureMaps: {
url:
'https://atlas.microsoft.com/map/tile?api-version={apiVersion}'+
'&tilesetId={variant}&x={x}&y={y}&zoom={z}&language={language}'+
'&subscription-key={subscriptionKey}',
options: {
attribution: 'See https://docs.microsoft.com/en-US/rest/api/maps/renderv2/getmaptilepreview for details.',
apiVersion: '2.0',
variant: 'microsoft.imagery',
subscriptionKey: '<insert your subscription key here>',
language: 'en-US',
},
variants: {
MicrosoftImagery: 'microsoft.imagery',
MicrosoftBaseDarkGrey: 'microsoft.base.darkgrey',
MicrosoftBaseRoad: 'microsoft.base.road',
MicrosoftBaseHybridRoad: 'microsoft.base.hybrid.road',
MicrosoftTerraMain: 'microsoft.terra.main',
MicrosoftWeatherInfraredMain: {
url:
'https://atlas.microsoft.com/map/tile?api-version={apiVersion}'+
'&tilesetId={variant}&x={x}&y={y}&zoom={z}'+
'&timeStamp={timeStamp}&language={language}' +
'&subscription-key={subscriptionKey}',
options: {
timeStamp: '2021-05-08T09:03:00Z',
attribution: 'See https://docs.microsoft.com/en-US/rest/api/maps/renderv2/getmaptilepreview#uri-parameters for details.',
variant: 'microsoft.weather.infrared.main',
},
},
MicrosoftWeatherRadarMain: {
url:
'https://atlas.microsoft.com/map/tile?api-version={apiVersion}'+
'&tilesetId={variant}&x={x}&y={y}&zoom={z}'+
'&timeStamp={timeStamp}&language={language}' +
'&subscription-key={subscriptionKey}',
options: {
timeStamp: '2021-05-08T09:03:00Z',
attribution: 'See https://docs.microsoft.com/en-US/rest/api/maps/renderv2/getmaptilepreview#uri-parameters for details.',
variant: 'microsoft.weather.radar.main',
},
}
},
}
};

4356
lib/leaflet/plugins/leaflet.markercluster-src.js

File diff suppressed because it is too large Load Diff
Loading…
Cancel
Save