proximiio-js-library 1.14.55 → 1.15.1

package/README.md

@@ -139,8 +139,9 @@ const map = new Proximiio.Map({
    newFeatureModalEvent: 'click',
 
    // Optional, you'll receive turn-by-turn text navigation object in found route
-   // listener response, default: true
-   enableTBTNavigation: true,
+   // listener response, default: 'full'
+   // possible values: 'disabled', 'simple', 'simple-levelChangers', 'full', 'full-levelChangers', 'landmark', 'landmark-levelChangers';
+   stepsNavigation: 'full',
 
    // Optional, you can pass mapbox initial options like center or zoom here,
    // all options can be found at https://docs.mapbox.com/mapbox-gl-js/api/map/

package/lib/common.d.ts

@@ -1,5 +1,6 @@
 import Feature from './models/feature';
 import { LngLatBoundsLike } from 'maplibre-gl';
+import { FloorModel } from './models/floor';
 export declare const axios: import("axios").AxiosInstance;
 export declare const camelToKebab: (input: string) => string;
 export declare const kebabToCamel: (input: string) => string;
@@ -42,4 +43,8 @@ declare const shortenCoordinates: ({ coords, decimals }: {
 }) => any;
 declare const isLevelChanger: (poi: Feature) => boolean;
 declare const pointInBounds: (point: [number, number], bounds: LngLatBoundsLike) => boolean;
-export { calculateDimensions, convertToRTL, base64toBlob, throttle, filterByAmenity, validateLabelLine, optimizeFeatures, isLevelChanger, pointInBounds, shortenCoordinates, };
+declare const getFloorName: ({ floor, language }: {
+    floor: FloorModel;
+    language: string;
+}) => string;
+export { calculateDimensions, convertToRTL, base64toBlob, throttle, filterByAmenity, validateLabelLine, optimizeFeatures, isLevelChanger, pointInBounds, shortenCoordinates, getFloorName, };

package/lib/common.js

@@ -294,4 +294,15 @@ const pointInBounds = (point, bounds) => {
     const [lng, lat] = point;
     return lng >= minLng && lng <= maxLng && lat >= minLat && lat <= maxLat;
 };
-export { calculateDimensions, convertToRTL, base64toBlob, throttle, filterByAmenity, validateLabelLine, optimizeFeatures, isLevelChanger, pointInBounds, shortenCoordinates, };
+const getFloorName = ({ floor, language }) => {
+    if (floor) {
+        if (floor.metadata && floor.metadata['title_' + language]) {
+            return floor.metadata['title_' + language];
+        }
+        if (floor.name.length === 1 && Number(parseInt(floor.name, 2))) {
+            return `L${floor.name}`;
+        }
+        return floor.name;
+    }
+};
+export { calculateDimensions, convertToRTL, base64toBlob, throttle, filterByAmenity, validateLabelLine, optimizeFeatures, isLevelChanger, pointInBounds, shortenCoordinates, getFloorName, };

package/lib/components/map/getCurrentStep.js

@@ -1,5 +1,6 @@
 import { lineString, point } from '@turf/helpers';
 import pointToLineDistance from '@turf/point-to-line-distance';
+import distance from '@turf/distance';
 /**
  * Find the most appropriate navigation step index based on user's current position.
  *
@@ -16,16 +17,22 @@ const getCurrentStepIndex = ({ userPosition, steps, lastKnownStepIndex = 0, thre
     // Only check steps ahead of current one to avoid regressions
     for (let i = lastKnownStepIndex; i < steps.length; i++) {
         const step = steps[i];
-        if (step.navMode === 'mall' && !step.lineStringFeatureFromLastStep) {
+        const isStartOrLevelChanger = step.direction === 'START' || step.levelChangerId;
+        if (step.navMode === 'mall' && !step.lineStringFeatureFromLastStep && !isStartOrLevelChanger) {
             return;
         }
-        const lineCoords = step.navMode === 'mall' ? step.lineStringFeatureFromLastStep.geometry.coordinates : step.geometry.coordinates;
-        const line = lineString(lineCoords);
-        // Calculate shortest distance from user to this step's path
-        const distance = pointToLineDistance(userPoint, line, { units: 'meters' });
+        let pointDistance = 0;
+        if (isStartOrLevelChanger) {
+            pointDistance = distance(userPoint, point(step.coordinates), { units: 'meters' });
+        }
+        else {
+            const lineCoords = step.navMode === 'mall' ? step.lineStringFeatureFromLastStep.geometry.coordinates : step.geometry.coordinates;
+            const line = lineString(lineCoords);
+            pointDistance = pointToLineDistance(userPoint, line, { units: 'meters' });
+        }
         // If within threshold and closest so far, consider this as best candidate
-        if (distance < thresholdMeters && distance < minDistance) {
-            minDistance = distance;
+        if (pointDistance < thresholdMeters && pointDistance < minDistance) {
+            minDistance = pointDistance;
             closestStepIndex = i;
         }
     }

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

@@ -1,24 +1,42 @@
 import Feature from '../../models/feature';
 import { GuidanceStep } from '../../models/wayfinding';
+import { FloorModel } from '../../models/floor';
 export default class GuidanceStepsGenerator {
     points: Feature[];
     steps: GuidanceStep[];
     language: string;
-    landMarkNav: boolean;
+    stepsNavigation: 'disabled' | 'simple' | 'simple-levelChangers' | 'full' | 'full-levelChangers' | 'landmark' | 'landmark-levelChangers';
     pois?: Feature[];
     levelChangers?: Feature[];
     initialBearing: number;
-    constructor({ points, language, landMarkNav, pois, levelChangers, initialBearing, }: {
+    landmarkSteps: boolean;
+    fullSteps: boolean;
+    simpleSteps: boolean;
+    levelChangersSteps: boolean;
+    floors: FloorModel[];
+    currentFloor: FloorModel;
+    constructor({ points, language, stepsNavigation, pois, levelChangers, initialBearing, floors, currentFloor, }: {
         points: Feature[];
         language: string;
-        landMarkNav: boolean;
+        stepsNavigation: 'disabled' | 'simple' | 'simple-levelChangers' | 'full' | 'full-levelChangers' | 'landmark' | 'landmark-levelChangers';
         pois?: Feature[];
         levelChangers?: Feature[];
         initialBearing: number;
+        floors: FloorModel[];
+        currentFloor: FloorModel;
     });
     private capitalize;
     private generateStepsFromPoints;
     private generateInstruction;
+    private generateSimpleInstruction;
+    private generateFullInstruction;
+    private generateFullLevelChangerInstruction;
+    private generateLevelChangerStepInstruction;
+    private generateLandmarkInstruction;
+    private getLandmarkLevelChangerPrefix;
+    private getLandmarkInitialBearingPrefix;
+    private getLandmarkDistancePrefix;
+    private getLandmarkDirectionWithContext;
     private getDirectionInstruction;
     private getBearingFromLastStep;
     private getStepDirection;

package/lib/components/map/guidanceStepsGenerator.js

@@ -4,6 +4,7 @@ import distance from '@turf/distance';
 import { lineString } from '@turf/helpers';
 import { translations } from './i18n';
 import nearestPoint from '@turf/nearest-point';
+import { getFloorName } from '../../common';
 var Direction;
 (function (Direction) {
     Direction["Start"] = "START";
@@ -21,6 +22,11 @@ var Direction;
     Direction["ExitEscalator"] = "EXIT_ESCALATOR";
     Direction["ExitElevator"] = "EXIT_ELEVATOR";
     Direction["ExitRamp"] = "EXIT_RAMP";
+    Direction["At"] = "AT";
+    Direction["AtStaircase"] = "AT_STAIRS";
+    Direction["AtEscalator"] = "AT_ESCALATOR";
+    Direction["AtElevator"] = "AT_ELEVATOR";
+    Direction["AtRamp"] = "AT_RAMP";
     Direction["Up"] = "UP";
     Direction["Down"] = "DOWN";
     Direction["Left"] = "LEFT";
@@ -40,17 +46,36 @@ var LevelChangerTypes;
     LevelChangerTypes["ramp"] = "RAMP";
 })(LevelChangerTypes || (LevelChangerTypes = {}));
 export default class GuidanceStepsGenerator {
-    constructor({ points, language, landMarkNav, pois, levelChangers, initialBearing, }) {
+    constructor({ points, language, stepsNavigation, pois, levelChangers, initialBearing, floors, currentFloor, }) {
         this.capitalize = (s) => s && String(s[0]).toUpperCase() + String(s).slice(1);
         this.points = points;
         this.language = language;
-        if (landMarkNav) {
-            this.landMarkNav = landMarkNav;
+        this.stepsNavigation = stepsNavigation;
+        this.floors = floors;
+        this.currentFloor = currentFloor;
+        this.landmarkSteps = this.stepsNavigation === 'landmark' || this.stepsNavigation === 'landmark-levelChangers';
+        this.fullSteps = this.stepsNavigation === 'full' || this.stepsNavigation === 'full-levelChangers';
+        this.simpleSteps = this.stepsNavigation === 'simple' || this.stepsNavigation === 'simple-levelChangers';
+        this.levelChangersSteps =
+            this.stepsNavigation === 'simple-levelChangers' ||
+                this.stepsNavigation === 'full-levelChangers' ||
+                this.stepsNavigation === 'landmark-levelChangers';
+        if (this.landmarkSteps) {
             this.pois = pois;
             this.levelChangers = levelChangers;
             this.initialBearing = initialBearing;
         }
         if (this.points && this.points.length > 0) {
+            if (this.levelChangersSteps) {
+                this.points = this.points.flatMap((point, i) => {
+                    const next = this.points[i + 1];
+                    if (point.isLevelChanger && (next === null || next === void 0 ? void 0 : next.isLevelChanger) && point.properties.level !== next.properties.level) {
+                        const transition = new Feature(Object.assign({}, point));
+                        return [point, transition];
+                    }
+                    return [point];
+                });
+            }
             this.generateStepsFromPoints();
         }
     }
@@ -76,20 +101,35 @@ export default class GuidanceStepsGenerator {
             });
             const distanceFromLastStep = this.getDistanceFromLastStep(data);
             const extendedData = Object.assign(Object.assign({}, data), { direction, distanceFromLastStep });
-            if (this.landMarkNav &&
+            if (this.stepsNavigation === 'landmark' &&
                 (direction === Direction.Start ||
                     (direction === Direction.Finish && currentPoint.isPoi) ||
                     direction === Direction.TurnAround ||
-                    /*direction === `${Direction.Down}_${LevelChangerTypes[currentPoint.properties.type]}` ||
-                    direction === `${Direction.Up}_${LevelChangerTypes[currentPoint.properties.type]}` ||*/
                     direction === `${Direction.Exit}_${LevelChangerTypes[currentPoint.properties.type]}` ||
                     distanceFromLastStep === 0)) {
                 return;
             }
