@wemap/routers 12.10.8 → 12.11.0

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

@@ -0,0 +1,6 @@
+/**
+ * Create and return a date with a given timezone
+ * timeZone - timezone name (e.g. 'Europe/Paris')
+ */
+export declare function dateWithTimeZone(year: number, month: number, day: number, hour: number, minute: number, second: number, timeZone?: string): Date;
+export declare function isRoutingError(e: unknown): e is Error;

package/dist/src/remote/cityway/CitywayRemoteRouter.d.ts

@@ -0,0 +1,109 @@
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+type CitywayCoordinates = {
+    Lat: number;
+    Long: number;
+};
+type CitywayLeg = {
+    TransportMode: string;
+    Duration: string;
+    Departure: {
+        Time: string;
+        Site: {
+            Name: string;
+            Position: CitywayCoordinates;
+        };
+        StopPlace: {
+            Name: string;
+            Position: CitywayCoordinates;
+        };
+    };
+    Arrival: {
+        Time: string;
+        Site: {
+            Name: string;
+            Position: CitywayCoordinates;
+        };
+        StopPlace: {
+            Name: string;
+            Position: CitywayCoordinates;
+        };
+    };
+    Line: {
+        Name: string;
+        Number: string;
+        Color: string;
+        TextColor: string;
+    };
+    Destination: string;
+    Distance: number;
+    steps: {
+        Step: {
+            Geometry: string;
+        }[];
+    };
+    pathLinks: {
+        PathLink: {
+            Departure: {
+                Site: {
+                    Name: string;
+                };
+            };
+            Distance: number;
+            Geometry: string | 'Null';
+        }[];
+    };
+};
+type CitywayJson = {
+    StatusCode: number;
+    Message: string;
+    Data: {
+        response: {
+            trips: {
+                Trip: {
+                    Duration: string;
+                    Departure: {
+                        Time: string;
+                        Site: {
+                            Position: CitywayCoordinates;
+                        };
+                    };
+                    Arrival: {
+                        Time: string;
+                        Site: {
+                            Position: CitywayCoordinates;
+                        };
+                    };
+                    sections: {
+                        Section: {
+                            Leg?: CitywayLeg;
+                            PTRide: CitywayLeg;
+                        }[];
+                    };
+                }[];
+            };
+        };
+        PlanTripType?: string;
+    }[];
+};
+/**
+ * Singleton.
+ */
+declare class CitywayRemoteRouter extends RemoteRouter {
+    get rname(): "cityway";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getURL(endpointUrl: string, routerRequest: RouterRequest): string;
+    /**
+     * Generate multi itineraries from Cityway JSON
+     * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
+     */
+    parseResponse(json: CitywayJson): Itinerary[];
+    /**
+     * @param {string} iso8601Duration
+     * @see https://stackoverflow.com/a/29153059/2239938
+     */
+    parseDuration(iso8601Duration: string): number;
+}
+declare const _default: CitywayRemoteRouter;
+export default _default;

package/dist/src/remote/deutsche-bahn/DeutscheBahnRemoteRouter.d.ts

@@ -0,0 +1,31 @@
+import { Coordinates } from '@wemap/geo';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+type DBJson = {
+    segments: {
+        fromLevel: number;
+        toLevel: number;
+        polyline: {
+            lat: number;
+            lon: number;
+        }[];
+    }[];
+};
+/**
+ * Singleton.
+ */
+declare class DeutscheBahnRemoteRouter extends RemoteRouter {
+    /**
+     * @override
+     */
+    get rname(): "deutsche-bahn";
+    /**
+     * @override
+     */
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getURL(endpointUrl: string, routerRequest: RouterRequest): string;
+    parseResponse(json: DBJson, origin: Coordinates, destination: Coordinates): Itinerary[];
+}
+declare const _default: DeutscheBahnRemoteRouter;
+export default _default;

package/dist/src/remote/geovelo/GeoveloRemoteRouter.d.ts

