1 /* esri-leaflet-geocoder - v2.2.4 - Wed Mar 22 2017 15:48:59 GMT-0700 (PDT)

     2  * Copyright (c) 2017 Environmental Systems Research Institute, Inc.

     3  * Apache-2.0 */

     4 (function (global, factory) {

     5 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet'), require('esri-leaflet')) :

     6 	typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'esri-leaflet'], factory) :

     7 	(factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.Geocoding = global.L.esri.Geocoding || {}),global.L,global.L.esri));

     8 }(this, function (exports,L,esriLeaflet) { 'use strict';

     9 

    10 	L = 'default' in L ? L['default'] : L;

    11 

    12 	var version = "2.2.4";

    13 

    14 	var Geocode = esriLeaflet.Task.extend({

    15 	  path: 'findAddressCandidates',

    16 

    17 	  params: {

    18 	    outSr: 4326,

    19 	    forStorage: false,

    20 	    outFields: '*',

    21 	    maxLocations: 20

    22 	  },

    23 

    24 	  setters: {

    25 	    'address': 'address',

    26 	    'neighborhood': 'neighborhood',

    27 	    'city': 'city',

    28 	    'subregion': 'subregion',

    29 	    'region': 'region',

    30 	    'postal': 'postal',

    31 	    'country': 'country',

    32 	    'text': 'singleLine',

    33 	    'category': 'category',

    34 	    'token': 'token',

    35 	    'key': 'magicKey',

    36 	    'fields': 'outFields',

    37 	    'forStorage': 'forStorage',

    38 	    'maxLocations': 'maxLocations'

    39 	  },

    40 

    41 	  initialize: function (options) {

    42 	    options = options || {};

    43 	    options.url = options.url || WorldGeocodingServiceUrl;

    44 	    esriLeaflet.Task.prototype.initialize.call(this, options);

    45 	  },

    46 

    47 	  within: function (bounds) {

    48 	    bounds = L.latLngBounds(bounds);

    49 	    this.params.searchExtent = esriLeaflet.Util.boundsToExtent(bounds);

    50 	    return this;

    51 	  },

    52 

    53 	  nearby: function (latlng, radius) {

    54 	    latlng = L.latLng(latlng);

    55 	    this.params.location = latlng.lng + ',' + latlng.lat;

    56 	    this.params.distance = Math.min(Math.max(radius, 2000), 50000);

    57 	    return this;

    58 	  },

    59 

    60 	  run: function (callback, context) {

    61 	    if (this.options.customParam) {

    62 	      this.params[this.options.customParam] = this.params.singleLine;

    63 	      delete this.params.singleLine;

    64 	    }

    65 

    66 	    return this.request(function (error, response) {

    67 	      var processor = this._processGeocoderResponse;

    68 	      var results = (!error) ? processor(response) : undefined;

    69 	      callback.call(context, error, { results: results }, response);

    70 	    }, this);

    71 	  },

    72 

    73 	  _processGeocoderResponse: function (response) {

    74 	    var results = [];

    75 

    76 	    for (var i = 0; i < response.candidates.length; i++) {

    77 	      var candidate = response.candidates[i];

    78 	      if (candidate.extent) {

    79 	        var bounds = esriLeaflet.Util.extentToBounds(candidate.extent);

    80 	      }

    81 

    82 	      results.push({

    83 	        text: candidate.address,

    84 	        bounds: bounds,

    85 	        score: candidate.score,

    86 	        latlng: L.latLng(candidate.location.y, candidate.location.x),

    87 	        properties: candidate.attributes

    88 	      });

    89 	    }

    90 	    return results;

    91 	  }

    92 	});

    93 

    94 	function geocode (options) {

    95 	  return new Geocode(options);

    96 	}

    97 

    98 	var ReverseGeocode = esriLeaflet.Task.extend({

    99 	  path: 'reverseGeocode',

   100 

   101 	  params: {

   102 	    outSR: 4326,

   103 	    returnIntersection: false

   104 	  },

   105 

   106 	  setters: {

   107 	    'distance': 'distance',

   108 	    'language': 'langCode',

   109 	    'intersection': 'returnIntersection'

   110 	  },

   111 

   112 	  initialize: function (options) {

   113 	    options = options || {};

   114 	    options.url = options.url || WorldGeocodingServiceUrl;

   115 	    esriLeaflet.Task.prototype.initialize.call(this, options);

   116 	  },

   117 

   118 	  latlng: function (latlng) {

   119 	    latlng = L.latLng(latlng);

   120 	    this.params.location = latlng.lng + ',' + latlng.lat;

   121 	    return this;

   122 	  },

   123 

   124 	  run: function (callback, context) {

   125 	    return this.request(function (error, response) {

   126 	      var result;

   127 

   128 	      if (!error) {

   129 	        result = {

   130 	          latlng: L.latLng(response.location.y, response.location.x),

   131 	          address: response.address

   132 	        };

   133 	      } else {

   134 	        result = undefined;

   135 	      }

   136 

   137 	      callback.call(context, error, result, response);

   138 	    }, this);

   139 	  }

   140 	});

   141 

   142 	function reverseGeocode (options) {

   143 	  return new ReverseGeocode(options);

   144 	}

   145 

   146 	var Suggest = esriLeaflet.Task.extend({

   147 	  path: 'suggest',

   148 

   149 	  params: {},

   150 

   151 	  setters: {

   152 	    text: 'text',

   153 	    category: 'category',

   154 	    countries: 'countryCode',

   155 	    maxSuggestions: 'maxSuggestions'

   156 	  },

   157 

   158 	  initialize: function (options) {

   159 	    options = options || {};

   160 	    if (!options.url) {

   161 	      options.url = WorldGeocodingServiceUrl;

   162 	      options.supportsSuggest = true;

   163 	    }

   164 	    esriLeaflet.Task.prototype.initialize.call(this, options);

   165 	  },

   166 

   167 	  within: function (bounds) {

   168 	    bounds = L.latLngBounds(bounds);

   169 	    bounds = bounds.pad(0.5);

   170 	    var center = bounds.getCenter();

   171 	    var ne = bounds.getNorthWest();

   172 	    this.params.location = center.lng + ',' + center.lat;

   173 	    this.params.distance = Math.min(Math.max(center.distanceTo(ne), 2000), 50000);

   174 	    this.params.searchExtent = esriLeaflet.Util.boundsToExtent(bounds);

   175 	    return this;

   176 	  },

   177 

   178 	  nearby: function (latlng, radius) {

   179 	    latlng = L.latLng(latlng);

   180 	    this.params.location = latlng.lng + ',' + latlng.lat;

   181 	    this.params.distance = Math.min(Math.max(radius, 2000), 50000);

   182 	    return this;

   183 	  },

   184 

   185 	  run: function (callback, context) {

   186 	    if (this.options.supportsSuggest) {

   187 	      return this.request(function (error, response) {

   188 	        callback.call(context, error, response, response);

   189 	      }, this);

   190 	    } else {

   191 	      console.warn('this geocoding service does not support asking for suggestions');

   192 	    }

   193 	  }

   194 

   195 	});

   196 

   197 	function suggest (options) {

   198 	  return new Suggest(options);

   199 	}

   200 

   201 	var GeocodeService = esriLeaflet.Service.extend({

   202 	  initialize: function (options) {

   203 	    options = options || {};

   204 	    if (options.url) {

   205 	      esriLeaflet.Service.prototype.initialize.call(this, options);

   206 	      this._confirmSuggestSupport();

   207 	    } else {

   208 	      options.url = WorldGeocodingServiceUrl;

   209 	      options.supportsSuggest = true;

   210 	      esriLeaflet.Service.prototype.initialize.call(this, options);

   211 	    }

   212 	  },

   213 

   214 	  geocode: function () {

   215 	    return geocode(this);

   216 	  },

   217 

   218 	  reverse: function () {

   219 	    return reverseGeocode(this);

   220 	  },

   221 

   222 	  suggest: function () {

   223 	    // requires either the Esri World Geocoding Service or a <10.3 ArcGIS Server Geocoding Service that supports suggest.

   224 	    return suggest(this);

   225 	  },

   226 

   227 	  _confirmSuggestSupport: function () {

   228 	    this.metadata(function (error, response) {

   229 	      if (error) { return; }

   230 	      // pre 10.3 geocoding services dont list capabilities (and dont support maxLocations)

   231 	      // only SOME individual services have been configured to support asking for suggestions

   232 	      if (!response.capabilities) {

   233 	        this.options.supportsSuggest = false;

   234 	        this.options.customParam = response.singleLineAddressField.name;

   235 	      } else if (response.capabilities.indexOf('Suggest') > -1) {

   236 	        this.options.supportsSuggest = true;

   237 	      } else {

   238 	        this.options.supportsSuggest = false;

   239 	      }

   240 	    }, this);

   241 	  }

   242 	});

   243 

   244 	function geocodeService (options) {

   245 	  return new GeocodeService(options);

   246 	}

   247 

   248 	var GeosearchCore = L.Evented.extend({

   249 

   250 	  options: {

   251 	    zoomToResult: true,

   252 	    useMapBounds: 12,

   253 	    searchBounds: null

   254 	  },

   255 

   256 	  initialize: function (control, options) {

   257 	    L.Util.setOptions(this, options);

   258 	    this._control = control;

   259 

   260 	    if (!options || !options.providers || !options.providers.length) {

   261 	      throw new Error('You must specify at least one provider');

   262 	    }

   263 

   264 	    this._providers = options.providers;

   265 	  },

   266 

   267 	  _geocode: function (text, key, provider) {

   268 	    var activeRequests = 0;

   269 	    var allResults = [];

   270 	    var bounds;

   271 

   272 	    var callback = L.Util.bind(function (error, results) {

   273 	      activeRequests--;

   274 	      if (error) {

   275 	        return;

   276 	      }

   277 

   278 	      if (results) {

   279 	        allResults = allResults.concat(results);

   280 	      }

   281 

   282 	      if (activeRequests <= 0) {

   283 	        bounds = this._boundsFromResults(allResults);

   284 

   285 	        this.fire('results', {

   286 	          results: allResults,

   287 	          bounds: bounds,

   288 	          latlng: (bounds) ? bounds.getCenter() : undefined,

   289 	          text: text

   290 	        }, true);

   291 

   292 	        if (this.options.zoomToResult && bounds) {

   293 	          this._control._map.fitBounds(bounds);

   294 	        }

   295 

   296 	        this.fire('load');

   297 	      }

   298 	    }, this);

   299 

   300 	    if (key) {

   301 	      activeRequests++;

   302 	      provider.results(text, key, this._searchBounds(), callback);

   303 	    } else {

   304 	      for (var i = 0; i < this._providers.length; i++) {

   305 	        activeRequests++;

   306 	        this._providers[i].results(text, key, this._searchBounds(), callback);

   307 	      }

   308 	    }

   309 	  },

   310 

   311 	  _suggest: function (text) {

   312 	    var activeRequests = this._providers.length;

   313 

   314 	    var createCallback = L.Util.bind(function (text, provider) {

   315 	      return L.Util.bind(function (error, suggestions) {

   316 	        if (error) { return; }

   317 

   318 	        var i;

   319 

   320 	        activeRequests = activeRequests - 1;

   321 

   322 	        if (text.length < 2) {

   323 	          this._suggestions.innerHTML = '';

   324 	          this._suggestions.style.display = 'none';

   325 	          return;

   326 	        }

   327 

   328 	        if (suggestions.length) {

   329 	          for (i = 0; i < suggestions.length; i++) {

   330 	            suggestions[i].provider = provider;

   331 	          }

   332 	        } else {

   333 	          // we still need to update the UI

   334 	          this._control._renderSuggestions(suggestions);

   335 	        }

   336 

   337 	        if (provider._lastRender !== text && provider.nodes) {

   338 	          for (i = 0; i < provider.nodes.length; i++) {

   339 	            if (provider.nodes[i].parentElement) {

   340 	              this._control._suggestions.removeChild(provider.nodes[i]);

   341 	            }

   342 	          }

   343 

   344 	          provider.nodes = [];

   345 	        }

   346 

   347 	        if (suggestions.length && this._control._input.value === text) {

   348 	          this._control.clearSuggestions(provider.nodes);

   349 

   350 	          provider._lastRender = text;

   351 	          provider.nodes = this._control._renderSuggestions(suggestions);

   352 	          this._control._nodes = [];

   353 	        }

   354 	      }, this);

   355 	    }, this);

   356 

   357 	    this._pendingSuggestions = [];

   358 

   359 	    for (var i = 0; i < this._providers.length; i++) {

   360 	      var provider = this._providers[i];

   361 	      var request = provider.suggestions(text, this._searchBounds(), createCallback(text, provider));

   362 	      this._pendingSuggestions.push(request);

   363 	    }

   364 	  },

   365 

   366 	  _searchBounds: function () {

   367 	    if (this.options.searchBounds !== null) {

   368 	      return this.options.searchBounds;

   369 	    }

   370 

   371 	    if (this.options.useMapBounds === false) {

   372 	      return null;

   373 	    }

   374 

   375 	    if (this.options.useMapBounds === true) {

   376 	      return this._control._map.getBounds();

   377 	    }

   378 

   379 	    if (this.options.useMapBounds <= this._control._map.getZoom()) {

   380 	      return this._control._map.getBounds();

   381 	    }

   382 

   383 	    return null;

   384 	  },

   385 

   386 	  _boundsFromResults: function (results) {

   387 	    if (!results.length) {

   388 	      return;

   389 	    }

   390 

   391 	    var nullIsland = L.latLngBounds([0, 0], [0, 0]);

   392 	    var resultBounds = [];

   393 	    var resultLatlngs = [];

   394 

   395 	    // collect the bounds and center of each result

   396 	    for (var i = results.length - 1; i >= 0; i--) {

   397 	      var result = results[i];

   398 

   399 	      resultLatlngs.push(result.latlng);

   400 

   401 	      // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present

   402 	      if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {

   403 	        resultBounds.push(result.bounds);

   404 	      }

   405 	    }

   406 

   407 	    // form a bounds object containing all center points

   408 	    var bounds = L.latLngBounds(resultLatlngs);

   409 

   410 	    // and extend it to contain all bounds objects

   411 	    for (var j = 0; j < resultBounds.length; j++) {

   412 	      bounds.extend(resultBounds[j]);

   413 	    }

   414 

   415 	    return bounds;

   416 	  },

   417 

   418 	  _getAttribution: function () {

   419 	    var attribs = [];

   420 	    var providers = this._providers;

   421 

   422 	    for (var i = 0; i < providers.length; i++) {

   423 	      if (providers[i].options.attribution) {

   424 	        attribs.push(providers[i].options.attribution);

   425 	      }

   426 	    }

   427 

   428 	    return attribs.join(', ');

   429 	  }

   430 

   431 	});

   432 

   433 	function geosearchCore (control, options) {

   434 	  return new GeosearchCore(control, options);

   435 	}

   436 

   437 	var ArcgisOnlineProvider = GeocodeService.extend({

   438 	  options: {

   439 	    label: 'Places and Addresses',

   440 	    maxResults: 5

   441 	  },

   442 

   443 	  suggestions: function (text, bounds, callback) {

   444 	    var request = this.suggest().text(text);

   445 

   446 	    if (bounds) {

   447 	      request.within(bounds);

   448 	    }

   449 

   450 	    if (this.options.countries) {

   451 	      request.countries(this.options.countries);

   452 	    }

   453 

   454 	    if (this.options.categories) {

   455 	      request.category(this.options.categories);

   456 	    }

   457 

   458 	    // 15 is the maximum number of suggestions that can be returned

   459 	    request.maxSuggestions(this.options.maxResults);

   460 

   461 	    return request.run(function (error, results, response) {

   462 	      var suggestions = [];

   463 	      if (!error) {

   464 	        while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {

   465 	          var suggestion = response.suggestions.shift();

   466 	          if (!suggestion.isCollection) {

   467 	            suggestions.push({

   468 	              text: suggestion.text,

   469 	              magicKey: suggestion.magicKey

   470 	            });

   471 	          }

   472 	        }

   473 	      }

   474 	      callback(error, suggestions);

   475 	    }, this);

   476 	  },

   477 

   478 	  results: function (text, key, bounds, callback) {

   479 	    var request = this.geocode().text(text);

   480 

   481 	    if (key) {

   482 	      request.key(key);

   483 	    }

   484 	    // in the future Address/StreetName geocoding requests that include a magicKey will always only return one match

   485 	    request.maxLocations(this.options.maxResults);

   486 

   487 	    if (bounds) {

   488 	      request.within(bounds);

   489 	    }

   490 

   491 	    if (this.options.forStorage) {

   492 	      request.forStorage(true);

   493 	    }

   494 

   495 	    return request.run(function (error, response) {

   496 	      callback(error, response.results);

   497 	    }, this);

   498 	  }

   499 	});

   500 

   501 	function arcgisOnlineProvider (options) {

   502 	  return new ArcgisOnlineProvider(options);

   503 	}

   504 

   505 	var Geosearch = L.Control.extend({

   506 	  includes: L.Mixin.Events,

   507 

   508 	  options: {

   509 	    position: 'topleft',

   510 	    collapseAfterResult: true,

   511 	    expanded: false,

   512 	    allowMultipleResults: true,

   513 	    placeholder: 'Search for places or addresses',

   514 	    title: 'Location Search'

   515 	  },

   516 

   517 	  initialize: function (options) {

   518 	    L.Util.setOptions(this, options);

   519 

   520 	    if (!options || !options.providers || !options.providers.length) {

   521 	      if (!options) {

   522 	        options = {};

   523 	      }

   524 	      options.providers = [ arcgisOnlineProvider() ];

   525 	    }

   526 

   527 	    // instantiate the underlying class and pass along options

   528 	    this._geosearchCore = geosearchCore(this, options);

   529 	    this._geosearchCore._providers = options.providers;

   530 

   531 	    // bubble each providers events to the control

   532 	    this._geosearchCore.addEventParent(this);

   533 	    for (var i = 0; i < this._geosearchCore._providers.length; i++) {

   534 	      this._geosearchCore._providers[i].addEventParent(this);

   535 	    }

   536 

   537 	    this._geosearchCore._pendingSuggestions = [];

   538 

   539 	    L.Control.prototype.initialize.call(options);

   540 	  },

   541 

   542 	  _renderSuggestions: function (suggestions) {

   543 	    var currentGroup;

   544 

   545 	    if (suggestions.length > 0) {

   546 	      this._suggestions.style.display = 'block';

   547 	    }

   548 	    // set the maxHeight of the suggestions box to

   549 	    // map height

   550 	    // - suggestions offset (distance from top of suggestions to top of control)

   551 	    // - control offset (distance from top of control to top of map)

   552 	    // - 10 (extra padding)

   553 	    this._suggestions.style.maxHeight = (this._map.getSize().y - this._suggestions.offsetTop - this._wrapper.offsetTop - 10) + 'px';

   554 

   555 	    var nodes = [];

   556 	    var list;

   557 	    var header;

   558 	    var suggestionTextArray = [];

   559 

   560 	    for (var i = 0; i < suggestions.length; i++) {

   561 	      var suggestion = suggestions[i];

   562 	      if (!header && this._geosearchCore._providers.length > 1 && currentGroup !== suggestion.provider.options.label) {

   563 	        header = L.DomUtil.create('span', 'geocoder-control-header', this._suggestions);

   564 	        header.textContent = suggestion.provider.options.label;

   565 	        header.innerText = suggestion.provider.options.label;

   566 	        currentGroup = suggestion.provider.options.label;

   567 	        nodes.push(header);

   568 	      }

   569 

   570 	      if (!list) {

   571 	        list = L.DomUtil.create('ul', 'geocoder-control-list', this._suggestions);

   572 	      }

   573 

   574 	      if (suggestionTextArray.indexOf(suggestion.text) === -1) {

   575 	        var suggestionItem = L.DomUtil.create('li', 'geocoder-control-suggestion', list);

   576 

   577 	        suggestionItem.innerHTML = suggestion.text;

   578 	        suggestionItem.provider = suggestion.provider;

   579 	        suggestionItem['data-magic-key'] = suggestion.magicKey;

   580 	      } else {

   581 	        for (var j = 0; j < list.childNodes.length; j++) {

   582 	          // if the same text already appears in the list of suggestions, append an additional ObjectID to its magicKey instead

   583 	          if (list.childNodes[j].innerHTML === suggestion.text) {

   584 	            list.childNodes[j]['data-magic-key'] += ',' + suggestion.magicKey;

   585 	          }

   586 	        }

   587 	      }

   588 	      suggestionTextArray.push(suggestion.text);

   589 	    }

   590 

   591 	    L.DomUtil.removeClass(this._input, 'geocoder-control-loading');

   592 

   593 	    nodes.push(list);

   594 

   595 	    return nodes;

   596 	  },

   597 

   598 	  _boundsFromResults: function (results) {

   599 	    if (!results.length) {

   600 	      return;

   601 	    }

   602 

   603 	    var nullIsland = L.latLngBounds([0, 0], [0, 0]);

   604 	    var resultBounds = [];

   605 	    var resultLatlngs = [];

   606 

   607 	    // collect the bounds and center of each result

   608 	    for (var i = results.length - 1; i >= 0; i--) {

   609 	      var result = results[i];

   610 

   611 	      resultLatlngs.push(result.latlng);

   612 

   613 	      // make sure bounds are valid and not 0,0. sometimes bounds are incorrect or not present

   614 	      if (result.bounds && result.bounds.isValid() && !result.bounds.equals(nullIsland)) {

   615 	        resultBounds.push(result.bounds);

   616 	      }

   617 	    }

   618 

   619 	    // form a bounds object containing all center points

   620 	    var bounds = L.latLngBounds(resultLatlngs);

   621 

   622 	    // and extend it to contain all bounds objects

   623 	    for (var j = 0; j < resultBounds.length; j++) {

   624 	      bounds.extend(resultBounds[j]);

   625 	    }

   626 

   627 	    return bounds;

   628 	  },

   629 

   630 	  clear: function () {

   631 	    this._suggestions.innerHTML = '';

   632 	    this._suggestions.style.display = 'none';

   633 	    this._input.value = '';

   634 

   635 	    if (this.options.collapseAfterResult) {

   636 	      this._input.placeholder = '';

   637 	      L.DomUtil.removeClass(this._wrapper, 'geocoder-control-expanded');

   638 	    }

   639 

   640 	    if (!this._map.scrollWheelZoom.enabled() && this._map.options.scrollWheelZoom) {

   641 	      this._map.scrollWheelZoom.enable();

   642 	    }

   643 	  },

   644 

   645 	  clearSuggestions: function () {

   646 	    if (this._nodes) {

   647 	      for (var k = 0; k < this._nodes.length; k++) {

   648 	        if (this._nodes[k].parentElement) {

   649 	          this._suggestions.removeChild(this._nodes[k]);

   650 	        }

   651 	      }

   652 	    }

   653 	  },

   654 

   655 	  _setupClick: function () {

   656 	    L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');

   657 	    this._input.focus();

   658 	  },

   659 

   660 	  disable: function () {

   661 	    this._input.disabled = true;

   662 	    L.DomUtil.addClass(this._input, 'geocoder-control-input-disabled');

   663 	    L.DomEvent.removeListener(this._wrapper, 'click', this._setupClick, this);

   664 	  },

   665 

   666 	  enable: function () {

   667 	    this._input.disabled = false;

   668 	    L.DomUtil.removeClass(this._input, 'geocoder-control-input-disabled');

   669 	    L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);

   670 	  },

   671 

   672 	  getAttribution: function () {

   673 	    var attribs = [];

   674 

   675 	    for (var i = 0; i < this._providers.length; i++) {

   676 	      if (this._providers[i].options.attribution) {

   677 	        attribs.push(this._providers[i].options.attribution);

   678 	      }

   679 	    }

   680 

   681 	    return attribs.join(', ');

   682 	  },

   683 

   684 	  onAdd: function (map) {

   685 	    // include 'Powered by Esri' in map attribution

   686 	    esriLeaflet.Util.setEsriAttribution(map);

   687 

   688 	    this._map = map;

   689 	    this._wrapper = L.DomUtil.create('div', 'geocoder-control');

   690 	    this._input = L.DomUtil.create('input', 'geocoder-control-input leaflet-bar', this._wrapper);

   691 	    this._input.title = this.options.title;

   692 

   693 	    if (this.options.expanded) {

   694 	      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');

   695 	      this._input.placeholder = this.options.placeholder;

   696 	    }

   697 

   698 	    this._suggestions = L.DomUtil.create('div', 'geocoder-control-suggestions leaflet-bar', this._wrapper);

   699 

   700 	    var credits = this._geosearchCore._getAttribution();

   701 	    map.attributionControl.addAttribution(credits);

   702 

   703 	    L.DomEvent.addListener(this._input, 'focus', function (e) {

   704 	      this._input.placeholder = this.options.placeholder;

   705 	      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');

   706 	    }, this);

   707 

   708 	    L.DomEvent.addListener(this._wrapper, 'click', this._setupClick, this);

   709 

   710 	    L.DomEvent.addListener(this._suggestions, 'mousedown', function (e) {

   711 	      var suggestionItem = e.target || e.srcElement;

   712 	      this._geosearchCore._geocode(suggestionItem.innerHTML, suggestionItem['data-magic-key'], suggestionItem.provider);

   713 	      this.clear();

   714 	    }, this);

   715 

   716 	    L.DomEvent.addListener(this._input, 'blur', function (e) {

   717 	      this.clear();

   718 	    }, this);

   719 

   720 	    L.DomEvent.addListener(this._input, 'keydown', function (e) {

   721 	      var text = (e.target || e.srcElement).value;

   722 

   723 	      L.DomUtil.addClass(this._wrapper, 'geocoder-control-expanded');

   724 

   725 	      var list = this._suggestions.querySelectorAll('.' + 'geocoder-control-suggestion');

   726 	      var selected = this._suggestions.querySelectorAll('.' + 'geocoder-control-selected')[0];

   727 	      var selectedPosition;

   728 

   729 	      for (var i = 0; i < list.length; i++) {

   730 	        if (list[i] === selected) {

   731 	          selectedPosition = i;

   732 	          break;

   733 	        }

   734 	      }

   735 

   736 	      switch (e.keyCode) {

   737 	        case 13:

   738 	          /*

   739 	            if an item has been selected, geocode it

   740 	            if focus is on the input textbox, geocode only if multiple results are allowed and more than two characters are present, or if a single suggestion is displayed.

   741 	            if less than two characters have been typed, abort the geocode

   742 	          */

   743 	          if (selected) {

   744 	            this._geosearchCore._geocode(selected.innerHTML, selected['data-magic-key'], selected.provider);

   745 	            this.clear();

   746 	          } else if (this.options.allowMultipleResults && text.length >= 2) {

   747 	            this._geosearchCore._geocode(this._input.value, undefined);

   748 	            this.clear();

   749 	          } else {

   750 	            if (list.length === 1) {

   751 	              L.DomUtil.addClass(list[0], 'geocoder-control-selected');

   752 	              this._geosearchCore._geocode(list[0].innerHTML, list[0]['data-magic-key'], list[0].provider);

   753 	            } else {

   754 	              this.clear();

   755 	              this._input.blur();

   756 	            }

   757 	          }

   758 	          L.DomEvent.preventDefault(e);

   759 	          break;

   760 	        case 38:

   761 	          if (selected) {

   762 	            L.DomUtil.removeClass(selected, 'geocoder-control-selected');

   763 	          }

   764 

   765 	          var previousItem = list[selectedPosition - 1];

   766 

   767 	          if (selected && previousItem) {

   768 	            L.DomUtil.addClass(previousItem, 'geocoder-control-selected');

   769 	          } else {

   770 	            L.DomUtil.addClass(list[list.length - 1], 'geocoder-control-selected');

   771 	          }

   772 	          L.DomEvent.preventDefault(e);

   773 	          break;

   774 	        case 40:

   775 	          if (selected) {

   776 	            L.DomUtil.removeClass(selected, 'geocoder-control-selected');

   777 	          }

   778 

   779 	          var nextItem = list[selectedPosition + 1];

   780 

   781 	          if (selected && nextItem) {

   782 	            L.DomUtil.addClass(nextItem, 'geocoder-control-selected');

   783 	          } else {

   784 	            L.DomUtil.addClass(list[0], 'geocoder-control-selected');

   785 	          }

   786 	          L.DomEvent.preventDefault(e);

   787 	          break;

   788 	        default:

   789 	          // when the input changes we should cancel all pending suggestion requests if possible to avoid result collisions

   790 	          for (var x = 0; x < this._geosearchCore._pendingSuggestions.length; x++) {

   791 	            var request = this._geosearchCore._pendingSuggestions[x];

   792 	            if (request && request.abort && !request.id) {

   793 	              request.abort();

   794 	            }

   795 	          }

   796 	          break;

   797 	      }

   798 	    }, this);

   799 

   800 	    L.DomEvent.addListener(this._input, 'keyup', L.Util.throttle(function (e) {

   801 	      var key = e.which || e.keyCode;

   802 	      var text = (e.target || e.srcElement).value;

   803 

   804 	      // require at least 2 characters for suggestions

   805 	      if (text.length < 2) {

   806 	        this._suggestions.innerHTML = '';

   807 	        this._suggestions.style.display = 'none';

   808 	        L.DomUtil.removeClass(this._input, 'geocoder-control-loading');

   809 	        return;

   810 	      }

   811 

   812 	      // if this is the escape key it will clear the input so clear suggestions

   813 	      if (key === 27) {

   814 	        this._suggestions.innerHTML = '';

   815 	        this._suggestions.style.display = 'none';

   816 	        return;

   817 	      }

   818 

   819 	      // if this is NOT the up/down arrows or enter make a suggestion

   820 	      if (key !== 13 && key !== 38 && key !== 40) {

   821 	        if (this._input.value !== this._lastValue) {

   822 	          this._lastValue = this._input.value;

   823 	          L.DomUtil.addClass(this._input, 'geocoder-control-loading');

   824 	          this._geosearchCore._suggest(text);

   825 	        }

   826 	      }

   827 	    }, 50, this), this);

   828 

   829 	    L.DomEvent.disableClickPropagation(this._wrapper);

   830 

   831 	    // when mouse moves over suggestions disable scroll wheel zoom if its enabled

   832 	    L.DomEvent.addListener(this._suggestions, 'mouseover', function (e) {

   833 	      if (map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {

   834 	        map.scrollWheelZoom.disable();

   835 	      }

   836 	    });

   837 

   838 	    // when mouse moves leaves suggestions enable scroll wheel zoom if its disabled

   839 	    L.DomEvent.addListener(this._suggestions, 'mouseout', function (e) {

   840 	      if (!map.scrollWheelZoom.enabled() && map.options.scrollWheelZoom) {

   841 	        map.scrollWheelZoom.enable();

   842 	      }

   843 	    });

   844 

   845 	    this._geosearchCore.on('load', function (e) {

   846 	      L.DomUtil.removeClass(this._input, 'geocoder-control-loading');

   847 	      this.clear();

   848 	      this._input.blur();

   849 	    }, this);

   850 

   851 	    return this._wrapper;

   852 	  }

   853 	});

   854 

   855 	function geosearch (options) {

   856 	  return new Geosearch(options);

   857 	}

   858 

   859 	var FeatureLayerProvider = esriLeaflet.FeatureLayerService.extend({

   860 	  options: {

   861 	    label: 'Feature Layer',

   862 	    maxResults: 5,

   863 	    bufferRadius: 1000,

   864 	    formatSuggestion: function (feature) {

   865 	      return feature.properties[this.options.searchFields[0]];

   866 	    }

   867 	  },

   868 

   869 	  initialize: function (options) {

   870 	    esriLeaflet.FeatureLayerService.prototype.initialize.call(this, options);

   871 	    if (typeof this.options.searchFields === 'string') {

   872 	      this.options.searchFields = [this.options.searchFields];

   873 	    }

   874 	    this._suggestionsQuery = this.query();

   875 	    this._resultsQuery = this.query();

   876 	  },

   877 

   878 	  suggestions: function (text, bounds, callback) {

   879 	    var query = this._suggestionsQuery.where(this._buildQuery(text))

   880 	      .returnGeometry(false);

   881 

   882 	    if (bounds) {

   883 	      query.intersects(bounds);

   884 	    }

   885 

   886 	    if (this.options.idField) {

   887 	      query.fields([this.options.idField].concat(this.options.searchFields));

   888 	    }

   889 

   890 	    var request = query.run(function (error, results, raw) {

   891 	      if (error) {

   892 	        callback(error, []);

   893 	      } else {

   894 	        this.options.idField = raw.objectIdFieldName;

   895 	        var suggestions = [];

   896 	        for (var i = results.features.length - 1; i >= 0; i--) {

   897 	          var feature = results.features[i];

   898 	          suggestions.push({

   899 	            text: this.options.formatSuggestion.call(this, feature),

   900 	            magicKey: feature.id

   901 	          });

   902 	        }

   903 	        callback(error, suggestions.slice(0, this.options.maxResults));

   904 	      }

   905 	    }, this);

   906 

   907 	    return request;

   908 	  },

   909 

   910 	  results: function (text, key, bounds, callback) {

   911 	    var query = this._resultsQuery;

   912 

   913 	    if (key) {

   914 	      delete query.params.where;

   915 	      query.featureIds([key]);

   916 	    } else {

   917 	      query.where(this._buildQuery(text));

   918 	    }

   919 

   920 	    if (bounds) {

   921 	      query.within(bounds);

   922 	    }

   923 

   924 	    return query.run(L.Util.bind(function (error, features) {

   925 	      var results = [];

   926 	      for (var i = 0; i < features.features.length; i++) {

   927 	        var feature = features.features[i];

   928 	        if (feature) {

   929 	          var bounds = this._featureBounds(feature);

   930 

   931 	          var result = {

   932 	            latlng: bounds.getCenter(),

   933 	            bounds: bounds,

   934 	            text: this.options.formatSuggestion.call(this, feature),

   935 	            properties: feature.properties,

   936 	            geojson: feature

   937 	          };

   938 

   939 	          results.push(result);

   940 

   941 	          // clear query parameters for the next search

   942 	          delete this._resultsQuery.params['objectIds'];

   943 	        }

   944 	      }

   945 	      callback(error, results);

   946 	    }, this));

   947 	  },

   948 

   949 	  orderBy: function (fieldName, order) {

   950 	    this._suggestionsQuery.orderBy(fieldName, order);

   951 	  },

   952 

   953 	  _buildQuery: function (text) {

   954 	    var queryString = [];

   955 

   956 	    for (var i = this.options.searchFields.length - 1; i >= 0; i--) {

   957 	      var field = 'upper("' + this.options.searchFields[i] + '")';

   958 

   959 	      queryString.push(field + " LIKE upper('%" + text + "%')");

   960 	    }

   961 

   962 	    if (this.options.where) {

   963 	      return this.options.where + ' AND (' + queryString.join(' OR ') + ')';

   964 	    } else {

   965 	      return queryString.join(' OR ');

   966 	    }

   967 	  },

   968 

   969 	  _featureBounds: function (feature) {

   970 	    var geojson = L.geoJson(feature);

   971 	    if (feature.geometry.type === 'Point') {

   972 	      var center = geojson.getBounds().getCenter();

   973 	      var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);

   974 	      var latRadius = (this.options.bufferRadius / 40075017) * 360;

   975 	      return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);

   976 	    } else {

   977 	      return geojson.getBounds();

   978 	    }

   979 	  }

   980 	});

   981 

   982 	function featureLayerProvider (options) {

   983 	  return new FeatureLayerProvider(options);

   984 	}

   985 

   986 	var MapServiceProvider = esriLeaflet.MapService.extend({

   987 	  options: {

   988 	    layers: [0],

   989 	    label: 'Map Service',

   990 	    bufferRadius: 1000,

   991 	    maxResults: 5,

   992 	    formatSuggestion: function (feature) {

   993 	      return feature.properties[feature.displayFieldName] + ' <small>' + feature.layerName + '</small>';

   994 	    }

   995 	  },

   996 

   997 	  initialize: function (options) {

   998 	    esriLeaflet.MapService.prototype.initialize.call(this, options);

   999 	    this._getIdFields();

  1000 	  },

  1001 

  1002 	  suggestions: function (text, bounds, callback) {

  1003 	    var request = this.find().text(text).fields(this.options.searchFields).returnGeometry(false).layers(this.options.layers);

  1004 

  1005 	    return request.run(function (error, results, raw) {

  1006 	      var suggestions = [];

  1007 	      if (!error) {

  1008 	        var count = Math.min(this.options.maxResults, results.features.length);

  1009 	        raw.results = raw.results.reverse();

  1010 	        for (var i = 0; i < count; i++) {

  1011 	          var feature = results.features[i];

  1012 	          var result = raw.results[i];

  1013 	          var layer = result.layerId;

  1014 	          var idField = this._idFields[layer];

  1015 	          feature.layerId = layer;

  1016 	          feature.layerName = this._layerNames[layer];

  1017 	          feature.displayFieldName = this._displayFields[layer];

  1018 	          if (idField) {

  1019 	            suggestions.push({

  1020 	              text: this.options.formatSuggestion.call(this, feature),

  1021 	              magicKey: result.attributes[idField] + ':' + layer

  1022 	            });

  1023 	          }

  1024 	        }

  1025 	      }

  1026 	      callback(error, suggestions.reverse());

  1027 	    }, this);

  1028 	  },

  1029 

  1030 	  results: function (text, key, bounds, callback) {

  1031 	    var results = [];

  1032 	    var request;

  1033 

  1034 	    if (key) {

  1035 	      var featureId = key.split(':')[0];

  1036 	      var layer = key.split(':')[1];

  1037 	      request = this.query().layer(layer).featureIds(featureId);

  1038 	    } else {

  1039 	      request = this.find().text(text).fields(this.options.searchFields).layers(this.options.layers);

  1040 	    }

  1041 

  1042 	    return request.run(function (error, features, response) {

  1043 	      if (!error) {

  1044 	        if (response.results) {

  1045 	          response.results = response.results.reverse();

  1046 	        }

  1047 	        for (var i = 0; i < features.features.length; i++) {

  1048 	          var feature = features.features[i];

  1049 	          layer = layer || response.results[i].layerId;

  1050 

  1051 	          if (feature && layer !== undefined) {

  1052 	            var bounds = this._featureBounds(feature);

  1053 	            feature.layerId = layer;

  1054 	            feature.layerName = this._layerNames[layer];

  1055 	            feature.displayFieldName = this._displayFields[layer];

  1056 

  1057 	            var result = {

  1058 	              latlng: bounds.getCenter(),

  1059 	              bounds: bounds,

  1060 	              text: this.options.formatSuggestion.call(this, feature),

  1061 	              properties: feature.properties,

  1062 	              geojson: feature

  1063 	            };

  1064 

  1065 	            results.push(result);

  1066 	          }

  1067 	        }

  1068 	      }

  1069 	      callback(error, results.reverse());

  1070 	    }, this);

  1071 	  },

  1072 

  1073 	  _featureBounds: function (feature) {

  1074 	    var geojson = L.geoJson(feature);

  1075 	    if (feature.geometry.type === 'Point') {

  1076 	      var center = geojson.getBounds().getCenter();

  1077 	      var lngRadius = ((this.options.bufferRadius / 40075017) * 360) / Math.cos((180 / Math.PI) * center.lat);

  1078 	      var latRadius = (this.options.bufferRadius / 40075017) * 360;

  1079 	      return L.latLngBounds([center.lat - latRadius, center.lng - lngRadius], [center.lat + latRadius, center.lng + lngRadius]);

  1080 	    } else {

  1081 	      return geojson.getBounds();

  1082 	    }

  1083 	  },

  1084 

  1085 	  _layerMetadataCallback: function (layerid) {

  1086 	    return L.Util.bind(function (error, metadata) {

  1087 	      if (error) { return; }

  1088 	      this._displayFields[layerid] = metadata.displayField;

  1089 	      this._layerNames[layerid] = metadata.name;

  1090 	      for (var i = 0; i < metadata.fields.length; i++) {

  1091 	        var field = metadata.fields[i];

  1092 	        if (field.type === 'esriFieldTypeOID') {

  1093 	          this._idFields[layerid] = field.name;

  1094 	          break;

  1095 	        }

  1096 	      }

  1097 	    }, this);

  1098 	  },

  1099 

  1100 	  _getIdFields: function () {

  1101 	    this._idFields = {};

  1102 	    this._displayFields = {};

  1103 	    this._layerNames = {};

  1104 	    for (var i = 0; i < this.options.layers.length; i++) {

  1105 	      var layer = this.options.layers[i];

  1106 	      this.get(layer, {}, this._layerMetadataCallback(layer));

  1107 	    }

  1108 	  }

  1109 	});

  1110 

  1111 	function mapServiceProvider (options) {

  1112 	  return new MapServiceProvider(options);

  1113 	}

  1114 

  1115 	var GeocodeServiceProvider = GeocodeService.extend({

  1116 	  options: {

  1117 	    label: 'Geocode Server',

  1118 	    maxResults: 5

  1119 	  },

  1120 

  1121 	  suggestions: function (text, bounds, callback) {

  1122 	    if (this.options.supportsSuggest) {

  1123 	      var request = this.suggest().text(text);

  1124 	      if (bounds) {

  1125 	        request.within(bounds);

  1126 	      }

  1127 

  1128 	      return request.run(function (error, results, response) {

  1129 	        var suggestions = [];

  1130 	        if (!error) {

  1131 	          while (response.suggestions.length && suggestions.length <= (this.options.maxResults - 1)) {

  1132 	            var suggestion = response.suggestions.shift();

  1133 	            if (!suggestion.isCollection) {

  1134 	              suggestions.push({

  1135 	                text: suggestion.text,