first commit

public/js/ajaxcrud.js

@@ -0,0 +1,105 @@
+$(document).on('click', 'pagination a', function (event) {
+    event.preventDefault();
+    ajaxLoad($(this).attr('href'));
+});
+
+$(document).on('submit', 'form#frm', function (event) {
+    event.preventDefault();
+    var form = $(this);
+    var data = new FormData($(this)[0]);
+    var url = form.attr("action");
+    $.ajax({
+        type: form.attr('method'),
+        url: url,
+        data: data,
+        cache: false,
+        contentType: false,
+        processData: false,
+        success: function (data) {
+            $('.is-invalid').removeClass('is-invalid');
+            if (data.fail) {
+                for (control in data.errors) {
+                    $('#' + control).addClass('is-invalid');
+                    $('#error-' + control).html(data.errors[control]);
+                }
+            } else {
+                ajaxLoad(data.redirect_url);
+            }
+        },
+        error: function (xhr, textStatus, errorThrown) {
+            alert("Error: " + errorThrown);
+        }
+    });
+    return false;
+});
+
+function ajaxLoad(filename, content) {
+    content = typeof content !== 'undefined' ? content : 'content';
+    $('.loading').show();
+    $.ajax({
+        type: "GET",
+        url: filename,
+        contentType: false,
+        success: function (data) {
+            $("#" + content).html(data);
+            $('.loading').hide();
+        },
+        error: function (xhr, status, error) {
+            alert(xhr.responseText);
+        }
+    });
+}
+
+function ajaxDelete(filename, token, content) {
+    content = typeof content !== 'undefined' ? content : 'content';
+    $('.loading').show();
+    $.ajax({
+        type: 'POST',
+        data: {_method: 'DELETE', _token: token},
+        url: filename,
+        success: function (data) {
+            window.location.href = filename.slice(0, -9);
+            $("#" + content).html(data);
+            $('.loading').hide();
+        },
+        error: function (xhr, status, error) {
+            alert(xhr.responseText);
+        }
+    });
+}
+
+function ajaxDeleteComments(filename, token, content) {
+    content = typeof content !== 'undefined' ? content : 'content';
+    $('.loading').show();
+    $.ajax({
+        type: 'POST',
+        data: {_method: 'DELETE', _token: token},
+        url: filename,
+        success: function (data) {
+            window.location.href = filename.replace("delete/", "");
+            $("#" + content).html(data);
+            $('.loading').hide();
+        },
+        error: function (xhr, status, error) {
+            alert(xhr.responseText);
+        }
+    });
+}
+
+function ajaxRedirect(filename, token, content) {
+    content = typeof content !== 'undefined' ? content : 'content';
+    $('.loading').show();
+    $.ajax({
+        type: 'POST',
+        data: {_method: 'PUT', _token: token},
+        url: filename,
+        success: function (data) {
+            window.location.href = filename.slice(0, -14);
+            $("#" + content).html(data);
+            $('.loading').hide();
+        },
+        error: function (xhr, status, error) {
+            alert(xhr.responseText);
+        }
+    });
+}

public/js/autofill.js