@@ -0,0 +1,106 @@
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+type DistanceDetails = {
+    total: number;
+    normalRoads: number;
+    recommendedRoads: number;
+    discouragedRoads: number;
+    cycleway: number;
+    greenway: number;
+    lane: number;
+    livingstreet: number;
+    sharebusway: number;
+    footway: number;
+    pedestrian: number;
+    opposite: number;
+    steps: number;
+    zone30: number;
+    residential: number;
+};
+type Waypoint = {
+    longitude: number;
+    latitude: number;
+    title?: string | null;
+};
+type Instruction = Array<string | number>;
+type SectionWithInstructions = {
+    transportMode: 'BIKE' | 'PEDESTRIAN';
+    duration: number;
+    waypointsIndices: number[] | null;
+    geometry: string;
+    estimatedDatetimeOfDeparture: string;
+    estimatedDatetimeOfArrival: string;
+    details: SectionDetails;
+    waypoints: Waypoint[];
+};
+type SectionDetails = {
+    distances: DistanceDetails;
+    instructions: Instruction[];
+    profile: string;
+    direction: string;
+    verticalGain: number;
+    verticalLoss: number;
+    calories: number;
+    elevations: string | null;
+    ridesets: any[];
+    averageSpeed: number;
+    bikeType: string;
+};
+type Route = {
+    sections: SectionWithInstructions[];
+    distances: {
+        total: number;
+        normalRoads: number;
+        recommendedRoads: number;
+        discouragedRoads: number;
+    };
+    title: string;
+    waypoints: Waypoint[];
+    estimatedDatetimeOfDeparture: string;
+    estimatedDatetimeOfArrival: string;
+    duration: number;
+    id: string;
+};
+type Routes = Route[];
+type QueryParams = {
+    instructions: boolean;
+    elevations: boolean;
+    geometry: boolean;
+    single_result: boolean;
+    bike_stations: boolean;
+    objects_as_ids: boolean;
+    merge_instructions: boolean;
+    show_pushing_bike_instructions: boolean;
+};
+type RequestBodyParams = {
+    datetimeOfDeparture?: string;
+    datetimeOfArrival?: string;
+    bikeDetails?: {
+        profile: string;
+        bikeType: string;
+        averageSpeed: number;
+        eBike: boolean;
+        bikeStations: Array<{
+            from: number;
+            to: number;
+        }>;
+    };
+    transportModes: Array<'BIKE' | 'PEDESTRIAN'>;
+    waypoints: Waypoint[];
+};
+/**
+ * Singleton.
+ */
+declare class GeoveloRemoteRouter extends RemoteRouter {
+    /**
+     * @override
+     */
+    get rname(): "geovelo";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getQueryParams(): QueryParams;
+    getBodyParams(routerRequest: RouterRequest): RequestBodyParams;
+    parseResponse(json: Routes): Itinerary[];
+}
+declare const _default: GeoveloRemoteRouter;
+export default _default;

package/dist/src/remote/idfm/IdfmRemoteRouter.d.ts

