@wemap/routers 12.10.8 → 12.10.9

package/src/model/Leg.ts

@@ -1,224 +0,0 @@
-import {
-    Coordinates, CoordinatesCompressedJson, Level, Utils as GeoUtils
-} from '@wemap/geo';
-
-import Graph from '../graph/Graph.js';
-import GraphRoute from '../graph/GraphRoute.js';
-import { getDurationFromLength } from '../Utils.js';
-import { TransitMode, isTransitModePublicTransport } from './TransitMode.js';
-
-import { jsonToStep, Step, stepEquals, StepJson, stepToJson } from './Step.js'
-import StepsBuilder from './StepsBuilder.js';
-
-export type Destination = {
-    name: string | null,
-    coords: Coordinates
-};
-
-export type DestinationConstructor = {
-    name?: string,
-    coords: Coordinates
-};
-
-export type DestinationJson = {
-    name?: string,
-    coords: CoordinatesCompressedJson
-};
-
-export type TransportInfo = {
-    name: string,
-    routeColor?: string,
-    routeTextColor?: string,
-    directionName?: string
-}
-
-type LegCommon = {
-    transitMode: TransitMode,
-    startTime?: number,
-    endTime?: number,
-    transportInfo?: TransportInfo,
-}
-
-type LegConstructor =
-    {
-        start: DestinationConstructor,
-        end: DestinationConstructor,
-        coords: Coordinates[],
-        steps?: Step[],
-        duration?: number
-    }
-    & LegCommon;
-
-export type LegJson = {
-    start: DestinationJson,
-    end: DestinationJson,
-    coords: CoordinatesCompressedJson[],
-    steps: StepJson[],
-    distance: number,
-    duration: number
-} & LegCommon;
-
-export default class Leg {
-
-    start: Destination;
-    end: Destination;
-    coords: Coordinates[];
-    distance: number;
-    transitMode: TransitMode;
-
-    duration: number;
-    startTime: number | null;
-    endTime: number | null;
-
-    steps: Step[];
-    transportInfo: TransportInfo | null;
-
-    constructor({
-        start, end, coords, transitMode, duration,
-        startTime, endTime, transportInfo, steps
-    }: LegConstructor) {
-        this.start = {
-            name: start.name || null,
-            coords: start.coords
-        };
-        this.end = {
-            name: end.name || null,
-            coords: end.coords
-        };
-        this.coords = coords;
-        this.transitMode = transitMode;
-        this.distance = GeoUtils.calcDistance(coords)
-        this.duration = typeof duration === 'number' ? duration : getDurationFromLength(this.distance);
-        this.startTime = typeof startTime === 'number' ? startTime : null;
-        this.endTime = typeof endTime === 'number' ? endTime : null;
-        this.transportInfo = transportInfo || null;
-        this.steps = Array.isArray(steps)
-            ? steps
-            : new StepsBuilder().setStart(start.coords).setEnd(end.coords).setPathCoords(coords).build();
-    }
-
-    isPublicTransport() {
-        return isTransitModePublicTransport(this.transitMode);
-    }
-
-    toGraph() {
-        return Graph.fromCoordinatesSegments([this.coords]);
-    }
-
-    static equals(obj1: Leg, obj2: Leg) {
-        const intermediate = obj1.transitMode === obj2.transitMode
-            && Math.abs(obj1.duration - obj2.duration) <= 0.05
-            && obj1.startTime === obj2.startTime
-            && obj1.endTime === obj2.endTime
-            && obj1.start.name === obj2.start.name
-            && obj1.start.coords.equals(obj2.start.coords)
-            && obj1.end.name === obj2.end.name
-            && obj1.end.coords.equals(obj2.end.coords)
-            && obj1.coords.length === obj2.coords.length
-            && (
-                obj1.steps === obj2.steps
-                || obj1.steps?.length === obj2.steps?.length
-            );
-
-        if (!intermediate) {
-            return false;
-        }
-
-        let i;
-        for (i = 0; i < obj1.coords.length; i++) {
-            if (!obj1.coords[i].equals(obj2.coords[i])) {
-                return false;
-            }
-        }
-        for (i = 0; i < obj1.steps.length; i++) {
-            if (!stepEquals(obj1.steps[i], obj2.steps[i])) {
-                return false;
-            }
-        }
-
-        if (obj1.transportInfo !== obj2.transportInfo) {
-            if (obj1.transportInfo === null || obj2.transportInfo === null) {
-                return false;
-            }
-            if (
-                obj1.transportInfo.name !== obj2.transportInfo.name
-                || obj1.transportInfo.routeColor !== obj2.transportInfo.routeColor
-                || obj1.transportInfo.routeTextColor !== obj2.transportInfo.routeTextColor
-                || obj1.transportInfo.directionName !== obj2.transportInfo.directionName
-            ) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    equals(obj: Leg) {
-        return Leg.equals(this, obj);
-    }
-
-    toJson(): LegJson {
-        return {
-            transitMode: this.transitMode,
-            start: {
-                coords: this.start.coords.toCompressedJson(),
-                ...(this.start.name && { name: this.start.name }),
-            },
-            end: {
-                coords: this.end.coords.toCompressedJson(),
-                ...(this.end.name && { name: this.end.name }),
-            },
-            distance: Number(this.distance.toFixed(1)),
-            duration: Number(this.duration.toFixed(1)),
-            coords: this.coords.map(coords => coords.toCompressedJson()),
-            steps: this.steps.map(stepToJson),
-            ...(this.startTime !== null && { startTime: this.startTime }),
-            ...(this.endTime !== null && { endTime: this.endTime }),
-            ...(this.transportInfo !== null && { transportInfo: this.transportInfo }),
-        };
-    }
-
-    static fromJson(json: LegJson) {
-        const leg = new Leg(Object.assign({}, json, {
-            start: {
-                coords: Coordinates.fromCompressedJson(json.start.coords),
-                name: json.start.name || null
-            },
-            end: {
-                coords: Coordinates.fromCompressedJson(json.end.coords),
-                name: json.end.name || null
-            },
-            coords: json.coords.map(Coordinates.fromCompressedJson),
-            steps: json.steps?.map(jsonToStep) || null,
-        }));
-
-        return leg;
-    }
-
-    static fromGraphRoute(
-        graphRoute: GraphRoute,
-        transitMode: TransitMode = 'WALK'
-    ) {
-        return new Leg({
-            start: { coords: graphRoute.start },
-            end: { coords: graphRoute.end },
-            coords: graphRoute.vertices.map(vertex => vertex.coords),
-            duration: graphRoute.edgesWeights.reduce((acc, weight) => acc + weight, 0),
-            transitMode,
-            steps: new StepsBuilder().setGraphRoute(graphRoute).build()
-        });
-    }
-
-    // TODO: Remove when possible...
-    // Livemap specific
-    multiplyLevel(levelFactor: number) {
-        this.start.coords.level = Level.multiplyBy(this.start.coords.level, levelFactor);
-        this.end.coords.level = Level.multiplyBy(this.end.coords.level, levelFactor);
-        for (const coords of this.coords) {
-            coords.level = Level.multiplyBy(coords.level, levelFactor);
-        }
-        this.steps.forEach(step => {
-            step.coords.level = Level.multiplyBy(step.coords.level, levelFactor);
-        });
-    }
-}

package/src/model/LevelChange.spec.ts

@@ -1,50 +0,0 @@
-import chai from 'chai';
-
-import { LevelChange, areLevelChangeEquals } from './LevelChange.js';
-
-const { expect } = chai;
-
-const levelChange1: LevelChange = {
-    direction: 'up',
-    difference: 1,
-    type: 'stairs'
-};
-
-const levelChange2: LevelChange = {
-    direction: 'down',
-    difference: -1,
-    type: 'elevator'
-};
-
-const levelChange3: LevelChange = {
-    direction: 'up',
-    difference: 3,
-    type: 'escalator'
-};
-
-const levelChange4: LevelChange = {
-    direction: 'up',
-    difference: 1
-};
-
-const levelChange5: LevelChange = {
-    direction: 'up',
-    difference: 1
-};
-
-describe('LevelChange', () => {
-
-    it('equals', () => {
-        expect(areLevelChangeEquals(levelChange1, levelChange1)).is.true;
-        expect(areLevelChangeEquals(levelChange2, levelChange2)).is.true;
-        expect(areLevelChangeEquals(levelChange3, levelChange3)).is.true;
-        expect(areLevelChangeEquals(levelChange4, levelChange4)).is.true;
-        expect(areLevelChangeEquals(levelChange4, levelChange5)).is.true;
-        expect(areLevelChangeEquals(levelChange1, levelChange2)).is.false;
-        expect(areLevelChangeEquals(levelChange1, levelChange3)).is.false;
-        expect(areLevelChangeEquals(levelChange1, levelChange4)).is.false;
-    });
-
-});
-
-export { levelChange1, levelChange2, levelChange3, levelChange4 };

package/src/model/LevelChange.ts

@@ -1,14 +0,0 @@
-export type LevelChangeType = 'elevator' | 'escalator' | 'stairs' | 'moving walkway' | 'incline plane';
-
-export type LevelChange = {
-    direction: 'up' | 'down';
-    difference: number;
-    type?: LevelChangeType;
-}
-
-export function areLevelChangeEquals(l1: LevelChange, l2: LevelChange) {
-    return l1 === l2
-        || l1.difference === l2.difference
-        && l1.direction === l2.direction
-        && l1.type === l2.type;
-}

package/src/model/RouterRequest.ts

@@ -1,33 +0,0 @@
-import { Coordinates } from "@wemap/geo"
-
-import { TravelMode, TravelModePreference } from "./TravelMode"
-
-export type RouterRequest = {
-    origin: Coordinates,
-    destination: Coordinates,
-    travelMode: TravelMode,
-    travelModePreference?: TravelModePreference,
-    provideItineraryAlternatives?: boolean,
-    waypoints?: Coordinates[],
-    optimizeWaypoints?: boolean,
-    itineraryModifiers?: {
-        avoidStairs?: boolean,
-        avoidEscalators?: boolean,
-        avoidElevators?: boolean,
-        avoidMovingWalkways?: boolean,
-        avoidTicketRestrictedAreas?: boolean
-    }
-    output?: {
-        distanceAndDurationOnly?: boolean
-    }
-}
-
-export function routerRequestToJson(routerRequest: RouterRequest) {
-    const { origin, destination, waypoints, ...rest } = routerRequest;
-    return {
-        origin: origin.toJson(),
-        destination: destination.toJson(),
-        ...(waypoints && { waypoints: waypoints.map(w => w.toJson()) }),
-        ...rest
-    }
-}

package/src/model/Step.spec.ts

@@ -1,99 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-import chai from 'chai';
-
-import { jsonToStep, Step, stepEquals, stepToJson } from './Step.js';
-import { levelChange1 } from './LevelChange.spec.js';
-
-const { expect } = chai;
-
-const step1: Step = {
-    firstStep: true,
-    lastStep: false,
-    number: 1,
-    coords: new Coordinates(0, 0),
-    angle: 0,
-    previousBearing: 0,
-    nextBearing: 0,
-    distance: 10,
-    duration: 0,
-    name: null,
-    levelChange: null,
-    extras: null
-};
-
-const step2Coords = new Coordinates(1, 0);
-const step2 = {
-    ...step1,
-    firstStep: false,
-    number: 2,
-    coords: step2Coords,
-    distance: step1.coords.distanceTo(step2Coords),
-    extras: { subwayEntrance: true, subwayEntranceRef: 'toto', isGate: true }
-};
-
-const step3Coords = new Coordinates(2, 0, null);
-const step3Distance = step2.coords.distanceTo(step3Coords);
-const step3 = {
-    ...step2,
-    number: 3,
-    coords: step3Coords,
-    distance: step3Distance,
-    duration: step3Distance * 2,
-    levelChange: levelChange1,
-    extras: { subwayEntrance: false }
-};
-
-const step4Coords = new Coordinates(3, 0);
-const step4 = {
-    ...step3,
-    lastStep: true,
-    number: 4,
-    coords: step4Coords,
-    distance: step3.coords.distanceTo(step4Coords),
-    name: 'end',
-    extras: {}
-};
-
-
-const step5 = Object.assign({}, step4);
-
-describe('Step', () => {
-
-    it('equals', () => {
-        expect(stepEquals(step1, step1)).is.true;
-        expect(stepEquals(step2, step2)).is.true;
-        expect(stepEquals(step3, step3)).is.true;
-        expect(stepEquals(step4, step4)).is.true;
-        expect(stepEquals(step4, step5)).is.true;
-        expect(stepEquals(step1, step2)).is.false;
-        expect(stepEquals(step1, step3)).is.false;
-        expect(stepEquals(step1, step4)).is.false;
-    });
-
-    it('from / to JSON', () => {
-
-        const step1Json = stepToJson(step1);
-        expect(step1Json).be.an('object');
-        const step1Bis = jsonToStep(step1Json);
-        expect(stepEquals(step1, step1Bis)).is.true;
-
-        const step2Json = stepToJson(step2);
-        expect(step2Json).be.an('object');
-        const step2Bis = jsonToStep(step2Json);
-        expect(stepEquals(step2, step2Bis)).is.true;
-
-        const step3Json = stepToJson(step3);
-        expect(step3Json).be.an('object');
-        const step3Bis = jsonToStep(step3Json);
-        expect(stepEquals(step3, step3Bis)).is.true;
-
-        const step4Json = stepToJson(step4);
-        expect(step4Json).be.an('object');
-        const step4Bis = jsonToStep(step4Json);
-        expect(stepEquals(step4, step4Bis)).is.true;
-
-    });
-
-});
-
-export { step1, step2, step3, step4 };

package/src/model/Step.ts

@@ -1,90 +0,0 @@
-import { Coordinates, CoordinatesCompressedJson } from '@wemap/geo';
-
-import { LevelChange } from './LevelChange.js';
-import { StepExtra } from './StepExtra.js';
-
-export type Step = {
-
-    firstStep: boolean;
-    lastStep: boolean;
-    number: number;
-
-    angle: number;
-    previousBearing: number;
-    nextBearing: number;
-    distance: number;
-    duration: number;
-
-    readonly coords: Coordinates;
-    readonly name: string | null;
-    readonly levelChange: LevelChange | null;
-    readonly extras: StepExtra | null;
-}
-
-export type StepJson = {
-    firstStep?: boolean,
-    lastStep?: boolean
-    number: number,
-    coords: CoordinatesCompressedJson,
-    name?: string,
-    angle: number,
-    previousBearing: number,
-    nextBearing: number,
-    distance: number,
-    duration: number
-    levelChange?: LevelChange
-    extras?: StepExtra,
-};
-
-export type MinStepInfo = {
-    coords: Coordinates,
-    name?: string,
-    levelChange?: LevelChange
-    extras?: StepExtra,
-    distance?: number,
-    duration?: number
-};
-
-export function stepToJson(step: Step): StepJson {
-    return {
-        ...(step.firstStep && { firstStep: true }),
-        ...(step.lastStep && { lastStep: true }),
-        number: step.number,
-        coords: step.coords.toCompressedJson(),
-        ...(step.name !== null && { name: step.name }),
-        angle: Number(step.angle.toFixed(2)),
-        previousBearing: Number(step.previousBearing.toFixed(2)),
-        nextBearing: Number(step.nextBearing.toFixed(2)),
-        distance: Number(step.distance.toFixed(1)),
-        duration: Number(step.duration.toFixed(1)),
-        ...(step.levelChange !== null && { levelChange: step.levelChange }),
-        ...(step.extras && Object.keys(step.extras).length !== 0 && { extras: step.extras }),
-    };
-}
-
-export function jsonToStep(json: StepJson): Step {
-    return Object.assign({}, json, {
-        coords: Coordinates.fromCompressedJson(json.coords),
-        firstStep: Boolean(json.firstStep),
-        lastStep: Boolean(json.lastStep),
-        name: json.name || null,
-        levelChange: json.levelChange || null,
-        extras: json.extras || null
-    });
-}
-
-export function stepEquals(step1: Step, step2: Step) {
-    return step1.coords.equals(step2.coords)
-        && Math.abs(step1.angle - step2.angle) <= 0.005
-        && Math.abs(step1.distance - step2.distance) <= 0.05
-        && Math.abs(step1.duration - step2.duration) <= 0.05
-        && step1.firstStep === step2.firstStep
-        && step1.lastStep === step2.lastStep
-        && step1.levelChange?.difference === step2.levelChange?.difference
-        && step1.levelChange?.direction === step2.levelChange?.direction
-        && step1.levelChange?.type === step2.levelChange?.type
-        && step1.name === step2.name
-        && Math.abs(step1.nextBearing - step2.nextBearing) <= 0.005
-        && step1.number === step2.number
-        && Math.abs(step1.previousBearing - step2.previousBearing) <= 0.005
-}

package/src/model/StepExtra.ts

@@ -1 +0,0 @@
-export type StepExtra = { [key: string]: number | string | boolean | null }