diff --git a/dist/esri-leaflet-debug.js b/dist/esri-leaflet-debug.js new file mode 100644 index 000000000..86c33b78d --- /dev/null +++ b/dist/esri-leaflet-debug.js @@ -0,0 +1,3808 @@ +/* esri-leaflet - v2.0.0-beta.8 - Mon Feb 29 2016 13:00:36 GMT-0800 (PST) + * Copyright (c) 2016 Environmental Systems Research Institute, Inc. + * Apache-2.0 */ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet')) : + typeof define === 'function' && define.amd ? define(['exports', 'leaflet'], factory) : + (factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}),global.L)); +}(this, function (exports,L) { 'use strict'; + + L = 'default' in L ? L['default'] : L; + + var version = "2.0.0-beta.8"; + + var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest())); + var pointerEvents = document.documentElement.style.pointerEvents === ''; + + var Support = { + cors: cors, + pointerEvents: pointerEvents + }; + + /* + * Copyright 2015 Esri + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the Liscense. + */ + + // checks if 2 x,y points are equal + function pointsEqual (a, b) { + for (var i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + + // checks if the first and last points of a ring are equal and closes the ring + function closeRing (coordinates) { + if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) { + coordinates.push(coordinates[0]); + } + return coordinates; + } + + // determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring + // or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon- + // points-are-in-clockwise-order + function ringIsClockwise (ringToTest) { + var total = 0; + var i = 0; + var rLength = ringToTest.length; + var pt1 = ringToTest[i]; + var pt2; + for (i; i < rLength - 1; i++) { + pt2 = ringToTest[i + 1]; + total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]); + pt1 = pt2; + } + return (total >= 0); + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519 + function vertexIntersectsVertex (a1, a2, b1, b2) { + var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]); + var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]); + var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]); + + if (uB !== 0) { + var ua = uaT / uB; + var ub = ubT / uB; + + if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) { + return true; + } + } + + return false; + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531 + function arrayIntersectsArray (a, b) { + for (var i = 0; i < a.length - 1; i++) { + for (var j = 0; j < b.length - 1; j++) { + if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) { + return true; + } + } + } + + return false; + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480 + function coordinatesContainPoint (coordinates, point) { + var contains = false; + for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) { + if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) || + (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) && + (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) { + contains = !contains; + } + } + return contains; + } + + // ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113 + function coordinatesContainCoordinates (outer, inner) { + var intersects = arrayIntersectsArray(outer, inner); + var contains = coordinatesContainPoint(outer, inner[0]); + if (!intersects && contains) { + return true; + } + return false; + } + + // do any polygons in this array contain any other polygons in this array? + // used for checking for holes in arcgis rings + // ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172 + function convertRingsToGeoJSON (rings) { + var outerRings = []; + var holes = []; + var x; // iterator + var outerRing; // current outer ring being evaluated + var hole; // current hole being evaluated + + // for each ring + for (var r = 0; r < rings.length; r++) { + var ring = closeRing(rings[r].slice(0)); + if (ring.length < 4) { + continue; + } + // is this ring an outer ring? is it clockwise? + if (ringIsClockwise(ring)) { + var polygon = [ ring ]; + outerRings.push(polygon); // push to outer rings + } else { + holes.push(ring); // counterclockwise push to holes + } + } + + var uncontainedHoles = []; + + // while there are holes left... + while (holes.length) { + // pop a hole off out stack + hole = holes.pop(); + + // loop over all outer rings and see if they contain our hole. + var contained = false; + for (x = outerRings.length - 1; x >= 0; x--) { + outerRing = outerRings[x][0]; + if (coordinatesContainCoordinates(outerRing, hole)) { + // the hole is contained push it into our polygon + outerRings[x].push(hole); + contained = true; + break; + } + } + + // ring is not contained in any outer ring + // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320 + if (!contained) { + uncontainedHoles.push(hole); + } + } + + // if we couldn't match any holes using contains we can try intersects... + while (uncontainedHoles.length) { + // pop a hole off out stack + hole = uncontainedHoles.pop(); + + // loop over all outer rings and see if any intersect our hole. + var intersects = false; + + for (x = outerRings.length - 1; x >= 0; x--) { + outerRing = outerRings[x][0]; + if (arrayIntersectsArray(outerRing, hole)) { + // the hole is contained push it into our polygon + outerRings[x].push(hole); + intersects = true; + break; + } + } + + if (!intersects) { + outerRings.push([hole.reverse()]); + } + } + + if (outerRings.length === 1) { + return { + type: 'Polygon', + coordinates: outerRings[0] + }; + } else { + return { + type: 'MultiPolygon', + coordinates: outerRings + }; + } + } + + // This function ensures that rings are oriented in the right directions + // outer rings are clockwise, holes are counterclockwise + // used for converting GeoJSON Polygons to ArcGIS Polygons + function orientRings (poly) { + var output = []; + var polygon = poly.slice(0); + var outerRing = closeRing(polygon.shift().slice(0)); + if (outerRing.length >= 4) { + if (!ringIsClockwise(outerRing)) { + outerRing.reverse(); + } + + output.push(outerRing); + + for (var i = 0; i < polygon.length; i++) { + var hole = closeRing(polygon[i].slice(0)); + if (hole.length >= 4) { + if (ringIsClockwise(hole)) { + hole.reverse(); + } + output.push(hole); + } + } + } + + return output; + } + + // This function flattens holes in multipolygons to one array of polygons + // used for converting GeoJSON Polygons to ArcGIS Polygons + function flattenMultiPolygonRings (rings) { + var output = []; + for (var i = 0; i < rings.length; i++) { + var polygon = orientRings(rings[i]); + for (var x = polygon.length - 1; x >= 0; x--) { + var ring = polygon[x].slice(0); + output.push(ring); + } + } + return output; + } + + // shallow object clone for feature properties and attributes + // from http://jsperf.com/cloning-an-object/2 + function shallowClone$1 (obj) { + var target = {}; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + target[i] = obj[i]; + } + } + return target; + } + + function arcgisToGeoJSON$1 (arcgis, idAttribute) { + var geojson = {}; + + if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') { + geojson.type = 'Point'; + geojson.coordinates = [arcgis.x, arcgis.y]; + } + + if (arcgis.points) { + geojson.type = 'MultiPoint'; + geojson.coordinates = arcgis.points.slice(0); + } + + if (arcgis.paths) { + if (arcgis.paths.length === 1) { + geojson.type = 'LineString'; + geojson.coordinates = arcgis.paths[0].slice(0); + } else { + geojson.type = 'MultiLineString'; + geojson.coordinates = arcgis.paths.slice(0); + } + } + + if (arcgis.rings) { + geojson = convertRingsToGeoJSON(arcgis.rings.slice(0)); + } + + if (arcgis.geometry || arcgis.attributes) { + geojson.type = 'Feature'; + geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON$1(arcgis.geometry) : null; + geojson.properties = (arcgis.attributes) ? shallowClone$1(arcgis.attributes) : null; + if (arcgis.attributes) { + geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID; + } + } + + return geojson; + } + + function geojsonToArcGIS$1 (geojson, idAttribute) { + idAttribute = idAttribute || 'OBJECTID'; + var spatialReference = { wkid: 4326 }; + var result = {}; + var i; + + switch (geojson.type) { + case 'Point': + result.x = geojson.coordinates[0]; + result.y = geojson.coordinates[1]; + result.spatialReference = spatialReference; + break; + case 'MultiPoint': + result.points = geojson.coordinates.slice(0); + result.spatialReference = spatialReference; + break; + case 'LineString': + result.paths = [geojson.coordinates.slice(0)]; + result.spatialReference = spatialReference; + break; + case 'MultiLineString': + result.paths = geojson.coordinates.slice(0); + result.spatialReference = spatialReference; + break; + case 'Polygon': + result.rings = orientRings(geojson.coordinates.slice(0)); + result.spatialReference = spatialReference; + break; + case 'MultiPolygon': + result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0)); + result.spatialReference = spatialReference; + break; + case 'Feature': + if (geojson.geometry) { + result.geometry = geojsonToArcGIS$1(geojson.geometry, idAttribute); + } + result.attributes = (geojson.properties) ? shallowClone$1(geojson.properties) : {}; + if (geojson.id) { + result.attributes[idAttribute] = geojson.id; + } + break; + case 'FeatureCollection': + result = []; + for (i = 0; i < geojson.features.length; i++) { + result.push(geojsonToArcGIS$1(geojson.features[i], idAttribute)); + } + break; + case 'GeometryCollection': + result = []; + for (i = 0; i < geojson.geometries.length; i++) { + result.push(geojsonToArcGIS$1(geojson.geometries[i], idAttribute)); + } + break; + } + + return result; + } + + function geojsonToArcGIS (geojson, idAttr) { + return geojsonToArcGIS$1(geojson, idAttr); + } + + function arcgisToGeoJSON (arcgis, idAttr) { + return arcgisToGeoJSON$1(arcgis, idAttr); + } + + // shallow object clone for feature properties and attributes + // from http://jsperf.com/cloning-an-object/2 + function shallowClone (obj) { + var target = {}; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + target[i] = obj[i]; + } + } + return target; + } + + // convert an extent (ArcGIS) to LatLngBounds (Leaflet) + function extentToBounds (extent) { + var sw = L.latLng(extent.ymin, extent.xmin); + var ne = L.latLng(extent.ymax, extent.xmax); + return L.latLngBounds(sw, ne); + } + + // convert an LatLngBounds (Leaflet) to extent (ArcGIS) + function boundsToExtent (bounds) { + bounds = L.latLngBounds(bounds); + return { + 'xmin': bounds.getSouthWest().lng, + 'ymin': bounds.getSouthWest().lat, + 'xmax': bounds.getNorthEast().lng, + 'ymax': bounds.getNorthEast().lat, + 'spatialReference': { + 'wkid': 4326 + } + }; + } + + function responseToFeatureCollection (response, idAttribute) { + var objectIdField; + + if (idAttribute) { + objectIdField = idAttribute; + } else if (response.objectIdFieldName) { + objectIdField = response.objectIdFieldName; + } else if (response.fields) { + for (var j = 0; j <= response.fields.length - 1; j++) { + if (response.fields[j].type === 'esriFieldTypeOID') { + objectIdField = response.fields[j].name; + break; + } + } + } else { + objectIdField = 'OBJECTID'; + } + + var featureCollection = { + type: 'FeatureCollection', + features: [] + }; + var features = response.features || response.results; + if (features.length) { + for (var i = features.length - 1; i >= 0; i--) { + var feature = arcgisToGeoJSON(features[i], objectIdField); + featureCollection.features.push(feature); + } + } + + return featureCollection; + } + + // trim url whitespace and add a trailing slash if needed + function cleanUrl (url) { + // trim leading and trailing spaces, but not spaces inside the url + url = L.Util.trim(url); + + // add a trailing slash to the url if the user omitted it + if (url[url.length - 1] !== '/') { + url += '/'; + } + + return url; + } + + function isArcgisOnline (url) { + /* hosted feature services can emit geojson natively. + our check for 'geojson' support will need to be revisted + once the functionality makes its way to ArcGIS Server*/ + return (/\.arcgis\.com.*?FeatureServer/g).test(url); + } + + function geojsonTypeToArcGIS (geoJsonType) { + var arcgisGeometryType; + switch (geoJsonType) { + case 'Point': + arcgisGeometryType = 'esriGeometryPoint'; + break; + case 'MultiPoint': + arcgisGeometryType = 'esriGeometryMultipoint'; + break; + case 'LineString': + arcgisGeometryType = 'esriGeometryPolyline'; + break; + case 'MultiLineString': + arcgisGeometryType = 'esriGeometryPolyline'; + break; + case 'Polygon': + arcgisGeometryType = 'esriGeometryPolygon'; + break; + case 'MultiPolygon': + arcgisGeometryType = 'esriGeometryPolygon'; + break; + } + + return arcgisGeometryType; + } + + function warn () { + if (console && console.warn) { + console.warn.apply(console, arguments); + } + } + + var Util = { + shallowClone: shallowClone, + warn: warn, + cleanUrl: cleanUrl, + isArcgisOnline: isArcgisOnline, + geojsonTypeToArcGIS: geojsonTypeToArcGIS, + responseToFeatureCollection: responseToFeatureCollection, + geojsonToArcGIS: geojsonToArcGIS, + arcgisToGeoJSON: arcgisToGeoJSON, + boundsToExtent: boundsToExtent, + extentToBounds: extentToBounds + }; + + var callbacks = 0; + + function serialize (params) { + var data = ''; + + params.f = params.f || 'json'; + + for (var key in params) { + if (params.hasOwnProperty(key)) { + var param = params[key]; + var type = Object.prototype.toString.call(param); + var value; + + if (data.length) { + data += '&'; + } + + if (type === '[object Array]') { + value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(','); + } else if (type === '[object Object]') { + value = JSON.stringify(param); + } else if (type === '[object Date]') { + value = param.valueOf(); + } else { + value = param; + } + + data += encodeURIComponent(key) + '=' + encodeURIComponent(value); + } + } + + return data; + } + + function createRequest (callback, context) { + var httpRequest = new window.XMLHttpRequest(); + + httpRequest.onerror = function (e) { + httpRequest.onreadystatechange = L.Util.falseFn; + + callback.call(context, { + error: { + code: 500, + message: 'XMLHttpRequest error' + } + }, null); + }; + + httpRequest.onreadystatechange = function () { + var response; + var error; + + if (httpRequest.readyState === 4) { + try { + response = JSON.parse(httpRequest.responseText); + } catch (e) { + response = null; + error = { + code: 500, + message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.' + }; + } + + if (!error && response.error) { + error = response.error; + response = null; + } + + httpRequest.onerror = L.Util.falseFn; + + callback.call(context, error, response); + } + }; + + httpRequest.ontimeout = function () { + this.onerror(); + }; + + return httpRequest; + } + + function xmlHttpPost (url, params, callback, context) { + var httpRequest = createRequest(callback, context); + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + + httpRequest.open('POST', url); + httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpRequest.send(serialize(params)); + + return httpRequest; + } + + function xmlHttpGet (url, params, callback, context) { + var httpRequest = createRequest(callback, context); + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + + httpRequest.open('GET', url + '?' + serialize(params), true); + httpRequest.send(null); + + return httpRequest; + } + + // AJAX handlers for CORS (modern browsers) or JSONP (older browsers) + function request (url, params, callback, context) { + var paramString = serialize(params); + var httpRequest = createRequest(callback, context); + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + + var requestLength = (url + '?' + paramString).length; + + // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest + if (requestLength <= 2000 && Support.cors) { + httpRequest.open('GET', url + '?' + paramString); + httpRequest.send(null); + + // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest + } else if (requestLength > 2000 && Support.cors) { + httpRequest.open('POST', url); + httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpRequest.send(paramString); + + // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request + } else if (requestLength <= 2000 && !Support.cors) { + return jsonp(url, params, callback, context); + + // request is longer then 2000 characters and the browser does not support CORS, log a warning + } else { + warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html'); + return; + } + + return httpRequest; + } + + function jsonp (url, params, callback, context) { + window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {}; + var callbackId = 'c' + callbacks; + + params.callback = 'window._EsriLeafletCallbacks.' + callbackId; + + var script = L.DomUtil.create('script', null, document.body); + script.type = 'text/javascript'; + script.src = url + '?' + serialize(params); + script.id = callbackId; + + window._EsriLeafletCallbacks[callbackId] = function (response) { + if (window._EsriLeafletCallbacks[callbackId] !== true) { + var error; + var responseType = Object.prototype.toString.call(response); + + if (!(responseType === '[object Object]' || responseType === '[object Array]')) { + error = { + error: { + code: 500, + message: 'Expected array or object as JSONP response' + } + }; + response = null; + } + + if (!error && response.error) { + error = response; + response = null; + } + + callback.call(context, error, response); + window._EsriLeafletCallbacks[callbackId] = true; + } + }; + + callbacks++; + + return { + id: callbackId, + url: script.src, + abort: function () { + window._EsriLeafletCallbacks._callback[callbackId]({ + code: 0, + message: 'Request aborted.' + }); + } + }; + } + + var get = ((Support.cors) ? xmlHttpGet : jsonp); + get.CORS = xmlHttpGet; + get.JSONP = jsonp; + + // export the Request object to call the different handlers for debugging + var Request = { + request: request, + get: get, + post: xmlHttpPost + }; + + var Task = L.Class.extend({ + + options: { + proxy: false, + useCors: cors + }, + + // Generate a method for each methodName:paramName in the setters for this task. + generateSetter: function (param, context) { + return L.Util.bind(function (value) { + this.params[param] = value; + return this; + }, context); + }, + + initialize: function (endpoint) { + // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service + if (endpoint.request && endpoint.options) { + this._service = endpoint; + L.Util.setOptions(this, endpoint.options); + } else { + L.Util.setOptions(this, endpoint); + this.options.url = cleanUrl(endpoint.url); + } + + // clone default params into this object + this.params = L.Util.extend({}, this.params || {}); + + // generate setter methods based on the setters object implimented a child class + if (this.setters) { + for (var setter in this.setters) { + var param = this.setters[setter]; + this[setter] = this.generateSetter(param, this); + } + } + }, + + token: function (token) { + if (this._service) { + this._service.authenticate(token); + } else { + this.params.token = token; + } + return this; + }, + + request: function (callback, context) { + if (this._service) { + return this._service.request(this.path, this.params, callback, context); + } + + return this._request('request', this.path, this.params, callback, context); + }, + + _request: function (method, path, params, callback, context) { + var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path; + + if ((method === 'get' || method === 'request') && !this.options.useCors) { + return Request.get.JSONP(url, params, callback, context); + } + + return Request[method](url, params, callback, context); + } + }); + + function task (options) { + return new Task(options); + } + + var Query = Task.extend({ + setters: { + 'offset': 'offset', + 'limit': 'limit', + 'fields': 'outFields', + 'precision': 'geometryPrecision', + 'featureIds': 'objectIds', + 'returnGeometry': 'returnGeometry', + 'token': 'token' + }, + + path: 'query', + + params: { + returnGeometry: true, + where: '1=1', + outSr: 4326, + outFields: '*' + }, + + within: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer + return this; + }, + + intersects: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelIntersects'; + return this; + }, + + contains: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer + return this; + }, + + crosses: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelCrosses'; + return this; + }, + + touches: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelTouches'; + return this; + }, + + overlaps: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelOverlaps'; + return this; + }, + + // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online + nearby: function (latlng, radius) { + latlng = L.latLng(latlng); + this.params.geometry = [latlng.lng, latlng.lat]; + this.params.geometryType = 'esriGeometryPoint'; + this.params.spatialRel = 'esriSpatialRelIntersects'; + this.params.units = 'esriSRUnit_Meter'; + this.params.distance = radius; + this.params.inSr = 4326; + return this; + }, + + where: function (string) { + // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered + this.params.where = string; + return this; + }, + + between: function (start, end) { + this.params.time = [start.valueOf(), end.valueOf()]; + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor; + return this; + }, + + orderBy: function (fieldName, order) { + order = order || 'ASC'; + this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : ''; + this.params.orderByFields += ([fieldName, order]).join(' '); + return this; + }, + + run: function (callback, context) { + this._cleanParams(); + + // if the service is hosted on arcgis online request geojson directly + if (Util.isArcgisOnline(this.options.url)) { + this.params.f = 'geojson'; + + return this.request(function (error, response) { + this._trapSQLerrors(error); + callback.call(context, error, response, response); + }, this); + + // otherwise convert it in the callback then pass it on + } else { + return this.request(function (error, response) { + this._trapSQLerrors(error); + callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response); + }, this); + } + }, + + count: function (callback, context) { + this._cleanParams(); + this.params.returnCountOnly = true; + return this.request(function (error, response) { + callback.call(this, error, (response && response.count), response); + }, context); + }, + + ids: function (callback, context) { + this._cleanParams(); + this.params.returnIdsOnly = true; + return this.request(function (error, response) { + callback.call(this, error, (response && response.objectIds), response); + }, context); + }, + + // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online + bounds: function (callback, context) { + this._cleanParams(); + this.params.returnExtentOnly = true; + return this.request(function (error, response) { + callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response); + }, context); + }, + + // only valid for image services + pixelSize: function (point) { + point = L.point(point); + this.params.pixelSize = [point.x, point.y]; + return this; + }, + + // only valid for map services + layer: function (layer) { + this.path = layer + '/query'; + return this; + }, + + _trapSQLerrors: function (error) { + if (error) { + if (error.code === '400') { + Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes'); + } + } + }, + + _cleanParams: function () { + delete this.params.returnIdsOnly; + delete this.params.returnExtentOnly; + delete this.params.returnCountOnly; + }, + + _setGeometry: function (geometry) { + this.params.inSr = 4326; + + // convert bounds to extent and finish + if (geometry instanceof L.LatLngBounds) { + // set geometry + geometryType + this.params.geometry = Util.boundsToExtent(geometry); + this.params.geometryType = 'esriGeometryEnvelope'; + return; + } + + // convert L.Marker > L.LatLng + if (geometry.getLatLng) { + geometry = geometry.getLatLng(); + } + + // convert L.LatLng to a geojson point and continue; + if (geometry instanceof L.LatLng) { + geometry = { + type: 'Point', + coordinates: [geometry.lng, geometry.lat] + }; + } + + // handle L.GeoJSON, pull out the first geometry + if (geometry instanceof L.GeoJSON) { + // reassign geometry to the GeoJSON value (we are assuming that only one feature is present) + geometry = geometry.getLayers()[0].feature.geometry; + this.params.geometry = Util.geojsonToArcGIS(geometry); + this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + } + + // Handle L.Polyline and L.Polygon + if (geometry.toGeoJSON) { + geometry = geometry.toGeoJSON(); + } + + // handle GeoJSON feature by pulling out the geometry + if (geometry.type === 'Feature') { + // get the geometry of the geojson feature + geometry = geometry.geometry; + } + + // confirm that our GeoJSON is a point, line or polygon + if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') { + this.params.geometry = Util.geojsonToArcGIS(geometry); + this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + return; + } + + // warn the user if we havn't found a + /* global console */ + Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object'); + + return; + } + }); + + function query (options) { + return new Query(options); + } + + var Find = Task.extend({ + setters: { + // method name > param name + 'contains': 'contains', + 'text': 'searchText', + 'fields': 'searchFields', // denote an array or single string + 'spatialReference': 'sr', + 'sr': 'sr', + 'layers': 'layers', + 'returnGeometry': 'returnGeometry', + 'maxAllowableOffset': 'maxAllowableOffset', + 'precision': 'geometryPrecision', + 'dynamicLayers': 'dynamicLayers', + 'returnZ': 'returnZ', + 'returnM': 'returnM', + 'gdbVersion': 'gdbVersion', + 'token': 'token' + }, + + path: 'find', + + params: { + sr: 4326, + contains: true, + returnGeometry: true, + returnZ: true, + returnM: false + }, + + layerDefs: function (id, where) { + this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : ''; + this.params.layerDefs += ([id, where]).join(':'); + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor; + return this; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response); + }, context); + } + }); + + function find (options) { + return new Find(options); + } + + var Identify = Task.extend({ + path: 'identify', + + between: function (start, end) { + this.params.time = [start.valueOf(), end.valueOf()]; + return this; + } + }); + + function identify (options) { + return new Identify(options); + } + + var IdentifyFeatures = Identify.extend({ + setters: { + 'layers': 'layers', + 'precision': 'geometryPrecision', + 'tolerance': 'tolerance', + 'returnGeometry': 'returnGeometry' + }, + + params: { + sr: 4326, + layers: 'all', + tolerance: 3, + returnGeometry: true + }, + + on: function (map) { + var extent = Util.boundsToExtent(map.getBounds()); + var size = map.getSize(); + this.params.imageDisplay = [size.x, size.y, 96]; + this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax]; + return this; + }, + + at: function (latlng) { + latlng = L.latLng(latlng); + this.params.geometry = [latlng.lng, latlng.lat]; + this.params.geometryType = 'esriGeometryPoint'; + return this; + }, + + layerDef: function (id, where) { + this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : ''; + this.params.layerDefs += ([id, where]).join(':'); + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor); + return this; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + // immediately invoke with an error + if (error) { + callback.call(context, error, undefined, response); + return; + + // ok no error lets just assume we have features... + } else { + var featureCollection = Util.responseToFeatureCollection(response); + response.results = response.results.reverse(); + for (var i = 0; i < featureCollection.features.length; i++) { + var feature = featureCollection.features[i]; + feature.layerId = response.results[i].layerId; + } + callback.call(context, undefined, featureCollection, response); + } + }); + } + }); + + function identifyFeatures (options) { + return new IdentifyFeatures(options); + } + + var IdentifyImage = Identify.extend({ + setters: { + 'setMosaicRule': 'mosaicRule', + 'setRenderingRule': 'renderingRule', + 'setPixelSize': 'pixelSize', + 'returnCatalogItems': 'returnCatalogItems', + 'returnGeometry': 'returnGeometry' + }, + + params: { + returnGeometry: false + }, + + at: function (latlng) { + latlng = L.latLng(latlng); + this.params.geometry = JSON.stringify({ + x: latlng.lng, + y: latlng.lat, + spatialReference: { + wkid: 4326 + } + }); + this.params.geometryType = 'esriGeometryPoint'; + return this; + }, + + getMosaicRule: function () { + return this.params.mosaicRule; + }, + + getRenderingRule: function () { + return this.params.renderingRule; + }, + + getPixelSize: function () { + return this.params.pixelSize; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + callback.call(context, error, (response && this._responseToGeoJSON(response)), response); + }, this); + }, + + // get pixel data and return as geoJSON point + // populate catalog items (if any) + // merging in any catalogItemVisibilities as a propery of each feature + _responseToGeoJSON: function (response) { + var location = response.location; + var catalogItems = response.catalogItems; + var catalogItemVisibilities = response.catalogItemVisibilities; + var geoJSON = { + 'pixel': { + 'type': 'Feature', + 'geometry': { + 'type': 'Point', + 'coordinates': [location.x, location.y] + }, + 'crs': { + 'type': 'EPSG', + 'properties': { + 'code': location.spatialReference.wkid + } + }, + 'properties': { + 'OBJECTID': response.objectId, + 'name': response.name, + 'value': response.value + }, + 'id': response.objectId + } + }; + + if (response.properties && response.properties.Values) { + geoJSON.pixel.properties.values = response.properties.Values; + } + + if (catalogItems && catalogItems.features) { + geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems); + if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) { + for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) { + geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i]; + } + } + } + return geoJSON; + } + + }); + + function identifyImage (params) { + return new IdentifyImage(params); + } + + var Service = L.Evented.extend({ + + options: { + proxy: false, + useCors: cors, + timeout: 0 + }, + + initialize: function (options) { + options = options || {}; + this._requestQueue = []; + this._authenticating = false; + L.Util.setOptions(this, options); + this.options.url = cleanUrl(this.options.url); + }, + + get: function (path, params, callback, context) { + return this._request('get', path, params, callback, context); + }, + + post: function (path, params, callback, context) { + return this._request('post', path, params, callback, context); + }, + + request: function (path, params, callback, context) { + return this._request('request', path, params, callback, context); + }, + + metadata: function (callback, context) { + return this._request('get', '', {}, callback, context); + }, + + authenticate: function (token) { + this._authenticating = false; + this.options.token = token; + this._runQueue(); + return this; + }, + + getTimeout: function () { + return this.options.timeout; + }, + + setTimeout: function (timeout) { + this.options.timeout = timeout; + }, + + _request: function (method, path, params, callback, context) { + this.fire('requeststart', { + url: this.options.url + path, + params: params, + method: method + }, true); + + var wrappedCallback = this._createServiceCallback(method, path, params, callback, context); + + if (this.options.token) { + params.token = this.options.token; + } + + if (this._authenticating) { + this._requestQueue.push([method, path, params, callback, context]); + return; + } else { + var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path; + + if ((method === 'get' || method === 'request') && !this.options.useCors) { + return Request.get.JSONP(url, params, wrappedCallback, context); + } else { + return Request[method](url, params, wrappedCallback, context); + } + } + }, + + _createServiceCallback: function (method, path, params, callback, context) { + return L.Util.bind(function (error, response) { + if (error && (error.code === 499 || error.code === 498)) { + this._authenticating = true; + + this._requestQueue.push([method, path, params, callback, context]); + + // fire an event for users to handle and re-authenticate + this.fire('authenticationrequired', { + authenticate: L.Util.bind(this.authenticate, this) + }, true); + + // if the user has access to a callback they can handle the auth error + error.authenticate = L.Util.bind(this.authenticate, this); + } + + callback.call(context, error, response); + + if (error) { + this.fire('requesterror', { + url: this.options.url + path, + params: params, + message: error.message, + code: error.code, + method: method + }, true); + } else { + this.fire('requestsuccess', { + url: this.options.url + path, + params: params, + response: response, + method: method + }, true); + } + + this.fire('requestend', { + url: this.options.url + path, + params: params, + method: method + }, true); + }, this); + }, + + _runQueue: function () { + for (var i = this._requestQueue.length - 1; i >= 0; i--) { + var request = this._requestQueue[i]; + var method = request.shift(); + this[method].apply(this, request); + } + this._requestQueue = []; + } + }); + + function service (options) { + return new Service(options); + } + + var MapService = Service.extend({ + + identify: function () { + return identifyFeatures(this); + }, + + find: function () { + return find(this); + }, + + query: function () { + return query(this); + } + + }); + + function mapService (options) { + return new MapService(options); + } + + var ImageService = Service.extend({ + + query: function () { + return query(this); + }, + + identify: function () { + return identifyImage(this); + } + }); + + function imageService (options) { + return new ImageService(options); + } + + var FeatureLayerService = Service.extend({ + + options: { + idAttribute: 'OBJECTID' + }, + + query: function () { + return query(this); + }, + + addFeature: function (feature, callback, context) { + delete feature.id; + + feature = geojsonToArcGIS(feature); + + return this.post('addFeatures', { + features: [feature] + }, function (error, response) { + var result = (response && response.addResults) ? response.addResults[0] : undefined; + if (callback) { + callback.call(context, error || response.addResults[0].error, result); + } + }, context); + }, + + updateFeature: function (feature, callback, context) { + feature = geojsonToArcGIS(feature, this.options.idAttribute); + + return this.post('updateFeatures', { + features: [feature] + }, function (error, response) { + var result = (response && response.updateResults) ? response.updateResults[0] : undefined; + if (callback) { + callback.call(context, error || response.updateResults[0].error, result); + } + }, context); + }, + + deleteFeature: function (id, callback, context) { + return this.post('deleteFeatures', { + objectIds: id + }, function (error, response) { + var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined; + if (callback) { + callback.call(context, error || response.deleteResults[0].error, result); + } + }, context); + }, + + deleteFeatures: function (ids, callback, context) { + return this.post('deleteFeatures', { + objectIds: ids + }, function (error, response) { + // pass back the entire array + var result = (response && response.deleteResults) ? response.deleteResults : undefined; + if (callback) { + callback.call(context, error || response.deleteResults[0].error, result); + } + }, context); + } + }); + + function featureLayerService (options) { + return new FeatureLayerService(options); + } + + var Logo = L.Control.extend({ + options: { + position: 'bottomright', + marginTop: 0, + marginLeft: 0, + marginBottom: 0, + marginRight: 0 + }, + + onAdd: function () { + var div = L.DomUtil.create('div', 'esri-leaflet-logo'); + div.style.marginTop = this.options.marginTop; + div.style.marginLeft = this.options.marginLeft; + div.style.marginBottom = this.options.marginBottom; + div.style.marginRight = this.options.marginRight; + div.innerHTML = 'Powered by Esri'; + + return div; + } + }); + + function logo (options) { + return new Logo(options); + } + + var tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:'; + + var BasemapLayer = L.TileLayer.extend({ + statics: { + TILES: { + Streets: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + Topographic: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + Oceans: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + OceansLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + NationalGeographic: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.' + } + }, + DarkGray: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors' + } + }, + DarkGrayLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + + } + }, + Gray: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors' + } + }, + GrayLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + Imagery: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community' + } + }, + ImageryLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + ImageryTransportation: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + ShadedRelief: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + attribution: 'Esri, USGS' + } + }, + ShadedReliefLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 12, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + Terrain: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + attribution: 'Esri, USGS, NOAA' + } + }, + TerrainLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + } + } + }, + initialize: function (key, options) { + var config; + + // set the config variable with the appropriate config object + if (typeof key === 'object' && key.urlTemplate && key.options) { + config = key; + } else if (typeof key === 'string' && BasemapLayer.TILES[key]) { + config = BasemapLayer.TILES[key]; + } else { + throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of "Streets", "Topographic", "Oceans", "OceansLabels", "NationalGeographic", "Gray", "GrayLabels", "DarkGray", "DarkGrayLabels", "Imagery", "ImageryLabels", "ImageryTransportation", "ShadedRelief", "ShadedReliefLabels", "Terrain" or "TerrainLabels"'); + } + + // merge passed options into the config options + var tileOptions = L.Util.extend(config.options, options); + + L.Util.setOptions(this, tileOptions); + + // call the initialize method on L.TileLayer to set everything up + L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions); + + // if this basemap requires dynamic attribution set it up + if (config.attributionUrl) { + this._getAttributionData(config.attributionUrl); + } + + this._logo = logo({ + position: this.options.logoPosition + }); + }, + + onAdd: function (map) { + if (!this.options.hideLogo && !map._hasEsriLogo) { + this._logo.addTo(map); + map._hasEsriLogo = true; + } + + if (this.options.pane === 'esri-labels') { + this._initPane(); + } + + map.on('moveend', this._updateMapAttribution, this); + + L.TileLayer.prototype.onAdd.call(this, map); + }, + + onRemove: function (map) { + // check to make sure the logo hasn't already been removed + if (this._logo && this._logo._container) { + map.removeControl(this._logo); + map._hasEsriLogo = false; + } + + map.off('moveend', this._updateMapAttribution, this); + + L.TileLayer.prototype.onRemove.call(this, map); + }, + + getAttribution: function () { + if (this.options.attribution) { + var attribution = '' + this.options.attribution + ''; + } + return attribution; + }, + + _initPane: function () { + if (!this._map.getPane(this.options.pane)) { + var pane = this._map.createPane(this.options.pane); + pane.style.pointerEvents = 'none'; + pane.style.zIndex = 500; + } + }, + + _getAttributionData: function (url) { + jsonp(url, {}, L.Util.bind(function (error, attributions) { + if (error) { return; } + this._attributions = []; + + for (var c = 0; c < attributions.contributors.length; c++) { + var contributor = attributions.contributors[c]; + for (var i = 0; i < contributor.coverageAreas.length; i++) { + var coverageArea = contributor.coverageAreas[i]; + var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]); + var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]); + this._attributions.push({ + attribution: contributor.attribution, + score: coverageArea.score, + bounds: L.latLngBounds(southWest, northEast), + minZoom: coverageArea.zoomMin, + maxZoom: coverageArea.zoomMax + }); + } + } + + this._attributions.sort(function (a, b) { + return b.score - a.score; + }); + + this._updateMapAttribution(); + }, this)); + }, + + _updateMapAttribution: function () { + if (this._map && this._map.attributionControl && this._attributions) { + var newAttributions = ''; + var bounds = this._map.getBounds(); + var zoom = this._map.getZoom(); + + for (var i = 0; i < this._attributions.length; i++) { + var attribution = this._attributions[i]; + var text = attribution.attribution; + if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) { + newAttributions += (', ' + text); + } + } + newAttributions = newAttributions.substr(2); + var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions'); + + attributionElement.innerHTML = newAttributions; + attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px'; + + this.fire('attributionupdated', { + attribution: newAttributions + }); + } + } + }); + + function basemapLayer (key, options) { + return new BasemapLayer(key, options); + } + + var TiledMapLayer = L.TileLayer.extend({ + options: { + zoomOffsetAllowance: 0.1 + }, + + statics: { + MercatorZoomLevels: { + '0': 156543.03392799999, + '1': 78271.516963999893, + '2': 39135.758482000099, + '3': 19567.879240999901, + '4': 9783.9396204999593, + '5': 4891.9698102499797, + '6': 2445.9849051249898, + '7': 1222.9924525624899, + '8': 611.49622628138002, + '9': 305.74811314055802, + '10': 152.874056570411, + '11': 76.437028285073197, + '12': 38.218514142536598, + '13': 19.109257071268299, + '14': 9.5546285356341496, + '15': 4.7773142679493699, + '16': 2.38865713397468, + '17': 1.1943285668550501, + '18': 0.59716428355981699, + '19': 0.29858214164761698, + '20': 0.14929107082381, + '21': 0.07464553541191, + '22': 0.0373227677059525, + '23': 0.0186613838529763 + } + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + options = L.Util.setOptions(this, options); + + // set the urls + this.tileUrl = options.url + 'tile/{z}/{y}/{x}'; + this.service = mapService(options); + this.service.addEventParent(this); + + var arcgisonline = new RegExp(/tiles.arcgis(online)?\.com/g); + if (arcgisonline.test(options.url)) { + this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}'); + options.subdomains = ['1', '2', '3', '4']; + } + + if (this.options.token) { + this.tileUrl += ('?token=' + this.options.token); + } + + // init layer by calling TileLayers initialize method + L.TileLayer.prototype.initialize.call(this, this.tileUrl, options); + }, + + getTileUrl: function (tilePoint) { + return L.Util.template(this.tileUrl, L.extend({ + s: this._getSubdomain(tilePoint), + z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level + x: tilePoint.x, + y: tilePoint.y + }, this.options)); + }, + + createTile: function (coords, done) { + var tile = document.createElement('img'); + + L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile)); + L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile)); + + if (this.options.crossOrigin) { + tile.crossOrigin = ''; + } + + /* + Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons + http://www.w3.org/TR/WCAG20-TECHS/H67 + */ + tile.alt = ''; + + // if there is no lod map or an lod map with a proper zoom load the tile + // otherwise wait for the lod map to become available + if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) { + tile.src = this.getTileUrl(coords); + } else { + this.once('lodmap', function () { + tile.src = this.getTileUrl(coords); + }, this); + } + + return tile; + }, + + onAdd: function (map) { + if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) { + this._lodMap = {}; + this.metadata(function (error, metadata) { + if (!error) { + var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid; + if (sr === 102100 || sr === 3857) { + // create the zoom level data + var arcgisLODs = metadata.tileInfo.lods; + var correctResolutions = TiledMapLayer.MercatorZoomLevels; + + for (var i = 0; i < arcgisLODs.length; i++) { + var arcgisLOD = arcgisLODs[i]; + for (var ci in correctResolutions) { + var correctRes = correctResolutions[ci]; + + if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) { + this._lodMap[ci] = arcgisLOD.level; + break; + } + } + } + + this.fire('lodmap'); + } else { + warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html'); + } + } + }, this); + } + + L.TileLayer.prototype.onAdd.call(this, map); + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + identify: function () { + return this.service.identify(); + }, + + find: function () { + return this.service.find(); + }, + + query: function () { + return this.service.query(); + }, + + authenticate: function (token) { + var tokenQs = '?token=' + token; + this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs; + this.options.token = token; + this.service.authenticate(token); + return this; + }, + + _withinPercentage: function (a, b, percentage) { + var diff = Math.abs((a / b) - 1); + return diff < percentage; + } + }); + + function tiledMapLayer (url, options) { + return new TiledMapLayer(url, options); + } + + var Overlay = L.ImageOverlay.extend({ + onAdd: function (map) { + this._topLeft = map.getPixelBounds().min; + L.ImageOverlay.prototype.onAdd.call(this, map); + }, + _reset: function () { + if (this._map.options.crs === L.CRS.EPSG3857) { + L.ImageOverlay.prototype._reset.call(this); + } else { + L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin())); + } + } + }); + + var RasterLayer = L.Layer.extend({ + + options: { + opacity: 1, + position: 'front', + f: 'image', + useCors: cors, + attribution: null, + interactive: false, + alt: '' + }, + + onAdd: function (map) { + this._update = L.Util.throttle(this._update, this.options.updateInterval, this); + + map.on('moveend', this._update, this); + + // if we had an image loaded and it matches the + // current bounds show the image otherwise remove it + if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) { + map.addLayer(this._currentImage); + } else if (this._currentImage) { + this._map.removeLayer(this._currentImage); + this._currentImage = null; + } + + this._update(); + + if (this._popup) { + this._map.on('click', this._getPopupData, this); + this._map.on('dblclick', this._resetPopupState, this); + } + }, + + onRemove: function (map) { + if (this._currentImage) { + this._map.removeLayer(this._currentImage); + } + + if (this._popup) { + this._map.off('click', this._getPopupData, this); + this._map.off('dblclick', this._resetPopupState, this); + } + + this._map.off('moveend', this._update, this); + }, + + bindPopup: function (fn, popupOptions) { + this._shouldRenderPopup = false; + this._lastClick = false; + this._popup = L.popup(popupOptions); + this._popupFunction = fn; + if (this._map) { + this._map.on('click', this._getPopupData, this); + this._map.on('dblclick', this._resetPopupState, this); + } + return this; + }, + + unbindPopup: function () { + if (this._map) { + this._map.closePopup(this._popup); + this._map.off('click', this._getPopupData, this); + this._map.off('dblclick', this._resetPopupState, this); + } + this._popup = false; + return this; + }, + + bringToFront: function () { + this.options.position = 'front'; + if (this._currentImage) { + this._currentImage.bringToFront(); + } + return this; + }, + + bringToBack: function () { + this.options.position = 'back'; + if (this._currentImage) { + this._currentImage.bringToBack(); + } + return this; + }, + + getAttribution: function () { + return this.options.attribution; + }, + + getOpacity: function () { + return this.options.opacity; + }, + + setOpacity: function (opacity) { + this.options.opacity = opacity; + this._currentImage.setOpacity(opacity); + return this; + }, + + getTimeRange: function () { + return [this.options.from, this.options.to]; + }, + + setTimeRange: function (from, to) { + this.options.from = from; + this.options.to = to; + this._update(); + return this; + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + authenticate: function (token) { + this.service.authenticate(token); + return this; + }, + + _renderImage: function (url, bounds) { + if (this._map) { + // create a new image overlay and add it to the map + // to start loading the image + // opacity is 0 while the image is loading + var image = new Overlay(url, bounds, { + opacity: 0, + crossOrigin: this.options.useCors, + alt: this.options.alt, + pane: this.options.pane || this.getPane(), + interactive: this.options.interactive + }).addTo(this._map); + + // once the image loads + image.once('load', function (e) { + if (this._map) { + var newImage = e.target; + var oldImage = this._currentImage; + + // if the bounds of this image matches the bounds that + // _renderImage was called with and we have a map with the same bounds + // hide the old image if there is one and set the opacity + // of the new image otherwise remove the new image + if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) { + this._currentImage = newImage; + + if (this.options.position === 'front') { + this.bringToFront(); + } else { + this.bringToBack(); + } + + if (this._map && this._currentImage._map) { + this._currentImage.setOpacity(this.options.opacity); + } else { + this._currentImage._map.removeLayer(this._currentImage); + } + + if (oldImage && this._map) { + this._map.removeLayer(oldImage); + } + + if (oldImage && oldImage._map) { + oldImage._map.removeLayer(oldImage); + } + } else { + this._map.removeLayer(newImage); + } + } + + this.fire('load', { + bounds: bounds + }); + }, this); + + this.fire('loading', { + bounds: bounds + }); + } + }, + + _update: function () { + if (!this._map) { + return; + } + + var zoom = this._map.getZoom(); + var bounds = this._map.getBounds(); + + if (this._animatingZoom) { + return; + } + + if (this._map._panTransition && this._map._panTransition._inProgress) { + return; + } + + if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { + this._currentImage._map.removeLayer(this._currentImage); + return; + } + + var params = this._buildExportParams(); + + this._requestExport(params, bounds); + }, + + _renderPopup: function (latlng, error, results, response) { + latlng = L.latLng(latlng); + if (this._shouldRenderPopup && this._lastClick.equals(latlng)) { + // add the popup to the map where the mouse was clicked at + var content = this._popupFunction(error, results, response); + if (content) { + this._popup.setLatLng(latlng).setContent(content).openOn(this._map); + } + } + }, + + _resetPopupState: function (e) { + this._shouldRenderPopup = false; + this._lastClick = e.latlng; + } + }); + + var ImageMapLayer = RasterLayer.extend({ + + options: { + updateInterval: 150, + format: 'jpgpng', + transparent: true, + f: 'json' + }, + + query: function () { + return this.service.query(); + }, + + identify: function () { + return this.service.identify(); + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + this.service = imageService(options); + this.service.addEventParent(this); + + L.Util.setOptions(this, options); + }, + + setPixelType: function (pixelType) { + this.options.pixelType = pixelType; + this._update(); + return this; + }, + + getPixelType: function () { + return this.options.pixelType; + }, + + setBandIds: function (bandIds) { + if (L.Util.isArray(bandIds)) { + this.options.bandIds = bandIds.join(','); + } else { + this.options.bandIds = bandIds.toString(); + } + this._update(); + return this; + }, + + getBandIds: function () { + return this.options.bandIds; + }, + + setNoData: function (noData, noDataInterpretation) { + if (L.Util.isArray(noData)) { + this.options.noData = noData.join(','); + } else { + this.options.noData = noData.toString(); + } + if (noDataInterpretation) { + this.options.noDataInterpretation = noDataInterpretation; + } + this._update(); + return this; + }, + + getNoData: function () { + return this.options.noData; + }, + + getNoDataInterpretation: function () { + return this.options.noDataInterpretation; + }, + + setRenderingRule: function (renderingRule) { + this.options.renderingRule = renderingRule; + this._update(); + }, + + getRenderingRule: function () { + return this.options.renderingRule; + }, + + setMosaicRule: function (mosaicRule) { + this.options.mosaicRule = mosaicRule; + this._update(); + }, + + getMosaicRule: function () { + return this.options.mosaicRule; + }, + + _getPopupData: function (e) { + var callback = L.Util.bind(function (error, results, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + setTimeout(L.Util.bind(function () { + this._renderPopup(e.latlng, error, results, response); + }, this), 300); + }, this); + + var identifyRequest = this.identify().at(e.latlng); + + // set mosaic rule for identify task if it is set for layer + if (this.options.mosaicRule) { + identifyRequest.setMosaicRule(this.options.mosaicRule); + // @TODO: force return catalog items too? + } + + // @TODO: set rendering rule? Not sure, + // sometimes you want raw pixel values + // if (this.options.renderingRule) { + // identifyRequest.setRenderingRule(this.options.renderingRule); + // } + + identifyRequest.run(callback); + + // set the flags to show the popup + this._shouldRenderPopup = true; + this._lastClick = e.latlng; + }, + + _buildExportParams: function () { + var bounds = this._map.getBounds(); + var size = this._map.getSize(); + var ne = this._map.options.crs.project(bounds._northEast); + var sw = this._map.options.crs.project(bounds._southWest); + var sr = parseInt(this._map.options.crs.code.split(':')[1], 10); + + var params = { + bbox: [sw.x, sw.y, ne.x, ne.y].join(','), + size: size.x + ',' + size.y, + format: this.options.format, + transparent: this.options.transparent, + bboxSR: sr, + imageSR: sr + }; + + if (this.options.from && this.options.to) { + params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf(); + } + + if (this.options.pixelType) { + params.pixelType = this.options.pixelType; + } + + if (this.options.interpolation) { + params.interpolation = this.options.interpolation; + } + + if (this.options.compressionQuality) { + params.compressionQuality = this.options.compressionQuality; + } + + if (this.options.bandIds) { + params.bandIds = this.options.bandIds; + } + + if (this.options.noData) { + params.noData = this.options.noData; + } + + if (this.options.noDataInterpretation) { + params.noDataInterpretation = this.options.noDataInterpretation; + } + + if (this.service.options.token) { + params.token = this.service.options.token; + } + + if (this.options.renderingRule) { + params.renderingRule = JSON.stringify(this.options.renderingRule); + } + + if (this.options.mosaicRule) { + params.mosaicRule = JSON.stringify(this.options.mosaicRule); + } + + return params; + }, + + _requestExport: function (params, bounds) { + if (this.options.f === 'json') { + this.service.request('exportImage', params, function (error, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + this._renderImage(response.href, bounds); + }, this); + } else { + params.f = 'image'; + this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds); + } + } + }); + + function imageMapLayer (url, options) { + return new ImageMapLayer(url, options); + } + + var DynamicMapLayer = RasterLayer.extend({ + + options: { + updateInterval: 150, + layers: false, + layerDefs: false, + timeOptions: false, + format: 'png24', + transparent: true, + f: 'json' + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + this.service = mapService(options); + this.service.addEventParent(this); + + if ((options.proxy || options.token) && options.f !== 'json') { + options.f = 'json'; + } + L.Util.setOptions(this, options); + }, + + getDynamicLayers: function () { + return this.options.dynamicLayers; + }, + + setDynamicLayers: function (dynamicLayers) { + this.options.dynamicLayers = dynamicLayers; + this._update(); + return this; + }, + + getLayers: function () { + return this.options.layers; + }, + + setLayers: function (layers) { + this.options.layers = layers; + this._update(); + return this; + }, + + getLayerDefs: function () { + return this.options.layerDefs; + }, + + setLayerDefs: function (layerDefs) { + this.options.layerDefs = layerDefs; + this._update(); + return this; + }, + + getTimeOptions: function () { + return this.options.timeOptions; + }, + + setTimeOptions: function (timeOptions) { + this.options.timeOptions = timeOptions; + this._update(); + return this; + }, + + query: function () { + return this.service.query(); + }, + + identify: function () { + return this.service.identify(); + }, + + find: function () { + return this.service.find(); + }, + + _getPopupData: function (e) { + var callback = L.Util.bind(function (error, featureCollection, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + setTimeout(L.Util.bind(function () { + this._renderPopup(e.latlng, error, featureCollection, response); + }, this), 300); + }, this); + + var identifyRequest = this.identify().on(this._map).at(e.latlng); + + if (this.options.layers) { + identifyRequest.layers('visible:' + this.options.layers.join(',')); + } else { + identifyRequest.layers('visible'); + } + + identifyRequest.run(callback); + + // set the flags to show the popup + this._shouldRenderPopup = true; + this._lastClick = e.latlng; + }, + + _buildExportParams: function () { + var bounds = this._map.getBounds(); + var size = this._map.getSize(); + var ne = this._map.options.crs.project(bounds.getNorthEast()); + var sw = this._map.options.crs.project(bounds.getSouthWest()); + var sr = parseInt(this._map.options.crs.code.split(':')[1], 10); + + // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying + var top = this._map.latLngToLayerPoint(bounds._northEast); + var bottom = this._map.latLngToLayerPoint(bounds._southWest); + + if (top.y > 0 || bottom.y < size.y) { + size.y = bottom.y - top.y; + } + + var params = { + bbox: [sw.x, sw.y, ne.x, ne.y].join(','), + size: size.x + ',' + size.y, + dpi: 96, + format: this.options.format, + transparent: this.options.transparent, + bboxSR: sr, + imageSR: sr + }; + + if (this.options.dynamicLayers) { + params.dynamicLayers = this.options.dynamicLayers; + } + + if (this.options.layers) { + params.layers = 'show:' + this.options.layers.join(','); + } + + if (this.options.layerDefs) { + params.layerDefs = JSON.stringify(this.options.layerDefs); + } + + if (this.options.timeOptions) { + params.timeOptions = JSON.stringify(this.options.timeOptions); + } + + if (this.options.from && this.options.to) { + params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf(); + } + + if (this.service.options.token) { + params.token = this.service.options.token; + } + + return params; + }, + + _requestExport: function (params, bounds) { + if (this.options.f === 'json') { + this.service.request('export', params, function (error, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + this._renderImage(response.href, bounds); + }, this); + } else { + params.f = 'image'; + this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds); + } + } + }); + + function dynamicMapLayer (url, options) { + return new DynamicMapLayer(url, options); + } + + var VirtualGrid = L.Layer.extend({ + + options: { + cellSize: 512, + updateInterval: 150 + }, + + initialize: function (options) { + options = L.setOptions(this, options); + this._ok = true; + }, + + onAdd: function (map) { + this._map = map; + this._update = L.Util.throttle(this._update, this.options.updateInterval, this); + this._reset(); + this._update(); + }, + + onRemove: function () { + this._map.removeEventListener(this.getEvents(), this); + this._removeCells(); + }, + + getEvents: function () { + var events = { + moveend: this._update, + movestart: this._start, + zoomend: this._reset + }; + + return events; + }, + + addTo: function (map) { + map.addLayer(this); + return this; + }, + + removeFrom: function (map) { + map.removeLayer(this); + return this; + }, + + _start: function () { + this._ok = true; + }, + + _reset: function () { + if (!this._ok) { + return; + } + + this._removeCells(); + + this._cells = {}; + this._activeCells = {}; + this._cellsToLoad = 0; + this._cellsTotal = 0; + this._cellNumBounds = this._getCellNumBounds(); + + this._resetWrap(); + this._zooming = false; + }, + + _resetWrap: function () { + var map = this._map; + var crs = map.options.crs; + + if (crs.infinite) { return; } + + var cellSize = this._getCellSize(); + + if (crs.wrapLng) { + this._wrapLng = [ + Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize), + Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize) + ]; + } + + if (crs.wrapLat) { + this._wrapLat = [ + Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize), + Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize) + ]; + } + }, + + _getCellSize: function () { + return this.options.cellSize; + }, + + _update: function () { + if (!this._ok) { + return; + } + + if (!this._map) { + return; + } + + var bounds = this._map.getPixelBounds(); + var cellSize = this._getCellSize(); + + // cell coordinates range for the current view + var cellBounds = L.bounds( + bounds.min.divideBy(cellSize).floor(), + bounds.max.divideBy(cellSize).floor()); + + this._removeOtherCells(cellBounds); + this._addCells(cellBounds); + + this.fire('cellsupdated'); + + this._ok = false; + }, + + _addCells: function (bounds) { + var queue = []; + var center = bounds.getCenter(); + var zoom = this._map.getZoom(); + + var j, i, coords; + // create a queue of coordinates to load cells from + for (j = bounds.min.y; j <= bounds.max.y; j++) { + for (i = bounds.min.x; i <= bounds.max.x; i++) { + coords = L.point(i, j); + coords.z = zoom; + + if (this._isValidCell(coords)) { + queue.push(coords); + } + } + } + + var cellsToLoad = queue.length; + + if (cellsToLoad === 0) { return; } + + this._cellsToLoad += cellsToLoad; + this._cellsTotal += cellsToLoad; + + // sort cell queue to load cells in order of their distance to center + queue.sort(function (a, b) { + return a.distanceTo(center) - b.distanceTo(center); + }); + + for (i = 0; i < cellsToLoad; i++) { + this._addCell(queue[i]); + } + }, + + _isValidCell: function (coords) { + var crs = this._map.options.crs; + + if (!crs.infinite) { + // don't load cell if it's out of bounds and not wrapped + var bounds = this._cellNumBounds; + if ( + (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) || + (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y)) + ) { + return false; + } + } + + if (!this.options.bounds) { + return true; + } + + // don't load cell if it doesn't intersect the bounds in options + var cellBounds = this._cellCoordsToBounds(coords); + return L.latLngBounds(this.options.bounds).intersects(cellBounds); + }, + + // converts cell coordinates to its geographical bounds + _cellCoordsToBounds: function (coords) { + var map = this._map; + var cellSize = this.options.cellSize; + var nwPoint = coords.multiplyBy(cellSize); + var sePoint = nwPoint.add([cellSize, cellSize]); + var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z)); + var se = map.wrapLatLng(map.unproject(sePoint, coords.z)); + + return L.latLngBounds(nw, se); + }, + + // converts cell coordinates to key for the cell cache + _cellCoordsToKey: function (coords) { + return coords.x + ':' + coords.y; + }, + + // converts cell cache key to coordiantes + _keyToCellCoords: function (key) { + var kArr = key.split(':'); + var x = parseInt(kArr[0], 10); + var y = parseInt(kArr[1], 10); + + return L.point(x, y); + }, + + // remove any present cells that are off the specified bounds + _removeOtherCells: function (bounds) { + for (var key in this._cells) { + if (!bounds.contains(this._keyToCellCoords(key))) { + this._removeCell(key); + } + } + }, + + _removeCell: function (key) { + var cell = this._activeCells[key]; + + if (cell) { + delete this._activeCells[key]; + + if (this.cellLeave) { + this.cellLeave(cell.bounds, cell.coords); + } + + this.fire('cellleave', { + bounds: cell.bounds, + coords: cell.coords + }); + } + }, + + _removeCells: function () { + for (var key in this._cells) { + var bounds = this._cells[key].bounds; + var coords = this._cells[key].coords; + + if (this.cellLeave) { + this.cellLeave(bounds, coords); + } + + this.fire('cellleave', { + bounds: bounds, + coords: coords + }); + } + }, + + _addCell: function (coords) { + // wrap cell coords if necessary (depending on CRS) + this._wrapCoords(coords); + + // generate the cell key + var key = this._cellCoordsToKey(coords); + + // get the cell from the cache + var cell = this._cells[key]; + // if this cell should be shown as isnt active yet (enter) + + if (cell && !this._activeCells[key]) { + if (this.cellEnter) { + this.cellEnter(cell.bounds, coords); + } + + this.fire('cellenter', { + bounds: cell.bounds, + coords: coords + }); + + this._activeCells[key] = cell; + } + + // if we dont have this cell in the cache yet (create) + if (!cell) { + cell = { + coords: coords, + bounds: this._cellCoordsToBounds(coords) + }; + + this._cells[key] = cell; + this._activeCells[key] = cell; + + if (this.createCell) { + this.createCell(cell.bounds, coords); + } + + this.fire('cellcreate', { + bounds: cell.bounds, + coords: coords + }); + } + }, + + _wrapCoords: function (coords) { + coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x; + coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y; + }, + + // get the global cell coordinates range for the current zoom + _getCellNumBounds: function () { + var bounds = this._map.getPixelWorldBounds(); + var size = this._getCellSize(); + + return bounds ? L.bounds( + bounds.min.divideBy(size).floor(), + bounds.max.divideBy(size).ceil().subtract([1, 1])) : null; + } + }); + + function BinarySearchIndex (values) { + this.values = [].concat(values || []); + } + + BinarySearchIndex.prototype.query = function (value) { + var index = this.getIndex(value); + return this.values[index]; + }; + + BinarySearchIndex.prototype.getIndex = function getIndex (value) { + if (this.dirty) { + this.sort(); + } + + var minIndex = 0; + var maxIndex = this.values.length - 1; + var currentIndex; + var currentElement; + + while (minIndex <= maxIndex) { + currentIndex = (minIndex + maxIndex) / 2 | 0; + currentElement = this.values[Math.round(currentIndex)]; + if (+currentElement.value < +value) { + minIndex = currentIndex + 1; + } else if (+currentElement.value > +value) { + maxIndex = currentIndex - 1; + } else { + return currentIndex; + } + } + + return Math.abs(~maxIndex); + }; + + BinarySearchIndex.prototype.between = function between (start, end) { + var startIndex = this.getIndex(start); + var endIndex = this.getIndex(end); + + if (startIndex === 0 && endIndex === 0) { + return []; + } + + while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) { + startIndex--; + } + + while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) { + endIndex++; + } + + if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) { + endIndex++; + } + + return this.values.slice(startIndex, endIndex); + }; + + BinarySearchIndex.prototype.insert = function insert (item) { + this.values.splice(this.getIndex(item.value), 0, item); + return this; + }; + + BinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) { + this.values = this.values.concat([].concat(items || [])); + + if (sort) { + this.sort(); + } else { + this.dirty = true; + } + + return this; + }; + + BinarySearchIndex.prototype.sort = function sort () { + this.values.sort(function (a, b) { + return +b.value - +a.value; + }).reverse(); + this.dirty = false; + return this; + }; + + var FeatureManager = VirtualGrid.extend({ + /** + * Options + */ + + options: { + attribution: null, + where: '1=1', + fields: ['*'], + from: false, + to: false, + timeField: false, + timeFilterMode: 'server', + simplifyFactor: 0, + precision: 6 + }, + + /** + * Constructor + */ + + initialize: function (options) { + VirtualGrid.prototype.initialize.call(this, options); + + options.url = cleanUrl(options.url); + options = L.setOptions(this, options); + + this.service = featureLayerService(options); + this.service.addEventParent(this); + + // use case insensitive regex to look for common fieldnames used for indexing + if (this.options.fields[0] !== '*') { + var oidCheck = false; + for (var i = 0; i < this.options.fields.length; i++) { + if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) { + oidCheck = true; + } + } + if (oidCheck === false) { + warn('no known esriFieldTypeOID field detected in fields Array. Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.'); + } + } + + if (this.options.timeField.start && this.options.timeField.end) { + this._startTimeIndex = new BinarySearchIndex(); + this._endTimeIndex = new BinarySearchIndex(); + } else if (this.options.timeField) { + this._timeIndex = new BinarySearchIndex(); + } + + this._cache = {}; + this._currentSnapshot = []; // cache of what layers should be active + this._activeRequests = 0; + }, + + /** + * Layer Interface + */ + + onAdd: function (map) { + map.on('zoomend', this._handleZoomChange, this); + + return VirtualGrid.prototype.onAdd.call(this, map); + }, + + onRemove: function (map) { + map.off('zoomend', this._handleZoomChange, this); + + return VirtualGrid.prototype.onRemove.call(this, map); + }, + + getAttribution: function () { + return this.options.attribution; + }, + + /** + * Feature Management + */ + + createCell: function (bounds, coords) { + this._requestFeatures(bounds, coords); + }, + + _requestFeatures: function (bounds, coords, callback) { + this._activeRequests++; + + // our first active request fires loading + if (this._activeRequests === 1) { + this.fire('loading', { + bounds: bounds + }, true); + } + + return this._buildQuery(bounds).run(function (error, featureCollection, response) { + if (response && response.exceededTransferLimit) { + this.fire('drawlimitexceeded'); + } + + // no error, features + if (!error && featureCollection && featureCollection.features.length) { + // schedule adding features until the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this._addFeatures(featureCollection.features, coords); + this._postProcessFeatures(bounds); + }, this)); + } + + // no error, no features + if (!error && featureCollection && !featureCollection.features.length) { + this._postProcessFeatures(bounds); + } + + if (error) { + this._postProcessFeatures(bounds); + } + + if (callback) { + callback.call(this, error, featureCollection); + } + }, this); + }, + + _postProcessFeatures: function (bounds) { + // deincriment the request counter now that we have processed features + this._activeRequests--; + + // if there are no more active requests fire a load event for this view + if (this._activeRequests <= 0) { + this.fire('load', { + bounds: bounds + }); + } + }, + + _cacheKey: function (coords) { + return coords.z + ':' + coords.x + ':' + coords.y; + }, + + _addFeatures: function (features, coords) { + var key = this._cacheKey(coords); + this._cache[key] = this._cache[key] || []; + + for (var i = features.length - 1; i >= 0; i--) { + var id = features[i].id; + this._currentSnapshot.push(id); + this._cache[key].push(id); + } + + if (this.options.timeField) { + this._buildTimeIndexes(features); + } + + // need to PR removal of the logic below too... + // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102 + + this.createLayers(features); + }, + + _buildQuery: function (bounds) { + var query = this.service.query() + .intersects(bounds) + .where(this.options.where) + .fields(this.options.fields) + .precision(this.options.precision); + + if (this.options.simplifyFactor) { + query.simplify(this._map, this.options.simplifyFactor); + } + + if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) { + query.between(this.options.from, this.options.to); + } + + return query; + }, + + /** + * Where Methods + */ + + setWhere: function (where, callback, context) { + this.options.where = (where && where.length) ? where : '1=1'; + + var oldSnapshot = []; + var newSnapshot = []; + var pendingRequests = 0; + var requestError = null; + var requestCallback = L.Util.bind(function (error, featureCollection) { + if (error) { + requestError = error; + } + + if (featureCollection) { + for (var i = featureCollection.features.length - 1; i >= 0; i--) { + newSnapshot.push(featureCollection.features[i].id); + } + } + + pendingRequests--; + + if (pendingRequests <= 0) { + this._currentSnapshot = newSnapshot; + // schedule adding features for the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this.removeLayers(oldSnapshot); + this.addLayers(newSnapshot); + if (callback) { + callback.call(context, requestError); + } + }, this)); + } + }, this); + + for (var i = this._currentSnapshot.length - 1; i >= 0; i--) { + oldSnapshot.push(this._currentSnapshot[i]); + } + + for (var key in this._activeCells) { + pendingRequests++; + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key, requestCallback); + } + + return this; + }, + + getWhere: function () { + return this.options.where; + }, + + /** + * Time Range Methods + */ + + getTimeRange: function () { + return [this.options.from, this.options.to]; + }, + + setTimeRange: function (from, to, callback, context) { + var oldFrom = this.options.from; + var oldTo = this.options.to; + var pendingRequests = 0; + var requestError = null; + var requestCallback = L.Util.bind(function (error) { + if (error) { + requestError = error; + } + this._filterExistingFeatures(oldFrom, oldTo, from, to); + + pendingRequests--; + + if (callback && pendingRequests <= 0) { + callback.call(context, requestError); + } + }, this); + + this.options.from = from; + this.options.to = to; + + this._filterExistingFeatures(oldFrom, oldTo, from, to); + + if (this.options.timeFilterMode === 'server') { + for (var key in this._activeCells) { + pendingRequests++; + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key, requestCallback); + } + } + + return this; + }, + + refresh: function () { + for (var key in this._activeCells) { + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key); + } + + if (this.redraw) { + this.once('load', function () { + this.eachFeature(function (layer) { + this._redraw(layer.feature.id); + }, this); + }, this); + } + }, + + _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) { + var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot; + var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo); + + if (layersToAdd.indexOf) { + for (var i = 0; i < layersToAdd.length; i++) { + var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]); + if (shouldRemoveLayer >= 0) { + layersToRemove.splice(shouldRemoveLayer, 1); + } + } + } + + // schedule adding features until the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this.removeLayers(layersToRemove); + this.addLayers(layersToAdd); + }, this)); + }, + + _getFeaturesInTimeRange: function (start, end) { + var ids = []; + var search; + + if (this.options.timeField.start && this.options.timeField.end) { + var startTimes = this._startTimeIndex.between(start, end); + var endTimes = this._endTimeIndex.between(start, end); + search = startTimes.concat(endTimes); + } else { + search = this._timeIndex.between(start, end); + } + + for (var i = search.length - 1; i >= 0; i--) { + ids.push(search[i].id); + } + + return ids; + }, + + _buildTimeIndexes: function (geojson) { + var i; + var feature; + if (this.options.timeField.start && this.options.timeField.end) { + var startTimeEntries = []; + var endTimeEntries = []; + for (i = geojson.length - 1; i >= 0; i--) { + feature = geojson[i]; + startTimeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField.start]) + }); + endTimeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField.end]) + }); + } + this._startTimeIndex.bulkAdd(startTimeEntries); + this._endTimeIndex.bulkAdd(endTimeEntries); + } else { + var timeEntries = []; + for (i = geojson.length - 1; i >= 0; i--) { + feature = geojson[i]; + timeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField]) + }); + } + + this._timeIndex.bulkAdd(timeEntries); + } + }, + + _featureWithinTimeRange: function (feature) { + if (!this.options.from || !this.options.to) { + return true; + } + + var from = +this.options.from.valueOf(); + var to = +this.options.to.valueOf(); + + if (typeof this.options.timeField === 'string') { + var date = +feature.properties[this.options.timeField]; + return (date >= from) && (date <= to); + } + + if (this.options.timeField.start && this.options.timeField.end) { + var startDate = +feature.properties[this.options.timeField.start]; + var endDate = +feature.properties[this.options.timeField.end]; + return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to)); + } + }, + + _visibleZoom: function () { + // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer + if (!this._map) { + return false; + } + var zoom = this._map.getZoom(); + if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { + return false; + } else { return true; } + }, + + _handleZoomChange: function () { + if (!this._visibleZoom()) { + this.removeLayers(this._currentSnapshot); + this._currentSnapshot = []; + } else { + /* + for every cell in this._activeCells + 1. Get the cache key for the coords of the cell + 2. If this._cache[key] exists it will be an array of feature IDs. + 3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back. + */ + for (var i in this._activeCells) { + var coords = this._activeCells[i].coords; + var key = this._cacheKey(coords); + if (this._cache[key]) { + this.addLayers(this._cache[key]); + } + } + } + }, + + /** + * Service Methods + */ + + authenticate: function (token) { + this.service.authenticate(token); + return this; + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + query: function () { + return this.service.query(); + }, + + _getMetadata: function (callback) { + if (this._metadata) { + var error; + callback(error, this._metadata); + } else { + this.metadata(L.Util.bind(function (error, response) { + this._metadata = response; + callback(error, this._metadata); + }, this)); + } + }, + + addFeature: function (feature, callback, context) { + this._getMetadata(L.Util.bind(function (error, metadata) { + if (error) { + if (callback) { callback.call(this, error, null); } + return; + } + + this.service.addFeature(feature, L.Util.bind(function (error, response) { + if (!error) { + // assign ID from result to appropriate objectid field from service metadata + feature.properties[metadata.objectIdField] = response.objectId; + + // we also need to update the geojson id for createLayers() to function + feature.id = response.objectId; + this.createLayers([feature]); + } + + if (callback) { + callback.call(context, error, response); + } + }, this)); + }, this)); + }, + + updateFeature: function (feature, callback, context) { + this.service.updateFeature(feature, function (error, response) { + if (!error) { + this.removeLayers([feature.id], true); + this.createLayers([feature]); + } + + if (callback) { + callback.call(context, error, response); + } + }, this); + }, + + deleteFeature: function (id, callback, context) { + this.service.deleteFeature(id, function (error, response) { + if (!error && response.objectId) { + this.removeLayers([response.objectId], true); + } + if (callback) { + callback.call(context, error, response); + } + }, this); + }, + + deleteFeatures: function (ids, callback, context) { + return this.service.deleteFeatures(ids, function (error, response) { + if (!error && response.length > 0) { + for (var i = 0; i < response.length; i++) { + this.removeLayers([response[i].objectId], true); + } + } + if (callback) { + callback.call(context, error, response); + } + }, this); + } + }); + + var FeatureLayer = FeatureManager.extend({ + + options: { + cacheLayers: true + }, + + /** + * Constructor + */ + initialize: function (options) { + FeatureManager.prototype.initialize.call(this, options); + this._originalStyle = this.options.style; + this._layers = {}; + }, + + /** + * Layer Interface + */ + + onRemove: function (map) { + for (var i in this._layers) { + map.removeLayer(this._layers[i]); + } + + return FeatureManager.prototype.onRemove.call(this, map); + }, + + createNewLayer: function (geojson) { + var layer = L.GeoJSON.geometryToLayer(geojson, this.options); + layer.defaultOptions = layer.options; + return layer; + }, + + _updateLayer: function (layer, geojson) { + // convert the geojson coordinates into a Leaflet LatLng array/nested arrays + // pass it to setLatLngs to update layer geometries + var latlngs = []; + var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng; + + // copy new attributes, if present + if (geojson.properties) { + layer.feature.properties = geojson.properties; + } + + switch (geojson.geometry.type) { + case 'Point': + latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates); + layer.setLatLng(latlngs); + break; + case 'LineString': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'MultiLineString': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'Polygon': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'MultiPolygon': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + } + }, + + /** + * Feature Management Methods + */ + + createLayers: function (features) { + for (var i = features.length - 1; i >= 0; i--) { + var geojson = features[i]; + + var layer = this._layers[geojson.id]; + var newLayer; + + if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) { + this._map.addLayer(layer); + } + + // update geometry if necessary + if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) { + this._updateLayer(layer, geojson); + } + + if (!layer) { + newLayer = this.createNewLayer(geojson); + newLayer.feature = geojson; + + // bubble events from individual layers to the feature layer + newLayer.addEventParent(this); + + if (this.options.onEachFeature) { + this.options.onEachFeature(newLayer.feature, newLayer); + } + + // cache the layer + this._layers[newLayer.feature.id] = newLayer; + + // style the layer + this.setFeatureStyle(newLayer.feature.id, this.options.style); + + this.fire('createfeature', { + feature: newLayer.feature + }, true); + + // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled + if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) { + this._map.addLayer(newLayer); + } + } + } + }, + + addLayers: function (ids) { + for (var i = ids.length - 1; i >= 0; i--) { + var layer = this._layers[ids[i]]; + if (layer) { + this.fire('addfeature', { + feature: layer.feature + }, true); + this._map.addLayer(layer); + } + } + }, + + removeLayers: function (ids, permanent) { + for (var i = ids.length - 1; i >= 0; i--) { + var id = ids[i]; + var layer = this._layers[id]; + if (layer) { + this.fire('removefeature', { + feature: layer.feature, + permanent: permanent + }, true); + this._map.removeLayer(layer); + } + if (layer && permanent) { + delete this._layers[id]; + } + } + }, + + cellEnter: function (bounds, coords) { + if (!this._zooming && this._map) { + L.Util.requestAnimFrame(L.Util.bind(function () { + var cacheKey = this._cacheKey(coords); + var cellKey = this._cellCoordsToKey(coords); + var layers = this._cache[cacheKey]; + if (this._activeCells[cellKey] && layers) { + this.addLayers(layers); + } + }, this)); + } + }, + + cellLeave: function (bounds, coords) { + if (!this._zooming) { + L.Util.requestAnimFrame(L.Util.bind(function () { + if (this._map) { + var cacheKey = this._cacheKey(coords); + var cellKey = this._cellCoordsToKey(coords); + var layers = this._cache[cacheKey]; + var mapBounds = this._map.getBounds(); + if (!this._activeCells[cellKey] && layers) { + var removable = true; + + for (var i = 0; i < layers.length; i++) { + var layer = this._layers[layers[i]]; + if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) { + removable = false; + } + } + + if (removable) { + this.removeLayers(layers, !this.options.cacheLayers); + } + + if (!this.options.cacheLayers && removable) { + delete this._cache[cacheKey]; + delete this._cells[cellKey]; + delete this._activeCells[cellKey]; + } + } + } + }, this)); + } + }, + + /** + * Styling Methods + */ + + resetStyle: function () { + this.options.style = this._originalStyle; + this.eachFeature(function (layer) { + this.resetFeatureStyle(layer.feature.id); + }, this); + return this; + }, + + setStyle: function (style) { + this.options.style = style; + this.eachFeature(function (layer) { + this.setFeatureStyle(layer.feature.id, style); + }, this); + return this; + }, + + resetFeatureStyle: function (id) { + var layer = this._layers[id]; + var style = this._originalStyle || L.Path.prototype.options; + if (layer) { + L.Util.extend(layer.options, layer.defaultOptions); + this.setFeatureStyle(id, style); + } + return this; + }, + + setFeatureStyle: function (id, style) { + var layer = this._layers[id]; + if (typeof style === 'function') { + style = style(layer.feature); + } + if (layer.setStyle) { + layer.setStyle(style); + } + return this; + }, + + /** + * Utility Methods + */ + + eachFeature: function (fn, context) { + for (var i in this._layers) { + fn.call(context, this._layers[i]); + } + return this; + }, + + getFeature: function (id) { + return this._layers[id]; + }, + + bringToBack: function () { + this.eachFeature(function (layer) { + if (layer.bringToBack) { + layer.bringToBack(); + } + }); + }, + + bringToFront: function () { + this.eachFeature(function (layer) { + if (layer.bringToFront) { + layer.bringToFront(); + } + }); + }, + + redraw: function (id) { + if (id) { + this._redraw(id); + } + return this; + }, + + _redraw: function (id) { + var layer = this._layers[id]; + var geojson = layer.feature; + + // if this looks like a marker + if (layer && layer.setIcon && this.options.pointToLayer) { + // update custom symbology, if necessary + if (this.options.pointToLayer) { + var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0])); + var updatedIcon = getIcon.options.icon; + layer.setIcon(updatedIcon); + } + } + + // looks like a vector marker (circleMarker) + if (layer && layer.setStyle && this.options.pointToLayer) { + var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0])); + var updatedStyle = getStyle.options; + this.setFeatureStyle(geojson.id, updatedStyle); + } + + // looks like a path (polygon/polyline) + if (layer && layer.setStyle && this.options.style) { + this.resetStyle(geojson.id); + } + } + }); + + function featureLayer (options) { + return new FeatureLayer(options); + } + + exports.VERSION = version; + exports.Support = Support; + exports.Util = Util; + exports.get = get; + exports.post = xmlHttpPost; + exports.request = request; + exports.Task = Task; + exports.task = task; + exports.Query = Query; + exports.query = query; + exports.Find = Find; + exports.find = find; + exports.Identify = Identify; + exports.identify = identify; + exports.IdentifyFeatures = IdentifyFeatures; + exports.identifyFeatures = identifyFeatures; + exports.IdentifyImage = IdentifyImage; + exports.identifyImage = identifyImage; + exports.Service = Service; + exports.service = service; + exports.MapService = MapService; + exports.mapService = mapService; + exports.ImageService = ImageService; + exports.imageService = imageService; + exports.FeatureLayerService = FeatureLayerService; + exports.featureLayerService = featureLayerService; + exports.BasemapLayer = BasemapLayer; + exports.basemapLayer = basemapLayer; + exports.TiledMapLayer = TiledMapLayer; + exports.tiledMapLayer = tiledMapLayer; + exports.RasterLayer = RasterLayer; + exports.ImageMapLayer = ImageMapLayer; + exports.imageMapLayer = imageMapLayer; + exports.DynamicMapLayer = DynamicMapLayer; + exports.dynamicMapLayer = dynamicMapLayer; + exports.FeatureManager = FeatureManager; + exports.FeatureLayer = FeatureLayer; + exports.featureLayer = featureLayer; + +})); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-debug.js","sources":["../package.json","../src/Support.js","../node_modules/arcgis-to-geojson-utils/index.js","../src/Util.js","../src/Request.js","../src/Tasks/Task.js","../src/Tasks/Query.js","../src/Tasks/Find.js","../src/Tasks/Identify.js","../src/Tasks/IdentifyFeatures.js","../src/Tasks/IdentifyImage.js","../src/Services/Service.js","../src/Services/MapService.js","../src/Services/ImageService.js","../src/Services/FeatureLayerService.js","../src/Controls/Logo.js","../src/Layers/BasemapLayer.js","../src/Layers/TiledMapLayer.js","../src/Layers/RasterLayer.js","../src/Layers/ImageMapLayer.js","../src/Layers/DynamicMapLayer.js","../node_modules/leaflet-virtual-grid/src/virtual-grid.js","../node_modules/tiny-binary-search/index.js","../src/Layers/FeatureLayer/FeatureManager.js","../src/Layers/FeatureLayer/FeatureLayer.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet\",\n  \"description\": \"Leaflet plugins for consuming ArcGIS Online and ArcGIS Server services.\",\n  \"version\": \"2.0.0-beta.8\",\n  \"author\": \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n  \"browser\": \"dist/esri-leaflet-debug.js\",\n  \"bugs\": {\n    \"url\": \"https://github.com/esri/esri-leaflet/issues\"\n  },\n  \"contributors\": [\n    \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n    \"John Gravois <jgravois@esri.com> (http://johngravois.com)\"\n  ],\n  \"dependencies\": {\n    \"arcgis-to-geojson-utils\": \"^1.0.1\",\n    \"leaflet\": \"^1.0.0-beta.2\",\n    \"leaflet-virtual-grid\": \"^1.0.3\",\n    \"tiny-binary-search\": \"^1.0.2\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"2.3.0\",\n    \"eslint\": \"^1.10.2\",\n    \"gh-release\": \"^2.0.0\",\n    \"highlight.js\": \"^8.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.16\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^0.5.3\",\n    \"karma-mocha\": \"^0.1.0\",\n    \"karma-mocha-reporter\": \"^0.2.5\",\n    \"karma-phantomjs-launcher\": \"^0.2.0\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"load-grunt-tasks\": \"^0.4.0\",\n    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^2.3.4\",\n    \"phantomjs\": \"^1.9.17\",\n    \"rollup\": \"^0.25.4\",\n    \"rollup-plugin-json\": \"^2.0.0\",\n    \"rollup-plugin-node-resolve\": \"^1.4.0\",\n    \"rollup-plugin-npm\": \"^1.2.1\",\n    \"rollup-plugin-uglify\": \"^0.1.0\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"snazzy\": \"^2.0.1\",\n    \"uglify-js\": \"^2.6.1\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"http://esri.github.io/esri-leaflet\",\n  \"jsnext:main\": \"src/EsriLeaflet.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeaflet.js\"\n  },\n  \"keywords\": [\n    \"arcgis\",\n    \"esri\",\n    \"esri leaflet\",\n    \"gis\",\n    \"leaflet plugin\",\n    \"mapping\"\n  ],\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git@github.com:Esri/esri-leaflet.git\"\n  },\n  \"scripts\": {\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\n    \"prebuild\": \"mkdirp dist\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"release\": \"./scripts/release.sh\",\n    \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\",\n    \"test\": \"npm run lint && karma start\"\n  }\n}\n","export var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest()));\nexport var pointerEvents = document.documentElement.style.pointerEvents === '';\n\nexport var Support = {\n  cors: cors,\n  pointerEvents: pointerEvents\n};\n\nexport default Support;\n","/*\n * Copyright 2015 Esri\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the Liscense.\n */\n\n// checks if 2 x,y points are equal\nfunction pointsEqual (a, b) {\n  for (var i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// checks if the first and last points of a ring are equal and closes the ring\nfunction closeRing (coordinates) {\n  if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {\n    coordinates.push(coordinates[0]);\n  }\n  return coordinates;\n}\n\n// determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring\n// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-\n// points-are-in-clockwise-order\nfunction ringIsClockwise (ringToTest) {\n  var total = 0;\n  var i = 0;\n  var rLength = ringToTest.length;\n  var pt1 = ringToTest[i];\n  var pt2;\n  for (i; i < rLength - 1; i++) {\n    pt2 = ringToTest[i + 1];\n    total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);\n    pt1 = pt2;\n  }\n  return (total >= 0);\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519\nfunction vertexIntersectsVertex (a1, a2, b1, b2) {\n  var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);\n  var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);\n  var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);\n\n  if (uB !== 0) {\n    var ua = uaT / uB;\n    var ub = ubT / uB;\n\n    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531\nfunction arrayIntersectsArray (a, b) {\n  for (var i = 0; i < a.length - 1; i++) {\n    for (var j = 0; j < b.length - 1; j++) {\n      if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480\nfunction coordinatesContainPoint (coordinates, point) {\n  var contains = false;\n  for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {\n    if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||\n         (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&\n        (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {\n      contains = !contains;\n    }\n  }\n  return contains;\n}\n\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113\nfunction coordinatesContainCoordinates (outer, inner) {\n  var intersects = arrayIntersectsArray(outer, inner);\n  var contains = coordinatesContainPoint(outer, inner[0]);\n  if (!intersects && contains) {\n    return true;\n  }\n  return false;\n}\n\n// do any polygons in this array contain any other polygons in this array?\n// used for checking for holes in arcgis rings\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172\nfunction convertRingsToGeoJSON (rings) {\n  var outerRings = [];\n  var holes = [];\n  var x; // iterator\n  var outerRing; // current outer ring being evaluated\n  var hole; // current hole being evaluated\n\n  // for each ring\n  for (var r = 0; r < rings.length; r++) {\n    var ring = closeRing(rings[r].slice(0));\n    if (ring.length < 4) {\n      continue;\n    }\n    // is this ring an outer ring? is it clockwise?\n    if (ringIsClockwise(ring)) {\n      var polygon = [ ring ];\n      outerRings.push(polygon); // push to outer rings\n    } else {\n      holes.push(ring); // counterclockwise push to holes\n    }\n  }\n\n  var uncontainedHoles = [];\n\n  // while there are holes left...\n  while (holes.length) {\n    // pop a hole off out stack\n    hole = holes.pop();\n\n    // loop over all outer rings and see if they contain our hole.\n    var contained = false;\n    for (x = outerRings.length - 1; x >= 0; x--) {\n      outerRing = outerRings[x][0];\n      if (coordinatesContainCoordinates(outerRing, hole)) {\n        // the hole is contained push it into our polygon\n        outerRings[x].push(hole);\n        contained = true;\n        break;\n      }\n    }\n\n    // ring is not contained in any outer ring\n    // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320\n    if (!contained) {\n      uncontainedHoles.push(hole);\n    }\n  }\n\n  // if we couldn't match any holes using contains we can try intersects...\n  while (uncontainedHoles.length) {\n    // pop a hole off out stack\n    hole = uncontainedHoles.pop();\n\n    // loop over all outer rings and see if any intersect our hole.\n    var intersects = false;\n\n    for (x = outerRings.length - 1; x >= 0; x--) {\n      outerRing = outerRings[x][0];\n      if (arrayIntersectsArray(outerRing, hole)) {\n        // the hole is contained push it into our polygon\n        outerRings[x].push(hole);\n        intersects = true;\n        break;\n      }\n    }\n\n    if (!intersects) {\n      outerRings.push([hole.reverse()]);\n    }\n  }\n\n  if (outerRings.length === 1) {\n    return {\n      type: 'Polygon',\n      coordinates: outerRings[0]\n    };\n  } else {\n    return {\n      type: 'MultiPolygon',\n      coordinates: outerRings\n    };\n  }\n}\n\n// This function ensures that rings are oriented in the right directions\n// outer rings are clockwise, holes are counterclockwise\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction orientRings (poly) {\n  var output = [];\n  var polygon = poly.slice(0);\n  var outerRing = closeRing(polygon.shift().slice(0));\n  if (outerRing.length >= 4) {\n    if (!ringIsClockwise(outerRing)) {\n      outerRing.reverse();\n    }\n\n    output.push(outerRing);\n\n    for (var i = 0; i < polygon.length; i++) {\n      var hole = closeRing(polygon[i].slice(0));\n      if (hole.length >= 4) {\n        if (ringIsClockwise(hole)) {\n          hole.reverse();\n        }\n        output.push(hole);\n      }\n    }\n  }\n\n  return output;\n}\n\n// This function flattens holes in multipolygons to one array of polygons\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction flattenMultiPolygonRings (rings) {\n  var output = [];\n  for (var i = 0; i < rings.length; i++) {\n    var polygon = orientRings(rings[i]);\n    for (var x = polygon.length - 1; x >= 0; x--) {\n      var ring = polygon[x].slice(0);\n      output.push(ring);\n    }\n  }\n  return output;\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nfunction shallowClone (obj) {\n  var target = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      target[i] = obj[i];\n    }\n  }\n  return target;\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttribute) {\n  var geojson = {};\n\n  if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {\n    geojson.type = 'Point';\n    geojson.coordinates = [arcgis.x, arcgis.y];\n  }\n\n  if (arcgis.points) {\n    geojson.type = 'MultiPoint';\n    geojson.coordinates = arcgis.points.slice(0);\n  }\n\n  if (arcgis.paths) {\n    if (arcgis.paths.length === 1) {\n      geojson.type = 'LineString';\n      geojson.coordinates = arcgis.paths[0].slice(0);\n    } else {\n      geojson.type = 'MultiLineString';\n      geojson.coordinates = arcgis.paths.slice(0);\n    }\n  }\n\n  if (arcgis.rings) {\n    geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));\n  }\n\n  if (arcgis.geometry || arcgis.attributes) {\n    geojson.type = 'Feature';\n    geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON(arcgis.geometry) : null;\n    geojson.properties = (arcgis.attributes) ? shallowClone(arcgis.attributes) : null;\n    if (arcgis.attributes) {\n      geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID;\n    }\n  }\n\n  return geojson;\n}\n\nexport function geojsonToArcGIS (geojson, idAttribute) {\n  idAttribute = idAttribute || 'OBJECTID';\n  var spatialReference = { wkid: 4326 };\n  var result = {};\n  var i;\n\n  switch (geojson.type) {\n    case 'Point':\n      result.x = geojson.coordinates[0];\n      result.y = geojson.coordinates[1];\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiPoint':\n      result.points = geojson.coordinates.slice(0);\n      result.spatialReference = spatialReference;\n      break;\n    case 'LineString':\n      result.paths = [geojson.coordinates.slice(0)];\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiLineString':\n      result.paths = geojson.coordinates.slice(0);\n      result.spatialReference = spatialReference;\n      break;\n    case 'Polygon':\n      result.rings = orientRings(geojson.coordinates.slice(0));\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiPolygon':\n      result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));\n      result.spatialReference = spatialReference;\n      break;\n    case 'Feature':\n      if (geojson.geometry) {\n        result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);\n      }\n      result.attributes = (geojson.properties) ? shallowClone(geojson.properties) : {};\n      if (geojson.id) {\n        result.attributes[idAttribute] = geojson.id;\n      }\n      break;\n    case 'FeatureCollection':\n      result = [];\n      for (i = 0; i < geojson.features.length; i++) {\n        result.push(geojsonToArcGIS(geojson.features[i], idAttribute));\n      }\n      break;\n    case 'GeometryCollection':\n      result = [];\n      for (i = 0; i < geojson.geometries.length; i++) {\n        result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));\n      }\n      break;\n  }\n\n  return result;\n}\n","import L from 'leaflet';\nimport {\n  geojsonToArcGIS as g2a,\n  arcgisToGeoJSON as a2g\n} from 'arcgis-to-geojson-utils';\n\nexport function geojsonToArcGIS (geojson, idAttr) {\n  return g2a(geojson, idAttr);\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttr) {\n  return a2g(arcgis, idAttr);\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nexport function shallowClone (obj) {\n  var target = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      target[i] = obj[i];\n    }\n  }\n  return target;\n}\n\n// convert an extent (ArcGIS) to LatLngBounds (Leaflet)\nexport function extentToBounds (extent) {\n  var sw = L.latLng(extent.ymin, extent.xmin);\n  var ne = L.latLng(extent.ymax, extent.xmax);\n  return L.latLngBounds(sw, ne);\n}\n\n// convert an LatLngBounds (Leaflet) to extent (ArcGIS)\nexport function boundsToExtent (bounds) {\n  bounds = L.latLngBounds(bounds);\n  return {\n    'xmin': bounds.getSouthWest().lng,\n    'ymin': bounds.getSouthWest().lat,\n    'xmax': bounds.getNorthEast().lng,\n    'ymax': bounds.getNorthEast().lat,\n    'spatialReference': {\n      'wkid': 4326\n    }\n  };\n}\n\nexport function responseToFeatureCollection (response, idAttribute) {\n  var objectIdField;\n\n  if (idAttribute) {\n    objectIdField = idAttribute;\n  } else if (response.objectIdFieldName) {\n    objectIdField = response.objectIdFieldName;\n  } else if (response.fields) {\n    for (var j = 0; j <= response.fields.length - 1; j++) {\n      if (response.fields[j].type === 'esriFieldTypeOID') {\n        objectIdField = response.fields[j].name;\n        break;\n      }\n    }\n  } else {\n    objectIdField = 'OBJECTID';\n  }\n\n  var featureCollection = {\n    type: 'FeatureCollection',\n    features: []\n  };\n  var features = response.features || response.results;\n  if (features.length) {\n    for (var i = features.length - 1; i >= 0; i--) {\n      var feature = arcgisToGeoJSON(features[i], objectIdField);\n      featureCollection.features.push(feature);\n    }\n  }\n\n  return featureCollection;\n}\n\n  // trim url whitespace and add a trailing slash if needed\nexport function cleanUrl (url) {\n  // trim leading and trailing spaces, but not spaces inside the url\n  url = L.Util.trim(url);\n\n  // add a trailing slash to the url if the user omitted it\n  if (url[url.length - 1] !== '/') {\n    url += '/';\n  }\n\n  return url;\n}\n\nexport function isArcgisOnline (url) {\n  /* hosted feature services can emit geojson natively.\n  our check for 'geojson' support will need to be revisted\n  once the functionality makes its way to ArcGIS Server*/\n  return (/\\.arcgis\\.com.*?FeatureServer/g).test(url);\n}\n\nexport function geojsonTypeToArcGIS (geoJsonType) {\n  var arcgisGeometryType;\n  switch (geoJsonType) {\n    case 'Point':\n      arcgisGeometryType = 'esriGeometryPoint';\n      break;\n    case 'MultiPoint':\n      arcgisGeometryType = 'esriGeometryMultipoint';\n      break;\n    case 'LineString':\n      arcgisGeometryType = 'esriGeometryPolyline';\n      break;\n    case 'MultiLineString':\n      arcgisGeometryType = 'esriGeometryPolyline';\n      break;\n    case 'Polygon':\n      arcgisGeometryType = 'esriGeometryPolygon';\n      break;\n    case 'MultiPolygon':\n      arcgisGeometryType = 'esriGeometryPolygon';\n      break;\n  }\n\n  return arcgisGeometryType;\n}\n\nexport function warn () {\n  if (console && console.warn) {\n    console.warn.apply(console, arguments);\n  }\n}\n\nexport var Util = {\n  shallowClone: shallowClone,\n  warn: warn,\n  cleanUrl: cleanUrl,\n  isArcgisOnline: isArcgisOnline,\n  geojsonTypeToArcGIS: geojsonTypeToArcGIS,\n  responseToFeatureCollection: responseToFeatureCollection,\n  geojsonToArcGIS: geojsonToArcGIS,\n  arcgisToGeoJSON: arcgisToGeoJSON,\n  boundsToExtent: boundsToExtent,\n  extentToBounds: extentToBounds\n};\n\nexport default Util;\n","import L from 'leaflet';\nimport Support from './Support';\nimport { warn } from './Util';\n\nvar callbacks = 0;\n\nfunction serialize (params) {\n  var data = '';\n\n  params.f = params.f || 'json';\n\n  for (var key in params) {\n    if (params.hasOwnProperty(key)) {\n      var param = params[key];\n      var type = Object.prototype.toString.call(param);\n      var value;\n\n      if (data.length) {\n        data += '&';\n      }\n\n      if (type === '[object Array]') {\n        value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(',');\n      } else if (type === '[object Object]') {\n        value = JSON.stringify(param);\n      } else if (type === '[object Date]') {\n        value = param.valueOf();\n      } else {\n        value = param;\n      }\n\n      data += encodeURIComponent(key) + '=' + encodeURIComponent(value);\n    }\n  }\n\n  return data;\n}\n\nfunction createRequest (callback, context) {\n  var httpRequest = new window.XMLHttpRequest();\n\n  httpRequest.onerror = function (e) {\n    httpRequest.onreadystatechange = L.Util.falseFn;\n\n    callback.call(context, {\n      error: {\n        code: 500,\n        message: 'XMLHttpRequest error'\n      }\n    }, null);\n  };\n\n  httpRequest.onreadystatechange = function () {\n    var response;\n    var error;\n\n    if (httpRequest.readyState === 4) {\n      try {\n        response = JSON.parse(httpRequest.responseText);\n      } catch (e) {\n        response = null;\n        error = {\n          code: 500,\n          message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.'\n        };\n      }\n\n      if (!error && response.error) {\n        error = response.error;\n        response = null;\n      }\n\n      httpRequest.onerror = L.Util.falseFn;\n\n      callback.call(context, error, response);\n    }\n  };\n\n  httpRequest.ontimeout = function () {\n    this.onerror();\n  };\n\n  return httpRequest;\n}\n\nfunction xmlHttpPost (url, params, callback, context) {\n  var httpRequest = createRequest(callback, context);\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n\n  httpRequest.open('POST', url);\n  httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n  httpRequest.send(serialize(params));\n\n  return httpRequest;\n}\n\nfunction xmlHttpGet (url, params, callback, context) {\n  var httpRequest = createRequest(callback, context);\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n\n  httpRequest.open('GET', url + '?' + serialize(params), true);\n  httpRequest.send(null);\n\n  return httpRequest;\n}\n\n// AJAX handlers for CORS (modern browsers) or JSONP (older browsers)\nexport function request (url, params, callback, context) {\n  var paramString = serialize(params);\n  var httpRequest = createRequest(callback, context);\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n\n  var requestLength = (url + '?' + paramString).length;\n\n  // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest\n  if (requestLength <= 2000 && Support.cors) {\n    httpRequest.open('GET', url + '?' + paramString);\n    httpRequest.send(null);\n\n  // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest\n  } else if (requestLength > 2000 && Support.cors) {\n    httpRequest.open('POST', url);\n    httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n    httpRequest.send(paramString);\n\n  // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request\n  } else if (requestLength <= 2000 && !Support.cors) {\n    return jsonp(url, params, callback, context);\n\n  // request is longer then 2000 characters and the browser does not support CORS, log a warning\n  } else {\n    warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html');\n    return;\n  }\n\n  return httpRequest;\n}\n\nexport function jsonp (url, params, callback, context) {\n  window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {};\n  var callbackId = 'c' + callbacks;\n\n  params.callback = 'window._EsriLeafletCallbacks.' + callbackId;\n\n  var script = L.DomUtil.create('script', null, document.body);\n  script.type = 'text/javascript';\n  script.src = url + '?' + serialize(params);\n  script.id = callbackId;\n\n  window._EsriLeafletCallbacks[callbackId] = function (response) {\n    if (window._EsriLeafletCallbacks[callbackId] !== true) {\n      var error;\n      var responseType = Object.prototype.toString.call(response);\n\n      if (!(responseType === '[object Object]' || responseType === '[object Array]')) {\n        error = {\n          error: {\n            code: 500,\n            message: 'Expected array or object as JSONP response'\n          }\n        };\n        response = null;\n      }\n\n      if (!error && response.error) {\n        error = response;\n        response = null;\n      }\n\n      callback.call(context, error, response);\n      window._EsriLeafletCallbacks[callbackId] = true;\n    }\n  };\n\n  callbacks++;\n\n  return {\n    id: callbackId,\n    url: script.src,\n    abort: function () {\n      window._EsriLeafletCallbacks._callback[callbackId]({\n        code: 0,\n        message: 'Request aborted.'\n      });\n    }\n  };\n}\n\nvar get = ((Support.cors) ? xmlHttpGet : jsonp);\nget.CORS = xmlHttpGet;\nget.JSONP = jsonp;\n\n// choose the correct AJAX handler depending on CORS support\nexport { get };\n\n// always use XMLHttpRequest for posts\nexport { xmlHttpPost as post };\n\n// export the Request object to call the different handlers for debugging\nexport var Request = {\n  request: request,\n  get: get,\n  post: xmlHttpPost\n};\n\nexport default Request;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Task = L.Class.extend({\n\n  options: {\n    proxy: false,\n    useCors: cors\n  },\n\n  // Generate a method for each methodName:paramName in the setters for this task.\n  generateSetter: function (param, context) {\n    return L.Util.bind(function (value) {\n      this.params[param] = value;\n      return this;\n    }, context);\n  },\n\n  initialize: function (endpoint) {\n    // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service\n    if (endpoint.request && endpoint.options) {\n      this._service = endpoint;\n      L.Util.setOptions(this, endpoint.options);\n    } else {\n      L.Util.setOptions(this, endpoint);\n      this.options.url = cleanUrl(endpoint.url);\n    }\n\n    // clone default params into this object\n    this.params = L.Util.extend({}, this.params || {});\n\n    // generate setter methods based on the setters object implimented a child class\n    if (this.setters) {\n      for (var setter in this.setters) {\n        var param = this.setters[setter];\n        this[setter] = this.generateSetter(param, this);\n      }\n    }\n  },\n\n  token: function (token) {\n    if (this._service) {\n      this._service.authenticate(token);\n    } else {\n      this.params.token = token;\n    }\n    return this;\n  },\n\n  request: function (callback, context) {\n    if (this._service) {\n      return this._service.request(this.path, this.params, callback, context);\n    }\n\n    return this._request('request', this.path, this.params, callback, context);\n  },\n\n  _request: function (method, path, params, callback, context) {\n    var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n    if ((method === 'get' || method === 'request') && !this.options.useCors) {\n      return Request.get.JSONP(url, params, callback, context);\n    }\n\n    return Request[method](url, params, callback, context);\n  }\n});\n\nexport function task (options) {\n  return new Task(options);\n}\n\nexport default task;\n","import L from 'leaflet';\nimport { Task } from './Task';\nimport Util from '../Util';\n\nexport var Query = Task.extend({\n  setters: {\n    'offset': 'offset',\n    'limit': 'limit',\n    'fields': 'outFields',\n    'precision': 'geometryPrecision',\n    'featureIds': 'objectIds',\n    'returnGeometry': 'returnGeometry',\n    'token': 'token'\n  },\n\n  path: 'query',\n\n  params: {\n    returnGeometry: true,\n    where: '1=1',\n    outSr: 4326,\n    outFields: '*'\n  },\n\n  within: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer\n    return this;\n  },\n\n  intersects: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelIntersects';\n    return this;\n  },\n\n  contains: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer\n    return this;\n  },\n\n  crosses: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelCrosses';\n    return this;\n  },\n\n  touches: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelTouches';\n    return this;\n  },\n\n  overlaps: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelOverlaps';\n    return this;\n  },\n\n  // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n  nearby: function (latlng, radius) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = [latlng.lng, latlng.lat];\n    this.params.geometryType = 'esriGeometryPoint';\n    this.params.spatialRel = 'esriSpatialRelIntersects';\n    this.params.units = 'esriSRUnit_Meter';\n    this.params.distance = radius;\n    this.params.inSr = 4326;\n    return this;\n  },\n\n  where: function (string) {\n    // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered\n    this.params.where = string;\n    return this;\n  },\n\n  between: function (start, end) {\n    this.params.time = [start.valueOf(), end.valueOf()];\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n    return this;\n  },\n\n  orderBy: function (fieldName, order) {\n    order = order || 'ASC';\n    this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : '';\n    this.params.orderByFields += ([fieldName, order]).join(' ');\n    return this;\n  },\n\n  run: function (callback, context) {\n    this._cleanParams();\n\n    // if the service is hosted on arcgis online request geojson directly\n    if (Util.isArcgisOnline(this.options.url)) {\n      this.params.f = 'geojson';\n\n      return this.request(function (error, response) {\n        this._trapSQLerrors(error);\n        callback.call(context, error, response, response);\n      }, this);\n\n    // otherwise convert it in the callback then pass it on\n    } else {\n      return this.request(function (error, response) {\n        this._trapSQLerrors(error);\n        callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n      }, this);\n    }\n  },\n\n  count: function (callback, context) {\n    this._cleanParams();\n    this.params.returnCountOnly = true;\n    return this.request(function (error, response) {\n      callback.call(this, error, (response && response.count), response);\n    }, context);\n  },\n\n  ids: function (callback, context) {\n    this._cleanParams();\n    this.params.returnIdsOnly = true;\n    return this.request(function (error, response) {\n      callback.call(this, error, (response && response.objectIds), response);\n    }, context);\n  },\n\n  // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n  bounds: function (callback, context) {\n    this._cleanParams();\n    this.params.returnExtentOnly = true;\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response);\n    }, context);\n  },\n\n  // only valid for image services\n  pixelSize: function (point) {\n    point = L.point(point);\n    this.params.pixelSize = [point.x, point.y];\n    return this;\n  },\n\n  // only valid for map services\n  layer: function (layer) {\n    this.path = layer + '/query';\n    return this;\n  },\n\n  _trapSQLerrors: function (error) {\n    if (error) {\n      if (error.code === '400') {\n        Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes');\n      }\n    }\n  },\n\n  _cleanParams: function () {\n    delete this.params.returnIdsOnly;\n    delete this.params.returnExtentOnly;\n    delete this.params.returnCountOnly;\n  },\n\n  _setGeometry: function (geometry) {\n    this.params.inSr = 4326;\n\n    // convert bounds to extent and finish\n    if (geometry instanceof L.LatLngBounds) {\n      // set geometry + geometryType\n      this.params.geometry = Util.boundsToExtent(geometry);\n      this.params.geometryType = 'esriGeometryEnvelope';\n      return;\n    }\n\n    // convert L.Marker > L.LatLng\n    if (geometry.getLatLng) {\n      geometry = geometry.getLatLng();\n    }\n\n    // convert L.LatLng to a geojson point and continue;\n    if (geometry instanceof L.LatLng) {\n      geometry = {\n        type: 'Point',\n        coordinates: [geometry.lng, geometry.lat]\n      };\n    }\n\n    // handle L.GeoJSON, pull out the first geometry\n    if (geometry instanceof L.GeoJSON) {\n      // reassign geometry to the GeoJSON value  (we are assuming that only one feature is present)\n      geometry = geometry.getLayers()[0].feature.geometry;\n      this.params.geometry = Util.geojsonToArcGIS(geometry);\n      this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n    }\n\n    // Handle L.Polyline and L.Polygon\n    if (geometry.toGeoJSON) {\n      geometry = geometry.toGeoJSON();\n    }\n\n    // handle GeoJSON feature by pulling out the geometry\n    if (geometry.type === 'Feature') {\n      // get the geometry of the geojson feature\n      geometry = geometry.geometry;\n    }\n\n    // confirm that our GeoJSON is a point, line or polygon\n    if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n      this.params.geometry = Util.geojsonToArcGIS(geometry);\n      this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n      return;\n    }\n\n    // warn the user if we havn't found a\n    /* global console */\n    Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object');\n\n    return;\n  }\n});\n\nexport function query (options) {\n  return new Query(options);\n}\n\nexport default query;\n","import { Task } from './Task';\nimport Util from '../Util';\n\nexport var Find = Task.extend({\n  setters: {\n    // method name > param name\n    'contains': 'contains',\n    'text': 'searchText',\n    'fields': 'searchFields', // denote an array or single string\n    'spatialReference': 'sr',\n    'sr': 'sr',\n    'layers': 'layers',\n    'returnGeometry': 'returnGeometry',\n    'maxAllowableOffset': 'maxAllowableOffset',\n    'precision': 'geometryPrecision',\n    'dynamicLayers': 'dynamicLayers',\n    'returnZ': 'returnZ',\n    'returnM': 'returnM',\n    'gdbVersion': 'gdbVersion',\n    'token': 'token'\n  },\n\n  path: 'find',\n\n  params: {\n    sr: 4326,\n    contains: true,\n    returnGeometry: true,\n    returnZ: true,\n    returnM: false\n  },\n\n  layerDefs: function (id, where) {\n    this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n    this.params.layerDefs += ([id, where]).join(':');\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n    return this;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n    }, context);\n  }\n});\n\nexport function find (options) {\n  return new Find(options);\n}\n\nexport default find;\n","import { Task } from './Task';\n\nexport var Identify = Task.extend({\n  path: 'identify',\n\n  between: function (start, end) {\n    this.params.time = [start.valueOf(), end.valueOf()];\n    return this;\n  }\n});\n\nexport function identify (options) {\n  return new Identify(options);\n}\n\nexport default identify;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyFeatures = Identify.extend({\n  setters: {\n    'layers': 'layers',\n    'precision': 'geometryPrecision',\n    'tolerance': 'tolerance',\n    'returnGeometry': 'returnGeometry'\n  },\n\n  params: {\n    sr: 4326,\n    layers: 'all',\n    tolerance: 3,\n    returnGeometry: true\n  },\n\n  on: function (map) {\n    var extent = Util.boundsToExtent(map.getBounds());\n    var size = map.getSize();\n    this.params.imageDisplay = [size.x, size.y, 96];\n    this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax];\n    return this;\n  },\n\n  at: function (latlng) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = [latlng.lng, latlng.lat];\n    this.params.geometryType = 'esriGeometryPoint';\n    return this;\n  },\n\n  layerDef: function (id, where) {\n    this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n    this.params.layerDefs += ([id, where]).join(':');\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor);\n    return this;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      // immediately invoke with an error\n      if (error) {\n        callback.call(context, error, undefined, response);\n        return;\n\n      // ok no error lets just assume we have features...\n      } else {\n        var featureCollection = Util.responseToFeatureCollection(response);\n        response.results = response.results.reverse();\n        for (var i = 0; i < featureCollection.features.length; i++) {\n          var feature = featureCollection.features[i];\n          feature.layerId = response.results[i].layerId;\n        }\n        callback.call(context, undefined, featureCollection, response);\n      }\n    });\n  }\n});\n\nexport function identifyFeatures (options) {\n  return new IdentifyFeatures(options);\n}\n\nexport default identifyFeatures;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyImage = Identify.extend({\n  setters: {\n    'setMosaicRule': 'mosaicRule',\n    'setRenderingRule': 'renderingRule',\n    'setPixelSize': 'pixelSize',\n    'returnCatalogItems': 'returnCatalogItems',\n    'returnGeometry': 'returnGeometry'\n  },\n\n  params: {\n    returnGeometry: false\n  },\n\n  at: function (latlng) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = JSON.stringify({\n      x: latlng.lng,\n      y: latlng.lat,\n      spatialReference: {\n        wkid: 4326\n      }\n    });\n    this.params.geometryType = 'esriGeometryPoint';\n    return this;\n  },\n\n  getMosaicRule: function () {\n    return this.params.mosaicRule;\n  },\n\n  getRenderingRule: function () {\n    return this.params.renderingRule;\n  },\n\n  getPixelSize: function () {\n    return this.params.pixelSize;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && this._responseToGeoJSON(response)), response);\n    }, this);\n  },\n\n  // get pixel data and return as geoJSON point\n  // populate catalog items (if any)\n  // merging in any catalogItemVisibilities as a propery of each feature\n  _responseToGeoJSON: function (response) {\n    var location = response.location;\n    var catalogItems = response.catalogItems;\n    var catalogItemVisibilities = response.catalogItemVisibilities;\n    var geoJSON = {\n      'pixel': {\n        'type': 'Feature',\n        'geometry': {\n          'type': 'Point',\n          'coordinates': [location.x, location.y]\n        },\n        'crs': {\n          'type': 'EPSG',\n          'properties': {\n            'code': location.spatialReference.wkid\n          }\n        },\n        'properties': {\n          'OBJECTID': response.objectId,\n          'name': response.name,\n          'value': response.value\n        },\n        'id': response.objectId\n      }\n    };\n\n    if (response.properties && response.properties.Values) {\n      geoJSON.pixel.properties.values = response.properties.Values;\n    }\n\n    if (catalogItems && catalogItems.features) {\n      geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems);\n      if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) {\n        for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) {\n          geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i];\n        }\n      }\n    }\n    return geoJSON;\n  }\n\n});\n\nexport function identifyImage (params) {\n  return new IdentifyImage(params);\n}\n\nexport default identifyImage;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Service = L.Evented.extend({\n\n  options: {\n    proxy: false,\n    useCors: cors,\n    timeout: 0\n  },\n\n  initialize: function (options) {\n    options = options || {};\n    this._requestQueue = [];\n    this._authenticating = false;\n    L.Util.setOptions(this, options);\n    this.options.url = cleanUrl(this.options.url);\n  },\n\n  get: function (path, params, callback, context) {\n    return this._request('get', path, params, callback, context);\n  },\n\n  post: function (path, params, callback, context) {\n    return this._request('post', path, params, callback, context);\n  },\n\n  request: function (path, params, callback, context) {\n    return this._request('request', path, params, callback, context);\n  },\n\n  metadata: function (callback, context) {\n    return this._request('get', '', {}, callback, context);\n  },\n\n  authenticate: function (token) {\n    this._authenticating = false;\n    this.options.token = token;\n    this._runQueue();\n    return this;\n  },\n\n  getTimeout: function () {\n    return this.options.timeout;\n  },\n\n  setTimeout: function (timeout) {\n    this.options.timeout = timeout;\n  },\n\n  _request: function (method, path, params, callback, context) {\n    this.fire('requeststart', {\n      url: this.options.url + path,\n      params: params,\n      method: method\n    }, true);\n\n    var wrappedCallback = this._createServiceCallback(method, path, params, callback, context);\n\n    if (this.options.token) {\n      params.token = this.options.token;\n    }\n\n    if (this._authenticating) {\n      this._requestQueue.push([method, path, params, callback, context]);\n      return;\n    } else {\n      var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n      if ((method === 'get' || method === 'request') && !this.options.useCors) {\n        return Request.get.JSONP(url, params, wrappedCallback, context);\n      } else {\n        return Request[method](url, params, wrappedCallback, context);\n      }\n    }\n  },\n\n  _createServiceCallback: function (method, path, params, callback, context) {\n    return L.Util.bind(function (error, response) {\n      if (error && (error.code === 499 || error.code === 498)) {\n        this._authenticating = true;\n\n        this._requestQueue.push([method, path, params, callback, context]);\n\n        // fire an event for users to handle and re-authenticate\n        this.fire('authenticationrequired', {\n          authenticate: L.Util.bind(this.authenticate, this)\n        }, true);\n\n        // if the user has access to a callback they can handle the auth error\n        error.authenticate = L.Util.bind(this.authenticate, this);\n      }\n\n      callback.call(context, error, response);\n\n      if (error) {\n        this.fire('requesterror', {\n          url: this.options.url + path,\n          params: params,\n          message: error.message,\n          code: error.code,\n          method: method\n        }, true);\n      } else {\n        this.fire('requestsuccess', {\n          url: this.options.url + path,\n          params: params,\n          response: response,\n          method: method\n        }, true);\n      }\n\n      this.fire('requestend', {\n        url: this.options.url + path,\n        params: params,\n        method: method\n      }, true);\n    }, this);\n  },\n\n  _runQueue: function () {\n    for (var i = this._requestQueue.length - 1; i >= 0; i--) {\n      var request = this._requestQueue[i];\n      var method = request.shift();\n      this[method].apply(this, request);\n    }\n    this._requestQueue = [];\n  }\n});\n\nexport function service (options) {\n  return new Service(options);\n}\n\nexport default service;\n","import { Service } from './Service';\nimport identifyFeatures from '../Tasks/IdentifyFeatures';\nimport query from '../Tasks/Query';\nimport find from '../Tasks/Find';\n\nexport var MapService = Service.extend({\n\n  identify: function () {\n    return identifyFeatures(this);\n  },\n\n  find: function () {\n    return find(this);\n  },\n\n  query: function () {\n    return query(this);\n  }\n\n});\n\nexport function mapService (options) {\n  return new MapService(options);\n}\n\nexport default mapService;\n","import { Service } from './Service';\nimport identifyImage from '../Tasks/IdentifyImage';\nimport query from '../Tasks/Query';\n\nexport var ImageService = Service.extend({\n\n  query: function () {\n    return query(this);\n  },\n\n  identify: function () {\n    return identifyImage(this);\n  }\n});\n\nexport function imageService (options) {\n  return new ImageService(options);\n}\n\nexport default imageService;\n","import { Service } from './Service';\nimport query from '../Tasks/Query';\nimport { geojsonToArcGIS } from '../Util';\n\nexport var FeatureLayerService = Service.extend({\n\n  options: {\n    idAttribute: 'OBJECTID'\n  },\n\n  query: function () {\n    return query(this);\n  },\n\n  addFeature: function (feature, callback, context) {\n    delete feature.id;\n\n    feature = geojsonToArcGIS(feature);\n\n    return this.post('addFeatures', {\n      features: [feature]\n    }, function (error, response) {\n      var result = (response && response.addResults) ? response.addResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.addResults[0].error, result);\n      }\n    }, context);\n  },\n\n  updateFeature: function (feature, callback, context) {\n    feature = geojsonToArcGIS(feature, this.options.idAttribute);\n\n    return this.post('updateFeatures', {\n      features: [feature]\n    }, function (error, response) {\n      var result = (response && response.updateResults) ? response.updateResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.updateResults[0].error, result);\n      }\n    }, context);\n  },\n\n  deleteFeature: function (id, callback, context) {\n    return this.post('deleteFeatures', {\n      objectIds: id\n    }, function (error, response) {\n      var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.deleteResults[0].error, result);\n      }\n    }, context);\n  },\n\n  deleteFeatures: function (ids, callback, context) {\n    return this.post('deleteFeatures', {\n      objectIds: ids\n    }, function (error, response) {\n      // pass back the entire array\n      var result = (response && response.deleteResults) ? response.deleteResults : undefined;\n      if (callback) {\n        callback.call(context, error || response.deleteResults[0].error, result);\n      }\n    }, context);\n  }\n});\n\nexport function featureLayerService (options) {\n  return new FeatureLayerService(options);\n}\n\nexport default featureLayerService;\n","import L from 'leaflet';\n\nexport var Logo = L.Control.extend({\n  options: {\n    position: 'bottomright',\n    marginTop: 0,\n    marginLeft: 0,\n    marginBottom: 0,\n    marginRight: 0\n  },\n\n  onAdd: function () {\n    var div = L.DomUtil.create('div', 'esri-leaflet-logo');\n    div.style.marginTop = this.options.marginTop;\n    div.style.marginLeft = this.options.marginLeft;\n    div.style.marginBottom = this.options.marginBottom;\n    div.style.marginRight = this.options.marginRight;\n    div.innerHTML = '<a href=\"http://www.esri.com\" target=\"_blank\" style=\"border: none;\"><img src=\"https://js.arcgis.com/3.13/esri/images/map/logo-sm.png\" alt=\"Powered by Esri\" style=\"border: none;\"></a>';\n\n    return div;\n  }\n});\n\nexport default function logo (options) {\n  return new Logo(options);\n}\n","import L from 'leaflet';\nimport logo from '../Controls/Logo';\nimport { jsonp } from '../Request';\nimport { pointerEvents } from '../Support';\n\nvar tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:';\n\nexport var BasemapLayer = L.TileLayer.extend({\n  statics: {\n    TILES: {\n      Streets: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      Topographic: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      Oceans: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      OceansLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      NationalGeographic: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.'\n        }\n      },\n      DarkGray: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n        }\n      },\n      DarkGrayLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n\n        }\n      },\n      Gray: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n        }\n      },\n      GrayLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      Imagery: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'\n        }\n      },\n      ImageryLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      ImageryTransportation: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      ShadedRelief: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, USGS'\n        }\n      },\n      ShadedReliefLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 12,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      Terrain: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, USGS, NOAA'\n        }\n      },\n      TerrainLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      }\n    }\n  },\n  initialize: function (key, options) {\n    var config;\n\n    // set the config variable with the appropriate config object\n    if (typeof key === 'object' && key.urlTemplate && key.options) {\n      config = key;\n    } else if (typeof key === 'string' && BasemapLayer.TILES[key]) {\n      config = BasemapLayer.TILES[key];\n    } else {\n      throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of \"Streets\", \"Topographic\", \"Oceans\", \"OceansLabels\", \"NationalGeographic\", \"Gray\", \"GrayLabels\", \"DarkGray\", \"DarkGrayLabels\", \"Imagery\", \"ImageryLabels\", \"ImageryTransportation\", \"ShadedRelief\", \"ShadedReliefLabels\", \"Terrain\" or \"TerrainLabels\"');\n    }\n\n    // merge passed options into the config options\n    var tileOptions = L.Util.extend(config.options, options);\n\n    L.Util.setOptions(this, tileOptions);\n\n    // call the initialize method on L.TileLayer to set everything up\n    L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions);\n\n    // if this basemap requires dynamic attribution set it up\n    if (config.attributionUrl) {\n      this._getAttributionData(config.attributionUrl);\n    }\n\n    this._logo = logo({\n      position: this.options.logoPosition\n    });\n  },\n\n  onAdd: function (map) {\n    if (!this.options.hideLogo && !map._hasEsriLogo) {\n      this._logo.addTo(map);\n      map._hasEsriLogo = true;\n    }\n\n    if (this.options.pane === 'esri-labels') {\n      this._initPane();\n    }\n\n    map.on('moveend', this._updateMapAttribution, this);\n\n    L.TileLayer.prototype.onAdd.call(this, map);\n  },\n\n  onRemove: function (map) {\n    // check to make sure the logo hasn't already been removed\n    if (this._logo && this._logo._container) {\n      map.removeControl(this._logo);\n      map._hasEsriLogo = false;\n    }\n\n    map.off('moveend', this._updateMapAttribution, this);\n\n    L.TileLayer.prototype.onRemove.call(this, map);\n  },\n\n  getAttribution: function () {\n    if (this.options.attribution) {\n      var attribution = '<span class=\"esri-attributions\" style=\"line-height:14px; vertical-align: -3px; text-overflow:ellipsis; white-space:nowrap; overflow:hidden; display:inline-block;\">' + this.options.attribution + '</span>';\n    }\n    return attribution;\n  },\n\n  _initPane: function () {\n    if (!this._map.getPane(this.options.pane)) {\n      var pane = this._map.createPane(this.options.pane);\n      pane.style.pointerEvents = 'none';\n      pane.style.zIndex = 500;\n    }\n  },\n\n  _getAttributionData: function (url) {\n    jsonp(url, {}, L.Util.bind(function (error, attributions) {\n      if (error) { return; }\n      this._attributions = [];\n\n      for (var c = 0; c < attributions.contributors.length; c++) {\n        var contributor = attributions.contributors[c];\n        for (var i = 0; i < contributor.coverageAreas.length; i++) {\n          var coverageArea = contributor.coverageAreas[i];\n          var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]);\n          var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]);\n          this._attributions.push({\n            attribution: contributor.attribution,\n            score: coverageArea.score,\n            bounds: L.latLngBounds(southWest, northEast),\n            minZoom: coverageArea.zoomMin,\n            maxZoom: coverageArea.zoomMax\n          });\n        }\n      }\n\n      this._attributions.sort(function (a, b) {\n        return b.score - a.score;\n      });\n\n      this._updateMapAttribution();\n    }, this));\n  },\n\n  _updateMapAttribution: function () {\n    if (this._map && this._map.attributionControl && this._attributions) {\n      var newAttributions = '';\n      var bounds = this._map.getBounds();\n      var zoom = this._map.getZoom();\n\n      for (var i = 0; i < this._attributions.length; i++) {\n        var attribution = this._attributions[i];\n        var text = attribution.attribution;\n        if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) {\n          newAttributions += (', ' + text);\n        }\n      }\n      newAttributions = newAttributions.substr(2);\n      var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions');\n\n      attributionElement.innerHTML = newAttributions;\n      attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px';\n\n      this.fire('attributionupdated', {\n        attribution: newAttributions\n      });\n    }\n  }\n});\n\nexport function basemapLayer (key, options) {\n  return new BasemapLayer(key, options);\n}\n\nexport default basemapLayer;\n","import L from 'leaflet';\nimport {warn, cleanUrl} from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var TiledMapLayer = L.TileLayer.extend({\n  options: {\n    zoomOffsetAllowance: 0.1\n  },\n\n  statics: {\n    MercatorZoomLevels: {\n      '0': 156543.03392799999,\n      '1': 78271.516963999893,\n      '2': 39135.758482000099,\n      '3': 19567.879240999901,\n      '4': 9783.9396204999593,\n      '5': 4891.9698102499797,\n      '6': 2445.9849051249898,\n      '7': 1222.9924525624899,\n      '8': 611.49622628138002,\n      '9': 305.74811314055802,\n      '10': 152.874056570411,\n      '11': 76.437028285073197,\n      '12': 38.218514142536598,\n      '13': 19.109257071268299,\n      '14': 9.5546285356341496,\n      '15': 4.7773142679493699,\n      '16': 2.38865713397468,\n      '17': 1.1943285668550501,\n      '18': 0.59716428355981699,\n      '19': 0.29858214164761698,\n      '20': 0.14929107082381,\n      '21': 0.07464553541191,\n      '22': 0.0373227677059525,\n      '23': 0.0186613838529763\n    }\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    options = L.Util.setOptions(this, options);\n\n    // set the urls\n    this.tileUrl = options.url + 'tile/{z}/{y}/{x}';\n    this.service = mapService(options);\n    this.service.addEventParent(this);\n\n    var arcgisonline = new RegExp(/tiles.arcgis(online)?\\.com/g);\n    if (arcgisonline.test(options.url)) {\n      this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');\n      options.subdomains = ['1', '2', '3', '4'];\n    }\n\n    if (this.options.token) {\n      this.tileUrl += ('?token=' + this.options.token);\n    }\n\n    // init layer by calling TileLayers initialize method\n    L.TileLayer.prototype.initialize.call(this, this.tileUrl, options);\n  },\n\n  getTileUrl: function (tilePoint) {\n    return L.Util.template(this.tileUrl, L.extend({\n      s: this._getSubdomain(tilePoint),\n      z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level\n      x: tilePoint.x,\n      y: tilePoint.y\n    }, this.options));\n  },\n\n  createTile: function (coords, done) {\n    var tile = document.createElement('img');\n\n    L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile));\n    L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile));\n\n    if (this.options.crossOrigin) {\n      tile.crossOrigin = '';\n    }\n\n    /*\n     Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons\n     http://www.w3.org/TR/WCAG20-TECHS/H67\n    */\n    tile.alt = '';\n\n    // if there is no lod map or an lod map with a proper zoom load the tile\n    // otherwise wait for the lod map to become available\n    if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) {\n      tile.src = this.getTileUrl(coords);\n    } else {\n      this.once('lodmap', function () {\n        tile.src = this.getTileUrl(coords);\n      }, this);\n    }\n\n    return tile;\n  },\n\n  onAdd: function (map) {\n    if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) {\n      this._lodMap = {};\n      this.metadata(function (error, metadata) {\n        if (!error) {\n          var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid;\n          if (sr === 102100 || sr === 3857) {\n            // create the zoom level data\n            var arcgisLODs = metadata.tileInfo.lods;\n            var correctResolutions = TiledMapLayer.MercatorZoomLevels;\n\n            for (var i = 0; i < arcgisLODs.length; i++) {\n              var arcgisLOD = arcgisLODs[i];\n              for (var ci in correctResolutions) {\n                var correctRes = correctResolutions[ci];\n\n                if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) {\n                  this._lodMap[ci] = arcgisLOD.level;\n                  break;\n                }\n              }\n            }\n\n            this.fire('lodmap');\n          } else {\n            warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html');\n          }\n        }\n      }, this);\n    }\n\n    L.TileLayer.prototype.onAdd.call(this, map);\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  find: function () {\n    return this.service.find();\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  authenticate: function (token) {\n    var tokenQs = '?token=' + token;\n    this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs;\n    this.options.token = token;\n    this.service.authenticate(token);\n    return this;\n  },\n\n  _withinPercentage: function (a, b, percentage) {\n    var diff = Math.abs((a / b) - 1);\n    return diff < percentage;\n  }\n});\n\nexport function tiledMapLayer (url, options) {\n  return new TiledMapLayer(url, options);\n}\n\nexport default tiledMapLayer;\n","import L from 'leaflet';\nimport {cors} from '../Support';\n\nvar Overlay = L.ImageOverlay.extend({\n  onAdd: function (map) {\n    this._topLeft = map.getPixelBounds().min;\n    L.ImageOverlay.prototype.onAdd.call(this, map);\n  },\n  _reset: function () {\n    if (this._map.options.crs === L.CRS.EPSG3857) {\n      L.ImageOverlay.prototype._reset.call(this);\n    } else {\n      L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin()));\n    }\n  }\n});\n\nexport var RasterLayer = L.Layer.extend({\n\n  options: {\n    opacity: 1,\n    position: 'front',\n    f: 'image',\n    useCors: cors,\n    attribution: null,\n    interactive: false,\n    alt: ''\n  },\n\n  onAdd: function (map) {\n    this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n\n    map.on('moveend', this._update, this);\n\n    // if we had an image loaded and it matches the\n    // current bounds show the image otherwise remove it\n    if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) {\n      map.addLayer(this._currentImage);\n    } else if (this._currentImage) {\n      this._map.removeLayer(this._currentImage);\n      this._currentImage = null;\n    }\n\n    this._update();\n\n    if (this._popup) {\n      this._map.on('click', this._getPopupData, this);\n      this._map.on('dblclick', this._resetPopupState, this);\n    }\n  },\n\n  onRemove: function (map) {\n    if (this._currentImage) {\n      this._map.removeLayer(this._currentImage);\n    }\n\n    if (this._popup) {\n      this._map.off('click', this._getPopupData, this);\n      this._map.off('dblclick', this._resetPopupState, this);\n    }\n\n    this._map.off('moveend', this._update, this);\n  },\n\n  bindPopup: function (fn, popupOptions) {\n    this._shouldRenderPopup = false;\n    this._lastClick = false;\n    this._popup = L.popup(popupOptions);\n    this._popupFunction = fn;\n    if (this._map) {\n      this._map.on('click', this._getPopupData, this);\n      this._map.on('dblclick', this._resetPopupState, this);\n    }\n    return this;\n  },\n\n  unbindPopup: function () {\n    if (this._map) {\n      this._map.closePopup(this._popup);\n      this._map.off('click', this._getPopupData, this);\n      this._map.off('dblclick', this._resetPopupState, this);\n    }\n    this._popup = false;\n    return this;\n  },\n\n  bringToFront: function () {\n    this.options.position = 'front';\n    if (this._currentImage) {\n      this._currentImage.bringToFront();\n    }\n    return this;\n  },\n\n  bringToBack: function () {\n    this.options.position = 'back';\n    if (this._currentImage) {\n      this._currentImage.bringToBack();\n    }\n    return this;\n  },\n\n  getAttribution: function () {\n    return this.options.attribution;\n  },\n\n  getOpacity: function () {\n    return this.options.opacity;\n  },\n\n  setOpacity: function (opacity) {\n    this.options.opacity = opacity;\n    this._currentImage.setOpacity(opacity);\n    return this;\n  },\n\n  getTimeRange: function () {\n    return [this.options.from, this.options.to];\n  },\n\n  setTimeRange: function (from, to) {\n    this.options.from = from;\n    this.options.to = to;\n    this._update();\n    return this;\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  authenticate: function (token) {\n    this.service.authenticate(token);\n    return this;\n  },\n\n  _renderImage: function (url, bounds) {\n    if (this._map) {\n      // create a new image overlay and add it to the map\n      // to start loading the image\n      // opacity is 0 while the image is loading\n      var image = new Overlay(url, bounds, {\n        opacity: 0,\n        crossOrigin: this.options.useCors,\n        alt: this.options.alt,\n        pane: this.options.pane || this.getPane(),\n        interactive: this.options.interactive\n      }).addTo(this._map);\n\n      // once the image loads\n      image.once('load', function (e) {\n        if (this._map) {\n          var newImage = e.target;\n          var oldImage = this._currentImage;\n\n          // if the bounds of this image matches the bounds that\n          // _renderImage was called with and we have a map with the same bounds\n          // hide the old image if there is one and set the opacity\n          // of the new image otherwise remove the new image\n          if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) {\n            this._currentImage = newImage;\n\n            if (this.options.position === 'front') {\n              this.bringToFront();\n            } else {\n              this.bringToBack();\n            }\n\n            if (this._map && this._currentImage._map) {\n              this._currentImage.setOpacity(this.options.opacity);\n            } else {\n              this._currentImage._map.removeLayer(this._currentImage);\n            }\n\n            if (oldImage && this._map) {\n              this._map.removeLayer(oldImage);\n            }\n\n            if (oldImage && oldImage._map) {\n              oldImage._map.removeLayer(oldImage);\n            }\n          } else {\n            this._map.removeLayer(newImage);\n          }\n        }\n\n        this.fire('load', {\n          bounds: bounds\n        });\n      }, this);\n\n      this.fire('loading', {\n        bounds: bounds\n      });\n    }\n  },\n\n  _update: function () {\n    if (!this._map) {\n      return;\n    }\n\n    var zoom = this._map.getZoom();\n    var bounds = this._map.getBounds();\n\n    if (this._animatingZoom) {\n      return;\n    }\n\n    if (this._map._panTransition && this._map._panTransition._inProgress) {\n      return;\n    }\n\n    if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n      this._currentImage._map.removeLayer(this._currentImage);\n      return;\n    }\n\n    var params = this._buildExportParams();\n\n    this._requestExport(params, bounds);\n  },\n\n  _renderPopup: function (latlng, error, results, response) {\n    latlng = L.latLng(latlng);\n    if (this._shouldRenderPopup && this._lastClick.equals(latlng)) {\n      // add the popup to the map where the mouse was clicked at\n      var content = this._popupFunction(error, results, response);\n      if (content) {\n        this._popup.setLatLng(latlng).setContent(content).openOn(this._map);\n      }\n    }\n  },\n\n  _resetPopupState: function (e) {\n    this._shouldRenderPopup = false;\n    this._lastClick = e.latlng;\n  }\n});\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport imageService from '../Services/ImageService';\n\nexport var ImageMapLayer = RasterLayer.extend({\n\n  options: {\n    updateInterval: 150,\n    format: 'jpgpng',\n    transparent: true,\n    f: 'json'\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    this.service = imageService(options);\n    this.service.addEventParent(this);\n\n    L.Util.setOptions(this, options);\n  },\n\n  setPixelType: function (pixelType) {\n    this.options.pixelType = pixelType;\n    this._update();\n    return this;\n  },\n\n  getPixelType: function () {\n    return this.options.pixelType;\n  },\n\n  setBandIds: function (bandIds) {\n    if (L.Util.isArray(bandIds)) {\n      this.options.bandIds = bandIds.join(',');\n    } else {\n      this.options.bandIds = bandIds.toString();\n    }\n    this._update();\n    return this;\n  },\n\n  getBandIds: function () {\n    return this.options.bandIds;\n  },\n\n  setNoData: function (noData, noDataInterpretation) {\n    if (L.Util.isArray(noData)) {\n      this.options.noData = noData.join(',');\n    } else {\n      this.options.noData = noData.toString();\n    }\n    if (noDataInterpretation) {\n      this.options.noDataInterpretation = noDataInterpretation;\n    }\n    this._update();\n    return this;\n  },\n\n  getNoData: function () {\n    return this.options.noData;\n  },\n\n  getNoDataInterpretation: function () {\n    return this.options.noDataInterpretation;\n  },\n\n  setRenderingRule: function (renderingRule) {\n    this.options.renderingRule = renderingRule;\n    this._update();\n  },\n\n  getRenderingRule: function () {\n    return this.options.renderingRule;\n  },\n\n  setMosaicRule: function (mosaicRule) {\n    this.options.mosaicRule = mosaicRule;\n    this._update();\n  },\n\n  getMosaicRule: function () {\n    return this.options.mosaicRule;\n  },\n\n  _getPopupData: function (e) {\n    var callback = L.Util.bind(function (error, results, response) {\n      if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n      setTimeout(L.Util.bind(function () {\n        this._renderPopup(e.latlng, error, results, response);\n      }, this), 300);\n    }, this);\n\n    var identifyRequest = this.identify().at(e.latlng);\n\n    // set mosaic rule for identify task if it is set for layer\n    if (this.options.mosaicRule) {\n      identifyRequest.setMosaicRule(this.options.mosaicRule);\n      // @TODO: force return catalog items too?\n    }\n\n    // @TODO: set rendering rule? Not sure,\n    // sometimes you want raw pixel values\n    // if (this.options.renderingRule) {\n    //   identifyRequest.setRenderingRule(this.options.renderingRule);\n    // }\n\n    identifyRequest.run(callback);\n\n    // set the flags to show the popup\n    this._shouldRenderPopup = true;\n    this._lastClick = e.latlng;\n  },\n\n  _buildExportParams: function () {\n    var bounds = this._map.getBounds();\n    var size = this._map.getSize();\n    var ne = this._map.options.crs.project(bounds._northEast);\n    var sw = this._map.options.crs.project(bounds._southWest);\n    var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n    var params = {\n      bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n      size: size.x + ',' + size.y,\n      format: this.options.format,\n      transparent: this.options.transparent,\n      bboxSR: sr,\n      imageSR: sr\n    };\n\n    if (this.options.from && this.options.to) {\n      params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n    }\n\n    if (this.options.pixelType) {\n      params.pixelType = this.options.pixelType;\n    }\n\n    if (this.options.interpolation) {\n      params.interpolation = this.options.interpolation;\n    }\n\n    if (this.options.compressionQuality) {\n      params.compressionQuality = this.options.compressionQuality;\n    }\n\n    if (this.options.bandIds) {\n      params.bandIds = this.options.bandIds;\n    }\n\n    if (this.options.noData) {\n      params.noData = this.options.noData;\n    }\n\n    if (this.options.noDataInterpretation) {\n      params.noDataInterpretation = this.options.noDataInterpretation;\n    }\n\n    if (this.service.options.token) {\n      params.token = this.service.options.token;\n    }\n\n    if (this.options.renderingRule) {\n      params.renderingRule = JSON.stringify(this.options.renderingRule);\n    }\n\n    if (this.options.mosaicRule) {\n      params.mosaicRule = JSON.stringify(this.options.mosaicRule);\n    }\n\n    return params;\n  },\n\n  _requestExport: function (params, bounds) {\n    if (this.options.f === 'json') {\n      this.service.request('exportImage', params, function (error, response) {\n        if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n        this._renderImage(response.href, bounds);\n      }, this);\n    } else {\n      params.f = 'image';\n      this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds);\n    }\n  }\n});\n\nexport function imageMapLayer (url, options) {\n  return new ImageMapLayer(url, options);\n}\n\nexport default imageMapLayer;\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var DynamicMapLayer = RasterLayer.extend({\n\n  options: {\n    updateInterval: 150,\n    layers: false,\n    layerDefs: false,\n    timeOptions: false,\n    format: 'png24',\n    transparent: true,\n    f: 'json'\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    this.service = mapService(options);\n    this.service.addEventParent(this);\n\n    if ((options.proxy || options.token) && options.f !== 'json') {\n      options.f = 'json';\n    }\n    L.Util.setOptions(this, options);\n  },\n\n  getDynamicLayers: function () {\n    return this.options.dynamicLayers;\n  },\n\n  setDynamicLayers: function (dynamicLayers) {\n    this.options.dynamicLayers = dynamicLayers;\n    this._update();\n    return this;\n  },\n\n  getLayers: function () {\n    return this.options.layers;\n  },\n\n  setLayers: function (layers) {\n    this.options.layers = layers;\n    this._update();\n    return this;\n  },\n\n  getLayerDefs: function () {\n    return this.options.layerDefs;\n  },\n\n  setLayerDefs: function (layerDefs) {\n    this.options.layerDefs = layerDefs;\n    this._update();\n    return this;\n  },\n\n  getTimeOptions: function () {\n    return this.options.timeOptions;\n  },\n\n  setTimeOptions: function (timeOptions) {\n    this.options.timeOptions = timeOptions;\n    this._update();\n    return this;\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  find: function () {\n    return this.service.find();\n  },\n\n  _getPopupData: function (e) {\n    var callback = L.Util.bind(function (error, featureCollection, response) {\n      if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n      setTimeout(L.Util.bind(function () {\n        this._renderPopup(e.latlng, error, featureCollection, response);\n      }, this), 300);\n    }, this);\n\n    var identifyRequest = this.identify().on(this._map).at(e.latlng);\n\n    if (this.options.layers) {\n      identifyRequest.layers('visible:' + this.options.layers.join(','));\n    } else {\n      identifyRequest.layers('visible');\n    }\n\n    identifyRequest.run(callback);\n\n    // set the flags to show the popup\n    this._shouldRenderPopup = true;\n    this._lastClick = e.latlng;\n  },\n\n  _buildExportParams: function () {\n    var bounds = this._map.getBounds();\n    var size = this._map.getSize();\n    var ne = this._map.options.crs.project(bounds.getNorthEast());\n    var sw = this._map.options.crs.project(bounds.getSouthWest());\n    var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n    // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n    var top = this._map.latLngToLayerPoint(bounds._northEast);\n    var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n    if (top.y > 0 || bottom.y < size.y) {\n      size.y = bottom.y - top.y;\n    }\n\n    var params = {\n      bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n      size: size.x + ',' + size.y,\n      dpi: 96,\n      format: this.options.format,\n      transparent: this.options.transparent,\n      bboxSR: sr,\n      imageSR: sr\n    };\n\n    if (this.options.dynamicLayers) {\n      params.dynamicLayers = this.options.dynamicLayers;\n    }\n\n    if (this.options.layers) {\n      params.layers = 'show:' + this.options.layers.join(',');\n    }\n\n    if (this.options.layerDefs) {\n      params.layerDefs = JSON.stringify(this.options.layerDefs);\n    }\n\n    if (this.options.timeOptions) {\n      params.timeOptions = JSON.stringify(this.options.timeOptions);\n    }\n\n    if (this.options.from && this.options.to) {\n      params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n    }\n\n    if (this.service.options.token) {\n      params.token = this.service.options.token;\n    }\n\n    return params;\n  },\n\n  _requestExport: function (params, bounds) {\n    if (this.options.f === 'json') {\n      this.service.request('export', params, function (error, response) {\n        if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n        this._renderImage(response.href, bounds);\n      }, this);\n    } else {\n      params.f = 'image';\n      this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds);\n    }\n  }\n});\n\nexport function dynamicMapLayer (url, options) {\n  return new DynamicMapLayer(url, options);\n}\n\nexport default dynamicMapLayer;\n","import L from 'leaflet';\n\nvar VirtualGrid = L.Layer.extend({\n\n  options: {\n    cellSize: 512,\n    updateInterval: 150\n  },\n\n  initialize: function (options) {\n    options = L.setOptions(this, options);\n    this._ok = true;\n  },\n\n  onAdd: function (map) {\n    this._map = map;\n    this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n    this._reset();\n    this._update();\n  },\n\n  onRemove: function () {\n    this._map.removeEventListener(this.getEvents(), this);\n    this._removeCells();\n  },\n\n  getEvents: function () {\n    var events = {\n      moveend: this._update,\n      movestart: this._start,\n      zoomend: this._reset\n    };\n\n    return events;\n  },\n\n  addTo: function (map) {\n    map.addLayer(this);\n    return this;\n  },\n\n  removeFrom: function (map) {\n    map.removeLayer(this);\n    return this;\n  },\n\n  _start: function () {\n    this._ok = true;\n  },\n\n  _reset: function () {\n    if (!this._ok) {\n      return;\n    }\n\n    this._removeCells();\n\n    this._cells = {};\n    this._activeCells = {};\n    this._cellsToLoad = 0;\n    this._cellsTotal = 0;\n    this._cellNumBounds = this._getCellNumBounds();\n\n    this._resetWrap();\n    this._zooming = false;\n  },\n\n  _resetWrap: function () {\n    var map = this._map;\n    var crs = map.options.crs;\n\n    if (crs.infinite) { return; }\n\n    var cellSize = this._getCellSize();\n\n    if (crs.wrapLng) {\n      this._wrapLng = [\n        Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize),\n        Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize)\n      ];\n    }\n\n    if (crs.wrapLat) {\n      this._wrapLat = [\n        Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize),\n        Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize)\n      ];\n    }\n  },\n\n  _getCellSize: function () {\n    return this.options.cellSize;\n  },\n\n  _update: function () {\n    if (!this._ok) {\n      return;\n    }\n\n    if (!this._map) {\n      return;\n    }\n\n    var bounds = this._map.getPixelBounds();\n    var cellSize = this._getCellSize();\n\n    // cell coordinates range for the current view\n    var cellBounds = L.bounds(\n      bounds.min.divideBy(cellSize).floor(),\n      bounds.max.divideBy(cellSize).floor());\n\n    this._removeOtherCells(cellBounds);\n    this._addCells(cellBounds);\n\n    this.fire('cellsupdated');\n\n    this._ok = false;\n  },\n\n  _addCells: function (bounds) {\n    var queue = [];\n    var center = bounds.getCenter();\n    var zoom = this._map.getZoom();\n\n    var j, i, coords;\n    // create a queue of coordinates to load cells from\n    for (j = bounds.min.y; j <= bounds.max.y; j++) {\n      for (i = bounds.min.x; i <= bounds.max.x; i++) {\n        coords = L.point(i, j);\n        coords.z = zoom;\n\n        if (this._isValidCell(coords)) {\n          queue.push(coords);\n        }\n      }\n    }\n\n    var cellsToLoad = queue.length;\n\n    if (cellsToLoad === 0) { return; }\n\n    this._cellsToLoad += cellsToLoad;\n    this._cellsTotal += cellsToLoad;\n\n    // sort cell queue to load cells in order of their distance to center\n    queue.sort(function (a, b) {\n      return a.distanceTo(center) - b.distanceTo(center);\n    });\n\n    for (i = 0; i < cellsToLoad; i++) {\n      this._addCell(queue[i]);\n    }\n  },\n\n  _isValidCell: function (coords) {\n    var crs = this._map.options.crs;\n\n    if (!crs.infinite) {\n      // don't load cell if it's out of bounds and not wrapped\n      var bounds = this._cellNumBounds;\n      if (\n        (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) ||\n        (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y))\n      ) {\n        return false;\n      }\n    }\n\n    if (!this.options.bounds) {\n      return true;\n    }\n\n    // don't load cell if it doesn't intersect the bounds in options\n    var cellBounds = this._cellCoordsToBounds(coords);\n    return L.latLngBounds(this.options.bounds).intersects(cellBounds);\n  },\n\n  // converts cell coordinates to its geographical bounds\n  _cellCoordsToBounds: function (coords) {\n    var map = this._map;\n    var cellSize = this.options.cellSize;\n    var nwPoint = coords.multiplyBy(cellSize);\n    var sePoint = nwPoint.add([cellSize, cellSize]);\n    var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z));\n    var se = map.wrapLatLng(map.unproject(sePoint, coords.z));\n\n    return L.latLngBounds(nw, se);\n  },\n\n  // converts cell coordinates to key for the cell cache\n  _cellCoordsToKey: function (coords) {\n    return coords.x + ':' + coords.y;\n  },\n\n  // converts cell cache key to coordiantes\n  _keyToCellCoords: function (key) {\n    var kArr = key.split(':');\n    var x = parseInt(kArr[0], 10);\n    var y = parseInt(kArr[1], 10);\n\n    return L.point(x, y);\n  },\n\n  // remove any present cells that are off the specified bounds\n  _removeOtherCells: function (bounds) {\n    for (var key in this._cells) {\n      if (!bounds.contains(this._keyToCellCoords(key))) {\n        this._removeCell(key);\n      }\n    }\n  },\n\n  _removeCell: function (key) {\n    var cell = this._activeCells[key];\n\n    if (cell) {\n      delete this._activeCells[key];\n\n      if (this.cellLeave) {\n        this.cellLeave(cell.bounds, cell.coords);\n      }\n\n      this.fire('cellleave', {\n        bounds: cell.bounds,\n        coords: cell.coords\n      });\n    }\n  },\n\n  _removeCells: function () {\n    for (var key in this._cells) {\n      var bounds = this._cells[key].bounds;\n      var coords = this._cells[key].coords;\n\n      if (this.cellLeave) {\n        this.cellLeave(bounds, coords);\n      }\n\n      this.fire('cellleave', {\n        bounds: bounds,\n        coords: coords\n      });\n    }\n  },\n\n  _addCell: function (coords) {\n    // wrap cell coords if necessary (depending on CRS)\n    this._wrapCoords(coords);\n\n    // generate the cell key\n    var key = this._cellCoordsToKey(coords);\n\n    // get the cell from the cache\n    var cell = this._cells[key];\n    // if this cell should be shown as isnt active yet (enter)\n\n    if (cell && !this._activeCells[key]) {\n      if (this.cellEnter) {\n        this.cellEnter(cell.bounds, coords);\n      }\n\n      this.fire('cellenter', {\n        bounds: cell.bounds,\n        coords: coords\n      });\n\n      this._activeCells[key] = cell;\n    }\n\n    // if we dont have this cell in the cache yet (create)\n    if (!cell) {\n      cell = {\n        coords: coords,\n        bounds: this._cellCoordsToBounds(coords)\n      };\n\n      this._cells[key] = cell;\n      this._activeCells[key] = cell;\n\n      if (this.createCell) {\n        this.createCell(cell.bounds, coords);\n      }\n\n      this.fire('cellcreate', {\n        bounds: cell.bounds,\n        coords: coords\n      });\n    }\n  },\n\n  _wrapCoords: function (coords) {\n    coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x;\n    coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y;\n  },\n\n  // get the global cell coordinates range for the current zoom\n  _getCellNumBounds: function () {\n    var bounds = this._map.getPixelWorldBounds();\n    var size = this._getCellSize();\n\n    return bounds ? L.bounds(\n        bounds.min.divideBy(size).floor(),\n        bounds.max.divideBy(size).ceil().subtract([1, 1])) : null;\n  }\n});\n\nexport default VirtualGrid;\n","function BinarySearchIndex (values) {\n  this.values = [].concat(values || []);\n}\n\nBinarySearchIndex.prototype.query = function (value) {\n  var index = this.getIndex(value);\n  return this.values[index];\n};\n\nBinarySearchIndex.prototype.getIndex = function getIndex (value) {\n  if (this.dirty) {\n    this.sort();\n  }\n\n  var minIndex = 0;\n  var maxIndex = this.values.length - 1;\n  var currentIndex;\n  var currentElement;\n\n  while (minIndex <= maxIndex) {\n    currentIndex = (minIndex + maxIndex) / 2 | 0;\n    currentElement = this.values[Math.round(currentIndex)];\n    if (+currentElement.value < +value) {\n      minIndex = currentIndex + 1;\n    } else if (+currentElement.value > +value) {\n      maxIndex = currentIndex - 1;\n    } else {\n      return currentIndex;\n    }\n  }\n\n  return Math.abs(~maxIndex);\n};\n\nBinarySearchIndex.prototype.between = function between (start, end) {\n  var startIndex = this.getIndex(start);\n  var endIndex = this.getIndex(end);\n\n  if (startIndex === 0 && endIndex === 0) {\n    return [];\n  }\n\n  while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) {\n    startIndex--;\n  }\n\n  while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) {\n    endIndex++;\n  }\n\n  if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) {\n    endIndex++;\n  }\n\n  return this.values.slice(startIndex, endIndex);\n};\n\nBinarySearchIndex.prototype.insert = function insert (item) {\n  this.values.splice(this.getIndex(item.value), 0, item);\n  return this;\n};\n\nBinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) {\n  this.values = this.values.concat([].concat(items || []));\n\n  if (sort) {\n    this.sort();\n  } else {\n    this.dirty = true;\n  }\n\n  return this;\n};\n\nBinarySearchIndex.prototype.sort = function sort () {\n  this.values.sort(function (a, b) {\n    return +b.value - +a.value;\n  }).reverse();\n  this.dirty = false;\n  return this;\n};\n\nexport default BinarySearchIndex;\n","import L from 'leaflet';\nimport featureLayerService from '../../Services/FeatureLayerService';\nimport { cleanUrl, warn } from '../../Util';\nimport VirtualGrid from 'leaflet-virtual-grid';\nimport BinarySearchIndex from 'tiny-binary-search';\n\nexport var FeatureManager = VirtualGrid.extend({\n  /**\n   * Options\n   */\n\n  options: {\n    attribution: null,\n    where: '1=1',\n    fields: ['*'],\n    from: false,\n    to: false,\n    timeField: false,\n    timeFilterMode: 'server',\n    simplifyFactor: 0,\n    precision: 6\n  },\n\n  /**\n   * Constructor\n   */\n\n  initialize: function (options) {\n    VirtualGrid.prototype.initialize.call(this, options);\n\n    options.url = cleanUrl(options.url);\n    options = L.setOptions(this, options);\n\n    this.service = featureLayerService(options);\n    this.service.addEventParent(this);\n\n    // use case insensitive regex to look for common fieldnames used for indexing\n    if (this.options.fields[0] !== '*') {\n      var oidCheck = false;\n      for (var i = 0; i < this.options.fields.length; i++) {\n        if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) {\n          oidCheck = true;\n        }\n      }\n      if (oidCheck === false) {\n        warn('no known esriFieldTypeOID field detected in fields Array.  Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.');\n      }\n    }\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      this._startTimeIndex = new BinarySearchIndex();\n      this._endTimeIndex = new BinarySearchIndex();\n    } else if (this.options.timeField) {\n      this._timeIndex = new BinarySearchIndex();\n    }\n\n    this._cache = {};\n    this._currentSnapshot = []; // cache of what layers should be active\n    this._activeRequests = 0;\n  },\n\n  /**\n   * Layer Interface\n   */\n\n  onAdd: function (map) {\n    map.on('zoomend', this._handleZoomChange, this);\n\n    return VirtualGrid.prototype.onAdd.call(this, map);\n  },\n\n  onRemove: function (map) {\n    map.off('zoomend', this._handleZoomChange, this);\n\n    return VirtualGrid.prototype.onRemove.call(this, map);\n  },\n\n  getAttribution: function () {\n    return this.options.attribution;\n  },\n\n  /**\n   * Feature Management\n   */\n\n  createCell: function (bounds, coords) {\n    this._requestFeatures(bounds, coords);\n  },\n\n  _requestFeatures: function (bounds, coords, callback) {\n    this._activeRequests++;\n\n    // our first active request fires loading\n    if (this._activeRequests === 1) {\n      this.fire('loading', {\n        bounds: bounds\n      }, true);\n    }\n\n    return this._buildQuery(bounds).run(function (error, featureCollection, response) {\n      if (response && response.exceededTransferLimit) {\n        this.fire('drawlimitexceeded');\n      }\n\n      // no error, features\n      if (!error && featureCollection && featureCollection.features.length) {\n        // schedule adding features until the next animation frame\n        L.Util.requestAnimFrame(L.Util.bind(function () {\n          this._addFeatures(featureCollection.features, coords);\n          this._postProcessFeatures(bounds);\n        }, this));\n      }\n\n      // no error, no features\n      if (!error && featureCollection && !featureCollection.features.length) {\n        this._postProcessFeatures(bounds);\n      }\n\n      if (error) {\n        this._postProcessFeatures(bounds);\n      }\n\n      if (callback) {\n        callback.call(this, error, featureCollection);\n      }\n    }, this);\n  },\n\n  _postProcessFeatures: function (bounds) {\n    // deincriment the request counter now that we have processed features\n    this._activeRequests--;\n\n    // if there are no more active requests fire a load event for this view\n    if (this._activeRequests <= 0) {\n      this.fire('load', {\n        bounds: bounds\n      });\n    }\n  },\n\n  _cacheKey: function (coords) {\n    return coords.z + ':' + coords.x + ':' + coords.y;\n  },\n\n  _addFeatures: function (features, coords) {\n    var key = this._cacheKey(coords);\n    this._cache[key] = this._cache[key] || [];\n\n    for (var i = features.length - 1; i >= 0; i--) {\n      var id = features[i].id;\n      this._currentSnapshot.push(id);\n      this._cache[key].push(id);\n    }\n\n    if (this.options.timeField) {\n      this._buildTimeIndexes(features);\n    }\n\n    // need to PR removal of the logic below too...\n    // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102\n\n    this.createLayers(features);\n  },\n\n  _buildQuery: function (bounds) {\n    var query = this.service.query()\n      .intersects(bounds)\n      .where(this.options.where)\n      .fields(this.options.fields)\n      .precision(this.options.precision);\n\n    if (this.options.simplifyFactor) {\n      query.simplify(this._map, this.options.simplifyFactor);\n    }\n\n    if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) {\n      query.between(this.options.from, this.options.to);\n    }\n\n    return query;\n  },\n\n  /**\n   * Where Methods\n   */\n\n  setWhere: function (where, callback, context) {\n    this.options.where = (where && where.length) ? where : '1=1';\n\n    var oldSnapshot = [];\n    var newSnapshot = [];\n    var pendingRequests = 0;\n    var requestError = null;\n    var requestCallback = L.Util.bind(function (error, featureCollection) {\n      if (error) {\n        requestError = error;\n      }\n\n      if (featureCollection) {\n        for (var i = featureCollection.features.length - 1; i >= 0; i--) {\n          newSnapshot.push(featureCollection.features[i].id);\n        }\n      }\n\n      pendingRequests--;\n\n      if (pendingRequests <= 0) {\n        this._currentSnapshot = newSnapshot;\n        // schedule adding features for the next animation frame\n        L.Util.requestAnimFrame(L.Util.bind(function () {\n          this.removeLayers(oldSnapshot);\n          this.addLayers(newSnapshot);\n          if (callback) {\n            callback.call(context, requestError);\n          }\n        }, this));\n      }\n    }, this);\n\n    for (var i = this._currentSnapshot.length - 1; i >= 0; i--) {\n      oldSnapshot.push(this._currentSnapshot[i]);\n    }\n\n    for (var key in this._activeCells) {\n      pendingRequests++;\n      var coords = this._keyToCellCoords(key);\n      var bounds = this._cellCoordsToBounds(coords);\n      this._requestFeatures(bounds, key, requestCallback);\n    }\n\n    return this;\n  },\n\n  getWhere: function () {\n    return this.options.where;\n  },\n\n  /**\n   * Time Range Methods\n   */\n\n  getTimeRange: function () {\n    return [this.options.from, this.options.to];\n  },\n\n  setTimeRange: function (from, to, callback, context) {\n    var oldFrom = this.options.from;\n    var oldTo = this.options.to;\n    var pendingRequests = 0;\n    var requestError = null;\n    var requestCallback = L.Util.bind(function (error) {\n      if (error) {\n        requestError = error;\n      }\n      this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n      pendingRequests--;\n\n      if (callback && pendingRequests <= 0) {\n        callback.call(context, requestError);\n      }\n    }, this);\n\n    this.options.from = from;\n    this.options.to = to;\n\n    this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n    if (this.options.timeFilterMode === 'server') {\n      for (var key in this._activeCells) {\n        pendingRequests++;\n        var coords = this._keyToCellCoords(key);\n        var bounds = this._cellCoordsToBounds(coords);\n        this._requestFeatures(bounds, key, requestCallback);\n      }\n    }\n\n    return this;\n  },\n\n  refresh: function () {\n    for (var key in this._activeCells) {\n      var coords = this._keyToCellCoords(key);\n      var bounds = this._cellCoordsToBounds(coords);\n      this._requestFeatures(bounds, key);\n    }\n\n    if (this.redraw) {\n      this.once('load', function () {\n        this.eachFeature(function (layer) {\n          this._redraw(layer.feature.id);\n        }, this);\n      }, this);\n    }\n  },\n\n  _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) {\n    var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot;\n    var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo);\n\n    if (layersToAdd.indexOf) {\n      for (var i = 0; i < layersToAdd.length; i++) {\n        var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]);\n        if (shouldRemoveLayer >= 0) {\n          layersToRemove.splice(shouldRemoveLayer, 1);\n        }\n      }\n    }\n\n    // schedule adding features until the next animation frame\n    L.Util.requestAnimFrame(L.Util.bind(function () {\n      this.removeLayers(layersToRemove);\n      this.addLayers(layersToAdd);\n    }, this));\n  },\n\n  _getFeaturesInTimeRange: function (start, end) {\n    var ids = [];\n    var search;\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startTimes = this._startTimeIndex.between(start, end);\n      var endTimes = this._endTimeIndex.between(start, end);\n      search = startTimes.concat(endTimes);\n    } else {\n      search = this._timeIndex.between(start, end);\n    }\n\n    for (var i = search.length - 1; i >= 0; i--) {\n      ids.push(search[i].id);\n    }\n\n    return ids;\n  },\n\n  _buildTimeIndexes: function (geojson) {\n    var i;\n    var feature;\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startTimeEntries = [];\n      var endTimeEntries = [];\n      for (i = geojson.length - 1; i >= 0; i--) {\n        feature = geojson[i];\n        startTimeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField.start])\n        });\n        endTimeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField.end])\n        });\n      }\n      this._startTimeIndex.bulkAdd(startTimeEntries);\n      this._endTimeIndex.bulkAdd(endTimeEntries);\n    } else {\n      var timeEntries = [];\n      for (i = geojson.length - 1; i >= 0; i--) {\n        feature = geojson[i];\n        timeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField])\n        });\n      }\n\n      this._timeIndex.bulkAdd(timeEntries);\n    }\n  },\n\n  _featureWithinTimeRange: function (feature) {\n    if (!this.options.from || !this.options.to) {\n      return true;\n    }\n\n    var from = +this.options.from.valueOf();\n    var to = +this.options.to.valueOf();\n\n    if (typeof this.options.timeField === 'string') {\n      var date = +feature.properties[this.options.timeField];\n      return (date >= from) && (date <= to);\n    }\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startDate = +feature.properties[this.options.timeField.start];\n      var endDate = +feature.properties[this.options.timeField.end];\n      return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to));\n    }\n  },\n\n  _visibleZoom: function () {\n    // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer\n    if (!this._map) {\n      return false;\n    }\n    var zoom = this._map.getZoom();\n    if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n      return false;\n    } else { return true; }\n  },\n\n  _handleZoomChange: function () {\n    if (!this._visibleZoom()) {\n      this.removeLayers(this._currentSnapshot);\n      this._currentSnapshot = [];\n    } else {\n      /*\n      for every cell in this._activeCells\n        1. Get the cache key for the coords of the cell\n        2. If this._cache[key] exists it will be an array of feature IDs.\n        3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back.\n      */\n      for (var i in this._activeCells) {\n        var coords = this._activeCells[i].coords;\n        var key = this._cacheKey(coords);\n        if (this._cache[key]) {\n          this.addLayers(this._cache[key]);\n        }\n      }\n    }\n  },\n\n  /**\n   * Service Methods\n   */\n\n  authenticate: function (token) {\n    this.service.authenticate(token);\n    return this;\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  _getMetadata: function (callback) {\n    if (this._metadata) {\n      var error;\n      callback(error, this._metadata);\n    } else {\n      this.metadata(L.Util.bind(function (error, response) {\n        this._metadata = response;\n        callback(error, this._metadata);\n      }, this));\n    }\n  },\n\n  addFeature: function (feature, callback, context) {\n    this._getMetadata(L.Util.bind(function (error, metadata) {\n      if (error) {\n        if (callback) { callback.call(this, error, null); }\n        return;\n      }\n\n      this.service.addFeature(feature, L.Util.bind(function (error, response) {\n        if (!error) {\n          // assign ID from result to appropriate objectid field from service metadata\n          feature.properties[metadata.objectIdField] = response.objectId;\n\n          // we also need to update the geojson id for createLayers() to function\n          feature.id = response.objectId;\n          this.createLayers([feature]);\n        }\n\n        if (callback) {\n          callback.call(context, error, response);\n        }\n      }, this));\n    }, this));\n  },\n\n  updateFeature: function (feature, callback, context) {\n    this.service.updateFeature(feature, function (error, response) {\n      if (!error) {\n        this.removeLayers([feature.id], true);\n        this.createLayers([feature]);\n      }\n\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  },\n\n  deleteFeature: function (id, callback, context) {\n    this.service.deleteFeature(id, function (error, response) {\n      if (!error && response.objectId) {\n        this.removeLayers([response.objectId], true);\n      }\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  },\n\n  deleteFeatures: function (ids, callback, context) {\n    return this.service.deleteFeatures(ids, function (error, response) {\n      if (!error && response.length > 0) {\n        for (var i = 0; i < response.length; i++) {\n          this.removeLayers([response[i].objectId], true);\n        }\n      }\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  }\n});\n","import L from 'leaflet';\nimport { FeatureManager } from './FeatureManager';\n\nexport var FeatureLayer = FeatureManager.extend({\n\n  options: {\n    cacheLayers: true\n  },\n\n  /**\n   * Constructor\n   */\n  initialize: function (options) {\n    FeatureManager.prototype.initialize.call(this, options);\n    this._originalStyle = this.options.style;\n    this._layers = {};\n  },\n\n  /**\n   * Layer Interface\n   */\n\n  onRemove: function (map) {\n    for (var i in this._layers) {\n      map.removeLayer(this._layers[i]);\n    }\n\n    return FeatureManager.prototype.onRemove.call(this, map);\n  },\n\n  createNewLayer: function (geojson) {\n    var layer = L.GeoJSON.geometryToLayer(geojson, this.options);\n    layer.defaultOptions = layer.options;\n    return layer;\n  },\n\n  _updateLayer: function (layer, geojson) {\n    // convert the geojson coordinates into a Leaflet LatLng array/nested arrays\n    // pass it to setLatLngs to update layer geometries\n    var latlngs = [];\n    var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng;\n\n    // copy new attributes, if present\n    if (geojson.properties) {\n      layer.feature.properties = geojson.properties;\n    }\n\n    switch (geojson.geometry.type) {\n      case 'Point':\n        latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates);\n        layer.setLatLng(latlngs);\n        break;\n      case 'LineString':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'MultiLineString':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'Polygon':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'MultiPolygon':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n    }\n  },\n\n  /**\n   * Feature Management Methods\n   */\n\n  createLayers: function (features) {\n    for (var i = features.length - 1; i >= 0; i--) {\n      var geojson = features[i];\n\n      var layer = this._layers[geojson.id];\n      var newLayer;\n\n      if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) {\n        this._map.addLayer(layer);\n      }\n\n      // update geometry if necessary\n      if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) {\n        this._updateLayer(layer, geojson);\n      }\n\n      if (!layer) {\n        newLayer = this.createNewLayer(geojson);\n        newLayer.feature = geojson;\n\n        // bubble events from individual layers to the feature layer\n        newLayer.addEventParent(this);\n\n        if (this.options.onEachFeature) {\n          this.options.onEachFeature(newLayer.feature, newLayer);\n        }\n\n        // cache the layer\n        this._layers[newLayer.feature.id] = newLayer;\n\n        // style the layer\n        this.setFeatureStyle(newLayer.feature.id, this.options.style);\n\n        this.fire('createfeature', {\n          feature: newLayer.feature\n        }, true);\n\n        // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled\n        if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) {\n          this._map.addLayer(newLayer);\n        }\n      }\n    }\n  },\n\n  addLayers: function (ids) {\n    for (var i = ids.length - 1; i >= 0; i--) {\n      var layer = this._layers[ids[i]];\n      if (layer) {\n        this.fire('addfeature', {\n          feature: layer.feature\n        }, true);\n        this._map.addLayer(layer);\n      }\n    }\n  },\n\n  removeLayers: function (ids, permanent) {\n    for (var i = ids.length - 1; i >= 0; i--) {\n      var id = ids[i];\n      var layer = this._layers[id];\n      if (layer) {\n        this.fire('removefeature', {\n          feature: layer.feature,\n          permanent: permanent\n        }, true);\n        this._map.removeLayer(layer);\n      }\n      if (layer && permanent) {\n        delete this._layers[id];\n      }\n    }\n  },\n\n  cellEnter: function (bounds, coords) {\n    if (!this._zooming && this._map) {\n      L.Util.requestAnimFrame(L.Util.bind(function () {\n        var cacheKey = this._cacheKey(coords);\n        var cellKey = this._cellCoordsToKey(coords);\n        var layers = this._cache[cacheKey];\n        if (this._activeCells[cellKey] && layers) {\n          this.addLayers(layers);\n        }\n      }, this));\n    }\n  },\n\n  cellLeave: function (bounds, coords) {\n    if (!this._zooming) {\n      L.Util.requestAnimFrame(L.Util.bind(function () {\n        if (this._map) {\n          var cacheKey = this._cacheKey(coords);\n          var cellKey = this._cellCoordsToKey(coords);\n          var layers = this._cache[cacheKey];\n          var mapBounds = this._map.getBounds();\n          if (!this._activeCells[cellKey] && layers) {\n            var removable = true;\n\n            for (var i = 0; i < layers.length; i++) {\n              var layer = this._layers[layers[i]];\n              if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) {\n                removable = false;\n              }\n            }\n\n            if (removable) {\n              this.removeLayers(layers, !this.options.cacheLayers);\n            }\n\n            if (!this.options.cacheLayers && removable) {\n              delete this._cache[cacheKey];\n              delete this._cells[cellKey];\n              delete this._activeCells[cellKey];\n            }\n          }\n        }\n      }, this));\n    }\n  },\n\n  /**\n   * Styling Methods\n   */\n\n  resetStyle: function () {\n    this.options.style = this._originalStyle;\n    this.eachFeature(function (layer) {\n      this.resetFeatureStyle(layer.feature.id);\n    }, this);\n    return this;\n  },\n\n  setStyle: function (style) {\n    this.options.style = style;\n    this.eachFeature(function (layer) {\n      this.setFeatureStyle(layer.feature.id, style);\n    }, this);\n    return this;\n  },\n\n  resetFeatureStyle: function (id) {\n    var layer = this._layers[id];\n    var style = this._originalStyle || L.Path.prototype.options;\n    if (layer) {\n      L.Util.extend(layer.options, layer.defaultOptions);\n      this.setFeatureStyle(id, style);\n    }\n    return this;\n  },\n\n  setFeatureStyle: function (id, style) {\n    var layer = this._layers[id];\n    if (typeof style === 'function') {\n      style = style(layer.feature);\n    }\n    if (layer.setStyle) {\n      layer.setStyle(style);\n    }\n    return this;\n  },\n\n  /**\n   * Utility Methods\n   */\n\n  eachFeature: function (fn, context) {\n    for (var i in this._layers) {\n      fn.call(context, this._layers[i]);\n    }\n    return this;\n  },\n\n  getFeature: function (id) {\n    return this._layers[id];\n  },\n\n  bringToBack: function () {\n    this.eachFeature(function (layer) {\n      if (layer.bringToBack) {\n        layer.bringToBack();\n      }\n    });\n  },\n\n  bringToFront: function () {\n    this.eachFeature(function (layer) {\n      if (layer.bringToFront) {\n        layer.bringToFront();\n      }\n    });\n  },\n\n  redraw: function (id) {\n    if (id) {\n      this._redraw(id);\n    }\n    return this;\n  },\n\n  _redraw: function (id) {\n    var layer = this._layers[id];\n    var geojson = layer.feature;\n\n    // if this looks like a marker\n    if (layer && layer.setIcon && this.options.pointToLayer) {\n      // update custom symbology, if necessary\n      if (this.options.pointToLayer) {\n        var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n        var updatedIcon = getIcon.options.icon;\n        layer.setIcon(updatedIcon);\n      }\n    }\n\n    // looks like a vector marker (circleMarker)\n    if (layer && layer.setStyle && this.options.pointToLayer) {\n      var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n      var updatedStyle = getStyle.options;\n      this.setFeatureStyle(geojson.id, updatedStyle);\n    }\n\n    // looks like a path (polygon/polyline)\n    if (layer && layer.setStyle && this.options.style) {\n      this.resetStyle(geojson.id);\n    }\n  }\n});\n\nexport function featureLayer (options) {\n  return new FeatureLayer(options);\n}\n\nexport default featureLayer;\n"],"names":["shallowClone","arcgisToGeoJSON","geojsonToArcGIS","g2a","a2g"],"mappings":"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"} \ No newline at end of file diff --git a/dist/esri-leaflet.js b/dist/esri-leaflet.js new file mode 100644 index 000000000..6af7f8625 --- /dev/null +++ b/dist/esri-leaflet.js @@ -0,0 +1,3 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("leaflet")):"function"==typeof define&&define.amd?define(["exports","leaflet"],e):e((t.L=t.L||{},t.L.esri=t.L.esri||{}),t.L)}(this,function(t,e){"use strict";function i(t,e){for(var i=0;is;s++)e=t[s+1],i+=(e[0]-o[0])*(e[1]+o[1]),o=e;return i>=0}function o(t,e,i,s){var r=(s[0]-i[0])*(t[1]-i[1])-(s[1]-i[1])*(t[0]-i[0]),o=(e[0]-t[0])*(t[1]-i[1])-(e[1]-t[1])*(t[0]-i[0]),n=(s[1]-i[1])*(e[0]-t[0])-(s[0]-i[0])*(e[1]-t[1]);if(0!==n){var a=r/n,l=o/n;if(a>=0&&1>=a&&l>=0&&1>=l)return!0}return!1}function n(t,e){for(var i=0;i=0;e--)if(i=a[e][0],l(i,o)){a[e].push(o),m=!0;break}m||d.push(o)}for(;d.length;){o=d.pop();var f=!1;for(e=a.length-1;e>=0;e--)if(i=a[e][0],n(i,o)){a[e].push(o),f=!0;break}f||a.push([o.reverse()])}return 1===a.length?{type:"Polygon",coordinates:a[0]}:{type:"MultiPolygon",coordinates:a}}function h(t){var e=[],i=t.slice(0),o=s(i.shift().slice(0));if(o.length>=4){r(o)||o.reverse(),e.push(o);for(var n=0;n=4&&(r(a)&&a.reverse(),e.push(a))}}return e}function c(t){for(var e=[],i=0;i=0;r--){var o=s[r].slice(0);e.push(o)}return e}function p(t){var e={};for(var i in t)t.hasOwnProperty(i)&&(e[i]=t[i]);return e}function d(t,e){var i={};return"number"==typeof t.x&&"number"==typeof t.y&&(i.type="Point",i.coordinates=[t.x,t.y]),t.points&&(i.type="MultiPoint",i.coordinates=t.points.slice(0)),t.paths&&(1===t.paths.length?(i.type="LineString",i.coordinates=t.paths[0].slice(0)):(i.type="MultiLineString",i.coordinates=t.paths.slice(0))),t.rings&&(i=u(t.rings.slice(0))),(t.geometry||t.attributes)&&(i.type="Feature",i.geometry=t.geometry?d(t.geometry):null,i.properties=t.attributes?p(t.attributes):null,t.attributes&&(i.id=t.attributes[e]||t.attributes.OBJECTID||t.attributes.FID)),i}function m(t,e){e=e||"OBJECTID";var i,s={wkid:4326},r={};switch(t.type){case"Point":r.x=t.coordinates[0],r.y=t.coordinates[1],r.spatialReference=s;break;case"MultiPoint":r.points=t.coordinates.slice(0),r.spatialReference=s;break;case"LineString":r.paths=[t.coordinates.slice(0)],r.spatialReference=s;break;case"MultiLineString":r.paths=t.coordinates.slice(0),r.spatialReference=s;break;case"Polygon":r.rings=h(t.coordinates.slice(0)),r.spatialReference=s;break;case"MultiPolygon":r.rings=c(t.coordinates.slice(0)),r.spatialReference=s;break;case"Feature":t.geometry&&(r.geometry=m(t.geometry,e)),r.attributes=t.properties?p(t.properties):{},t.id&&(r.attributes[e]=t.id);break;case"FeatureCollection":for(r=[],i=0;i=0;n--){var a=g(o[n],i);r.features.push(a)}return r}function L(t){return t=e.Util.trim(t),"/"!==t[t.length-1]&&(t+="/"),t}function x(t){return/\.arcgis\.com.*?FeatureServer/g.test(t)}function S(t){var e;switch(t){case"Point":e="esriGeometryPoint";break;case"MultiPoint":e="esriGeometryMultipoint";break;case"LineString":e="esriGeometryPolyline";break;case"MultiLineString":e="esriGeometryPolyline";break;case"Polygon":e="esriGeometryPolygon";break;case"MultiPolygon":e="esriGeometryPolygon"}return e}function T(){console&&console.warn&&console.warn.apply(console,arguments)}function I(t){var e="";t.f=t.f||"json";for(var i in t)if(t.hasOwnProperty(i)){var s,r=t[i],o=Object.prototype.toString.call(r);e.length&&(e+="&"),s="[object Array]"===o?"[object Object]"===Object.prototype.toString.call(r[0])?JSON.stringify(r):r.join(","):"[object Object]"===o?JSON.stringify(r):"[object Date]"===o?r.valueOf():r,e+=encodeURIComponent(i)+"="+encodeURIComponent(s)}return e}function w(t,i){var s=new window.XMLHttpRequest;return s.onerror=function(r){s.onreadystatechange=e.Util.falseFn,t.call(i,{error:{code:500,message:"XMLHttpRequest error"}},null)},s.onreadystatechange=function(){var r,o;if(4===s.readyState){try{r=JSON.parse(s.responseText)}catch(n){r=null,o={code:500,message:"Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error."}}!o&&r.error&&(o=r.error,r=null),s.onerror=e.Util.falseFn,t.call(i,o,r)}},s.ontimeout=function(){this.onerror()},s}function P(t,e,i,s){var r=w(i,s);return"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(r.timeout=s.options.timeout),r.open("POST",t),r.setRequestHeader("Content-Type","application/x-www-form-urlencoded"),r.send(I(e)),r}function R(t,e,i,s){var r=w(i,s);return"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(r.timeout=s.options.timeout),r.open("GET",t+"?"+I(e),!0),r.send(null),r}function C(t,e,i,s){var r=I(e),o=w(i,s);"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(o.timeout=s.options.timeout);var n=(t+"?"+r).length;if(2e3>=n&&X.cors)o.open("GET",t+"?"+r),o.send(null);else{if(!(n>2e3&&X.cors))return 2e3>=n&&!X.cors?O(t,e,i,s):void T("a request to "+t+" was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html");o.open("POST",t),o.setRequestHeader("Content-Type","application/x-www-form-urlencoded"),o.send(r)}return o}function O(t,i,s,r){window._EsriLeafletCallbacks=window._EsriLeafletCallbacks||{};var o="c"+Y;i.callback="window._EsriLeafletCallbacks."+o;var n=e.DomUtil.create("script",null,document.body);return n.type="text/javascript",n.src=t+"?"+I(i),n.id=o,window._EsriLeafletCallbacks[o]=function(t){if(window._EsriLeafletCallbacks[o]!==!0){var e,i=Object.prototype.toString.call(t);"[object Object]"!==i&&"[object Array]"!==i&&(e={error:{code:500,message:"Expected array or object as JSONP response"}},t=null),!e&&t.error&&(e=t,t=null),s.call(r,e,t),window._EsriLeafletCallbacks[o]=!0}},Y++,{id:o,url:n.src,abort:function(){window._EsriLeafletCallbacks._callback[o]({code:0,message:"Request aborted."})}}}function F(t){return new it(t)}function k(t){return new st(t)}function M(t){return new rt(t)}function E(t){return new ot(t)}function G(t){return new nt(t)}function q(t){return new at(t)}function A(t){return new lt(t)}function U(t){return new ut(t)}function D(t){return new ht(t)}function B(t){return new ct(t)}function z(t){return new pt(t)}function j(t,e){return new mt(t,e)}function Z(t,e){return new ft(t,e)}function N(t,e){return new _t(t,e)}function W(t,e){return new vt(t,e)}function J(t){this.values=[].concat(t||[])}function Q(t){return new xt(t)}e="default"in e?e["default"]:e;var H="2.0.0-beta.8",K=window.XMLHttpRequest&&"withCredentials"in new window.XMLHttpRequest,V=""===document.documentElement.style.pointerEvents,X={cors:K,pointerEvents:V},$={shallowClone:y,warn:T,cleanUrl:L,isArcgisOnline:x,geojsonTypeToArcGIS:S,responseToFeatureCollection:b,geojsonToArcGIS:f,arcgisToGeoJSON:g,boundsToExtent:v,extentToBounds:_},Y=0,tt=X.cors?R:O;tt.CORS=R,tt.JSONP=O;var et={request:C,get:tt,post:P},it=e.Class.extend({options:{proxy:!1,useCors:K},generateSetter:function(t,i){return e.Util.bind(function(e){return this.params[t]=e,this},i)},initialize:function(t){if(t.request&&t.options?(this._service=t,e.Util.setOptions(this,t.options)):(e.Util.setOptions(this,t),this.options.url=L(t.url)),this.params=e.Util.extend({},this.params||{}),this.setters)for(var i in this.setters){var s=this.setters[i];this[i]=this.generateSetter(s,this)}},token:function(t){return this._service?this._service.authenticate(t):this.params.token=t,this},request:function(t,e){return this._service?this._service.request(this.path,this.params,t,e):this._request("request",this.path,this.params,t,e)},_request:function(t,e,i,s,r){var o=this.options.proxy?this.options.proxy+"?"+this.options.url+e:this.options.url+e;return"get"!==t&&"request"!==t||this.options.useCors?et[t](o,i,s,r):et.get.JSONP(o,i,s,r)}}),st=it.extend({setters:{offset:"offset",limit:"limit",fields:"outFields",precision:"geometryPrecision",featureIds:"objectIds",returnGeometry:"returnGeometry",token:"token"},path:"query",params:{returnGeometry:!0,where:"1=1",outSr:4326,outFields:"*"},within:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelContains",this},intersects:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelIntersects",this},contains:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelWithin",this},crosses:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelCrosses",this},touches:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelTouches",this},overlaps:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelOverlaps",this},nearby:function(t,i){return t=e.latLng(t),this.params.geometry=[t.lng,t.lat],this.params.geometryType="esriGeometryPoint",this.params.spatialRel="esriSpatialRelIntersects",this.params.units="esriSRUnit_Meter",this.params.distance=i,this.params.inSr=4326,this},where:function(t){return this.params.where=t,this},between:function(t,e){return this.params.time=[t.valueOf(),e.valueOf()],this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*e,this},orderBy:function(t,e){return e=e||"ASC",this.params.orderByFields=this.params.orderByFields?this.params.orderByFields+",":"",this.params.orderByFields+=[t,e].join(" "),this},run:function(t,e){return this._cleanParams(),$.isArcgisOnline(this.options.url)?(this.params.f="geojson",this.request(function(i,s){this._trapSQLerrors(i),t.call(e,i,s,s)},this)):this.request(function(i,s){this._trapSQLerrors(i),t.call(e,i,s&&$.responseToFeatureCollection(s),s)},this)},count:function(t,e){return this._cleanParams(),this.params.returnCountOnly=!0,this.request(function(e,i){t.call(this,e,i&&i.count,i)},e)},ids:function(t,e){return this._cleanParams(),this.params.returnIdsOnly=!0,this.request(function(e,i){t.call(this,e,i&&i.objectIds,i)},e)},bounds:function(t,e){return this._cleanParams(),this.params.returnExtentOnly=!0,this.request(function(i,s){t.call(e,i,s&&s.extent&&$.extentToBounds(s.extent),s)},e)},pixelSize:function(t){return t=e.point(t),this.params.pixelSize=[t.x,t.y],this},layer:function(t){return this.path=t+"/query",this},_trapSQLerrors:function(t){t&&"400"===t.code&&$.warn("one common syntax error in query requests is encasing string values in double quotes instead of single quotes")},_cleanParams:function(){delete this.params.returnIdsOnly,delete this.params.returnExtentOnly,delete this.params.returnCountOnly},_setGeometry:function(t){return this.params.inSr=4326,t instanceof e.LatLngBounds?(this.params.geometry=$.boundsToExtent(t),void(this.params.geometryType="esriGeometryEnvelope")):(t.getLatLng&&(t=t.getLatLng()),t instanceof e.LatLng&&(t={type:"Point",coordinates:[t.lng,t.lat]}),t instanceof e.GeoJSON&&(t=t.getLayers()[0].feature.geometry,this.params.geometry=$.geojsonToArcGIS(t),this.params.geometryType=$.geojsonTypeToArcGIS(t.type)),t.toGeoJSON&&(t=t.toGeoJSON()),"Feature"===t.type&&(t=t.geometry),"Point"===t.type||"LineString"===t.type||"Polygon"===t.type?(this.params.geometry=$.geojsonToArcGIS(t),void(this.params.geometryType=$.geojsonTypeToArcGIS(t.type))):void $.warn("invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object"))}}),rt=it.extend({setters:{contains:"contains",text:"searchText",fields:"searchFields",spatialReference:"sr",sr:"sr",layers:"layers",returnGeometry:"returnGeometry",maxAllowableOffset:"maxAllowableOffset",precision:"geometryPrecision",dynamicLayers:"dynamicLayers",returnZ:"returnZ",returnM:"returnM",gdbVersion:"gdbVersion",token:"token"},path:"find",params:{sr:4326,contains:!0,returnGeometry:!0,returnZ:!0,returnM:!1},layerDefs:function(t,e){return this.params.layerDefs=this.params.layerDefs?this.params.layerDefs+";":"",this.params.layerDefs+=[t,e].join(":"),this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*e,this},run:function(t,e){return this.request(function(i,s){t.call(e,i,s&&$.responseToFeatureCollection(s),s)},e)}}),ot=it.extend({path:"identify",between:function(t,e){return this.params.time=[t.valueOf(),e.valueOf()],this}}),nt=ot.extend({setters:{layers:"layers",precision:"geometryPrecision",tolerance:"tolerance",returnGeometry:"returnGeometry"},params:{sr:4326,layers:"all",tolerance:3,returnGeometry:!0},on:function(t){var e=$.boundsToExtent(t.getBounds()),i=t.getSize();return this.params.imageDisplay=[i.x,i.y,96],this.params.mapExtent=[e.xmin,e.ymin,e.xmax,e.ymax],this},at:function(t){return t=e.latLng(t),this.params.geometry=[t.lng,t.lat],this.params.geometryType="esriGeometryPoint",this},layerDef:function(t,e){return this.params.layerDefs=this.params.layerDefs?this.params.layerDefs+";":"",this.params.layerDefs+=[t,e].join(":"),this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*(1-e),this},run:function(t,e){return this.request(function(i,s){if(i)return void t.call(e,i,void 0,s);var r=$.responseToFeatureCollection(s);s.results=s.results.reverse();for(var o=0;o=0;o--)r.catalogItems.features[o].properties.catalogItemVisibility=s[o];return r}}),lt=e.Evented.extend({options:{proxy:!1,useCors:K,timeout:0},initialize:function(t){t=t||{},this._requestQueue=[],this._authenticating=!1,e.Util.setOptions(this,t),this.options.url=L(this.options.url)},get:function(t,e,i,s){return this._request("get",t,e,i,s)},post:function(t,e,i,s){return this._request("post",t,e,i,s)},request:function(t,e,i,s){return this._request("request",t,e,i,s)},metadata:function(t,e){return this._request("get","",{},t,e)},authenticate:function(t){return this._authenticating=!1,this.options.token=t,this._runQueue(),this},getTimeout:function(){return this.options.timeout},setTimeout:function(t){this.options.timeout=t},_request:function(t,e,i,s,r){this.fire("requeststart",{url:this.options.url+e,params:i,method:t},!0);var o=this._createServiceCallback(t,e,i,s,r);if(this.options.token&&(i.token=this.options.token),this._authenticating)return void this._requestQueue.push([t,e,i,s,r]);var n=this.options.proxy?this.options.proxy+"?"+this.options.url+e:this.options.url+e;return"get"!==t&&"request"!==t||this.options.useCors?et[t](n,i,o,r):et.get.JSONP(n,i,o,r)},_createServiceCallback:function(t,i,s,r,o){return e.Util.bind(function(n,a){!n||499!==n.code&&498!==n.code||(this._authenticating=!0,this._requestQueue.push([t,i,s,r,o]),this.fire("authenticationrequired",{authenticate:e.Util.bind(this.authenticate,this)},!0),n.authenticate=e.Util.bind(this.authenticate,this)),r.call(o,n,a),n?this.fire("requesterror",{url:this.options.url+i,params:s,message:n.message,code:n.code,method:t},!0):this.fire("requestsuccess",{url:this.options.url+i,params:s,response:a,method:t},!0),this.fire("requestend",{url:this.options.url+i,params:s,method:t},!0)},this)},_runQueue:function(){for(var t=this._requestQueue.length-1;t>=0;t--){var e=this._requestQueue[t],i=e.shift();this[i].apply(this,e)}this._requestQueue=[]}}),ut=lt.extend({identify:function(){return G(this)},find:function(){return M(this)},query:function(){return k(this)}}),ht=lt.extend({query:function(){return k(this)},identify:function(){return q(this)}}),ct=lt.extend({options:{idAttribute:"OBJECTID"},query:function(){return k(this)},addFeature:function(t,e,i){return delete t.id,t=f(t),this.post("addFeatures",{features:[t]},function(t,s){var r=s&&s.addResults?s.addResults[0]:void 0;e&&e.call(i,t||s.addResults[0].error,r)},i)},updateFeature:function(t,e,i){return t=f(t,this.options.idAttribute),this.post("updateFeatures",{features:[t]},function(t,s){var r=s&&s.updateResults?s.updateResults[0]:void 0;e&&e.call(i,t||s.updateResults[0].error,r)},i)},deleteFeature:function(t,e,i){return this.post("deleteFeatures",{objectIds:t},function(t,s){var r=s&&s.deleteResults?s.deleteResults[0]:void 0;e&&e.call(i,t||s.deleteResults[0].error,r)},i)},deleteFeatures:function(t,e,i){return this.post("deleteFeatures",{objectIds:t},function(t,s){var r=s&&s.deleteResults?s.deleteResults:void 0;e&&e.call(i,t||s.deleteResults[0].error,r)},i)}}),pt=e.Control.extend({options:{position:"bottomright",marginTop:0,marginLeft:0,marginBottom:0,marginRight:0},onAdd:function(){var t=e.DomUtil.create("div","esri-leaflet-logo");return t.style.marginTop=this.options.marginTop,t.style.marginLeft=this.options.marginLeft,t.style.marginBottom=this.options.marginBottom,t.style.marginRight=this.options.marginRight,t.innerHTML='Powered by Esri',t}}),dt="https:"!==window.location.protocol?"http:":"https:",mt=e.TileLayer.extend({statics:{TILES:{Streets:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/World_Street_Map",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri"}},Topographic:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/World_Topo_Map",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri"}},Oceans:{urlTemplate:dt+"//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/Ocean_Basemap",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri"}},OceansLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},NationalGeographic:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp."}},DarkGray:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors"}},DarkGrayLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Gray:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors"}},GrayLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Imagery:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community"}},ImageryLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},ImageryTransportation:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},ShadedRelief:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],attribution:"Esri, USGS"}},ShadedReliefLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:12,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Terrain:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],attribution:"Esri, USGS, NOAA"}},TerrainLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}}}},initialize:function(t,i){var s;if("object"==typeof t&&t.urlTemplate&&t.options)s=t;else{if("string"!=typeof t||!mt.TILES[t])throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of "Streets", "Topographic", "Oceans", "OceansLabels", "NationalGeographic", "Gray", "GrayLabels", "DarkGray", "DarkGrayLabels", "Imagery", "ImageryLabels", "ImageryTransportation", "ShadedRelief", "ShadedReliefLabels", "Terrain" or "TerrainLabels"');s=mt.TILES[t]}var r=e.Util.extend(s.options,i);e.Util.setOptions(this,r),e.TileLayer.prototype.initialize.call(this,s.urlTemplate,r),s.attributionUrl&&this._getAttributionData(s.attributionUrl),this._logo=z({position:this.options.logoPosition})},onAdd:function(t){this.options.hideLogo||t._hasEsriLogo||(this._logo.addTo(t),t._hasEsriLogo=!0),"esri-labels"===this.options.pane&&this._initPane(),t.on("moveend",this._updateMapAttribution,this),e.TileLayer.prototype.onAdd.call(this,t)},onRemove:function(t){this._logo&&this._logo._container&&(t.removeControl(this._logo),t._hasEsriLogo=!1),t.off("moveend",this._updateMapAttribution,this),e.TileLayer.prototype.onRemove.call(this,t)},getAttribution:function(){if(this.options.attribution)var t=''+this.options.attribution+"";return t},_initPane:function(){if(!this._map.getPane(this.options.pane)){var t=this._map.createPane(this.options.pane);t.style.pointerEvents="none",t.style.zIndex=500}},_getAttributionData:function(t){O(t,{},e.Util.bind(function(t,i){if(!t){this._attributions=[];for(var s=0;s=r.minZoom&&i<=r.maxZoom&&(t+=", "+o)}t=t.substr(2);var n=this._map.attributionControl._container.querySelector(".esri-attributions");n.innerHTML=t,n.style.maxWidth=.65*this._map.getSize().x+"px",this.fire("attributionupdated",{attribution:t})}}}),ft=e.TileLayer.extend({options:{zoomOffsetAllowance:.1},statics:{MercatorZoomLevels:{0:156543.033928,1:78271.5169639999,2:39135.7584820001,3:19567.8792409999,4:9783.93962049996,5:4891.96981024998,6:2445.98490512499,7:1222.99245256249,8:611.49622628138,9:305.748113140558,10:152.874056570411,11:76.4370282850732,12:38.2185141425366,13:19.1092570712683,14:9.55462853563415,15:4.77731426794937,16:2.38865713397468,17:1.19432856685505,18:.597164283559817,19:.298582141647617,20:.14929107082381,21:.07464553541191,22:.0373227677059525,23:.0186613838529763}},initialize:function(t){t.url=L(t.url),t=e.Util.setOptions(this,t),this.tileUrl=t.url+"tile/{z}/{y}/{x}",this.service=U(t),this.service.addEventParent(this);var i=new RegExp(/tiles.arcgis(online)?\.com/g);i.test(t.url)&&(this.tileUrl=this.tileUrl.replace("://tiles","://tiles{s}"),t.subdomains=["1","2","3","4"]),this.options.token&&(this.tileUrl+="?token="+this.options.token),e.TileLayer.prototype.initialize.call(this,this.tileUrl,t)},getTileUrl:function(t){return e.Util.template(this.tileUrl,e.extend({s:this._getSubdomain(t),z:this._lodMap&&this._lodMap[t.z]?this._lodMap[t.z]:t.z,x:t.x,y:t.y},this.options))},createTile:function(t,i){var s=document.createElement("img");return e.DomEvent.on(s,"load",e.bind(this._tileOnLoad,this,i,s)),e.DomEvent.on(s,"error",e.bind(this._tileOnError,this,i,s)),this.options.crossOrigin&&(s.crossOrigin=""),s.alt="",!this._lodMap||this._lodMap&&this._lodMap[t.z]?s.src=this.getTileUrl(t):this.once("lodmap",function(){s.src=this.getTileUrl(t)},this),s},onAdd:function(t){t.options.crs!==e.CRS.EPSG3857||this._lodMap||(this._lodMap={},this.metadata(function(t,e){if(!t){var i=e.spatialReference.latestWkid||e.spatialReference.wkid;if(102100===i||3857===i){for(var s=e.tileInfo.lods,r=ft.MercatorZoomLevels,o=0;os}}),gt=e.ImageOverlay.extend({onAdd:function(t){this._topLeft=t.getPixelBounds().min,e.ImageOverlay.prototype.onAdd.call(this,t)},_reset:function(){this._map.options.crs===e.CRS.EPSG3857?e.ImageOverlay.prototype._reset.call(this):e.DomUtil.setPosition(this._image,this._topLeft.subtract(this._map.getPixelOrigin()))}}),yt=e.Layer.extend({options:{opacity:1,position:"front",f:"image",useCors:K,attribution:null,interactive:!1,alt:""},onAdd:function(t){this._update=e.Util.throttle(this._update,this.options.updateInterval,this),t.on("moveend",this._update,this),this._currentImage&&this._currentImage._bounds.equals(this._map.getBounds())?t.addLayer(this._currentImage):this._currentImage&&(this._map.removeLayer(this._currentImage),this._currentImage=null),this._update(),this._popup&&(this._map.on("click",this._getPopupData,this),this._map.on("dblclick",this._resetPopupState,this))},onRemove:function(t){this._currentImage&&this._map.removeLayer(this._currentImage),this._popup&&(this._map.off("click",this._getPopupData,this),this._map.off("dblclick",this._resetPopupState,this)),this._map.off("moveend",this._update,this)},bindPopup:function(t,i){return this._shouldRenderPopup=!1,this._lastClick=!1,this._popup=e.popup(i),this._popupFunction=t,this._map&&(this._map.on("click",this._getPopupData,this),this._map.on("dblclick",this._resetPopupState,this)),this},unbindPopup:function(){return this._map&&(this._map.closePopup(this._popup),this._map.off("click",this._getPopupData,this),this._map.off("dblclick",this._resetPopupState,this)),this._popup=!1,this},bringToFront:function(){return this.options.position="front",this._currentImage&&this._currentImage.bringToFront(),this},bringToBack:function(){return this.options.position="back",this._currentImage&&this._currentImage.bringToBack(),this},getAttribution:function(){return this.options.attribution},getOpacity:function(){return this.options.opacity},setOpacity:function(t){return this.options.opacity=t,this._currentImage.setOpacity(t),this},getTimeRange:function(){return[this.options.from,this.options.to]},setTimeRange:function(t,e){return this.options.from=t,this.options.to=e,this._update(),this},metadata:function(t,e){return this.service.metadata(t,e),this},authenticate:function(t){return this.service.authenticate(t),this},_renderImage:function(t,e){if(this._map){var i=new gt(t,e,{opacity:0,crossOrigin:this.options.useCors, +alt:this.options.alt,pane:this.options.pane||this.getPane(),interactive:this.options.interactive}).addTo(this._map);i.once("load",function(t){if(this._map){var i=t.target,s=this._currentImage;i._bounds.equals(e)&&i._bounds.equals(this._map.getBounds())?(this._currentImage=i,"front"===this.options.position?this.bringToFront():this.bringToBack(),this._map&&this._currentImage._map?this._currentImage.setOpacity(this.options.opacity):this._currentImage._map.removeLayer(this._currentImage),s&&this._map&&this._map.removeLayer(s),s&&s._map&&s._map.removeLayer(s)):this._map.removeLayer(i)}this.fire("load",{bounds:e})},this),this.fire("loading",{bounds:e})}},_update:function(){if(this._map){var t=this._map.getZoom(),e=this._map.getBounds();if(!(this._animatingZoom||this._map._panTransition&&this._map._panTransition._inProgress)){if(t>this.options.maxZoom||t0||n.ys;s++)this._addCell(o[s])},_isValidCell:function(t){var i=this._map.options.crs;if(!i.infinite){var s=this._cellNumBounds;if(!i.wrapLng&&(t.xs.max.x)||!i.wrapLat&&(t.ys.max.y))return!1}if(!this.options.bounds)return!0;var r=this._cellCoordsToBounds(t);return e.latLngBounds(this.options.bounds).intersects(r)},_cellCoordsToBounds:function(t){var i=this._map,s=this.options.cellSize,r=t.multiplyBy(s),o=r.add([s,s]),n=i.wrapLatLng(i.unproject(r,t.z)),a=i.wrapLatLng(i.unproject(o,t.z));return e.latLngBounds(n,a)},_cellCoordsToKey:function(t){return t.x+":"+t.y},_keyToCellCoords:function(t){var i=t.split(":"),s=parseInt(i[0],10),r=parseInt(i[1],10);return e.point(s,r)},_removeOtherCells:function(t){for(var e in this._cells)t.contains(this._keyToCellCoords(e))||this._removeCell(e)},_removeCell:function(t){var e=this._activeCells[t];e&&(delete this._activeCells[t],this.cellLeave&&this.cellLeave(e.bounds,e.coords),this.fire("cellleave",{bounds:e.bounds,coords:e.coords}))},_removeCells:function(){for(var t in this._cells){var e=this._cells[t].bounds,i=this._cells[t].coords;this.cellLeave&&this.cellLeave(e,i),this.fire("cellleave",{bounds:e,coords:i})}},_addCell:function(t){this._wrapCoords(t);var e=this._cellCoordsToKey(t),i=this._cells[e];i&&!this._activeCells[e]&&(this.cellEnter&&this.cellEnter(i.bounds,t),this.fire("cellenter",{bounds:i.bounds,coords:t}),this._activeCells[e]=i),i||(i={coords:t,bounds:this._cellCoordsToBounds(t)},this._cells[e]=i,this._activeCells[e]=i,this.createCell&&this.createCell(i.bounds,t),this.fire("cellcreate",{bounds:i.bounds,coords:t}))},_wrapCoords:function(t){t.x=this._wrapLng?e.Util.wrapNum(t.x,this._wrapLng):t.x,t.y=this._wrapLat?e.Util.wrapNum(t.y,this._wrapLat):t.y},_getCellNumBounds:function(){var t=this._map.getPixelWorldBounds(),i=this._getCellSize();return t?e.bounds(t.min.divideBy(i).floor(),t.max.divideBy(i).ceil().subtract([1,1])):null}});J.prototype.query=function(t){var e=this.getIndex(t);return this.values[e]},J.prototype.getIndex=function(t){this.dirty&&this.sort();for(var e,i,s=0,r=this.values.length-1;r>=s;)if(e=(s+r)/2|0,i=this.values[Math.round(e)],+i.value<+t)s=e+1;else{if(!(+i.value>+t))return e;r=e-1}return Math.abs(~r)},J.prototype.between=function(t,e){var i=this.getIndex(t),s=this.getIndex(e);if(0===i&&0===s)return[];for(;this.values[i-1]&&this.values[i-1].value===t;)i--;for(;this.values[s+1]&&this.values[s+1].value===e;)s++;return this.values[s]&&this.values[s].value===e&&this.values[s+1]&&s++,this.values.slice(i,s)},J.prototype.insert=function(t){return this.values.splice(this.getIndex(t.value),0,t),this},J.prototype.bulkAdd=function(t,e){return this.values=this.values.concat([].concat(t||[])),e?this.sort():this.dirty=!0,this},J.prototype.sort=function(){return this.values.sort(function(t,e){return+e.value-+t.value}).reverse(),this.dirty=!1,this};var Lt=bt.extend({options:{attribution:null,where:"1=1",fields:["*"],from:!1,to:!1,timeField:!1,timeFilterMode:"server",simplifyFactor:0,precision:6},initialize:function(t){if(bt.prototype.initialize.call(this,t),t.url=L(t.url),t=e.setOptions(this,t),this.service=B(t),this.service.addEventParent(this),"*"!==this.options.fields[0]){for(var i=!1,s=0;s=0;s--){var r=t[s].id;this._currentSnapshot.push(r),this._cache[i].push(r)}this.options.timeField&&this._buildTimeIndexes(t),this.createLayers(t)},_buildQuery:function(t){var e=this.service.query().intersects(t).where(this.options.where).fields(this.options.fields).precision(this.options.precision);return this.options.simplifyFactor&&e.simplify(this._map,this.options.simplifyFactor),"server"===this.options.timeFilterMode&&this.options.from&&this.options.to&&e.between(this.options.from,this.options.to),e},setWhere:function(t,i,s){this.options.where=t&&t.length?t:"1=1";for(var r=[],o=[],n=0,a=null,l=e.Util.bind(function(t,l){if(t&&(a=t),l)for(var u=l.features.length-1;u>=0;u--)o.push(l.features[u].id);n--,0>=n&&(this._currentSnapshot=o,e.Util.requestAnimFrame(e.Util.bind(function(){this.removeLayers(r),this.addLayers(o),i&&i.call(s,a)},this)))},this),u=this._currentSnapshot.length-1;u>=0;u--)r.push(this._currentSnapshot[u]);for(var h in this._activeCells){n++;var c=this._keyToCellCoords(h),p=this._cellCoordsToBounds(c);this._requestFeatures(p,h,l)}return this},getWhere:function(){return this.options.where},getTimeRange:function(){return[this.options.from,this.options.to]},setTimeRange:function(t,i,s,r){var o=this.options.from,n=this.options.to,a=0,l=null,u=e.Util.bind(function(e){e&&(l=e),this._filterExistingFeatures(o,n,t,i),a--,s&&0>=a&&s.call(r,l)},this);if(this.options.from=t,this.options.to=i,this._filterExistingFeatures(o,n,t,i),"server"===this.options.timeFilterMode)for(var h in this._activeCells){a++;var c=this._keyToCellCoords(h),p=this._cellCoordsToBounds(c);this._requestFeatures(p,h,u)}return this},refresh:function(){for(var t in this._activeCells){var e=this._keyToCellCoords(t),i=this._cellCoordsToBounds(e);this._requestFeatures(i,t)}this.redraw&&this.once("load",function(){this.eachFeature(function(t){this._redraw(t.feature.id)},this)},this)},_filterExistingFeatures:function(t,i,s,r){var o=t&&i?this._getFeaturesInTimeRange(t,i):this._currentSnapshot,n=this._getFeaturesInTimeRange(s,r);if(n.indexOf)for(var a=0;a=0&&o.splice(l,1)}e.Util.requestAnimFrame(e.Util.bind(function(){this.removeLayers(o),this.addLayers(n)},this))},_getFeaturesInTimeRange:function(t,e){var i,s=[];if(this.options.timeField.start&&this.options.timeField.end){var r=this._startTimeIndex.between(t,e),o=this._endTimeIndex.between(t,e);i=r.concat(o)}else i=this._timeIndex.between(t,e);for(var n=i.length-1;n>=0;n--)s.push(i[n].id);return s},_buildTimeIndexes:function(t){var e,i;if(this.options.timeField.start&&this.options.timeField.end){var s=[],r=[];for(e=t.length-1;e>=0;e--)i=t[e],s.push({id:i.id,value:new Date(i.properties[this.options.timeField.start])}),r.push({id:i.id,value:new Date(i.properties[this.options.timeField.end])});this._startTimeIndex.bulkAdd(s),this._endTimeIndex.bulkAdd(r)}else{var o=[];for(e=t.length-1;e>=0;e--)i=t[e],o.push({id:i.id,value:new Date(i.properties[this.options.timeField])});this._timeIndex.bulkAdd(o)}},_featureWithinTimeRange:function(t){if(!this.options.from||!this.options.to)return!0;var e=+this.options.from.valueOf(),i=+this.options.to.valueOf();if("string"==typeof this.options.timeField){var s=+t.properties[this.options.timeField];return s>=e&&i>=s}if(this.options.timeField.start&&this.options.timeField.end){var r=+t.properties[this.options.timeField.start],o=+t.properties[this.options.timeField.end];return r>=e&&i>=r||o>=e&&i>=o}},_visibleZoom:function(){if(!this._map)return!1;var t=this._map.getZoom();return t>this.options.maxZoom||t0)for(var r=0;r=0;e--){var i,s=t[e],r=this._layers[s.id];this._visibleZoom()&&r&&!this._map.hasLayer(r)&&this._map.addLayer(r),r&&this.options.simplifyFactor>0&&(r.setLatLngs||r.setLatLng)&&this._updateLayer(r,s),r||(i=this.createNewLayer(s),i.feature=s,i.addEventParent(this),this.options.onEachFeature&&this.options.onEachFeature(i.feature,i),this._layers[i.feature.id]=i,this.setFeatureStyle(i.feature.id,this.options.style),this.fire("createfeature",{feature:i.feature},!0),this._visibleZoom()&&(!this.options.timeField||this.options.timeField&&this._featureWithinTimeRange(s))&&this._map.addLayer(i))}},addLayers:function(t){for(var e=t.length-1;e>=0;e--){var i=this._layers[t[e]];i&&(this.fire("addfeature",{feature:i.feature},!0),this._map.addLayer(i))}},removeLayers:function(t,e){for(var i=t.length-1;i>=0;i--){var s=t[i],r=this._layers[s];r&&(this.fire("removefeature",{feature:r.feature,permanent:e},!0),this._map.removeLayer(r)),r&&e&&delete this._layers[s]}},cellEnter:function(t,i){!this._zooming&&this._map&&e.Util.requestAnimFrame(e.Util.bind(function(){var t=this._cacheKey(i),e=this._cellCoordsToKey(i),s=this._cache[t];this._activeCells[e]&&s&&this.addLayers(s)},this))},cellLeave:function(t,i){this._zooming||e.Util.requestAnimFrame(e.Util.bind(function(){if(this._map){var t=this._cacheKey(i),e=this._cellCoordsToKey(i),s=this._cache[t],r=this._map.getBounds();if(!this._activeCells[e]&&s){for(var o=!0,n=0;n (http://patrickarlt.com)\",\n \"browser\": \"dist/esri-leaflet-debug.js\",\n \"bugs\": {\n \"url\": \"https://github.com/esri/esri-leaflet/issues\"\n },\n \"contributors\": [\n \"Patrick Arlt (http://patrickarlt.com)\",\n \"John Gravois (http://johngravois.com)\"\n ],\n \"dependencies\": {\n \"arcgis-to-geojson-utils\": \"^1.0.1\",\n \"leaflet\": \"^1.0.0-beta.2\",\n \"leaflet-virtual-grid\": \"^1.0.3\",\n \"tiny-binary-search\": \"^1.0.2\"\n },\n \"devDependencies\": {\n \"chai\": \"2.3.0\",\n \"eslint\": \"^1.10.2\",\n \"gh-release\": \"^2.0.0\",\n \"highlight.js\": \"^8.0.0\",\n \"http-server\": \"^0.8.5\",\n \"isparta\": \"^3.0.3\",\n \"istanbul\": \"^0.4.2\",\n \"karma\": \"^0.12.16\",\n \"karma-chai-sinon\": \"^0.1.3\",\n \"karma-coverage\": \"^0.5.3\",\n \"karma-mocha\": \"^0.1.0\",\n \"karma-mocha-reporter\": \"^0.2.5\",\n \"karma-phantomjs-launcher\": \"^0.2.0\",\n \"karma-sourcemap-loader\": \"^0.3.5\",\n \"load-grunt-tasks\": \"^0.4.0\",\n \"mkdirp\": \"^0.5.1\",\n \"mocha\": \"^2.3.4\",\n \"phantomjs\": \"^1.9.17\",\n \"rollup\": \"^0.25.4\",\n \"rollup-plugin-json\": \"^2.0.0\",\n \"rollup-plugin-node-resolve\": \"^1.4.0\",\n \"rollup-plugin-npm\": \"^1.2.1\",\n \"rollup-plugin-uglify\": \"^0.1.0\",\n \"semistandard\": \"^7.0.5\",\n \"sinon\": \"^1.11.1\",\n \"sinon-chai\": \"2.7.0\",\n \"snazzy\": \"^2.0.1\",\n \"uglify-js\": \"^2.6.1\",\n \"watch\": \"^0.17.1\"\n },\n \"homepage\": \"http://esri.github.io/esri-leaflet\",\n \"jsnext:main\": \"src/EsriLeaflet.js\",\n \"jspm\": {\n \"registry\": \"npm\",\n \"format\": \"es6\",\n \"main\": \"src/EsriLeaflet.js\"\n },\n \"keywords\": [\n \"arcgis\",\n \"esri\",\n \"esri leaflet\",\n \"gis\",\n \"leaflet plugin\",\n \"mapping\"\n ],\n \"license\": \"Apache-2.0\",\n \"main\": \"dist/esri-leaflet-debug.js\",\n \"readmeFilename\": \"README.md\",\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"git@github.com:Esri/esri-leaflet.git\"\n },\n \"scripts\": {\n \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n \"lint\": \"semistandard src/**/*.js | snazzy\",\n \"prebuild\": \"mkdirp dist\",\n \"prepublish\": \"npm run build\",\n \"pretest\": \"npm run build\",\n \"release\": \"./scripts/release.sh\",\n \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\",\n \"test\": \"npm run lint && karma start\"\n }\n}\n","export var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest()));\nexport var pointerEvents = document.documentElement.style.pointerEvents === '';\n\nexport var Support = {\n cors: cors,\n pointerEvents: pointerEvents\n};\n\nexport default Support;\n","/*\n * Copyright 2015 Esri\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the Liscense.\n */\n\n// checks if 2 x,y points are equal\nfunction pointsEqual (a, b) {\n for (var i = 0; i < a.length; i++) {\n if (a[i] !== b[i]) {\n return false;\n }\n }\n return true;\n}\n\n// checks if the first and last points of a ring are equal and closes the ring\nfunction closeRing (coordinates) {\n if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {\n coordinates.push(coordinates[0]);\n }\n return coordinates;\n}\n\n// determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring\n// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-\n// points-are-in-clockwise-order\nfunction ringIsClockwise (ringToTest) {\n var total = 0;\n var i = 0;\n var rLength = ringToTest.length;\n var pt1 = ringToTest[i];\n var pt2;\n for (i; i < rLength - 1; i++) {\n pt2 = ringToTest[i + 1];\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);\n pt1 = pt2;\n }\n return (total >= 0);\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519\nfunction vertexIntersectsVertex (a1, a2, b1, b2) {\n var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);\n var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);\n var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);\n\n if (uB !== 0) {\n var ua = uaT / uB;\n var ub = ubT / uB;\n\n if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {\n return true;\n }\n }\n\n return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531\nfunction arrayIntersectsArray (a, b) {\n for (var i = 0; i < a.length - 1; i++) {\n for (var j = 0; j < b.length - 1; j++) {\n if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) {\n return true;\n }\n }\n }\n\n return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480\nfunction coordinatesContainPoint (coordinates, point) {\n var contains = false;\n for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {\n if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||\n (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&\n (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {\n contains = !contains;\n }\n }\n return contains;\n}\n\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113\nfunction coordinatesContainCoordinates (outer, inner) {\n var intersects = arrayIntersectsArray(outer, inner);\n var contains = coordinatesContainPoint(outer, inner[0]);\n if (!intersects && contains) {\n return true;\n }\n return false;\n}\n\n// do any polygons in this array contain any other polygons in this array?\n// used for checking for holes in arcgis rings\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172\nfunction convertRingsToGeoJSON (rings) {\n var outerRings = [];\n var holes = [];\n var x; // iterator\n var outerRing; // current outer ring being evaluated\n var hole; // current hole being evaluated\n\n // for each ring\n for (var r = 0; r < rings.length; r++) {\n var ring = closeRing(rings[r].slice(0));\n if (ring.length < 4) {\n continue;\n }\n // is this ring an outer ring? is it clockwise?\n if (ringIsClockwise(ring)) {\n var polygon = [ ring ];\n outerRings.push(polygon); // push to outer rings\n } else {\n holes.push(ring); // counterclockwise push to holes\n }\n }\n\n var uncontainedHoles = [];\n\n // while there are holes left...\n while (holes.length) {\n // pop a hole off out stack\n hole = holes.pop();\n\n // loop over all outer rings and see if they contain our hole.\n var contained = false;\n for (x = outerRings.length - 1; x >= 0; x--) {\n outerRing = outerRings[x][0];\n if (coordinatesContainCoordinates(outerRing, hole)) {\n // the hole is contained push it into our polygon\n outerRings[x].push(hole);\n contained = true;\n break;\n }\n }\n\n // ring is not contained in any outer ring\n // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320\n if (!contained) {\n uncontainedHoles.push(hole);\n }\n }\n\n // if we couldn't match any holes using contains we can try intersects...\n while (uncontainedHoles.length) {\n // pop a hole off out stack\n hole = uncontainedHoles.pop();\n\n // loop over all outer rings and see if any intersect our hole.\n var intersects = false;\n\n for (x = outerRings.length - 1; x >= 0; x--) {\n outerRing = outerRings[x][0];\n if (arrayIntersectsArray(outerRing, hole)) {\n // the hole is contained push it into our polygon\n outerRings[x].push(hole);\n intersects = true;\n break;\n }\n }\n\n if (!intersects) {\n outerRings.push([hole.reverse()]);\n }\n }\n\n if (outerRings.length === 1) {\n return {\n type: 'Polygon',\n coordinates: outerRings[0]\n };\n } else {\n return {\n type: 'MultiPolygon',\n coordinates: outerRings\n };\n }\n}\n\n// This function ensures that rings are oriented in the right directions\n// outer rings are clockwise, holes are counterclockwise\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction orientRings (poly) {\n var output = [];\n var polygon = poly.slice(0);\n var outerRing = closeRing(polygon.shift().slice(0));\n if (outerRing.length >= 4) {\n if (!ringIsClockwise(outerRing)) {\n outerRing.reverse();\n }\n\n output.push(outerRing);\n\n for (var i = 0; i < polygon.length; i++) {\n var hole = closeRing(polygon[i].slice(0));\n if (hole.length >= 4) {\n if (ringIsClockwise(hole)) {\n hole.reverse();\n }\n output.push(hole);\n }\n }\n }\n\n return output;\n}\n\n// This function flattens holes in multipolygons to one array of polygons\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction flattenMultiPolygonRings (rings) {\n var output = [];\n for (var i = 0; i < rings.length; i++) {\n var polygon = orientRings(rings[i]);\n for (var x = polygon.length - 1; x >= 0; x--) {\n var ring = polygon[x].slice(0);\n output.push(ring);\n }\n }\n return output;\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nfunction shallowClone (obj) {\n var target = {};\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n target[i] = obj[i];\n }\n }\n return target;\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttribute) {\n var geojson = {};\n\n if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {\n geojson.type = 'Point';\n geojson.coordinates = [arcgis.x, arcgis.y];\n }\n\n if (arcgis.points) {\n geojson.type = 'MultiPoint';\n geojson.coordinates = arcgis.points.slice(0);\n }\n\n if (arcgis.paths) {\n if (arcgis.paths.length === 1) {\n geojson.type = 'LineString';\n geojson.coordinates = arcgis.paths[0].slice(0);\n } else {\n geojson.type = 'MultiLineString';\n geojson.coordinates = arcgis.paths.slice(0);\n }\n }\n\n if (arcgis.rings) {\n geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));\n }\n\n if (arcgis.geometry || arcgis.attributes) {\n geojson.type = 'Feature';\n geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON(arcgis.geometry) : null;\n geojson.properties = (arcgis.attributes) ? shallowClone(arcgis.attributes) : null;\n if (arcgis.attributes) {\n geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID;\n }\n }\n\n return geojson;\n}\n\nexport function geojsonToArcGIS (geojson, idAttribute) {\n idAttribute = idAttribute || 'OBJECTID';\n var spatialReference = { wkid: 4326 };\n var result = {};\n var i;\n\n switch (geojson.type) {\n case 'Point':\n result.x = geojson.coordinates[0];\n result.y = geojson.coordinates[1];\n result.spatialReference = spatialReference;\n break;\n case 'MultiPoint':\n result.points = geojson.coordinates.slice(0);\n result.spatialReference = spatialReference;\n break;\n case 'LineString':\n result.paths = [geojson.coordinates.slice(0)];\n result.spatialReference = spatialReference;\n break;\n case 'MultiLineString':\n result.paths = geojson.coordinates.slice(0);\n result.spatialReference = spatialReference;\n break;\n case 'Polygon':\n result.rings = orientRings(geojson.coordinates.slice(0));\n result.spatialReference = spatialReference;\n break;\n case 'MultiPolygon':\n result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));\n result.spatialReference = spatialReference;\n break;\n case 'Feature':\n if (geojson.geometry) {\n result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);\n }\n result.attributes = (geojson.properties) ? shallowClone(geojson.properties) : {};\n if (geojson.id) {\n result.attributes[idAttribute] = geojson.id;\n }\n break;\n case 'FeatureCollection':\n result = [];\n for (i = 0; i < geojson.features.length; i++) {\n result.push(geojsonToArcGIS(geojson.features[i], idAttribute));\n }\n break;\n case 'GeometryCollection':\n result = [];\n for (i = 0; i < geojson.geometries.length; i++) {\n result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));\n }\n break;\n }\n\n return result;\n}\n","import L from 'leaflet';\nimport {\n geojsonToArcGIS as g2a,\n arcgisToGeoJSON as a2g\n} from 'arcgis-to-geojson-utils';\n\nexport function geojsonToArcGIS (geojson, idAttr) {\n return g2a(geojson, idAttr);\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttr) {\n return a2g(arcgis, idAttr);\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nexport function shallowClone (obj) {\n var target = {};\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n target[i] = obj[i];\n }\n }\n return target;\n}\n\n// convert an extent (ArcGIS) to LatLngBounds (Leaflet)\nexport function extentToBounds (extent) {\n var sw = L.latLng(extent.ymin, extent.xmin);\n var ne = L.latLng(extent.ymax, extent.xmax);\n return L.latLngBounds(sw, ne);\n}\n\n// convert an LatLngBounds (Leaflet) to extent (ArcGIS)\nexport function boundsToExtent (bounds) {\n bounds = L.latLngBounds(bounds);\n return {\n 'xmin': bounds.getSouthWest().lng,\n 'ymin': bounds.getSouthWest().lat,\n 'xmax': bounds.getNorthEast().lng,\n 'ymax': bounds.getNorthEast().lat,\n 'spatialReference': {\n 'wkid': 4326\n }\n };\n}\n\nexport function responseToFeatureCollection (response, idAttribute) {\n var objectIdField;\n\n if (idAttribute) {\n objectIdField = idAttribute;\n } else if (response.objectIdFieldName) {\n objectIdField = response.objectIdFieldName;\n } else if (response.fields) {\n for (var j = 0; j <= response.fields.length - 1; j++) {\n if (response.fields[j].type === 'esriFieldTypeOID') {\n objectIdField = response.fields[j].name;\n break;\n }\n }\n } else {\n objectIdField = 'OBJECTID';\n }\n\n var featureCollection = {\n type: 'FeatureCollection',\n features: []\n };\n var features = response.features || response.results;\n if (features.length) {\n for (var i = features.length - 1; i >= 0; i--) {\n var feature = arcgisToGeoJSON(features[i], objectIdField);\n featureCollection.features.push(feature);\n }\n }\n\n return featureCollection;\n}\n\n // trim url whitespace and add a trailing slash if needed\nexport function cleanUrl (url) {\n // trim leading and trailing spaces, but not spaces inside the url\n url = L.Util.trim(url);\n\n // add a trailing slash to the url if the user omitted it\n if (url[url.length - 1] !== '/') {\n url += '/';\n }\n\n return url;\n}\n\nexport function isArcgisOnline (url) {\n /* hosted feature services can emit geojson natively.\n our check for 'geojson' support will need to be revisted\n once the functionality makes its way to ArcGIS Server*/\n return (/\\.arcgis\\.com.*?FeatureServer/g).test(url);\n}\n\nexport function geojsonTypeToArcGIS (geoJsonType) {\n var arcgisGeometryType;\n switch (geoJsonType) {\n case 'Point':\n arcgisGeometryType = 'esriGeometryPoint';\n break;\n case 'MultiPoint':\n arcgisGeometryType = 'esriGeometryMultipoint';\n break;\n case 'LineString':\n arcgisGeometryType = 'esriGeometryPolyline';\n break;\n case 'MultiLineString':\n arcgisGeometryType = 'esriGeometryPolyline';\n break;\n case 'Polygon':\n arcgisGeometryType = 'esriGeometryPolygon';\n break;\n case 'MultiPolygon':\n arcgisGeometryType = 'esriGeometryPolygon';\n break;\n }\n\n return arcgisGeometryType;\n}\n\nexport function warn () {\n if (console && console.warn) {\n console.warn.apply(console, arguments);\n }\n}\n\nexport var Util = {\n shallowClone: shallowClone,\n warn: warn,\n cleanUrl: cleanUrl,\n isArcgisOnline: isArcgisOnline,\n geojsonTypeToArcGIS: geojsonTypeToArcGIS,\n responseToFeatureCollection: responseToFeatureCollection,\n geojsonToArcGIS: geojsonToArcGIS,\n arcgisToGeoJSON: arcgisToGeoJSON,\n boundsToExtent: boundsToExtent,\n extentToBounds: extentToBounds\n};\n\nexport default Util;\n","import L from 'leaflet';\nimport Support from './Support';\nimport { warn } from './Util';\n\nvar callbacks = 0;\n\nfunction serialize (params) {\n var data = '';\n\n params.f = params.f || 'json';\n\n for (var key in params) {\n if (params.hasOwnProperty(key)) {\n var param = params[key];\n var type = Object.prototype.toString.call(param);\n var value;\n\n if (data.length) {\n data += '&';\n }\n\n if (type === '[object Array]') {\n value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(',');\n } else if (type === '[object Object]') {\n value = JSON.stringify(param);\n } else if (type === '[object Date]') {\n value = param.valueOf();\n } else {\n value = param;\n }\n\n data += encodeURIComponent(key) + '=' + encodeURIComponent(value);\n }\n }\n\n return data;\n}\n\nfunction createRequest (callback, context) {\n var httpRequest = new window.XMLHttpRequest();\n\n httpRequest.onerror = function (e) {\n httpRequest.onreadystatechange = L.Util.falseFn;\n\n callback.call(context, {\n error: {\n code: 500,\n message: 'XMLHttpRequest error'\n }\n }, null);\n };\n\n httpRequest.onreadystatechange = function () {\n var response;\n var error;\n\n if (httpRequest.readyState === 4) {\n try {\n response = JSON.parse(httpRequest.responseText);\n } catch (e) {\n response = null;\n error = {\n code: 500,\n message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.'\n };\n }\n\n if (!error && response.error) {\n error = response.error;\n response = null;\n }\n\n httpRequest.onerror = L.Util.falseFn;\n\n callback.call(context, error, response);\n }\n };\n\n httpRequest.ontimeout = function () {\n this.onerror();\n };\n\n return httpRequest;\n}\n\nfunction xmlHttpPost (url, params, callback, context) {\n var httpRequest = createRequest(callback, context);\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n\n httpRequest.open('POST', url);\n httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n httpRequest.send(serialize(params));\n\n return httpRequest;\n}\n\nfunction xmlHttpGet (url, params, callback, context) {\n var httpRequest = createRequest(callback, context);\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n\n httpRequest.open('GET', url + '?' + serialize(params), true);\n httpRequest.send(null);\n\n return httpRequest;\n}\n\n// AJAX handlers for CORS (modern browsers) or JSONP (older browsers)\nexport function request (url, params, callback, context) {\n var paramString = serialize(params);\n var httpRequest = createRequest(callback, context);\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n\n var requestLength = (url + '?' + paramString).length;\n\n // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest\n if (requestLength <= 2000 && Support.cors) {\n httpRequest.open('GET', url + '?' + paramString);\n httpRequest.send(null);\n\n // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest\n } else if (requestLength > 2000 && Support.cors) {\n httpRequest.open('POST', url);\n httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n httpRequest.send(paramString);\n\n // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request\n } else if (requestLength <= 2000 && !Support.cors) {\n return jsonp(url, params, callback, context);\n\n // request is longer then 2000 characters and the browser does not support CORS, log a warning\n } else {\n warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html');\n return;\n }\n\n return httpRequest;\n}\n\nexport function jsonp (url, params, callback, context) {\n window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {};\n var callbackId = 'c' + callbacks;\n\n params.callback = 'window._EsriLeafletCallbacks.' + callbackId;\n\n var script = L.DomUtil.create('script', null, document.body);\n script.type = 'text/javascript';\n script.src = url + '?' + serialize(params);\n script.id = callbackId;\n\n window._EsriLeafletCallbacks[callbackId] = function (response) {\n if (window._EsriLeafletCallbacks[callbackId] !== true) {\n var error;\n var responseType = Object.prototype.toString.call(response);\n\n if (!(responseType === '[object Object]' || responseType === '[object Array]')) {\n error = {\n error: {\n code: 500,\n message: 'Expected array or object as JSONP response'\n }\n };\n response = null;\n }\n\n if (!error && response.error) {\n error = response;\n response = null;\n }\n\n callback.call(context, error, response);\n window._EsriLeafletCallbacks[callbackId] = true;\n }\n };\n\n callbacks++;\n\n return {\n id: callbackId,\n url: script.src,\n abort: function () {\n window._EsriLeafletCallbacks._callback[callbackId]({\n code: 0,\n message: 'Request aborted.'\n });\n }\n };\n}\n\nvar get = ((Support.cors) ? xmlHttpGet : jsonp);\nget.CORS = xmlHttpGet;\nget.JSONP = jsonp;\n\n// choose the correct AJAX handler depending on CORS support\nexport { get };\n\n// always use XMLHttpRequest for posts\nexport { xmlHttpPost as post };\n\n// export the Request object to call the different handlers for debugging\nexport var Request = {\n request: request,\n get: get,\n post: xmlHttpPost\n};\n\nexport default Request;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Task = L.Class.extend({\n\n options: {\n proxy: false,\n useCors: cors\n },\n\n // Generate a method for each methodName:paramName in the setters for this task.\n generateSetter: function (param, context) {\n return L.Util.bind(function (value) {\n this.params[param] = value;\n return this;\n }, context);\n },\n\n initialize: function (endpoint) {\n // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service\n if (endpoint.request && endpoint.options) {\n this._service = endpoint;\n L.Util.setOptions(this, endpoint.options);\n } else {\n L.Util.setOptions(this, endpoint);\n this.options.url = cleanUrl(endpoint.url);\n }\n\n // clone default params into this object\n this.params = L.Util.extend({}, this.params || {});\n\n // generate setter methods based on the setters object implimented a child class\n if (this.setters) {\n for (var setter in this.setters) {\n var param = this.setters[setter];\n this[setter] = this.generateSetter(param, this);\n }\n }\n },\n\n token: function (token) {\n if (this._service) {\n this._service.authenticate(token);\n } else {\n this.params.token = token;\n }\n return this;\n },\n\n request: function (callback, context) {\n if (this._service) {\n return this._service.request(this.path, this.params, callback, context);\n }\n\n return this._request('request', this.path, this.params, callback, context);\n },\n\n _request: function (method, path, params, callback, context) {\n var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n if ((method === 'get' || method === 'request') && !this.options.useCors) {\n return Request.get.JSONP(url, params, callback, context);\n }\n\n return Request[method](url, params, callback, context);\n }\n});\n\nexport function task (options) {\n return new Task(options);\n}\n\nexport default task;\n","import L from 'leaflet';\nimport { Task } from './Task';\nimport Util from '../Util';\n\nexport var Query = Task.extend({\n setters: {\n 'offset': 'offset',\n 'limit': 'limit',\n 'fields': 'outFields',\n 'precision': 'geometryPrecision',\n 'featureIds': 'objectIds',\n 'returnGeometry': 'returnGeometry',\n 'token': 'token'\n },\n\n path: 'query',\n\n params: {\n returnGeometry: true,\n where: '1=1',\n outSr: 4326,\n outFields: '*'\n },\n\n within: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer\n return this;\n },\n\n intersects: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelIntersects';\n return this;\n },\n\n contains: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer\n return this;\n },\n\n crosses: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelCrosses';\n return this;\n },\n\n touches: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelTouches';\n return this;\n },\n\n overlaps: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelOverlaps';\n return this;\n },\n\n // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n nearby: function (latlng, radius) {\n latlng = L.latLng(latlng);\n this.params.geometry = [latlng.lng, latlng.lat];\n this.params.geometryType = 'esriGeometryPoint';\n this.params.spatialRel = 'esriSpatialRelIntersects';\n this.params.units = 'esriSRUnit_Meter';\n this.params.distance = radius;\n this.params.inSr = 4326;\n return this;\n },\n\n where: function (string) {\n // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered\n this.params.where = string;\n return this;\n },\n\n between: function (start, end) {\n this.params.time = [start.valueOf(), end.valueOf()];\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n return this;\n },\n\n orderBy: function (fieldName, order) {\n order = order || 'ASC';\n this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : '';\n this.params.orderByFields += ([fieldName, order]).join(' ');\n return this;\n },\n\n run: function (callback, context) {\n this._cleanParams();\n\n // if the service is hosted on arcgis online request geojson directly\n if (Util.isArcgisOnline(this.options.url)) {\n this.params.f = 'geojson';\n\n return this.request(function (error, response) {\n this._trapSQLerrors(error);\n callback.call(context, error, response, response);\n }, this);\n\n // otherwise convert it in the callback then pass it on\n } else {\n return this.request(function (error, response) {\n this._trapSQLerrors(error);\n callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n }, this);\n }\n },\n\n count: function (callback, context) {\n this._cleanParams();\n this.params.returnCountOnly = true;\n return this.request(function (error, response) {\n callback.call(this, error, (response && response.count), response);\n }, context);\n },\n\n ids: function (callback, context) {\n this._cleanParams();\n this.params.returnIdsOnly = true;\n return this.request(function (error, response) {\n callback.call(this, error, (response && response.objectIds), response);\n }, context);\n },\n\n // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n bounds: function (callback, context) {\n this._cleanParams();\n this.params.returnExtentOnly = true;\n return this.request(function (error, response) {\n callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response);\n }, context);\n },\n\n // only valid for image services\n pixelSize: function (point) {\n point = L.point(point);\n this.params.pixelSize = [point.x, point.y];\n return this;\n },\n\n // only valid for map services\n layer: function (layer) {\n this.path = layer + '/query';\n return this;\n },\n\n _trapSQLerrors: function (error) {\n if (error) {\n if (error.code === '400') {\n Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes');\n }\n }\n },\n\n _cleanParams: function () {\n delete this.params.returnIdsOnly;\n delete this.params.returnExtentOnly;\n delete this.params.returnCountOnly;\n },\n\n _setGeometry: function (geometry) {\n this.params.inSr = 4326;\n\n // convert bounds to extent and finish\n if (geometry instanceof L.LatLngBounds) {\n // set geometry + geometryType\n this.params.geometry = Util.boundsToExtent(geometry);\n this.params.geometryType = 'esriGeometryEnvelope';\n return;\n }\n\n // convert L.Marker > L.LatLng\n if (geometry.getLatLng) {\n geometry = geometry.getLatLng();\n }\n\n // convert L.LatLng to a geojson point and continue;\n if (geometry instanceof L.LatLng) {\n geometry = {\n type: 'Point',\n coordinates: [geometry.lng, geometry.lat]\n };\n }\n\n // handle L.GeoJSON, pull out the first geometry\n if (geometry instanceof L.GeoJSON) {\n // reassign geometry to the GeoJSON value (we are assuming that only one feature is present)\n geometry = geometry.getLayers()[0].feature.geometry;\n this.params.geometry = Util.geojsonToArcGIS(geometry);\n this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n }\n\n // Handle L.Polyline and L.Polygon\n if (geometry.toGeoJSON) {\n geometry = geometry.toGeoJSON();\n }\n\n // handle GeoJSON feature by pulling out the geometry\n if (geometry.type === 'Feature') {\n // get the geometry of the geojson feature\n geometry = geometry.geometry;\n }\n\n // confirm that our GeoJSON is a point, line or polygon\n if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n this.params.geometry = Util.geojsonToArcGIS(geometry);\n this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n return;\n }\n\n // warn the user if we havn't found a\n /* global console */\n Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object');\n\n return;\n }\n});\n\nexport function query (options) {\n return new Query(options);\n}\n\nexport default query;\n","import { Task } from './Task';\nimport Util from '../Util';\n\nexport var Find = Task.extend({\n setters: {\n // method name > param name\n 'contains': 'contains',\n 'text': 'searchText',\n 'fields': 'searchFields', // denote an array or single string\n 'spatialReference': 'sr',\n 'sr': 'sr',\n 'layers': 'layers',\n 'returnGeometry': 'returnGeometry',\n 'maxAllowableOffset': 'maxAllowableOffset',\n 'precision': 'geometryPrecision',\n 'dynamicLayers': 'dynamicLayers',\n 'returnZ': 'returnZ',\n 'returnM': 'returnM',\n 'gdbVersion': 'gdbVersion',\n 'token': 'token'\n },\n\n path: 'find',\n\n params: {\n sr: 4326,\n contains: true,\n returnGeometry: true,\n returnZ: true,\n returnM: false\n },\n\n layerDefs: function (id, where) {\n this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n this.params.layerDefs += ([id, where]).join(':');\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n return this;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n }, context);\n }\n});\n\nexport function find (options) {\n return new Find(options);\n}\n\nexport default find;\n","import { Task } from './Task';\n\nexport var Identify = Task.extend({\n path: 'identify',\n\n between: function (start, end) {\n this.params.time = [start.valueOf(), end.valueOf()];\n return this;\n }\n});\n\nexport function identify (options) {\n return new Identify(options);\n}\n\nexport default identify;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyFeatures = Identify.extend({\n setters: {\n 'layers': 'layers',\n 'precision': 'geometryPrecision',\n 'tolerance': 'tolerance',\n 'returnGeometry': 'returnGeometry'\n },\n\n params: {\n sr: 4326,\n layers: 'all',\n tolerance: 3,\n returnGeometry: true\n },\n\n on: function (map) {\n var extent = Util.boundsToExtent(map.getBounds());\n var size = map.getSize();\n this.params.imageDisplay = [size.x, size.y, 96];\n this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax];\n return this;\n },\n\n at: function (latlng) {\n latlng = L.latLng(latlng);\n this.params.geometry = [latlng.lng, latlng.lat];\n this.params.geometryType = 'esriGeometryPoint';\n return this;\n },\n\n layerDef: function (id, where) {\n this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n this.params.layerDefs += ([id, where]).join(':');\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor);\n return this;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n // immediately invoke with an error\n if (error) {\n callback.call(context, error, undefined, response);\n return;\n\n // ok no error lets just assume we have features...\n } else {\n var featureCollection = Util.responseToFeatureCollection(response);\n response.results = response.results.reverse();\n for (var i = 0; i < featureCollection.features.length; i++) {\n var feature = featureCollection.features[i];\n feature.layerId = response.results[i].layerId;\n }\n callback.call(context, undefined, featureCollection, response);\n }\n });\n }\n});\n\nexport function identifyFeatures (options) {\n return new IdentifyFeatures(options);\n}\n\nexport default identifyFeatures;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyImage = Identify.extend({\n setters: {\n 'setMosaicRule': 'mosaicRule',\n 'setRenderingRule': 'renderingRule',\n 'setPixelSize': 'pixelSize',\n 'returnCatalogItems': 'returnCatalogItems',\n 'returnGeometry': 'returnGeometry'\n },\n\n params: {\n returnGeometry: false\n },\n\n at: function (latlng) {\n latlng = L.latLng(latlng);\n this.params.geometry = JSON.stringify({\n x: latlng.lng,\n y: latlng.lat,\n spatialReference: {\n wkid: 4326\n }\n });\n this.params.geometryType = 'esriGeometryPoint';\n return this;\n },\n\n getMosaicRule: function () {\n return this.params.mosaicRule;\n },\n\n getRenderingRule: function () {\n return this.params.renderingRule;\n },\n\n getPixelSize: function () {\n return this.params.pixelSize;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n callback.call(context, error, (response && this._responseToGeoJSON(response)), response);\n }, this);\n },\n\n // get pixel data and return as geoJSON point\n // populate catalog items (if any)\n // merging in any catalogItemVisibilities as a propery of each feature\n _responseToGeoJSON: function (response) {\n var location = response.location;\n var catalogItems = response.catalogItems;\n var catalogItemVisibilities = response.catalogItemVisibilities;\n var geoJSON = {\n 'pixel': {\n 'type': 'Feature',\n 'geometry': {\n 'type': 'Point',\n 'coordinates': [location.x, location.y]\n },\n 'crs': {\n 'type': 'EPSG',\n 'properties': {\n 'code': location.spatialReference.wkid\n }\n },\n 'properties': {\n 'OBJECTID': response.objectId,\n 'name': response.name,\n 'value': response.value\n },\n 'id': response.objectId\n }\n };\n\n if (response.properties && response.properties.Values) {\n geoJSON.pixel.properties.values = response.properties.Values;\n }\n\n if (catalogItems && catalogItems.features) {\n geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems);\n if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) {\n for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) {\n geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i];\n }\n }\n }\n return geoJSON;\n }\n\n});\n\nexport function identifyImage (params) {\n return new IdentifyImage(params);\n}\n\nexport default identifyImage;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Service = L.Evented.extend({\n\n options: {\n proxy: false,\n useCors: cors,\n timeout: 0\n },\n\n initialize: function (options) {\n options = options || {};\n this._requestQueue = [];\n this._authenticating = false;\n L.Util.setOptions(this, options);\n this.options.url = cleanUrl(this.options.url);\n },\n\n get: function (path, params, callback, context) {\n return this._request('get', path, params, callback, context);\n },\n\n post: function (path, params, callback, context) {\n return this._request('post', path, params, callback, context);\n },\n\n request: function (path, params, callback, context) {\n return this._request('request', path, params, callback, context);\n },\n\n metadata: function (callback, context) {\n return this._request('get', '', {}, callback, context);\n },\n\n authenticate: function (token) {\n this._authenticating = false;\n this.options.token = token;\n this._runQueue();\n return this;\n },\n\n getTimeout: function () {\n return this.options.timeout;\n },\n\n setTimeout: function (timeout) {\n this.options.timeout = timeout;\n },\n\n _request: function (method, path, params, callback, context) {\n this.fire('requeststart', {\n url: this.options.url + path,\n params: params,\n method: method\n }, true);\n\n var wrappedCallback = this._createServiceCallback(method, path, params, callback, context);\n\n if (this.options.token) {\n params.token = this.options.token;\n }\n\n if (this._authenticating) {\n this._requestQueue.push([method, path, params, callback, context]);\n return;\n } else {\n var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n if ((method === 'get' || method === 'request') && !this.options.useCors) {\n return Request.get.JSONP(url, params, wrappedCallback, context);\n } else {\n return Request[method](url, params, wrappedCallback, context);\n }\n }\n },\n\n _createServiceCallback: function (method, path, params, callback, context) {\n return L.Util.bind(function (error, response) {\n if (error && (error.code === 499 || error.code === 498)) {\n this._authenticating = true;\n\n this._requestQueue.push([method, path, params, callback, context]);\n\n // fire an event for users to handle and re-authenticate\n this.fire('authenticationrequired', {\n authenticate: L.Util.bind(this.authenticate, this)\n }, true);\n\n // if the user has access to a callback they can handle the auth error\n error.authenticate = L.Util.bind(this.authenticate, this);\n }\n\n callback.call(context, error, response);\n\n if (error) {\n this.fire('requesterror', {\n url: this.options.url + path,\n params: params,\n message: error.message,\n code: error.code,\n method: method\n }, true);\n } else {\n this.fire('requestsuccess', {\n url: this.options.url + path,\n params: params,\n response: response,\n method: method\n }, true);\n }\n\n this.fire('requestend', {\n url: this.options.url + path,\n params: params,\n method: method\n }, true);\n }, this);\n },\n\n _runQueue: function () {\n for (var i = this._requestQueue.length - 1; i >= 0; i--) {\n var request = this._requestQueue[i];\n var method = request.shift();\n this[method].apply(this, request);\n }\n this._requestQueue = [];\n }\n});\n\nexport function service (options) {\n return new Service(options);\n}\n\nexport default service;\n","import { Service } from './Service';\nimport identifyFeatures from '../Tasks/IdentifyFeatures';\nimport query from '../Tasks/Query';\nimport find from '../Tasks/Find';\n\nexport var MapService = Service.extend({\n\n identify: function () {\n return identifyFeatures(this);\n },\n\n find: function () {\n return find(this);\n },\n\n query: function () {\n return query(this);\n }\n\n});\n\nexport function mapService (options) {\n return new MapService(options);\n}\n\nexport default mapService;\n","import { Service } from './Service';\nimport identifyImage from '../Tasks/IdentifyImage';\nimport query from '../Tasks/Query';\n\nexport var ImageService = Service.extend({\n\n query: function () {\n return query(this);\n },\n\n identify: function () {\n return identifyImage(this);\n }\n});\n\nexport function imageService (options) {\n return new ImageService(options);\n}\n\nexport default imageService;\n","import { Service } from './Service';\nimport query from '../Tasks/Query';\nimport { geojsonToArcGIS } from '../Util';\n\nexport var FeatureLayerService = Service.extend({\n\n options: {\n idAttribute: 'OBJECTID'\n },\n\n query: function () {\n return query(this);\n },\n\n addFeature: function (feature, callback, context) {\n delete feature.id;\n\n feature = geojsonToArcGIS(feature);\n\n return this.post('addFeatures', {\n features: [feature]\n }, function (error, response) {\n var result = (response && response.addResults) ? response.addResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.addResults[0].error, result);\n }\n }, context);\n },\n\n updateFeature: function (feature, callback, context) {\n feature = geojsonToArcGIS(feature, this.options.idAttribute);\n\n return this.post('updateFeatures', {\n features: [feature]\n }, function (error, response) {\n var result = (response && response.updateResults) ? response.updateResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.updateResults[0].error, result);\n }\n }, context);\n },\n\n deleteFeature: function (id, callback, context) {\n return this.post('deleteFeatures', {\n objectIds: id\n }, function (error, response) {\n var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.deleteResults[0].error, result);\n }\n }, context);\n },\n\n deleteFeatures: function (ids, callback, context) {\n return this.post('deleteFeatures', {\n objectIds: ids\n }, function (error, response) {\n // pass back the entire array\n var result = (response && response.deleteResults) ? response.deleteResults : undefined;\n if (callback) {\n callback.call(context, error || response.deleteResults[0].error, result);\n }\n }, context);\n }\n});\n\nexport function featureLayerService (options) {\n return new FeatureLayerService(options);\n}\n\nexport default featureLayerService;\n","import L from 'leaflet';\n\nexport var Logo = L.Control.extend({\n options: {\n position: 'bottomright',\n marginTop: 0,\n marginLeft: 0,\n marginBottom: 0,\n marginRight: 0\n },\n\n onAdd: function () {\n var div = L.DomUtil.create('div', 'esri-leaflet-logo');\n div.style.marginTop = this.options.marginTop;\n div.style.marginLeft = this.options.marginLeft;\n div.style.marginBottom = this.options.marginBottom;\n div.style.marginRight = this.options.marginRight;\n div.innerHTML = '\"Powered';\n\n return div;\n }\n});\n\nexport default function logo (options) {\n return new Logo(options);\n}\n","import L from 'leaflet';\nimport logo from '../Controls/Logo';\nimport { jsonp } from '../Request';\nimport { pointerEvents } from '../Support';\n\nvar tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:';\n\nexport var BasemapLayer = L.TileLayer.extend({\n statics: {\n TILES: {\n Streets: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n Topographic: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n Oceans: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n OceansLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n NationalGeographic: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.'\n }\n },\n DarkGray: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n }\n },\n DarkGrayLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n\n }\n },\n Gray: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n }\n },\n GrayLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n Imagery: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'\n }\n },\n ImageryLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n ImageryTransportation: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n ShadedRelief: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n attribution: 'Esri, USGS'\n }\n },\n ShadedReliefLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 12,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n Terrain: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n attribution: 'Esri, USGS, NOAA'\n }\n },\n TerrainLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n }\n }\n },\n initialize: function (key, options) {\n var config;\n\n // set the config variable with the appropriate config object\n if (typeof key === 'object' && key.urlTemplate && key.options) {\n config = key;\n } else if (typeof key === 'string' && BasemapLayer.TILES[key]) {\n config = BasemapLayer.TILES[key];\n } else {\n throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of \"Streets\", \"Topographic\", \"Oceans\", \"OceansLabels\", \"NationalGeographic\", \"Gray\", \"GrayLabels\", \"DarkGray\", \"DarkGrayLabels\", \"Imagery\", \"ImageryLabels\", \"ImageryTransportation\", \"ShadedRelief\", \"ShadedReliefLabels\", \"Terrain\" or \"TerrainLabels\"');\n }\n\n // merge passed options into the config options\n var tileOptions = L.Util.extend(config.options, options);\n\n L.Util.setOptions(this, tileOptions);\n\n // call the initialize method on L.TileLayer to set everything up\n L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions);\n\n // if this basemap requires dynamic attribution set it up\n if (config.attributionUrl) {\n this._getAttributionData(config.attributionUrl);\n }\n\n this._logo = logo({\n position: this.options.logoPosition\n });\n },\n\n onAdd: function (map) {\n if (!this.options.hideLogo && !map._hasEsriLogo) {\n this._logo.addTo(map);\n map._hasEsriLogo = true;\n }\n\n if (this.options.pane === 'esri-labels') {\n this._initPane();\n }\n\n map.on('moveend', this._updateMapAttribution, this);\n\n L.TileLayer.prototype.onAdd.call(this, map);\n },\n\n onRemove: function (map) {\n // check to make sure the logo hasn't already been removed\n if (this._logo && this._logo._container) {\n map.removeControl(this._logo);\n map._hasEsriLogo = false;\n }\n\n map.off('moveend', this._updateMapAttribution, this);\n\n L.TileLayer.prototype.onRemove.call(this, map);\n },\n\n getAttribution: function () {\n if (this.options.attribution) {\n var attribution = '' + this.options.attribution + '';\n }\n return attribution;\n },\n\n _initPane: function () {\n if (!this._map.getPane(this.options.pane)) {\n var pane = this._map.createPane(this.options.pane);\n pane.style.pointerEvents = 'none';\n pane.style.zIndex = 500;\n }\n },\n\n _getAttributionData: function (url) {\n jsonp(url, {}, L.Util.bind(function (error, attributions) {\n if (error) { return; }\n this._attributions = [];\n\n for (var c = 0; c < attributions.contributors.length; c++) {\n var contributor = attributions.contributors[c];\n for (var i = 0; i < contributor.coverageAreas.length; i++) {\n var coverageArea = contributor.coverageAreas[i];\n var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]);\n var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]);\n this._attributions.push({\n attribution: contributor.attribution,\n score: coverageArea.score,\n bounds: L.latLngBounds(southWest, northEast),\n minZoom: coverageArea.zoomMin,\n maxZoom: coverageArea.zoomMax\n });\n }\n }\n\n this._attributions.sort(function (a, b) {\n return b.score - a.score;\n });\n\n this._updateMapAttribution();\n }, this));\n },\n\n _updateMapAttribution: function () {\n if (this._map && this._map.attributionControl && this._attributions) {\n var newAttributions = '';\n var bounds = this._map.getBounds();\n var zoom = this._map.getZoom();\n\n for (var i = 0; i < this._attributions.length; i++) {\n var attribution = this._attributions[i];\n var text = attribution.attribution;\n if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) {\n newAttributions += (', ' + text);\n }\n }\n newAttributions = newAttributions.substr(2);\n var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions');\n\n attributionElement.innerHTML = newAttributions;\n attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px';\n\n this.fire('attributionupdated', {\n attribution: newAttributions\n });\n }\n }\n});\n\nexport function basemapLayer (key, options) {\n return new BasemapLayer(key, options);\n}\n\nexport default basemapLayer;\n","import L from 'leaflet';\nimport {warn, cleanUrl} from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var TiledMapLayer = L.TileLayer.extend({\n options: {\n zoomOffsetAllowance: 0.1\n },\n\n statics: {\n MercatorZoomLevels: {\n '0': 156543.03392799999,\n '1': 78271.516963999893,\n '2': 39135.758482000099,\n '3': 19567.879240999901,\n '4': 9783.9396204999593,\n '5': 4891.9698102499797,\n '6': 2445.9849051249898,\n '7': 1222.9924525624899,\n '8': 611.49622628138002,\n '9': 305.74811314055802,\n '10': 152.874056570411,\n '11': 76.437028285073197,\n '12': 38.218514142536598,\n '13': 19.109257071268299,\n '14': 9.5546285356341496,\n '15': 4.7773142679493699,\n '16': 2.38865713397468,\n '17': 1.1943285668550501,\n '18': 0.59716428355981699,\n '19': 0.29858214164761698,\n '20': 0.14929107082381,\n '21': 0.07464553541191,\n '22': 0.0373227677059525,\n '23': 0.0186613838529763\n }\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n options = L.Util.setOptions(this, options);\n\n // set the urls\n this.tileUrl = options.url + 'tile/{z}/{y}/{x}';\n this.service = mapService(options);\n this.service.addEventParent(this);\n\n var arcgisonline = new RegExp(/tiles.arcgis(online)?\\.com/g);\n if (arcgisonline.test(options.url)) {\n this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');\n options.subdomains = ['1', '2', '3', '4'];\n }\n\n if (this.options.token) {\n this.tileUrl += ('?token=' + this.options.token);\n }\n\n // init layer by calling TileLayers initialize method\n L.TileLayer.prototype.initialize.call(this, this.tileUrl, options);\n },\n\n getTileUrl: function (tilePoint) {\n return L.Util.template(this.tileUrl, L.extend({\n s: this._getSubdomain(tilePoint),\n z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level\n x: tilePoint.x,\n y: tilePoint.y\n }, this.options));\n },\n\n createTile: function (coords, done) {\n var tile = document.createElement('img');\n\n L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile));\n L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile));\n\n if (this.options.crossOrigin) {\n tile.crossOrigin = '';\n }\n\n /*\n Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons\n http://www.w3.org/TR/WCAG20-TECHS/H67\n */\n tile.alt = '';\n\n // if there is no lod map or an lod map with a proper zoom load the tile\n // otherwise wait for the lod map to become available\n if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) {\n tile.src = this.getTileUrl(coords);\n } else {\n this.once('lodmap', function () {\n tile.src = this.getTileUrl(coords);\n }, this);\n }\n\n return tile;\n },\n\n onAdd: function (map) {\n if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) {\n this._lodMap = {};\n this.metadata(function (error, metadata) {\n if (!error) {\n var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid;\n if (sr === 102100 || sr === 3857) {\n // create the zoom level data\n var arcgisLODs = metadata.tileInfo.lods;\n var correctResolutions = TiledMapLayer.MercatorZoomLevels;\n\n for (var i = 0; i < arcgisLODs.length; i++) {\n var arcgisLOD = arcgisLODs[i];\n for (var ci in correctResolutions) {\n var correctRes = correctResolutions[ci];\n\n if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) {\n this._lodMap[ci] = arcgisLOD.level;\n break;\n }\n }\n }\n\n this.fire('lodmap');\n } else {\n warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html');\n }\n }\n }, this);\n }\n\n L.TileLayer.prototype.onAdd.call(this, map);\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n find: function () {\n return this.service.find();\n },\n\n query: function () {\n return this.service.query();\n },\n\n authenticate: function (token) {\n var tokenQs = '?token=' + token;\n this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs;\n this.options.token = token;\n this.service.authenticate(token);\n return this;\n },\n\n _withinPercentage: function (a, b, percentage) {\n var diff = Math.abs((a / b) - 1);\n return diff < percentage;\n }\n});\n\nexport function tiledMapLayer (url, options) {\n return new TiledMapLayer(url, options);\n}\n\nexport default tiledMapLayer;\n","import L from 'leaflet';\nimport {cors} from '../Support';\n\nvar Overlay = L.ImageOverlay.extend({\n onAdd: function (map) {\n this._topLeft = map.getPixelBounds().min;\n L.ImageOverlay.prototype.onAdd.call(this, map);\n },\n _reset: function () {\n if (this._map.options.crs === L.CRS.EPSG3857) {\n L.ImageOverlay.prototype._reset.call(this);\n } else {\n L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin()));\n }\n }\n});\n\nexport var RasterLayer = L.Layer.extend({\n\n options: {\n opacity: 1,\n position: 'front',\n f: 'image',\n useCors: cors,\n attribution: null,\n interactive: false,\n alt: ''\n },\n\n onAdd: function (map) {\n this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n\n map.on('moveend', this._update, this);\n\n // if we had an image loaded and it matches the\n // current bounds show the image otherwise remove it\n if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) {\n map.addLayer(this._currentImage);\n } else if (this._currentImage) {\n this._map.removeLayer(this._currentImage);\n this._currentImage = null;\n }\n\n this._update();\n\n if (this._popup) {\n this._map.on('click', this._getPopupData, this);\n this._map.on('dblclick', this._resetPopupState, this);\n }\n },\n\n onRemove: function (map) {\n if (this._currentImage) {\n this._map.removeLayer(this._currentImage);\n }\n\n if (this._popup) {\n this._map.off('click', this._getPopupData, this);\n this._map.off('dblclick', this._resetPopupState, this);\n }\n\n this._map.off('moveend', this._update, this);\n },\n\n bindPopup: function (fn, popupOptions) {\n this._shouldRenderPopup = false;\n this._lastClick = false;\n this._popup = L.popup(popupOptions);\n this._popupFunction = fn;\n if (this._map) {\n this._map.on('click', this._getPopupData, this);\n this._map.on('dblclick', this._resetPopupState, this);\n }\n return this;\n },\n\n unbindPopup: function () {\n if (this._map) {\n this._map.closePopup(this._popup);\n this._map.off('click', this._getPopupData, this);\n this._map.off('dblclick', this._resetPopupState, this);\n }\n this._popup = false;\n return this;\n },\n\n bringToFront: function () {\n this.options.position = 'front';\n if (this._currentImage) {\n this._currentImage.bringToFront();\n }\n return this;\n },\n\n bringToBack: function () {\n this.options.position = 'back';\n if (this._currentImage) {\n this._currentImage.bringToBack();\n }\n return this;\n },\n\n getAttribution: function () {\n return this.options.attribution;\n },\n\n getOpacity: function () {\n return this.options.opacity;\n },\n\n setOpacity: function (opacity) {\n this.options.opacity = opacity;\n this._currentImage.setOpacity(opacity);\n return this;\n },\n\n getTimeRange: function () {\n return [this.options.from, this.options.to];\n },\n\n setTimeRange: function (from, to) {\n this.options.from = from;\n this.options.to = to;\n this._update();\n return this;\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n authenticate: function (token) {\n this.service.authenticate(token);\n return this;\n },\n\n _renderImage: function (url, bounds) {\n if (this._map) {\n // create a new image overlay and add it to the map\n // to start loading the image\n // opacity is 0 while the image is loading\n var image = new Overlay(url, bounds, {\n opacity: 0,\n crossOrigin: this.options.useCors,\n alt: this.options.alt,\n pane: this.options.pane || this.getPane(),\n interactive: this.options.interactive\n }).addTo(this._map);\n\n // once the image loads\n image.once('load', function (e) {\n if (this._map) {\n var newImage = e.target;\n var oldImage = this._currentImage;\n\n // if the bounds of this image matches the bounds that\n // _renderImage was called with and we have a map with the same bounds\n // hide the old image if there is one and set the opacity\n // of the new image otherwise remove the new image\n if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) {\n this._currentImage = newImage;\n\n if (this.options.position === 'front') {\n this.bringToFront();\n } else {\n this.bringToBack();\n }\n\n if (this._map && this._currentImage._map) {\n this._currentImage.setOpacity(this.options.opacity);\n } else {\n this._currentImage._map.removeLayer(this._currentImage);\n }\n\n if (oldImage && this._map) {\n this._map.removeLayer(oldImage);\n }\n\n if (oldImage && oldImage._map) {\n oldImage._map.removeLayer(oldImage);\n }\n } else {\n this._map.removeLayer(newImage);\n }\n }\n\n this.fire('load', {\n bounds: bounds\n });\n }, this);\n\n this.fire('loading', {\n bounds: bounds\n });\n }\n },\n\n _update: function () {\n if (!this._map) {\n return;\n }\n\n var zoom = this._map.getZoom();\n var bounds = this._map.getBounds();\n\n if (this._animatingZoom) {\n return;\n }\n\n if (this._map._panTransition && this._map._panTransition._inProgress) {\n return;\n }\n\n if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n this._currentImage._map.removeLayer(this._currentImage);\n return;\n }\n\n var params = this._buildExportParams();\n\n this._requestExport(params, bounds);\n },\n\n _renderPopup: function (latlng, error, results, response) {\n latlng = L.latLng(latlng);\n if (this._shouldRenderPopup && this._lastClick.equals(latlng)) {\n // add the popup to the map where the mouse was clicked at\n var content = this._popupFunction(error, results, response);\n if (content) {\n this._popup.setLatLng(latlng).setContent(content).openOn(this._map);\n }\n }\n },\n\n _resetPopupState: function (e) {\n this._shouldRenderPopup = false;\n this._lastClick = e.latlng;\n }\n});\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport imageService from '../Services/ImageService';\n\nexport var ImageMapLayer = RasterLayer.extend({\n\n options: {\n updateInterval: 150,\n format: 'jpgpng',\n transparent: true,\n f: 'json'\n },\n\n query: function () {\n return this.service.query();\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n this.service = imageService(options);\n this.service.addEventParent(this);\n\n L.Util.setOptions(this, options);\n },\n\n setPixelType: function (pixelType) {\n this.options.pixelType = pixelType;\n this._update();\n return this;\n },\n\n getPixelType: function () {\n return this.options.pixelType;\n },\n\n setBandIds: function (bandIds) {\n if (L.Util.isArray(bandIds)) {\n this.options.bandIds = bandIds.join(',');\n } else {\n this.options.bandIds = bandIds.toString();\n }\n this._update();\n return this;\n },\n\n getBandIds: function () {\n return this.options.bandIds;\n },\n\n setNoData: function (noData, noDataInterpretation) {\n if (L.Util.isArray(noData)) {\n this.options.noData = noData.join(',');\n } else {\n this.options.noData = noData.toString();\n }\n if (noDataInterpretation) {\n this.options.noDataInterpretation = noDataInterpretation;\n }\n this._update();\n return this;\n },\n\n getNoData: function () {\n return this.options.noData;\n },\n\n getNoDataInterpretation: function () {\n return this.options.noDataInterpretation;\n },\n\n setRenderingRule: function (renderingRule) {\n this.options.renderingRule = renderingRule;\n this._update();\n },\n\n getRenderingRule: function () {\n return this.options.renderingRule;\n },\n\n setMosaicRule: function (mosaicRule) {\n this.options.mosaicRule = mosaicRule;\n this._update();\n },\n\n getMosaicRule: function () {\n return this.options.mosaicRule;\n },\n\n _getPopupData: function (e) {\n var callback = L.Util.bind(function (error, results, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n setTimeout(L.Util.bind(function () {\n this._renderPopup(e.latlng, error, results, response);\n }, this), 300);\n }, this);\n\n var identifyRequest = this.identify().at(e.latlng);\n\n // set mosaic rule for identify task if it is set for layer\n if (this.options.mosaicRule) {\n identifyRequest.setMosaicRule(this.options.mosaicRule);\n // @TODO: force return catalog items too?\n }\n\n // @TODO: set rendering rule? Not sure,\n // sometimes you want raw pixel values\n // if (this.options.renderingRule) {\n // identifyRequest.setRenderingRule(this.options.renderingRule);\n // }\n\n identifyRequest.run(callback);\n\n // set the flags to show the popup\n this._shouldRenderPopup = true;\n this._lastClick = e.latlng;\n },\n\n _buildExportParams: function () {\n var bounds = this._map.getBounds();\n var size = this._map.getSize();\n var ne = this._map.options.crs.project(bounds._northEast);\n var sw = this._map.options.crs.project(bounds._southWest);\n var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n var params = {\n bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n size: size.x + ',' + size.y,\n format: this.options.format,\n transparent: this.options.transparent,\n bboxSR: sr,\n imageSR: sr\n };\n\n if (this.options.from && this.options.to) {\n params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n }\n\n if (this.options.pixelType) {\n params.pixelType = this.options.pixelType;\n }\n\n if (this.options.interpolation) {\n params.interpolation = this.options.interpolation;\n }\n\n if (this.options.compressionQuality) {\n params.compressionQuality = this.options.compressionQuality;\n }\n\n if (this.options.bandIds) {\n params.bandIds = this.options.bandIds;\n }\n\n if (this.options.noData) {\n params.noData = this.options.noData;\n }\n\n if (this.options.noDataInterpretation) {\n params.noDataInterpretation = this.options.noDataInterpretation;\n }\n\n if (this.service.options.token) {\n params.token = this.service.options.token;\n }\n\n if (this.options.renderingRule) {\n params.renderingRule = JSON.stringify(this.options.renderingRule);\n }\n\n if (this.options.mosaicRule) {\n params.mosaicRule = JSON.stringify(this.options.mosaicRule);\n }\n\n return params;\n },\n\n _requestExport: function (params, bounds) {\n if (this.options.f === 'json') {\n this.service.request('exportImage', params, function (error, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n this._renderImage(response.href, bounds);\n }, this);\n } else {\n params.f = 'image';\n this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds);\n }\n }\n});\n\nexport function imageMapLayer (url, options) {\n return new ImageMapLayer(url, options);\n}\n\nexport default imageMapLayer;\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var DynamicMapLayer = RasterLayer.extend({\n\n options: {\n updateInterval: 150,\n layers: false,\n layerDefs: false,\n timeOptions: false,\n format: 'png24',\n transparent: true,\n f: 'json'\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n this.service = mapService(options);\n this.service.addEventParent(this);\n\n if ((options.proxy || options.token) && options.f !== 'json') {\n options.f = 'json';\n }\n L.Util.setOptions(this, options);\n },\n\n getDynamicLayers: function () {\n return this.options.dynamicLayers;\n },\n\n setDynamicLayers: function (dynamicLayers) {\n this.options.dynamicLayers = dynamicLayers;\n this._update();\n return this;\n },\n\n getLayers: function () {\n return this.options.layers;\n },\n\n setLayers: function (layers) {\n this.options.layers = layers;\n this._update();\n return this;\n },\n\n getLayerDefs: function () {\n return this.options.layerDefs;\n },\n\n setLayerDefs: function (layerDefs) {\n this.options.layerDefs = layerDefs;\n this._update();\n return this;\n },\n\n getTimeOptions: function () {\n return this.options.timeOptions;\n },\n\n setTimeOptions: function (timeOptions) {\n this.options.timeOptions = timeOptions;\n this._update();\n return this;\n },\n\n query: function () {\n return this.service.query();\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n find: function () {\n return this.service.find();\n },\n\n _getPopupData: function (e) {\n var callback = L.Util.bind(function (error, featureCollection, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n setTimeout(L.Util.bind(function () {\n this._renderPopup(e.latlng, error, featureCollection, response);\n }, this), 300);\n }, this);\n\n var identifyRequest = this.identify().on(this._map).at(e.latlng);\n\n if (this.options.layers) {\n identifyRequest.layers('visible:' + this.options.layers.join(','));\n } else {\n identifyRequest.layers('visible');\n }\n\n identifyRequest.run(callback);\n\n // set the flags to show the popup\n this._shouldRenderPopup = true;\n this._lastClick = e.latlng;\n },\n\n _buildExportParams: function () {\n var bounds = this._map.getBounds();\n var size = this._map.getSize();\n var ne = this._map.options.crs.project(bounds.getNorthEast());\n var sw = this._map.options.crs.project(bounds.getSouthWest());\n var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n var top = this._map.latLngToLayerPoint(bounds._northEast);\n var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n if (top.y > 0 || bottom.y < size.y) {\n size.y = bottom.y - top.y;\n }\n\n var params = {\n bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n size: size.x + ',' + size.y,\n dpi: 96,\n format: this.options.format,\n transparent: this.options.transparent,\n bboxSR: sr,\n imageSR: sr\n };\n\n if (this.options.dynamicLayers) {\n params.dynamicLayers = this.options.dynamicLayers;\n }\n\n if (this.options.layers) {\n params.layers = 'show:' + this.options.layers.join(',');\n }\n\n if (this.options.layerDefs) {\n params.layerDefs = JSON.stringify(this.options.layerDefs);\n }\n\n if (this.options.timeOptions) {\n params.timeOptions = JSON.stringify(this.options.timeOptions);\n }\n\n if (this.options.from && this.options.to) {\n params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n }\n\n if (this.service.options.token) {\n params.token = this.service.options.token;\n }\n\n return params;\n },\n\n _requestExport: function (params, bounds) {\n if (this.options.f === 'json') {\n this.service.request('export', params, function (error, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n this._renderImage(response.href, bounds);\n }, this);\n } else {\n params.f = 'image';\n this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds);\n }\n }\n});\n\nexport function dynamicMapLayer (url, options) {\n return new DynamicMapLayer(url, options);\n}\n\nexport default dynamicMapLayer;\n","import L from 'leaflet';\n\nvar VirtualGrid = L.Layer.extend({\n\n options: {\n cellSize: 512,\n updateInterval: 150\n },\n\n initialize: function (options) {\n options = L.setOptions(this, options);\n this._ok = true;\n },\n\n onAdd: function (map) {\n this._map = map;\n this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n this._reset();\n this._update();\n },\n\n onRemove: function () {\n this._map.removeEventListener(this.getEvents(), this);\n this._removeCells();\n },\n\n getEvents: function () {\n var events = {\n moveend: this._update,\n movestart: this._start,\n zoomend: this._reset\n };\n\n return events;\n },\n\n addTo: function (map) {\n map.addLayer(this);\n return this;\n },\n\n removeFrom: function (map) {\n map.removeLayer(this);\n return this;\n },\n\n _start: function () {\n this._ok = true;\n },\n\n _reset: function () {\n if (!this._ok) {\n return;\n }\n\n this._removeCells();\n\n this._cells = {};\n this._activeCells = {};\n this._cellsToLoad = 0;\n this._cellsTotal = 0;\n this._cellNumBounds = this._getCellNumBounds();\n\n this._resetWrap();\n this._zooming = false;\n },\n\n _resetWrap: function () {\n var map = this._map;\n var crs = map.options.crs;\n\n if (crs.infinite) { return; }\n\n var cellSize = this._getCellSize();\n\n if (crs.wrapLng) {\n this._wrapLng = [\n Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize),\n Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize)\n ];\n }\n\n if (crs.wrapLat) {\n this._wrapLat = [\n Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize),\n Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize)\n ];\n }\n },\n\n _getCellSize: function () {\n return this.options.cellSize;\n },\n\n _update: function () {\n if (!this._ok) {\n return;\n }\n\n if (!this._map) {\n return;\n }\n\n var bounds = this._map.getPixelBounds();\n var cellSize = this._getCellSize();\n\n // cell coordinates range for the current view\n var cellBounds = L.bounds(\n bounds.min.divideBy(cellSize).floor(),\n bounds.max.divideBy(cellSize).floor());\n\n this._removeOtherCells(cellBounds);\n this._addCells(cellBounds);\n\n this.fire('cellsupdated');\n\n this._ok = false;\n },\n\n _addCells: function (bounds) {\n var queue = [];\n var center = bounds.getCenter();\n var zoom = this._map.getZoom();\n\n var j, i, coords;\n // create a queue of coordinates to load cells from\n for (j = bounds.min.y; j <= bounds.max.y; j++) {\n for (i = bounds.min.x; i <= bounds.max.x; i++) {\n coords = L.point(i, j);\n coords.z = zoom;\n\n if (this._isValidCell(coords)) {\n queue.push(coords);\n }\n }\n }\n\n var cellsToLoad = queue.length;\n\n if (cellsToLoad === 0) { return; }\n\n this._cellsToLoad += cellsToLoad;\n this._cellsTotal += cellsToLoad;\n\n // sort cell queue to load cells in order of their distance to center\n queue.sort(function (a, b) {\n return a.distanceTo(center) - b.distanceTo(center);\n });\n\n for (i = 0; i < cellsToLoad; i++) {\n this._addCell(queue[i]);\n }\n },\n\n _isValidCell: function (coords) {\n var crs = this._map.options.crs;\n\n if (!crs.infinite) {\n // don't load cell if it's out of bounds and not wrapped\n var bounds = this._cellNumBounds;\n if (\n (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) ||\n (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y))\n ) {\n return false;\n }\n }\n\n if (!this.options.bounds) {\n return true;\n }\n\n // don't load cell if it doesn't intersect the bounds in options\n var cellBounds = this._cellCoordsToBounds(coords);\n return L.latLngBounds(this.options.bounds).intersects(cellBounds);\n },\n\n // converts cell coordinates to its geographical bounds\n _cellCoordsToBounds: function (coords) {\n var map = this._map;\n var cellSize = this.options.cellSize;\n var nwPoint = coords.multiplyBy(cellSize);\n var sePoint = nwPoint.add([cellSize, cellSize]);\n var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z));\n var se = map.wrapLatLng(map.unproject(sePoint, coords.z));\n\n return L.latLngBounds(nw, se);\n },\n\n // converts cell coordinates to key for the cell cache\n _cellCoordsToKey: function (coords) {\n return coords.x + ':' + coords.y;\n },\n\n // converts cell cache key to coordiantes\n _keyToCellCoords: function (key) {\n var kArr = key.split(':');\n var x = parseInt(kArr[0], 10);\n var y = parseInt(kArr[1], 10);\n\n return L.point(x, y);\n },\n\n // remove any present cells that are off the specified bounds\n _removeOtherCells: function (bounds) {\n for (var key in this._cells) {\n if (!bounds.contains(this._keyToCellCoords(key))) {\n this._removeCell(key);\n }\n }\n },\n\n _removeCell: function (key) {\n var cell = this._activeCells[key];\n\n if (cell) {\n delete this._activeCells[key];\n\n if (this.cellLeave) {\n this.cellLeave(cell.bounds, cell.coords);\n }\n\n this.fire('cellleave', {\n bounds: cell.bounds,\n coords: cell.coords\n });\n }\n },\n\n _removeCells: function () {\n for (var key in this._cells) {\n var bounds = this._cells[key].bounds;\n var coords = this._cells[key].coords;\n\n if (this.cellLeave) {\n this.cellLeave(bounds, coords);\n }\n\n this.fire('cellleave', {\n bounds: bounds,\n coords: coords\n });\n }\n },\n\n _addCell: function (coords) {\n // wrap cell coords if necessary (depending on CRS)\n this._wrapCoords(coords);\n\n // generate the cell key\n var key = this._cellCoordsToKey(coords);\n\n // get the cell from the cache\n var cell = this._cells[key];\n // if this cell should be shown as isnt active yet (enter)\n\n if (cell && !this._activeCells[key]) {\n if (this.cellEnter) {\n this.cellEnter(cell.bounds, coords);\n }\n\n this.fire('cellenter', {\n bounds: cell.bounds,\n coords: coords\n });\n\n this._activeCells[key] = cell;\n }\n\n // if we dont have this cell in the cache yet (create)\n if (!cell) {\n cell = {\n coords: coords,\n bounds: this._cellCoordsToBounds(coords)\n };\n\n this._cells[key] = cell;\n this._activeCells[key] = cell;\n\n if (this.createCell) {\n this.createCell(cell.bounds, coords);\n }\n\n this.fire('cellcreate', {\n bounds: cell.bounds,\n coords: coords\n });\n }\n },\n\n _wrapCoords: function (coords) {\n coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x;\n coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y;\n },\n\n // get the global cell coordinates range for the current zoom\n _getCellNumBounds: function () {\n var bounds = this._map.getPixelWorldBounds();\n var size = this._getCellSize();\n\n return bounds ? L.bounds(\n bounds.min.divideBy(size).floor(),\n bounds.max.divideBy(size).ceil().subtract([1, 1])) : null;\n }\n});\n\nexport default VirtualGrid;\n","function BinarySearchIndex (values) {\n this.values = [].concat(values || []);\n}\n\nBinarySearchIndex.prototype.query = function (value) {\n var index = this.getIndex(value);\n return this.values[index];\n};\n\nBinarySearchIndex.prototype.getIndex = function getIndex (value) {\n if (this.dirty) {\n this.sort();\n }\n\n var minIndex = 0;\n var maxIndex = this.values.length - 1;\n var currentIndex;\n var currentElement;\n\n while (minIndex <= maxIndex) {\n currentIndex = (minIndex + maxIndex) / 2 | 0;\n currentElement = this.values[Math.round(currentIndex)];\n if (+currentElement.value < +value) {\n minIndex = currentIndex + 1;\n } else if (+currentElement.value > +value) {\n maxIndex = currentIndex - 1;\n } else {\n return currentIndex;\n }\n }\n\n return Math.abs(~maxIndex);\n};\n\nBinarySearchIndex.prototype.between = function between (start, end) {\n var startIndex = this.getIndex(start);\n var endIndex = this.getIndex(end);\n\n if (startIndex === 0 && endIndex === 0) {\n return [];\n }\n\n while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) {\n startIndex--;\n }\n\n while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) {\n endIndex++;\n }\n\n if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) {\n endIndex++;\n }\n\n return this.values.slice(startIndex, endIndex);\n};\n\nBinarySearchIndex.prototype.insert = function insert (item) {\n this.values.splice(this.getIndex(item.value), 0, item);\n return this;\n};\n\nBinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) {\n this.values = this.values.concat([].concat(items || []));\n\n if (sort) {\n this.sort();\n } else {\n this.dirty = true;\n }\n\n return this;\n};\n\nBinarySearchIndex.prototype.sort = function sort () {\n this.values.sort(function (a, b) {\n return +b.value - +a.value;\n }).reverse();\n this.dirty = false;\n return this;\n};\n\nexport default BinarySearchIndex;\n","import L from 'leaflet';\nimport featureLayerService from '../../Services/FeatureLayerService';\nimport { cleanUrl, warn } from '../../Util';\nimport VirtualGrid from 'leaflet-virtual-grid';\nimport BinarySearchIndex from 'tiny-binary-search';\n\nexport var FeatureManager = VirtualGrid.extend({\n /**\n * Options\n */\n\n options: {\n attribution: null,\n where: '1=1',\n fields: ['*'],\n from: false,\n to: false,\n timeField: false,\n timeFilterMode: 'server',\n simplifyFactor: 0,\n precision: 6\n },\n\n /**\n * Constructor\n */\n\n initialize: function (options) {\n VirtualGrid.prototype.initialize.call(this, options);\n\n options.url = cleanUrl(options.url);\n options = L.setOptions(this, options);\n\n this.service = featureLayerService(options);\n this.service.addEventParent(this);\n\n // use case insensitive regex to look for common fieldnames used for indexing\n if (this.options.fields[0] !== '*') {\n var oidCheck = false;\n for (var i = 0; i < this.options.fields.length; i++) {\n if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) {\n oidCheck = true;\n }\n }\n if (oidCheck === false) {\n warn('no known esriFieldTypeOID field detected in fields Array. Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.');\n }\n }\n\n if (this.options.timeField.start && this.options.timeField.end) {\n this._startTimeIndex = new BinarySearchIndex();\n this._endTimeIndex = new BinarySearchIndex();\n } else if (this.options.timeField) {\n this._timeIndex = new BinarySearchIndex();\n }\n\n this._cache = {};\n this._currentSnapshot = []; // cache of what layers should be active\n this._activeRequests = 0;\n },\n\n /**\n * Layer Interface\n */\n\n onAdd: function (map) {\n map.on('zoomend', this._handleZoomChange, this);\n\n return VirtualGrid.prototype.onAdd.call(this, map);\n },\n\n onRemove: function (map) {\n map.off('zoomend', this._handleZoomChange, this);\n\n return VirtualGrid.prototype.onRemove.call(this, map);\n },\n\n getAttribution: function () {\n return this.options.attribution;\n },\n\n /**\n * Feature Management\n */\n\n createCell: function (bounds, coords) {\n this._requestFeatures(bounds, coords);\n },\n\n _requestFeatures: function (bounds, coords, callback) {\n this._activeRequests++;\n\n // our first active request fires loading\n if (this._activeRequests === 1) {\n this.fire('loading', {\n bounds: bounds\n }, true);\n }\n\n return this._buildQuery(bounds).run(function (error, featureCollection, response) {\n if (response && response.exceededTransferLimit) {\n this.fire('drawlimitexceeded');\n }\n\n // no error, features\n if (!error && featureCollection && featureCollection.features.length) {\n // schedule adding features until the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this._addFeatures(featureCollection.features, coords);\n this._postProcessFeatures(bounds);\n }, this));\n }\n\n // no error, no features\n if (!error && featureCollection && !featureCollection.features.length) {\n this._postProcessFeatures(bounds);\n }\n\n if (error) {\n this._postProcessFeatures(bounds);\n }\n\n if (callback) {\n callback.call(this, error, featureCollection);\n }\n }, this);\n },\n\n _postProcessFeatures: function (bounds) {\n // deincriment the request counter now that we have processed features\n this._activeRequests--;\n\n // if there are no more active requests fire a load event for this view\n if (this._activeRequests <= 0) {\n this.fire('load', {\n bounds: bounds\n });\n }\n },\n\n _cacheKey: function (coords) {\n return coords.z + ':' + coords.x + ':' + coords.y;\n },\n\n _addFeatures: function (features, coords) {\n var key = this._cacheKey(coords);\n this._cache[key] = this._cache[key] || [];\n\n for (var i = features.length - 1; i >= 0; i--) {\n var id = features[i].id;\n this._currentSnapshot.push(id);\n this._cache[key].push(id);\n }\n\n if (this.options.timeField) {\n this._buildTimeIndexes(features);\n }\n\n // need to PR removal of the logic below too...\n // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102\n\n this.createLayers(features);\n },\n\n _buildQuery: function (bounds) {\n var query = this.service.query()\n .intersects(bounds)\n .where(this.options.where)\n .fields(this.options.fields)\n .precision(this.options.precision);\n\n if (this.options.simplifyFactor) {\n query.simplify(this._map, this.options.simplifyFactor);\n }\n\n if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) {\n query.between(this.options.from, this.options.to);\n }\n\n return query;\n },\n\n /**\n * Where Methods\n */\n\n setWhere: function (where, callback, context) {\n this.options.where = (where && where.length) ? where : '1=1';\n\n var oldSnapshot = [];\n var newSnapshot = [];\n var pendingRequests = 0;\n var requestError = null;\n var requestCallback = L.Util.bind(function (error, featureCollection) {\n if (error) {\n requestError = error;\n }\n\n if (featureCollection) {\n for (var i = featureCollection.features.length - 1; i >= 0; i--) {\n newSnapshot.push(featureCollection.features[i].id);\n }\n }\n\n pendingRequests--;\n\n if (pendingRequests <= 0) {\n this._currentSnapshot = newSnapshot;\n // schedule adding features for the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this.removeLayers(oldSnapshot);\n this.addLayers(newSnapshot);\n if (callback) {\n callback.call(context, requestError);\n }\n }, this));\n }\n }, this);\n\n for (var i = this._currentSnapshot.length - 1; i >= 0; i--) {\n oldSnapshot.push(this._currentSnapshot[i]);\n }\n\n for (var key in this._activeCells) {\n pendingRequests++;\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key, requestCallback);\n }\n\n return this;\n },\n\n getWhere: function () {\n return this.options.where;\n },\n\n /**\n * Time Range Methods\n */\n\n getTimeRange: function () {\n return [this.options.from, this.options.to];\n },\n\n setTimeRange: function (from, to, callback, context) {\n var oldFrom = this.options.from;\n var oldTo = this.options.to;\n var pendingRequests = 0;\n var requestError = null;\n var requestCallback = L.Util.bind(function (error) {\n if (error) {\n requestError = error;\n }\n this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n pendingRequests--;\n\n if (callback && pendingRequests <= 0) {\n callback.call(context, requestError);\n }\n }, this);\n\n this.options.from = from;\n this.options.to = to;\n\n this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n if (this.options.timeFilterMode === 'server') {\n for (var key in this._activeCells) {\n pendingRequests++;\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key, requestCallback);\n }\n }\n\n return this;\n },\n\n refresh: function () {\n for (var key in this._activeCells) {\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key);\n }\n\n if (this.redraw) {\n this.once('load', function () {\n this.eachFeature(function (layer) {\n this._redraw(layer.feature.id);\n }, this);\n }, this);\n }\n },\n\n _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) {\n var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot;\n var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo);\n\n if (layersToAdd.indexOf) {\n for (var i = 0; i < layersToAdd.length; i++) {\n var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]);\n if (shouldRemoveLayer >= 0) {\n layersToRemove.splice(shouldRemoveLayer, 1);\n }\n }\n }\n\n // schedule adding features until the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this.removeLayers(layersToRemove);\n this.addLayers(layersToAdd);\n }, this));\n },\n\n _getFeaturesInTimeRange: function (start, end) {\n var ids = [];\n var search;\n\n if (this.options.timeField.start && this.options.timeField.end) {\n var startTimes = this._startTimeIndex.between(start, end);\n var endTimes = this._endTimeIndex.between(start, end);\n search = startTimes.concat(endTimes);\n } else {\n search = this._timeIndex.between(start, end);\n }\n\n for (var i = search.length - 1; i >= 0; i--) {\n ids.push(search[i].id);\n }\n\n return ids;\n },\n\n _buildTimeIndexes: function (geojson) {\n var i;\n var feature;\n if (this.options.timeField.start && this.options.timeField.end) {\n var startTimeEntries = [];\n var endTimeEntries = [];\n for (i = geojson.length - 1; i >= 0; i--) {\n feature = geojson[i];\n startTimeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField.start])\n });\n endTimeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField.end])\n });\n }\n this._startTimeIndex.bulkAdd(startTimeEntries);\n this._endTimeIndex.bulkAdd(endTimeEntries);\n } else {\n var timeEntries = [];\n for (i = geojson.length - 1; i >= 0; i--) {\n feature = geojson[i];\n timeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField])\n });\n }\n\n this._timeIndex.bulkAdd(timeEntries);\n }\n },\n\n _featureWithinTimeRange: function (feature) {\n if (!this.options.from || !this.options.to) {\n return true;\n }\n\n var from = +this.options.from.valueOf();\n var to = +this.options.to.valueOf();\n\n if (typeof this.options.timeField === 'string') {\n var date = +feature.properties[this.options.timeField];\n return (date >= from) && (date <= to);\n }\n\n if (this.options.timeField.start && this.options.timeField.end) {\n var startDate = +feature.properties[this.options.timeField.start];\n var endDate = +feature.properties[this.options.timeField.end];\n return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to));\n }\n },\n\n _visibleZoom: function () {\n // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer\n if (!this._map) {\n return false;\n }\n var zoom = this._map.getZoom();\n if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n return false;\n } else { return true; }\n },\n\n _handleZoomChange: function () {\n if (!this._visibleZoom()) {\n this.removeLayers(this._currentSnapshot);\n this._currentSnapshot = [];\n } else {\n /*\n for every cell in this._activeCells\n 1. Get the cache key for the coords of the cell\n 2. If this._cache[key] exists it will be an array of feature IDs.\n 3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back.\n */\n for (var i in this._activeCells) {\n var coords = this._activeCells[i].coords;\n var key = this._cacheKey(coords);\n if (this._cache[key]) {\n this.addLayers(this._cache[key]);\n }\n }\n }\n },\n\n /**\n * Service Methods\n */\n\n authenticate: function (token) {\n this.service.authenticate(token);\n return this;\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n query: function () {\n return this.service.query();\n },\n\n _getMetadata: function (callback) {\n if (this._metadata) {\n var error;\n callback(error, this._metadata);\n } else {\n this.metadata(L.Util.bind(function (error, response) {\n this._metadata = response;\n callback(error, this._metadata);\n }, this));\n }\n },\n\n addFeature: function (feature, callback, context) {\n this._getMetadata(L.Util.bind(function (error, metadata) {\n if (error) {\n if (callback) { callback.call(this, error, null); }\n return;\n }\n\n this.service.addFeature(feature, L.Util.bind(function (error, response) {\n if (!error) {\n // assign ID from result to appropriate objectid field from service metadata\n feature.properties[metadata.objectIdField] = response.objectId;\n\n // we also need to update the geojson id for createLayers() to function\n feature.id = response.objectId;\n this.createLayers([feature]);\n }\n\n if (callback) {\n callback.call(context, error, response);\n }\n }, this));\n }, this));\n },\n\n updateFeature: function (feature, callback, context) {\n this.service.updateFeature(feature, function (error, response) {\n if (!error) {\n this.removeLayers([feature.id], true);\n this.createLayers([feature]);\n }\n\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n },\n\n deleteFeature: function (id, callback, context) {\n this.service.deleteFeature(id, function (error, response) {\n if (!error && response.objectId) {\n this.removeLayers([response.objectId], true);\n }\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n },\n\n deleteFeatures: function (ids, callback, context) {\n return this.service.deleteFeatures(ids, function (error, response) {\n if (!error && response.length > 0) {\n for (var i = 0; i < response.length; i++) {\n this.removeLayers([response[i].objectId], true);\n }\n }\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n }\n});\n","import L from 'leaflet';\nimport { FeatureManager } from './FeatureManager';\n\nexport var FeatureLayer = FeatureManager.extend({\n\n options: {\n cacheLayers: true\n },\n\n /**\n * Constructor\n */\n initialize: function (options) {\n FeatureManager.prototype.initialize.call(this, options);\n this._originalStyle = this.options.style;\n this._layers = {};\n },\n\n /**\n * Layer Interface\n */\n\n onRemove: function (map) {\n for (var i in this._layers) {\n map.removeLayer(this._layers[i]);\n }\n\n return FeatureManager.prototype.onRemove.call(this, map);\n },\n\n createNewLayer: function (geojson) {\n var layer = L.GeoJSON.geometryToLayer(geojson, this.options);\n layer.defaultOptions = layer.options;\n return layer;\n },\n\n _updateLayer: function (layer, geojson) {\n // convert the geojson coordinates into a Leaflet LatLng array/nested arrays\n // pass it to setLatLngs to update layer geometries\n var latlngs = [];\n var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng;\n\n // copy new attributes, if present\n if (geojson.properties) {\n layer.feature.properties = geojson.properties;\n }\n\n switch (geojson.geometry.type) {\n case 'Point':\n latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates);\n layer.setLatLng(latlngs);\n break;\n case 'LineString':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'MultiLineString':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'Polygon':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'MultiPolygon':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n }\n },\n\n /**\n * Feature Management Methods\n */\n\n createLayers: function (features) {\n for (var i = features.length - 1; i >= 0; i--) {\n var geojson = features[i];\n\n var layer = this._layers[geojson.id];\n var newLayer;\n\n if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) {\n this._map.addLayer(layer);\n }\n\n // update geometry if necessary\n if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) {\n this._updateLayer(layer, geojson);\n }\n\n if (!layer) {\n newLayer = this.createNewLayer(geojson);\n newLayer.feature = geojson;\n\n // bubble events from individual layers to the feature layer\n newLayer.addEventParent(this);\n\n if (this.options.onEachFeature) {\n this.options.onEachFeature(newLayer.feature, newLayer);\n }\n\n // cache the layer\n this._layers[newLayer.feature.id] = newLayer;\n\n // style the layer\n this.setFeatureStyle(newLayer.feature.id, this.options.style);\n\n this.fire('createfeature', {\n feature: newLayer.feature\n }, true);\n\n // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled\n if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) {\n this._map.addLayer(newLayer);\n }\n }\n }\n },\n\n addLayers: function (ids) {\n for (var i = ids.length - 1; i >= 0; i--) {\n var layer = this._layers[ids[i]];\n if (layer) {\n this.fire('addfeature', {\n feature: layer.feature\n }, true);\n this._map.addLayer(layer);\n }\n }\n },\n\n removeLayers: function (ids, permanent) {\n for (var i = ids.length - 1; i >= 0; i--) {\n var id = ids[i];\n var layer = this._layers[id];\n if (layer) {\n this.fire('removefeature', {\n feature: layer.feature,\n permanent: permanent\n }, true);\n this._map.removeLayer(layer);\n }\n if (layer && permanent) {\n delete this._layers[id];\n }\n }\n },\n\n cellEnter: function (bounds, coords) {\n if (!this._zooming && this._map) {\n L.Util.requestAnimFrame(L.Util.bind(function () {\n var cacheKey = this._cacheKey(coords);\n var cellKey = this._cellCoordsToKey(coords);\n var layers = this._cache[cacheKey];\n if (this._activeCells[cellKey] && layers) {\n this.addLayers(layers);\n }\n }, this));\n }\n },\n\n cellLeave: function (bounds, coords) {\n if (!this._zooming) {\n L.Util.requestAnimFrame(L.Util.bind(function () {\n if (this._map) {\n var cacheKey = this._cacheKey(coords);\n var cellKey = this._cellCoordsToKey(coords);\n var layers = this._cache[cacheKey];\n var mapBounds = this._map.getBounds();\n if (!this._activeCells[cellKey] && layers) {\n var removable = true;\n\n for (var i = 0; i < layers.length; i++) {\n var layer = this._layers[layers[i]];\n if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) {\n removable = false;\n }\n }\n\n if (removable) {\n this.removeLayers(layers, !this.options.cacheLayers);\n }\n\n if (!this.options.cacheLayers && removable) {\n delete this._cache[cacheKey];\n delete this._cells[cellKey];\n delete this._activeCells[cellKey];\n }\n }\n }\n }, this));\n }\n },\n\n /**\n * Styling Methods\n */\n\n resetStyle: function () {\n this.options.style = this._originalStyle;\n this.eachFeature(function (layer) {\n this.resetFeatureStyle(layer.feature.id);\n }, this);\n return this;\n },\n\n setStyle: function (style) {\n this.options.style = style;\n this.eachFeature(function (layer) {\n this.setFeatureStyle(layer.feature.id, style);\n }, this);\n return this;\n },\n\n resetFeatureStyle: function (id) {\n var layer = this._layers[id];\n var style = this._originalStyle || L.Path.prototype.options;\n if (layer) {\n L.Util.extend(layer.options, layer.defaultOptions);\n this.setFeatureStyle(id, style);\n }\n return this;\n },\n\n setFeatureStyle: function (id, style) {\n var layer = this._layers[id];\n if (typeof style === 'function') {\n style = style(layer.feature);\n }\n if (layer.setStyle) {\n layer.setStyle(style);\n }\n return this;\n },\n\n /**\n * Utility Methods\n */\n\n eachFeature: function (fn, context) {\n for (var i in this._layers) {\n fn.call(context, this._layers[i]);\n }\n return this;\n },\n\n getFeature: function (id) {\n return this._layers[id];\n },\n\n bringToBack: function () {\n this.eachFeature(function (layer) {\n if (layer.bringToBack) {\n layer.bringToBack();\n }\n });\n },\n\n bringToFront: function () {\n this.eachFeature(function (layer) {\n if (layer.bringToFront) {\n layer.bringToFront();\n }\n });\n },\n\n redraw: function (id) {\n if (id) {\n this._redraw(id);\n }\n return this;\n },\n\n _redraw: function (id) {\n var layer = this._layers[id];\n var geojson = layer.feature;\n\n // if this looks like a marker\n if (layer && layer.setIcon && this.options.pointToLayer) {\n // update custom symbology, if necessary\n if (this.options.pointToLayer) {\n var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n var updatedIcon = getIcon.options.icon;\n layer.setIcon(updatedIcon);\n }\n }\n\n // looks like a vector marker (circleMarker)\n if (layer && layer.setStyle && this.options.pointToLayer) {\n var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n var updatedStyle = getStyle.options;\n this.setFeatureStyle(geojson.id, updatedStyle);\n }\n\n // looks like a path (polygon/polyline)\n if (layer && layer.setStyle && this.options.style) {\n this.resetStyle(geojson.id);\n }\n }\n});\n\nexport function featureLayer (options) {\n return new FeatureLayer(options);\n}\n\nexport default featureLayer;\n"],"names":["pointsEqual","a","b","i","length","closeRing","coordinates","push","ringIsClockwise","ringToTest","pt2","total","rLength","pt1","vertexIntersectsVertex","a1","a2","b1","b2","uaT","ubT","uB","ua","ub","arrayIntersectsArray","j","coordinatesContainPoint","point","contains","l","coordinatesContainCoordinates","outer","inner","intersects","convertRingsToGeoJSON","rings","x","outerRing","hole","outerRings","holes","r","ring","slice","polygon","uncontainedHoles","pop","contained","reverse","type","orientRings","poly","output","shift","flattenMultiPolygonRings","shallowClone","obj","target","hasOwnProperty","arcgisToGeoJSON","arcgis","idAttribute","geojson","y","points","paths","geometry","attributes","properties","id","OBJECTID","FID","geojsonToArcGIS","spatialReference","wkid","result","features","geometries","idAttr","g2a","a2g","extentToBounds","extent","sw","L","latLng","ymin","xmin","ne","ymax","xmax","latLngBounds","boundsToExtent","bounds","getSouthWest","lng","lat","getNorthEast","responseToFeatureCollection","response","objectIdField","objectIdFieldName","fields","name","featureCollection","results","feature","cleanUrl","url","Util","trim","isArcgisOnline","test","geojsonTypeToArcGIS","geoJsonType","arcgisGeometryType","warn","console","apply","arguments","serialize","params","data","f","key","value","param","Object","prototype","toString","call","JSON","stringify","join","valueOf","encodeURIComponent","createRequest","callback","context","httpRequest","window","XMLHttpRequest","onerror","e","onreadystatechange","falseFn","error","code","message","readyState","parse","responseText","ontimeout","this","xmlHttpPost","options","timeout","open","setRequestHeader","send","xmlHttpGet","request","paramString","requestLength","Support","cors","jsonp","_EsriLeafletCallbacks","callbackId","callbacks","script","DomUtil","create","document","body","src","responseType","abort","_callback","task","Task","query","Query","find","Find","identify","Identify","identifyFeatures","IdentifyFeatures","identifyImage","IdentifyImage","service","Service","mapService","MapService","imageService","ImageService","featureLayerService","FeatureLayerService","logo","Logo","basemapLayer","BasemapLayer","tiledMapLayer","TiledMapLayer","imageMapLayer","ImageMapLayer","dynamicMapLayer","DynamicMapLayer","BinarySearchIndex","values","concat","featureLayer","FeatureLayer","pointerEvents","documentElement","style","get","CORS","JSONP","Request","post","Class","extend","proxy","useCors","generateSetter","bind","initialize","endpoint","_service","setOptions","setters","setter","token","authenticate","path","_request","method","offset","limit","precision","featureIds","returnGeometry","where","outSr","outFields","within","_setGeometry","spatialRel","crosses","touches","overlaps","nearby","latlng","radius","geometryType","units","distance","inSr","string","between","start","end","time","simplify","map","factor","mapWidth","Math","abs","getBounds","getWest","getEast","maxAllowableOffset","getSize","orderBy","fieldName","order","orderByFields","run","_cleanParams","_trapSQLerrors","count","returnCountOnly","ids","returnIdsOnly","objectIds","returnExtentOnly","pixelSize","layer","LatLngBounds","getLatLng","LatLng","GeoJSON","getLayers","toGeoJSON","text","sr","layers","dynamicLayers","returnZ","returnM","gdbVersion","layerDefs","tolerance","on","size","imageDisplay","mapExtent","at","layerDef","undefined","layerId","setMosaicRule","setRenderingRule","setPixelSize","returnCatalogItems","getMosaicRule","mosaicRule","getRenderingRule","renderingRule","getPixelSize","_responseToGeoJSON","location","catalogItems","catalogItemVisibilities","geoJSON","pixel","crs","objectId","Values","catalogItemVisibility","Evented","_requestQueue","_authenticating","metadata","_runQueue","getTimeout","setTimeout","fire","wrappedCallback","_createServiceCallback","addFeature","addResults","updateFeature","updateResults","deleteFeature","deleteResults","deleteFeatures","Control","position","marginTop","marginLeft","marginBottom","marginRight","onAdd","div","innerHTML","tileProtocol","protocol","TileLayer","statics","TILES","Streets","urlTemplate","attributionUrl","hideLogo","logoPosition","minZoom","maxZoom","subdomains","attribution","Topographic","Oceans","OceansLabels","pane","NationalGeographic","DarkGray","DarkGrayLabels","Gray","GrayLabels","Imagery","ImageryLabels","ImageryTransportation","ShadedRelief","ShadedReliefLabels","Terrain","TerrainLabels","config","Error","tileOptions","_getAttributionData","_logo","_hasEsriLogo","addTo","_initPane","_updateMapAttribution","onRemove","_container","removeControl","off","getAttribution","_map","getPane","createPane","zIndex","attributions","_attributions","c","contributors","contributor","coverageAreas","coverageArea","southWest","bbox","northEast","score","zoomMin","zoomMax","sort","attributionControl","newAttributions","zoom","getZoom","match","substr","attributionElement","querySelector","maxWidth","zoomOffsetAllowance","MercatorZoomLevels","0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","tileUrl","addEventParent","arcgisonline","RegExp","replace","getTileUrl","tilePoint","template","s","_getSubdomain","z","_lodMap","createTile","coords","done","tile","createElement","DomEvent","_tileOnLoad","_tileOnError","crossOrigin","alt","once","CRS","EPSG3857","latestWkid","arcgisLODs","tileInfo","lods","correctResolutions","arcgisLOD","ci","correctRes","_withinPercentage","resolution","level","tokenQs","percentage","diff","Overlay","ImageOverlay","_topLeft","getPixelBounds","min","_reset","setPosition","_image","subtract","getPixelOrigin","RasterLayer","Layer","opacity","interactive","_update","throttle","updateInterval","_currentImage","_bounds","equals","addLayer","removeLayer","_popup","_getPopupData","_resetPopupState","bindPopup","fn","popupOptions","_shouldRenderPopup","_lastClick","popup","_popupFunction","unbindPopup","closePopup","bringToFront","bringToBack","getOpacity","setOpacity","getTimeRange","from","to","setTimeRange","_renderImage","image","newImage","oldImage","_animatingZoom","_panTransition","_inProgress","_buildExportParams","_requestExport","_renderPopup","content","setLatLng","setContent","openOn","format","transparent","setPixelType","pixelType","getPixelType","setBandIds","bandIds","isArray","getBandIds","setNoData","noData","noDataInterpretation","getNoData","getNoDataInterpretation","identifyRequest","project","_northEast","_southWest","parseInt","split","bboxSR","imageSR","interpolation","compressionQuality","href","getParamString","timeOptions","getDynamicLayers","setDynamicLayers","setLayers","getLayerDefs","setLayerDefs","getTimeOptions","setTimeOptions","top","latLngToLayerPoint","bottom","dpi","VirtualGrid","cellSize","_ok","removeEventListener","getEvents","_removeCells","events","moveend","movestart","_start","zoomend","removeFrom","_cells","_activeCells","_cellsToLoad","_cellsTotal","_cellNumBounds","_getCellNumBounds","_resetWrap","_zooming","infinite","_getCellSize","wrapLng","_wrapLng","floor","ceil","wrapLat","_wrapLat","cellBounds","divideBy","max","_removeOtherCells","_addCells","queue","center","getCenter","_isValidCell","cellsToLoad","distanceTo","_addCell","_cellCoordsToBounds","nwPoint","multiplyBy","sePoint","add","nw","wrapLatLng","unproject","se","_cellCoordsToKey","_keyToCellCoords","kArr","_removeCell","cell","cellLeave","_wrapCoords","cellEnter","createCell","wrapNum","getPixelWorldBounds","index","getIndex","dirty","currentIndex","currentElement","minIndex","maxIndex","round","startIndex","endIndex","insert","item","splice","bulkAdd","items","FeatureManager","timeField","timeFilterMode","simplifyFactor","oidCheck","_startTimeIndex","_endTimeIndex","_timeIndex","_cache","_currentSnapshot","_activeRequests","_handleZoomChange","_requestFeatures","_buildQuery","exceededTransferLimit","requestAnimFrame","_addFeatures","_postProcessFeatures","_cacheKey","_buildTimeIndexes","createLayers","setWhere","oldSnapshot","newSnapshot","pendingRequests","requestError","requestCallback","removeLayers","addLayers","getWhere","oldFrom","oldTo","_filterExistingFeatures","refresh","redraw","eachFeature","_redraw","newFrom","newTo","layersToRemove","_getFeaturesInTimeRange","layersToAdd","indexOf","shouldRemoveLayer","search","startTimes","endTimes","startTimeEntries","endTimeEntries","Date","timeEntries","_featureWithinTimeRange","date","startDate","endDate","_visibleZoom","_getMetadata","_metadata","cacheLayers","_originalStyle","_layers","createNewLayer","geometryToLayer","defaultOptions","_updateLayer","latlngs","coordsToLatLng","coordsToLatLngs","setLatLngs","newLayer","hasLayer","onEachFeature","setFeatureStyle","permanent","cacheKey","cellKey","mapBounds","removable","resetStyle","resetFeatureStyle","setStyle","Path","getFeature","setIcon","pointToLayer","getIcon","updatedIcon","icon","getStyle","updatedStyle"],"mappings":"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"} \ No newline at end of file