-            return {
+            if (this.stepsNavigation === 'landmark-levelChangers' &&
+                (direction === Direction.Start ||
+                    (direction === Direction.Finish && currentPoint.isPoi) ||
+                    direction === Direction.TurnAround)) {
+                return;
+            }
+            if (this.stepsNavigation === 'full' &&
+                (direction === Direction.Start ||
+                    direction === Direction.TurnAround ||
+                    direction === `${Direction.Exit}_${LevelChangerTypes[currentPoint.properties.type]}` ||
+                    distanceFromLastStep === 0)) {
+                return;
+            }
+            if (this.stepsNavigation === 'full-levelChangers' &&
+                (direction === Direction.Start || direction === Direction.TurnAround)) {
+                return;
+            }
+            const step = {
                 bearingFromLastStep: this.getBearingFromLastStep(data),
                 coordinates: [point.geometry.coordinates[0], point.geometry.coordinates[1]],
-                direction: this.landMarkNav
+                direction: this.landmarkSteps
                     ? nextStepDirection === Direction.Finish && (nextPoint === null || nextPoint === void 0 ? void 0 : nextPoint.isPoi)
                         ? Direction.Finish
                         : direction
@@ -103,72 +143,257 @@ export default class GuidanceStepsGenerator {
                     ? nextPoint.properties.level
                     : null,
                 lineStringFeatureFromLastStep: this.getLineStringFeatureFromLastStep(data),
-                instruction: this.generateInstruction(extendedData), // New attribute
             };
+            const destinationFloor = step.levelChangerDestinationLevel && this.floors.filter((f) => f.level === step.levelChangerDestinationLevel)
+                ? this.floors.filter((f) => f.level === step.levelChangerDestinationLevel)[0]
+                : this.currentFloor;
+            step.destinationFloor = destinationFloor;
+            return Object.assign(Object.assign({}, step), { instruction: this.generateInstruction(Object.assign(Object.assign({}, extendedData), { step })) });
         });
