@wemap/osm 4.0.14 → 5.0.0

package/package.json

@@ -11,7 +11,7 @@
         "directory": "packages/osm"
     },
     "name": "@wemap/osm",
-    "version": "4.0.14",
+    "version": "5.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -25,10 +25,11 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/geo": "^4.0.14",
-        "@wemap/logger": "^4.0.0",
-        "@wemap/maths": "^4.0.3",
+        "@mapbox/polyline": "^1.1.1",
+        "@wemap/geo": "^5.0.0",
+        "@wemap/logger": "^5.0.0",
+        "@wemap/maths": "^5.0.0",
         "sax": "^1.2.4"
     },
-    "gitHead": "0b7188383438fcb1dd498dd117799076115dfee6"
+    "gitHead": "73607e294f29d3f9a41673bfc25ad9489a1da7f4"
 }

package/src/routers/Itinerary.js

@@ -0,0 +1,185 @@
+/* eslint-disable max-statements */
+import { Coordinates, Network } from '@wemap/geo';
+import Leg from './Leg.js';
+
+/**
+ * Main attributes are:
+ * nodes: the ordered list of Node
+ * edges: the ordered list of Edge
+ * start: the start point (Coordinates)
+ * end: the end point (Coordinates)
+ * length: the route length
+ */
+class Itinerary {
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!(Leg[])} */
+    legs = [];
+
+    /** @type {?Coordinates[]} */
+    _coords = null;
+
+    set coords(_) {
+        throw new Error('Itinerary.coords cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Coordinates[])} */
+    get coords() {
+        if (!this._coords) {
+            // Returns the coordinates contained in all legs and remove duplicates between array
+            this._coords = this.legs.reduce((acc, val) => {
+                const isDuplicate = acc.length && val.coords.length && acc[acc.length - 1].equalsTo(val.coords[0]);
+                acc.push(...val.coords.slice(isDuplicate ? 1 : 0));
+                return acc;
+            }, []);
+        }
+        return this._coords;
+    }
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @param {Itinerary[]} itineraries
+     * @returns {Itinerary}
+     */
+    static fromItineraries(...itineraries) {
+        const itinerary = new Itinerary();
+        itinerary.from = itineraries[0].from;
+        itinerary.to = itineraries[itineraries.length - 1].to;
+        itinerary.distance = 0;
+        itinerary.duration = 0;
+        itinerary.legs = [];
+
+        itineraries.forEach(_itinerary => {
+            itinerary.distance += _itinerary.distance;
+            itinerary.duration += _itinerary.duration;
+            itinerary.legs.push(..._itinerary.legs);
+            itinerary.legs.forEach(leg => {
+                leg.steps[0].firstStep = false;
+                leg.steps[leg.steps.length - 1].lastStep = false;
+            });
+        });
+
+        itinerary.legs[0].steps[0].firstStep = true;
+        const lastLeg = itinerary.legs[itinerary.legs.length - 1];
+        lastLeg.steps[lastLeg.steps.length - 1].lastStep = true;
+
+        return itinerary;
+    }
+
+    /**
+     * Convert lat/lng/level points to Itinerary
+     * @param {number[][]} points 2D points array of lat/lng/level (level is optional)
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedPointsArray(points, start, end) {
+
+        const pointToCoordinates = point => new Coordinates(point[0], point[1], null, point[2]);
+
+        return this.fromOrderedCoordinates(
+            points.map(pointToCoordinates),
+            pointToCoordinates(start),
+            pointToCoordinates(end)
+        );
+    }
+
+    /**
+     * Convert ordered Coordinates to Itinerary
+     * @param {Coordinates[]} points
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedCoordinates(points, from, to, mode = 'WALK') {
+
+        const itinerary = new Itinerary();
+        itinerary.from = from;
+        itinerary.to = to;
+
+        const leg = new Leg();
+        leg.mode = mode;
+        leg.from = from;
+        leg.to = to;
+
+        leg.coords = points;
+        leg.distance = points.reduce((acc, coords, idx, arr) => {
+            if (idx !== 0) {
+                return acc + arr[idx - 1].distanceTo(coords);
+            }
+            return acc;
+        }, 0);
+        leg.duration = leg.distance;
+
+        itinerary.distance = leg.distance;
+        itinerary.duration = leg.duration;
+
+        return itinerary;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            legs: this.legs.map(leg => leg.toJson())
+        };
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Itinerary}
+     */
+    static fromJson(json) {
+        const itinerary = new Itinerary();
+        itinerary.from = Coordinates.fromCompressedJson(json.from);
+        itinerary.to = Coordinates.fromCompressedJson(json.to);
+        itinerary.distance = json.distance;
+        itinerary.duration = json.duration;
+        itinerary.legs = json.legs.map(Leg.fromJson);
+        if (json.startTime) {
+            itinerary.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            itinerary.endTime = json.endTime;
+        }
+        return itinerary;
+    }
+}
+export default Itinerary;

package/src/routers/Itinerary.type.spec.js

@@ -0,0 +1,104 @@
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import LevelChange from './LevelChange.js';
+import Leg from './Leg.js';
+import Itinerary from './Itinerary.js';
+import Step from './Step.js';
+
+const { expect } = chai;
+
+
+const isNullOrNumber = val => val === null || typeof val === 'number';
+const isNullOrString = val => val === null || typeof val === 'string';
+const isNullOrObject = val => val === null || typeof val === 'object';
+const isNullOrArray = val => val === null || Array.isArray(val);
+const isNullOrLevelChange = val => val === null || val instanceof LevelChange;
+
+const isUndefinedOrBoolean = val => typeof val === 'undefined' || typeof val === 'boolean';
+const isUndefinedOrString = val => typeof val === 'undefined' || typeof val === 'string';
+
+const stepExtraProperties = ['subwayEntrance', 'subwayEntranceRef'];
+
+/**
+ * @param {Step} step
+ */
+export function verifyStepData(step) {
+
+    expect(step).instanceOf(Step);
+    expect(step.firstStep).be.a('boolean');
+    expect(step.lastStep).be.a('boolean');
+    expect(step.number).be.a('number');
+    expect(step.coords).instanceOf(Coordinates);
+    expect(step.angle).be.a('number');
+    expect(step.previousBearing).be.a('number');
+    expect(step.nextBearing).be.a('number');
+    expect(step.distance).be.a('number');
+    expect(step.duration).satisfies(isNullOrNumber);
+    expect(step.name).satisfies(isNullOrString);
+    expect(step.levelChange).satisfies(isNullOrLevelChange);
+
+    expect(step.extras).satisfies(isNullOrObject);
+    if (step.extras !== null) {
+        for (const key of Object.keys(step.extras)) {
+            expect(stepExtraProperties).includes(key);
+        }
+        expect(step.extras.subwayEntrance).satisfies(isUndefinedOrBoolean);
+        expect(step.extras.subwayEntranceRef).satisfies(isUndefinedOrString);
+    }
+}
+
+/**
+ * @param {Leg} routerResponse
+ */
+export function verifyLegData(leg) {
+
+    expect(leg).instanceOf(Leg);
+    expect(leg.mode).be.a('string');
+    expect(leg.distance).be.a('number');
+    expect(leg.duration).be.a('number');
+    expect(leg.startTime).satisfies(isNullOrNumber);
+    expect(leg.endTime).satisfies(isNullOrNumber);
+    expect(leg.from).be.an('object');
+    expect(leg.from.name).satisfies(isNullOrString);
+    expect(leg.from.coords).instanceOf(Coordinates);
+    expect(leg.to).be.an('object');
+    expect(leg.to.name).satisfies(isNullOrString);
+    expect(leg.to.coords).instanceOf(Coordinates);
+    expect(leg.coords).be.an('array');
+    leg.coords.forEach(coords => expect(coords).instanceOf(Coordinates));
+
+    expect(leg.transportInfo).satisfies(isNullOrObject);
+    if (leg.transportInfo !== null) {
+        expect(leg.transportInfo.name).be.a('string');
+        expect(leg.transportInfo.routeColor).satisfies(isNullOrString);
+        expect(leg.transportInfo.routeTextColor).satisfies(isNullOrString);
+        expect(leg.transportInfo.directionName).satisfies(isNullOrString);
+    }
+    expect(leg.steps).satisfies(isNullOrArray);
+    if (leg.steps !== null) {
+        leg.steps.forEach(verifyStepData);
+    }
+}
+
+
+/**
+ * @param {Itinerary} itinerary
+ */
+export function verifyItineraryData(itinerary) {
+
+    expect(itinerary).instanceOf(Itinerary);
+    expect(itinerary.from).instanceOf(Coordinates);
+    expect(itinerary.to).instanceOf(Coordinates);
+    expect(itinerary.coords).be.an('array');
+    for (const coords of itinerary.coords) {
+        expect(coords).instanceOf(Coordinates);
+    }
+    expect(itinerary.distance).be.a('number');
+    expect(itinerary.duration).be.a('number');
+    expect(itinerary.startTime).satisfies(isNullOrNumber);
+    expect(itinerary.endTime).satisfies(isNullOrNumber);
+    expect(itinerary.legs).be.an('array');
+    itinerary.legs.forEach(verifyLegData);
+}

package/src/routers/Leg.js

@@ -0,0 +1,101 @@
+import { Coordinates, Network } from '@wemap/geo';
+
+import Step from './Step.js';
+
+class Leg {
+
+    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR */
+    mode;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    from;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    to;
+
+    /** @type {!Coordinates[]} */
+    coords;
+
+    /** @type {?{name: !string, routeColor: ?string, routeTextColor: ?string, directionName: ?string}} */
+    transportInfo = null;
+
+    /** @type {?(Step[])} */
+    steps = null;
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            mode: this.mode,
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            coords: this.coords.map(coords => coords.toCompressedJson())
+        };
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        if (this.transportInfo !== null) {
+            output.transportInfo = this.transportInfo;
+        }
+        if (this.steps !== null && this.steps.length > 0) {
+            output.steps = this.steps.map(step => step.toJson());
+        }
+        return output;
+    }
+
+
+    /**
+     * @param {object} json
+     * @returns {Leg}
+     */
+    static fromJson(json) {
+        const leg = new Leg();
+        leg.mode = json.mode;
+        leg.from = Coordinates.fromCompressedJson(json.from);
+        leg.to = Coordinates.fromCompressedJson(json.to);
+        leg.distance = json.distance;
+        leg.duration = json.duration;
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+        if (json.startTime) {
+            leg.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            leg.endTime = json.endTime;
+        }
+        if (json.transportInfo) {
+            leg.transportInfo = json.transportInfo;
+        }
+        if (json.steps) {
+            leg.steps = json.steps.map(Step.fromJson);
+        }
+        return leg;
+    }
+
+}
+
+export default Leg;

