proximiio-js-library 1.13.13 → 1.13.15

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

@@ -4,9 +4,20 @@ export default class GuidanceStepsGenerator {
     points: Feature[];
     steps: GuidanceStep[];
     language: string;
-    constructor(points: Feature[], language: string);
+    landMarkNav: boolean;
+    pois?: Feature[];
+    levelChangers?: Feature[];
+    constructor({ points, language, landMarkNav, pois, levelChangers, }: {
+        points: Feature[];
+        language: string;
+        landMarkNav: boolean;
+        pois?: Feature[];
+        levelChangers?: Feature[];
+    });
+    private capitalize;
     private generateStepsFromPoints;
     private generateInstruction;
+    private getDirectionInstruction;
     private getBearingFromLastStep;
     private getStepDirection;
     private getDistanceFromLastStep;

package/lib/components/map/guidanceStepsGenerator.js

@@ -3,6 +3,7 @@ import bearing from '@turf/bearing';
 import distance from '@turf/distance';
 import { lineString } from '@turf/helpers';
 import { translations } from './i18n';
+import nearestPoint from '@turf/nearest-point';
 var Direction;
 (function (Direction) {
     Direction["Start"] = "START";
@@ -39,9 +40,15 @@ var LevelChangerTypes;
     LevelChangerTypes["ramp"] = "RAMP";
 })(LevelChangerTypes || (LevelChangerTypes = {}));
 export default class GuidanceStepsGenerator {
-    constructor(points, language) {
+    constructor({ points, language, landMarkNav, pois, levelChangers, }) {
+        this.capitalize = (s) => s && String(s[0]).toUpperCase() + String(s).slice(1);
         this.points = points;
         this.language = language;
+        if (landMarkNav) {
+            this.landMarkNav = landMarkNav;
+            this.pois = pois;
+            this.levelChangers = levelChangers;
+        }
         if (this.points && this.points.length > 0) {
             this.generateStepsFromPoints();
         }
@@ -51,18 +58,37 @@ export default class GuidanceStepsGenerator {
             const previousPoint = this.points[index - 1] ? new Feature(this.points[index - 1]) : null;
             const currentPoint = new Feature(point);
             const nextPoint = this.points[index + 1] ? new Feature(this.points[index + 1]) : null;
+            const secondNextPoint = this.points[index + 2] ? new Feature(this.points[index + 2]) : null;
             const data = {
                 previousPoint,
                 currentPoint,
                 nextPoint,
+                secondNextPoint,
             };
             const direction = this.getStepDirection(data);
+            const nextStepDirection = this.getStepDirection({
+                previousPoint: currentPoint,
+                currentPoint: nextPoint,
+                nextPoint: secondNextPoint,
+            });
             const distanceFromLastStep = this.getDistanceFromLastStep(data);
             const extendedData = Object.assign(Object.assign({}, data), { direction, distanceFromLastStep });
+            if (this.landMarkNav &&
+                (direction === Direction.Start ||
+                    direction === Direction.Finish ||
+                    direction === Direction.TurnAround ||
+                    direction === `${Direction.Exit}_${LevelChangerTypes[currentPoint.properties.type]}` ||
+                    distanceFromLastStep === 0)) {
+                return;
+            }
             return {
                 bearingFromLastStep: this.getBearingFromLastStep(data),
                 coordinates: [point.geometry.coordinates[0], point.geometry.coordinates[1]],
-                direction,
+                direction: this.landMarkNav
+                    ? nextStepDirection === Direction.Finish
+                        ? Direction.Finish
+                        : direction
+                    : direction,
                 distanceFromLastStep,
                 level: point.properties.level,
                 levelChangerId: currentPoint.isLevelChanger ? currentPoint.id : null,
@@ -76,83 +102,98 @@ export default class GuidanceStepsGenerator {
             };
         });
     }
-    generateInstruction({ previousPoint, currentPoint, nextPoint, direction, distanceFromLastStep, }) {
+    generateInstruction({ previousPoint, currentPoint, nextPoint, secondNextPoint, direction, distanceFromLastStep, }) {
         let instruction = '';
+        if (previousPoint.isLevelChanger) {
+            const levelChangerFeature = this.levelChangers.find((f) => f.id === previousPoint.id);
+            const levelChangeDirection = this.getStepDirection({
+                previousPoint: levelChangerFeature,
+                currentPoint: previousPoint,
+                nextPoint: currentPoint,
+                levelChangerDirection: true,
+            });
+            instruction += `${this.capitalize(this.getDirectionInstruction(levelChangeDirection))} `;
+        }
         if (distanceFromLastStep > 0) {
-            instruction += `${translations[this.language].IN} ${distanceFromLastStep.toFixed(0)} ${translations[this.language].METERS} `;
+            instruction += `${this.capitalize(translations[this.language].IN)} ${distanceFromLastStep.toFixed(0)} ${translations[this.language].METERS} `;
+        }
+        if (direction === Direction.TurnAround || direction === Direction.Start || direction === Direction.Finish) {
+            instruction += this.getDirectionInstruction(direction);
+            return instruction;
+        }
+        if (this.landMarkNav) {
+            const featureCollection = {
+                type: 'FeatureCollection',
+                features: this.pois.filter((f) => f.properties.level === currentPoint.properties.level),
+            };
+            const nextPointDirection = this.getStepDirection({
+                previousPoint: currentPoint,
+                currentPoint: nextPoint,
+                nextPoint: secondNextPoint,
+            });
+            if (nextPointDirection === Direction.Finish) {
+                instruction += `${translations[this.language].DESTINATION} ${nextPoint.properties.title_i18n && nextPoint.properties.title_i18n[this.language]
+                    ? nextPoint.properties.title_i18n[this.language]
+                    : nextPoint.properties.title} ${translations[this.language].IS_ON_YOUR} ${this.getDirectionInstruction(direction).replace('turn ', '')}`;
+                return instruction;
+            }
+            instruction += this.getDirectionInstruction(direction);
+            const nearestPoi = nearestPoint(currentPoint.geometry.coordinates, featureCollection);
+            instruction = `${instruction.slice(0, -1)} ${translations[this.language].BY} ${nearestPoi.properties.title_i18n && nearestPoi.properties.title_i18n[this.language]
+                ? nearestPoi.properties.title_i18n[this.language]
+                : nearestPoi.properties.title}`;
         }
+        return instruction;
+    }
+    getDirectionInstruction(direction) {
         switch (direction) {
             case Direction.Start:
-                instruction += translations[this.language].START;
-                break;
+                return translations[this.language].START;
             case Direction.Finish:
-                instruction += translations[this.language].DESTINATION;
-                break;
+                return translations[this.language].DESTINATION;
             case Direction.Straight:
-                instruction += translations[this.language].STRAIGHT;
-                break;
+                return translations[this.language].STRAIGHT;
             case Direction.TurnAround:
-                instruction += translations[this.language].TURN_AROUND;
-                break;
+                return translations[this.language].TURN_AROUND;
             case Direction.HardLeft:
-                instruction += translations[this.language].HARD_LEFT;
-                break;
+                return translations[this.language].HARD_LEFT;
             case Direction.SlightLeft:
-                instruction += translations[this.language].SLIGHT_LEFT;
-                break;
+                return translations[this.language].SLIGHT_LEFT;
             case Direction.Left:
-                instruction += translations[this.language].LEFT;
-                break;
+                return translations[this.language].LEFT;
             case Direction.HardRight:
-                instruction += translations[this.language].HARD_RIGHT;
-                break;
+                return translations[this.language].HARD_RIGHT;
             case Direction.SlightRight:
-                instruction += translations[this.language].SLIGHT_RIGHT;
-                break;
+                return translations[this.language].SLIGHT_RIGHT;
             case Direction.Right:
-                instruction += translations[this.language].RIGHT;
-                break;
+                return translations[this.language].RIGHT;
             case Direction.UpStaircase:
-                instruction += translations[this.language].UP_STAIRCASE;
-                break;
+                return translations[this.language].UP_STAIRCASE;
             case Direction.UpEscalator:
-                instruction += translations[this.language].UP_ESCALATOR;
-                break;
+                return translations[this.language].UP_ESCALATOR;
             case Direction.UpElevator:
-                instruction += translations[this.language].UP_ELEVATOR;
-                break;
+                return translations[this.language].UP_ELEVATOR;
             case Direction.UpRamp:
-                instruction += translations[this.language].UP_RAMP;
-                break;
+                return translations[this.language].UP_RAMP;
             case Direction.DownStaircase:
-                instruction += translations[this.language].DOWN_STAIRCASE;
-                break;
+                return translations[this.language].DOWN_STAIRCASE;
             case Direction.DownEscalator:
-                instruction += translations[this.language].DOWN_ESCALATOR;
-                break;
+                return translations[this.language].DOWN_ESCALATOR;
             case Direction.DownElevator:
-                instruction += translations[this.language].DOWN_ELEVATOR;
-                break;
+                return translations[this.language].DOWN_ELEVATOR;
             case Direction.DownRamp:
-                instruction += translations[this.language].DOWN_RAMP;
-                break;
+                return translations[this.language].DOWN_RAMP;
             case Direction.ExitStaircase:
-                instruction += translations[this.language].EXIT_STAIRCASE;
-                break;
+                return translations[this.language].EXIT_STAIRCASE;
             case Direction.ExitEscalator:
-                instruction += translations[this.language].EXIT_ESCALATOR;
-                break;
+                return translations[this.language].EXIT_ESCALATOR;
             case Direction.ExitElevator:
-                instruction += translations[this.language].EXIT_ELEVATOR;
-                break;
+                return translations[this.language].EXIT_ELEVATOR;
             case Direction.ExitRamp:
-                instruction += translations[this.language].EXIT_RAMP;
-                break;
+                return translations[this.language].EXIT_RAMP;
             default:
-                instruction += translations[this.language].CONTINUE;
-                break;
+                return translations[this.language].CONTINUE;
         }
-        return instruction;
     }
     getBearingFromLastStep({ previousPoint, currentPoint, nextPoint, }) {
         if (!previousPoint) {
@@ -161,24 +202,26 @@ export default class GuidanceStepsGenerator {
         const bearingVar = bearing(previousPoint.geometry.coordinates, currentPoint.geometry.coordinates);
         return bearingVar;
     }
-    getStepDirection({ previousPoint, currentPoint, nextPoint, }) {
-        if (!previousPoint) {
-            return Direction.Start;
-        }
-        if (!nextPoint) {
-            return Direction.Finish;
-        }
-        if (currentPoint.isPoi && nextPoint.isPoi && currentPoint.id === nextPoint.id) {
-            return Direction.Finish;
-        }
-        if (currentPoint.isLevelChanger && nextPoint.properties.level > currentPoint.properties.level) {
-            return `${Direction.Up}_${LevelChangerTypes[currentPoint.properties.type]}`;
-        }
-        if (currentPoint.isLevelChanger && nextPoint.properties.level < currentPoint.properties.level) {
-            return `${Direction.Down}_${LevelChangerTypes[currentPoint.properties.type]}`;
-        }
-        if (previousPoint.isLevelChanger && currentPoint.isLevelChanger) {
-            return `${Direction.Exit}_${LevelChangerTypes[currentPoint.properties.type]}`;
+    getStepDirection({ previousPoint, currentPoint, nextPoint, levelChangerDirection = false, }) {
+        if (!levelChangerDirection) {
+            if (!previousPoint) {
+                return Direction.Start;
+            }
+            if (!nextPoint) {
+                return Direction.Finish;
+            }
+            if (currentPoint.isPoi && nextPoint.isPoi && currentPoint.id === nextPoint.id) {
+                return Direction.Finish;
+            }
+            if (currentPoint.isLevelChanger && nextPoint.properties.level > currentPoint.properties.level) {
+                return `${Direction.Up}_${LevelChangerTypes[currentPoint.properties.type]}`;
+            }
+            if (currentPoint.isLevelChanger && nextPoint.properties.level < currentPoint.properties.level) {
+                return `${Direction.Down}_${LevelChangerTypes[currentPoint.properties.type]}`;
+            }
+            if (previousPoint.isLevelChanger && currentPoint.isLevelChanger) {
+                return `${Direction.Exit}_${LevelChangerTypes[currentPoint.properties.type]}`;
+            }
         }
         const bearingVar = bearing(currentPoint.geometry.coordinates, nextPoint.geometry.coordinates) -
             bearing(previousPoint.geometry.coordinates, currentPoint.geometry.coordinates);

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

@@ -35,6 +35,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     fi: {
         ELEVATOR: string;
@@ -72,6 +74,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     ar: {
         ELEVATOR: string;
@@ -109,6 +113,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     it: {
         ELEVATOR: string;
@@ -146,6 +152,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     id: {
         ELEVATOR: string;
@@ -183,6 +191,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     zh: {
         ELEVATOR: string;
@@ -220,6 +230,8 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
     ru: {
         ELEVATOR: string;
@@ -257,5 +269,7 @@ export declare const translations: {
         CONTINUE: string;
         TO: string;
         FLOOR: string;
+        BY: string;
+        IS_ON_YOUR: string;
     };
 };

package/lib/components/map/i18n.js

@@ -35,6 +35,8 @@ export const translations = {
         CONTINUE: 'continue.',
         TO: 'to',
         FLOOR: 'floor',
+        BY: 'by',
+        IS_ON_YOUR: 'is on your',
     },
     fi: {
         ELEVATOR: 'Hissi',
@@ -72,6 +74,8 @@ export const translations = {
         CONTINUE: 'jatka.',
         TO: 'osoitteeseen',
         FLOOR: 'lattia',
+        BY: 'liikkeellä',
+        IS_ON_YOUR: 'on sinun',
     },
     ar: {
         ELEVATOR: 'المصعد',
@@ -109,6 +113,8 @@ export const translations = {
         CONTINUE: 'تابع.',
         TO: 'إلى',
         FLOOR: 'الطابق',
+        BY: 'بواسطة',
+        IS_ON_YOUR: 'في',
     },
     it: {
         ELEVATOR: 'Ascensore',
@@ -146,6 +152,8 @@ export const translations = {
         CONTINUE: 'continua.',
         TO: 'al',
         FLOOR: 'piano',
+        BY: 'per',
+        IS_ON_YOUR: 'su',
     },
     id: {
         ELEVATOR: 'Lift',
@@ -183,6 +191,8 @@ export const translations = {
         CONTINUE: 'lanjutkan.',
         TO: 'ke',
         FLOOR: 'lantai',
+        BY: 'oleh',
+        IS_ON_YOUR: 'di',
     },
     zh: {
         ELEVATOR: '电梯',
@@ -220,6 +230,8 @@ export const translations = {
         CONTINUE: '继续',
         TO: '到 ',
         FLOOR: '楼层',
+        BY: '通过',
+        IS_ON_YOUR: '在',
     },
     ru: {
         ELEVATOR: 'Лифт',
@@ -257,5 +269,7 @@ export const translations = {
         CONTINUE: 'продолжать',
         TO: 'к',
         FLOOR: 'пол',
+        BY: 'по',
+        IS_ON_YOUR: 'на',
     },
 };

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

@@ -82,6 +82,7 @@ export interface Options {
     allowNewFeatureModal?: boolean;
     newFeatureModalEvent?: string;
     enableTBTNavigation?: boolean;
+    landmarkTBTNavigation?: boolean;
     mapboxOptions?: MapboxOptions;
     zoomIntoPlace?: boolean;
     defaultPlaceId?: string;
@@ -142,6 +143,7 @@ export interface Options {
         cityPointIconUrl?: string;
         cityRouteMaxDuration?: number;
         autoStart?: boolean;
+        autoContinue?: boolean;
     };
     useRasterTiles?: boolean;
     rasterTilesOptions?: {

package/lib/components/map/main.js

@@ -96,6 +96,7 @@ export class Map {
             allowNewFeatureModal: false,
             newFeatureModalEvent: 'click',
             enableTBTNavigation: true,
+            landmarkTBTNavigation: false,
             zoomIntoPlace: true,
             defaultFloorLevel: 0,
             isKiosk: false,
@@ -200,6 +201,7 @@ export class Map {
                 cityRouteSpeedMultiplier: 5,
                 cityRouteMaxDuration: 5,
                 autoStart: true,
+                autoContinue: true,
             },
             useRasterTiles: false,
             handleUrlParams: false,
@@ -504,6 +506,11 @@ export class Map {
                 if (this.defaultOptions.routeWithDetails !== null && this.defaultOptions.routeWithDetails !== undefined) {
                     this.routingSource.routing.routeWithDetails = this.defaultOptions.routeWithDetails;
                 }
+                if (this.defaultOptions.landmarkTBTNavigation) {
+                    this.routingSource.setLandmarkTBT(this.defaultOptions.landmarkTBTNavigation);
+                    this.routingSource.setPois(optimizedFeatures.features.filter((f) => f.geometry.coordinates && f.geometry.type === 'Point' && f.properties.type === 'poi'));
+                    this.routingSource.setLevelChangers(levelChangers);
+                }
                 this.geojsonSource.fetch(optimizedFeatures);
                 this.routingSource.routing.setData(new FeatureCollection(features));
                 this.prepareStyle(style);
@@ -1949,7 +1956,7 @@ export class Map {
                 this.filterOutFeatures();
             }
             if (!isTemporary) {
-                this.state.features.features.push(featureVar);
+                this.state.optimizedFeatures.features.push(featureVar);
                 yield addFeatures({
                     type: 'FeatureCollection',
                     features: [featureVar.json],
@@ -1989,18 +1996,18 @@ export class Map {
                 this.filterOutFeatures();
             }
             if (!isTemporary) {
-                const featureIndex = this.state.features.features.findIndex((x) => x.id === featureVar.id || x.properties.id === featureVar.id);
-                this.state.features.features[featureIndex] = featureVar;
+                const featureIndex = this.state.optimizedFeatures.features.findIndex((x) => x.id === featureVar.id || x.properties.id === featureVar.id);
+                this.state.optimizedFeatures.features[featureIndex] = featureVar;
                 yield addFeatures({
                     type: 'FeatureCollection',
                     features: [featureVar.json],
                 });
             }
             else {
-                const featureIndex = this.state.features.features.findIndex((x) => x.id === featureVar.id || x.properties.id === featureVar.id);
+                const featureIndex = this.state.optimizedFeatures.features.findIndex((x) => x.id === featureVar.id || x.properties.id === featureVar.id);
                 const dynamicIndex = this.state.dynamicFeatures.features.findIndex((x) => x.id === featureVar.id || x.properties.id === featureVar.id);
                 if (featureIndex)
-                    this.state.features.features[featureIndex] = featureVar;
+                    this.state.optimizedFeatures.features[featureIndex] = featureVar;
                 if (dynamicIndex)
                     this.state.dynamicFeatures.features[dynamicIndex] = featureVar;
             }
@@ -2022,8 +2029,8 @@ export class Map {
                 throw new Error(`Deleting feature failed: Feature with id '${id}' has not been found!`);
             }
             if (!isTemporary) {
-                const featureIndex = this.state.features.features.findIndex((x) => x.id === id || x.properties.id === id);
-                this.state.features.features.splice(featureIndex, 1);
+                const featureIndex = this.state.optimizedFeatures.features.findIndex((x) => x.id === id || x.properties.id === id);
+                this.state.optimizedFeatures.features.splice(featureIndex, 1);
                 yield deleteFeatures({
                     type: 'FeatureCollection',
                     features: [foundFeature],
@@ -2988,6 +2995,8 @@ export class Map {
         this.removeStopMarkers();
         this.routingSource.cancel();
         this.onRouteCancelListener.next('route cancelled');
+        this.currentStep = 0;
+        this.currentStop = 0;
     }
     centerOnPoi(poi) {
         if (this.state.floor.level !== parseInt(poi.properties.level, 0)) {
@@ -3142,8 +3151,9 @@ export class Map {
                 ? this.routingSource.route[`path-part-${this.currentStep}`]
                 : lineString(this.routingSource.levelPoints[this.state.floor.level].map((i) => i.geometry.coordinates), { level: this.state.floor.level });
             let routeUntilNextStep;
-            if (this.routingSource.navigationType === 'city') {
+            if (this.routingSource.navigationType === 'city' || this.defaultOptions.landmarkTBTNavigation) {
                 const routePoints = this.routingSource.lines
+                    .filter((i) => i.properties.level === this.state.floor.level)
                     .map((i, index) => {
                     if (index > this.currentStep) {
                         return null;
@@ -3192,8 +3202,11 @@ export class Map {
                                 return;
                             }
                             setTimeout(() => {
-                                this.setNavStep('next');
-                                if (this.defaultOptions.autoRestartAnimationAfterFloorChange) {
+                                if (this.defaultOptions.routeAnimation.autoContinue) {
+                                    this.setNavStep('next');
+                                }
+                                if (this.defaultOptions.autoRestartAnimationAfterFloorChange &&
+                                    !this.defaultOptions.landmarkTBTNavigation) {
                                     this.restartRouteAnimation({ delay: 0, recenter: true });
                                 }
                             }, 2000);
@@ -3205,7 +3218,9 @@ export class Map {
                     // Interpolate the current point along the route
                     const currentPoint = along(route, currentDistance);
                     // cut the line at the point
-                    const lineAlong = lineSplit(this.routingSource.navigationType === 'city' ? routeUntilNextStep : route, currentPoint).features[0];
+                    const lineAlong = lineSplit(this.routingSource.navigationType === 'city' || this.defaultOptions.landmarkTBTNavigation
+                        ? routeUntilNextStep
+                        : route, currentPoint).features[0];
                     // Update the point position
                     // @ts-ignore
                     const pointData = this.map.getSource('pointAlong')._data;
@@ -3976,7 +3991,7 @@ export class Map {
                 this.animateRoute();
             }
             else {
-                if (this.routingSource.isMultipoint) {
+                if (this.routingSource.isMultipoint || this.defaultOptions.enableTBTNavigation) {
                     this.animateRoute();
                 }
                 this.centerOnRoute(this.routingSource.route[`path-part-${newStep}`]);

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

@@ -9,10 +9,11 @@ export default class Routing {
     setData(collection: FeatureCollection): void;
     toggleOnlyAccessible(onlyAccessible: any): void;
     setConfig(config: WayfindingConfigModel): void;
-    route({ start, finish, stops }: {
+    route({ start, finish, stops, landmarkTBT, }: {
         start: Feature;
         finish?: Feature;
         stops?: Feature[];
+        landmarkTBT?: boolean;
     }): {
         paths: any;
         points: any;

package/lib/components/map/routing.js

@@ -60,7 +60,7 @@ export default class Routing {
     setConfig(config) {
         this.wayfinding.setConfiguration(config);
     }
-    route({ start, finish, stops }) {
+    route({ start, finish, stops, landmarkTBT = false, }) {
         const isMultipoint = stops && stops.length > 1;
         let points = null;
         let details = null;
@@ -114,26 +114,53 @@ export default class Routing {
         const pathPoints = {};
         let pathPartIndex = 0;
         points.forEach((p, index) => {
-            var _a;
-            if (this.forceFloorLevel !== null && this.forceFloorLevel !== undefined) {
-                if (typeof pathPoints['path-part-'.concat(pathPartIndex)] === 'undefined') {
-                    pathPoints['path-part-'.concat(pathPartIndex)] = [];
-                }
-                pathPoints['path-part-'.concat(pathPartIndex)].push(p);
-                if (p.isLevelChanger && points[index + 1].isLevelChanger && p.level !== points[index + 1].level) {
-                    pathPartIndex++;
+            var _a, _b, _c;
+            if (landmarkTBT) {
+                if (typeof pathPoints[`path-part-${pathPartIndex}`] === 'undefined') {
+                    if (p.isLevelChanger && p.properties.level !== points[index + 1].properties.level) {
+                        return;
+                    }
+                    else if (p.isPoi && p.id === ((_a = points[index + 1]) === null || _a === void 0 ? void 0 : _a.id)) {
+                        return;
+                    }
+                    else if ((_b = points[index + 1]) === null || _b === void 0 ? void 0 : _b.isPoi) {
+                        // do not add another path part if next poi is finish
+                        return;
+                    }
+                    if (points[index + 1]) {
+                        pathPoints[`path-part-${pathPartIndex}`] = [];
+                        if (points[index + 2] && points[index + 2].isPoi) {
+                            // if second next poi is path destination, add three points to path part as there won't be another path part added
+                            pathPoints[`path-part-${pathPartIndex}`].push(p, points[index + 1], points[index + 2]);
+                        }
+                        else {
+                            pathPoints[`path-part-${pathPartIndex}`].push(p, points[index + 1]);
+                        }
+                        pathPartIndex++;
+                    }
                 }
             }
             else {
-                if (typeof pathPoints[`path-part-${pathPartIndex}`] === 'undefined') {
-                    pathPoints[`path-part-${pathPartIndex}`] = [];
-                }
-                pathPoints[`path-part-${pathPartIndex}`].push(p);
-                if (p.isLevelChanger && p.properties.level !== points[index + 1].properties.level) {
-                    pathPartIndex++;
+                if (this.forceFloorLevel !== null && this.forceFloorLevel !== undefined) {
+                    if (typeof pathPoints['path-part-'.concat(pathPartIndex)] === 'undefined') {
+                        pathPoints['path-part-'.concat(pathPartIndex)] = [];
+                    }
+                    pathPoints['path-part-'.concat(pathPartIndex)].push(p);
+                    if (p.isLevelChanger && points[index + 1].isLevelChanger && p.level !== points[index + 1].level) {
+                        pathPartIndex++;
+                    }
                 }
-                else if (p.isPoi && p.id === ((_a = points[index + 1]) === null || _a === void 0 ? void 0 : _a.id)) {
-                    pathPartIndex++;
+                else {
+                    if (typeof pathPoints[`path-part-${pathPartIndex}`] === 'undefined') {
+                        pathPoints[`path-part-${pathPartIndex}`] = [];
+                    }
+                    pathPoints[`path-part-${pathPartIndex}`].push(p);
+                    if (p.isLevelChanger && p.properties.level !== points[index + 1].properties.level) {
+                        pathPartIndex++;
+                    }
+                    else if (p.isPoi && p.id === ((_c = points[index + 1]) === null || _c === void 0 ? void 0 : _c.id)) {
+                        pathPartIndex++;
+                    }
                 }
             }
         });

package/lib/components/map/sources/routing_source.d.ts

@@ -34,10 +34,16 @@ export default class RoutingSource extends DataSource {
     navigationType: 'mall' | 'city';
     fullPath?: Feature;
     isMultipoint: boolean;
+    landmarkTBT: boolean;
+    pois?: Feature[];
+    levelChangers?: Feature[];
     constructor();
     toggleAccessible(value: any): void;
     setConfig(config: WayfindingConfigModel): void;
     setNavigationType(type: 'mall' | 'city'): void;
+    setLandmarkTBT(value: boolean): void;
+    setPois(pois: Feature[]): void;
+    setLevelChangers(levelChangers: Feature[]): void;
     update({ start, finish, stops, preview, language, }: {
         start?: Feature;
         finish?: Feature;