@wemap/routers 12.11.3 → 12.11.5

package/helpers/InstructionManager.ts

@@ -0,0 +1,184 @@
+import { Coordinates } from '@wemap/geo';
+import { diffAngle, rad2deg, roundFactor } from '@wemap/maths';
+import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
+import { Step } from '../src/model/Step.js';
+
+export default class InstructionManager {
+
+    static useProposals = false;
+
+    static getTurnInfoFromAngle(_angle: number) {
+
+        let direction, directionExtra;
+
+        const directionAngle = rad2deg(diffAngle(_angle, Math.PI));
+        const directionAngleAbs = Math.abs(directionAngle);
+        if (directionAngleAbs <= 20) {
+            direction = 'straight';
+        } else {
+            direction = directionAngle > 0 ? 'left' : 'right';
+            if (directionAngleAbs < 55) {
+                directionExtra = 'slight';
+            } else if (directionAngleAbs > 120) {
+                directionExtra = 'sharp';
+            }
+        }
+
+        return { direction, directionExtra };
+    }
+
+    static getInfoFromStep(step: Step) {
+
+        let type, direction, directionExtra, levelChange;
+
+        if (step.levelChange) {
+            type = 'level-change';
+            levelChange = step.levelChange;
+        } else {
+            type = 'turn';
+            const turnInfo = InstructionManager.getTurnInfoFromAngle(step.angle);
+            direction = turnInfo.direction;
+            directionExtra = turnInfo.directionExtra;
+        }
+
+        return {
+            type,
+            direction,
+            directionExtra,
+            levelChange,
+            name: step.name,
+            indoor: step.coords.level !== null
+        };
+    }
+
+    // eslint-disable-next-line max-statements, complexity
+    static getInstructionFromStep(step: Step) {
+
+        const { direction, directionExtra } = InstructionManager.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';
+            }
+        }
+
+        let suffix = '';
+        if (step.extras?.isGate) {
+            suffix = ` on gate ${step.name}`;
+        } else if (step.name) {
+            suffix = ` on ${step.name}`;
+        }
+
+        if (step.levelChange) {
+            if (step.levelChange.direction === 'up') {
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go up the stairs';
+                }
+                if (step.levelChange.type === 'escalator') {
+                    return 'Go up the escalator';
+                }
+                if (step.levelChange.type === 'elevator') {
+                    return 'Go up the elevator';
+                }
+                if (step.levelChange.type === 'moving walkway') {
+                    return 'Go up the moving walkway';
+                }
+                if (step.levelChange.type === 'incline plane') {
+                    return 'Go up the incline plane';
+                }
+                return 'Go up' + suffix;
+            }
+            if (step.levelChange.direction === 'down') {
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go down the stairs';
+                }
+                if (step.levelChange.type === 'escalator') {
+                    return 'Go down the escalator';
+                }
+                if (step.levelChange.type === 'elevator') {
+                    return 'Go down the elevator';
+                }
+                if (step.levelChange.type === 'moving walkway') {
+                    return 'Go down the moving walkway';
+                }
+                if (step.levelChange.type === 'incline plane') {
+                    return 'Go down the incline plane';
+                }
+                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 'Continue straight';
+    }
+
+
+
+    static getInstructionFromPosition(itineraryInfoManager: ItineraryInfoManager, position: Coordinates) {
+        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 > nextStep.number
+            && step.coords.distanceTo(nextStep.coords) < 10
+        ) || null;
+
+        if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
+            const nextBearing = nextStep.coords.bearingTo(stepWithImportantInfo.coords);
+            const { direction } = InstructionManager.getTurnInfoFromAngle(nextBearing - 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.ts

@@ -0,0 +1,95 @@
+import { Coordinates } from '@wemap/geo';
+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 {
+
+    // eslint-disable-next-line max-statements, complexity
+    static getInstructionFromStep(step: 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 === 'escalator') {
+                    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 === 'escalator') {
+                    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 '';
+    }
+
+    static getInstructionFromPosition(itineraryInfoManager: ItineraryInfoManager, position: Coordinates) {
+        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": "12.11.3",
+    "version": "12.11.5",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -46,14 +46,19 @@
         "geojson": "^0.5.0"
     },
     "files": [
-        "dist"
+        "dist",
+        "helpers"
     ],
     "exports": {
         ".": {
-            "types": "./dist/index.d.ts",
             "import": "./dist/index.mjs",
-            "require": "./dist/index.js"
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./helpers/*": {
+            "default": "./helpers/*.js",
+            "types": "./dist/helpers/*.d.ts"
         }
     },
-    "gitHead": "720dada72f8a6e15e7054d86e082ff21b294708a"
+    "gitHead": "b844e20806d66574493b38d245dfeb3e954dc300"
 }