@wemap/routers 12.12.4 → 13.1.0

package/dist/src/Utils.d.ts

@@ -1,6 +1,13 @@
+import { StepDirection } from './model/Step';
 /**
  * Get route duration
  * @param {Number} speed in km/h
  * @returns {Number} duration in seconds
  */
 export declare function getDurationFromLength(length: number, speed?: number): number;
+/**
+ * Get direction from angle (radians)
+ * @param {Number} angle in radians
+ * @returns {String} direction
+ */
+export declare function getDirectionFromAngle(_angle: number): StepDirection;

package/dist/src/model/Itinerary.d.ts

@@ -47,6 +47,8 @@ export default class Itinerary {
     get coords(): Coordinates[];
     set steps(_: Step[]);
     get steps(): Step[];
+    set price(_: number);
+    get price(): number;
     set transitMode(_: TransitMode);
     get transitMode(): TransitMode;
     set distance(_: number);
@@ -76,6 +78,8 @@ export default class Itinerary {
      * - all steps number
      * - first/last steps
      * - previousBearing/nextBearing/angle of first and last step of each leg
+     * - distance/duration of first and last step of each leg
+     * - remove type depart | arrive if step is not first or last
      */
     updateStepsFromLegs(): void;
 }

package/dist/src/model/Leg.d.ts

@@ -20,6 +20,7 @@ export type TransportInfo = {
     routeColor?: string;
     routeTextColor?: string;
     directionName?: string;
+    price?: number;
 };
 type LegCommon = {
     transitMode: TransitMode;

package/dist/src/model/Step.d.ts

@@ -1,10 +1,22 @@
 import { Coordinates, CoordinatesCompressedJson } from '@wemap/geo';
-import { LevelChange } from './LevelChange.js';
-import { StepExtra } from './StepExtra.js';
-export type Step = {
+type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
+export declare const SHARED_STEP_TYPE: readonly ["moving-walkway"];
+export type SharedStepType = typeof SHARED_STEP_TYPE[number];
+export declare const VERTICAL_STEP_TYPE: readonly ["moving-walkway", "elevator", "escalator", "stairs", "incline-plane"];
+export type VerticalStepType = typeof VERTICAL_STEP_TYPE[number];
+export declare const VERTICAL_DIRECTION: readonly ["up", "down"];
+export type VerticalDirection = typeof VERTICAL_DIRECTION[number];
+export declare const HORIZONTAL_STEP_TYPE: readonly ["moving-walkway", "depart", "turn", "continue", "roundabout", "exit-roundabout", "arrive", "subway-entrance", "gate", "transit"];
+export type HorizontalStepType = typeof HORIZONTAL_STEP_TYPE[number];
+export declare const HORIZONTAL_DIRECTION: readonly ["straight", "right", "slight-right", "sharp-right", "left", "slight-left", "sharp-left", "u-turn"];
+export type HorizontalDirection = typeof HORIZONTAL_DIRECTION[number];
+export type StepDirection = VerticalDirection | HorizontalDirection;
+export type StepType = VerticalStepType | HorizontalStepType;
+interface BaseStep {
     firstStep: boolean;
     lastStep: boolean;
     number: number;
+    levelDifference: number | null;
     angle: number;
     previousBearing: number;
     nextBearing: number;
@@ -12,31 +24,34 @@ export type Step = {
     duration: number;
     readonly coords: Coordinates;
     readonly name: string | null;
-    readonly levelChange: LevelChange | null;
-    readonly extras: StepExtra | null;
-};
+}
+interface VerticalStep extends BaseStep {
+    type: VerticalStepType | null;
+    direction: VerticalDirection;
+}
+interface HorizontalStep extends BaseStep {
+    type: HorizontalStepType | null;
+    direction: HorizontalDirection | null;
+}
+export type Step = VerticalStep | HorizontalStep;
 export type StepJson = {
     firstStep?: boolean;
     lastStep?: boolean;
     number: number;
     coords: CoordinatesCompressedJson;
     name?: string;
+    type: StepType | null;
     angle: number;
+    direction: StepDirection | null;
     previousBearing: number;
     nextBearing: number;
     distance: number;
     duration: number;
-    levelChange?: LevelChange;
-    extras?: StepExtra;
-};
-export type MinStepInfo = {
-    coords: Coordinates;
-    name?: string;
-    levelChange?: LevelChange;
-    extras?: StepExtra;
-    distance?: number;
-    duration?: number;
+    levelDifference?: number | null;
 };
+export type MinStepInfo = AtLeast<Step, 'coords'>;
 export declare function stepToJson(step: Step): StepJson;
 export declare function jsonToStep(json: StepJson): Step;
 export declare function stepEquals(step1: Step, step2: Step): boolean;
+export declare function isStepLevelChange(step?: Step | MinStepInfo | null): step is VerticalStep;
+export {};

package/dist/src/remote/RemoteRouterManager.d.ts

@@ -53,9 +53,6 @@ declare const remoteRouters: readonly [{
                                         };
                                     };
                                     Arrival: {
-                                        /**
-                                         * Singleton
-                                         */
                                         Time: string;
                                         Site: {
                                             Name: string;
@@ -118,9 +115,6 @@ declare const remoteRouters: readonly [{
                                         };
                                     };
                                     Arrival: {
-                                        /**
-                                         * Singleton
-                                         */
                                         Time: string;
                                         Site: {
                                             Name: string;
@@ -543,9 +537,11 @@ declare const remoteRouters: readonly [{
     getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<import('../model/Itinerary.js').default[]>;
     getURL(endpointUrl: string, routerRequest: RouterRequest): string;
     inputModeCorrespondance: (routerRequest: RouterRequest) => "walking" | "bike" | "driving" | "pmr" | "bike-safest" | "bike-fastest";
+    osrmTypeToStepType(type: "depart" | "turn" | "roundabout" | "arrive" | "exit roundabout"): "moving-walkway" | "depart" | "turn" | "continue" | "roundabout" | "exit-roundabout" | "arrive" | "subway-entrance" | "gate" | "transit";
+    osrmModifierToStepDirection(modifier: "straight" | "right" | "left" | "sharp right" | "sharp left" | "slight right" | "slight left" | "u turn"): "straight" | "right" | "slight-right" | "sharp-right" | "left" | "slight-left" | "sharp-left" | "u-turn";
     coordinatesToJson({ lat, lng, level }: import('@wemap/geo/dist/src/coordinates/Coordinates.js').default): import('geojson').Position;
     jsonToCoordinates(json: import('geojson').Position): import('@wemap/geo/dist/src/coordinates/Coordinates.js').default;
-    getModifierFromAngle(_angle: number): "sharp right" | "sharp left" | "slight right" | "slight left" | "right" | "left" | "u turn" | "straight";
+    getModifierFromAngle(_angle: number): "straight" | "right" | "left" | "sharp right" | "sharp left" | "slight right" | "slight left" | "u turn";
     noRouteFoundJson(message: object): {
         code: string;
         message: object;
@@ -564,11 +560,15 @@ declare const remoteRouters: readonly [{
                     duration: number;
                     name?: string | undefined;
                     maneuver: {
+                        /**
+                         * Singleton
+                         */
                         bearing_before: number;
                         bearing_after: number;
                         location: import('geojson').Position;
-                        modifier: "sharp right" | "sharp left" | "slight right" | "slight left" | "right" | "left" | "u turn" | "straight";
-                        type: "depart" | "turn" | "arrive";
+                        modifier: "straight" | "right" | "left" | "sharp right" | "sharp left" | "slight right" | "slight left" | "u turn";
+                        type: "depart" | "turn" | "roundabout" | "arrive" | "exit roundabout";
+                        exit?: number | undefined;
                     };
                 }[];
             }[];
@@ -593,11 +593,15 @@ declare const remoteRouters: readonly [{
                     duration: number;
                     name?: string | undefined;
                     maneuver: {
+                        /**
+                         * Singleton
+                         */
                         bearing_before: number;
                         bearing_after: number;
                         location: import('geojson').Position;
-                        modifier: "sharp right" | "sharp left" | "slight right" | "slight left" | "right" | "left" | "u turn" | "straight";
-                        type: "depart" | "turn" | "arrive";
+                        modifier: "straight" | "right" | "left" | "sharp right" | "sharp left" | "slight right" | "slight left" | "u turn";
+                        type: "depart" | "turn" | "roundabout" | "arrive" | "exit roundabout";
+                        exit?: number | undefined;
                     };
                 }[];
             }[];
@@ -705,6 +709,11 @@ declare const remoteRouters: readonly [{
             }[];
         };
     }): import('../model/Itinerary.js').default[];
+}, {
+    readonly rname: "tictactrip";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<import('../model/Itinerary.js').default[]>;
+    getBodyParams(routerRequest: RouterRequest): import('./tictactrip/type.js').TictactripRequest;
+    parseResponse(json: import('./tictactrip/type.js').TictactripResponse): import('../model/Itinerary.js').default[];
 }, {
     readonly rname: "wemap-multi";
     getItineraries(endpointUrl: string, routerRequest: Omit<RouterRequest, "origin" | "destination" | "waypoints"> & {

package/dist/src/remote/osrm/OsrmRemoteRouter.d.ts

@@ -4,9 +4,10 @@ import { default as Itinerary } from '../../model/Itinerary.js';
 import { default as RemoteRouter } from '../RemoteRouter.js';
 import { TravelMode } from '../../model/TravelMode.js';
 import { RouterRequest } from '../../model/RouterRequest.js';
+import { HorizontalDirection, HorizontalStepType } from '../../model/Step.js';
 type OsrmCoordinates = Position;
 type OsrmModifier = 'sharp right' | 'sharp left' | 'slight right' | 'slight left' | 'right' | 'left' | 'u turn' | 'straight';
-type OsrmManeuverType = 'depart' | 'turn' | 'arrive';
+type OsrmManeuverType = 'depart' | 'turn' | 'roundabout' | 'exit roundabout' | 'arrive';
 type OsrmStep = {
     geometry: LineString;
     distance: number;
@@ -18,6 +19,7 @@ type OsrmStep = {
         location: OsrmCoordinates;
         modifier: OsrmModifier;
         type: OsrmManeuverType;
+        exit?: number;
     };
 };
 type OsrmJson = {
@@ -49,6 +51,8 @@ declare class OsrmRemoteRouter extends RemoteRouter {
      */
     getURL(endpointUrl: string, routerRequest: RouterRequest): string;
     inputModeCorrespondance: (routerRequest: RouterRequest) => OsrmMode;
+    osrmTypeToStepType(type: OsrmManeuverType): HorizontalStepType;
+    osrmModifierToStepDirection(modifier: OsrmModifier): HorizontalDirection;
     coordinatesToJson({ lat, lng, level }: Coordinates): OsrmCoordinates;
     /**
      * @param {object} json

package/dist/src/remote/tictactrip/TictactripRemoteRouter.d.ts

@@ -0,0 +1,18 @@
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+import { TictactripResponse, TictactripRequest } from './type.js';
+/**
+ * Singleton.
+ */
+declare class TictactripRemoteRouter extends RemoteRouter {
+    /**
+     * @override
+     */
+    get rname(): "tictactrip";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getBodyParams(routerRequest: RouterRequest): TictactripRequest;
+    parseResponse(json: TictactripResponse): Itinerary[];
+}
+declare const _default: TictactripRemoteRouter;
+export default _default;

package/dist/src/remote/tictactrip/type.d.ts

@@ -0,0 +1,73 @@
+export type TictactripRequest = {
+    origin: {
+        latitude: number;
+        longitude: number;
+    };
+    destination: {
+        latitude: number;
+        longitude: number;
+    };
+    outbound_date: string;
+    passengers: {
+        age: number;
+    }[];
+};
+export interface TictactripProvider {
+    id: string;
+    name: string;
+    company: string;
+    transportType: string;
+}
+export interface TictactripLocation {
+    id: string;
+    name: string;
+    city: string;
+    region: string;
+    country: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+}
+export interface TictactripSegment {
+    id: string;
+    provider: TictactripProvider;
+    origin: TictactripLocation;
+    destination: TictactripLocation;
+    priceCents: number;
+    durationMinutes: number;
+    departureUTC: number;
+    arrivalUTC: number;
+    originOffset: string;
+    destinationOffset: string;
+    arrivalLocalISO: string;
+    departureLocalISO: string;
+    transportType: 'bus' | 'train';
+    vehicleIdentifier: string;
+    co2g: number;
+    bookingClass: string;
+    fareName: string;
+    notAvailableReason: string | null;
+    includedBaggage: boolean;
+}
+export interface TictactripTrip {
+    id: string;
+    direction: string;
+    origin: TictactripLocation;
+    destination: TictactripLocation;
+    available: boolean;
+    priceCents: number;
+    durationMinutes: number;
+    departureUTC: number;
+    arrivalUTC: number;
+    originOffset: string;
+    isIdentityDocumentRequired: boolean;
+    arrivalLocalISO: string;
+    departureLocalISO: string;
+    destinationOffset: string;
+    transportType: 'TRAIN' | 'BUS' | 'MULTIMODAL';
+    providers: TictactripProvider[];
+    segments: TictactripSegment[];
+}
+export type TictactripResponse = {
+    trips: Record<string, TictactripTrip>;
+};

package/helpers/InstructionManager.ts

@@ -1,6 +1,6 @@
 import { Coordinates } from '@wemap/geo';
 import { diffAngle, rad2deg, roundFactor } from '@wemap/maths';
-import { ItineraryInfoManager, Step } from '@wemap/routers';
+import { ItineraryInfoManager, Step, isStepLevelChange } from '@wemap/routers';
 
 export default class InstructionManager {
 
@@ -30,9 +30,9 @@ export default class InstructionManager {
 
         let type, direction, directionExtra, levelChange;
 
-        if (step.levelChange) {
+        if (isStepLevelChange(step)) {
             type = 'level-change';
-            levelChange = step.levelChange;
+            levelChange = step.levelDifference;
         } else {
             type = 'turn';
             const turnInfo = InstructionManager.getTurnInfoFromAngle(step.angle);
@@ -65,52 +65,53 @@ export default class InstructionManager {
         }
 
         let suffix = '';
-        if (step.extras?.isGate) {
+        if (step.type === 'gate') {
             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') {
+        if (isStepLevelChange(step)) {
+            if (step.direction === 'up') {
+                if (step.type === 'stairs') {
                     return 'Go up the stairs';
                 }
-                if (step.levelChange.type === 'escalator') {
+                if (step.type === 'escalator') {
                     return 'Go up the escalator';
                 }
-                if (step.levelChange.type === 'elevator') {
+                if (step.type === 'elevator') {
                     return 'Go up the elevator';
                 }
-                if (step.levelChange.type === 'moving walkway') {
+                if (step.type === 'moving-walkway') {
                     return 'Go up the moving walkway';
                 }
-                if (step.levelChange.type === 'incline plane') {
+                if (step.type === 'incline-plane') {
                     return 'Go up the incline plane';
                 }
                 return 'Go up' + suffix;
             }
-            if (step.levelChange.direction === 'down') {
-                if (step.levelChange.type === 'stairs') {
+            if (step.direction === 'down') {
+                if (step.type === 'stairs') {
                     return 'Go down the stairs';
                 }
-                if (step.levelChange.type === 'escalator') {
+                if (step.type === 'escalator') {
                     return 'Go down the escalator';
                 }
-                if (step.levelChange.type === 'elevator') {
+                if (step.type === 'elevator') {
                     return 'Go down the elevator';
                 }
-                if (step.levelChange.type === 'moving walkway') {
+                if (step.type === 'moving-walkway') {
                     return 'Go down the moving walkway';
                 }
-                if (step.levelChange.type === 'incline plane') {
+                if (step.type === 'incline-plane') {
                     return 'Go down the incline plane';
                 }
                 return 'Go down' + suffix;
             }
-            if (step.extras?.subwayEntrance) {
-                return `Take exit ${step.extras.subwayEntranceRef}`;
-            }
+        }
+
+        if (step.type === 'subway-entrance') {
+            return `Take exit ${step.name}`;
         }
 
         if (isTurn) {
@@ -160,16 +161,16 @@ export default class InstructionManager {
 
         let instruction = InstructionManager.getInstructionFromStep(nextStep);
 
-        const stepWithImportantInfo = itineraryInfoManager._steps.find(step => step.levelChange
+        const stepWithImportantInfo = itineraryInfoManager._steps.find(step => isStepLevelChange(step)
             && step.number > nextStep.number
             && step.coords.distanceTo(nextStep.coords) < 10
         ) || null;
 
-        if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
+        if (stepWithImportantInfo && isStepLevelChange(stepWithImportantInfo)) {
             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;
+            const { direction: levelDirection, type: levelType } = stepWithImportantInfo;
             instruction += ` and take the ${levelType} going ${levelDirection}`;
         }
 

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.12.4",
+    "version": "13.1.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -34,10 +34,10 @@
         "@turf/convex": "^6.5.0",
         "@turf/helpers": "^6.5.0",
         "@types/mapbox__polyline": "^1.0.2",
-        "@wemap/geo": "^12.12.0",
-        "@wemap/logger": "^12.10.9",
-        "@wemap/maths": "^12.10.9",
-        "@wemap/osm": "^12.12.3",
+        "@wemap/geo": "^13.1.0",
+        "@wemap/logger": "^13.0.0",
+        "@wemap/maths": "^13.0.0",
+        "@wemap/osm": "^13.1.0",
         "@wemap/salesman.js": "^2.1.0"
     },
     "devDependencies": {
@@ -62,5 +62,5 @@
             "types": "./dist/helpers/*.d.ts"
         }
     },
-    "gitHead": "150f561ed17ba6ac7050d846b45dbd4a056f82ec"
+    "gitHead": "4e46ef122f3139bc2e16c0368b53e0a8ea52db72"
 }

package/dist/src/model/LevelChange.d.ts

@@ -1,7 +0,0 @@
-export type LevelChangeType = 'elevator' | 'escalator' | 'stairs' | 'moving walkway' | 'incline plane';
-export type LevelChange = {
-    direction: 'up' | 'down';
-    difference: number;
-    type?: LevelChangeType;
-};
-export declare function areLevelChangeEquals(l1: LevelChange, l2: LevelChange): boolean;