@@ -0,0 +1,123 @@
+import { Coordinates } from '@wemap/geo';
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+type IdfmCoordinates = {
+    lat: number | string;
+    lon: number | string;
+};
+type IdfmPath = {
+    name: string;
+    length: number;
+} & ({
+    instruction_start_coordinate: IdfmCoordinates;
+} | {
+    via_uri: string;
+});
+type IdfmWaypoint = {
+    name: string;
+} & ({
+    stop_point: {
+        coord: IdfmCoordinates;
+    };
+} | {
+    address: {
+        coord: IdfmCoordinates;
+    };
+} | {
+    poi: {
+        coord: IdfmCoordinates;
+    };
+});
+type IdfmSection = {
+    id: string;
+    type: 'waiting' | 'transfer' | string;
+    mode: string;
+    departure_date_time: string;
+    arrival_date_time: string;
+    duration: number;
+    geojson: {
+        coordinates: [number, number][];
+        properties: {
+            length: number;
+        }[];
+    };
+    path: IdfmPath[];
+    display_informations: {
+        code: string;
+        color: string;
+        text_color: string;
+        direction: string;
+        physical_mode: string;
+    };
+    from: IdfmWaypoint;
+    to: IdfmWaypoint;
+    vias?: {
+        id: string;
+        name: string;
+        access_point: {
+            id: string;
+            name: string;
+            coord: {
+                lon: string;
+                lat: string;
+            };
+            embedded_type: string;
+        };
+        is_entrance: boolean;
+        is_exit: boolean;
+        length: number;
+        traversal_time: number;
+        pathway_mode: number;
+    }[];
+};
+type IdfmJson = {
+    journeys: {
+        duration: number;
+        departure_date_time: string;
+        arrival_date_time: string;
+        sections: IdfmSection[];
+    }[];
+    context: {
+        timezone: string;
+    };
+    error: {
+        message?: string;
+    };
+};
+type IdfmIntermediateStep = {
+    name: string;
+    distance: number;
+};
+/**
+ * Singleton.
+ */
+declare class IdfmRemoteRouter extends RemoteRouter {
+    /**
+     * @override
+     */
+    get rname(): "idfm";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getURL(endpointUrl: string, routerRequest: RouterRequest): string;
+    getCarQuery(): URLSearchParams;
+    getWalkingQuery(): URLSearchParams;
+    getBikeQuery(): URLSearchParams;
+    getSectionCoords(section: IdfmSection): {
+        from: Coordinates;
+        to: Coordinates;
+    };
+    /**
+     * Since the IDFM API does not provide coords for each step, we need to compute them
+     * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+     * @param {Leg} leg
+     */
+    findStepsCoord(legCoords: Coordinates[], steps: IdfmIntermediateStep[]): {
+        coords: Coordinates;
+        name: string;
+        distance: number;
+    }[];
+    findStepCoords(step: IdfmSection['path'][number], section: IdfmSection): Coordinates | undefined;
+    parseResponse(json: IdfmJson): Itinerary[];
+}
+declare const _default: IdfmRemoteRouter;
+export default _default;

package/dist/src/remote/navitia/NavitiaRemoteRouter.d.ts

@@ -0,0 +1,34 @@
+import { Coordinates } from '@wemap/geo';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+import { NavitiaJson, NavitiaSection, NavitiaIntermediateStep } from './types';
+/**
+ * Singleton.
+ */
+declare class NavitiaRemoteRouter extends RemoteRouter {
+    get rname(): "navitia";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getURL(endpointUrl: string, routerRequest: RouterRequest): URL;
+    getCarQuery(): URLSearchParams;
+    getWalkingQuery(): URLSearchParams;
+    getBikeQuery(): URLSearchParams;
+    getSectionCoords(section: NavitiaSection): {
+        from: Coordinates;
+        to: Coordinates;
+    };
+    /**
+     * Since the navitia API does not provide coords for each step, we need to compute them
+     * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+     * @param {Leg} leg
+     */
+    findStepsCoord(legCoords: Coordinates[], steps: NavitiaIntermediateStep[]): {
+        coords: Coordinates;
+        name: string;
+        distance: number;
+    }[];
+    findStepCoords(step: NavitiaSection['path'][number], section: NavitiaSection): Coordinates | undefined;
+    parseResponse(json: NavitiaJson): Itinerary[];
+}
+declare const _default: NavitiaRemoteRouter;
+export default _default;

package/dist/src/remote/navitia/types.d.ts

