@wemap/routers 12.10.8 → 12.11.0

package/src/graph/Vertex.ts

@@ -1,45 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-
-import { GraphVertexJson } from '../types.js';
-
-export type VertexProperties = {
-
-    name?: string;
-    externalId?: string | number;
-
-    isGate?: boolean;
-    isSubwayEntrance?: boolean;
-    subwayEntranceRef?: string;
-}
-
-export default class Vertex {
-
-    public id = -1;
-
-    constructor(public coords: Coordinates, public properties: VertexProperties = {}) { }
-
-    distanceTo(other: Vertex) {
-        return this.coords.distanceTo(other.coords);
-    }
-
-    bearingTo(other: Vertex) {
-        return this.coords.bearingTo(other.coords);
-    }
-
-    toJson(): GraphVertexJson {
-        return {
-            id: this.id,
-            coords: this.coords.toCompressedJson(),
-            ...(Object.keys(this.properties).length > 0 && { properties: this.properties })
-        }
-    }
-
-    static fromJson(json: GraphVertexJson) {
-        const v = new Vertex(
-            Coordinates.fromCompressedJson(json.coords),
-            json.properties
-        );
-        v.id = json.id;
-        return v;
-    }
-}

package/src/model/Itinerary.spec.ts

@@ -1,134 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-
-import { Coordinates } from '@wemap/geo';
-import { diffAngle } from '@wemap/maths';
-
-import Itinerary from './Itinerary.js';
-import { leg1, leg2, leg3, leg4 } from './Leg.spec.js';
-import Leg from './Leg.js';
-
-const expect = chai.expect;
-
-const itinerary1 = new Itinerary({
-    origin: new Coordinates(0, 0),
-    destination: new Coordinates(1, 0),
-    legs: [leg1]
-});
-
-const itinerary2 = new Itinerary({
-    origin: new Coordinates(0, 0),
-    destination: new Coordinates(1, 0),
-    duration: 200,
-    legs: [Leg.fromJson(leg1.toJson()), Leg.fromJson(leg2.toJson())],
-    startTime: 0,
-    endTime: 10
-});
-
-const itinerary3 = new Itinerary({
-    origin: new Coordinates(0, 0),
-    destination: new Coordinates(3, 0),
-    duration: 2000,
-    legs: [
-        Leg.fromJson(leg1.toJson()),
-        Leg.fromJson(leg2.toJson()),
-        Leg.fromJson(leg3.toJson()),
-        Leg.fromJson(leg4.toJson())
-    ],
-});
-
-const itinerary4 = new Itinerary({
-    origin: new Coordinates(1, 0),
-    destination: new Coordinates(4, 0),
-    duration: 20000,
-    legs: [Leg.fromJson(leg1.toJson())],
-});
-
-const itinerary5 = new Itinerary({
-    origin: new Coordinates(1, 0),
-    destination: new Coordinates(4, 0),
-    duration: 20000,
-    legs: [Leg.fromJson(leg1.toJson())],
-});
-
-export const verifyStepsCoherence = (itinerary: Itinerary) => {
-
-    chai.use(chaiAlmost(1e-3));
-
-    const itineraryCoords = itinerary.coords
-        // Remove duplicates
-        .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-    const steps = itinerary.steps;
-
-
-    steps.forEach((step, stepId) => {
-        const coordsId = itineraryCoords.findIndex(coords => coords.equals(step.coords));
-        expect(coordsId).not.equal(-1);
-
-        const coordsBeforeStep = coordsId === 0 ? itinerary.origin : itineraryCoords[coordsId - 1];
-        const coordsAfterStep = coordsId === itineraryCoords.length - 1
-            ? itinerary.destination
-            : itineraryCoords[coordsId + 1];
-
-        expect(step.number).equals(stepId + 1);
-        expect(step.previousBearing).equals(coordsBeforeStep.bearingTo(step.coords));
-        expect(step.nextBearing).equals(step.coords.bearingTo(coordsAfterStep));
-        expect(step.angle).almost.equals(diffAngle(step.previousBearing, step.nextBearing + Math.PI));
-        expect(step.firstStep).equals(stepId === 0);
-        expect(step.lastStep).equals(stepId === steps.length - 1);
-    });
-    itinerary.legs.forEach(leg => {
-        const legSteps = leg.steps;
-        expect(legSteps.length).not.equals(0);
-        legSteps.forEach(step => expect(step).is.not.undefined);
-    });
-}
-
-describe('Itinerary', () => {
-
-    it('equals', () => {
-        expect(itinerary1.equals(itinerary1)).is.true;
-        expect(itinerary2.equals(itinerary2)).is.true;
-        expect(itinerary3.equals(itinerary3)).is.true;
-        expect(itinerary4.equals(itinerary4)).is.true;
-        expect(itinerary4.equals(itinerary5)).is.true;
-        expect(itinerary1.equals(itinerary2)).is.false;
-        expect(itinerary1.equals(itinerary3)).is.false;
-        expect(itinerary1.equals(itinerary4)).is.false;
-    });
-
-    it('steps coherence', () => {
-        verifyStepsCoherence(itinerary1);
-        verifyStepsCoherence(itinerary2);
-        verifyStepsCoherence(itinerary3);
-        verifyStepsCoherence(itinerary4);
-        verifyStepsCoherence(itinerary5);
-    });
-
-    it('from / to JSON', () => {
-
-        const itinerary1Json = itinerary1.toJson();
-        expect(itinerary1Json).be.an('object');
-        const itinerary1Bis = Itinerary.fromJson(itinerary1Json);
-        expect(itinerary1.equals(itinerary1Bis)).is.true;
-
-        const itinerary2Json = itinerary2.toJson();
-        expect(itinerary2Json).be.an('object');
-        const itinerary2Bis = Itinerary.fromJson(itinerary2Json);
-        expect(itinerary2.equals(itinerary2Bis)).is.true;
-
-        const itinerary3Json = itinerary3.toJson();
-        expect(itinerary3Json).be.an('object');
-        const itinerary3Bis = Itinerary.fromJson(itinerary3Json);
-        expect(itinerary3.equals(itinerary3Bis)).is.true;
-
-        const itinerary4Json = itinerary4.toJson();
-        expect(itinerary4Json).be.an('object');
-        const itinerary4Bis = Itinerary.fromJson(itinerary4Json);
-        expect(itinerary4.equals(itinerary4Bis)).is.true;
-
-    });
-
-});
-
-export { itinerary1, itinerary2, itinerary3, itinerary4 };