@@ -0,0 +1,89 @@
+/*
+	Copywrite Square Bracket LLC - Sean Clark 2012-3012
+	http://square-bracket.com
+	http://connect.ai
+	http://youtube.com/optikalefxx
+*/
+(function($) {
+	$.fn.autofill = function(opts) {
+		return this.each(function() {
+			var self = this,
+				usingTags = $(this).parent().hasClass("tags-wrapper");
+
+			if(!opts) opts = {};
+			// if were combined with tagging
+			if(usingTags) {
+				self = $(this).parent().find("li input");
+			}
+
+			// make this guy see through
+			$(self).css({
+				"background":"transparent",
+				"position":"absolute",
+				"z-index":2,
+				"outline":"none"
+			});
+
+			// create the div wrapper
+			var $wrapper = $("<div class='autofill-wrapper'></div>").css("position","relative");
+			// wrap
+			$(self).wrap($wrapper);
+			// reset wrapper cuz now its doc fragment?
+			$wrapper = $(self).parent();
+			// make the bg input
+			var color = opts.color || "rgba(214,215,220,1)";
+			var top = opts.top || -4;
+			var $bg = $("<input type='text' class='autofill-bg' disabled/>").css({
+				"color":color,
+				"top": top,
+				"outline":"none"
+			});
+
+
+
+			// set data
+			$bg.data("data",opts.data);
+
+			var bg = $bg[0];
+			// add classes
+			if(opts.classList) $bg.addClass(opts.classList);
+			// add the bg input (this not being absolute keeps the spacing)
+			$wrapper.append($bg);
+
+			// add listeners for data
+			if(opts.data) {
+
+				// we have to do this here because of tab
+				$(self).on("keydown",function(e) {
+					if(!!~[39,13,9].indexOf(e.keyCode)) {
+						e.preventDefault();
+						this.value = bg.value;
+						bg.value = "";
+					}
+				});
+
+				// keyup for letters
+				$(self).on("keyup",function(e) {
+					var found = 0,rx,val = this.value;
+					if(val) {
+						opts.data.forEach(function(term) {
+							rx = new RegExp("^"+val);
+							if(rx.test(term)) {
+								bg.value = term;
+								found++;
+							}
+						});
+
+						// if no matches
+						if(!found) bg.value = "";
+
+					// blank
+					} else {
+						bg.value = "";
+					}
+				});
+			}
+
+		});
+	}
+})(jQuery);

public/js/jquery.geocomplete.js

