@wemap/routers 10.5.0 → 10.5.2

package/helpers/InstructionManager.js

@@ -94,8 +94,7 @@ export default class InstructionManager {
             }
         }
 
-
-        return '';
+        return 'Continue straight';
     }
 
 

package/index.d.ts

@@ -1,4 +1,5 @@
-import { Coordinates, GraphProjection, Network } from '@wemap/geo';
+import { Coordinates, GraphEdge, GraphNode, GraphProjection, GraphRouter, Network } from '@wemap/geo';
+import { OsmElement } from '@wemap/osm';
 
 declare module '@wemap/routers' {
 
@@ -53,7 +54,7 @@ declare module '@wemap/routers' {
 
         isPublicTransport(): boolean;
         equals(obj: Leg): boolean;
-        toNetwork(): Network;
+        toNetwork(): Network<null>;
         toJson(): object;
 
         static equals(obj1: Leg, obj2: Leg): boolean;
@@ -74,13 +75,13 @@ declare module '@wemap/routers' {
         get mode(): ItineraryMode;
 
         equals(obj: Itinerary): boolean;
-        toNetwork(): Network;
+        toNetwork(): Network<null>;
         toJson(): object;
 
         static equals(obj1: Itinerary, obj2: Itinerary): boolean;
         static fromItineraries(...itineraries: Itinerary[]): Itinerary;
         static fromOrderedPointsArray(points: number[][], from: Coordinates, to: Coordinates): Itinerary;
-        static fromOrderedCoordinates(points: Coordinates[], from: Coordinates, to: Coordinates, mode: ItineraryMode = 'WALK'): Itinerary;
+        static fromOrderedCoordinates(points: Coordinates[], from: Coordinates, to: Coordinates, mode?: ItineraryMode): Itinerary;
         static fromJson(json: object): Itinerary;
     }
 
@@ -98,10 +99,10 @@ declare module '@wemap/routers' {
         static fromJson(json: object): RouterResponse;
     }
 
-    export class ItineraryInfo {
+    export class ItineraryInfo<T> {
         nextStep: Step;
         previousStep: Step;
-        projection: GraphProjection;
+        projection: GraphProjection<T>;
         leg: Leg;
         traveledDistance: number;
         traveledPercentage: number;
@@ -109,12 +110,56 @@ declare module '@wemap/routers' {
         remainingPercentage: number;
     }
 
-    export class ItineraryInfoManager {
+    export class ItineraryInfoManager<T> {
         set itinerary(itinerary: Itinerary);
-        getInfo(position: Coordinates): ItineraryInfo | null;
+        getInfo(position: Coordinates): ItineraryInfo<T> | null;
     }
 
-    export function getDurationFromLength(length: number, speed: number = 5): number;
+    export class WemapRouterOptions {
+        static DEFAULT: WemapRouterOptions;
+        static get WITHOUT_STAIRS(): WemapRouterOptions;
+        static getDurationFromLength(length: number, speed?: number): number;
+
+        weightEdgeFn: (edge: GraphEdge<OsmElement>) => boolean;
+    }
+
+    export class WemapMetaRouterIOMap {
+        name: string | null;
+        network: Network<OsmElement>;
+        router: GraphRouter<OsmElement>;
+        bounds: [number, number][];
+        entryPoints: GraphNode<OsmElement>;
+        disabledWays: Set<number>;
+
+        constructor(
+            network: Network<OsmElement>,
+            entryPoints: GraphNode<OsmElement>[],
+            bounds?: Coordinates[] | null,
+            name?: string | null
+        );
+
+        disableWay(osmId: number): void;
+        enableWay(osmId: number): void;
+        getOrderedEntryPointsSortedByDistance(
+            start: Coordinates, end: Coordinates
+        ): GraphNode<OsmElement>[];
+        getBestItineraryFromEntryPointsToEnd(
+            start: Coordinates, end: Coordinates,
+            options: WemapRouterOptions
+        ): Itinerary[];
+        getBestItineraryFromStartToEntryPoints(
+            start: Coordinates, end: Coordinates,
+            options: WemapRouterOptions
+        ): Itinerary[];
+        getItineraryInsideMap(start: Coordinates, end: Coordinates,
+            options: WemapRouterOptions
+        ): Itinerary[] | null;
+        isPointInside(coordinates: Coordinates): boolean;
+
+        static fromOsmXml(osmXmlString: string, name?: string | null): WemapMetaRouterIOMap;
+    }
+
+    export function getDurationFromLength(length: number, speed?: number): number;
     export function multiplyLegLevel(leg: Leg, levelFactor: number): void;
     export function multiplyItineraryLevel(itinerary: Itinerary, levelFactor: number): void;
     export function multiplyRouterResponseLevel(routerResponse: RouterResponse, levelFactor: number): void;

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "10.5.0",
+    "version": "10.5.2",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -30,10 +30,10 @@
         "@turf/boolean-point-in-polygon": "^6.5.0",
         "@turf/convex": "^6.5.0",
         "@turf/helpers": "^6.5.0",
-        "@wemap/geo": "^10.5.0",
+        "@wemap/geo": "^10.5.1",
         "@wemap/logger": "^10.0.0",
         "@wemap/maths": "^10.3.1",
-        "@wemap/osm": "^10.5.0"
+        "@wemap/osm": "^10.5.1"
     },
-    "gitHead": "da571076de6bd9f4f2653d097763ff1244a36ebb"
+    "gitHead": "befe244ba1bc8d1761522e2458f611efe8cee598"
 }

package/src/Utils.js

@@ -68,3 +68,31 @@ export function multiplyRouterResponseLevel(routerResponse, levelFactor) {
 }
 
 
+/**
+ * @param {Itinerary} itinerary
+ * @param {number} levelFactor
+ */
+export function forceUnknownItineraryLevelTo0(itinerary) {
+
+    itinerary.from.level ||= 0;
+    itinerary.to.level ||= 0;
+
+    for (const leg of itinerary.legs) {
+        leg.from.coords.level ||= 0;
+        leg.to.coords.level ||= 0;
+        for (const coords of leg.coords) {
+            coords.level ||= 0;
+        }
+        if (leg.steps) {
+            for (const step of leg.steps) {
+                step.coords.level ||= 0;
+            }
+        }
+    }
+
+    if (itinerary._coords) {
+        for (const coords of itinerary._coords) {
+            coords.level ||= 0;
+        }
+    }
+}

package/src/wemap/WemapRouterUtils.js

@@ -1,5 +1,5 @@
 import { GraphItinerary } from '@wemap/geo';
-import { diffAngleLines, positiveMod, rad2deg } from '@wemap/maths';
+import { diffAngle, rad2deg } from '@wemap/maths';
 import { OsmElement } from '@wemap/osm';
 
 import Constants from '../Constants.js';
@@ -56,18 +56,18 @@ export function getTurnInfoFromAngle(_angle) {
 
     let direction, directionExtra;
 
-    const directionAngle = rad2deg(diffAngleLines(_angle, Math.PI));
-    if (directionAngle <= 20) {
+    const directionAngle = rad2deg(diffAngle(_angle, Math.PI));
+    const directionAngleAbs = Math.abs(directionAngle);
+    if (directionAngleAbs <= 20) {
         direction = 'straight';
     } else {
-        direction = positiveMod(_angle, 2 * Math.PI) > Math.PI ? 'left' : 'right';
-        if (directionAngle < 55) {
+        direction = directionAngle > 0 ? 'left' : 'right';
+        if (directionAngleAbs < 55) {
             directionExtra = 'slight';
-        } else if (directionAngle > 120) {
+        } else if (directionAngleAbs > 120) {
             directionExtra = 'sharp';
         }
     }
 
-
     return { direction, directionExtra };
 }

package/src/wemap-meta/IOMap.js

@@ -26,8 +26,8 @@ class IOMap {
     /** @type {!(GraphNode<OsmElement>[])} */
     entryPoints;
 
-    /** @type {number[]} */
-    disabledWays = [];
+    /** @type {Set<number>} */
+    disabledWays = new Set();
 
     /**
      * @param {Network} network The network of the map
@@ -198,13 +198,17 @@ class IOMap {
     }
 
     enableWay(osmId) {
-        const edges = this.network.edges.filter(edge => edge.builtFrom.id === osmId);
-        this.router.disabledEdges = this.router.disabledEdges.filter(edge => !edges.includes(edge));
+        this.network.edges
+            .filter(edge => edge.builtFrom.id === osmId)
+            .forEach(e => this.router.disabledEdges.delete(e));
+        this.disabledWays.delete(osmId);
     }
 
     disableWay(osmId) {
-        const edges = this.network.edges.filter(edge => edge.builtFrom.id === osmId);
-        this.router.disabledEdges.push(...edges);
+        this.network.edges
+            .filter(edge => edge.builtFrom.id === osmId)
+            .forEach(e => this.router.disabledEdges.add(e));
+        this.disabledWays.add(osmId);
     }
 }