package/src/model/Itinerary.ts

@@ -1,370 +0,0 @@
-import { Feature, FeatureCollection, MultiLineString, Point } from 'geojson';
-import { Coordinates, Level, Utils as GeoUtils, CoordinatesJson, Level_t } from '@wemap/geo';
-import { diffAngle, Point2_t, Vector3_t } from '@wemap/maths';
-
-import Graph from '../graph/Graph.js';
-import Leg, { type LegJson } from './Leg.js';
-import { isTransitModePublicTransport, type TransitMode } from './TransitMode.js';
-import { Step } from './Step.js';
-import { getDurationFromLength } from '../Utils.js';
-import StepsBuilder from './StepsBuilder.js';
-import GraphRoute from '../graph/GraphRoute.js';
-
-
-export type ItineraryCommon = {
-    startTime?: number,
-    endTime?: number
-};
-
-export type ItineraryJson = {
-    transitMode: TransitMode,
-    origin: CoordinatesJson,
-    destination: CoordinatesJson,
-    distance: number,
-    duration: number,
-    legs: LegJson[]
-} & ItineraryCommon;
-
-
-export type ItineraryConstructor = {
-    origin: Coordinates,
-    destination: Coordinates,
-    duration?: number
-    legs: Leg[],
-} & ItineraryCommon;
-
-/**
- * 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
- */
-export default class Itinerary {
-
-    origin: Coordinates;
-    destination: Coordinates;
-    duration: number;
-    readonly legs: Leg[];
-
-    private _transitMode: TransitMode | null = null;
-    startTime: number | null;
-    endTime: number | null;
-
-    private _coords: Coordinates[] | null = null;
-    private _distance: number | null = null;
-
-    constructor({
-        origin, destination, duration, legs, startTime, endTime
-    }: ItineraryConstructor) {
-        this.origin = origin;
-        this.destination = destination;
-        this.legs = legs;
-        if (typeof duration === 'number') {
-            this.duration = duration;
-        } else {
-            this.duration = this.legs.reduce((dur, leg) => dur + leg.duration, 0);
-        }
-        this.startTime = typeof startTime === 'number' ? startTime : null;
-        this.endTime = typeof endTime === 'number' ? endTime : null;
-
-        this.updateStepsFromLegs();
-    }
-
-    set coords(_) {
-        throw new Error('Itinerary.coords cannot be set. They are calculated from Itinerary.legs.');
-    }
-
-    public get coords() {
-        if (!this._coords) {
-            this._coords = this.legs.map(leg => leg.coords)
-                .flat()
-                // Remove duplicates
-                .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-        }
-        return this._coords;
-    }
-
-    set steps(_) {
-        throw new Error('Itinerary.step cannot be set. They are calculated from Itinerary.legs.');
-    }
-
-    get steps(): Step[] {
-        return this.legs.map(leg => leg.steps).flat();
-    }
-
-    set transitMode(_) {
-        throw new Error('Itinerary.transitMode cannot be set. They are calculated from Itinerary.legs.');
-    }
-
-    // Transit mode will return MULTI if there are several transit modes except WALK
-    // Else it will return the only transit mode
-    // fallback to WALK if no transit mode
-    get transitMode() {
-        if (!this._transitMode) {
-            const legTransitModes = new Set(this.legs.map(leg => leg.transitMode));
-
-            // Remove WALK from transit modes
-            legTransitModes.delete('WALK');
-
-            if (legTransitModes.size > 1) {
-                this._transitMode = 'MULTI';
-
-                return this._transitMode;
-            }
-
-            if (legTransitModes.size === 1) {
-                this._transitMode = legTransitModes.values().next().value as TransitMode;
-
-                return this._transitMode;
-            }
-
-            this._transitMode = 'WALK';
-        }
-
-        return this._transitMode;
-
-    }
-
-    set distance(_) {
-        throw new Error('Itinerary.distance cannot be set. They are calculated from Itinerary.legs.');
-    }
-
-    get distance() {
-        if (this._distance === null) {
-            this._distance = GeoUtils.calcDistance(this.coords);
-        }
-        return this._distance;
-
-        // Does not work if legs does not intersect
-        // return this.legs.reduce((dist, leg) => dist + leg.distance, 0);
-    }
-
-    toGraph() {
-        return Graph.fromCoordinatesSegments([this.coords]);
-    }
-
-    static fromItineraries(...itineraries: Itinerary[]) {
-        return new Itinerary({
-            origin: itineraries[0].origin,
-            destination: itineraries[itineraries.length - 1].destination,
-            legs: itineraries.map(itinerary => itinerary.legs).flat(),
-        });
-    }
-
-    /**
-     * Convert lat/lng/level? points to Itinerary
-     */
-    static fromOrderedPointsArray(
-        points: (Point2_t | Vector3_t)[],
-        start: (Point2_t | Vector3_t),
-        end: (Point2_t | Vector3_t)) {
-
-        const pointToCoordinates = (point: Point2_t | Vector3_t) =>
-            new Coordinates(point[0], point[1], null, point[2]);
-
-        return this.fromOrderedCoordinates(
-            points.map(pointToCoordinates),
-            pointToCoordinates(start),
-            pointToCoordinates(end)
-        );
-    }
-
-    /**
-     * Convert ordered Coordinates to Itinerary
-     */
-    static fromOrderedCoordinates(
-        coords: Coordinates[],
-        origin: Coordinates,
-        destination: Coordinates,
-        transitMode: TransitMode = 'WALK'
-    ) {
-
-        const steps = new StepsBuilder().setPathCoords(coords).setStart(origin).setEnd(destination).build();
-
-        const leg = new Leg({
-            start: { coords: origin },
-            end: { coords: destination },
-            coords,
-            transitMode,
-            steps
-        });
-
-        return new Itinerary({ origin, destination, legs: [leg] });
-    }
-
-
-    static equals(obj1: Itinerary, obj2: Itinerary) {
-        const intermediate = obj1.origin.equals(obj2.origin)
-            && obj1.destination.equals(obj2.destination)
-            && Math.abs(obj1.distance - obj2.distance) <= 0.05
-            && Math.abs(obj1.duration - obj2.duration) <= 0.05
-            && obj1.startTime === obj2.startTime
-            && obj1.endTime === obj2.endTime
-            && obj1.legs.length === obj2.legs.length;
-
-        if (!intermediate) {
-            return false;
-        }
-
-        for (let i = 0; i < obj1.legs.length; i++) {
-            if (!obj1.legs[i].equals(obj2.legs[i])) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    equals(obj: Itinerary) {
-        return Itinerary.equals(this, obj);
-    }
-
-    toJson(): ItineraryJson {
-        return {
-            origin: this.origin.toJson(),
-            destination: this.destination.toJson(),
-            distance: Number(this.distance.toFixed(1)),
-            duration: Number(this.duration.toFixed(1)),
-            transitMode: this.transitMode,
-            legs: this.legs.map(leg => leg.toJson()),
-            ...(this.startTime !== null && { startTime: this.startTime }),
-            ...(this.endTime !== null && { endTime: this.endTime })
-        };
-    }
-
-    static fromJson(json: ItineraryJson) {
-        return new Itinerary({
-            origin: Coordinates.fromJson(json.origin),
-            destination: Coordinates.fromJson(json.destination),
-            duration: json.duration,
-            legs: json.legs.map(Leg.fromJson),
-            startTime: json.startTime,
-            endTime: json.endTime
-        });
-    }
-
-    static fromGraphRoute(graphRoute: GraphRoute, transitMode: TransitMode = 'WALK') {
-        const leg = Leg.fromGraphRoute(graphRoute, transitMode);
-        return new Itinerary({
-            origin: graphRoute.start,
-            destination: graphRoute.end,
-            legs: [leg]
-        });
-    }
-
-    // TODO: Remove when possible...
-    // Livemap specific
-    multiplyLevel(levelFactor: number) {
-
-        this.origin.level = Level.multiplyBy(this.origin.level, levelFactor);
-        this.destination.level = Level.multiplyBy(this.destination.level, levelFactor);
-
-        this.legs.forEach(leg => leg.multiplyLevel(levelFactor));
-
-        // It is not necessary to multiply this._coords because 
-        //  coords are not cloned between legs and itinerary
-    }
-
-    // TODO: Remove when possible...
-    // Livemap specific
-    forceUnknownLevelTo0() {
-
-        this.origin.level = this.origin.level || 0;
-        this.destination.level = this.destination.level || 0;
-
-        for (const leg of this.legs) {
-            leg.start.coords.level = leg.start.coords.level || 0;
-            leg.end.coords.level = leg.end.coords.level || 0;
-            for (const coords of leg.coords) {
-                coords.level = coords.level || 0;
-            }
-            if (leg.steps) {
-                for (const step of leg.steps) {
-                    step.coords.level = step.coords.level || 0;
-                }
-            }
-        }
-
-        if (this._coords) {
-            for (const coords of this._coords) {
-                coords.level = coords.level || 0;
-            }
-        }
-    }
-
-    toGeoJson(): FeatureCollection {
-        const transformToPoint = (point: Coordinates, name?: string, type?: string): Feature<Point> => ({
-            type: "Feature",
-            properties: { name, level: point.level, ...(type && { type }) },
-            geometry: {
-                type: 'Point',
-                coordinates: [point.lng, point.lat]
-            }
-        });
-        const transformToMultiLineStrings = (segments: Coordinates[][], level: Level_t): Feature<MultiLineString> => ({
-            type: "Feature",
-            properties: { level, name: level?.toString() },
-            geometry: {
-                type: 'MultiLineString',
-                coordinates: segments.map(s => s.map(({ lat, lng }) => [lng, lat]))
-            }
-        });
-
-        const levelsOfItinerary = [...new Set(this.coords.map(c => Level.toString(c.level)))].map(Level.fromString);
-        const segmentsSplitted: [Level_t, Coordinates[][]][] = levelsOfItinerary.map(loi => [loi, GeoUtils.createSegmentsAtLevel(this.coords, loi, true)]);
-        const multiLineStrings = segmentsSplitted.map(([loi, segments]) => transformToMultiLineStrings(segments, loi))
-        const legsStarts = this.legs.map((leg, idx) => transformToPoint(leg.start.coords, `Leg ${idx} start`, 'leg-start'));
-        const legsEnds = this.legs.map((leg, idx) => transformToPoint(leg.end.coords, `Leg ${idx} end`, 'leg-end'));
-        const steps = this.steps.map(step => transformToPoint(step.coords, `Step ${step.number}`, 'step'))
-        return {
-            type: "FeatureCollection",
-            features: [
-                transformToPoint(this.origin, 'origin', 'origin'),
-                transformToPoint(this.destination, 'destination', 'destination'),
-                ...multiLineStrings,
-                ...legsStarts,
-                ...legsEnds,
-                ...steps
-            ]
-        };
-    }
-
-    /**
-     * TODO: Remove it in router v3
-     * Update steps info thanks to the coordinates of the whole itinerary.
-     * This method will update:
-     * - all steps number
-     * - first/last steps
-     * - previousBearing/nextBearing/angle of first and last step of each leg
-     */
-    updateStepsFromLegs() {
-
-        const itineraryCoords = this.coords
-            // Remove duplicates
-            .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-        const steps = this.legs.map(leg => leg.steps).flat();
-
-
-        steps.map((step, stepId) => {
-            const coordsId = itineraryCoords.findIndex(coords => coords.equals(step.coords));
-            if (coordsId === -1) {
-                throw new Error('Cannot find step coordinates in itinerary coordinates.');
-            }
-
-            const coordsBeforeStep = coordsId === 0 ? this.origin : itineraryCoords[coordsId - 1];
-            const coordsAfterStep = coordsId === itineraryCoords.length - 1
-                ? this.destination
-                : itineraryCoords[coordsId + 1];
-
-            step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
-            step.nextBearing = step.coords.bearingTo(coordsAfterStep);
-            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
-
-            step.number = stepId + 1;
-            step.firstStep = stepId === 0;
-            step.lastStep = stepId === steps.length - 1;
-        });
-    }
-}

package/src/model/Leg.spec.ts

@@ -1,107 +0,0 @@
-import chai from 'chai';
-
-import { Coordinates } from '@wemap/geo';
-
-import Leg from './Leg.js';
-import { step1, step2, step3, step4 } from './Step.spec.js';
-
-const { expect } = chai;
-
-const leg1 = new Leg({
-    start: { coords: new Coordinates(0, 0) },
-    end: { coords: new Coordinates(1, 0) },
-    coords: [new Coordinates(0, 0), new Coordinates(1, 0)],
-    transitMode: 'CAR',
-    duration: 5
-});
-
-const leg2 = new Leg({
-    start: { coords: new Coordinates(1, 0) },
-    end: { coords: new Coordinates(2, 0) },
-    coords: [new Coordinates(1, 0), new Coordinates(1.5, 0), new Coordinates(2, 0)],
-    transitMode: 'WALK',
-    duration: 200
-});
-
-const leg3 = new Leg({
-    start: { name: 'foo1', coords: new Coordinates(2, 0) },
-    end: { name: 'foo2', coords: new Coordinates(3, 0) },
-    coords: [new Coordinates(2, 0), new Coordinates(3, 0)],
-    transitMode: 'BUS',
-    duration: 300,
-    startTime: 0,
-    endTime: 10,
-    transportInfo: {
-        name: 'foo3',
-        routeColor: '#000',
-        routeTextColor: '#fff',
-        directionName: 'foo4'
-    }
-});
-
-const leg4 = new Leg({
-    start: { coords: new Coordinates(0, 0) },
-    end: { coords: new Coordinates(4, 0) },
-    coords: [new Coordinates(0, 0), new Coordinates(4, 0)],
-    transitMode: 'BOAT',
-    duration: 2000,
-    steps: [step1, step2, step3, step4]
-});
-
-const leg5 = new Leg({
-    start: { coords: new Coordinates(0, 0) },
-    end: { coords: new Coordinates(4, 0) },
-    coords: [new Coordinates(0, 0), new Coordinates(4, 0)],
-    transitMode: 'BOAT',
-    duration: 2000,
-    steps: [step1, step2, step3, step4]
-});
-
-
-describe('Leg', () => {
-
-    it('isPublicTransport', () => {
-        expect(leg1.isPublicTransport()).is.false;
-        expect(leg2.isPublicTransport()).is.false;
-        expect(leg3.isPublicTransport()).is.true;
-        expect(leg4.isPublicTransport()).is.true;
-    });
-
-    it('equals', () => {
-        expect(leg1.equals(leg1)).is.true;
-        expect(leg2.equals(leg2)).is.true;
-        expect(leg3.equals(leg3)).is.true;
-        expect(leg4.equals(leg4)).is.true;
-        expect(leg4.equals(leg5)).is.true;
-        expect(leg1.equals(leg2)).is.false;
-        expect(leg1.equals(leg3)).is.false;
-        expect(leg1.equals(leg4)).is.false;
-    });
-
-    it('from / to JSON', () => {
-
-        const leg1Json = leg1.toJson();
-        expect(leg1Json).be.an('object');
-        const leg1Bis = Leg.fromJson(leg1Json);
-        expect(leg1.equals(leg1Bis)).is.true;
-
-        const leg2Json = leg2.toJson();
-        expect(leg2Json).be.an('object');
-        const leg2Bis = Leg.fromJson(leg2Json);
-        expect(leg2.equals(leg2Bis)).is.true;
-
-        const leg3Json = leg3.toJson();
-        expect(leg3Json).be.an('object');
-        const leg3Bis = Leg.fromJson(leg3Json);
-        expect(leg3.equals(leg3Bis)).is.true;
-
-        const leg4Json = leg4.toJson();
-        expect(leg4Json).be.an('object');
-        const leg4Bis = Leg.fromJson(leg4Json);
-        expect(leg4.equals(leg4Bis)).is.true;
-
-    });
-
-});
-
-export { leg1, leg2, leg3, leg4 };