From 23479294c53ddc1af03ac32fba208f08cc77dd1a Mon Sep 17 00:00:00 2001 From: jgravois Date: Sun, 6 Nov 2016 15:39:56 -0800 Subject: [PATCH] build 2.2.0 --- dist/esri-leaflet-geocoder-debug.js | 1195 +++++++++++++++++++++++++++ dist/esri-leaflet-geocoder.css | 1 + dist/esri-leaflet-geocoder.js | 5 + dist/esri-leaflet-geocoder.js.map | 1 + dist/img/loading.gif | Bin 0 -> 1276 bytes dist/img/loading@2x.gif | Bin 0 -> 3973 bytes dist/img/search-disabled.png | Bin 0 -> 206 bytes dist/img/search.png | Bin 0 -> 425 bytes dist/img/search@2x-disabled.png | Bin 0 -> 206 bytes dist/img/search@2x.png | Bin 0 -> 772 bytes 10 files changed, 1202 insertions(+) create mode 100644 dist/esri-leaflet-geocoder-debug.js create mode 100644 dist/esri-leaflet-geocoder.css create mode 100644 dist/esri-leaflet-geocoder.js create mode 100644 dist/esri-leaflet-geocoder.js.map create mode 100755 dist/img/loading.gif create mode 100755 dist/img/loading@2x.gif create mode 100644 dist/img/search-disabled.png create mode 100644 dist/img/search.png create mode 100644 dist/img/search@2x-disabled.png create mode 100644 dist/img/search@2x.png diff --git a/dist/esri-leaflet-geocoder-debug.js b/dist/esri-leaflet-geocoder-debug.js new file mode 100644 index 0000000..0a14ef9 --- /dev/null +++ b/dist/esri-leaflet-geocoder-debug.js @@ -0,0 +1,1195 @@ +/* esri-leaflet-geocoder - v2.2.0 - Sun Nov 06 2016 15:39:39 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'), require('esri-leaflet')) : + typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'esri-leaflet'], factory) : + (factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.Geocoding = global.L.esri.Geocoding || {}),global.L,global.L.esri)); +}(this, function (exports,L,esriLeaflet) { 'use strict'; + + L = 'default' in L ? L['default'] : L; + + var version = "2.2.0"; + + var Geocode = esriLeaflet.Task.extend({ + path: 'find', + + params: { + outSr: 4326, + forStorage: false, + outFields: '*', + maxLocations: 20 + }, + + setters: { + 'address': 'address', + 'neighborhood': 'neighborhood', + 'city': 'city', + 'subregion': 'subregion', + 'region': 'region', + 'postal': 'postal', + 'country': 'country', + 'text': 'text', + 'category': 'category', + 'token': 'token', + 'key': 'magicKey', + 'fields': 'outFields', + 'forStorage': 'forStorage', + 'maxLocations': 'maxLocations' + }, + + initialize: function (options) { + options = options || {}; + options.url = options.url || WorldGeocodingServiceUrl; + esriLeaflet.Task.prototype.initialize.call(this, options); + }, + + within: function (bounds) { + bounds = L.latLngBounds(bounds); + this.params.bbox = esriLeaflet.Util.boundsToExtent(bounds); + return this; + }, + + nearby: function (latlng, radius) { + latlng = L.latLng(latlng); + this.params.location = latlng.lng + ',' + latlng.lat; + this.params.distance = Math.min(Math.max(radius, 2000), 50000); + return this; + }, + + run: function (callback, context) { + if (this.options.customParam) { + this.path = 'findAddressCandidates'; + this.params[this.options.customParam] = this.params.text; + delete this.params.text; + } else { + this.path = (this.params.text) ? 'find' : 'findAddressCandidates'; + } + + if (this.path === 'findAddressCandidates' && this.params.bbox) { + this.params.searchExtent = this.params.bbox; + delete this.params.bbox; + } + + return this.request(function (error, response) { + var processor = (this.path === 'find') ? this._processFindResponse : this._processFindAddressCandidatesResponse; + var results = (!error) ? processor(response) : undefined; + callback.call(context, error, { results: results }, response); + }, this); + }, + + _processFindResponse: function (response) { + var results = []; + + for (var i = 0; i < response.locations.length; i++) { + var location = response.locations[i]; + var bounds; + + if (location.extent) { + bounds = esriLeaflet.Util.extentToBounds(location.extent); + } + + results.push({ + text: location.name, + bounds: bounds, + score: location.feature.attributes.Score, + latlng: L.latLng(location.feature.geometry.y, location.feature.geometry.x), + properties: location.feature.attributes + }); + } + + return results; + }, + + _processFindAddressCandidatesResponse: function (response) { + var results = []; + + for (var i = 0; i < response.candidates.length; i++) { + var candidate = response.candidates[i]; + if (candidate.extent) { + var bounds = esriLeaflet.Util.extentToBounds(candidate.extent); + } + + results.push({ + text: candidate.address, + bounds: bounds, + score: candidate.score, + latlng: L.latLng(candidate.location.y, candidate.location.x), + properties: candidate.attributes + }); + } + + return results; + } + + }); + + function geocode (options) { + return new Geocode(options); + } + + var ReverseGeocode = esriLeaflet.Task.extend({ + path: 'reverseGeocode', + + params: { + outSR: 4326, + returnIntersection: false + }, + + setters: { + 'distance': 'distance', + 'language': 'langCode', + 'intersection': 'returnIntersection' + }, + + initialize: function (options) { + options = options || {}; + options.url = options.url || WorldGeocodingServiceUrl; + esriLeaflet.Task.prototype.initialize.call(this, options); + }, + + latlng: function (latlng) { + latlng = L.latLng(latlng); + this.params.location = latlng.lng + ',' + latlng.lat; + return this; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + var result; + + if (!error) { + result = { + latlng: L.latLng(response.location.y, response.location.x), + address: response.address + }; + } else { + result = undefined; + } + + callback.call(context, error, result, response); + }, this); + } + }); + + function reverseGeocode (options) { + return new ReverseGeocode(options); + } + + var Suggest = esriLeaflet.Task.extend({ + path: 'suggest', + + params: {}, + + setters: { + text: 'text', + category: 'category', + countries: 'countryCode', + maxSuggestions: 'maxSuggestions' + }, + + initialize: function (options) { + options = options || {}; + if (!options.url) { + options.url = WorldGeocodingServiceUrl; + options.supportsSuggest = true; + } + esriLeaflet.Task.prototype.initialize.call(this, options); + }, + + within: function (bounds) { + bounds = L.latLngBounds(bounds); + bounds = bounds.pad(0.5); + var center = bounds.getCenter(); + var ne = bounds.getNorthWest(); + this.params.location = center.lng + ',' + center.lat; + this.params.distance = Math.min(Math.max(center.distanceTo(ne), 2000), 50000); + this.params.searchExtent = esriLeaflet.Util.boundsToExtent(bounds); + return this; + }, + + nearby: function (latlng, radius) { + latlng = L.latLng(latlng); + this.params.location = latlng.lng + ',' + latlng.lat; + this.params.distance = Math.min(Math.max(radius, 2000), 50000); + return this; + }, + + run: function (callback, context) { + if (this.options.supportsSuggest) { + return this.request(function (error, response) { + callback.call(context, error, response, response); + }, this); + } else { + console.warn('this geocoding service does not support asking for suggestions'); + } + } + + }); + + function suggest (options) { + return new Suggest(options); + } + + var GeocodeService = esriLeaflet.Service.extend({ + initialize: function (options) { + options = options || {}; + if (options.url) { + esriLeaflet.Service.prototype.initialize.call(this, options); + this._confirmSuggestSupport(); + } else { + options.url = WorldGeocodingServiceUrl; + options.supportsSuggest = true; + esriLeaflet.Service.prototype.initialize.call(this, options); + } + }, + + geocode: function () { + return geocode(this); + }, + + reverse: function () { + return reverseGeocode(this); + }, + + suggest: function () { + // requires either the Esri World Geocoding Service or a <10.3 ArcGIS Server Geocoding Service that supports suggest. + return suggest(this); + }, + + _confirmSuggestSupport: function () { + this.metadata(function (error, response) { + if (error) { return; } + // pre 10.3 geocoding services dont list capabilities (and dont support maxLocations) + // since, only SOME individual services have been configured to support asking for suggestions + if (!response.capabilities) { + this.options.supportsSuggest = false; + this.options.customParam = response.singleLineAddressField.name; + } else if (response.capabilities.indexOf('Suggest') > -1) { + this.options.supportsSuggest = true; + } else { + this.options.supportsSuggest = false; + } + }, this); + } + }); + + function geocodeService (options) { + return new GeocodeService(options); + } + + var GeosearchCore = L.Evented.extend({ + + options: { + zoomToResult: true, + useMapBounds: 12, + searchBounds: null + }, + + initialize: function (control, options) { + L.Util.setOptions(this, options); + this._control = control; + + if (!options || !options.providers || !options.providers.length) { + throw new Error('You must specify at least one provider'); + } + + this._providers = options.providers; + }, + + _geocode: function (text, key, provider) { + var activeRequests = 0; + var allResults = []; + var bounds; + + var callback = L.Util.bind(function (error, results) { + activeRequests--; + if (error) { + return; + } + + if (results) { + allResults = allResults.concat(results); + } + + if (activeRequests <= 0) { + bounds = this._boundsFromResults(allResults); + + this.fire('results', { + results: allResults, + bounds: bounds, + latlng: (bounds) ? bounds.getCenter() : undefined, + text: text + }, true); + + if (this.options.zoomToResult && bounds) { + this._control._map.fitBounds(bounds); + } + + this.fire('load'); + } + }, this); + + if (key) { + activeRequests++; + provider.results(text, key, this._searchBounds(), callback); + } else { + for (var i = 0; i < this._providers.length; i++) { + activeRequests++; + this._providers[i].results(text, key, this._searchBounds(), callback); + } + } + }, + + _suggest: function (text) { + var activeRequests = this._providers.length; + + var createCallback = L.Util.bind(function (text, provider) { + return L.Util.bind(function (error, suggestions) { + if (error) { return; } + + var i; + + activeRequests = activeRequests - 1; + + if (text.length < 2) { + this._suggestions.innerHTML = ''; + this._suggestions.style.display = 'none'; + return; + } + + if (suggestions.length) { + for (i = 0; i < suggestions.length; i++) { + suggestions[i].provider = provider; + } + } else { + // we still need to update the UI + this._control._renderSuggestions(suggestions); + } + + if (provider._lastRender !== text && provider.nodes) { + for (i = 0; i < provider.nodes.length; i++) { + if (provider.nodes[i].parentElement) { + this._control._suggestions.removeChild(provider.nodes[i]); + } + } + + provider.nodes = []; + } + + if (suggestions.length && this._control._input.value === text) { + this._control.clearSuggestions(provider.nodes); + + provider._lastRender = text; + provider.nodes = this._control._renderSuggestions(suggestions); + this._control._nodes = []; + } + }, this); + }, this); + + this._pendingSuggestions = []; + + for (var i = 0; i < this._providers.length; i++) { + var provider = this._providers[i]; + var request = provider.suggestions(text, this._searchBounds(), createCallback(text, provider)); + this._pendingSuggestions.push(request); + } + }, + + _searchBounds: function () { + if (this.options.searchBounds !== null) { + return this.options.searchBounds; + } + + if (this.options.useMapBounds === false) { + return null; + } + + if (this.options.useMapBounds === true) { + return this._control._map.getBounds(); + } + + if (this.options.useMapBounds <= this._control._map.getZoom()) { + return this._control._map.getBounds(); + } + + return null; + }, + + _boundsFromResults: function (results) { + if (!results.length) { + return; + } + + var nullIsland = L.latLngBounds([0, 0], [0, 0]); + var resultBounds = []; + var resultLatlngs = []; + + // collect the bounds and center of each result + for (var i = results.length - 1; i >= 0; i--) { + var result = results[i]; + + resultLatlngs.push(result.latlng); + + // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present + if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) { + resultBounds.push(result.bounds); + } + } + + // form a bounds object containing all center points + var bounds = L.latLngBounds(resultLatlngs); + + // and extend it to contain all bounds objects + for (var j = 0; j < resultBounds.length; j++) { + bounds.extend(resultBounds[j]); + } + + return bounds; + }, + + _getAttribution: function () { + var attribs = []; + var providers = this._providers; + + for (var i = 0; i < providers.length; i++) { + if (providers[i].options.attribution) { + attribs.push(providers[i].options.attribution); + } + } + + return attribs.join(', '); + } + + }); + + function geosearchCore (control, options) { + return new GeosearchCore(control, options); + } + + var ArcgisOnlineProvider = GeocodeService.extend({ + options: { + label: 'Places and Addresses', + maxResults: 5 + }, + + suggestions: function (text, bounds, callback) { + var request = this.suggest().text(text); + + if (bounds) { + request.within(bounds); + } + + if (this.options.countries) { + request.countries(this.options.countries); + } + + if (this.options.categories) { + request.category(this.options.categories); + } + + // 15 is the maximum number of suggestions that can be returned + request.maxSuggestions(this.options.maxResults); + + return request.run(function (error, results, response) { + var suggestions = []; + if (!error) { + while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) { + var suggestion = response.suggestions.shift(); + if (!suggestion.isCollection) { + suggestions.push({ + text: suggestion.text, + magicKey: suggestion.magicKey + }); + } + } + } + callback(error, suggestions); + }, this); + }, + + results: function (text, key, bounds, callback) { + var request = this.geocode().text(text); + + if (key) { + request.key(key); + } + // in the future Address/StreetName geocoding requests that include a magicKey will only return one match + request.maxLocations(this.options.maxResults); + + if (bounds) { + request.within(bounds); + } + + if (this.options.forStorage) { + request.forStorage(true); + } + + return request.run(function (error, response) { + callback(error, response.results); + }, this); + } + }); + + function arcgisOnlineProvider (options) { + return new ArcgisOnlineProvider(options); + } + + var Geosearch = L.Control.extend({ + includes: L.Mixin.Events, + + options: { + position: 'topleft', + collapseAfterResult: true, + expanded: false, + allowMultipleResults: true, + placeholder: 'Search for places or addresses', + title: 'Location Search' + }, + + initialize: function (options) { + L.Util.setOptions(this, options); + + if (!options || !options.providers || !options.providers.length) { + options = {}; + options.providers = [ arcgisOnlineProvider() ]; + } + + // instantiate the underlying class and pass along options + this._geosearchCore = geosearchCore(this, options); + this._geosearchCore._providers = options.providers; + + // bubble each providers events to the control + this._geosearchCore.addEventParent(this); + for (var i = 0; i < this._geosearchCore._providers.length; i++) { + this._geosearchCore._providers[i].addEventParent(this); + } + + this._geosearchCore._pendingSuggestions = []; + + L.Control.prototype.initialize.call(options); + }, + + _renderSuggestions: function (suggestions) { + var currentGroup; + this._suggestions.style.display = 'block'; + + // set the maxHeight of the suggestions box to + // map height + // - suggestions offset (distance from top of suggestions to top of control) + // - control offset (distance from top of control to top of map) + // - 10 (extra padding) + this._suggestions.style.maxHeight = (this._map.getSize().y - this._suggestions.offsetTop - this._wrapper.offsetTop - 10) + 'px'; + + var nodes = []; + var list; + var header; + + for (var i = 0; i < suggestions.length; i++) { + var suggestion = suggestions[i]; + if (!header && this._geosearchCore._providers.length > 1 && currentGroup !== suggestion.provider.options.label) { + header = L.DomUtil.create('span', 'geocoder-control-header', this._suggestions); + header.textContent = suggestion.provider.options.label; + header.innerText = suggestion.provider.options.label; + currentGroup = suggestion.provider.options.label; + nodes.push(header); + } + + if (!list) { + list = L.DomUtil.create('ul', 'geocoder-control-list', this._suggestions); + } + + var suggestionItem = L.DomUtil.create('li', 'geocoder-control-suggestion', list); + + suggestionItem.innerHTML = suggestion.text; + suggestionItem.provider = suggestion.provider; + suggestionItem['data-magic-key'] = suggestion.magicKey; + } + + L.DomUtil.removeClass(this._input, 'geocoder-control-loading'); + + nodes.push(list); + + return nodes; + }, + + _boundsFromResults: function (results) { + if (!results.length) { + return; + } + + var nullIsland = L.latLngBounds([0, 0], [0, 0]); + var resultBounds = []; + var resultLatlngs = []; + + // collect the bounds and center of each result + for (var i = results.length - 1; i >= 0; i--) { + var result = results[i]; + + resultLatlngs.push(result.latlng); + + // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present + if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) { + resultBounds.push(result.bounds); + } + } + + // form a bounds object containing all center points + var bounds = L.latLngBounds(resultLatlngs); + + // and extend it to contain all bounds objects + for (var j = 0; j < resultBounds.length; j++) { + bounds.extend(resultBounds[j]); + } + + return bounds; + }, + + clear: function () { + this._suggestions.innerHTML = ''; + this._suggestions.style.display = 'none'; + this._input.value = ''; + + if (this.options.collapseAfterResult) { + this._input.placeholder = ''; + L.DomUtil.removeClass(this._wrapper, 'geocoder-control-expanded'); + } + + if (!this._map.scrollWheelZoom.enabled() && this._map.options.scrollWheelZoom) { + this._map.scrollWheelZoom.enable(); + } + }, + + clearSuggestions: function () { + if (this._nodes) { + for (var k = 0; k < this._nodes.length; k++) { + if (this._nodes[k].parentElement) { + this._suggestions.removeChild(this._nodes[k]); + } + } + } + }, + + _setupClick: function () { + L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded'); + this._input.focus(); + }, + + disable: function () { + this._input.disabled = true; + L.DomUtil.addClass(this._input, 'geocoder-control-input-disabled'); + L.DomEvent.removeListener(this._wrapper, 'click', this._setupClick, this); + }, + + enable: function () { + this._input.disabled = false; + L.DomUtil.removeClass(this._input, 'geocoder-control-input-disabled'); + L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this); + }, + + getAttribution: function () { + var attribs = []; + + for (var i = 0; i < this._providers.length; i++) { + if (this._providers[i].options.attribution) { + attribs.push(this._providers[i].options.attribution); + } + } + + return attribs.join(', '); + }, + + onAdd: function (map) { + // include 'Powered by Esri' in map attribution + esriLeaflet.Util.setEsriAttribution(map); + + this._map = map; + this._wrapper = L.DomUtil.create('div', 'geocoder-control'); + this._input = L.DomUtil.create('input', 'geocoder-control-input leaflet-bar', this._wrapper); + this._input.title = this.options.title; + + if (this.options.expanded) { + L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded'); + this._input.placeholder = this.options.placeholder; + } + + this._suggestions = L.DomUtil.create('div', 'geocoder-control-suggestions leaflet-bar', this._wrapper); + + var credits = this._geosearchCore._getAttribution(); + map.attributionControl.addAttribution(credits); + + L.DomEvent.addListener(this._input, 'focus', function (e) { + this._input.placeholder = this.options.placeholder; + L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded'); + }, this); + + L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this); + + L.DomEvent.addListener(this._suggestions, 'mousedown', function (e) { + var suggestionItem = e.target || e.srcElement; + this._geosearchCore._geocode(suggestionItem.innerHTML, suggestionItem['data-magic-key'], suggestionItem.provider); + this.clear(); + }, this); + + L.DomEvent.addListener(this._input, 'blur', function (e) { + this.clear(); + }, this); + + L.DomEvent.addListener(this._input, 'keydown', function (e) { + L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded'); + + var list = this._suggestions.querySelectorAll('.' + 'geocoder-control-suggestion'); + var selected = this._suggestions.querySelectorAll('.' + 'geocoder-control-selected')[0]; + var selectedPosition; + + for (var i = 0; i < list.length; i++) { + if (list[i] === selected) { + selectedPosition = i; + break; + } + } + + switch (e.keyCode) { + case 13: + if (selected) { + this._geosearchCore._geocode(selected.innerHTML, selected['data-magic-key'], selected.provider); + this.clear(); + } else if (this.options.allowMultipleResults) { + this._geosearchCore._geocode(this._input.value, undefined); + this.clear(); + } else { + L.DomUtil.addClass(list[0], 'geocoder-control-selected'); + } + L.DomEvent.preventDefault(e); + break; + case 38: + if (selected) { + L.DomUtil.removeClass(selected, 'geocoder-control-selected'); + } + + var previousItem = list[selectedPosition - 1]; + + if (selected && previousItem) { + L.DomUtil.addClass(previousItem, 'geocoder-control-selected'); + } else { + L.DomUtil.addClass(list[list.length - 1], 'geocoder-control-selected'); + } + L.DomEvent.preventDefault(e); + break; + case 40: + if (selected) { + L.DomUtil.removeClass(selected, 'geocoder-control-selected'); + } + + var nextItem = list[selectedPosition + 1]; + + if (selected && nextItem) { + L.DomUtil.addClass(nextItem, 'geocoder-control-selected'); + } else { + L.DomUtil.addClass(list[0], 'geocoder-control-selected'); + } + L.DomEvent.preventDefault(e); + break; + default: + // when the input changes we should cancel all pending suggestion requests if possible to avoid result collisions + for (var x = 0; x < this._geosearchCore._pendingSuggestions.length; x++) { + var request = this._geosearchCore._pendingSuggestions[x]; + if (request && request.abort && !request.id) { + request.abort(); + } + } + break; + } + }, this); + + L.DomEvent.addListener(this._input, 'keyup', L.Util.throttle(function (e) { + var key = e.which || e.keyCode; + var text = (e.target || e.srcElement).value; + + // require at least 2 characters for suggestions + if (text.length < 2) { + this._suggestions.innerHTML = ''; + this._suggestions.style.display = 'none'; + L.DomUtil.removeClass(this._input, 'geocoder-control-loading'); + return; + } + + // if this is the escape key it will clear the input so clear suggestions + if (key === 27) { + this._suggestions.innerHTML = ''; + this._suggestions.style.display = 'none'; + return; + } + + // if this is NOT the up/down arrows or enter make a suggestion + if (key !== 13 && key !== 38 && key !== 40) { + if (this._input.value !== this._lastValue) { + this._lastValue = this._input.value; + L.DomUtil.addClass(this._input, 'geocoder-control-loading'); + this._geosearchCore._suggest(text); + } + } + }, 50, this), this); + + L.DomEvent.disableClickPropagation(this._wrapper); + + // when mouse moves over suggestions disable scroll wheel zoom if its enabled + L.DomEvent.addListener(this._suggestions, 'mouseover', function (e) { + if (map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) { + map.scrollWheelZoom.disable(); + } + }); + + // when mouse moves leaves suggestions enable scroll wheel zoom if its disabled + L.DomEvent.addListener(this._suggestions, 'mouseout', function (e) { + if (!map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) { + map.scrollWheelZoom.enable(); + } + }); + + this._geosearchCore.on('load', function (e) { + L.DomUtil.removeClass(this._input, 'geocoder-control-loading'); + this.clear(); + this._input.blur(); + }, this); + + return this._wrapper; + } + }); + + function geosearch (options) { + return new Geosearch(options); + } + + var FeatureLayerProvider = esriLeaflet.FeatureLayerService.extend({ + options: { + label: 'Feature Layer', + maxResults: 5, + bufferRadius: 1000, + formatSuggestion: function (feature) { + return feature.properties[this.options.searchFields[0]]; + } + }, + + initialize: function (options) { + esriLeaflet.FeatureLayerService.prototype.initialize.call(this, options); + if (typeof this.options.searchFields === 'string') { + this.options.searchFields = [this.options.searchFields]; + } + this._suggestionsQuery = this.query(); + this._resultsQuery = this.query(); + }, + + suggestions: function (text, bounds, callback) { + var query = this._suggestionsQuery.where(this._buildQuery(text)) + .returnGeometry(false); + + if (bounds) { + query.intersects(bounds); + } + + if (this.options.idField) { + query.fields([this.options.idField].concat(this.options.searchFields)); + } + + var request = query.run(function (error, results, raw) { + if (error) { + callback(error, []); + } else { + this.options.idField = raw.objectIdFieldName; + var suggestions = []; + for (var i = results.features.length - 1; i >= 0; i--) { + var feature = results.features[i]; + suggestions.push({ + text: this.options.formatSuggestion.call(this, feature), + magicKey: feature.id + }); + } + callback(error, suggestions.slice(0, this.options.maxResults)); + } + }, this); + + return request; + }, + + results: function (text, key, bounds, callback) { + var query = this._resultsQuery; + + if (key) { + query.featureIds([key]); + } else { + query.where(this._buildQuery(text)); + } + + if (bounds) { + query.within(bounds); + } + + return query.run(L.Util.bind(function (error, features) { + var results = []; + for (var i = 0; i < features.features.length; i++) { + var feature = features.features[i]; + if (feature) { + var bounds = this._featureBounds(feature); + + var result = { + latlng: bounds.getCenter(), + bounds: bounds, + text: this.options.formatSuggestion.call(this, feature), + properties: feature.properties, + geojson: feature + }; + + results.push(result); + } + } + callback(error, results); + }, this)); + }, + + orderBy: function (fieldName, order) { + this._suggestionsQuery.orderBy(fieldName, order); + }, + + _buildQuery: function (text) { + var queryString = []; + + for (var i = this.options.searchFields.length - 1; i >= 0; i--) { + var field = 'upper("' + this.options.searchFields[i] + '")'; + + queryString.push(field + " LIKE upper('%" + text + "%')"); + } + + if (this.options.where) { + return this.options.where + ' AND (' + queryString.join(' OR ') + ')'; + } else { + return queryString.join(' OR '); + } + }, + + _featureBounds: function (feature) { + var geojson = L.geoJson(feature); + if (feature.geometry.type === 'Point') { + var center = geojson.getBounds().getCenter(); + var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat); + var latRadius = (this.options.bufferRadius / 40075017) * 360; + return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]); + } else { + return geojson.getBounds(); + } + } + }); + + function featureLayerProvider (options) { + return new FeatureLayerProvider(options); + } + + var MapServiceProvider = esriLeaflet.MapService.extend({ + options: { + layers: [0], + label: 'Map Service', + bufferRadius: 1000, + maxResults: 5, + formatSuggestion: function (feature) { + return feature.properties[feature.displayFieldName] + ' ' + feature.layerName + ''; + } + }, + + initialize: function (options) { + esriLeaflet.MapService.prototype.initialize.call(this, options); + this._getIdFields(); + }, + + suggestions: function (text, bounds, callback) { + var request = this.find().text(text).fields(this.options.searchFields).returnGeometry(false).layers(this.options.layers); + + return request.run(function (error, results, raw) { + var suggestions = []; + if (!error) { + var count = Math.min(this.options.maxResults, results.features.length); + raw.results = raw.results.reverse(); + for (var i = 0; i < count; i++) { + var feature = results.features[i]; + var result = raw.results[i]; + var layer = result.layerId; + var idField = this._idFields[layer]; + feature.layerId = layer; + feature.layerName = this._layerNames[layer]; + feature.displayFieldName = this._displayFields[layer]; + if (idField) { + suggestions.push({ + text: this.options.formatSuggestion.call(this, feature), + magicKey: result.attributes[idField] + ':' + layer + }); + } + } + } + callback(error, suggestions.reverse()); + }, this); + }, + + results: function (text, key, bounds, callback) { + var results = []; + var request; + + if (key) { + var featureId = key.split(':')[0]; + var layer = key.split(':')[1]; + request = this.query().layer(layer).featureIds(featureId); + } else { + request = this.find().text(text).fields(this.options.searchFields).layers(this.options.layers); + } + + return request.run(function (error, features, response) { + if (!error) { + if (response.results) { + response.results = response.results.reverse(); + } + for (var i = 0; i < features.features.length; i++) { + var feature = features.features[i]; + layer = layer || response.results[i].layerId; + + if (feature && layer !== undefined) { + var bounds = this._featureBounds(feature); + feature.layerId = layer; + feature.layerName = this._layerNames[layer]; + feature.displayFieldName = this._displayFields[layer]; + + var result = { + latlng: bounds.getCenter(), + bounds: bounds, + text: this.options.formatSuggestion.call(this, feature), + properties: feature.properties, + geojson: feature + }; + + results.push(result); + } + } + } + callback(error, results.reverse()); + }, this); + }, + + _featureBounds: function (feature) { + var geojson = L.geoJson(feature); + if (feature.geometry.type === 'Point') { + var center = geojson.getBounds().getCenter(); + var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat); + var latRadius = (this.options.bufferRadius / 40075017) * 360; + return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]); + } else { + return geojson.getBounds(); + } + }, + + _layerMetadataCallback: function (layerid) { + return L.Util.bind(function (error, metadata) { + if (error) { return; } + this._displayFields[layerid] = metadata.displayField; + this._layerNames[layerid] = metadata.name; + for (var i = 0; i < metadata.fields.length; i++) { + var field = metadata.fields[i]; + if (field.type === 'esriFieldTypeOID') { + this._idFields[layerid] = field.name; + break; + } + } + }, this); + }, + + _getIdFields: function () { + this._idFields = {}; + this._displayFields = {}; + this._layerNames = {}; + for (var i = 0; i < this.options.layers.length; i++) { + var layer = this.options.layers[i]; + this.get(layer, {}, this._layerMetadataCallback(layer)); + } + } + }); + + function mapServiceProvider (options) { + return new MapServiceProvider(options); + } + + var GeocodeServiceProvider = GeocodeService.extend({ + options: { + label: 'Geocode Server', + maxResults: 5 + }, + + suggestions: function (text, bounds, callback) { + if (this.options.supportsSuggest) { + var request = this.suggest().text(text); + if (bounds) { + request.within(bounds); + } + + return request.run(function (error, results, response) { + var suggestions = []; + if (!error) { + while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) { + var suggestion = response.suggestions.shift(); + if (!suggestion.isCollection) { + suggestions.push({ + text: suggestion.text, + magicKey: suggestion.magicKey + }); + } + } + } + callback(error, suggestions); + }, this); + } else { + callback(undefined, []); + return false; + } + }, + + results: function (text, key, bounds, callback) { + var request = this.geocode().text(text); + + request.maxLocations(this.options.maxResults); + + if (bounds) { + request.within(bounds); + } + + return request.run(function (error, response) { + callback(error, response.results); + }, this); + } + }); + + function geocodeServiceProvider (options) { + return new GeocodeServiceProvider(options); + } + + var WorldGeocodingServiceUrl = 'https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/'; + + exports.WorldGeocodingServiceUrl = WorldGeocodingServiceUrl; + exports.VERSION = version; + exports.Geocode = Geocode; + exports.geocode = geocode; + exports.ReverseGeocode = ReverseGeocode; + exports.reverseGeocode = reverseGeocode; + exports.Suggest = Suggest; + exports.suggest = suggest; + exports.GeocodeService = GeocodeService; + exports.geocodeService = geocodeService; + exports.Geosearch = Geosearch; + exports.geosearch = geosearch; + exports.GeosearchCore = GeosearchCore; + exports.geosearchCore = geosearchCore; + exports.ArcgisOnlineProvider = ArcgisOnlineProvider; + exports.arcgisOnlineProvider = arcgisOnlineProvider; + exports.FeatureLayerProvider = FeatureLayerProvider; + exports.featureLayerProvider = featureLayerProvider; + exports.MapServiceProvider = MapServiceProvider; + exports.mapServiceProvider = mapServiceProvider; + exports.GeocodeServiceProvider = GeocodeServiceProvider; + exports.geocodeServiceProvider = geocodeServiceProvider; + +})); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-geocoder-debug.js","sources":["../package.json","../src/Tasks/Geocode.js","../src/Tasks/ReverseGeocode.js","../src/Tasks/Suggest.js","../src/Services/Geocode.js","../src/Classes/GeosearchCore.js","../src/Providers/ArcgisOnlineGeocoder.js","../src/Controls/Geosearch.js","../src/Providers/FeatureLayer.js","../src/Providers/MapService.js","../src/Providers/GeocodeService.js","../src/EsriLeafletGeocoding.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet-geocoder\",\n  \"description\": \"Esri Geocoding utility and search plugin for Leaflet.\",\n  \"version\": \"2.2.0\",\n  \"author\": \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n  \"contributors\": [\n    \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n    \"John Gravois <jgravois@esri.com> (http://johngravois.com)\"\n  ],\n  \"dependencies\": {\n    \"esri-leaflet\": \"^2.0.3\",\n    \"leaflet\": \"^1.0.0\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"2.3.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"imagemin\": \"^3.2.0\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.24\",\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    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^2.3.4\",\n    \"node-sass\": \"^3.2.0\",\n    \"parallelshell\": \"^2.0.0\",\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-uglify\": \"^0.3.1\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"uglify-js\": \"^2.6.1\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"https://github.com/Esri/esri-leaflet-geocoder\",\n  \"jsnext:main\": \"src/EsriLeafletGeocoding.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeafletGeocoding.js\"\n  },\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-geocoder-debug.js\",\n  \"browser\": \"dist/esri-leaflet-geocoder-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git@github.com:Esri/esri-leaflet-geocoder.git\"\n  },\n  \"scripts\": {\n    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js & npm run css & npm run img\",\n    \"css\": \"node-sass ./src/esri-leaflet-geocoder.css ./dist/esri-leaflet-geocoder.css --output-style compressed\",\n    \"img\": \"imagemin ./src/img ./dist/img\",\n    \"lint\": \"semistandard src/**/*.js\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"release\": \"./scripts/release.sh\",\n    \"start-watch\": \"watch \\\"npm run build\\\" src\",\n    \"start\": \"parallelshell \\\"npm run start-watch\\\" \\\"http-server -p 5678 -c-1 -o\\\"\",\n    \"test\": \"npm run lint && karma start\"\n  },\n  \"style\": \"./dist/esri-leaflet-geocoder.css\"\n}\n","import L from 'leaflet';\nimport { Task, Util } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var Geocode = Task.extend({\n  path: 'find',\n\n  params: {\n    outSr: 4326,\n    forStorage: false,\n    outFields: '*',\n    maxLocations: 20\n  },\n\n  setters: {\n    'address': 'address',\n    'neighborhood': 'neighborhood',\n    'city': 'city',\n    'subregion': 'subregion',\n    'region': 'region',\n    'postal': 'postal',\n    'country': 'country',\n    'text': 'text',\n    'category': 'category',\n    'token': 'token',\n    'key': 'magicKey',\n    'fields': 'outFields',\n    'forStorage': 'forStorage',\n    'maxLocations': 'maxLocations'\n  },\n\n  initialize: function (options) {\n    options = options || {};\n    options.url = options.url || WorldGeocodingServiceUrl;\n    Task.prototype.initialize.call(this, options);\n  },\n\n  within: function (bounds) {\n    bounds = L.latLngBounds(bounds);\n    this.params.bbox = Util.boundsToExtent(bounds);\n    return this;\n  },\n\n  nearby: function (latlng, radius) {\n    latlng = L.latLng(latlng);\n    this.params.location = latlng.lng + ',' + latlng.lat;\n    this.params.distance = Math.min(Math.max(radius, 2000), 50000);\n    return this;\n  },\n\n  run: function (callback, context) {\n    if (this.options.customParam) {\n      this.path = 'findAddressCandidates';\n      this.params[this.options.customParam] = this.params.text;\n      delete this.params.text;\n    } else {\n      this.path = (this.params.text) ? 'find' : 'findAddressCandidates';\n    }\n\n    if (this.path === 'findAddressCandidates' && this.params.bbox) {\n      this.params.searchExtent = this.params.bbox;\n      delete this.params.bbox;\n    }\n\n    return this.request(function (error, response) {\n      var processor = (this.path === 'find') ? this._processFindResponse : this._processFindAddressCandidatesResponse;\n      var results = (!error) ? processor(response) : undefined;\n      callback.call(context, error, { results: results }, response);\n    }, this);\n  },\n\n  _processFindResponse: function (response) {\n    var results = [];\n\n    for (var i = 0; i < response.locations.length; i++) {\n      var location = response.locations[i];\n      var bounds;\n\n      if (location.extent) {\n        bounds = Util.extentToBounds(location.extent);\n      }\n\n      results.push({\n        text: location.name,\n        bounds: bounds,\n        score: location.feature.attributes.Score,\n        latlng: L.latLng(location.feature.geometry.y, location.feature.geometry.x),\n        properties: location.feature.attributes\n      });\n    }\n\n    return results;\n  },\n\n  _processFindAddressCandidatesResponse: function (response) {\n    var results = [];\n\n    for (var i = 0; i < response.candidates.length; i++) {\n      var candidate = response.candidates[i];\n      if (candidate.extent) {\n        var bounds = Util.extentToBounds(candidate.extent);\n      }\n\n      results.push({\n        text: candidate.address,\n        bounds: bounds,\n        score: candidate.score,\n        latlng: L.latLng(candidate.location.y, candidate.location.x),\n        properties: candidate.attributes\n      });\n    }\n\n    return results;\n  }\n\n});\n\nexport function geocode (options) {\n  return new Geocode(options);\n}\n\nexport default geocode;\n","import L from 'leaflet';\nimport { Task } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var ReverseGeocode = Task.extend({\n  path: 'reverseGeocode',\n\n  params: {\n    outSR: 4326,\n    returnIntersection: false\n  },\n\n  setters: {\n    'distance': 'distance',\n    'language': 'langCode',\n    'intersection': 'returnIntersection'\n  },\n\n  initialize: function (options) {\n    options = options || {};\n    options.url = options.url || WorldGeocodingServiceUrl;\n    Task.prototype.initialize.call(this, options);\n  },\n\n  latlng: function (latlng) {\n    latlng = L.latLng(latlng);\n    this.params.location = latlng.lng + ',' + latlng.lat;\n    return this;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      var result;\n\n      if (!error) {\n        result = {\n          latlng: L.latLng(response.location.y, response.location.x),\n          address: response.address\n        };\n      } else {\n        result = undefined;\n      }\n\n      callback.call(context, error, result, response);\n    }, this);\n  }\n});\n\nexport function reverseGeocode (options) {\n  return new ReverseGeocode(options);\n}\n\nexport default reverseGeocode;\n","import L from 'leaflet';\nimport { Task, Util } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var Suggest = Task.extend({\n  path: 'suggest',\n\n  params: {},\n\n  setters: {\n    text: 'text',\n    category: 'category',\n    countries: 'countryCode',\n    maxSuggestions: 'maxSuggestions'\n  },\n\n  initialize: function (options) {\n    options = options || {};\n    if (!options.url) {\n      options.url = WorldGeocodingServiceUrl;\n      options.supportsSuggest = true;\n    }\n    Task.prototype.initialize.call(this, options);\n  },\n\n  within: function (bounds) {\n    bounds = L.latLngBounds(bounds);\n    bounds = bounds.pad(0.5);\n    var center = bounds.getCenter();\n    var ne = bounds.getNorthWest();\n    this.params.location = center.lng + ',' + center.lat;\n    this.params.distance = Math.min(Math.max(center.distanceTo(ne), 2000), 50000);\n    this.params.searchExtent = Util.boundsToExtent(bounds);\n    return this;\n  },\n\n  nearby: function (latlng, radius) {\n    latlng = L.latLng(latlng);\n    this.params.location = latlng.lng + ',' + latlng.lat;\n    this.params.distance = Math.min(Math.max(radius, 2000), 50000);\n    return this;\n  },\n\n  run: function (callback, context) {\n    if (this.options.supportsSuggest) {\n      return this.request(function (error, response) {\n        callback.call(context, error, response, response);\n      }, this);\n    } else {\n      console.warn('this geocoding service does not support asking for suggestions');\n    }\n  }\n\n});\n\nexport function suggest (options) {\n  return new Suggest(options);\n}\n\nexport default suggest;\n","import { Service } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\nimport geocode from '../Tasks/Geocode';\nimport reverseGeocode from '../Tasks/ReverseGeocode';\nimport suggest from '../Tasks/Suggest';\n\nexport var GeocodeService = Service.extend({\n  initialize: function (options) {\n    options = options || {};\n    if (options.url) {\n      Service.prototype.initialize.call(this, options);\n      this._confirmSuggestSupport();\n    } else {\n      options.url = WorldGeocodingServiceUrl;\n      options.supportsSuggest = true;\n      Service.prototype.initialize.call(this, options);\n    }\n  },\n\n  geocode: function () {\n    return geocode(this);\n  },\n\n  reverse: function () {\n    return reverseGeocode(this);\n  },\n\n  suggest: function () {\n    // requires either the Esri World Geocoding Service or a <10.3 ArcGIS Server Geocoding Service that supports suggest.\n    return suggest(this);\n  },\n\n  _confirmSuggestSupport: function () {\n    this.metadata(function (error, response) {\n      if (error) { return; }\n      // pre 10.3 geocoding services dont list capabilities (and dont support maxLocations)\n      // since, only SOME individual services have been configured to support asking for suggestions\n      if (!response.capabilities) {\n        this.options.supportsSuggest = false;\n        this.options.customParam = response.singleLineAddressField.name;\n      } else if (response.capabilities.indexOf('Suggest') > -1) {\n        this.options.supportsSuggest = true;\n      } else {\n        this.options.supportsSuggest = false;\n      }\n    }, this);\n  }\n});\n\nexport function geocodeService (options) {\n  return new GeocodeService(options);\n}\n\nexport default geocodeService;\n","import L from 'leaflet';\n\nexport var GeosearchCore = L.Evented.extend({\n\n  options: {\n    zoomToResult: true,\n    useMapBounds: 12,\n    searchBounds: null\n  },\n\n  initialize: function (control, options) {\n    L.Util.setOptions(this, options);\n    this._control = control;\n\n    if (!options || !options.providers || !options.providers.length) {\n      throw new Error('You must specify at least one provider');\n    }\n\n    this._providers = options.providers;\n  },\n\n  _geocode: function (text, key, provider) {\n    var activeRequests = 0;\n    var allResults = [];\n    var bounds;\n\n    var callback = L.Util.bind(function (error, results) {\n      activeRequests--;\n      if (error) {\n        return;\n      }\n\n      if (results) {\n        allResults = allResults.concat(results);\n      }\n\n      if (activeRequests <= 0) {\n        bounds = this._boundsFromResults(allResults);\n\n        this.fire('results', {\n          results: allResults,\n          bounds: bounds,\n          latlng: (bounds) ? bounds.getCenter() : undefined,\n          text: text\n        }, true);\n\n        if (this.options.zoomToResult && bounds) {\n          this._control._map.fitBounds(bounds);\n        }\n\n        this.fire('load');\n      }\n    }, this);\n\n    if (key) {\n      activeRequests++;\n      provider.results(text, key, this._searchBounds(), callback);\n    } else {\n      for (var i = 0; i < this._providers.length; i++) {\n        activeRequests++;\n        this._providers[i].results(text, key, this._searchBounds(), callback);\n      }\n    }\n  },\n\n  _suggest: function (text) {\n    var activeRequests = this._providers.length;\n\n    var createCallback = L.Util.bind(function (text, provider) {\n      return L.Util.bind(function (error, suggestions) {\n        if (error) { return; }\n\n        var i;\n\n        activeRequests = activeRequests - 1;\n\n        if (text.length < 2) {\n          this._suggestions.innerHTML = '';\n          this._suggestions.style.display = 'none';\n          return;\n        }\n\n        if (suggestions.length) {\n          for (i = 0; i < suggestions.length; i++) {\n            suggestions[i].provider = provider;\n          }\n        } else {\n          // we still need to update the UI\n          this._control._renderSuggestions(suggestions);\n        }\n\n        if (provider._lastRender !== text && provider.nodes) {\n          for (i = 0; i < provider.nodes.length; i++) {\n            if (provider.nodes[i].parentElement) {\n              this._control._suggestions.removeChild(provider.nodes[i]);\n            }\n          }\n\n          provider.nodes = [];\n        }\n\n        if (suggestions.length && this._control._input.value === text) {\n          this._control.clearSuggestions(provider.nodes);\n\n          provider._lastRender = text;\n          provider.nodes = this._control._renderSuggestions(suggestions);\n          this._control._nodes = [];\n        }\n      }, this);\n    }, this);\n\n    this._pendingSuggestions = [];\n\n    for (var i = 0; i < this._providers.length; i++) {\n      var provider = this._providers[i];\n      var request = provider.suggestions(text, this._searchBounds(), createCallback(text, provider));\n      this._pendingSuggestions.push(request);\n    }\n  },\n\n  _searchBounds: function () {\n    if (this.options.searchBounds !== null) {\n      return this.options.searchBounds;\n    }\n\n    if (this.options.useMapBounds === false) {\n      return null;\n    }\n\n    if (this.options.useMapBounds === true) {\n      return this._control._map.getBounds();\n    }\n\n    if (this.options.useMapBounds <= this._control._map.getZoom()) {\n      return this._control._map.getBounds();\n    }\n\n    return null;\n  },\n\n  _boundsFromResults: function (results) {\n    if (!results.length) {\n      return;\n    }\n\n    var nullIsland = L.latLngBounds([0, 0], [0, 0]);\n    var resultBounds = [];\n    var resultLatlngs = [];\n\n    // collect the bounds and center of each result\n    for (var i = results.length - 1; i >= 0; i--) {\n      var result = results[i];\n\n      resultLatlngs.push(result.latlng);\n\n      // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present\n      if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {\n        resultBounds.push(result.bounds);\n      }\n    }\n\n    // form a bounds object containing all center points\n    var bounds = L.latLngBounds(resultLatlngs);\n\n    // and extend it to contain all bounds objects\n    for (var j = 0; j < resultBounds.length; j++) {\n      bounds.extend(resultBounds[j]);\n    }\n\n    return bounds;\n  },\n\n  _getAttribution: function () {\n    var attribs = [];\n    var providers = this._providers;\n\n    for (var i = 0; i < providers.length; i++) {\n      if (providers[i].options.attribution) {\n        attribs.push(providers[i].options.attribution);\n      }\n    }\n\n    return attribs.join(', ');\n  }\n\n});\n\nexport function geosearchCore (control, options) {\n  return new GeosearchCore(control, options);\n}\n\nexport default geosearchCore;\n","import { GeocodeService } from '../Services/Geocode';\n\nexport var ArcgisOnlineProvider = GeocodeService.extend({\n  options: {\n    label: 'Places and Addresses',\n    maxResults: 5\n  },\n\n  suggestions: function (text, bounds, callback) {\n    var request = this.suggest().text(text);\n\n    if (bounds) {\n      request.within(bounds);\n    }\n\n    if (this.options.countries) {\n      request.countries(this.options.countries);\n    }\n\n    if (this.options.categories) {\n      request.category(this.options.categories);\n    }\n\n    // 15 is the maximum number of suggestions that can be returned\n    request.maxSuggestions(this.options.maxResults);\n\n    return request.run(function (error, results, response) {\n      var suggestions = [];\n      if (!error) {\n        while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {\n          var suggestion = response.suggestions.shift();\n          if (!suggestion.isCollection) {\n            suggestions.push({\n              text: suggestion.text,\n              magicKey: suggestion.magicKey\n            });\n          }\n        }\n      }\n      callback(error, suggestions);\n    }, this);\n  },\n\n  results: function (text, key, bounds, callback) {\n    var request = this.geocode().text(text);\n\n    if (key) {\n      request.key(key);\n    }\n    // in the future Address/StreetName geocoding requests that include a magicKey will only return one match\n    request.maxLocations(this.options.maxResults);\n\n    if (bounds) {\n      request.within(bounds);\n    }\n\n    if (this.options.forStorage) {\n      request.forStorage(true);\n    }\n\n    return request.run(function (error, response) {\n      callback(error, response.results);\n    }, this);\n  }\n});\n\nexport function arcgisOnlineProvider (options) {\n  return new ArcgisOnlineProvider(options);\n}\n\nexport default arcgisOnlineProvider;\n","import L from 'leaflet';\nimport { geosearchCore } from '../Classes/GeosearchCore';\nimport { arcgisOnlineProvider } from '../Providers/ArcgisOnlineGeocoder';\nimport { Util } from 'esri-leaflet';\n\nexport var Geosearch = L.Control.extend({\n  includes: L.Mixin.Events,\n\n  options: {\n    position: 'topleft',\n    collapseAfterResult: true,\n    expanded: false,\n    allowMultipleResults: true,\n    placeholder: 'Search for places or addresses',\n    title: 'Location Search'\n  },\n\n  initialize: function (options) {\n    L.Util.setOptions(this, options);\n\n    if (!options || !options.providers || !options.providers.length) {\n      options = {};\n      options.providers = [ arcgisOnlineProvider() ];\n    }\n\n    // instantiate the underlying class and pass along options\n    this._geosearchCore = geosearchCore(this, options);\n    this._geosearchCore._providers = options.providers;\n\n    // bubble each providers events to the control\n    this._geosearchCore.addEventParent(this);\n    for (var i = 0; i < this._geosearchCore._providers.length; i++) {\n      this._geosearchCore._providers[i].addEventParent(this);\n    }\n\n    this._geosearchCore._pendingSuggestions = [];\n\n    L.Control.prototype.initialize.call(options);\n  },\n\n  _renderSuggestions: function (suggestions) {\n    var currentGroup;\n    this._suggestions.style.display = 'block';\n\n    // set the maxHeight of the suggestions box to\n    // map height\n    // - suggestions offset (distance from top of suggestions to top of control)\n    // - control offset (distance from top of control to top of map)\n    // - 10 (extra padding)\n    this._suggestions.style.maxHeight = (this._map.getSize().y - this._suggestions.offsetTop - this._wrapper.offsetTop - 10) + 'px';\n\n    var nodes = [];\n    var list;\n    var header;\n\n    for (var i = 0; i < suggestions.length; i++) {\n      var suggestion = suggestions[i];\n      if (!header && this._geosearchCore._providers.length > 1 && currentGroup !== suggestion.provider.options.label) {\n        header = L.DomUtil.create('span', 'geocoder-control-header', this._suggestions);\n        header.textContent = suggestion.provider.options.label;\n        header.innerText = suggestion.provider.options.label;\n        currentGroup = suggestion.provider.options.label;\n        nodes.push(header);\n      }\n\n      if (!list) {\n        list = L.DomUtil.create('ul', 'geocoder-control-list', this._suggestions);\n      }\n\n      var suggestionItem = L.DomUtil.create('li', 'geocoder-control-suggestion', list);\n\n      suggestionItem.innerHTML = suggestion.text;\n      suggestionItem.provider = suggestion.provider;\n      suggestionItem['data-magic-key'] = suggestion.magicKey;\n    }\n\n    L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n\n    nodes.push(list);\n\n    return nodes;\n  },\n\n  _boundsFromResults: function (results) {\n    if (!results.length) {\n      return;\n    }\n\n    var nullIsland = L.latLngBounds([0, 0], [0, 0]);\n    var resultBounds = [];\n    var resultLatlngs = [];\n\n    // collect the bounds and center of each result\n    for (var i = results.length - 1; i >= 0; i--) {\n      var result = results[i];\n\n      resultLatlngs.push(result.latlng);\n\n      // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present\n      if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {\n        resultBounds.push(result.bounds);\n      }\n    }\n\n    // form a bounds object containing all center points\n    var bounds = L.latLngBounds(resultLatlngs);\n\n    // and extend it to contain all bounds objects\n    for (var j = 0; j < resultBounds.length; j++) {\n      bounds.extend(resultBounds[j]);\n    }\n\n    return bounds;\n  },\n\n  clear: function () {\n    this._suggestions.innerHTML = '';\n    this._suggestions.style.display = 'none';\n    this._input.value = '';\n\n    if (this.options.collapseAfterResult) {\n      this._input.placeholder = '';\n      L.DomUtil.removeClass(this._wrapper, 'geocoder-control-expanded');\n    }\n\n    if (!this._map.scrollWheelZoom.enabled() && this._map.options.scrollWheelZoom) {\n      this._map.scrollWheelZoom.enable();\n    }\n  },\n\n  clearSuggestions: function () {\n    if (this._nodes) {\n      for (var k = 0; k < this._nodes.length; k++) {\n        if (this._nodes[k].parentElement) {\n          this._suggestions.removeChild(this._nodes[k]);\n        }\n      }\n    }\n  },\n\n  _setupClick: function () {\n    L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n    this._input.focus();\n  },\n\n  disable: function () {\n    this._input.disabled = true;\n    L.DomUtil.addClass(this._input, 'geocoder-control-input-disabled');\n    L.DomEvent.removeListener(this._wrapper, 'click', this._setupClick, this);\n  },\n\n  enable: function () {\n    this._input.disabled = false;\n    L.DomUtil.removeClass(this._input, 'geocoder-control-input-disabled');\n    L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);\n  },\n\n  getAttribution: function () {\n    var attribs = [];\n\n    for (var i = 0; i < this._providers.length; i++) {\n      if (this._providers[i].options.attribution) {\n        attribs.push(this._providers[i].options.attribution);\n      }\n    }\n\n    return attribs.join(', ');\n  },\n\n  onAdd: function (map) {\n    // include 'Powered by Esri' in map attribution\n    Util.setEsriAttribution(map);\n\n    this._map = map;\n    this._wrapper = L.DomUtil.create('div', 'geocoder-control');\n    this._input = L.DomUtil.create('input', 'geocoder-control-input leaflet-bar', this._wrapper);\n    this._input.title = this.options.title;\n\n    if (this.options.expanded) {\n      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n      this._input.placeholder = this.options.placeholder;\n    }\n\n    this._suggestions = L.DomUtil.create('div', 'geocoder-control-suggestions leaflet-bar', this._wrapper);\n\n    var credits = this._geosearchCore._getAttribution();\n    map.attributionControl.addAttribution(credits);\n\n    L.DomEvent.addListener(this._input, 'focus', function (e) {\n      this._input.placeholder = this.options.placeholder;\n      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n    }, this);\n\n    L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);\n\n    L.DomEvent.addListener(this._suggestions, 'mousedown', function (e) {\n      var suggestionItem = e.target || e.srcElement;\n      this._geosearchCore._geocode(suggestionItem.innerHTML, suggestionItem['data-magic-key'], suggestionItem.provider);\n      this.clear();\n    }, this);\n\n    L.DomEvent.addListener(this._input, 'blur', function (e) {\n      this.clear();\n    }, this);\n\n    L.DomEvent.addListener(this._input, 'keydown', function (e) {\n      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n\n      var list = this._suggestions.querySelectorAll('.' + 'geocoder-control-suggestion');\n      var selected = this._suggestions.querySelectorAll('.' + 'geocoder-control-selected')[0];\n      var selectedPosition;\n\n      for (var i = 0; i < list.length; i++) {\n        if (list[i] === selected) {\n          selectedPosition = i;\n          break;\n        }\n      }\n\n      switch (e.keyCode) {\n        case 13:\n          if (selected) {\n            this._geosearchCore._geocode(selected.innerHTML, selected['data-magic-key'], selected.provider);\n            this.clear();\n          } else if (this.options.allowMultipleResults) {\n            this._geosearchCore._geocode(this._input.value, undefined);\n            this.clear();\n          } else {\n            L.DomUtil.addClass(list[0], 'geocoder-control-selected');\n          }\n          L.DomEvent.preventDefault(e);\n          break;\n        case 38:\n          if (selected) {\n            L.DomUtil.removeClass(selected, 'geocoder-control-selected');\n          }\n\n          var previousItem = list[selectedPosition - 1];\n\n          if (selected && previousItem) {\n            L.DomUtil.addClass(previousItem, 'geocoder-control-selected');\n          } else {\n            L.DomUtil.addClass(list[list.length - 1], 'geocoder-control-selected');\n          }\n          L.DomEvent.preventDefault(e);\n          break;\n        case 40:\n          if (selected) {\n            L.DomUtil.removeClass(selected, 'geocoder-control-selected');\n          }\n\n          var nextItem = list[selectedPosition + 1];\n\n          if (selected && nextItem) {\n            L.DomUtil.addClass(nextItem, 'geocoder-control-selected');\n          } else {\n            L.DomUtil.addClass(list[0], 'geocoder-control-selected');\n          }\n          L.DomEvent.preventDefault(e);\n          break;\n        default:\n          // when the input changes we should cancel all pending suggestion requests if possible to avoid result collisions\n          for (var x = 0; x < this._geosearchCore._pendingSuggestions.length; x++) {\n            var request = this._geosearchCore._pendingSuggestions[x];\n            if (request && request.abort && !request.id) {\n              request.abort();\n            }\n          }\n          break;\n      }\n    }, this);\n\n    L.DomEvent.addListener(this._input, 'keyup', L.Util.throttle(function (e) {\n      var key = e.which || e.keyCode;\n      var text = (e.target || e.srcElement).value;\n\n      // require at least 2 characters for suggestions\n      if (text.length < 2) {\n        this._suggestions.innerHTML = '';\n        this._suggestions.style.display = 'none';\n        L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n        return;\n      }\n\n      // if this is the escape key it will clear the input so clear suggestions\n      if (key === 27) {\n        this._suggestions.innerHTML = '';\n        this._suggestions.style.display = 'none';\n        return;\n      }\n\n      // if this is NOT the up/down arrows or enter make a suggestion\n      if (key !== 13 && key !== 38 && key !== 40) {\n        if (this._input.value !== this._lastValue) {\n          this._lastValue = this._input.value;\n          L.DomUtil.addClass(this._input, 'geocoder-control-loading');\n          this._geosearchCore._suggest(text);\n        }\n      }\n    }, 50, this), this);\n\n    L.DomEvent.disableClickPropagation(this._wrapper);\n\n    // when mouse moves over suggestions disable scroll wheel zoom if its enabled\n    L.DomEvent.addListener(this._suggestions, 'mouseover', function (e) {\n      if (map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {\n        map.scrollWheelZoom.disable();\n      }\n    });\n\n    // when mouse moves leaves suggestions enable scroll wheel zoom if its disabled\n    L.DomEvent.addListener(this._suggestions, 'mouseout', function (e) {\n      if (!map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {\n        map.scrollWheelZoom.enable();\n      }\n    });\n\n    this._geosearchCore.on('load', function (e) {\n      L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n      this.clear();\n      this._input.blur();\n    }, this);\n\n    return this._wrapper;\n  }\n});\n\nexport function geosearch (options) {\n  return new Geosearch(options);\n}\n\nexport default geosearch;\n","import L from 'leaflet';\nimport { FeatureLayerService } from 'esri-leaflet';\n\nexport var FeatureLayerProvider = FeatureLayerService.extend({\n  options: {\n    label: 'Feature Layer',\n    maxResults: 5,\n    bufferRadius: 1000,\n    formatSuggestion: function (feature) {\n      return feature.properties[this.options.searchFields[0]];\n    }\n  },\n\n  initialize: function (options) {\n    FeatureLayerService.prototype.initialize.call(this, options);\n    if (typeof this.options.searchFields === 'string') {\n      this.options.searchFields = [this.options.searchFields];\n    }\n    this._suggestionsQuery = this.query();\n    this._resultsQuery = this.query();\n  },\n\n  suggestions: function (text, bounds, callback) {\n    var query = this._suggestionsQuery.where(this._buildQuery(text))\n      .returnGeometry(false);\n\n    if (bounds) {\n      query.intersects(bounds);\n    }\n\n    if (this.options.idField) {\n      query.fields([this.options.idField].concat(this.options.searchFields));\n    }\n\n    var request = query.run(function (error, results, raw) {\n      if (error) {\n        callback(error, []);\n      } else {\n        this.options.idField = raw.objectIdFieldName;\n        var suggestions = [];\n        for (var i = results.features.length - 1; i >= 0; i--) {\n          var feature = results.features[i];\n          suggestions.push({\n            text: this.options.formatSuggestion.call(this, feature),\n            magicKey: feature.id\n          });\n        }\n        callback(error, suggestions.slice(0, this.options.maxResults));\n      }\n    }, this);\n\n    return request;\n  },\n\n  results: function (text, key, bounds, callback) {\n    var query = this._resultsQuery;\n\n    if (key) {\n      query.featureIds([key]);\n    } else {\n      query.where(this._buildQuery(text));\n    }\n\n    if (bounds) {\n      query.within(bounds);\n    }\n\n    return query.run(L.Util.bind(function (error, features) {\n      var results = [];\n      for (var i = 0; i < features.features.length; i++) {\n        var feature = features.features[i];\n        if (feature) {\n          var bounds = this._featureBounds(feature);\n\n          var result = {\n            latlng: bounds.getCenter(),\n            bounds: bounds,\n            text: this.options.formatSuggestion.call(this, feature),\n            properties: feature.properties,\n            geojson: feature\n          };\n\n          results.push(result);\n        }\n      }\n      callback(error, results);\n    }, this));\n  },\n\n  orderBy: function (fieldName, order) {\n    this._suggestionsQuery.orderBy(fieldName, order);\n  },\n\n  _buildQuery: function (text) {\n    var queryString = [];\n\n    for (var i = this.options.searchFields.length - 1; i >= 0; i--) {\n      var field = 'upper(\"' + this.options.searchFields[i] + '\")';\n\n      queryString.push(field + \" LIKE upper('%\" + text + \"%')\");\n    }\n\n    if (this.options.where) {\n      return this.options.where + ' AND (' + queryString.join(' OR ') + ')';\n    } else {\n      return queryString.join(' OR ');\n    }\n  },\n\n  _featureBounds: function (feature) {\n    var geojson = L.geoJson(feature);\n    if (feature.geometry.type === 'Point') {\n      var center = geojson.getBounds().getCenter();\n      var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);\n      var latRadius = (this.options.bufferRadius / 40075017) * 360;\n      return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);\n    } else {\n      return geojson.getBounds();\n    }\n  }\n});\n\nexport function featureLayerProvider (options) {\n  return new FeatureLayerProvider(options);\n}\n\nexport default featureLayerProvider;\n","import L from 'leaflet';\nimport { MapService } from 'esri-leaflet';\n\nexport var MapServiceProvider = MapService.extend({\n  options: {\n    layers: [0],\n    label: 'Map Service',\n    bufferRadius: 1000,\n    maxResults: 5,\n    formatSuggestion: function (feature) {\n      return feature.properties[feature.displayFieldName] + ' <small>' + feature.layerName + '</small>';\n    }\n  },\n\n  initialize: function (options) {\n    MapService.prototype.initialize.call(this, options);\n    this._getIdFields();\n  },\n\n  suggestions: function (text, bounds, callback) {\n    var request = this.find().text(text).fields(this.options.searchFields).returnGeometry(false).layers(this.options.layers);\n\n    return request.run(function (error, results, raw) {\n      var suggestions = [];\n      if (!error) {\n        var count = Math.min(this.options.maxResults, results.features.length);\n        raw.results = raw.results.reverse();\n        for (var i = 0; i < count; i++) {\n          var feature = results.features[i];\n          var result = raw.results[i];\n          var layer = result.layerId;\n          var idField = this._idFields[layer];\n          feature.layerId = layer;\n          feature.layerName = this._layerNames[layer];\n          feature.displayFieldName = this._displayFields[layer];\n          if (idField) {\n            suggestions.push({\n              text: this.options.formatSuggestion.call(this, feature),\n              magicKey: result.attributes[idField] + ':' + layer\n            });\n          }\n        }\n      }\n      callback(error, suggestions.reverse());\n    }, this);\n  },\n\n  results: function (text, key, bounds, callback) {\n    var results = [];\n    var request;\n\n    if (key) {\n      var featureId = key.split(':')[0];\n      var layer = key.split(':')[1];\n      request = this.query().layer(layer).featureIds(featureId);\n    } else {\n      request = this.find().text(text).fields(this.options.searchFields).layers(this.options.layers);\n    }\n\n    return request.run(function (error, features, response) {\n      if (!error) {\n        if (response.results) {\n          response.results = response.results.reverse();\n        }\n        for (var i = 0; i < features.features.length; i++) {\n          var feature = features.features[i];\n          layer = layer || response.results[i].layerId;\n\n          if (feature && layer !== undefined) {\n            var bounds = this._featureBounds(feature);\n            feature.layerId = layer;\n            feature.layerName = this._layerNames[layer];\n            feature.displayFieldName = this._displayFields[layer];\n\n            var result = {\n              latlng: bounds.getCenter(),\n              bounds: bounds,\n              text: this.options.formatSuggestion.call(this, feature),\n              properties: feature.properties,\n              geojson: feature\n            };\n\n            results.push(result);\n          }\n        }\n      }\n      callback(error, results.reverse());\n    }, this);\n  },\n\n  _featureBounds: function (feature) {\n    var geojson = L.geoJson(feature);\n    if (feature.geometry.type === 'Point') {\n      var center = geojson.getBounds().getCenter();\n      var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);\n      var latRadius = (this.options.bufferRadius / 40075017) * 360;\n      return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);\n    } else {\n      return geojson.getBounds();\n    }\n  },\n\n  _layerMetadataCallback: function (layerid) {\n    return L.Util.bind(function (error, metadata) {\n      if (error) { return; }\n      this._displayFields[layerid] = metadata.displayField;\n      this._layerNames[layerid] = metadata.name;\n      for (var i = 0; i < metadata.fields.length; i++) {\n        var field = metadata.fields[i];\n        if (field.type === 'esriFieldTypeOID') {\n          this._idFields[layerid] = field.name;\n          break;\n        }\n      }\n    }, this);\n  },\n\n  _getIdFields: function () {\n    this._idFields = {};\n    this._displayFields = {};\n    this._layerNames = {};\n    for (var i = 0; i < this.options.layers.length; i++) {\n      var layer = this.options.layers[i];\n      this.get(layer, {}, this._layerMetadataCallback(layer));\n    }\n  }\n});\n\nexport function mapServiceProvider (options) {\n  return new MapServiceProvider(options);\n}\n\nexport default mapServiceProvider;\n","import { GeocodeService } from '../Services/Geocode';\n\nexport var GeocodeServiceProvider = GeocodeService.extend({\n  options: {\n    label: 'Geocode Server',\n    maxResults: 5\n  },\n\n  suggestions: function (text, bounds, callback) {\n    if (this.options.supportsSuggest) {\n      var request = this.suggest().text(text);\n      if (bounds) {\n        request.within(bounds);\n      }\n\n      return request.run(function (error, results, response) {\n        var suggestions = [];\n        if (!error) {\n          while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {\n            var suggestion = response.suggestions.shift();\n            if (!suggestion.isCollection) {\n              suggestions.push({\n                text: suggestion.text,\n                magicKey: suggestion.magicKey\n              });\n            }\n          }\n        }\n        callback(error, suggestions);\n      }, this);\n    } else {\n      callback(undefined, []);\n      return false;\n    }\n  },\n\n  results: function (text, key, bounds, callback) {\n    var request = this.geocode().text(text);\n\n    request.maxLocations(this.options.maxResults);\n\n    if (bounds) {\n      request.within(bounds);\n    }\n\n    return request.run(function (error, response) {\n      callback(error, response.results);\n    }, this);\n  }\n});\n\nexport function geocodeServiceProvider (options) {\n  return new GeocodeServiceProvider(options);\n}\n\nexport default geocodeServiceProvider;\n","export { version as VERSION } from '../package.json';\nexport var WorldGeocodingServiceUrl = 'https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/';\n\n// import tasks\nexport { Geocode, geocode } from './Tasks/Geocode';\nexport { ReverseGeocode, reverseGeocode } from './Tasks/ReverseGeocode';\nexport { Suggest, suggest } from './Tasks/Suggest';\n\n// import service\nexport { GeocodeService, geocodeService } from './Services/Geocode';\n\n// import control\nexport { Geosearch, geosearch } from './Controls/Geosearch';\n\n// import supporting class\nexport { GeosearchCore, geosearchCore } from './Classes/GeosearchCore';\n\n// import providers\nexport { ArcgisOnlineProvider, arcgisOnlineProvider } from './Providers/ArcgisOnlineGeocoder';\nexport { FeatureLayerProvider, featureLayerProvider } from './Providers/FeatureLayer';\nexport { MapServiceProvider, mapServiceProvider } from './Providers/MapService';\nexport { GeocodeServiceProvider, geocodeServiceProvider } from './Providers/GeocodeService';\n"],"names":["Task","Util","Service","FeatureLayerService","MapService"],"mappings":"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"} \ No newline at end of file diff --git a/dist/esri-leaflet-geocoder.css b/dist/esri-leaflet-geocoder.css new file mode 100644 index 0000000..1298c56 --- /dev/null +++ b/dist/esri-leaflet-geocoder.css @@ -0,0 +1 @@ +.geocoder-control-input{position:absolute;left:0;top:0;background-color:white;background-repeat:no-repeat;background-image:url("img/search.png");background-size:26px;border:none;padding:0;text-indent:6px;font-size:13px;line-height:normal;height:auto;padding-top:5px;padding-bottom:5px;width:100%;background-position:right center;cursor:pointer;box-sizing:border-box}.geocoder-control-input-disabled{background-color:#f4f4f4;background-image:url("img/search-disabled.png")}.geocoder-control{width:26px;height:26px;-webkit-transition:width .175s ease-in;-moz-transition:width .175s ease-in;-ms-transition:width .175s ease-in;-o-transition:width .175s ease-in;transition:width .175s ease-in}.geocoder-control-expanded,.leaflet-touch .geocoder-control-expanded{width:275px}.geocoder-control-input.geocoder-control-loading{background-image:url("img/loading.gif");background-size:26px}@media only screen and (min--moz-device-pixel-ratio: 2), only screen and (-o-min-device-pixel-ratio: 2 / 1), only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min-device-pixel-ratio: 2){.geocoder-control-input{background-image:url("img/search@2x.png")}.geocoder-control-input-disabled{background-image:url("img/search@2x-disabled.png")}.geocoder-control-input.geocoder-control-loading{background-image:url("img/loading@2x.gif")}}.geocoder-control-input:focus{outline:none;cursor:text}.geocoder-control-input::-ms-clear{display:none}.geocoder-control-suggestions{width:100%;position:absolute;top:26px;left:0;margin-top:10px;overflow:auto;display:none}.geocoder-control-list+.geocoder-control-header{border-top:1px solid #d5d5d5}.geocoder-control-header{font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:0.05em;color:#444;background:#F2F2F2;border-bottom:1px solid #d5d5d5;display:block;padding:.5em}.geocoder-control-list{list-style:none;margin:0;padding:0}.geocoder-control-suggestions .geocoder-control-suggestion{font-size:13px;padding:7px;background:white;border-top:1px solid #f1f1f1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:pointer}.geocoder-control-suggestions .geocoder-control-suggestion:first-child{border:none}.geocoder-control-suggestions .geocoder-control-suggestion.geocoder-control-selected,.geocoder-control-suggestions .geocoder-control-suggestion:hover{background:#7FDFFF;border-color:#7FDFFF}.leaflet-right .geocoder-control-suggestions{left:auto;right:0}.leaflet-right .geocoder-control-input{left:auto;right:0}.leaflet-touch .geocoder-control{width:30px;height:30px}.leaflet-touch .geocoder-control.geocoder-control-expanded{width:275px}.leaflet-touch .geocoder-control-input{height:30px;line-height:30px;background-size:30px}.leaflet-touch .geocoder-control-suggestions{top:30px}.leaflet-oldie .geocoder-control-input{width:28px;height:28px}.leaflet-oldie .geocoder-control-expanded .geocoder-control-input{width:auto}.leaflet-oldie .geocoder-control-input,.leaflet-oldie .geocoder-control-suggestions{border:1px solid #999} diff --git a/dist/esri-leaflet-geocoder.js b/dist/esri-leaflet-geocoder.js new file mode 100644 index 0000000..9e41dfa --- /dev/null +++ b/dist/esri-leaflet-geocoder.js @@ -0,0 +1,5 @@ +/* esri-leaflet-geocoder - v2.2.0 - Sun Nov 06 2016 15:39:39 GMT-0800 (PST) + * Copyright (c) 2016 Environmental Systems Research Institute, Inc. + * Apache-2.0 */ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("leaflet"),require("esri-leaflet")):"function"==typeof define&&define.amd?define(["exports","leaflet","esri-leaflet"],t):t((e.L=e.L||{},e.L.esri=e.L.esri||{},e.L.esri.Geocoding=e.L.esri.Geocoding||{}),e.L,e.L.esri)}(this,function(e,t,s){"use strict";function i(e){return new g(e)}function o(e){return new f(e)}function n(e){return new v(e)}function r(e){return new m(e)}function a(e,t){return new _(e,t)}function l(e){return new y(e)}function u(e){return new b(e)}function d(e){return new x(e)}function h(e){return new C(e)}function c(e){return new S(e)}t="default"in t?t.default:t;var p="2.2.0",g=s.Task.extend({path:"find",params:{outSr:4326,forStorage:!1,outFields:"*",maxLocations:20},setters:{address:"address",neighborhood:"neighborhood",city:"city",subregion:"subregion",region:"region",postal:"postal",country:"country",text:"text",category:"category",token:"token",key:"magicKey",fields:"outFields",forStorage:"forStorage",maxLocations:"maxLocations"},initialize:function(e){e=e||{},e.url=e.url||L,s.Task.prototype.initialize.call(this,e)},within:function(e){return e=t.latLngBounds(e),this.params.bbox=s.Util.boundsToExtent(e),this},nearby:function(e,s){return e=t.latLng(e),this.params.location=e.lng+","+e.lat,this.params.distance=Math.min(Math.max(s,2e3),5e4),this},run:function(e,t){return this.options.customParam?(this.path="findAddressCandidates",this.params[this.options.customParam]=this.params.text,delete this.params.text):this.path=this.params.text?"find":"findAddressCandidates","findAddressCandidates"===this.path&&this.params.bbox&&(this.params.searchExtent=this.params.bbox,delete this.params.bbox),this.request(function(s,i){var o="find"===this.path?this._processFindResponse:this._processFindAddressCandidatesResponse,n=s?void 0:o(i);e.call(t,s,{results:n},i)},this)},_processFindResponse:function(e){for(var i=[],o=0;o-1?this.options.supportsSuggest=!0:this.options.supportsSuggest=!1:(this.options.supportsSuggest=!1,this.options.customParam=t.singleLineAddressField.name))},this)}}),_=t.Evented.extend({options:{zoomToResult:!0,useMapBounds:12,searchBounds:null},initialize:function(e,s){if(t.Util.setOptions(this,s),this._control=e,!s||!s.providers||!s.providers.length)throw new Error("You must specify at least one provider");this._providers=s.providers},_geocode:function(e,s,i){var o,n=0,r=[],a=t.Util.bind(function(t,s){n--,t||(s&&(r=r.concat(s)),n<=0&&(o=this._boundsFromResults(r),this.fire("results",{results:r,bounds:o,latlng:o?o.getCenter():void 0,text:e},!0),this.options.zoomToResult&&o&&this._control._map.fitBounds(o),this.fire("load")))},this);if(s)n++,i.results(e,s,this._searchBounds(),a);else for(var l=0;l=0;n--){var r=e[n];o.push(r.latlng),r.bounds&&r.bounds.isValid()&&!r.bounds.equals(s)&&i.push(r.bounds)}for(var a=t.latLngBounds(o),l=0;l1&&s!==a.provider.options.label&&(o=t.DomUtil.create("span","geocoder-control-header",this._suggestions),o.textContent=a.provider.options.label,o.innerText=a.provider.options.label,s=a.provider.options.label,n.push(o)),i||(i=t.DomUtil.create("ul","geocoder-control-list",this._suggestions));var l=t.DomUtil.create("li","geocoder-control-suggestion",i);l.innerHTML=a.text,l.provider=a.provider,l["data-magic-key"]=a.magicKey}return t.DomUtil.removeClass(this._input,"geocoder-control-loading"),n.push(i),n},_boundsFromResults:function(e){if(e.length){for(var s=t.latLngBounds([0,0],[0,0]),i=[],o=[],n=e.length-1;n>=0;n--){var r=e[n];o.push(r.latlng),r.bounds&&r.bounds.isValid()&&!r.bounds.equals(s)&&i.push(r.bounds)}for(var a=t.latLngBounds(o),l=0;l=0;n--){var r=t.features[n];o.push({text:this.options.formatSuggestion.call(this,r),magicKey:r.id})}s(e,o.slice(0,this.options.maxResults))}},this);return o},results:function(e,s,i,o){var n=this._resultsQuery;return s?n.featureIds([s]):n.where(this._buildQuery(e)),i&&n.within(i),n.run(t.Util.bind(function(e,t){for(var s=[],i=0;i=0;s--){var i='upper("'+this.options.searchFields[s]+'")';t.push(i+" LIKE upper('%"+e+"%')")}return this.options.where?this.options.where+" AND ("+t.join(" OR ")+")":t.join(" OR ")},_featureBounds:function(e){var s=t.geoJson(e);if("Point"===e.geometry.type){var i=s.getBounds().getCenter(),o=this.options.bufferRadius/40075017*360/Math.cos(180/Math.PI*i.lat),n=this.options.bufferRadius/40075017*360;return t.latLngBounds([i.lat-n,i.lng-o],[i.lat+n,i.lng+o])}return s.getBounds()}}),C=s.MapService.extend({options:{layers:[0],label:"Map Service",bufferRadius:1e3,maxResults:5,formatSuggestion:function(e){return e.properties[e.displayFieldName]+" "+e.layerName+""}},initialize:function(e){s.MapService.prototype.initialize.call(this,e),this._getIdFields()},suggestions:function(e,t,s){var i=this.find().text(e).fields(this.options.searchFields).returnGeometry(!1).layers(this.options.layers);return i.run(function(e,t,i){var o=[];if(!e){var n=Math.min(this.options.maxResults,t.features.length);i.results=i.results.reverse();for(var r=0;r (http://patrickarlt.com)\",\n \"contributors\": [\n \"Patrick Arlt (http://patrickarlt.com)\",\n \"John Gravois (http://johngravois.com)\"\n ],\n \"dependencies\": {\n \"esri-leaflet\": \"^2.0.3\",\n \"leaflet\": \"^1.0.0\"\n },\n \"devDependencies\": {\n \"chai\": \"2.3.0\",\n \"gh-release\": \"^2.0.0\",\n \"http-server\": \"^0.8.5\",\n \"imagemin\": \"^3.2.0\",\n \"isparta\": \"^3.0.3\",\n \"istanbul\": \"^0.4.2\",\n \"karma\": \"^0.12.24\",\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 \"mkdirp\": \"^0.5.1\",\n \"mocha\": \"^2.3.4\",\n \"node-sass\": \"^3.2.0\",\n \"parallelshell\": \"^2.0.0\",\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-uglify\": \"^0.3.1\",\n \"semistandard\": \"^7.0.5\",\n \"sinon\": \"^1.11.1\",\n \"sinon-chai\": \"2.7.0\",\n \"uglify-js\": \"^2.6.1\",\n \"watch\": \"^0.17.1\"\n },\n \"homepage\": \"https://github.com/Esri/esri-leaflet-geocoder\",\n \"jsnext:main\": \"src/EsriLeafletGeocoding.js\",\n \"jspm\": {\n \"registry\": \"npm\",\n \"format\": \"es6\",\n \"main\": \"src/EsriLeafletGeocoding.js\"\n },\n \"license\": \"Apache-2.0\",\n \"main\": \"dist/esri-leaflet-geocoder-debug.js\",\n \"browser\": \"dist/esri-leaflet-geocoder-debug.js\",\n \"readmeFilename\": \"README.md\",\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"git@github.com:Esri/esri-leaflet-geocoder.git\"\n },\n \"scripts\": {\n \"prebuild\": \"mkdirp dist\",\n \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js & npm run css & npm run img\",\n \"css\": \"node-sass ./src/esri-leaflet-geocoder.css ./dist/esri-leaflet-geocoder.css --output-style compressed\",\n \"img\": \"imagemin ./src/img ./dist/img\",\n \"lint\": \"semistandard src/**/*.js\",\n \"prepublish\": \"npm run build\",\n \"pretest\": \"npm run build\",\n \"release\": \"./scripts/release.sh\",\n \"start-watch\": \"watch \\\"npm run build\\\" src\",\n \"start\": \"parallelshell \\\"npm run start-watch\\\" \\\"http-server -p 5678 -c-1 -o\\\"\",\n \"test\": \"npm run lint && karma start\"\n },\n \"style\": \"./dist/esri-leaflet-geocoder.css\"\n}\n","import L from 'leaflet';\nimport { Task, Util } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var Geocode = Task.extend({\n path: 'find',\n\n params: {\n outSr: 4326,\n forStorage: false,\n outFields: '*',\n maxLocations: 20\n },\n\n setters: {\n 'address': 'address',\n 'neighborhood': 'neighborhood',\n 'city': 'city',\n 'subregion': 'subregion',\n 'region': 'region',\n 'postal': 'postal',\n 'country': 'country',\n 'text': 'text',\n 'category': 'category',\n 'token': 'token',\n 'key': 'magicKey',\n 'fields': 'outFields',\n 'forStorage': 'forStorage',\n 'maxLocations': 'maxLocations'\n },\n\n initialize: function (options) {\n options = options || {};\n options.url = options.url || WorldGeocodingServiceUrl;\n Task.prototype.initialize.call(this, options);\n },\n\n within: function (bounds) {\n bounds = L.latLngBounds(bounds);\n this.params.bbox = Util.boundsToExtent(bounds);\n return this;\n },\n\n nearby: function (latlng, radius) {\n latlng = L.latLng(latlng);\n this.params.location = latlng.lng + ',' + latlng.lat;\n this.params.distance = Math.min(Math.max(radius, 2000), 50000);\n return this;\n },\n\n run: function (callback, context) {\n if (this.options.customParam) {\n this.path = 'findAddressCandidates';\n this.params[this.options.customParam] = this.params.text;\n delete this.params.text;\n } else {\n this.path = (this.params.text) ? 'find' : 'findAddressCandidates';\n }\n\n if (this.path === 'findAddressCandidates' && this.params.bbox) {\n this.params.searchExtent = this.params.bbox;\n delete this.params.bbox;\n }\n\n return this.request(function (error, response) {\n var processor = (this.path === 'find') ? this._processFindResponse : this._processFindAddressCandidatesResponse;\n var results = (!error) ? processor(response) : undefined;\n callback.call(context, error, { results: results }, response);\n }, this);\n },\n\n _processFindResponse: function (response) {\n var results = [];\n\n for (var i = 0; i < response.locations.length; i++) {\n var location = response.locations[i];\n var bounds;\n\n if (location.extent) {\n bounds = Util.extentToBounds(location.extent);\n }\n\n results.push({\n text: location.name,\n bounds: bounds,\n score: location.feature.attributes.Score,\n latlng: L.latLng(location.feature.geometry.y, location.feature.geometry.x),\n properties: location.feature.attributes\n });\n }\n\n return results;\n },\n\n _processFindAddressCandidatesResponse: function (response) {\n var results = [];\n\n for (var i = 0; i < response.candidates.length; i++) {\n var candidate = response.candidates[i];\n if (candidate.extent) {\n var bounds = Util.extentToBounds(candidate.extent);\n }\n\n results.push({\n text: candidate.address,\n bounds: bounds,\n score: candidate.score,\n latlng: L.latLng(candidate.location.y, candidate.location.x),\n properties: candidate.attributes\n });\n }\n\n return results;\n }\n\n});\n\nexport function geocode (options) {\n return new Geocode(options);\n}\n\nexport default geocode;\n","import L from 'leaflet';\nimport { Task } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var ReverseGeocode = Task.extend({\n path: 'reverseGeocode',\n\n params: {\n outSR: 4326,\n returnIntersection: false\n },\n\n setters: {\n 'distance': 'distance',\n 'language': 'langCode',\n 'intersection': 'returnIntersection'\n },\n\n initialize: function (options) {\n options = options || {};\n options.url = options.url || WorldGeocodingServiceUrl;\n Task.prototype.initialize.call(this, options);\n },\n\n latlng: function (latlng) {\n latlng = L.latLng(latlng);\n this.params.location = latlng.lng + ',' + latlng.lat;\n return this;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n var result;\n\n if (!error) {\n result = {\n latlng: L.latLng(response.location.y, response.location.x),\n address: response.address\n };\n } else {\n result = undefined;\n }\n\n callback.call(context, error, result, response);\n }, this);\n }\n});\n\nexport function reverseGeocode (options) {\n return new ReverseGeocode(options);\n}\n\nexport default reverseGeocode;\n","import L from 'leaflet';\nimport { Task, Util } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\n\nexport var Suggest = Task.extend({\n path: 'suggest',\n\n params: {},\n\n setters: {\n text: 'text',\n category: 'category',\n countries: 'countryCode',\n maxSuggestions: 'maxSuggestions'\n },\n\n initialize: function (options) {\n options = options || {};\n if (!options.url) {\n options.url = WorldGeocodingServiceUrl;\n options.supportsSuggest = true;\n }\n Task.prototype.initialize.call(this, options);\n },\n\n within: function (bounds) {\n bounds = L.latLngBounds(bounds);\n bounds = bounds.pad(0.5);\n var center = bounds.getCenter();\n var ne = bounds.getNorthWest();\n this.params.location = center.lng + ',' + center.lat;\n this.params.distance = Math.min(Math.max(center.distanceTo(ne), 2000), 50000);\n this.params.searchExtent = Util.boundsToExtent(bounds);\n return this;\n },\n\n nearby: function (latlng, radius) {\n latlng = L.latLng(latlng);\n this.params.location = latlng.lng + ',' + latlng.lat;\n this.params.distance = Math.min(Math.max(radius, 2000), 50000);\n return this;\n },\n\n run: function (callback, context) {\n if (this.options.supportsSuggest) {\n return this.request(function (error, response) {\n callback.call(context, error, response, response);\n }, this);\n } else {\n console.warn('this geocoding service does not support asking for suggestions');\n }\n }\n\n});\n\nexport function suggest (options) {\n return new Suggest(options);\n}\n\nexport default suggest;\n","import { Service } from 'esri-leaflet';\nimport { WorldGeocodingServiceUrl } from '../EsriLeafletGeocoding';\nimport geocode from '../Tasks/Geocode';\nimport reverseGeocode from '../Tasks/ReverseGeocode';\nimport suggest from '../Tasks/Suggest';\n\nexport var GeocodeService = Service.extend({\n initialize: function (options) {\n options = options || {};\n if (options.url) {\n Service.prototype.initialize.call(this, options);\n this._confirmSuggestSupport();\n } else {\n options.url = WorldGeocodingServiceUrl;\n options.supportsSuggest = true;\n Service.prototype.initialize.call(this, options);\n }\n },\n\n geocode: function () {\n return geocode(this);\n },\n\n reverse: function () {\n return reverseGeocode(this);\n },\n\n suggest: function () {\n // requires either the Esri World Geocoding Service or a <10.3 ArcGIS Server Geocoding Service that supports suggest.\n return suggest(this);\n },\n\n _confirmSuggestSupport: function () {\n this.metadata(function (error, response) {\n if (error) { return; }\n // pre 10.3 geocoding services dont list capabilities (and dont support maxLocations)\n // since, only SOME individual services have been configured to support asking for suggestions\n if (!response.capabilities) {\n this.options.supportsSuggest = false;\n this.options.customParam = response.singleLineAddressField.name;\n } else if (response.capabilities.indexOf('Suggest') > -1) {\n this.options.supportsSuggest = true;\n } else {\n this.options.supportsSuggest = false;\n }\n }, this);\n }\n});\n\nexport function geocodeService (options) {\n return new GeocodeService(options);\n}\n\nexport default geocodeService;\n","import L from 'leaflet';\n\nexport var GeosearchCore = L.Evented.extend({\n\n options: {\n zoomToResult: true,\n useMapBounds: 12,\n searchBounds: null\n },\n\n initialize: function (control, options) {\n L.Util.setOptions(this, options);\n this._control = control;\n\n if (!options || !options.providers || !options.providers.length) {\n throw new Error('You must specify at least one provider');\n }\n\n this._providers = options.providers;\n },\n\n _geocode: function (text, key, provider) {\n var activeRequests = 0;\n var allResults = [];\n var bounds;\n\n var callback = L.Util.bind(function (error, results) {\n activeRequests--;\n if (error) {\n return;\n }\n\n if (results) {\n allResults = allResults.concat(results);\n }\n\n if (activeRequests <= 0) {\n bounds = this._boundsFromResults(allResults);\n\n this.fire('results', {\n results: allResults,\n bounds: bounds,\n latlng: (bounds) ? bounds.getCenter() : undefined,\n text: text\n }, true);\n\n if (this.options.zoomToResult && bounds) {\n this._control._map.fitBounds(bounds);\n }\n\n this.fire('load');\n }\n }, this);\n\n if (key) {\n activeRequests++;\n provider.results(text, key, this._searchBounds(), callback);\n } else {\n for (var i = 0; i < this._providers.length; i++) {\n activeRequests++;\n this._providers[i].results(text, key, this._searchBounds(), callback);\n }\n }\n },\n\n _suggest: function (text) {\n var activeRequests = this._providers.length;\n\n var createCallback = L.Util.bind(function (text, provider) {\n return L.Util.bind(function (error, suggestions) {\n if (error) { return; }\n\n var i;\n\n activeRequests = activeRequests - 1;\n\n if (text.length < 2) {\n this._suggestions.innerHTML = '';\n this._suggestions.style.display = 'none';\n return;\n }\n\n if (suggestions.length) {\n for (i = 0; i < suggestions.length; i++) {\n suggestions[i].provider = provider;\n }\n } else {\n // we still need to update the UI\n this._control._renderSuggestions(suggestions);\n }\n\n if (provider._lastRender !== text && provider.nodes) {\n for (i = 0; i < provider.nodes.length; i++) {\n if (provider.nodes[i].parentElement) {\n this._control._suggestions.removeChild(provider.nodes[i]);\n }\n }\n\n provider.nodes = [];\n }\n\n if (suggestions.length && this._control._input.value === text) {\n this._control.clearSuggestions(provider.nodes);\n\n provider._lastRender = text;\n provider.nodes = this._control._renderSuggestions(suggestions);\n this._control._nodes = [];\n }\n }, this);\n }, this);\n\n this._pendingSuggestions = [];\n\n for (var i = 0; i < this._providers.length; i++) {\n var provider = this._providers[i];\n var request = provider.suggestions(text, this._searchBounds(), createCallback(text, provider));\n this._pendingSuggestions.push(request);\n }\n },\n\n _searchBounds: function () {\n if (this.options.searchBounds !== null) {\n return this.options.searchBounds;\n }\n\n if (this.options.useMapBounds === false) {\n return null;\n }\n\n if (this.options.useMapBounds === true) {\n return this._control._map.getBounds();\n }\n\n if (this.options.useMapBounds <= this._control._map.getZoom()) {\n return this._control._map.getBounds();\n }\n\n return null;\n },\n\n _boundsFromResults: function (results) {\n if (!results.length) {\n return;\n }\n\n var nullIsland = L.latLngBounds([0, 0], [0, 0]);\n var resultBounds = [];\n var resultLatlngs = [];\n\n // collect the bounds and center of each result\n for (var i = results.length - 1; i >= 0; i--) {\n var result = results[i];\n\n resultLatlngs.push(result.latlng);\n\n // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present\n if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {\n resultBounds.push(result.bounds);\n }\n }\n\n // form a bounds object containing all center points\n var bounds = L.latLngBounds(resultLatlngs);\n\n // and extend it to contain all bounds objects\n for (var j = 0; j < resultBounds.length; j++) {\n bounds.extend(resultBounds[j]);\n }\n\n return bounds;\n },\n\n _getAttribution: function () {\n var attribs = [];\n var providers = this._providers;\n\n for (var i = 0; i < providers.length; i++) {\n if (providers[i].options.attribution) {\n attribs.push(providers[i].options.attribution);\n }\n }\n\n return attribs.join(', ');\n }\n\n});\n\nexport function geosearchCore (control, options) {\n return new GeosearchCore(control, options);\n}\n\nexport default geosearchCore;\n","import { GeocodeService } from '../Services/Geocode';\n\nexport var ArcgisOnlineProvider = GeocodeService.extend({\n options: {\n label: 'Places and Addresses',\n maxResults: 5\n },\n\n suggestions: function (text, bounds, callback) {\n var request = this.suggest().text(text);\n\n if (bounds) {\n request.within(bounds);\n }\n\n if (this.options.countries) {\n request.countries(this.options.countries);\n }\n\n if (this.options.categories) {\n request.category(this.options.categories);\n }\n\n // 15 is the maximum number of suggestions that can be returned\n request.maxSuggestions(this.options.maxResults);\n\n return request.run(function (error, results, response) {\n var suggestions = [];\n if (!error) {\n while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {\n var suggestion = response.suggestions.shift();\n if (!suggestion.isCollection) {\n suggestions.push({\n text: suggestion.text,\n magicKey: suggestion.magicKey\n });\n }\n }\n }\n callback(error, suggestions);\n }, this);\n },\n\n results: function (text, key, bounds, callback) {\n var request = this.geocode().text(text);\n\n if (key) {\n request.key(key);\n }\n // in the future Address/StreetName geocoding requests that include a magicKey will only return one match\n request.maxLocations(this.options.maxResults);\n\n if (bounds) {\n request.within(bounds);\n }\n\n if (this.options.forStorage) {\n request.forStorage(true);\n }\n\n return request.run(function (error, response) {\n callback(error, response.results);\n }, this);\n }\n});\n\nexport function arcgisOnlineProvider (options) {\n return new ArcgisOnlineProvider(options);\n}\n\nexport default arcgisOnlineProvider;\n","import L from 'leaflet';\nimport { geosearchCore } from '../Classes/GeosearchCore';\nimport { arcgisOnlineProvider } from '../Providers/ArcgisOnlineGeocoder';\nimport { Util } from 'esri-leaflet';\n\nexport var Geosearch = L.Control.extend({\n includes: L.Mixin.Events,\n\n options: {\n position: 'topleft',\n collapseAfterResult: true,\n expanded: false,\n allowMultipleResults: true,\n placeholder: 'Search for places or addresses',\n title: 'Location Search'\n },\n\n initialize: function (options) {\n L.Util.setOptions(this, options);\n\n if (!options || !options.providers || !options.providers.length) {\n options = {};\n options.providers = [ arcgisOnlineProvider() ];\n }\n\n // instantiate the underlying class and pass along options\n this._geosearchCore = geosearchCore(this, options);\n this._geosearchCore._providers = options.providers;\n\n // bubble each providers events to the control\n this._geosearchCore.addEventParent(this);\n for (var i = 0; i < this._geosearchCore._providers.length; i++) {\n this._geosearchCore._providers[i].addEventParent(this);\n }\n\n this._geosearchCore._pendingSuggestions = [];\n\n L.Control.prototype.initialize.call(options);\n },\n\n _renderSuggestions: function (suggestions) {\n var currentGroup;\n this._suggestions.style.display = 'block';\n\n // set the maxHeight of the suggestions box to\n // map height\n // - suggestions offset (distance from top of suggestions to top of control)\n // - control offset (distance from top of control to top of map)\n // - 10 (extra padding)\n this._suggestions.style.maxHeight = (this._map.getSize().y - this._suggestions.offsetTop - this._wrapper.offsetTop - 10) + 'px';\n\n var nodes = [];\n var list;\n var header;\n\n for (var i = 0; i < suggestions.length; i++) {\n var suggestion = suggestions[i];\n if (!header && this._geosearchCore._providers.length > 1 && currentGroup !== suggestion.provider.options.label) {\n header = L.DomUtil.create('span', 'geocoder-control-header', this._suggestions);\n header.textContent = suggestion.provider.options.label;\n header.innerText = suggestion.provider.options.label;\n currentGroup = suggestion.provider.options.label;\n nodes.push(header);\n }\n\n if (!list) {\n list = L.DomUtil.create('ul', 'geocoder-control-list', this._suggestions);\n }\n\n var suggestionItem = L.DomUtil.create('li', 'geocoder-control-suggestion', list);\n\n suggestionItem.innerHTML = suggestion.text;\n suggestionItem.provider = suggestion.provider;\n suggestionItem['data-magic-key'] = suggestion.magicKey;\n }\n\n L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n\n nodes.push(list);\n\n return nodes;\n },\n\n _boundsFromResults: function (results) {\n if (!results.length) {\n return;\n }\n\n var nullIsland = L.latLngBounds([0, 0], [0, 0]);\n var resultBounds = [];\n var resultLatlngs = [];\n\n // collect the bounds and center of each result\n for (var i = results.length - 1; i >= 0; i--) {\n var result = results[i];\n\n resultLatlngs.push(result.latlng);\n\n // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present\n if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {\n resultBounds.push(result.bounds);\n }\n }\n\n // form a bounds object containing all center points\n var bounds = L.latLngBounds(resultLatlngs);\n\n // and extend it to contain all bounds objects\n for (var j = 0; j < resultBounds.length; j++) {\n bounds.extend(resultBounds[j]);\n }\n\n return bounds;\n },\n\n clear: function () {\n this._suggestions.innerHTML = '';\n this._suggestions.style.display = 'none';\n this._input.value = '';\n\n if (this.options.collapseAfterResult) {\n this._input.placeholder = '';\n L.DomUtil.removeClass(this._wrapper, 'geocoder-control-expanded');\n }\n\n if (!this._map.scrollWheelZoom.enabled() && this._map.options.scrollWheelZoom) {\n this._map.scrollWheelZoom.enable();\n }\n },\n\n clearSuggestions: function () {\n if (this._nodes) {\n for (var k = 0; k < this._nodes.length; k++) {\n if (this._nodes[k].parentElement) {\n this._suggestions.removeChild(this._nodes[k]);\n }\n }\n }\n },\n\n _setupClick: function () {\n L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n this._input.focus();\n },\n\n disable: function () {\n this._input.disabled = true;\n L.DomUtil.addClass(this._input, 'geocoder-control-input-disabled');\n L.DomEvent.removeListener(this._wrapper, 'click', this._setupClick, this);\n },\n\n enable: function () {\n this._input.disabled = false;\n L.DomUtil.removeClass(this._input, 'geocoder-control-input-disabled');\n L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);\n },\n\n getAttribution: function () {\n var attribs = [];\n\n for (var i = 0; i < this._providers.length; i++) {\n if (this._providers[i].options.attribution) {\n attribs.push(this._providers[i].options.attribution);\n }\n }\n\n return attribs.join(', ');\n },\n\n onAdd: function (map) {\n // include 'Powered by Esri' in map attribution\n Util.setEsriAttribution(map);\n\n this._map = map;\n this._wrapper = L.DomUtil.create('div', 'geocoder-control');\n this._input = L.DomUtil.create('input', 'geocoder-control-input leaflet-bar', this._wrapper);\n this._input.title = this.options.title;\n\n if (this.options.expanded) {\n L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n this._input.placeholder = this.options.placeholder;\n }\n\n this._suggestions = L.DomUtil.create('div', 'geocoder-control-suggestions leaflet-bar', this._wrapper);\n\n var credits = this._geosearchCore._getAttribution();\n map.attributionControl.addAttribution(credits);\n\n L.DomEvent.addListener(this._input, 'focus', function (e) {\n this._input.placeholder = this.options.placeholder;\n L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n }, this);\n\n L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);\n\n L.DomEvent.addListener(this._suggestions, 'mousedown', function (e) {\n var suggestionItem = e.target || e.srcElement;\n this._geosearchCore._geocode(suggestionItem.innerHTML, suggestionItem['data-magic-key'], suggestionItem.provider);\n this.clear();\n }, this);\n\n L.DomEvent.addListener(this._input, 'blur', function (e) {\n this.clear();\n }, this);\n\n L.DomEvent.addListener(this._input, 'keydown', function (e) {\n L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');\n\n var list = this._suggestions.querySelectorAll('.' + 'geocoder-control-suggestion');\n var selected = this._suggestions.querySelectorAll('.' + 'geocoder-control-selected')[0];\n var selectedPosition;\n\n for (var i = 0; i < list.length; i++) {\n if (list[i] === selected) {\n selectedPosition = i;\n break;\n }\n }\n\n switch (e.keyCode) {\n case 13:\n if (selected) {\n this._geosearchCore._geocode(selected.innerHTML, selected['data-magic-key'], selected.provider);\n this.clear();\n } else if (this.options.allowMultipleResults) {\n this._geosearchCore._geocode(this._input.value, undefined);\n this.clear();\n } else {\n L.DomUtil.addClass(list[0], 'geocoder-control-selected');\n }\n L.DomEvent.preventDefault(e);\n break;\n case 38:\n if (selected) {\n L.DomUtil.removeClass(selected, 'geocoder-control-selected');\n }\n\n var previousItem = list[selectedPosition - 1];\n\n if (selected && previousItem) {\n L.DomUtil.addClass(previousItem, 'geocoder-control-selected');\n } else {\n L.DomUtil.addClass(list[list.length - 1], 'geocoder-control-selected');\n }\n L.DomEvent.preventDefault(e);\n break;\n case 40:\n if (selected) {\n L.DomUtil.removeClass(selected, 'geocoder-control-selected');\n }\n\n var nextItem = list[selectedPosition + 1];\n\n if (selected && nextItem) {\n L.DomUtil.addClass(nextItem, 'geocoder-control-selected');\n } else {\n L.DomUtil.addClass(list[0], 'geocoder-control-selected');\n }\n L.DomEvent.preventDefault(e);\n break;\n default:\n // when the input changes we should cancel all pending suggestion requests if possible to avoid result collisions\n for (var x = 0; x < this._geosearchCore._pendingSuggestions.length; x++) {\n var request = this._geosearchCore._pendingSuggestions[x];\n if (request && request.abort && !request.id) {\n request.abort();\n }\n }\n break;\n }\n }, this);\n\n L.DomEvent.addListener(this._input, 'keyup', L.Util.throttle(function (e) {\n var key = e.which || e.keyCode;\n var text = (e.target || e.srcElement).value;\n\n // require at least 2 characters for suggestions\n if (text.length < 2) {\n this._suggestions.innerHTML = '';\n this._suggestions.style.display = 'none';\n L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n return;\n }\n\n // if this is the escape key it will clear the input so clear suggestions\n if (key === 27) {\n this._suggestions.innerHTML = '';\n this._suggestions.style.display = 'none';\n return;\n }\n\n // if this is NOT the up/down arrows or enter make a suggestion\n if (key !== 13 && key !== 38 && key !== 40) {\n if (this._input.value !== this._lastValue) {\n this._lastValue = this._input.value;\n L.DomUtil.addClass(this._input, 'geocoder-control-loading');\n this._geosearchCore._suggest(text);\n }\n }\n }, 50, this), this);\n\n L.DomEvent.disableClickPropagation(this._wrapper);\n\n // when mouse moves over suggestions disable scroll wheel zoom if its enabled\n L.DomEvent.addListener(this._suggestions, 'mouseover', function (e) {\n if (map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {\n map.scrollWheelZoom.disable();\n }\n });\n\n // when mouse moves leaves suggestions enable scroll wheel zoom if its disabled\n L.DomEvent.addListener(this._suggestions, 'mouseout', function (e) {\n if (!map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {\n map.scrollWheelZoom.enable();\n }\n });\n\n this._geosearchCore.on('load', function (e) {\n L.DomUtil.removeClass(this._input, 'geocoder-control-loading');\n this.clear();\n this._input.blur();\n }, this);\n\n return this._wrapper;\n }\n});\n\nexport function geosearch (options) {\n return new Geosearch(options);\n}\n\nexport default geosearch;\n","import L from 'leaflet';\nimport { FeatureLayerService } from 'esri-leaflet';\n\nexport var FeatureLayerProvider = FeatureLayerService.extend({\n options: {\n label: 'Feature Layer',\n maxResults: 5,\n bufferRadius: 1000,\n formatSuggestion: function (feature) {\n return feature.properties[this.options.searchFields[0]];\n }\n },\n\n initialize: function (options) {\n FeatureLayerService.prototype.initialize.call(this, options);\n if (typeof this.options.searchFields === 'string') {\n this.options.searchFields = [this.options.searchFields];\n }\n this._suggestionsQuery = this.query();\n this._resultsQuery = this.query();\n },\n\n suggestions: function (text, bounds, callback) {\n var query = this._suggestionsQuery.where(this._buildQuery(text))\n .returnGeometry(false);\n\n if (bounds) {\n query.intersects(bounds);\n }\n\n if (this.options.idField) {\n query.fields([this.options.idField].concat(this.options.searchFields));\n }\n\n var request = query.run(function (error, results, raw) {\n if (error) {\n callback(error, []);\n } else {\n this.options.idField = raw.objectIdFieldName;\n var suggestions = [];\n for (var i = results.features.length - 1; i >= 0; i--) {\n var feature = results.features[i];\n suggestions.push({\n text: this.options.formatSuggestion.call(this, feature),\n magicKey: feature.id\n });\n }\n callback(error, suggestions.slice(0, this.options.maxResults));\n }\n }, this);\n\n return request;\n },\n\n results: function (text, key, bounds, callback) {\n var query = this._resultsQuery;\n\n if (key) {\n query.featureIds([key]);\n } else {\n query.where(this._buildQuery(text));\n }\n\n if (bounds) {\n query.within(bounds);\n }\n\n return query.run(L.Util.bind(function (error, features) {\n var results = [];\n for (var i = 0; i < features.features.length; i++) {\n var feature = features.features[i];\n if (feature) {\n var bounds = this._featureBounds(feature);\n\n var result = {\n latlng: bounds.getCenter(),\n bounds: bounds,\n text: this.options.formatSuggestion.call(this, feature),\n properties: feature.properties,\n geojson: feature\n };\n\n results.push(result);\n }\n }\n callback(error, results);\n }, this));\n },\n\n orderBy: function (fieldName, order) {\n this._suggestionsQuery.orderBy(fieldName, order);\n },\n\n _buildQuery: function (text) {\n var queryString = [];\n\n for (var i = this.options.searchFields.length - 1; i >= 0; i--) {\n var field = 'upper(\"' + this.options.searchFields[i] + '\")';\n\n queryString.push(field + \" LIKE upper('%\" + text + \"%')\");\n }\n\n if (this.options.where) {\n return this.options.where + ' AND (' + queryString.join(' OR ') + ')';\n } else {\n return queryString.join(' OR ');\n }\n },\n\n _featureBounds: function (feature) {\n var geojson = L.geoJson(feature);\n if (feature.geometry.type === 'Point') {\n var center = geojson.getBounds().getCenter();\n var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);\n var latRadius = (this.options.bufferRadius / 40075017) * 360;\n return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);\n } else {\n return geojson.getBounds();\n }\n }\n});\n\nexport function featureLayerProvider (options) {\n return new FeatureLayerProvider(options);\n}\n\nexport default featureLayerProvider;\n","import L from 'leaflet';\nimport { MapService } from 'esri-leaflet';\n\nexport var MapServiceProvider = MapService.extend({\n options: {\n layers: [0],\n label: 'Map Service',\n bufferRadius: 1000,\n maxResults: 5,\n formatSuggestion: function (feature) {\n return feature.properties[feature.displayFieldName] + ' ' + feature.layerName + '';\n }\n },\n\n initialize: function (options) {\n MapService.prototype.initialize.call(this, options);\n this._getIdFields();\n },\n\n suggestions: function (text, bounds, callback) {\n var request = this.find().text(text).fields(this.options.searchFields).returnGeometry(false).layers(this.options.layers);\n\n return request.run(function (error, results, raw) {\n var suggestions = [];\n if (!error) {\n var count = Math.min(this.options.maxResults, results.features.length);\n raw.results = raw.results.reverse();\n for (var i = 0; i < count; i++) {\n var feature = results.features[i];\n var result = raw.results[i];\n var layer = result.layerId;\n var idField = this._idFields[layer];\n feature.layerId = layer;\n feature.layerName = this._layerNames[layer];\n feature.displayFieldName = this._displayFields[layer];\n if (idField) {\n suggestions.push({\n text: this.options.formatSuggestion.call(this, feature),\n magicKey: result.attributes[idField] + ':' + layer\n });\n }\n }\n }\n callback(error, suggestions.reverse());\n }, this);\n },\n\n results: function (text, key, bounds, callback) {\n var results = [];\n var request;\n\n if (key) {\n var featureId = key.split(':')[0];\n var layer = key.split(':')[1];\n request = this.query().layer(layer).featureIds(featureId);\n } else {\n request = this.find().text(text).fields(this.options.searchFields).layers(this.options.layers);\n }\n\n return request.run(function (error, features, response) {\n if (!error) {\n if (response.results) {\n response.results = response.results.reverse();\n }\n for (var i = 0; i < features.features.length; i++) {\n var feature = features.features[i];\n layer = layer || response.results[i].layerId;\n\n if (feature && layer !== undefined) {\n var bounds = this._featureBounds(feature);\n feature.layerId = layer;\n feature.layerName = this._layerNames[layer];\n feature.displayFieldName = this._displayFields[layer];\n\n var result = {\n latlng: bounds.getCenter(),\n bounds: bounds,\n text: this.options.formatSuggestion.call(this, feature),\n properties: feature.properties,\n geojson: feature\n };\n\n results.push(result);\n }\n }\n }\n callback(error, results.reverse());\n }, this);\n },\n\n _featureBounds: function (feature) {\n var geojson = L.geoJson(feature);\n if (feature.geometry.type === 'Point') {\n var center = geojson.getBounds().getCenter();\n var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);\n var latRadius = (this.options.bufferRadius / 40075017) * 360;\n return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);\n } else {\n return geojson.getBounds();\n }\n },\n\n _layerMetadataCallback: function (layerid) {\n return L.Util.bind(function (error, metadata) {\n if (error) { return; }\n this._displayFields[layerid] = metadata.displayField;\n this._layerNames[layerid] = metadata.name;\n for (var i = 0; i < metadata.fields.length; i++) {\n var field = metadata.fields[i];\n if (field.type === 'esriFieldTypeOID') {\n this._idFields[layerid] = field.name;\n break;\n }\n }\n }, this);\n },\n\n _getIdFields: function () {\n this._idFields = {};\n this._displayFields = {};\n this._layerNames = {};\n for (var i = 0; i < this.options.layers.length; i++) {\n var layer = this.options.layers[i];\n this.get(layer, {}, this._layerMetadataCallback(layer));\n }\n }\n});\n\nexport function mapServiceProvider (options) {\n return new MapServiceProvider(options);\n}\n\nexport default mapServiceProvider;\n","import { GeocodeService } from '../Services/Geocode';\n\nexport var GeocodeServiceProvider = GeocodeService.extend({\n options: {\n label: 'Geocode Server',\n maxResults: 5\n },\n\n suggestions: function (text, bounds, callback) {\n if (this.options.supportsSuggest) {\n var request = this.suggest().text(text);\n if (bounds) {\n request.within(bounds);\n }\n\n return request.run(function (error, results, response) {\n var suggestions = [];\n if (!error) {\n while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {\n var suggestion = response.suggestions.shift();\n if (!suggestion.isCollection) {\n suggestions.push({\n text: suggestion.text,\n magicKey: suggestion.magicKey\n });\n }\n }\n }\n callback(error, suggestions);\n }, this);\n } else {\n callback(undefined, []);\n return false;\n }\n },\n\n results: function (text, key, bounds, callback) {\n var request = this.geocode().text(text);\n\n request.maxLocations(this.options.maxResults);\n\n if (bounds) {\n request.within(bounds);\n }\n\n return request.run(function (error, response) {\n callback(error, response.results);\n }, this);\n }\n});\n\nexport function geocodeServiceProvider (options) {\n return new GeocodeServiceProvider(options);\n}\n\nexport default geocodeServiceProvider;\n","export { version as VERSION } from '../package.json';\nexport var WorldGeocodingServiceUrl = 'https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/';\n\n// import tasks\nexport { Geocode, geocode } from './Tasks/Geocode';\nexport { ReverseGeocode, reverseGeocode } from './Tasks/ReverseGeocode';\nexport { Suggest, suggest } from './Tasks/Suggest';\n\n// import service\nexport { GeocodeService, geocodeService } from './Services/Geocode';\n\n// import control\nexport { Geosearch, geosearch } from './Controls/Geosearch';\n\n// import supporting class\nexport { GeosearchCore, geosearchCore } from './Classes/GeosearchCore';\n\n// import providers\nexport { ArcgisOnlineProvider, arcgisOnlineProvider } from './Providers/ArcgisOnlineGeocoder';\nexport { FeatureLayerProvider, featureLayerProvider } from './Providers/FeatureLayer';\nexport { MapServiceProvider, mapServiceProvider } from './Providers/MapService';\nexport { GeocodeServiceProvider, geocodeServiceProvider } from './Providers/GeocodeService';\n"],"names":["geocode","options","Geocode","reverseGeocode","ReverseGeocode","suggest","Suggest","geocodeService","GeocodeService","geosearchCore","control","GeosearchCore","arcgisOnlineProvider","ArcgisOnlineProvider","geosearch","Geosearch","featureLayerProvider","FeatureLayerProvider","mapServiceProvider","MapServiceProvider","geocodeServiceProvider","GeocodeServiceProvider","Task","extend","path","params","outSr","forStorage","outFields","maxLocations","setters","address","neighborhood","city","subregion","region","postal","country","text","category","token","key","fields","initialize","url","WorldGeocodingServiceUrl","prototype","call","this","within","bounds","L","latLngBounds","bbox","Util","boundsToExtent","nearby","latlng","radius","latLng","location","lng","lat","distance","Math","min","max","run","callback","context","customParam","searchExtent","request","error","response","processor","_processFindResponse","_processFindAddressCandidatesResponse","results","undefined","i","locations","length","extent","extentToBounds","push","name","score","feature","attributes","Score","geometry","y","x","properties","candidates","candidate","outSR","returnIntersection","language","intersection","result","countries","maxSuggestions","supportsSuggest","pad","center","getCenter","ne","getNorthWest","distanceTo","console","warn","Service","_confirmSuggestSupport","reverse","metadata","capabilities","indexOf","singleLineAddressField","Evented","zoomToResult","useMapBounds","searchBounds","setOptions","_control","providers","Error","_providers","_geocode","provider","activeRequests","allResults","bind","concat","_boundsFromResults","fire","_map","fitBounds","_searchBounds","_suggest","createCallback","suggestions","_suggestions","innerHTML","style","display","_renderSuggestions","_lastRender","nodes","parentElement","removeChild","_input","value","clearSuggestions","_nodes","_pendingSuggestions","getBounds","getZoom","nullIsland","resultBounds","resultLatlngs","isValid","equals","j","_getAttribution","attribs","attribution","join","label","maxResults","categories","suggestion","shift","isCollection","magicKey","Control","includes","Mixin","Events","position","collapseAfterResult","expanded","allowMultipleResults","placeholder","title","_geosearchCore","addEventParent","currentGroup","maxHeight","getSize","offsetTop","_wrapper","list","header","DomUtil","create","textContent","innerText","suggestionItem","removeClass","clear","scrollWheelZoom","enabled","enable","k","_setupClick","addClass","focus","disable","disabled","DomEvent","removeListener","addListener","getAttribution","onAdd","map","setEsriAttribution","credits","attributionControl","addAttribution","e","target","srcElement","selectedPosition","querySelectorAll","selected","keyCode","preventDefault","previousItem","nextItem","abort","id","throttle","which","_lastValue","disableClickPropagation","on","blur","FeatureLayerService","bufferRadius","formatSuggestion","searchFields","_suggestionsQuery","query","_resultsQuery","where","_buildQuery","returnGeometry","intersects","idField","raw","objectIdFieldName","features","slice","featureIds","_featureBounds","geojson","orderBy","fieldName","order","queryString","field","geoJson","type","lngRadius","cos","PI","latRadius","MapService","layers","displayFieldName","layerName","_getIdFields","find","count","layer","layerId","_idFields","_layerNames","_displayFields","featureId","split","_layerMetadataCallback","layerid","displayField","get"],"mappings":"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"} \ No newline at end of file diff --git a/dist/img/loading.gif b/dist/img/loading.gif new file mode 100755 index 0000000000000000000000000000000000000000..d123f8803336f9a9dd844217f503ce1a4c8bb6de GIT binary patch literal 1276 zcmZ?wbhEHblwy!#xN6Vv|NsBi*4D3IzuMZ`{{8z`RaKRrpMUo3+3xP{pFVwxiHRvF zDCq3${P5w!pFe-zzki>Ul;rE{yL9Q&wzjtA%a?!q_U-fM&(+n{U0q%O{{4%MjeYy} zZAnQp64gJbU&mKRhe%geuf`SS7O$2V`@JbwH*D=X{4g9oCbqMn|fMMXvS_V&Mj|Nj2{`}60|U0hsr zbaa0F`0?x4FQDTU|8x7fh6Fo12DlpO889<4Ffb_oWMSoEuxHQ#vVoqIVqjofabSLd zhmKVLi6uoRbFAk3HL=mfed`+{Dr3Gzr3wTtSGFn1-LqtO()R~#p!-N^o*0+*DRE|TAMOc`HhnvT?dAF6R+(a%e1~DEpgOl#T+7?0QgZQ>wbBmOa zi0zMj8u0Sf>o;%TIU*d-#=yqF%fJV8d^XVWD=zZ%>ojc$5U}!by3G6Ohhe?Sgv4*F zTi6ttSRP$yiaErd5`Od&+mgrcOJ#VYIb6K!_B_$AX%ur8E#edx;C0diI^W4smP^)N zLqn3CkzL7NM@p8{o}1gAiCs9?zMtVA#qF^mQiC)*D&8{rfKpGzthsI8S>v z3Fzzo3ujf%l#0x~|I~?t*J*0vBc_!}74(ASbqdjh}f{o2ydXi!5bSFEt4o%GpBrDmGqdB0%iMPMAr(mN*UrWEI z=ZEBfLbANC)vZ|gB&WW*9#~T3g zN!nU~-$@VXM?NVj7DZ;o6647#_N=V-{EFskPKHWO3!S^l1q8~G><1+?NHiw_y{s{j zr~iaQ!VL$$srKB5*^2*ZOp#AM_#(1ZjPKYdS*||8X2nOq_?gka^hR2^7JiOyl zq2r`1XjEm-1oWxBy1G3u)jJz@N!v3s+w;nqS~;uPIn8jgNR^TCL$Q_}Xe}t7vk%-q z|3pBler8Kyn#6=YQ1&Zn^-XU@h&$D|IcFpXO}shKN=aB$dj%1Y_DX}c|SGbnKq7cX&S Gum%9n!NQ>c literal 0 HcmV?d00001 diff --git a/dist/img/loading@2x.gif b/dist/img/loading@2x.gif new file mode 100755 index 0000000000000000000000000000000000000000..ceec3a11aad13fcb1da4d045e277b2f041b9a373 GIT binary patch literal 3973 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 literal 0 HcmV?d00001 diff --git a/dist/img/search-disabled.png b/dist/img/search-disabled.png new file mode 100644 index 0000000000000000000000000000000000000000..fefe60df9631b6e7a456d8671fde045119bd8045 GIT binary patch literal 206 zcmeAS@N?(olHy`uVBq!ia0vp^CLqkj3?z4meXamfoB=)|u4-y(|NsBry?b}_1>u!I zL8g)*zhDN2vdL#HfV?747sn8d^Jgy^axn*TxL$038sD{AlI_x&tbai|PuCfRy74aY zG+l4KV9|m&+o~CS6DQe4ZSdv`WcqZ?)53StrKv){+nqkun=Dt*p8Mu%IpeWwJ>9F` z8z|&u=5A7{?bJ&**Ijh7&4uscQ|IiED4P%QTKVt!uW`mMFpvV;&fw|l=d#Wzp$PzJ C=}W}` literal 0 HcmV?d00001 diff --git a/dist/img/search.png b/dist/img/search.png new file mode 100644 index 0000000000000000000000000000000000000000..0d01c4545e01d6d9773221a7209b6bc86b364cd4 GIT binary patch literal 425 zcmV;a0apHrP)~EiaUMAvsUQr<`5(fS6Ajfg^kM(H9D=zWr_l)bhzTZ_G;Kx*B4No}6 z1@1BUn-P^5`b%+uF6?0+QH*0to=@8d8j+AW%xdikoMIU}$e4mmf879HFrU@_j76EZ z?jR#F1vTOUA3l9Ia&52?bcYty`t-HS_0~pE3guWunbzKhIIeMKV=?SvLl#9R4pE0b z2_F7wKjpHIMlppijG-S#c*iz|Yz3*KV+qZuLIrwpg-RsRWFttgHyN3#3E4k2*vy*4 zKL_b`j!C)iz(T%)RIOu0?x)d{uOL-3IFVC5=j9!w)Tt4Zxq1xWuwjs~z6BTnz+hU1 TvwpQk00000NkvXXu0mjfh5NJY literal 0 HcmV?d00001 diff --git a/dist/img/search@2x-disabled.png b/dist/img/search@2x-disabled.png new file mode 100644 index 0000000000000000000000000000000000000000..fefe60df9631b6e7a456d8671fde045119bd8045 GIT binary patch literal 206 zcmeAS@N?(olHy`uVBq!ia0vp^CLqkj3?z4meXamfoB=)|u4-y(|NsBry?b}_1>u!I zL8g)*zhDN2vdL#HfV?747sn8d^Jgy^axn*TxL$038sD{AlI_x&tbai|PuCfRy74aY zG+l4KV9|m&+o~CS6DQe4ZSdv`WcqZ?)53StrKv){+nqkun=Dt*p8Mu%IpeWwJ>9F` z8z|&u=5A7{?bJ&**Ijh7&4uscQ|IiED4P%QTKVt!uW`mMFpvV;&fw|l=d#Wzp$PzJ C=}W}` literal 0 HcmV?d00001 diff --git a/dist/img/search@2x.png b/dist/img/search@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..5e96a8b967a018b379a0eb79a475865a92e59ceb GIT binary patch literal 772 zcmV+f1N;1mP)qCJ4=M_RNE5_*tw8#CkPrnwqMq_Wl)fks0<(;Q-l9YZ2@(_`da*V_p@>Mc zDAWY2?SJ4594<4uvo7u#xd(o5@0q!?{AcdH=bXFYSS%J=NR}2_U}gnbK~|6zWCdA4 zR!|acaiRkwk%-r&rC>kE1FOJSFbulEgx}wZMx*m1$i-HJdT@q?m^KCOg9h+L`;^-a z-hzuBV#w0LDew-IY8F%gxJ{xR;6R+?Xjj`M`Y*HydSzq**FeTBW0rv199W&{)}=)dMg2>n zza2cCVUas2&tBnc0plvl2ewX7299&Th`-t$@Ql|-7Ei~soGLl?8eC0wrVvi_C|J}( zD>$wc`g{bvgqL6}ne|XIvTZ8b4uTutkB@QJ`3oM^SPxP3zW{cCo8Xgi{Tt{2N5n?5 zk*nLgV3U?LWZED&&#dE&nilRj#zZ`+fGKbuSQw4ezhdjn3p_z!`aAPRCa zjTRUG6(fNSj3BaV(Bl$L+POpzoFLjH%3XqSW+HJ?%VGT}ZxU17f6sw-I@OuNTx