-    }
-    generateInstruction({ previousPoint, secondPreviousPoint, currentPoint, nextPoint, secondNextPoint, direction, distanceFromLastStep, }) {
-        let instruction = '';
-        if (this.landMarkNav && previousPoint.isLevelChanger) {
-            const levelChangerFeature = this.levelChangers.find((f) => f.id === previousPoint.id);
-            const levelChangeDirection = this.getStepDirection({
-                previousPoint: levelChangerFeature,
-                currentPoint: previousPoint,
-                nextPoint: currentPoint,
-                levelChangerDirection: true,
+        if (this.simpleSteps) {
+            let previousIndex = 0;
+            this.steps = this.steps
+                .filter((i, index, array) => {
+                // Get the first part of the direction string
+                const direction = i.direction.split('_')[0];
+                if (this.stepsNavigation === 'simple') {
+                    // Check if the current step is a level changer and has a valid direction or is finish
+                    if ((i.levelChangerId && (direction === 'UP' || direction === 'DOWN')) || i.direction === 'FINISH') {
+                        i.stepsUntil = array.slice(previousIndex, index);
+                        previousIndex = index + 1;
+                        return i;
+                    }
+                }
+                else {
+                    if (i.levelChangerId) {
+                        i.stepsUntil = array.slice(previousIndex, index);
+                        previousIndex = index + 1;
+                        return i;
+                    }
+                    if (i.direction === 'FINISH') {
+                        i.stepsUntil = array.slice(previousIndex, index);
+                        previousIndex = index + 1;
+                        return i;
+                    }
+                }
+            })
+                .map((step) => {
+                const stepsUntilDistance = step.stepsUntil && step.stepsUntil.length > 0
+                    ? step.stepsUntil.reduce((total, item) => total + item.distanceFromLastStep, 0)
+                    : 0;
+                const totalDistance = step.distanceFromLastStep + stepsUntilDistance;
+                const simplifiedStep = Object.assign(Object.assign({}, step), { totalDistance });
+                return Object.assign(Object.assign({}, simplifiedStep), { instruction: this.generateInstruction({ direction: simplifiedStep.direction, step: simplifiedStep }) });
             });
-            instruction += `${this.capitalize(this.getDirectionInstruction(levelChangeDirection))} `;
         }
-        if (this.landMarkNav && !secondPreviousPoint && this.initialBearing) {
-            // if first step
-            const bearingVar = bearing(previousPoint.geometry.coordinates, currentPoint.geometry.coordinates) - this.initialBearing;
-            const dir = this.getDirectionFromBearing(bearingVar);
-            instruction += `${this.getDirectionInstruction(dir)} `;
+    }
+    generateInstruction(params) {
+        if (this.simpleSteps)
+            return this.generateSimpleInstruction(params);
+        if (this.fullSteps)
+            return this.generateFullInstruction(params);
+        if (this.landmarkSteps)
+            return this.generateLandmarkInstruction(params);
+        return '';
+    }
+    // ─── Simple ───────────────────────────────────────────────────────────────────
+    generateSimpleInstruction({ step, direction }) {
+        var _a, _b, _c;
+        if (!(step === null || step === void 0 ? void 0 : step.totalDistance) && !this.levelChangersSteps)
+            return '';
+        const t = translations[this.language];
+        if (direction === 'FINISH') {
+            return [
+                this.capitalize(t.IN),
+                step.totalDistance ? step.totalDistance.toFixed(0) : 0,
+                t.METERS,
+                this.getDirectionInstruction(direction),
+            ].join(' ');
+        }
+        const floorName = ((_a = step.destinationFloor) === null || _a === void 0 ? void 0 : _a.name)
+            ? getFloorName({ floor: step.destinationFloor, language: this.language })
+            : String(step.destinationLevel);
+        if (this.levelChangersSteps && step.levelChangerId && !step.distanceFromLastStep) {
+            return this.generateLevelChangerStepInstruction({ step, t });
+        }
+        return [
+            this.capitalize(t.GO),
+            step.totalDistance ? step.totalDistance.toFixed(0) : 0,
+            t.METERS,
+            t.AND_TAKE_THE,
+            (_c = t[(_b = step.levelChangerType) === null || _b === void 0 ? void 0 : _b.toUpperCase()]) === null || _c === void 0 ? void 0 : _c.toLowerCase(),
+            t[step.levelChangerDirection],
+            t.TO,
+            floorName,
+            t.FLOOR + '.',
+        ].join(' ');
+    }
+    // ─── Full ─────────────────────────────────────────────────────────────────────
+    generateFullInstruction({ direction, distanceFromLastStep, step, currentPoint, }) {
+        const t = translations[this.language];
+        if ((currentPoint === null || currentPoint === void 0 ? void 0 : currentPoint.isLevelChanger) && step && step.distanceFromLastStep) {
+            return this.generateFullLevelChangerInstruction({ step, t });
+        }
+        if (direction === Direction.Start) {
+            return this.getDirectionInstruction(direction);
+        }
+        if (direction === Direction.Finish) {
+            return [
+                this.capitalize(t.IN),
+                distanceFromLastStep.toFixed(0),
+                t.METERS + ',',
+                this.getDirectionInstruction(direction),
+            ].join(' ');
         }
         if (distanceFromLastStep > 0) {
-            instruction += `${this.capitalize(translations[this.language].IN)} ${distanceFromLastStep.toFixed(0)} ${translations[this.language].METERS} `;
+            return [
+                this.capitalize(t.IN),
+                distanceFromLastStep.toFixed(0),
+                t.METERS + ',',
+                this.getDirectionInstruction(direction),
+            ].join(' ');
         }
+        if (this.levelChangersSteps && step.levelChangerId) {
+            return this.generateLevelChangerStepInstruction({ step, t });
+        }
+        // Fallback: no distance yet (first step or distance not available)
+        return this.capitalize(this.getDirectionInstruction(direction));
+    }
+    generateFullLevelChangerInstruction({ step, t, }) {
+        var _a;
+        const floorName = ((_a = step.destinationFloor) === null || _a === void 0 ? void 0 : _a.name)
+            ? getFloorName({ floor: step.destinationFloor, language: this.language })
+            : String(step.destinationLevel);
+        return [
+            this.capitalize(t.IN),
+            step.distanceFromLastStep.toFixed(0),
+            t.METERS + ',',
+            t.TAKE_THE,
+            t[step.levelChangerType.toUpperCase()].toLowerCase(),
+            t[step.levelChangerDirection],
+            t.TO,
+            floorName,
+            t.FLOOR + '.',
+        ].join(' ');
+    }
+    generateLevelChangerStepInstruction({ step, t, }) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const floorName = ((_a = step.destinationFloor) === null || _a === void 0 ? void 0 : _a.name)
+            ? getFloorName({ floor: step.destinationFloor, language: this.language })
+            : String(step.destinationLevel);
+        const stepDirection = step.direction.split('_')[0];
+        // at level changer step
+        if (stepDirection === 'UP' || stepDirection === 'DOWN') {
+            return [
+                this.capitalize(t.YOU_ARE_AT_THE),
+                ((_c = t[(_b = step.levelChangerType) === null || _b === void 0 ? void 0 : _b.toUpperCase()]) === null || _c === void 0 ? void 0 : _c.toLowerCase()) + ',',
+                t.GO,
+                t[step.levelChangerDirection],
+                t.VIA,
+                (_e = t[(_d = step.levelChangerType) === null || _d === void 0 ? void 0 : _d.toUpperCase()]) === null || _e === void 0 ? void 0 : _e.toLowerCase(),
+                t.TO,
+                floorName,
+                t.FLOOR + '.',
+            ].join(' ');
+        }
+        // exit level changer step
+        if (stepDirection === 'EXIT') {
+            return [
+                this.capitalize(t.EXIT_THE),
+                ((_g = t[(_f = step.levelChangerType) === null || _f === void 0 ? void 0 : _f.toUpperCase()]) === null || _g === void 0 ? void 0 : _g.toLowerCase()) + ',',
+                t.YOU_ARE_AT.toLowerCase(),
+                floorName,
+                t.FLOOR + '.',
+            ].join(' ');
+        }
+    }
+    // ─── Landmark ────────────────────────────────────────────────────────────────
+    generateLandmarkInstruction(params) {
+        const parts = [];
+        parts.push(...this.getLandmarkLevelChangerPrefix(params));
+        parts.push(...this.getLandmarkInitialBearingPrefix(params));
+        parts.push(...this.getLandmarkDistancePrefix(params));
+        const { direction } = params;
         if (direction === Direction.TurnAround || direction === Direction.Start || direction === Direction.Finish) {
-            instruction += this.getDirectionInstruction(direction);
-            return instruction;
+            parts.push(this.getDirectionInstruction(direction));
+            return parts.join(' ');
         }
-        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 && nextPoint.isPoi) {
-                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].navInstructions[direction]}`;
-                return instruction;
+        parts.push(...this.getLandmarkDirectionWithContext(params));
+        return parts.join(' ');
+    }
+    getLandmarkLevelChangerPrefix({ previousPoint, currentPoint, step }) {
+        if (!(previousPoint === null || previousPoint === void 0 ? void 0 : previousPoint.isLevelChanger))
+            return [];
+        if (this.levelChangersSteps && (step === null || step === void 0 ? void 0 : step.levelChangerId))
+            return [];
+        const levelChangerFeature = this.levelChangers.find((f) => f.id === previousPoint.id);
+        const levelChangeDirection = this.getStepDirection({
+            previousPoint: levelChangerFeature,
+            currentPoint: previousPoint,
+            nextPoint: currentPoint,
+            levelChangerDirection: true,
+        });
+        return [this.capitalize(this.getDirectionInstruction(levelChangeDirection))];
+    }
+    getLandmarkInitialBearingPrefix({ previousPoint, secondPreviousPoint, currentPoint, step, }) {
+        if (secondPreviousPoint || !this.initialBearing)
+            return [];
+        if (this.levelChangersSteps && (step === null || step === void 0 ? void 0 : step.levelChangerId))
+            return [];
+        const bearingVar = bearing(previousPoint.geometry.coordinates, currentPoint.geometry.coordinates) - this.initialBearing;
+        const dir = this.getDirectionFromBearing(bearingVar);
+        return [this.getDirectionInstruction(dir)];
+    }
+    getLandmarkDistancePrefix({ distanceFromLastStep, currentPoint, step }) {
+        if (!distanceFromLastStep || distanceFromLastStep <= 0)
+            return [];
+        if (this.levelChangersSteps && (currentPoint === null || currentPoint === void 0 ? void 0 : currentPoint.isLevelChanger))
+            return [];
+        if (this.levelChangersSteps && (step === null || step === void 0 ? void 0 : step.levelChangerId))
+            return [];
+        const t = translations[this.language];
+        return [this.capitalize(t.IN), distanceFromLastStep.toFixed(0), t.METERS];
+    }
+    getLandmarkDirectionWithContext({ currentPoint, nextPoint, secondNextPoint, direction, step, }) {
+        var _a, _b, _c, _d, _e;
+        const t = translations[this.language];
+        const nextPointDirection = this.getStepDirection({
+            previousPoint: currentPoint,
+            currentPoint: nextPoint,
+            nextPoint: secondNextPoint,
+        });
+        // Approaching a POI destination
+        if (nextPointDirection === Direction.Finish && (nextPoint === null || nextPoint === void 0 ? void 0 : nextPoint.isPoi)) {
+            const title = (_b = (_a = nextPoint.properties.title_i18n) === null || _a === void 0 ? void 0 : _a[this.language]) !== null && _b !== void 0 ? _b : nextPoint.properties.title;
+            return [t.DESTINATION, title, t.navInstructions[direction]];
+        }
+        const directionInstruction = this.getDirectionInstruction(direction);
+        // Exiting a level changer
+        if (currentPoint === null || currentPoint === void 0 ? void 0 : currentPoint.isLevelChanger) {
+            const floorName = ((_c = step.destinationFloor) === null || _c === void 0 ? void 0 : _c.name)
+                ? getFloorName({ floor: step.destinationFloor, language: this.language })
+                : String(step.destinationLevel);
+            if (this.levelChangersSteps) {
+                if (step.distanceFromLastStep > 0) {
+                    return [this.generateFullLevelChangerInstruction({ step, t })];
+                }
+                else {
+                    return [this.generateLevelChangerStepInstruction({ step, t })];
+                }
             }
-            /*if (nextPoint.isLevelChanger) {
-              instruction += `${this.getDirectionInstruction(nextPointDirection).slice(0, -1)} ${
-                translations[this.language].TO_FLOOR
-              } ${secondNextPoint.properties.level}`;
-              return instruction;
-            }*/
-            instruction += this.getDirectionInstruction(direction);
-            if (currentPoint.isLevelChanger) {
-                instruction = instruction.slice(0, -1);
-                instruction += ` ${translations[this.language].TO_FLOOR} ${nextPoint.properties.level}`;
-                return instruction;
+            else {
+                // Trim trailing punctuation from direction instruction before appending floor
+                return [`${directionInstruction.replace(/[.,]$/, '')} ${t.TO} ${floorName} ${t.FLOOR}.`];
             }
-            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}`;
-        }
-        else {
-            instruction += this.getDirectionInstruction(direction);
         }
-        return instruction;
+        // Standard landmark: direction + nearest POI
+        const floorPois = {
+            type: 'FeatureCollection',
+            features: this.pois.filter((f) => f.properties.level === currentPoint.properties.level),
+        };
+        const nearestPoi = nearestPoint(currentPoint.geometry.coordinates, floorPois);
+        const poiTitle = (_e = (_d = nearestPoi.properties.title_i18n) === null || _d === void 0 ? void 0 : _d[this.language]) !== null && _e !== void 0 ? _e : nearestPoi.properties.title;
+        return [`${directionInstruction.replace(/[.,]$/, '')} ${t.BY} ${poiTitle}`];
     }
     getDirectionInstruction(direction) {
         switch (direction) {

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

@@ -37,6 +37,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -86,6 +94,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -135,6 +151,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -184,6 +208,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -233,6 +265,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -282,6 +322,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;
@@ -331,6 +379,14 @@ export declare const translations: {
         FLOOR: string;
         BY: string;
         IS_ON_YOUR: string;
+        GO: string;
+        AND_TAKE_THE: string;
+        WALK: string;
+        TAKE_THE: string;
+        YOU_ARE_AT: string;
+        YOU_ARE_AT_THE: string;
+        VIA: string;
+        EXIT_THE: string;
         navInstructions: {
             STRAIGHT: string;
             TURN_AROUND: string;