@@ -0,0 +1,722 @@
+/** 
+ * jquery.geocomplete v2.0.0 (https://github.com/tmentink/jquery.geocomplete)
+ * Copyright 2017-2019 Trent Mentink
+ * Licensed under MIT
+ */
+(function () {
+  'use strict';
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
+  var logError = function logError(msg) {
+    console.error(msg);
+  };
+
+  var SPACES = /\s+/g;
+  var SPACES_AND_UNDERSCORES = /\s+|_+/g;
+
+  var $ = window.jquery || window.$;
+
+  var NAME = 'geocomplete';
+  var DATA_KEY = "gmap.".concat(NAME);
+  var EVENT_KEY = ".".concat(DATA_KEY);
+  var Events = {
+    FOCUS: "focus".concat(EVENT_KEY),
+    PLACE_CHANGED: 'place_changed'
+  };
+
+  var _Defaults;
+  var Settings = {
+    APPEND_TO_PARENT: 'appendToParent',
+    FORMATS: 'formats',
+    FORM_ID: 'formId',
+    GEOLOCATE: 'geolocate',
+    INPUT_DATA_KEY: 'inputDataKey',
+    MAP: 'map',
+    ON_CHANGE: 'onChange',
+    ON_NO_RESULT: 'onNoResult'
+  };
+  var Formats = {
+    STREET_ADDRESS: function STREET_ADDRESS(placeResult) {
+      var streetNumber = placeResult.getComponentValue('street number');
+      var street = placeResult.getComponentValue('street');
+      return "".concat(streetNumber, " ").concat(street);
+    }
+  };
+  var Defaults = (_Defaults = {}, _defineProperty(_Defaults, Settings.APPEND_TO_PARENT, true), _defineProperty(_Defaults, Settings.FORMATS, Formats), _defineProperty(_Defaults, Settings.FORM_ID, null), _defineProperty(_Defaults, Settings.GEOLOCATE, false), _defineProperty(_Defaults, Settings.INPUT_DATA_KEY, 'geocomplete'), _defineProperty(_Defaults, Settings.MAP, null), _defineProperty(_Defaults, Settings.ON_CHANGE, function () {}), _defineProperty(_Defaults, Settings.ON_NO_RESULT, function () {}), _Defaults);
+  var getExtendedSettings = function getExtendedSettings(userSettings) {
+    var localSettings = $.fn[NAME].settings;
+    if (typeof userSettings === 'string') userSettings = {};
+    return $.extend(true, {}, Defaults, localSettings, userSettings);
+  };
+  var getFormats = function getFormats() {
+    return $.fn[NAME].settings[Settings.FORMATS];
+  };
+
+  var lookup = function lookup(_ref) {
+    var obj = _ref.obj,
+        query = _ref.query;
+    query = query.toLowerCase().replace(SPACES_AND_UNDERSCORES, '');
+    var key = Object.keys(obj).find(function (k) {
+      k = k.toLowerCase().replace(SPACES_AND_UNDERSCORES, '');
+      return k === query;
+    });
+    return obj[key];
+  };
+
+  var Properties = {
+    LONG_NAME: 'long_name',
+    SHORT_NAME: 'short_name',
+    TYPES: 'types'
+  };
+  var Types = {
+    ADMINISTRATIVE_AREA_LEVEL_1: 'administrative_area_level_1',
+    ADMINISTRATIVE_AREA_LEVEL_2: 'administrative_area_level_2',
+    ADMINISTRATIVE_AREA_LEVEL_3: 'administrative_area_level_3',
+    ADMINISTRATIVE_AREA_LEVEL_4: 'administrative_area_level_4',
+    ADMINISTRATIVE_AREA_LEVEL_5: 'administrative_area_level_5',
+    AIRPORT: 'airport',
+    COLLOQUIAL_AREA: 'colloquial_area',
+    COUNTRY: 'country',
+    INTERSECTION: 'intersection',
+    LOCALITY: 'locality',
+    NATURAL_FEATURE: 'natural_feature',
+    NEIGHBORHOOD: 'neighborhood',
+    PARK: 'park',
+    POINT_OF_INTEREST: 'point_of_interest',
+    POLITICAL: 'political',
+    POSTAL_CODE: 'postal_code',
+    POSTAL_CODE_SUFFIX: 'postal_code_suffix',
+    PREMISE: 'premise',
+    ROUTE: 'route',
+    STREET_NUMBER: 'street_number',
+    SUBLOCALITY: 'sublocality',
+    SUBPREMISE: 'subpremise'
+  };
+  var TypeAliases = {
+    CITY: Types.LOCALITY,
+    COUNTY: Types.ADMINISTRATIVE_AREA_LEVEL_2,
+    STATE: Types.ADMINISTRATIVE_AREA_LEVEL_1,
+    STREET: Types.ROUTE,
+    ZIP_CODE: Types.POSTAL_CODE,
+    ZIP_CODE_SUFFIX: Types.POSTAL_CODE_SUFFIX
+  };
+  var getName = function getName(addressType) {
+    var formatted = addressType.toLowerCase().replace(SPACES, '');
+    var isShort = formatted.indexOf('short') !== -1;
+    return isShort ? Properties.SHORT_NAME : Properties.LONG_NAME;
+  };
+  var getType = function getType(addressType) {
+    var formatted = addressType.toLowerCase().replace('short', '').replace(SPACES_AND_UNDERSCORES, '');
+    var value = lookupTypeAlias(formatted);
+    if (value == null) value = lookupType(formatted);
+    return value;
+  };
+  function lookupType(query) {
+    return lookup({
+      obj: Types,
+      query: query
+    });
+  }
+  function lookupTypeAlias(query) {
+    return lookup({
+      obj: TypeAliases,
+      query: query
+    });
+  }
+
+  var Properties$1 = {
+    ADDRESS_COMPONENTS: 'address_components',
+    ADR_ADDRESS: 'adr_address',
+    ASPECTS: 'aspects',
+    FORMATTED_ADDRESS: 'formatted_address',
+    FORMATTED_PHONE_NUMBER: 'formatted_phone_number',
+    GEOMETRY: 'geometry',
+    HTML_ATTRIBUTIONS: 'html_attributions',
+    ICON: 'icon',
+    INTERNATIONAL_PHONE_NUMBER: 'international_phone_number',
+    NAME: 'name',
+    OPENING_HOURS: 'opening_hours',
+    PERMANENTLY_CLOSED: 'permanently_closed',
+    PHOTOS: 'photos',
+    PLACE_ID: 'place_id',
+    PLUS_CODE: 'plus_code',
+    PRICE_LEVEL: 'price_level',
+    RATING: 'rating',
+    REVIEWS: 'reviews',
+    TYPES: 'types',
+    URL: 'url',
+    USER_RATINGS_TOTAL: 'user_ratings_total',
+    UTC_OFFSET: 'utc_offset',
+    VICINITY: 'vicinity',
+    WEBSITE: 'website'
+  };
+  var PlaceResult =
+  function () {
+    function PlaceResult(placeResult) {
+      var _this = this;
+      _classCallCheck(this, PlaceResult);
+      this.isEmpty = isEmptyResult(placeResult);
+      this.timestamp = new Date().toString();
+      if (!this.isEmpty) Object.values(Properties$1).forEach(function (prop) {
+        _this[prop] = placeResult[prop];
+      });
+    }
+    _createClass(PlaceResult, [{
+      key: "getComponentValue",
+      value: function getComponentValue(query) {
+        var name = getName(query);
+        var type = getType(query);
+        var component = findAddressComponent({
+          components: this[Properties$1.ADDRESS_COMPONENTS],
+          type: type
+        });
+        if (component == null) {
+          logError("".concat(query, " was not found in the results"));
+          return '';
+        }
+        return component[name];
+      }
+    }, {
+      key: "getFormatValue",
+      value: function getFormatValue(query) {
+        var format = lookupFormat(query);
+        if (format != null) return format(this);
+      }
+    }, {
+      key: "getPropertyValue",
+      value: function getPropertyValue(query) {
+        var prop = lookupProperty(query);
+        if (prop != null) return this[prop];
+      }
+    }, {
+      key: "getLocation",
+      value: function getLocation() {
+        var geometry = this[Properties$1.GEOMETRY] || {};
+        return geometry.location;
+      }
+    }, {
+      key: "getValue",
+      value: function getValue(query) {
+        var format = lookupFormat(query);
+        if (format != null) return format(this);
+        var prop = lookupProperty(query);
+        if (prop != null) return this[prop];
+        return this.getComponentValue(query);
+      }
+    }, {
+      key: "getViewport",
+      value: function getViewport() {
+        var geometry = this[Properties$1.GEOMETRY] || {};
+        return geometry.viewport;
+      }
+    }]);
+    return PlaceResult;
+  }();
+  function findAddressComponent(_ref) {
+    var components = _ref.components,
+        type = _ref.type;
+    return components.find(function (c) {
+      return c.types[0] === type;
+    });
+  }
+  function isEmptyResult(placeResult) {
+    return Object.keys(placeResult).length <= 1;
+  }
+  function lookupFormat(query) {
+    return lookup({
+      obj: getFormats(),
+      query: query
+    });
+  }
+  function lookupProperty(query) {
+    return lookup({
+      obj: Properties$1,
+      query: query
+    });
+  }
+
+  var isGoogleMap = function isGoogleMap(val) {
+    return val instanceof window.google.maps.Map;
+  };
+  var isLatLng = function isLatLng(val) {
+    return val instanceof window.google.maps.LatLng;
+  };
+  var isLatLngBounds = function isLatLngBounds(val) {
+    return val instanceof window.google.maps.LatLngBounds;
+  };
+  var isPlaceResult = function isPlaceResult(val) {
+    return val instanceof PlaceResult;
+  };
+
+  var Input =
+  function () {
+    function Input(_ref) {
+      var element = _ref.element,
+          form = _ref.form;
+      _classCallCheck(this, Input);
+      var inputDataKey = form.inputDataKey;
+      this.$element = $(element);
+      this.dataKey = this.$element.data(inputDataKey);
+      this.element = element;
+      this.form = form;
+      this.type = getType$1(element);
+      this.value = null;
+    }
+    _createClass(Input, [{
+      key: "clear",
+      value: function clear() {
+        var _this = this;
+        var Types = {
+          INPUT: function INPUT() {
+            _this.$element.val('');
+          },
+          SELECT: function SELECT() {
+            _this.$element.val('');
+          },
+          SEMANTIC_DROPDOWN: function SEMANTIC_DROPDOWN() {
+            _this.$element.dropdown('clear');
+          }
+        };
+        this.value = null;
+        return Types[this.type]();
+      }
+    }, {
+      key: "setValue",
+      value: function setValue(value) {
+        var _this2 = this;
+        var Types = {
+          INPUT: function INPUT(value) {
+            _this2.$element.val(value);
+          },
+          SELECT: function SELECT(value) {
+            var index = $("option:contains(".concat(value, ")"), _this2.$element)[0].index;
+            _this2.$element.prop('selectedIndex', index);
+          },
+          SEMANTIC_DROPDOWN: function SEMANTIC_DROPDOWN(value) {
+            _this2.$element.dropdown('set selected', value);
+          }
+        };
+        this.value = value;
+        return Types[this.type](value);
+      }
+    }]);
+    return Input;
+  }();
+  function getType$1(element) {
+    return isSemanticDropdown(element) ? 'SEMANTIC_DROPDOWN' : element.nodeName;
+  }
+  function isSemanticDropdown(element) {
+    var eClasses = element.classList;
+    var pClasses = element.parentElement.classList;
+    return eClasses.contains('ui') && eClasses.contains('dropdown') || pClasses.contains('ui') && pClasses.contains('dropdown');
+  }
+
+  var Form =
+  function () {
+    function Form(geocomplete, settings) {
+      _classCallCheck(this, Form);
+      this.id = settings[Settings.FORM_ID];
+      this.element = document.getElementById(this.id.replace('#', ''));
+      this.geocomplete = geocomplete;
+      this.inputDataKey = settings[Settings.INPUT_DATA_KEY];
+      this.inputs = [];
+      this.createInputs();
+    }
+    _createClass(Form, [{
+      key: "createInputs",
+      value: function createInputs() {
+        var _this = this;
+        this.inputs = [];
+        var query = "[data-".concat(this.inputDataKey, "]");
+        var inputElements = this.element.querySelectorAll(query);
+        inputElements.forEach(function (element) {
+          _this.inputs.push(new Input({
+            element: element,
+            form: _this
+          }));
+        });
+      }
+    }, {
+      key: "clear",
+      value: function clear() {
+        this.inputs.forEach(function (input) {
+          return input.clear();
+        });
+        return this.geocomplete.$element;
+      }
+    }, {
+      key: "fill",
+      value: function fill(placeResult) {
+        this.clear();
+        if (!isPlaceResult(placeResult)) {
+          placeResult = new PlaceResult(placeResult);
+        }
+        this.inputs.forEach(function (input) {
+          var value = placeResult.getValue(input.dataKey);
+          input.setValue(value);
+        });
+        return this.geocomplete.$element;
+      }
+    }, {
+      key: "getValues",
+      value: function getValues(query) {
+        var values = {};
+        this.inputs.forEach(function (input) {
+          values[input.dataKey] = input.value;
+        });
+        return query ? values[query] : values;
+      }
+    }]);
+    return Form;
+  }();
+
+  var StyleSheet =
+  function () {
+    function StyleSheet() {
+      _classCallCheck(this, StyleSheet);
+      this.styleSheet = document.createElement('style');
+      this.styleSheet.type = 'text/css';
+      document.head.appendChild(this.styleSheet);
+    }
+    _createClass(StyleSheet, [{
+      key: "addCSS",
+      value: function addCSS(css) {
+        this.styleSheet.innerHTML += css;
+      }
+    }]);
+    return StyleSheet;
+  }();
+
+  var Options = {
+    BOUNDS: 'bounds',
+    COMPONENT_RESTRICTIONS: 'componentRestrictions',
+    FIELDS: 'fields',
+    PLACE_ID_ONLY: 'placeIdOnly',
+    STRICT_BOUNDS: 'strictBounds',
+    TYPES: 'types'
+  };
+  var Autocomplete =
+  function () {
+    function Autocomplete(geocomplete, settings) {
+      _classCallCheck(this, Autocomplete);
+      var options = getOptions(settings);
+      this.$element = geocomplete.$element;
+      this.eventListeners = [];
+      this.geocomplete = geocomplete;
+      this.obj = new window.google.maps.places.Autocomplete(this.$element[0], options);
+    }
+    _createClass(Autocomplete, [{
+      key: "addListener",
+      value: function addListener(eventName, handler) {
+        var listener = this.obj.addListener(eventName, handler);
+        this.eventListeners.push(listener);
+        return listener;
+      }
+    }, {
+      key: "getBounds",
+      value: function getBounds() {
+        return this.obj.getBounds();
+      }
+    }, {
+      key: "getFields",
+      value: function getFields() {
+        return this.obj.getFields();
+      }
+    }, {
+      key: "getPlace",
+      value: function getPlace() {
+        return this.obj.getPlace();
+      }
+    }, {
+      key: "removeListeners",
+      value: function removeListeners() {
+        this.eventListeners.forEach(function (e) {
+          return e.remove();
+        });
+        return this.$element;
+      }
+    }, {
+      key: "setBounds",
+      value: function setBounds(parms) {
+        this.obj.setBounds(parms);
+        return this.$element;
+      }
+    }, {
+      key: "setComponentRestrictions",
+      value: function setComponentRestrictions(parms) {
+        this.obj.setComponentRestrictions(parms);
+        return this.$element;
+      }
+    }, {
+      key: "setFields",
+      value: function setFields(parms) {
+        this.obj.setFields(parms);
+        return this.$element;
+      }
+    }, {
+      key: "setOptions",
+      value: function setOptions(parms) {
+        this.obj.setOptions(parms);
+        return this.$element;
+      }
+    }, {
+      key: "setTypes",
+      value: function setTypes(parms) {
+        this.obj.setTypes(parms);
+        return this.$element;
+      }
+    }]);
+    return Autocomplete;
+  }();
+  function getOptions(settings) {
+    var options = {};
+    var AutocompleteOptions = Object.values(Options);
+    Object.keys(settings).forEach(function (key) {
+      if (AutocompleteOptions.indexOf(key) !== -1) {
+        options[key] = settings[key];
+      }
+    });
+    return options;
+  }
+
+  var PacContainer = function PacContainer(geocomplete, settings) {
+    var _this = this;
+    _classCallCheck(this, PacContainer);
+    this.element = null;
+    this.geocomplete = geocomplete;
+    this.styleSheet = geocomplete.styleSheet;
+    if (settings[Settings.APPEND_TO_PARENT]) {
+      var _this$geocomplete = this.geocomplete,
+          $geo = _this$geocomplete.$element,
+          index = _this$geocomplete.index;
+      $geo.on(Events.FOCUS, function () {
+        _this.element = document.getElementsByClassName('pac-container')[index];
+        if (_this.element != null) {
+          appendToParent({
+            $geo: $geo,
+            element: _this.element,
+            styleSheet: _this.styleSheet
+          });
+          $geo.off(Events.FOCUS);
+        }
+      });
+    }
+  };
+  function appendToParent(_ref) {
+    var $geo = _ref.$geo,
+        element = _ref.element,
+        styleSheet = _ref.styleSheet;
+    var left = "".concat(calcLeftPosition($geo), "px !important");
+    var top = "".concat(calcTopPosition($geo), "px !important");
+    element.id = "pac-container_".concat($geo[0].id);
+    styleSheet.addCSS("#".concat(element.id, "{top:").concat(top, "; left:").concat(left, ";}"));
+    $geo.parent().css({
+      position: 'relative'
+    }).append(element);
+  }
+  function calcLeftPosition($geo) {
+    var element_left = $geo.offset().left;
+    var parent_left = $geo.parent().offset().left;
+    return element_left - parent_left;
+  }
+  function calcTopPosition($geo) {
+    var element_top = $geo.offset().top;
+    var element_height = $geo.outerHeight();
+    var parent_top = $geo.parent().offset().top;
+    return element_top - parent_top + element_height;
+  }
+
+  var Index = -1;
+  var GlobalStyleSheet = new StyleSheet();
+  var Geocomplete =
+  function () {
+    function Geocomplete($element, userSettings) {
+      var _this = this;
+      _classCallCheck(this, Geocomplete);
+      var settings = getExtendedSettings(userSettings);
+      this.$element = $element;
+      this.form = null;
+      this.index = Index += 1;
+      this.map = settings[Settings.MAP];
+      this.placeResult = null;
+      this.styleSheet = GlobalStyleSheet;
+      this.autocomplete = new Autocomplete(this, settings);
+      this.pacContainer = new PacContainer(this, settings);
+      if (settings[Settings.FORM_ID]) this.form = new Form(this, settings);
+      this.autocomplete.addListener(Events.PLACE_CHANGED, function () {
+        var $element = _this.$element;
+        var rawResult = _this.getplace();
+        if (_this.placeResult.isEmpty) return settings[Settings.ON_NO_RESULT].call($element, rawResult.name);
+        settings[Settings.ON_CHANGE].call($element, rawResult.name, rawResult);
+        _this.centermap();
+        _this.fillform();
+      });
+      if (settings[Settings.GEOLOCATE]) this.geolocate();
+    }
+    _createClass(Geocomplete, [{
+      key: "centermap",
+      value: function centermap(bounds) {
+        if (this.map == null || !isGoogleMap(this.map)) return;
+        if (bounds == null) {
+          if (this.placeResult == null) this.getplace();
+          var location = this.placeResult.getLocation();
+          var viewport = this.placeResult.getViewport();
+          bounds = viewport || location;
+        }
+        if (isLatLngBounds(bounds)) {
+          this.map.fitBounds(bounds);
+          return this.$element;
+        }
+        if (isLatLng(bounds)) {
+          this.map.setCenter(bounds);
+          return this.$element;
+        }
+      }
+    }, {
+      key: "clearform",
+      value: function clearform() {
+        if (this.form == null) return;
+        return this.form.clear();
+      }
+    }, {
+      key: "destroy",
+      value: function destroy() {
+        this.autocomplete.removeListeners();
+      }
+    }, {
+      key: "fillform",
+      value: function fillform(placeResult) {
+        if (this.form == null) return;
+        placeResult = placeResult || this.placeResult;
+        return this.form.fill(placeResult);
+      }
+    }, {
+      key: "geolocate",
+      value: function geolocate() {
+        var _this2 = this;
+        if (navigator.geolocation) {
+          navigator.geolocation.getCurrentPosition(function (position) {
+            var circle = new window.google.maps.Circle({
+              center: {
+                lat: position.coords.latitude,
+                lng: position.coords.longitude
+              },
+              radius: position.coords.accuracy
+            });
+            _this2.autocomplete.setBounds(circle.getBounds());
+          });
+        }
+      }
+    }, {
+      key: "getcachedplace",
+      value: function getcachedplace() {
+        return this.placeResult;
+      }
+    }, {
+      key: "getformvalues",
+      value: function getformvalues(query) {
+        if (this.form == null) return;
+        return this.form.getValues(query);
+      }
+    }, {
+      key: "getbounds",
+      value: function getbounds() {
+        return this.autocomplete.getBounds();
+      }
+    }, {
+      key: "getfields",
+      value: function getfields() {
+        return this.autocomplete.getFields();
+      }
+    }, {
+      key: "getplace",
+      value: function getplace() {
+        var rawResult = this.autocomplete.getPlace();
+        this.placeResult = new PlaceResult(rawResult);
+        return rawResult;
+      }
+    }, {
+      key: "setbounds",
+      value: function setbounds(parms) {
+        return this.autocomplete.setBounds(parms);
+      }
+    }, {
+      key: "setcomponentrestrictions",
+      value: function setcomponentrestrictions(parms) {
+        return this.autocomplete.setComponentRestrictions(parms);
+      }
+    }, {
+      key: "setfields",
+      value: function setfields(parms) {
+        return this.autocomplete.setFields(parms);
+      }
+    }, {
+      key: "setoptions",
+      value: function setoptions(parms) {
+        return this.autocomplete.setOptions(parms);
+      }
+    }, {
+      key: "settypes",
+      value: function settypes(parms) {
+        return this.autocomplete.setTypes(parms);
+      }
+    }], [{
+      key: "_jQueryInterface",
+      value: function _jQueryInterface(userSettings, parms) {
+        var $element = $(this);
+        var geo = $element.data(DATA_KEY);
+        if (!geo) {
+          geo = new Geocomplete($element, userSettings);
+          $element.data(DATA_KEY, geo);
+        }
+        if (typeof userSettings === 'string') {
+          var method = userSettings.toLowerCase().replace(SPACES, '');
+          if (geo[method]) return geo[method](parms);
+          logError("\"".concat(userSettings, "\" is not a valid method"));
+        }
+        return this;
+      }
+    }]);
+    return Geocomplete;
+  }();
+  $.fn[NAME] = Geocomplete._jQueryInterface;
+  $.fn[NAME].Constructor = Geocomplete;
+  $.fn[NAME].settings = Defaults;
+
+}());