@wemap/routers 10.3.1 → 10.4.0

package/helpers/InstructionManager.js

@@ -0,0 +1,155 @@
+import { roundFactor } from '@wemap/maths';
+import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
+import Step from '../src/model/Step.js';
+import { getTurnInfoFromAngle } from '../src/wemap/WemapRouterUtils.js';
+
+export default class InstructionManager {
+
+    useProposals = false;
+
+    /**
+     * @param {Step} step
+     * @returns {{type: string, direction?: string}}
+     */
+    static getInfoFromStep(step) {
+
+        let type, direction, directionExtra, levelChange;
+
+        if (step.levelChange) {
+            type = 'level-change';
+            levelChange = step.levelChange;
+        } else {
+            type = 'turn';
+            const turnInfo = getTurnInfoFromAngle(step.angle);
+            direction = turnInfo.direction;
+            directionExtra = turnInfo.directionExtra;
+        }
+
+        return {
+            type,
+            direction,
+            directionExtra,
+            levelChange,
+            name: step.name,
+            indoor: step.coords.level !== null
+        };
+    }
+
+    /**
+     * @param {Step} step
+     * @returns {string}
+     */
+    // eslint-disable-next-line max-statements
+    static getInstructionFromStep(step) {
+
+        const { direction, directionExtra } = getTurnInfoFromAngle(step.angle);
+        const isTurn = direction !== 'straight';
+
+        if (step.lastStep) {
+            if (isTurn && direction === 'left') {
+                return 'Your destination is on your left';
+            } else if (isTurn && direction === 'right') {
+                return 'Your destination is on your right';
+            }
+        }
+
+        const suffix = step.name ? ` on ${step.name}` : '';
+
+        if (step.levelChange) {
+            if (step.levelChange.direction === 'up') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go up the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go up the stairs';
+                }
+                return 'Go up' + suffix;
+            }
+            if (step.levelChange.direction === 'down') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go down the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go down the stairs';
+                }
+                return 'Go down' + suffix;
+            }
+            if (step.extras.subwayEntrance) {
+                return `Take exit ${step.extras.subwayEntranceRef}`;
+            }
+        }
+
+        if (isTurn) {
+            if (direction === 'left') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly left' + suffix;
+                }
+                return 'Turn left' + suffix;
+            }
+            if (direction === 'right') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly right' + suffix;
+                }
+                return 'Turn right' + suffix;
+            }
+        }
+
+
+        return '';
+    }
+
+
+    /**
+     * @param {ItineraryInfoManager} itineraryInfoManager
+     * @param {Coordinates} position
+     * @returns {string | null}
+     */
+    static getInstructionFromPosition(itineraryInfoManager, position) {
+        const itineraryInfo = itineraryInfoManager.getInfo(position);
+        if (!itineraryInfo) {
+            return null;
+        }
+
+        // If distance between itinerary and position is too far,
+        // something went wrong. (mapmatching.maxDistance)
+        if (this.useProposals && itineraryInfo.projection.distanceFromNearestElement > 15) {
+            return 'It seems that we are a little bit lost, please start again the localization process';
+        }
+
+        const { nextStep } = itineraryInfo;
+        if (!nextStep) {
+            return 'You are arrived';
+        }
+
+        const distNextStep = position.distanceTo(nextStep.coords);
+        const distRounded = roundFactor(distNextStep, 5);
+
+        if (this.useProposals && distNextStep > 10) {
+            return `Continue straight for ${distRounded}m`;
+        }
+
+
+        let instruction = InstructionManager.getInstructionFromStep(nextStep);
+
+        const stepWithImportantInfo = itineraryInfoManager._steps.find(step =>
+            step.levelChange
+            && step.number > itineraryInfo.nextStep.number
+            && step.coords.distanceTo(itineraryInfo.nextStep.coords) < 10
+        ) || null;
+
+        if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
+            const nextBearing = nextStep.coords.bearingTo(stepWithImportantInfo.coords);
+            const { direction } = getTurnInfoFromAngle(nextBearing - itineraryInfo.nextStep.previousBearing);
+            instruction = direction === 'straight' ? 'Continue straight' : `Turn ${direction}`;
+            const { direction: levelDirection, type: levelType } = stepWithImportantInfo.levelChange;
+            instruction += ` and take the ${levelType} going ${levelDirection}`;
+        }
+
+        if (distNextStep >= 5) {
+            instruction += ` in ${distRounded}m`;
+        }
+
+        return instruction;
+    }
+
+}

package/helpers/InstructionManagerV1.js

@@ -0,0 +1,104 @@
+import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
+import Step from '../src/model/Step.js';
+import OsrmRemoteRouter from '../src/remote/osrm/OsrmRemoteRouter.js';
+
+export default class InstructionManagerV1 {
+
+    /**
+     * @param {Step} step
+     * @returns {string}
+     */
+    // eslint-disable-next-line max-statements, complexity
+    static getInstructionFromStep(step) {
+
+        const modifier = OsrmRemoteRouter.getModifierFromAngle(step.angle);
+        let direction, directionExtra;
+        if (modifier.includes('left')) {
+            direction = 'left';
+        } else if (modifier.includes('right')) {
+            direction = 'right';
+        }
+        if (modifier.includes('slight')) {
+            directionExtra = 'slight';
+        }
+        const isTurn = modifier !== 'straight';
+
+        if (step.lastStep) {
+            if (isTurn && direction === 'left') {
+                return 'Your destination is on your left';
+            } else if (isTurn && direction === 'right') {
+                return 'Your destination is on your right';
+            }
+        }
+
+        const suffix = step.name ? ` on ${step.name}` : '';
+
+        if (step.levelChange) {
+            if (step.levelChange.direction === 'up') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go up the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go up the stairs';
+                }
+                return 'Go up' + suffix;
+            }
+            if (step.levelChange.direction === 'down') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go down the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go down the stairs';
+                }
+                return 'Go down' + suffix;
+            }
+            if (step.extras.subwayEntrance) {
+                return `Take exit ${step.extras.subwayEntranceRef}`;
+            }
+        }
+
+        if (isTurn) {
+            if (direction === 'left') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly left' + suffix;
+                }
+                return 'Turn left' + suffix;
+            }
+            if (direction === 'right') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly right' + suffix;
+                }
+                return 'Turn right' + suffix;
+            }
+        }
+
+
+        return '';
+    }
+
+
+    /**
+     * @param {ItineraryInfoManager} itineraryInfoManager
+     * @param {Coordinates} position
+     * @returns {string | null}
+     */
+    static getInstructionFromPosition(itineraryInfoManager, position) {
+        const itineraryInfo = itineraryInfoManager.getInfo(position);
+        if (!itineraryInfo) {
+            return null;
+        }
+
+        const { nextStep } = itineraryInfo;
+        if (!nextStep) {
+            return null;
+        }
+
+        const distNextStep = position.distanceTo(nextStep.coords);
+        const nextStep2 = itineraryInfoManager._steps.find((step) => step.number > nextStep.number);
+        if (distNextStep < 3 && nextStep2) {
+            return InstructionManagerV1.getInstructionFromStep(nextStep2);
+        }
+
+        return InstructionManagerV1.getInstructionFromStep(nextStep);
+    }
+}

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "10.3.1",
+    "version": "10.4.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -35,5 +35,5 @@
         "@wemap/maths": "^10.3.1",
         "@wemap/osm": "^10.3.1"
     },
-    "gitHead": "e4775e59dd3db76cf7b3d1e63a3e2402bf5f0088"
+    "gitHead": "00c259754b234de1d75a307f543badda8f6f0771"
 }