578 lines
23 KiB
JavaScript
578 lines
23 KiB
JavaScript
(function e(t, n, r) { function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} }; t[o][0].call(l.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++)s(r[o]); return s })({
|
|
1: [function (require, module, exports) {
|
|
'use strict';
|
|
var immediate = require('immediate');
|
|
|
|
/* istanbul ignore next */
|
|
function INTERNAL() { }
|
|
|
|
var handlers = {};
|
|
|
|
var REJECTED = ['REJECTED'];
|
|
var FULFILLED = ['FULFILLED'];
|
|
var PENDING = ['PENDING'];
|
|
|
|
module.exports = exports = Promise;
|
|
|
|
function Promise(resolver) {
|
|
if (typeof resolver !== 'function') {
|
|
throw new TypeError('resolver must be a function');
|
|
}
|
|
this.state = PENDING;
|
|
this.queue = [];
|
|
this.outcome = void 0;
|
|
if (resolver !== INTERNAL) {
|
|
safelyResolveThenable(this, resolver);
|
|
}
|
|
}
|
|
|
|
Promise.prototype["catch"] = function (onRejected) {
|
|
return this.then(null, onRejected);
|
|
};
|
|
Promise.prototype.then = function (onFulfilled, onRejected) {
|
|
if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
|
|
typeof onRejected !== 'function' && this.state === REJECTED) {
|
|
return this;
|
|
}
|
|
var promise = new this.constructor(INTERNAL);
|
|
if (this.state !== PENDING) {
|
|
var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
|
|
unwrap(promise, resolver, this.outcome);
|
|
} else {
|
|
this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
|
|
}
|
|
|
|
return promise;
|
|
};
|
|
function QueueItem(promise, onFulfilled, onRejected) {
|
|
this.promise = promise;
|
|
if (typeof onFulfilled === 'function') {
|
|
this.onFulfilled = onFulfilled;
|
|
this.callFulfilled = this.otherCallFulfilled;
|
|
}
|
|
if (typeof onRejected === 'function') {
|
|
this.onRejected = onRejected;
|
|
this.callRejected = this.otherCallRejected;
|
|
}
|
|
}
|
|
QueueItem.prototype.callFulfilled = function (value) {
|
|
handlers.resolve(this.promise, value);
|
|
};
|
|
QueueItem.prototype.otherCallFulfilled = function (value) {
|
|
unwrap(this.promise, this.onFulfilled, value);
|
|
};
|
|
QueueItem.prototype.callRejected = function (value) {
|
|
handlers.reject(this.promise, value);
|
|
};
|
|
QueueItem.prototype.otherCallRejected = function (value) {
|
|
unwrap(this.promise, this.onRejected, value);
|
|
};
|
|
|
|
function unwrap(promise, func, value) {
|
|
immediate(function () {
|
|
var returnValue;
|
|
try {
|
|
returnValue = func(value);
|
|
} catch (e) {
|
|
return handlers.reject(promise, e);
|
|
}
|
|
if (returnValue === promise) {
|
|
handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
|
|
} else {
|
|
handlers.resolve(promise, returnValue);
|
|
}
|
|
});
|
|
}
|
|
|
|
handlers.resolve = function (self, value) {
|
|
var result = tryCatch(getThen, value);
|
|
if (result.status === 'error') {
|
|
return handlers.reject(self, result.value);
|
|
}
|
|
var thenable = result.value;
|
|
|
|
if (thenable) {
|
|
safelyResolveThenable(self, thenable);
|
|
} else {
|
|
self.state = FULFILLED;
|
|
self.outcome = value;
|
|
var i = -1;
|
|
var len = self.queue.length;
|
|
while (++i < len) {
|
|
self.queue[i].callFulfilled(value);
|
|
}
|
|
}
|
|
return self;
|
|
};
|
|
handlers.reject = function (self, error) {
|
|
self.state = REJECTED;
|
|
self.outcome = error;
|
|
var i = -1;
|
|
var len = self.queue.length;
|
|
while (++i < len) {
|
|
self.queue[i].callRejected(error);
|
|
}
|
|
return self;
|
|
};
|
|
|
|
function getThen(obj) {
|
|
// Make sure we only access the accessor once as required by the spec
|
|
var then = obj && obj.then;
|
|
if (obj && typeof obj === 'object' && typeof then === 'function') {
|
|
return function appyThen() {
|
|
then.apply(obj, arguments);
|
|
};
|
|
}
|
|
}
|
|
|
|
function safelyResolveThenable(self, thenable) {
|
|
// Either fulfill, reject or reject with error
|
|
var called = false;
|
|
function onError(value) {
|
|
if (called) {
|
|
return;
|
|
}
|
|
called = true;
|
|
handlers.reject(self, value);
|
|
}
|
|
|
|
function onSuccess(value) {
|
|
if (called) {
|
|
return;
|
|
}
|
|
called = true;
|
|
handlers.resolve(self, value);
|
|
}
|
|
|
|
function tryToUnwrap() {
|
|
thenable(onSuccess, onError);
|
|
}
|
|
|
|
var result = tryCatch(tryToUnwrap);
|
|
if (result.status === 'error') {
|
|
onError(result.value);
|
|
}
|
|
}
|
|
|
|
function tryCatch(func, value) {
|
|
var out = {};
|
|
try {
|
|
out.value = func(value);
|
|
out.status = 'success';
|
|
} catch (e) {
|
|
out.status = 'error';
|
|
out.value = e;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
exports.resolve = resolve;
|
|
function resolve(value) {
|
|
if (value instanceof this) {
|
|
return value;
|
|
}
|
|
return handlers.resolve(new this(INTERNAL), value);
|
|
}
|
|
|
|
exports.reject = reject;
|
|
function reject(reason) {
|
|
var promise = new this(INTERNAL);
|
|
return handlers.reject(promise, reason);
|
|
}
|
|
|
|
exports.all = all;
|
|
function all(iterable) {
|
|
var self = this;
|
|
if (Object.prototype.toString.call(iterable) !== '[object Array]') {
|
|
return this.reject(new TypeError('must be an array'));
|
|
}
|
|
|
|
var len = iterable.length;
|
|
var called = false;
|
|
if (!len) {
|
|
return this.resolve([]);
|
|
}
|
|
|
|
var values = new Array(len);
|
|
var resolved = 0;
|
|
var i = -1;
|
|
var promise = new this(INTERNAL);
|
|
|
|
while (++i < len) {
|
|
allResolver(iterable[i], i);
|
|
}
|
|
return promise;
|
|
function allResolver(value, i) {
|
|
self.resolve(value).then(resolveFromAll, function (error) {
|
|
if (!called) {
|
|
called = true;
|
|
handlers.reject(promise, error);
|
|
}
|
|
});
|
|
function resolveFromAll(outValue) {
|
|
values[i] = outValue;
|
|
if (++resolved === len && !called) {
|
|
called = true;
|
|
handlers.resolve(promise, values);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
exports.race = race;
|
|
function race(iterable) {
|
|
var self = this;
|
|
if (Object.prototype.toString.call(iterable) !== '[object Array]') {
|
|
return this.reject(new TypeError('must be an array'));
|
|
}
|
|
|
|
var len = iterable.length;
|
|
var called = false;
|
|
if (!len) {
|
|
return this.resolve([]);
|
|
}
|
|
|
|
var i = -1;
|
|
var promise = new this(INTERNAL);
|
|
|
|
while (++i < len) {
|
|
resolver(iterable[i]);
|
|
}
|
|
return promise;
|
|
function resolver(value) {
|
|
self.resolve(value).then(function (response) {
|
|
if (!called) {
|
|
called = true;
|
|
handlers.resolve(promise, response);
|
|
}
|
|
}, function (error) {
|
|
if (!called) {
|
|
called = true;
|
|
handlers.reject(promise, error);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
}, { "immediate": 2 }], 2: [function (require, module, exports) {
|
|
(function (global) {
|
|
'use strict';
|
|
var Mutation = global.MutationObserver || global.WebKitMutationObserver;
|
|
|
|
var scheduleDrain;
|
|
|
|
{
|
|
if (Mutation) {
|
|
var called = 0;
|
|
var observer = new Mutation(nextTick);
|
|
var element = global.document.createTextNode('');
|
|
observer.observe(element, {
|
|
characterData: true
|
|
});
|
|
scheduleDrain = function () {
|
|
element.data = (called = ++called % 2);
|
|
};
|
|
} else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
|
|
var channel = new global.MessageChannel();
|
|
channel.port1.onmessage = nextTick;
|
|
scheduleDrain = function () {
|
|
channel.port2.postMessage(0);
|
|
};
|
|
} else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
|
|
scheduleDrain = function () {
|
|
|
|
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
|
|
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
|
|
var scriptEl = global.document.createElement('script');
|
|
scriptEl.onreadystatechange = function () {
|
|
nextTick();
|
|
|
|
scriptEl.onreadystatechange = null;
|
|
scriptEl.parentNode.removeChild(scriptEl);
|
|
scriptEl = null;
|
|
};
|
|
global.document.documentElement.appendChild(scriptEl);
|
|
};
|
|
} else {
|
|
scheduleDrain = function () {
|
|
setTimeout(nextTick, 0);
|
|
};
|
|
}
|
|
}
|
|
|
|
var draining;
|
|
var queue = [];
|
|
//named nextTick for less confusing stack traces
|
|
function nextTick() {
|
|
draining = true;
|
|
var i, oldQueue;
|
|
var len = queue.length;
|
|
while (len) {
|
|
oldQueue = queue;
|
|
queue = [];
|
|
i = -1;
|
|
while (++i < len) {
|
|
oldQueue[i]();
|
|
}
|
|
len = queue.length;
|
|
}
|
|
draining = false;
|
|
}
|
|
|
|
module.exports = immediate;
|
|
function immediate(task) {
|
|
if (queue.push(task) === 1 && !draining) {
|
|
scheduleDrain();
|
|
}
|
|
}
|
|
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
}, {}], 3: [function (require, module, exports) {
|
|
(function (global) {
|
|
'use strict';
|
|
var jsonp = require('./jsonp');
|
|
var Promise = require('lie');
|
|
|
|
module.exports = function (url, options) {
|
|
options = options || {};
|
|
if (options.jsonp) {
|
|
return jsonp(url, options);
|
|
}
|
|
var request;
|
|
var cancel;
|
|
var out = new Promise(function (resolve, reject) {
|
|
cancel = reject;
|
|
if (global.XMLHttpRequest === undefined) {
|
|
reject('XMLHttpRequest is not supported');
|
|
}
|
|
var response;
|
|
request = new global.XMLHttpRequest();
|
|
request.open('GET', url);
|
|
if (options.headers) {
|
|
Object.keys(options.headers).forEach(function (key) {
|
|
request.setRequestHeader(key, options.headers[key]);
|
|
});
|
|
}
|
|
request.onreadystatechange = function () {
|
|
if (request.readyState === 4) {
|
|
if ((request.status < 400 && options.local) || request.status === 200) {
|
|
if (global.JSON) {
|
|
response = JSON.parse(request.responseText);
|
|
} else {
|
|
reject(new Error('JSON is not supported'));
|
|
}
|
|
resolve(response);
|
|
} else {
|
|
if (!request.status) {
|
|
reject('Attempted cross origin request without CORS enabled');
|
|
} else {
|
|
reject(request.statusText);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
request.send();
|
|
});
|
|
out.catch(function (reason) {
|
|
request.abort();
|
|
return reason;
|
|
});
|
|
out.abort = cancel;
|
|
return out;
|
|
};
|
|
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
}, { "./jsonp": 5, "lie": 1 }], 4: [function (require, module, exports) {
|
|
(function (global) {
|
|
'use strict';
|
|
var L = global.L || require('leaflet');
|
|
var Promise = require('lie');
|
|
var ajax = require('./ajax');
|
|
L.GeoJSON.AJAX = L.GeoJSON.extend({
|
|
defaultAJAXparams: {
|
|
dataType: 'json',
|
|
callbackParam: 'callback',
|
|
local: false,
|
|
middleware: function (f) {
|
|
return f;
|
|
}
|
|
},
|
|
initialize: function (url, options) {
|
|
this.urls = [];
|
|
if (url) {
|
|
if (typeof url === 'string') {
|
|
this.urls.push(url);
|
|
} else if (typeof url.pop === 'function') {
|
|
this.urls = this.urls.concat(url);
|
|
} else {
|
|
options = url;
|
|
url = undefined;
|
|
}
|
|
}
|
|
var ajaxParams = L.Util.extend({}, this.defaultAJAXparams);
|
|
|
|
for (var i in options) {
|
|
if (this.defaultAJAXparams.hasOwnProperty(i)) {
|
|
ajaxParams[i] = options[i];
|
|
}
|
|
}
|
|
this.ajaxParams = ajaxParams;
|
|
this._layers = {};
|
|
L.Util.setOptions(this, options);
|
|
this.on('data:loaded', function () {
|
|
if (this.filter) {
|
|
this.refilter(this.filter);
|
|
}
|
|
}, this);
|
|
var self = this;
|
|
if (this.urls.length > 0) {
|
|
new Promise(function (resolve) {
|
|
resolve();
|
|
}).then(function () {
|
|
self.addUrl();
|
|
});
|
|
}
|
|
},
|
|
clearLayers: function () {
|
|
this.urls = [];
|
|
L.GeoJSON.prototype.clearLayers.call(this);
|
|
return this;
|
|
},
|
|
addUrl: function (url) {
|
|
var self = this;
|
|
if (url) {
|
|
if (typeof url === 'string') {
|
|
self.urls.push(url);
|
|
} else if (typeof url.pop === 'function') {
|
|
self.urls = self.urls.concat(url);
|
|
}
|
|
}
|
|
var loading = self.urls.length;
|
|
var done = 0;
|
|
self.fire('data:loading');
|
|
self.urls.forEach(function (url) {
|
|
if (self.ajaxParams.dataType.toLowerCase() === 'json') {
|
|
ajax(url, self.ajaxParams).then(function (d) {
|
|
var data = self.ajaxParams.middleware(d);
|
|
self.addData(data);
|
|
self.fire('data:progress', data);
|
|
}, function (err) {
|
|
self.fire('data:progress', {
|
|
error: err
|
|
});
|
|
});
|
|
} else if (self.ajaxParams.dataType.toLowerCase() === 'jsonp') {
|
|
L.Util.jsonp(url, self.ajaxParams).then(function (d) {
|
|
var data = self.ajaxParams.middleware(d);
|
|
self.addData(data);
|
|
self.fire('data:progress', data);
|
|
}, function (err) {
|
|
self.fire('data:progress', {
|
|
error: err
|
|
});
|
|
});
|
|
}
|
|
});
|
|
self.on('data:progress', function () {
|
|
if (++done === loading) {
|
|
self.fire('data:loaded');
|
|
}
|
|
});
|
|
},
|
|
refresh: function (url) {
|
|
url = url || this.urls;
|
|
this.clearLayers();
|
|
this.addUrl(url);
|
|
},
|
|
refilter: function (func) {
|
|
if (typeof func !== 'function') {
|
|
this.filter = false;
|
|
this.eachLayer(function (a) {
|
|
a.setStyle({
|
|
stroke: true,
|
|
clickable: true
|
|
});
|
|
});
|
|
} else {
|
|
this.filter = func;
|
|
this.eachLayer(function (a) {
|
|
if (func(a.feature)) {
|
|
a.setStyle({
|
|
stroke: true,
|
|
clickable: true
|
|
});
|
|
} else {
|
|
a.setStyle({
|
|
stroke: false,
|
|
clickable: false
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
L.Util.Promise = Promise;
|
|
L.Util.ajax = ajax;
|
|
L.Util.jsonp = require('./jsonp');
|
|
L.geoJson.ajax = function (geojson, options) {
|
|
return new L.GeoJSON.AJAX(geojson, options);
|
|
};
|
|
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
}, { "./ajax": 3, "./jsonp": 5, "leaflet": undefined, "lie": 1 }], 5: [function (require, module, exports) {
|
|
(function (global) {
|
|
'use strict';
|
|
var L = global.L || require('leaflet');
|
|
var Promise = require('lie');
|
|
|
|
module.exports = function (url, options) {
|
|
options = options || {};
|
|
var head = document.getElementsByTagName('head')[0];
|
|
var scriptNode = L.DomUtil.create('script', '', head);
|
|
var cbName, ourl, cbSuffix, cancel;
|
|
var out = new Promise(function (resolve, reject) {
|
|
cancel = reject;
|
|
var cbParam = options.cbParam || 'callback';
|
|
if (options.callbackName) {
|
|
cbName = options.callbackName;
|
|
} else {
|
|
cbSuffix = '_' + ('' + Math.random()).slice(2);
|
|
cbName = '_leafletJSONPcallbacks.' + cbSuffix;
|
|
}
|
|
scriptNode.type = 'text/javascript';
|
|
if (cbSuffix) {
|
|
if (!global._leafletJSONPcallbacks) {
|
|
global._leafletJSONPcallbacks = {
|
|
length: 0
|
|
};
|
|
}
|
|
global._leafletJSONPcallbacks.length++;
|
|
global._leafletJSONPcallbacks[cbSuffix] = function (data) {
|
|
head.removeChild(scriptNode);
|
|
delete global._leafletJSONPcallbacks[cbSuffix];
|
|
global._leafletJSONPcallbacks.length--;
|
|
if (!global._leafletJSONPcallbacks.length) {
|
|
delete global._leafletJSONPcallbacks;
|
|
}
|
|
resolve(data);
|
|
};
|
|
}
|
|
if (url.indexOf('?') === -1) {
|
|
ourl = url + '?' + cbParam + '=' + cbName;
|
|
} else {
|
|
ourl = url + '&' + cbParam + '=' + cbName;
|
|
}
|
|
scriptNode.src = ourl;
|
|
}).then(null, function (reason) {
|
|
head.removeChild(scriptNode);
|
|
delete L.Util.ajax.cb[cbSuffix];
|
|
return reason;
|
|
});
|
|
out.abort = cancel;
|
|
return out;
|
|
};
|
|
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
}, { "leaflet": undefined, "lie": 1 }]
|
|
}, {}, [4]);
|