@wemap/osm 5.4.7 → 5.4.8

package/dist/wemap-osm.es.js

@@ -476,7 +476,7 @@ class Step {
 
 class Leg {
 
-    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR */
+    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
     mode;
 
     /** @type {!number} */
@@ -1203,7 +1203,7 @@ function coordinatesToJson(coordinates) {
  * @param {object} json
  * @returns {Coordinates}
  */
-function jsonToCoordinates$1(json) {
+function jsonToCoordinates$2(json) {
     const output = new Coordinates(json[1], json[0]);
     if (json.length > 2) {
         output.level = Level.fromString(json[2]);
@@ -1339,7 +1339,7 @@ function parseJsonSteps$1(jsonSteps, legCoords) {
     return jsonSteps.map(jsonStep => {
 
         const step = new Step();
-        step.coords = jsonToCoordinates$1(jsonStep.maneuver.location);
+        step.coords = jsonToCoordinates$2(jsonStep.maneuver.location);
 
         // Sometimes, OSRM step does not have the same coordinates than a point in legCoords.
         // ex: first step of https://routing.getwemap.com/route/v1/walking/2.33222164147,48.87084765712;2.3320734,48.8730212?geometries=geojson&overview=full&steps=true
@@ -1377,7 +1377,7 @@ function parseJsonSteps$1(jsonSteps, legCoords) {
  * @param {?string} routingMode [walking|driving|bicycle]
  * @returns {?RouterResponse}
  */
-function createRouterResponseFromJson$1(json, from, to, routingMode = 'walking') {
+function createRouterResponseFromJson$2(json, from, to, routingMode = 'walking') {
 
     const { routes: jsonRoutes } = json;
 
@@ -1418,7 +1418,7 @@ function createRouterResponseFromJson$1(json, from, to, routingMode = 'walking')
             leg.duration = jsonLeg.duration;
 
             leg.coords = jsonLeg.steps
-                .map(step => step.geometry.coordinates.map(jsonToCoordinates$1))
+                .map(step => step.geometry.coordinates.map(jsonToCoordinates$2))
                 .flat()
                 // Remove duplicates
                 .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equalsTo(coords));
@@ -1448,12 +1448,12 @@ function createRouterResponseFromJson$1(json, from, to, routingMode = 'walking')
 var OsrmUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     coordinatesToJson: coordinatesToJson,
-    jsonToCoordinates: jsonToCoordinates$1,
+    jsonToCoordinates: jsonToCoordinates$2,
     nodesToJsonCoords: nodesToJsonCoords,
     getModifierFromAngle: getModifierFromAngle,
     noRouteFoundJson: noRouteFoundJson,
     itineraryToOsrmJson: itineraryToOsrmJson,
-    createRouterResponseFromJson: createRouterResponseFromJson$1
+    createRouterResponseFromJson: createRouterResponseFromJson$2
 });
 
 /* eslint-disable max-statements */
@@ -1462,7 +1462,7 @@ var OsrmUtils = /*#__PURE__*/Object.freeze({
  * @param {object} json
  * @returns {Coordinates}
  */
-function jsonToCoordinates(json) {
+function jsonToCoordinates$1(json) {
     return new Coordinates(json.lat, json.lon);
 }
 
@@ -1480,7 +1480,7 @@ function parseJsonSteps(jsonSteps, legCoords) {
     return jsonSteps.map(jsonStep => {
 
         const step = new Step();
-        const stepCoords = jsonToCoordinates(jsonStep);
+        const stepCoords = jsonToCoordinates$1(jsonStep);
 
         // OTP step does not have the same coordinates than a point in legCoords.
         // That is why we look for the closest point.
@@ -1506,7 +1506,7 @@ function parseJsonSteps(jsonSteps, legCoords) {
  * @param {object} json JSON file provided by OTP.
  * @returns {?RouterResponse}
  */
-function createRouterResponseFromJson(json) {
+function createRouterResponseFromJson$1(json) {
 
     const { plan: jsonPlan } = json;
 
@@ -1517,8 +1517,8 @@ function createRouterResponseFromJson(json) {
     const routerResponse = new RouterResponse();
     routerResponse.routerName = 'otp';
 
-    routerResponse.from = jsonToCoordinates(jsonPlan.from);
-    routerResponse.to = jsonToCoordinates(jsonPlan.to);
+    routerResponse.from = jsonToCoordinates$1(jsonPlan.from);
+    routerResponse.to = jsonToCoordinates$1(jsonPlan.to);
 
     for (const jsonItinerary of jsonPlan.itineraries) {
 
@@ -1542,11 +1542,11 @@ function createRouterResponseFromJson(json) {
             leg.endTime = jsonLeg.endTime;
             leg.from = {
                 name: jsonLeg.from.name,
-                coords: jsonToCoordinates(jsonLeg.from)
+                coords: jsonToCoordinates$1(jsonLeg.from)
             };
             leg.to = {
                 name: jsonLeg.to.name,
-                coords: jsonToCoordinates(jsonLeg.to)
+                coords: jsonToCoordinates$1(jsonLeg.to)
             };
             leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
 
@@ -1597,6 +1597,233 @@ function createRouterResponseFromJson(json) {
 }
 
 var OtpUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    jsonToCoordinates: jsonToCoordinates$1,
+    createRouterResponseFromJson: createRouterResponseFromJson$1
+});
+
+/* eslint-disable max-depth */
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+function jsonToCoordinates(json) {
+    return new Coordinates(json.Lat, json.Long);
+}
+
+/**
+ * @param {string} jsonDate
+ * @returns {number}
+ */
+function jsonDateToTimestamp(jsonDate) {
+    const [dateStr, timeStr] = jsonDate.split(' ');
+    const [dayStr, monthStr, yearStr] = dateStr.split('/');
+    const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
+    const date = new Date(
+        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
+        Number(hoursStr), Number(minutesStr), Number(secondsStr)
+    );
+    return date.getTime();
+}
+
+/**
+ * @param {string} wktGeometry
+ * @returns {Coordinates[]}
+ */
+function parseWKTGeometry(wktGeometry) {
+    const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
+    if (!tmpCoordsStr) {
+        return null;
+    }
+    return tmpCoordsStr[1].split(',').map(str => {
+        const sp = str.trim().split(' ');
+        return new Coordinates(Number(sp[1]), Number(sp[0]));
+    });
+}
+
+/**
+ * @param {string} iso8601Duration
+ * @see https://stackoverflow.com/a/29153059/2239938
+ */
+function parseDuration(iso8601Duration) {
+    const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+
+    var matches = iso8601Duration.match(iso8601DurationRegex);
+
+    // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
+    const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
+    const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
+    const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
+    const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
+    const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
+    const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
+    const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
+
+    return seconds
+        + minutes * 60
+        + hours * 3600
+        + days * 86400
+        + weeks * (86400 * 7)
+        + months * (86400 * 30)
+        + years * (86400 * 365.25);
+}
+
+/**
+ * Generate multi itineraries from Cityway JSON
+ * @param {object} json JSON file provided by Cityway.
+ * @returns {?RouterResponse}
+ * @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
+ */
+function createRouterResponseFromJson(json) {
+
+    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'cityway';
+
+
+    // Do not know if it the best approach, but it works...
+    const allJsonTrips = json.Data.reduce((acc, dataObj) => {
+        acc.push(...dataObj.response.trips.Trip);
+        return acc;
+    }, []);
+
+    for (const trip of allJsonTrips) {
+
+        const itinerary = new Itinerary();
+
+        itinerary.duration = parseDuration(trip.Duration);
+        itinerary.startTime = jsonDateToTimestamp(trip.Departure.Time);
+        itinerary.from = jsonToCoordinates(trip.Departure.Site.Position);
+        itinerary.endTime = jsonDateToTimestamp(trip.Arrival.Time);
+        itinerary.to = jsonToCoordinates(trip.Arrival.Site.Position);
+        routerResponse.itineraries.push(itinerary);
+
+        for (const jsonSection of trip.sections.Section) {
+
+            const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+
+            const leg = new Leg();
+
+            leg.mode = jsonLeg.TransportMode;
+            leg.duration = parseDuration(jsonLeg.Duration);
+            leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
+            leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
+            leg.coords = [];
+
+            if (leg.mode === 'WALK' || leg.mode === 'BICYCLE') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                };
+
+                leg.steps = [];
+                for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+                    const step = new Step();
+                    let stepCoords;
+                    if (jsonPathLink.Geometry) {
+                        stepCoords = parseWKTGeometry(jsonPathLink.Geometry);
+                    } else {
+                        stepCoords = [leg.from.coords, leg.to.coords];
+                    }
+                    step.coords = stepCoords[0];
+                    step._idCoordsInLeg = leg.coords.length;
+                    stepCoords.forEach((coords, idx) => {
+                        if (
+                            idx !== 0
+                            || leg.coords.length === 0
+                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                        ) {
+                            leg.coords.push(coords);
+                        }
+                    });
+
+
+                    step.name = jsonPathLink.Departure.Site.Name;
+                    step.levelChange = null;
+
+                    step.distance = jsonPathLink.Distance;
+
+                    leg.steps.push(step);
+                }
+
+            } else if (leg.mode === 'BUS' || leg.mode === 'TRAM' || leg.mode === 'FUNICULAR') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
+                };
+
+                leg.transportInfo = {
+                    name: jsonLeg.Line.Number,
+                    routeColor: jsonLeg.Line.Color,
+                    routeTextColor: jsonLeg.Line.TextColor,
+                    directionName: jsonLeg.Destination
+                };
+
+                for (const jsonStep of jsonLeg.steps.Step) {
+                    const stepCoords = parseWKTGeometry(jsonStep.Geometry);
+                    stepCoords.forEach((coords, idx) => {
+                        if (
+                            idx !== 0
+                            || leg.coords.length === 0
+                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                        ) {
+                            leg.coords.push(coords);
+                        }
+                    });
+                }
+
+                const legStep = new Step();
+                legStep.coords = leg.coords[0];
+                legStep._idCoordsInLeg = 0;
+                legStep.name = jsonLeg.Line.Name;
+                legStep.levelChange = null;
+                legStep.distance = jsonLeg.Distance;
+                leg.steps = [legStep];
+            }
+
+            leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
+
+            itinerary.legs.push(leg);
+
+        }
+
+        itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+            if (idx === 0) {
+                return acc;
+            }
+            return acc + arr[idx - 1].distanceTo(coords);
+        }, 0);
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+    }
+
+    routerResponse.from = routerResponse.itineraries[0].from;
+    routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
+
+    return routerResponse;
+}
+
+var CitywayUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     jsonToCoordinates: jsonToCoordinates,
     createRouterResponseFromJson: createRouterResponseFromJson
@@ -1771,5 +1998,5 @@ class ItineraryInfoManager {
 
 }
 
-export { Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsmElement, OsmModel, OsmNetworkUtils, OsmNode, OsmParser, OsmRouter, OsmRouterOptions, OsmRouterUtils, OsmWay, OsrmUtils, OtpUtils, RouterResponse, Step };
+export { CitywayUtils, Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsmElement, OsmModel, OsmNetworkUtils, OsmNode, OsmParser, OsmRouter, OsmRouterOptions, OsmRouterUtils, OsmWay, OsrmUtils, OtpUtils, RouterResponse, Step };
 //# sourceMappingURL=wemap-osm.es.js.map