proximiio-js-library 1.9.7 → 1.9.8

package/README.md

@@ -175,6 +175,7 @@ const map = new Proximiio.Map({
    },
    language: 'en', // optional, set default map language for poi features
    routeColor: '#000000', // optional, define route line color
+   forceFloorLevel: 0, // optional, define floor number if you want to force routes visible for single level
 });
 ```
 
@@ -494,6 +495,22 @@ map.getMapReadyListener().subscribe(ready => {
 });
 ```
 
+##### Set Features Highlight
+
+Method for adding circle layer as a highlight for defined features.
+
+```
+// @param features {string[]} array of feature ids to set highlight on, you can send empty array to remove highlights.
+// @param color {string} highlight color, optional, default: '#000'.
+// @param radius {number} highlight circle radius, optional, default: 50.
+// @param blur {number} blur of the highlight circle, optional, default: 0.8.
+
+map.getMapReadyListener().subscribe(ready => {
+   console.log('map ready', ready);
+   map.setFeaturesHighlight(['featureid']);
+});
+```
+
 ##### Add New Feature
 
 Add new feature to map.

package/assets/wayfinding.js

@@ -60,8 +60,8 @@ export class Wayfinding {
         const routableAreaFeatureList = featureList.filter(feature => feature.properties.routable && this.ROUTABLE_TYPE.includes(feature.geometry.type));
         let floorGeojsonMap = new Map();
         for (let level = minLevel; level <= maxLevel; level++) {
-            let floorAreaFeature = routableAreaFeatureList.find(feature => feature.properties.level === level);
-            floorGeojsonMap.set(level, turf.featureCollection(floorAreaFeature !== undefined ? [floorAreaFeature] : []));
+            let floorAreaFeature = routableAreaFeatureList.filter(feature => feature.properties.level === level);
+            floorGeojsonMap.set(level, turf.featureCollection(floorAreaFeature !== undefined ? floorAreaFeature : []));
         }
         this.floorList = floorGeojsonMap;
 
@@ -117,7 +117,7 @@ export class Wayfinding {
         let maxLevel = undefined;
 
         featureList.forEach(feature => {
-            let level = feature.properties.level;
+            const level = feature.properties.level;
             if (minLevel === undefined || level < minLevel) {
                 minLevel = level;
             }
@@ -125,17 +125,17 @@ export class Wayfinding {
                 maxLevel = level;
             }
             if (feature.properties.levels !== undefined) {
-                feature.properties.levels.forEach(level => {
-                    if (minLevel === undefined || level < minLevel) {
-                        minLevel = level;
+                feature.properties.levels.forEach(item => {
+                    if (minLevel === undefined || item < minLevel) {
+                        minLevel = item;
                     }
-                    if (maxLevel === undefined || maxLevel < level) {
-                        maxLevel = level;
+                    if (maxLevel === undefined || maxLevel < item) {
+                        maxLevel = item;
                     }
                 });
             }
         });
-        return { minLevel, maxLevel};
+        return { minLevel, maxLevel };
     }
 
     rebuildData() {
@@ -146,8 +146,8 @@ export class Wayfinding {
             let floorAreas = [];
 
             // Floor features == "walkable areas"
-            floor.features.forEach((walkableArea, walkableAreaIndex) => {
-                let wallLineStringList = turf.flatten(turf.polygonToLine(walkableArea)).features.map(feature => {return feature.geometry; });
+            floor.features.forEach(walkableArea => {
+                let wallLineStringList = turf.flatten(turf.polygonToLine(walkableArea)).features.map(feature => feature.geometry);
                 // Floor wall lines, we wish to split to individual walls
                 wallLineStringList.forEach(wallLineString => {
                     let firstPoint;
@@ -160,6 +160,7 @@ export class Wayfinding {
                             firstPoint = turf.point(wallLineString.coordinates[index]);
                             firstPoint.properties.level = level;
                             firstPoint.properties.neighbours = [];
+                            firstPoint.properties.walkableAreaId = walkableArea.id;
                             point = firstPoint;
                         } else {
                             point = nextPoint;
@@ -170,6 +171,7 @@ export class Wayfinding {
                             nextPoint = turf.point(wallLineString.coordinates[index + 1]);
                             nextPoint.properties.level = level;
                             nextPoint.properties.neighbours = [];
+                            nextPoint.properties.walkableAreaId = walkableArea.id;
                         }
                         point.properties.neighbours.push(nextPoint);
                         nextPoint.properties.neighbours.push(point);
@@ -197,8 +199,8 @@ export class Wayfinding {
             let inAreaPoiList = this.accessibilityPoi
                 .filter(poi => floorLevel === poi.properties.level)
                 .filter(poi =>
-                    floorData.areas.filter(area => turf.booleanContains(area, poi)) .length > 0)
-            ;
+                    floorData.areas.filter(area => turf.booleanContains(area, poi)).length > 0);
+
             inAreaPoiList.forEach(poi => {
                 // Generate points around POI to allow going around, but only if they are "within area
                 let detourPointList = [
@@ -376,6 +378,8 @@ export class Wayfinding {
                     intersectPoint.properties.level = segment[0].properties.level;
                     intersectPoint.properties.neighbours = [];
                     intersectPoint.properties.bordersArea = true;
+                    intersectPoint.properties.walkableAreaId = walls[0][0].properties.walkableAreaId;
+                    
                     // Intersect point inherits filters from both intersecting lines
                     if (segmentFeature.properties.narrowPath) {
                         intersectPoint.properties.narrowPath = true;
@@ -756,11 +760,13 @@ export class Wayfinding {
                 if (previous === current || previous.geometry.coordinates[0] !== point.geometry.coordinates[0] || previous.geometry.coordinates[1] !== point.geometry.coordinates[1]) {
                     let newPoint = this._copyPoint(point);
                     newPoint.properties.level = current.properties.level;
+                    newPoint.properties.walkableAreaId = current.properties.walkableAreaId;
+                    newPoint.properties.bordersArea = current.properties.bordersArea;
                     path.push(newPoint);
                     previous = point;
                 }
             });
-            current =  current.properties.cameFrom;
+            current = current.properties.cameFrom;
         } while (current != null);
 
         path.reverse();
@@ -778,7 +784,7 @@ export class Wayfinding {
             }
 
             let distanceAtoB = this._distance(pointA, pointB);
-            // 70cm
+            // 50cm
             if (distanceAtoB < 0.5) {
                 pointsToFilter.push(pointA);
             }
@@ -910,7 +916,25 @@ export class Wayfinding {
      * @return {[Feature<Point>]}
      * @private
      */
-    runAStar(startPoint, endPoint) {
+     runAStar(startPoint, endPoint) {
+        const natural = this.calculatePath(startPoint, endPoint);
+        const reverse = this.calculatePath(endPoint, startPoint);
+
+        if (reverse === undefined || natural.length >= reverse.length) {
+            return natural
+        }
+
+        return reverse;
+    }
+
+    /**
+     *
+     * @param startPoint {Feature<Point>}
+     * @param endPoint {Feature<Point>}
+     * @return {[Feature<Point>]}
+     * @private
+     */
+     calculatePath(startPoint, endPoint) {
         this.clearData();
 
         this.nbLines = [];
@@ -927,7 +951,7 @@ export class Wayfinding {
         fixedStartPoint.properties.fscore = this._heuristic(fixedStartPoint, fixedEndPoint);
 
         while (openSet.length > 0) {
-            let current = this._getMinFScore(openSet);
+            let current = this._getMinFScore(openSet, closedSet);
 
             // Unable to find best point to continue?
             if (current === null) {
@@ -936,10 +960,11 @@ export class Wayfinding {
 
             if (current === fixedEndPoint) {
                 let finalPath = this.reconstructPath(current);
-                if (fixedEndPoint !== endPoint && endPoint.properties.levels !== undefined && (!fixedEndPoint.properties.onCorridor || this._distance(fixedEndPoint, endPoint) > this.pathFixDistance)) {
+                if (fixedEndPoint !== endPoint && (!fixedEndPoint.properties.onCorridor || this._distance(fixedEndPoint, endPoint) > this.pathFixDistance)) {
                     endPoint.properties.fixed = true
                     finalPath.push(endPoint);
                 }
+
                 if (fixedStartPoint !== startPoint && (!fixedStartPoint.properties.onCorridor || this._distance(fixedStartPoint, startPoint) > this.pathFixDistance)) {
                     startPoint.properties.fixed = true
                     finalPath.unshift(startPoint);
@@ -953,26 +978,45 @@ export class Wayfinding {
 
             neighbours.forEach(n => this.nbLines.push(turf.lineString([current.geometry.coordinates, n.geometry.coordinates])));
 
-            for (let nIndex in neighbours) {
-                let neighbour = neighbours[nIndex];
-                if (closedSet.indexOf(neighbour) > -1) {
-                    continue;
-                }
-
-                let tentativeGScore = current.properties.gscore + this._distance(current, neighbour);
-                let gScoreNeighbour = neighbour.properties.gscore != null ? neighbour.properties.gscore : Infinity;
-                if (tentativeGScore < gScoreNeighbour) {
-                    neighbour.properties.cameFrom = current;
-                    neighbour.properties.gscore = tentativeGScore + 0.2;
-                    neighbour.properties.fscore = tentativeGScore + this._heuristic(neighbour, fixedEndPoint);
-                    if (openSet.indexOf(neighbour) < 0) {
-                        openSet.push(neighbour);
+            neighbours.forEach( neighbour => {
+                if (closedSet.indexOf(neighbour) <= -1) {
+                    let tentativeGScore = current.properties.gscore + this._distance(current, neighbour);
+                    let gScoreNeighbour = neighbour.properties.gscore != null ? neighbour.properties.gscore : Infinity;
+
+                    if (tentativeGScore < gScoreNeighbour) {
+                        neighbour.properties.cameFrom = current;
+                        neighbour.properties.gscore = tentativeGScore + 0.2;
+                        neighbour.properties.fscore = tentativeGScore + this._heuristic(neighbour, fixedEndPoint);
+                        if (openSet.indexOf(neighbour) < 0) {
+                            openSet.push(neighbour);
+                        }
                     }
                 }
+            });
+        }
+        return undefined;
+    }
+
+    _checkIfCrossingTwoPolygon(current, neighbour) {
+        const last = current.properties || {};
+        const candidate = neighbour.properties || {};
+
+        if(candidate.walkableAreaId !== undefined && last.walkableAreaId !== undefined) {
+            if (candidate.walkableAreaId !== last.walkableAreaId) {
+                return true;
+            }
 
+            if (candidate.bordersArea === undefined) {
+                return true;
             }
         }
-        return undefined;
+
+        if(last.walkableAreaId !== undefined && candidate.walkableAreaId === undefined) {
+            if (candidate.isCorridorPoint === true) { return false; }
+            return true;
+        }
+
+        return false;
     }
 
     /**
@@ -992,7 +1036,9 @@ export class Wayfinding {
                 let level = point.properties.level;
                 let revolvingDoorBlock = this.configuration.avoidRevolvingDoors && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
                 let ticketGateBlock = this.configuration.avoidTicketGates && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
-                return !revolvingDoorBlock && !ticketGateBlock;
+                const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, neighbourPoint);
+
+                return !revolvingDoorBlock && !ticketGateBlock && !isCrossingTwoPolygon;
             });
         } else {
             // Gather neighbours over all levels
@@ -1003,12 +1049,13 @@ export class Wayfinding {
                     let levelNeighbourMap = this.neighbourMap[level];
                     if (levelNeighbourMap.hasOwnProperty(pointIndex)) {
                         levelNeighbourMap[pointIndex].forEach(neighbourIndex => {
-                            let neighbourPoint = points[neighbourIndex];
+                            const neighbourPoint = points[neighbourIndex];
 
-                            let revolvingDoorBlock = this.configuration.avoidRevolvingDoors && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
-                            let ticketGateBlock = this.configuration.avoidTicketGates && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
+                            const revolvingDoorBlock = this.configuration.avoidRevolvingDoors && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
+                            const ticketGateBlock = this.configuration.avoidTicketGates && this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
+                            const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, neighbourPoint);
                             
-                            if (!neighbours.includes(neighbourPoint) && (!revolvingDoorBlock && !ticketGateBlock)) {
+                            if (!neighbours.includes(neighbourPoint) && (!revolvingDoorBlock && !ticketGateBlock) && !isCrossingTwoPolygon) {
                                 neighbours.push(neighbourPoint);
                             }
                         });
@@ -1022,10 +1069,11 @@ export class Wayfinding {
                 || (point.properties.fixedPointMap != undefined && point.properties.fixedPointMap.has(endPoint.properties.level))
             ) {
 
-                let revolvingDoorBlock = this.configuration.avoidRevolvingDoors && this._testAccessibilityPoiNeighbourhood(point, endPoint, endPoint.properties.level, this.POI_TYPE.REVOLVING_DOOR);
-                let ticketGateBlock = this.configuration.avoidTicketGates && this._testAccessibilityPoiNeighbourhood(point, endPoint, endPoint.properties.level, this.POI_TYPE.TICKET_GATE);
+                const revolvingDoorBlock = this.configuration.avoidRevolvingDoors && this._testAccessibilityPoiNeighbourhood(point, endPoint, endPoint.properties.level, this.POI_TYPE.REVOLVING_DOOR);
+                const ticketGateBlock = this.configuration.avoidTicketGates && this._testAccessibilityPoiNeighbourhood(point, endPoint, endPoint.properties.level, this.POI_TYPE.TICKET_GATE);
+                const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, endPoint);
 
-                if (!revolvingDoorBlock && !ticketGateBlock) {
+                if (!revolvingDoorBlock && !ticketGateBlock && !isCrossingTwoPolygon) {
 
                     // Endpoint is fixed on corridor
                     if (endPoint.properties.onCorridor) {
@@ -1066,6 +1114,7 @@ export class Wayfinding {
             } else if (this.configuration.avoidHills && neighbour.properties.hill) {
                 return false;
             }
+
             return true;
         });
     }
@@ -1352,14 +1401,7 @@ export class Wayfinding {
     }
 
     _testIdenticalPointInList(point, pointList) {
-        let pointCoordinates = point.geometry.coordinates;
-        for (let index in pointList) {
-            let proposedPointCoordinates = pointList[index].geometry.coordinates;
-            if (proposedPointCoordinates[0] === pointCoordinates[0] && proposedPointCoordinates[1] === pointCoordinates[1]) {
-                return true;
-            }
-        }
-        return false;
+        return pointList.find((list) => list.geometry.coordinates[0] === point.geometry.coordinates[0] && list.geometry.coordinates[1] === point.geometry.coordinates[1]) !== undefined
     }
 
     /**
@@ -1367,16 +1409,24 @@ export class Wayfinding {
      * @param pointSet {[Feature<Point>]}
      * @returns {Feature<Point>}
      */
-    _getMinFScore(pointSet) {
+    _getMinFScore(pointSet, previous) {
         let bestPoint = null;
         let bestScore = Infinity;
-        for (let index in pointSet) {
-            let point = pointSet[index];
-            if (point.properties.fscore < bestScore) {
+
+        const lastWalkableAreaId = (previous.slice(-1).properties || {}).walkableAreaId;
+        const penultimateWalkableAreaId = (previous.slice(-2).properties || {}).walkableAreaId;
+
+        const closedWalkable = penultimateWalkableAreaId !== undefined && lastWalkableAreaId === penultimateWalkableAreaId;
+
+        pointSet.forEach(point => {
+            const properties = point.properties;
+
+            if (properties.fscore < bestScore) {//} && (closedWalkable || (!closedWalkable && properties.walkableAreaId === lastWalkableAreaId))) {
                 bestPoint = point;
-                bestScore = point.properties.fscore;
+                bestScore = properties.fscore;    
+
             }
-        }
+        });
         return bestPoint;
     }
 
@@ -1434,12 +1484,10 @@ export class Wayfinding {
      * @private
      */
     _getFixEndPoint(endPoint, startPointLevel) {
-        // LC
         let lc = this.levelChangerList.find(it => it.id === endPoint.id);
-        // if (lc !== undefined) return lc;
         if (lc !== undefined && lc.properties.fixedPointMap !== undefined) {
             let nearestLevel = undefined;
-            lc.properties.fixedPointMap.forEach((fixedPoint, level) => {
+            lc.properties.fixedPointMap.forEach((_, level) => {
                 if (nearestLevel === undefined || Math.abs(nearestLevel - startPointLevel) > Math.abs(level - startPointLevel)) {
                     nearestLevel = level;
                 }
@@ -1454,20 +1502,25 @@ export class Wayfinding {
         let floorData = this.floorData.get(point.properties.level);
 
         // If point is located without accessible area, do nothing
-        let areaList  = floorData.areas;
-        for (let index in areaList) {
-            let polygon = areaList[index];
+        let pointFound = undefined;
+        floorData.areas.forEach(polygon => {
             if (turf.booleanContains(polygon, point)) {
-                return point;
+                pointFound = point;
+                return;
             }
+        });
+        if (pointFound !== undefined) {
+            return pointFound;
         }
 
+
         // Find nearest wall to stick to
         let bestWall = null;
         let bestWallDistance = Infinity;
+
         floorData.wallFeatures.forEach(wall => {
-            let distance = turf.pointToLineDistance(point.geometry.coordinates, wall, {units: this.UNIT_TYPE});
-            if (distance < bestWallDistance) {
+            let distance = turf.pointToLineDistance(point.geometry.coordinates, wall, { units: this.UNIT_TYPE });
+            if (distance <= bestWallDistance) {
                 bestWall = wall;
                 bestWallDistance = distance;
             }
@@ -1545,7 +1598,6 @@ export class Wayfinding {
 
             // Return created point
             return fixedPoint;
-
         }
     }
 

package/lib/components/map/main.d.ts

@@ -84,6 +84,7 @@ interface Options {
     };
     language?: string;
     routeColor?: string;
+    forceFloorLevel?: number;
 }
 interface PaddingOptions {
     bottom: number;
@@ -135,6 +136,7 @@ export declare class Map {
     private onSetKiosk;
     private initGeoLocation;
     private initDirectionIcon;
+    private onSetFeaturesHighlight;
     private initAnimatedRoute;
     private initRasterTiles;
     private initPolygons;
@@ -833,5 +835,21 @@ export declare class Map {
      *  });
      */
     toggleRasterFloorplans(): void;
+    /**
+     * Method for adding circle layer as a highlight for defined features
+     *  @memberof Map
+     *  @name setFeaturesHighlight
+     *  @param features {string[]} feature id to set highlight on, you can send empty array to remove highlights.
+     *  @param color {string} highlight color, optional.
+     *  @param radius {number} highlight circle radius, optional.
+     *  @param blur {number} blur of the highlight circle, optional.
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.setFeaturesHighlight(['featureid']);
+     *  });
+     */
+    setFeaturesHighlight(features: string[], color?: string, radius?: number, blur?: number): void;
 }
 export {};

package/lib/components/map/main.js

@@ -331,7 +331,7 @@ var Map = /** @class */ (function () {
                         }
                         routingSymbolsLayer = map.getLayer('proximiio-routing-symbols');
                         if (routingSymbolsLayer) {
-                            routingSymbolsLayer.filter.push(['!=', ['get', 'type'], 'poi-custom']);
+                            routingSymbolsLayer.filter.push(['match', ['get', 'type'], ['poi', 'poi-custom'], false, true]);
                             this.state.style.getLayer('proximiio-routing-symbols').filter = routingSymbolsLayer.filter;
                             map.setFilter('proximiio-routing-symbols', routingSymbolsLayer.filter);
                         }
@@ -525,6 +525,52 @@ var Map = /** @class */ (function () {
             });
         }
     };
+    Map.prototype.onSetFeaturesHighlight = function (features, color, radius, blur) {
+        var map = this.map;
+        var featuresToHiglight = this.state.allFeatures.features.filter(function (f) {
+            return features.includes(f.id || f.properties.id);
+        });
+        var poisIconsLayer = this.map.getLayer('proximiio-pois-icons');
+        var poisIconsImageSize = this.map.getLayoutProperty('proximiio-pois-icons', 'icon-size');
+        if (map) {
+            if (!map.getLayer('highlight-icon-layer')) {
+                this.state.style.addLayer({
+                    id: 'highlight-icon-layer',
+                    type: 'circle',
+                    source: 'highlight-icon-source',
+                    minzoom: poisIconsLayer.minzoom,
+                    maxzoom: poisIconsLayer.maxzoom,
+                    paint: {
+                        'circle-radius': poisIconsImageSize[0] === 'interpolate'
+                            ? [
+                                poisIconsImageSize[0],
+                                poisIconsImageSize[1],
+                                poisIconsImageSize[2],
+                                poisIconsImageSize[3],
+                                poisIconsImageSize[4] * (radius ? radius : 50),
+                                poisIconsImageSize[5],
+                                poisIconsImageSize[6] * (radius ? radius : 50),
+                            ]
+                            : radius,
+                        'circle-color': color ? color : '#000',
+                        'circle-blur': blur !== null && blur !== undefined ? blur : 0.8,
+                    },
+                    filter: ['all', ['==', ['to-number', ['get', 'level']], this.state.floor.level]],
+                }, this.defaultOptions.initPolygons ? 'shop-custom' : 'proximiio-shop');
+            }
+            if (!map.getSource('highlight-icon-source')) {
+                this.state.style.addSource('highlight-icon-source', {
+                    type: 'geojson',
+                    data: {
+                        type: 'FeatureCollection',
+                        features: [],
+                    },
+                });
+            }
+            this.state.style.sources['highlight-icon-source'].data.features = featuresToHiglight ? featuresToHiglight : [];
+            this.map.setStyle(this.state.style);
+        }
+    };
     Map.prototype.initAnimatedRoute = function () {
         if (this.map) {
             this.state.style.addSource('route-point', {
@@ -586,7 +632,7 @@ var Map = /** @class */ (function () {
                 ? this.defaultOptions.rasterTilesOptions.beforeLayer
                 : metadata['proximiio:raster:beforelayer']
                     ? metadata['proximiio:raster:beforelayer']
-                    : 'proximiio-shop');
+                    : 'osm-country_label-en');
         }
     };
     Map.prototype.initPolygons = function () {
@@ -1302,6 +1348,7 @@ var Map = /** @class */ (function () {
     Map.prototype.onRouteChange = function (event) {
         return __awaiter(this, void 0, void 0, function () {
             var routeStart, textNavigation, logger, style;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1320,6 +1367,14 @@ var Map = /** @class */ (function () {
                         if (this.defaultOptions.animatedRoute) {
                             this.addAnimatedRouteFeatures();
                         }
+                        if (this.defaultOptions.forceFloorLevel !== null && this.defaultOptions.forceFloorLevel !== undefined) {
+                            this.routingSource.data.features = this.routingSource.data.features.map(function (feature) {
+                                if (feature.properties.level !== _this.defaultOptions.forceFloorLevel) {
+                                    feature.properties.level = _this.defaultOptions.forceFloorLevel;
+                                }
+                                return feature;
+                            });
+                        }
                         this.centerOnRoute(routeStart);
                         this.onRouteFoundListener.next({
                             route: this.routingSource.route,
@@ -1574,6 +1629,11 @@ var Map = /** @class */ (function () {
                 map.setFilter('route-point', filter);
                 this.state.style.getLayer('route-point').filter = filter;
             }
+            if (map.getLayer('highlight-icon-layer')) {
+                var filter = ['all', ['==', ['to-number', ['get', 'level']], floor.level]];
+                map.setFilter('highlight-icon-layer', filter);
+                this.state.style.getLayer('highlight-icon-layer').filter = filter;
+            }
         }
         this.state = __assign(__assign({}, this.state), { floor: floor, style: this.state.style });
         this.updateCluster();
@@ -2655,6 +2715,24 @@ var Map = /** @class */ (function () {
     Map.prototype.toggleRasterFloorplans = function () {
         this.onToggleRasterFloorplans();
     };
+    /**
+     * Method for adding circle layer as a highlight for defined features
+     *  @memberof Map
+     *  @name setFeaturesHighlight
+     *  @param features {string[]} feature id to set highlight on, you can send empty array to remove highlights.
+     *  @param color {string} highlight color, optional.
+     *  @param radius {number} highlight circle radius, optional.
+     *  @param blur {number} blur of the highlight circle, optional.
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.setFeaturesHighlight(['featureid']);
+     *  });
+     */
+    Map.prototype.setFeaturesHighlight = function (features, color, radius, blur) {
+        this.onSetFeaturesHighlight(features, color, radius, blur);
+    };
     return Map;
 }());
 exports.Map = Map;