@inlog/inlog-maps 5.0.5 → 6.0.0

package/lib/map.js

@@ -1,1011 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var googleMaps_1 = require("./models/apis/googleMaps");
-var leaflet_1 = require("./models/apis/leaflet");
-var map_type_1 = require("./models/dto/map-type");
-var marker_clusterer_config_1 = require("./models/features/marker-clusterer/marker-clusterer-config");
-var polyline_options_1 = require("./models/features/polyline/polyline-options");
-var Map = /** @class */ (function () {
-    function Map() {
-        this.markersList = {};
-        this.polygonsList = {};
-        this.circlesList = {};
-        this.polylinesList = {};
-        this.infoWindowList = {};
-        this.overlayList = {};
-        this.markerClusterer = {};
-    }
-    /**
-     * Use this to initialize map
-     * @param {InlogMaps.MapType} mapType
-     * @param {any} options
-     * @param {string} elementId default: 'inlog-map' [nullable]
-     * @returns {Promisse<any>}
-     */
-    Map.prototype.initialize = function (mapType, options, elementId) {
-        if (elementId === void 0) { elementId = 'inlog-map'; }
-        this.map = mapType === map_type_1.MapType.Google ? new googleMaps_1.default() : new leaflet_1.default();
-        return this.map.initialize(mapType, options, elementId);
-    };
-    /* GEOJson */
-    /**
-     * Use this function to add GEOJSON to the currentMap
-     * @param {object} data Geojson
-     * @param {InlogMaps.GeoJsonOptions} options
-     * @param {any} eventClick is a function callback on click [nullable]
-     */
-    Map.prototype.loadGEOJson = function (data, options, eventClick) {
-        this.map.loadGEOJson(data, options, eventClick);
-    };
-    /* Markers */
-    /**
-     * Use this function to draw markers in the currentMap
-     * @param {string} type
-     * @param {InlogMaps.MarkerOptions} options
-     * @param {any} eventClick is a function callback on click [nullable]
-     */
-    Map.prototype.drawMarker = function (type, options, eventClick) {
-        var marker = this.map.drawMarker(options, eventClick);
-        if (!this.markersList[type]) {
-            this.markersList[type] = [];
-        }
-        marker.type = 'simple';
-        this.markersList[type].push(marker);
-        if (options.addClusterer) {
-            if (!this.markerClusterer[type]) {
-                this.addMarkerClusterer(type, new marker_clusterer_config_1.default(true, 1, 10));
-            }
-            this.map.addMarkerOnClusterer(marker, this.markerClusterer[type]);
-        }
-    };
-    /**
-     * Use this function to draw circle markers in the currentMap
-     * @param {string} type
-     * @param {InlogMaps.CircleMarkerOptions} options
-     * @param {any} eventClick is a function callback on click [nullable]
-     */
-    Map.prototype.drawCircleMarker = function (type, options, eventClick) {
-        var marker = this.map.drawCircleMarker(options, eventClick);
-        if (!this.markersList[type]) {
-            this.markersList[type] = [];
-        }
-        marker.type = 'circle';
-        this.markersList[type].push(marker);
-    };
-    /**
-     * Use this function to show/hide markers from a specific type
-     * @param {boolean} show
-     * @param {string} type
-     * @param {any} condition toogle markers with the condition [nullable]
-     */
-    Map.prototype.toggleMarkers = function (show, type, condition) {
-        var markers = this.getMarkers(type, condition);
-        if (markers && markers.length) {
-            this.map.toggleMarkers(markers, show, this.markerClusterer[type]);
-        }
-    };
-    /**
-     * Remove markers from the map and from internal list
-     * @param {string} type
-     * @param {any} condition remove markers with the condition [nullable]
-     */
-    Map.prototype.removeMarkers = function (type, condition) {
-        if (this.markersList[type] && condition) {
-            var markers = this.getMarkers(type, condition);
-            // Hide markers with the condition
-            this.map.toggleMarkers(markers, false, this.markerClusterer[type]);
-            // Keep markers that doesn't have the condition
-            this.markersList[type] = this.markersList[type].filter(function (marker) { return !condition(marker.object); });
-        }
-        else {
-            if (this.markersList[type]) {
-                this.map.toggleMarkers(this.markersList[type], false, this.markerClusterer[type]);
-            }
-            this.markersList[type] = [];
-        }
-        if (this.markersList[type].length === 0) {
-            delete this.markersList[type];
-        }
-    };
-    /**
-     * Remove all markers from the map and from the internal list
-     */
-    Map.prototype.removeAllMarkers = function () {
-        for (var type in this.markersList) {
-            if (this.markersList.hasOwnProperty(type)) {
-                this.removeMarkers(type);
-            }
-        }
-    };
-    /**
-     * Use this function to alter marker style
-     * @param {string} type
-     * @param {InlogMaps.MarkerAlterOptions} options
-     * @param {any} condition alter markers with the condition [nullable]
-     */
-    Map.prototype.alterMarkerOptions = function (type, options, condition) {
-        var markers = this.getMarkers(type, condition);
-        if (markers && markers.length) {
-            this.map.alterMarkerOptions(markers, options);
-        }
-    };
-    /**
-     * Use this functions to alterar marker position
-     * @param {string } type
-     * @param {number[]} position
-     * @param {boolean} addTransition [nullable]
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.alterMarkerPosition = function (type, position, addTransition, condition) {
-        var markers = this.getMarkers(type, condition);
-        if (markers && markers.length) {
-            this.map.alterMarkerPosition(markers, position, addTransition);
-        }
-    };
-    /**
-     * Use this function to fit bounds in the markers with the especified type
-     * @param {string} type
-     * @param {any} condition [nullable]
-     * @param {boolean} onlyMarkersOnMap default true
-     */
-    Map.prototype.fitBoundsMarkers = function (type, condition, onlyMarkersOnMap) {
-        var _this = this;
-        if (onlyMarkersOnMap === void 0) { onlyMarkersOnMap = true; }
-        var markers = this.getMarkers(type, condition);
-        if (onlyMarkersOnMap) {
-            markers = markers.filter(function (x) { return _this.map.isMarkerOnMap(x); });
-        }
-        if (markers && markers.length) {
-            this.map.fitBoundsPositions(markers);
-        }
-    };
-    /**
-     * Use this functions to set the center of the map on marker
-     * @param {string} type
-     * @param {any} condition center on marker with the condition [nullable]
-     */
-    Map.prototype.setCenterMarker = function (type, condition) {
-        if (this.markersList[type] && condition) {
-            var marker = this.markersList[type].find(function (marker) { return condition(marker.object); });
-            // Center on the marker with the condition
-            this.map.setCenterMarker(marker);
-        }
-        else {
-            if (this.markersList[type] && this.markersList[type].length) {
-                this.map.setCenterMarker(this.markersList[type][0]);
-            }
-        }
-    };
-    /**
-     * This functions returns if marker exists
-     * @param type
-     * @param condition [nullable]
-     * @returns {boolean}
-     */
-    Map.prototype.markerExists = function (type, condition) {
-        var markers = this.getMarkers(type, condition);
-        return markers && markers.length > 0;
-    };
-    /**
-     * Use this function to count markers by type
-     * @param {string} type
-     * @param {boolean} onlyOnMap exclude hidden markers, default true
-     * @param {any} condition
-     * @returns {number}
-     */
-    Map.prototype.countMarkers = function (type, onlyOnMap, condition) {
-        var _this = this;
-        if (onlyOnMap === void 0) { onlyOnMap = true; }
-        if (this.markerClusterer[type]) {
-            return this.map.countMarkersOnCluster(this.markerClusterer[type]);
-        }
-        var markers = this.getMarkers(type, condition);
-        if (onlyOnMap) {
-            markers = markers.filter(function (x) { return _this.map.isMarkerOnMap(x); });
-        }
-        return markers.length;
-    };
-    /**
-     * This function add new events on marker
-     * @param {string} type
-     * @param {InlogMaps.MarkerEventType} event
-     * @param {any} eventFunction
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.addMarkerEvent = function (type, event, eventFunction, condition) {
-        var markers = this.getMarkers(type, condition);
-        this.map.addMarkerEvent(markers, event, eventFunction);
-    };
-    /**
-     * This function remove events of marker
-     * @param {string} type
-     * @param {InlogMaps.MarkerEventType} event
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.removeMarkerEvent = function (type, event, condition) {
-        var markers = this.getMarkers(type, condition);
-        this.map.removeMarkerEvent(markers, event);
-    };
-    /* Marker Clusterer */
-    /**
-     * Use this function to add MarkerClusterer on the map
-     * @param {string} type same type of markers
-     * @param {InlogMaps.MarkerClusterConfig} config
-     */
-    Map.prototype.addMarkerClusterer = function (type, config) {
-        this.markerClusterer[type] = this.map.addMarkerClusterer(config);
-    };
-    /**
-     * Use this function to alter clusterer options
-     * @param type same type of markers
-     * @param {InlogMaps.MarkerClusterConfig} config
-     */
-    Map.prototype.alterMarkerClustererConfig = function (type, config) {
-        if (this.markerClusterer[type]) {
-            this.map.alterMarkerClustererConfig(this.markerClusterer[type], config);
-        }
-    };
-    /**
-     * Use this function to redraw marker clusterer
-     * @param type same type of markers
-     */
-    Map.prototype.refreshClusterer = function (type) {
-        if (this.markerClusterer[type]) {
-            this.map.refreshClusterer(this.markerClusterer[type]);
-        }
-    };
-    /**
-     * Use this to clear markers on clusterer
-     * @param type same type of markers
-     */
-    Map.prototype.clearMarkersClusterer = function (type) {
-        if (this.markerClusterer[type]) {
-            this.map.clearMarkersClusterer(this.markerClusterer[type]);
-        }
-    };
-    /* Polygons */
-    /**
-     * Use this function to draw polygons
-     * @param {string} type
-     * @param {InlogMaps.PolygonOptions} options
-     * @param {any} eventClick [nullable]
-     */
-    Map.prototype.drawPolygon = function (type, options, eventClick) {
-        var polygon = this.map.drawPolygon(options, eventClick);
-        if (!this.polygonsList[type]) {
-            this.polygonsList[type] = [];
-        }
-        this.polygonsList[type].push(polygon);
-    };
-    /**
-     * Use this function to show/hide polygon from a especific type
-     * @param {boolean} show
-     * @param {string} type
-     * @param {any} condition toggle polygon with the condition [nullable]
-     */
-    Map.prototype.togglePolygons = function (show, type, condition) {
-        var polygons = this.getPolygons(type, condition);
-        if (polygons && polygons.length) {
-            this.map.togglePolygons(polygons, show);
-        }
-    };
-    /**
-     * Remove polygons from the map and from internal list
-     * @param {string} type
-     * @param {any} condition remove polygons with the condition [nullable]
-     */
-    Map.prototype.removePolygons = function (type, condition) {
-        if (this.polygonsList[type] && condition) {
-            var polygons = this.getPolygons(type, condition);
-            // Hide markers with the condition
-            this.map.togglePolygons(polygons, false);
-            // Keep markers that doesn't have the condition
-            this.polygonsList[type] = this.polygonsList[type].filter(function (polygon) { return !condition(polygon.object); });
-        }
-        else {
-            if (this.polygonsList[type]) {
-                this.map.togglePolygons(this.polygonsList[type], false);
-            }
-            this.polygonsList[type] = [];
-        }
-        if (this.polygonsList[type].length === 0) {
-            delete this.polygonsList[type];
-        }
-    };
-    /**
-     * Remove all polygons from the map and from the internal list
-     */
-    Map.prototype.removeAllPolygons = function () {
-        for (var type in this.polygonsList) {
-            if (this.polygonsList.hasOwnProperty(type)) {
-                this.removePolygons(type);
-            }
-        }
-    };
-    /**
-     * Use this function to alter polygons options/style
-     * @param {string} type
-     * @param {InlogMaps.PolygonAlterOptions} options
-     * @param {any} condition alter polygon with the condition [nullable]
-     */
-    Map.prototype.alterPolygonOptions = function (type, options, condition) {
-        var polygons = this.getPolygons(type, condition);
-        if (polygons && polygons.length) {
-            this.map.alterPolygonOptions(polygons, options);
-        }
-    };
-    /**
-     * Use this function to fit bounds of a polygon
-     * @param {string} type
-     * @param {any} condition fit polygon bounds with the condition [nullable]
-     */
-    Map.prototype.fitBoundsPolygons = function (type, condition) {
-        var _this = this;
-        var polygons = this.getPolygons(type, condition)
-            .filter(function (polygon) { return _this.map.isPolygonOnMap(polygon); });
-        if (polygons && polygons.length) {
-            this.map.fitBoundsPolygons(polygons);
-        }
-    };
-    /**
-     * Set center on polygon bounds
-     * @param {string} type
-     * @param {any} condition fit polygon bounds with the condition [nullable]
-     */
-    Map.prototype.setCenterPolygons = function (type, condition) {
-        var _this = this;
-        var polygons = this.getPolygons(type, condition)
-            .filter(function (polygon) { return _this.map.isPolygonOnMap(polygon); });
-        if (polygons && polygons.length) {
-            this.map.setCenterPolygons(polygons);
-        }
-    };
-    /**
-     * This functions returns if polygon exists
-     * @param type
-     * @param condition [nullable]
-     * @returns {boolean}
-     */
-    Map.prototype.polygonExists = function (type, condition) {
-        var polygons = this.getPolygons(type, condition);
-        return polygons && polygons.length > 0;
-    };
-    /**
-     * Use this function to get the path of some polygon
-     * @param {string} type
-     * @param {any} condition
-     * @returns {number[]}
-     */
-    Map.prototype.getPolygonPath = function (type, condition) {
-        var polygon = this.getPolygons(type, condition);
-        if (polygon && polygon.length) {
-            return this.map.getPolygonPath(polygon[0]);
-        }
-    };
-    /**
-     * This function add new events on polygon
-     * @param {string} type
-     * @param {InlogMaps.PolygonEventType} event
-     * @param {any} eventFunction
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.addPolygonEvent = function (type, event, eventFunction, condition) {
-        var polygons = this.getPolygons(type, condition);
-        this.map.addPolygonEvent(polygons, event, eventFunction);
-    };
-    /**
-     * This function remove events of polygon
-     * @param {string} type
-     * @param {InlogMaps.PolygonEventType} event
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.removePolygonEvent = function (type, event, condition) {
-        var polygons = this.getPolygons(type, condition);
-        this.map.removePolygonEvent(polygons, event);
-    };
-    /* Circles */
-    /**
-     * Use this function to draw circles on the currentMap
-     * @param {string} type
-     * @param {InlogMaps.CircleOptions} options
-     * @param {any} eventClick [nullable]
-     */
-    Map.prototype.drawCircle = function (type, options, eventClick) {
-        var circle = this.map.drawCircle(options, eventClick);
-        if (!this.circlesList[type]) {
-            this.circlesList[type] = [];
-        }
-        this.circlesList[type].push(circle);
-    };
-    /**
-     * Use this function to show/hide circles from a especific type
-     * @param {boolean} show
-     * @param {string} type
-     * @param {any} condition toggle circles with the condition [nullable]
-     */
-    Map.prototype.toggleCircles = function (show, type, condition) {
-        var circles = this.getCircles(type, condition);
-        if (circles && circles.length) {
-            this.map.toggleCircles(circles, show);
-        }
-    };
-    /**
-     * Remove circles from the map and from internal list
-     * @param {string} type
-     * @param {any} condition remove circles with the condition [nullable]
-     */
-    Map.prototype.removeCircles = function (type, condition) {
-        if (this.circlesList[type] && condition) {
-            var circles = this.getCircles(type, condition);
-            // Hide circles with the condition
-            this.map.toggleCircles(circles, false);
-            // Keep circles that doesn't have the condition
-            this.circlesList[type] = this.circlesList[type].filter(function (circle) { return !condition(circle.object); });
-        }
-        else {
-            if (this.circlesList[type]) {
-                this.map.toggleCircles(this.circlesList[type], false);
-            }
-            this.circlesList[type] = [];
-        }
-        if (this.circlesList[type].length === 0) {
-            delete this.circlesList[type];
-        }
-    };
-    /**
-     * Remove all circles from the map and from the internal list
-     */
-    Map.prototype.removeAllCircles = function () {
-        for (var type in this.circlesList) {
-            if (this.circlesList.hasOwnProperty(type)) {
-                this.removeCircles(type);
-            }
-        }
-    };
-    /**
-     * Use this function to alter circle options
-     * @param {string} type
-     * @param {InlogMaps.CircleAlterOptions} options
-     * @param {any} condition alter circle with the condition [nullable]
-     */
-    Map.prototype.alterCircleOptions = function (type, options, condition) {
-        var circles = this.getCircles(type, condition);
-        if (circles && circles.length) {
-            this.map.alterCircleOptions(circles, options);
-        }
-    };
-    /**
-     * Use this function to fit bounds of a polygon
-     * @param {string} type
-     * @param {any} condition fit polygon bounds with the condition [nullable]
-     */
-    Map.prototype.fitBoundsCircles = function (type, condition) {
-        var _this = this;
-        var circles = this.getCircles(type, condition)
-            .filter(function (circle) { return _this.map.isCircleOnMap(circle); });
-        if (circles && circles.length) {
-            this.map.fitBoundsCircles(circles);
-        }
-    };
-    /**
-     * This functions returns if circle exists
-     * @param {string} type
-     * @param {any} condition [nullable]
-     * @returns {boolean}
-     */
-    Map.prototype.circleExists = function (type, condition) {
-        var circles = this.getCircles(type, condition);
-        return circles && circles.length > 0;
-    };
-    /**
-     * This function return circle center
-     * @param {string} type
-     * @param {any} condition [nullable]
-     * @returns {number[]}
-     */
-    Map.prototype.getCircleCenter = function (type, condition) {
-        var circles = this.getCircles(type, condition);
-        if (circles && circles.length) {
-            return this.map.getCircleCenter(circles[0]);
-        }
-        return null;
-    };
-    /**
-     * This function return circle center
-     * @param {string} type
-     * @param {any} condition [nullable]
-     * @returns {number}
-     */
-    Map.prototype.getCircleRadius = function (type, condition) {
-        var circles = this.getCircles(type, condition);
-        if (circles && circles.length) {
-            return this.map.getCircleRadius(circles[0]);
-        }
-        return null;
-    };
-    /**
-     * This function add new events on circle
-     * @param {string} type
-     * @param {InlogMaps.CircleEventType} event
-     * @param {any} eventFunction
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.addCircleEvent = function (type, event, eventFunction, condition) {
-        var circles = this.getCircles(type, condition);
-        this.map.addCircleEvent(circles, event, eventFunction);
-    };
-    /**
-     * This function remove events of circle
-     * @param {string} type
-     * @param {InlogMaps.CircleEventType} event
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.removeCircleEvent = function (type, event, condition) {
-        var circles = this.getCircles(type, condition);
-        this.map.removeCircleEvent(circles, event);
-    };
-    /* Polylines */
-    /**
-     * Use this function to draw polylines on the currentMap
-     * @param {string} type
-     * @param {InlogMaps.PolylineOptions} options
-     * @param {any} eventClick [nullable]
-     */
-    Map.prototype.drawPolyline = function (type, options, eventClick) {
-        var polyline = this.map.drawPolyline(options, eventClick);
-        if (!this.polylinesList[type]) {
-            this.polylinesList[type] = [];
-        }
-        this.polylinesList[type].push(polyline);
-    };
-    /**
-     * Use this function to draw polylines with navigation on the currentMap
-     * @param {string} type
-     * @param {InlogMaps.PolylineOptions} options
-     */
-    Map.prototype.drawPolylineWithNavigation = function (type, options, eventClick) {
-        var polyline = this.map.drawPolylineWithNavigation(options, eventClick);
-        if (!this.polylinesList[type]) {
-            this.polylinesList[type] = [];
-        }
-        this.polylinesList[type].push(polyline);
-    };
-    /**
-     * Use this function to toggle polylines
-     * @param {boolean} show
-     * @param {string} type
-     * @param {any} condition toggle polyline with the condition [nullable]
-     */
-    Map.prototype.togglePolylines = function (show, type, condition) {
-        var polyline = this.getPolylines(type, condition);
-        if (polyline && polyline.length) {
-            this.map.togglePolylines(polyline, show);
-        }
-    };
-    /**
-     * Use this function to remove polylines
-     * @param {string} type
-     * @param {any} condition remove polyline with the condition [nullable]
-     */
-    Map.prototype.removePolylines = function (type, condition) {
-        if (this.polylinesList[type] && condition) {
-            var polylines = this.getPolylines(type, condition);
-            // Hide markers with the condition
-            this.map.togglePolylines(polylines, false);
-            // Keep markers that doesn't have the condition
-            this.polylinesList[type] = this.polylinesList[type].filter(function (polyline) { return !condition(polyline.object); });
-        }
-        else {
-            if (this.polylinesList[type]) {
-                this.map.togglePolylines(this.polylinesList[type], false);
-            }
-            this.polylinesList[type] = [];
-        }
-        if (this.polylinesList[type].length === 0) {
-            delete this.polylinesList[type];
-        }
-    };
-    /**
-     * Remove all polylines from the map and from the internal list
-     */
-    Map.prototype.removeAllPolylines = function () {
-        for (var type in this.polylinesList) {
-            if (this.polylinesList.hasOwnProperty(type)) {
-                this.removePolylines(type);
-            }
-        }
-    };
-    /**
-     * Use this function to alter polyline options
-     * @param {string} type
-     * @param {InlogMaps.PolylineOptions} options
-     * @param {any} condition alter polyline with the condition [nullable]
-     */
-    Map.prototype.alterPolylineOptions = function (type, options, condition) {
-        var polyline = this.getPolylines(type, condition);
-        if (polyline && polyline.length) {
-            this.map.alterPolylineOptions(polyline, options);
-        }
-    };
-    /**
-     * Use this functions to fit polylines bounds
-     * @param {string} type
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.fitBoundsPolylines = function (type, condition) {
-        var _this = this;
-        var polylines = this.getPolylines(type, condition)
-            .filter(function (polyline) { return _this.map.isPolylineOnMap(polyline); });
-        if (polylines && polylines.length) {
-            this.map.fitBoundsPolylines(polylines);
-        }
-    };
-    /**
-     * This functions returns if polyline exists
-     * @param {string} type
-     * @param {any} condition [nullable]
-     * @returns {boolean}
-     */
-    Map.prototype.polylineExists = function (type, condition) {
-        var polylines = this.getPolylines(type, condition);
-        return polylines && polylines.length > 0;
-    };
-    /**
-     * Use this function to add more paths to a polyline
-     * @param {string} type
-     * @param {number[]} position
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.addPolylinePath = function (type, position, condition) {
-        var polyline = this.getPolylines(type, condition);
-        if (polyline && polyline.length) {
-            this.map.addPolylinePath(polyline, position);
-        }
-        else {
-            var options = new polyline_options_1.default();
-            options.addToMap = true;
-            this.drawPolyline(type, options, null);
-        }
-    };
-    /**
-     * Use this function to get the path of some polyline
-     * @param {string} type
-     * @param {any} condition
-     * @returns {number[]}
-     */
-    Map.prototype.getPolylinePath = function (type, condition) {
-        var polyline = this.getPolylines(type, condition);
-        if (polyline && polyline.length) {
-            return this.map.getPolylinePath(polyline[0]);
-        }
-    };
-    /**
-     * Use this function to clear polyline selected from the currentMap
-     */
-    Map.prototype.removePolylineHighlight = function () {
-        this.map.removePolylineHighlight();
-    };
-    /**
-     * Use this function to add listeners on polyline
-     * @param {string} type
-     * @param {InlogMaps.PolylineEventType} event
-     * @param {any} eventFunction
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.addPolylineEvent = function (type, event, eventFunction, condition) {
-        var polyline = this.getPolylines(type, condition);
-        this.map.addPolylineEvent(polyline, event, eventFunction);
-    };
-    /**
-     * Use this function to remove listeners of polyline
-     * @param {string} type
-     * @param {InlogMaps.PolylineEventType} event
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.removePolylineEvent = function (type, event, condition) {
-        var polyline = this.getPolylines(type, condition);
-        this.map.removePolylineEvent(polyline, event);
-    };
-    /**
-     * Use this function to set position of polyline highlight
-     * @param {string} type
-     * @param {number} initialIndex
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.setIndexPolylineHighlight = function (type, initialIndex, condition) {
-        var polylines = this.getPolylines(type, condition);
-        if (polylines && polylines.length) {
-            this.map.setIndexPolylineHighlight(polylines[0], initialIndex);
-        }
-    };
-    /**
-     * Use this function to get the object of a polyline
-     * @param {string} type
-     * @param {any} condition
-     * @returns {object}
-     */
-    Map.prototype.getObjectPolyline = function (type, condition) {
-        var polylines = this.getPolylines(type, condition);
-        if (polylines && polylines.length) {
-            return this.map.getObjectPolyline(polylines[0]);
-        }
-        else {
-            return null;
-        }
-    };
-    /**
-     * Use this function to get the object of the polyline highligth
-     * @returns {object}
-     */
-    Map.prototype.getObjectPolylineHighlight = function () {
-        return this.map.getObjectPolylineHighlight();
-    };
-    /**
-     * Use this function to add events on polyline highligtht / selected polyline
-     * @param {InlogMaps.PolylineEventType} event
-     * @param {any} eventFunction
-     */
-    Map.prototype.addPolylineHighlightEvent = function (event, eventFunction) {
-        this.map.addPolylineHighlightEvent(event, eventFunction);
-    };
-    /**
-     * Use this function to get initial and final index of the polyline highlight
-     * @returns {number[]} returns an array with initial index and final index
-     */
-    Map.prototype.getPolylineHighlightIndex = function () {
-        return this.map.getPolylineHighlightIndex();
-    };
-    /* Info Windows */
-    /**
-     * Use this function to draw popups on the currentMap
-     * @param {string} type
-     * @param {InlogMaps.PopupOptions} options
-     */
-    Map.prototype.drawPopup = function (type, options) {
-        var marker = null;
-        if (options.marker) {
-            var markers = this.getMarkers(options.marker, options.conditionMarker);
-            marker = markers[0];
-        }
-        var popup;
-        if (this.infoWindowList[type]) {
-            popup = this.map.alterPopup(this.infoWindowList[type], options, marker);
-        }
-        else {
-            popup = this.map.drawPopup(options, marker);
-        }
-        this.infoWindowList[type] = popup;
-    };
-    /**
-     * Use this function to alter popups
-     * @param {string} type
-     * @param {InlogMaps.PopupOptions} options
-     */
-    Map.prototype.alterPopup = function (type, options) {
-        var popups = this.infoWindowList[type];
-        var markers;
-        if (options.marker) {
-            markers = this.getMarkers(options.marker, options.conditionMarker);
-        }
-        if (popups) {
-            this.map.alterPopupContent(popups, options, markers ? markers[0] : null);
-        }
-    };
-    /**
-     *
-     * @param {string} type
-     * @returns {object}
-     */
-    Map.prototype.getObjectOpenPopup = function (type) {
-        return this.infoWindowList[type] ? this.infoWindowList[type].object : null;
-    };
-    /**
-     * Use this function to close popup by type
-     * @param {string} type
-     */
-    Map.prototype.closePopup = function (type) {
-        if (this.infoWindowList[type]) {
-            this.map.closePopup(this.infoWindowList[type]);
-        }
-    };
-    /**
-     * Use this function to close all popups
-     * @param {string} type
-     */
-    Map.prototype.closeAllPopups = function () {
-        for (var type in this.infoWindowList) {
-            if (this.infoWindowList.hasOwnProperty(type)) {
-                this.closePopup(type);
-            }
-        }
-    };
-    /* Map */
-    /**
-     * Resize de map based on html size
-     */
-    Map.prototype.resizeMap = function () {
-        this.map.resizeMap();
-    };
-    /**
-     * Use this function to add event clicks on the currentMap
-     * @param {InlogMaps.MapEventType} eventType
-     * @param eventFunction function callback
-     */
-    Map.prototype.addEventMap = function (eventType, eventFunction) {
-        this.map.addEventMap(eventType, eventFunction);
-    };
-    /**
-     * Use this function to remove event clicks from the currentMap
-     * @param {InlogMaps.MapEventType} eventType
-     */
-    Map.prototype.removeEventMap = function (eventType) {
-        this.map.removeEventMap(eventType);
-    };
-    /**
-     * Returns the current zoom level of the map view
-     * @returns {number}
-     */
-    Map.prototype.getZoom = function () {
-        return this.map.getZoom();
-    };
-    /**
-     * Set the current zoom level of the map view
-     * @param {number} zoom
-     */
-    Map.prototype.setZoom = function (zoom) {
-        this.map.setZoom(zoom);
-    };
-    /**
-     * Returns the center position of the map
-     * @returns {number[]}
-     */
-    Map.prototype.getCenter = function () {
-        return this.map.getCenter();
-    };
-    /**
-     * Set the position center of the map
-     * @param {number[]} position
-     */
-    Map.prototype.setCenter = function (position) {
-        this.map.setCenter(position);
-    };
-    /**
-     * Returns the coordinates from pixels
-     * @param {number} offsetx
-     * @param {number} offsety
-     * @returns {number[]}
-     */
-    Map.prototype.pixelsToLatLng = function (offsetx, offsety) {
-        return this.map.pixelsToLatLng(offsetx, offsety);
-    };
-    /**
-     * Use this functions to fit bounds on elements with same type and condition
-     * @param {string} type
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.fitBoundsElements = function (type, condition) {
-        var _this = this;
-        var markers = this.getMarkers(type, condition)
-            .filter(function (marker) { return _this.map.isMarkerOnMap(marker); });
-        var circles = this.getCircles(type, condition)
-            .filter(function (circle) { return _this.map.isCircleOnMap(circle); });
-        var polygons = this.getPolygons(type, condition)
-            .filter(function (polygon) { return _this.map.isPolygonOnMap(polygon); });
-        var polylines = this.getPolylines(type, condition)
-            .filter(function (polyline) { return _this.map.isPolylineOnMap(polyline); });
-        this.map.fitBoundsElements(markers, circles, polygons, polylines);
-    };
-    /* Overlay */
-    /**
-     * Use this function to dray overlays on the current map
-     * @param {string} type
-     * @param {InlogMaps.OverlayOptions} options
-     */
-    Map.prototype.drawOverlay = function (type, options) {
-        var overlay = null;
-        if (options.polygon) {
-            var polygons = this.getPolygons(options.polygon, options.conditionPolygon);
-            if (polygons && polygons.length) {
-                overlay = this.map.drawOverlay(options, polygons);
-            }
-        }
-        else {
-            overlay = this.map.drawOverlay(options);
-        }
-        if (overlay != null) {
-            if (!this.overlayList[type]) {
-                this.overlayList[type] = [];
-            }
-            this.overlayList[type].push(overlay);
-        }
-    };
-    /**
-     * Use this function to show or hide overlay
-     * @param {boolean} show
-     * @param {string} type
-     * @param {any} condition [nullable]
-     */
-    Map.prototype.toggleOverlay = function (show, type, condition) {
-        var overlays = this.getOverlays(type, condition);
-        if (overlays && overlays.length) {
-            this.map.toggleOverlay(overlays, show);
-        }
-    };
-    /**
-     * Remove overlays from the map and from internal list
-     * @param {string} type
-     * @param {any} condition remove overlays with the condition [nullable]
-     */
-    Map.prototype.removeOverlays = function (type, condition) {
-        if (this.overlayList[type] && condition) {
-            var overlays = this.getOverlays(type, condition);
-            // Hide markers with the condition
-            this.map.toggleOverlay(overlays, false);
-            // Keep markers that doesn't have the condition
-            this.overlayList[type] = this.overlayList[type].filter(function (overlay) { return !condition(overlay.object); });
-        }
-        else {
-            if (this.overlayList[type]) {
-                this.map.toggleOverlay(this.overlayList[type], false);
-            }
-            this.overlayList[type] = [];
-        }
-        if (this.overlayList[type].length === 0) {
-            delete this.overlayList[type];
-        }
-    };
-    /**
-     * Remove all overlays from the map and from the internal list
-     */
-    Map.prototype.removeAllOverlays = function () {
-        for (var type in this.overlayList) {
-            if (this.overlayList.hasOwnProperty(type)) {
-                this.removeOverlays(type);
-            }
-        }
-    };
-    /* Private Methods */
-    Map.prototype.getMarkers = function (type, condition) {
-        var markers = this.markersList[type];
-        if (markers && markers.length) {
-            return condition ? markers.filter(function (marker) { return condition(marker.object); }) : markers;
-        }
-        else
-            return [];
-    };
-    Map.prototype.getPolygons = function (type, condition) {
-        var polygons = this.polygonsList[type];
-        if (polygons && polygons.length) {
-            return condition ? polygons.filter(function (polygon) { return condition(polygon.object); }) : polygons;
-        }
-        else
-            return [];
-    };
-    Map.prototype.getCircles = function (type, condition) {
-        var circles = this.circlesList[type];
-        if (circles && circles.length) {
-            return condition ? circles.filter(function (circle) { return condition(circle.object); }) : circles;
-        }
-        else
-            return [];
-    };
-    Map.prototype.getPolylines = function (type, condition) {
-        var polylines = this.polylinesList[type];
-        if (polylines && polylines.length) {
-            return condition ? polylines.filter(function (polyline) { return condition(polyline.object); }) : polylines;
-        }
-        else
-            return [];
-    };
-    Map.prototype.getOverlays = function (type, condition) {
-        var overlays = this.overlayList[type];
-        if (overlays && overlays.length) {
-            return condition ? overlays.filter(function (overlay) { return condition(overlay.object); }) : overlays;
-        }
-        else
-            return [];
-    };
-    return Map;
-}());
-exports.default = Map;
-//# sourceMappingURL=map.js.map