package/src/routers/LevelChange.js

@@ -0,0 +1,65 @@
+import { Level, GraphNode, GraphUtils } from '@wemap/geo';
+
+import OsmElement from '../model/OsmElement.js';
+
+class LevelChange {
+
+    /** @type {!string} [up|down] */
+    direction;
+
+    /** @type {!number} [-2, -1, 1, ...] */
+    difference;
+
+    /** @type {?string} [elevator|conveyor|stairs] */
+    type = null;
+
+    /**
+     * @param {GraphNode<OsmElement>} firstNode
+     * @param {GraphNode<OsmElement>} secondNode
+     * @returns {LevelChange}
+     */
+    static fromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.builtFrom.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.builtFrom.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.builtFrom.areStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return {
+            direction: this.direction,
+            difference: this.difference,
+            type: this.type
+        };
+    }
+
+    /**
+     * @param {object} json
+     * @returns {LevelChange}
+     */
+    static fromJson(json) {
+        const levelChange = new LevelChange();
+        levelChange.direction = json.direction;
+        levelChange.difference = json.difference;
+        levelChange.type = json.type;
+        return levelChange;
+    }
+}
+
+export default LevelChange;

package/src/routers/RouterResponse.js

@@ -0,0 +1,19 @@
+import { Coordinates } from '@wemap/geo';
+
+import Itinerary from './Itinerary.js';
+class RouterResponse {
+
+    /** @type {!string} */
+    routerName;
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!(Itinerary[])} */
+    itineraries = [];
+}
+
+export default RouterResponse;