@@ -0,0 +1,87 @@
+export type NavitiaCoordinates = {
+    lat: number | string;
+    lon: number | string;
+};
+export type NavitiaPath = {
+    name: string;
+    length: number;
+} & ({
+    instruction_start_coordinate: NavitiaCoordinates;
+} | {
+    via_uri: string;
+});
+export type NavitiaWaypoint = {
+    name: string;
+} & ({
+    stop_point: {
+        coord: NavitiaCoordinates;
+    };
+} | {
+    address: {
+        coord: NavitiaCoordinates;
+    };
+} | {
+    poi: {
+        coord: NavitiaCoordinates;
+    };
+});
+export type NavitiaSection = {
+    id: string;
+    type: 'waiting' | 'transfer' | string;
+    mode: string;
+    departure_date_time: string;
+    arrival_date_time: string;
+    duration: number;
+    geojson: {
+        coordinates: [number, number][];
+        properties: {
+            length: number;
+        }[];
+    };
+    path: NavitiaPath[];
+    display_informations: {
+        code: string;
+        color: string;
+        text_color: string;
+        direction: string;
+        physical_mode: string;
+    };
+    from: NavitiaWaypoint;
+    to: NavitiaWaypoint;
+    vias?: {
+        id: string;
+        name: string;
+        access_point: {
+            id: string;
+            name: string;
+            coord: {
+                lon: string;
+                lat: string;
+            };
+            embedded_type: string;
+        };
+        is_entrance: boolean;
+        is_exit: boolean;
+        length: number;
+        traversal_time: number;
+        pathway_mode: number;
+    }[];
+};
+export type NavitiaJson = {
+    journeys: {
+        duration: number;
+        departure_date_time: string;
+        arrival_date_time: string;
+        sections: NavitiaSection[];
+    }[];
+    context: {
+        timezone: string;
+    };
+    error: {
+        message?: string;
+    };
+};
+export type NavitiaIntermediateStep = {
+    name: string;
+    distance: number;
+};

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

@@ -0,0 +1,70 @@
+import { Coordinates } from '@wemap/geo';
+import { LineString, Position } from 'geojson';
+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';
+type OsrmCoordinates = Position;
+type OsrmModifier = 'sharp right' | 'sharp left' | 'slight right' | 'slight left' | 'right' | 'left' | 'u turn' | 'straight';
+type OsrmManeuverType = 'depart' | 'turn' | 'arrive';
+type OsrmStep = {
+    geometry: LineString;
+    distance: number;
+    duration: number;
+    name?: string;
+    maneuver: {
+        bearing_before: number;
+        bearing_after: number;
+        location: OsrmCoordinates;
+        modifier: OsrmModifier;
+        type: OsrmManeuverType;
+    };
+};
+type OsrmJson = {
+    code?: string;
+    message?: string;
+    routes?: {
+        geometry: LineString;
+        legs: {
+            distance: number;
+            duration: number;
+            steps: OsrmStep[];
+        }[];
+        distance: number;
+        duration: number;
+        weight_name: string;
+        weight: number;
+    }[];
+    waypoints?: [];
+};
+type OsrmMode = 'driving' | 'walking' | 'bike' | 'pmr' | 'bike-safest' | 'bike-fastest';
+/**
+ * Singleton.
+ */
+declare class OsrmRemoteRouter extends RemoteRouter {
+    get rname(): "osrm";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    /**
+     * @throws {TravelModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl: string, routerRequest: RouterRequest): string;
+    inputModeCorrespondance: (routerRequest: RouterRequest) => OsrmMode;
+    coordinatesToJson({ lat, lng, level }: Coordinates): OsrmCoordinates;
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json: OsrmCoordinates): Coordinates;
+    getModifierFromAngle(_angle: number): OsrmModifier;
+    noRouteFoundJson(message: object): {
+        code: string;
+        message: object;
+    };
+    /**
+     * @deprecated
+     */
+    itineraryToOsrmJson(itinerary: Itinerary): OsrmJson;
+    parseResponse(json: OsrmJson, origin: Coordinates, destination: Coordinates, travelMode: TravelMode): Itinerary[];
+}
+declare const _default: OsrmRemoteRouter;
+export default _default;

package/dist/src/remote/otp/OtpRemoteRouter.d.ts

