@wemap/routers 12.0.0 → 12.1.0

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.0.0",
+    "version": "12.1.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "90961b51b2bbbb32c4e7b64ddf19097e1d44a1df"
+    "gitHead": "a9ae25d8931032e8779034182c62aa6af1528819"
 }

package/src/graph/Edge.ts

@@ -3,7 +3,10 @@ import { Level, type Level_t } from '@wemap/geo';
 import Vertex from './Vertex.js';
 
 export type EdgeProperties = {
+    
     name?: string;
+    externalId?: string | number;
+
     isOneway?: boolean;
     areStairs?: boolean;
     isElevator?: boolean;

package/src/graph/Graph.ts

@@ -135,6 +135,7 @@ class Graph {
     toCompressedJson(): GeoGraphJson {
         return {
             vertices: this.vertices.map(vertex => vertex.toJson()),
+            verticesIds: this.vertices.map(vertex => vertex.id),
             edges: this.edges.map(edge => {
                 const vertex1Idx = this.vertices.indexOf(edge.vertex1);
                 const vertex2Idx = this.vertices.indexOf(edge.vertex2);
@@ -155,8 +156,7 @@ class Graph {
             vertices[jsonEdge[0]],
             vertices[jsonEdge[1]],
             jsonEdge.length > 2 ? jsonEdge[2] : {}
-        )
-        );
+        ));
 
         return new Graph(vertices, edges);
     }

package/src/graph/GraphRouter.ts

@@ -107,12 +107,14 @@ class GraphRouter extends GraphRouterEngine {
             if (projection.nearestElement instanceof Edge) {
                 const edge = projection.nearestElement;
                 const newVertex = new Vertex(projection.coords, {
-                    name: `proj on ${edge.properties.name || null} (tmp)`
+                    name: `proj on ${edge.properties.name || null} (tmp)`,
+                    ...(typeof edge.properties.externalId !== 'undefined' && { externalId: edge.properties.externalId })
                 });
                 newVertex.id = this.graph.vertices.length + createdVertices.size;
                 const newEdgesOptions: EdgeProperties = {
                     ...edge.properties,
                     name: `splitted ${edge.properties.name || null} (tmp)`,
+                    ...(typeof edge.properties.externalId !== 'undefined' && { externalId: edge.properties.externalId })
                 };
                 const newEdge1 = new Edge(edge.vertex1, newVertex, newEdgesOptions);
                 const newEdge2 = new Edge(newVertex, edge.vertex2, newEdgesOptions);

package/src/graph/Vertex.ts

@@ -5,6 +5,7 @@ import { GraphVertexJson } from '../types.js';
 export type VertexProperties = {
 
     name?: string;
+    externalId?: string | number;
 
     isGate?: boolean;
     isSubwayEntrance?: boolean;

package/src/model/Itinerary.ts

@@ -301,34 +301,38 @@ export default class Itinerary {
     }
 
     toGeoJson(): FeatureCollection {
-        const transformToPoint = (point: Coordinates, name?: string): Feature<Point> => ({
+        const transformToPoint = (point: Coordinates, name?: string, type?: string): Feature<Point> => ({
             type: "Feature",
-            properties: { name, level: point.level },
+            properties: { name, level: point.level, ...(type && { type }) },
             geometry: {
                 type: 'Point',
                 coordinates: [point.lng, point.lat]
             }
         });
-        const transformToMultiLineStrings = (segments: Coordinates[][], level: Level_t): Feature<MultiLineString> => {
-            return {
-                type: "Feature",
-                properties: { level, name: level?.toString() },
-                geometry: {
-                    type: 'MultiLineString',
-                    coordinates: segments.map(s => s.map(({ lat, lng }) => [lng, 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'),
-                transformToPoint(this.destination, 'destination'),
-                ...multiLineStrings
+                transformToPoint(this.origin, 'origin', 'origin'),
+                transformToPoint(this.destination, 'destination', 'destination'),
+                ...multiLineStrings,
+                ...legsStarts,
+                ...legsEnds,
+                ...steps
             ]
         };
     }

package/src/types.ts

@@ -5,6 +5,7 @@ export type GraphVertexJson = CoordinatesCompressedJson;
 
 export type GeoGraphJson = {
     vertices: GraphVertexJson[],
+    verticesIds: (string | number)[], 
     edges: (
         [number, number] |
         [number, number, EdgeProperties]

package/src/wemap-multi/CustomNetworkMap.ts

@@ -190,17 +190,6 @@ class CustomNetworkMap {
         return this.router.calculateShortestPathToMultipleDestinations(start, ends, options);
     }
 
-    get disabledEdges() { return this.router.disabledEdges }
-
-    enableEdge(edgeId: number) {
-        const edge = this.graph.edges.find(e => e.id === edgeId);
-        return Boolean(edge && this.router.disabledEdges.delete(edge));
-    }
-
-    disableEdge(edgeId: number) {
-        const edge = this.graph.edges.find(e => e.id === edgeId);
-        return Boolean(edge && this.router.disabledEdges.add(edge));
-    }
 }
 
 export default CustomNetworkMap;

package/src/wemap-osm/OsmGraphUtils.ts

@@ -24,6 +24,7 @@ export default class OsmGraphUtils {
     static parseNodeProperties(osmNode: OsmNode): VertexProperties {
         return {
             ...(osmNode.name && { name: osmNode.name }),
+            ...(osmNode.id && { externalId: osmNode.id }),
             ...(osmNode.isGate && { isGate: osmNode.isGate }),
             ...(osmNode.isSubwayEntrance && { isSubwayEntrance: osmNode.isSubwayEntrance }),
             ...(osmNode.subwayEntranceRef && { subwayEntrsanceRef: osmNode.subwayEntranceRef })
@@ -33,6 +34,7 @@ export default class OsmGraphUtils {
     static parseWayProperties(osmWay: OsmWay): EdgeProperties {
         return {
             ...(osmWay.name && { name: osmWay.name }),
+            ...(osmWay.id && { externalId: osmWay.id }),
             ...(osmWay.isOneway && { isOneway: osmWay.isOneway }),
             ...(osmWay.areStairs && { areStairs: osmWay.areStairs }),
             ...(osmWay.isElevator && { isElevator: osmWay.isElevator }),
@@ -143,14 +145,14 @@ export default class OsmGraphUtils {
 
                 entryVertices.forEach(entryVertex => {
                     const vertexCenter = getOrCreateVertex(elevatorCenterFakeOsmNode, entryVertex.coords.level);
-                    edges.push(new Edge(vertexCenter, entryVertex));
+                    edges.push(new Edge(vertexCenter, entryVertex, { externalId: way.id }));
                 })
             });
 
 
         // 4. Link elevators vertices
-        elevatorVertices.forEach(([, name, verticesOfEachLevel]) => {
-            const elevatorEdgeProps = { name, isElevator: true };
+        elevatorVertices.forEach(([id, name, verticesOfEachLevel]) => {
+            const elevatorEdgeProps = { name, isElevator: true, externalId: id };
             // Link vertices of each level together
             for (let i = 0; i < verticesOfEachLevel.length; i++) {
                 for (let j = i + 1; j < verticesOfEachLevel.length; j++) {