package/src/routers/RouterResponse.type.spec.js

@@ -0,0 +1,24 @@
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from './RouterResponse.js';
+
+import { verifyItineraryData } from './Itinerary.type.spec.js';
+
+const { expect } = chai;
+
+/**
+ * @param {RouterResponse} routerResponse
+ */
+export function verifyRouterResponseData(routerResponse) {
+
+    expect(routerResponse).instanceOf(RouterResponse);
+    expect(routerResponse.routerName).be.a('string');
+    expect(routerResponse.from).instanceOf(Coordinates);
+    expect(routerResponse.to).instanceOf(Coordinates);
+    expect(routerResponse.itineraries).be.an('array');
+    routerResponse.itineraries.forEach(verifyItineraryData);
+
+}
+

package/src/routers/Step.js

@@ -0,0 +1,113 @@
+import { Coordinates } from '@wemap/geo';
+
+import LevelChange from './LevelChange.js';
+
+class Step {
+
+    /** @type {!boolean} */
+    firstStep = false;
+
+    /** @type {!boolean} */
+    lastStep = false;
+
+    /** @type {!number} */
+    number;
+
+    /** @type {!Coordinates} */
+    coords = [];
+
+
+    /** @type {!number} */
+    angle;
+
+    /** @type {!number} */
+    previousBearing;
+
+    /** @type {!number} */
+    nextBearing;
+
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {?number} */
+    duration = null;
+
+    /** @type {?string} */
+    name = null;
+
+
+    /** @type {?LevelChange} */
+    levelChange = null;
+
+    /** @type {?{?subwayEntrance: boolean, ?subwayEntranceRef: string}} */
+    extras = {};
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            number: this.number,
+            coords: this.coords.toCompressedJson(),
+            angle: this.angle,
+            previousBearing: this.previousBearing,
+            nextBearing: this.nextBearing,
+            distance: this.distance
+        };
+        if (this.firstStep) {
+            output.firstStep = true;
+        }
+        if (this.lastStep) {
+            output.lastStep = true;
+        }
+        if (this.duration !== null) {
+            output.duration = this.duration;
+        }
+        if (this.name !== null) {
+            output.name = this.name;
+        }
+        if (this.levelChange !== null) {
+            output.levelChange = this.levelChange.toJson();
+        }
+        if (this.extras !== null) {
+            output.extras = this.extras;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Step}
+     */
+    static fromJson(json) {
+        const step = new Step();
+        step.number = json.number;
+        step.coords = Coordinates.fromCompressedJson(json.coords);
+        step.angle = json.angle;
+        step.previousBearing = json.previousBearing;
+        step.nextBearing = json.nextBearing;
+        step.distance = json.distance;
+        if (json.firstStep) {
+            step.firstStep = json.firstStep;
+        }
+        if (json.lastStep) {
+            step.lastStep = json.lastStep;
+        }
+        if (json.duration) {
+            step.duration = json.duration;
+        }
+        if (json.name) {
+            step.name = json.name;
+        }
+        if (json.levelChange) {
+            step.levelChange = LevelChange.fromJson(json.levelChange);
+        }
+        if (json.extras) {
+            step.extras = json.extras;
+        }
+        return step;
+    }
+}
+
+export default Step;

package/src/routers/Utils.js

@@ -0,0 +1,22 @@
+import Itinerary from './Itinerary.js';
+
+/**
+ * @param {Itinerary} itinerary
+ */
+export function generateStepsNumbers(itinerary) {
+    let counter = 1;
+    itinerary.legs.forEach((leg, legId) => {
+        leg.steps.forEach((step, stepId) => {
+
+            if (counter === 1) {
+                step.firstStep = true;
+            }
+            if (legId === itinerary.legs.length - 1
+                && stepId === leg.steps.length - 1) {
+                step.lastStep = true;
+            }
+
+            step.number = counter++;
+        });
+    });
+}