@@ -0,0 +1,69 @@
+import { default as Itinerary } from '../../model/Itinerary.js';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+type OtpCoordinates = {
+    lat: number;
+    lon: number;
+};
+type FromTo = OtpCoordinates & {
+    name: string;
+};
+type FromToPT = FromTo & {
+    stopId: string;
+    stopCode: string;
+};
+type CommonLeg = {
+    startTime: number;
+    endTime: number;
+    legGeometry: {
+        points: string;
+        length: number;
+    };
+    duration: number;
+};
+type LegWalk = CommonLeg & {
+    mode: 'WALK';
+    from: FromTo;
+    to: FromTo;
+    steps: (OtpCoordinates & {
+        distance: number;
+        streetName: string;
+    })[];
+};
+type LegPT = CommonLeg & {
+    mode: 'BUS' | 'TRAM';
+    from: FromToPT;
+    to: FromToPT;
+    intermediateStops: FromToPT;
+    routeShortName: 'string';
+    routeColor?: 'string';
+    routeTextColor?: 'string';
+    headsign: 'string';
+};
+type OtpJson = {
+    plan: {
+        from: FromTo;
+        to: FromTo;
+        itineraries: {
+            duration: number;
+            startTime: number;
+            endTime: number;
+            walkDistance: number;
+            legs: (LegWalk | LegPT)[];
+        }[];
+    };
+};
+/**
+ * Singleton.
+ */
+declare class OtpRemoteRouter extends RemoteRouter {
+    get rname(): "otp";
+    getItineraries(endpointUrl: string, routerRequest: RouterRequest): Promise<Itinerary[]>;
+    getURL(endpointUrl: string, routerRequest: RouterRequest): string;
+    /**
+     * Generate multi itineraries from OTP JSON
+     */
+    parseResponse(json: OtpJson): Itinerary[];
+}
+declare const _default: OtpRemoteRouter;
+export default _default;

package/dist/src/remote/wemap-multi/WemapMultiRemoteRouter.d.ts

@@ -0,0 +1,19 @@
+import { Coordinates } from '@wemap/geo';
+import { default as RemoteRouter } from '../RemoteRouter.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+import { default as Itinerary } from '../../model/Itinerary.js';
+type WemapRouterRequest = Omit<RouterRequest, 'origin' | 'destination' | 'waypoints'> & {
+    mapId?: number;
+    origin: Coordinates | number | string;
+    destination: Coordinates | number | string;
+    waypoints?: (Coordinates | number | string)[];
+};
+/**
+ * Singleton.
+ */
+declare class WemapMultiRemoteRouter extends RemoteRouter {
+    get rname(): "wemap-multi";
+    getItineraries(endpointUrl: string, routerRequest: WemapRouterRequest): Promise<Itinerary[]>;
+}
+declare const _default: WemapMultiRemoteRouter;
+export default _default;

package/dist/src/types.d.ts

@@ -0,0 +1,31 @@
+import { CoordinatesCompressedJson } from '@wemap/geo';
+import { EdgeProperties } from './graph/Edge.js';
+import { VertexProperties } from './graph/Vertex.js';
+export type GraphVertexJson = {
+    id: number;
+    coords: CoordinatesCompressedJson;
+    properties?: VertexProperties;
+};
+export type GraphEdgeJson = {
+    id: number;
+    vertex1Idx: number;
+    vertex2Idx: number;
+    properties?: EdgeProperties;
+};
+export type GeoGraphJson = {
+    vertices: GraphVertexJson[];
+    edges: GraphEdgeJson[];
+};
+export type CompressedGraphVertexJson = CoordinatesCompressedJson;
+export type CompressedGeoGraphJson = {
+    vertices: CompressedGraphVertexJson[];
+    verticesIds: (string | number)[];
+    edges: ([
+        number,
+        number
+    ] | [
+        number,
+        number,
+        EdgeProperties
+    ])[];
+};