@wemap/routers 6.0.0

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

@@ -0,0 +1,105 @@
+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._idCoordsInLeg).be.a('number');
+
+    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/model/ItineraryInfo.js

@@ -0,0 +1,34 @@
+import { GraphProjection } from '@wemap/geo';
+
+import Leg from './Leg.js';
+import Step from './Step.js';
+
+class ItineraryInfo {
+
+    /** @type {Step} */
+    nextStep;
+
+    /** @type {Step} */
+    previousStep;
+
+    /** @type {GraphProjection} */
+    projection;
+
+    /** @type {Leg} */
+    leg;
+
+    /** @type {number} */
+    traveledDistance;
+
+    /** @type {number} */
+    traveledPercentage;
+
+    /** @type {number} */
+    remainingDistance;
+
+    /** @type {number} */
+    remainingPercentage;
+
+}
+
+export default ItineraryInfo;

package/src/model/Leg.js

@@ -0,0 +1,113 @@
+import { Coordinates, Network } from '@wemap/geo';
+
+import Step from './Step.js';
+
+class Leg {
+
+    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    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: { coords: this.from.coords.toCompressedJson() },
+            to: { coords: this.to.coords.toCompressedJson() },
+            distance: this.distance,
+            duration: this.duration,
+            coords: this.coords.map(coords => coords.toCompressedJson())
+        };
+        if (this.from.name) {
+            output.from.name = this.from.name;
+        }
+        if (this.to.name) {
+            output.to.name = this.to.name;
+        }
+        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 = { coords: Coordinates.fromCompressedJson(json.from.coords) };
+        leg.to = { coords: Coordinates.fromCompressedJson(json.to.coords) };
+        leg.distance = json.distance;
+        leg.duration = json.duration;
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+        if (json.from.name) {
+            leg.from.name = json.from.name;
+        }
+        if (json.to.name) {
+            leg.to.name = json.to.name;
+        }
+        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/model/LevelChange.js

@@ -0,0 +1,65 @@
+import { Level, GraphNode, GraphUtils } from '@wemap/geo';
+
+import { OsmElement } from '@wemap/osm';
+
+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/model/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/model/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/model/Step.js

@@ -0,0 +1,118 @@
+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 = {};
+
+    /** @type {!number} */
+    _idCoordsInLeg = null;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            number: this.number,
+            coords: this.coords.toCompressedJson(),
+            angle: this.angle,
+            previousBearing: this.previousBearing,
+            nextBearing: this.nextBearing,
+            distance: this.distance,
+            _idCoordsInLeg: this._idCoordsInLeg
+        };
+        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 && Object.keys(this.extras).length !== 0) {
+            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;
+        step._idCoordsInLeg = json._idCoordsInLeg;
+        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;