@wemap/routers 12.10.8 → 12.11.0

package/src/wemap-osm/OsmGraphUtils.ts

@@ -1,173 +0,0 @@
-import { Coordinates, Level, Level_t } from '@wemap/geo';
-import { OsmModel, OsmNode, OsmWay } from '@wemap/osm';
-
-import Graph from '../graph/Graph.js';
-import { default as Edge, type EdgeProperties } from '../graph/Edge.js';
-import { default as Vertex, type VertexProperties } from '../graph/Vertex.js';
-
-
-export default class OsmGraphUtils {
-
-    static RESTRICTED_PEDESTRIANS_HIGHWAYS = ['motorway', 'motorway_link'];
-
-    static DEFAULT_WAY_SELECTOR = (way: OsmWay) => {
-        if (way.isArea) return false;
-        if (way.tags.foot === 'yes') return true;
-        if (['no', 'private'].includes(way.tags.access)) return false;
-
-        const isElevatorArea = way.tags.highway === 'elevator' && way.isGeometryClosed
-        return way.tags.highway && !OsmGraphUtils.RESTRICTED_PEDESTRIANS_HIGHWAYS.includes(way.tags.highway) && !isElevatorArea
-            || way.tags.footway === 'sidewalk'
-            || way.tags.public_transport === 'platform'
-            || way.tags.railway === 'platform';
-    };
-
-    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 })
-        }
-    }
-
-    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 }),
-            ...(osmWay.areEscalators && { areEscalators: osmWay.areEscalators }),
-            ...(osmWay.isMovingWalkway && { isMovingWalkway: osmWay.isMovingWalkway }),
-            ...(osmWay.needTicket && { needTicket: osmWay.needTicket }),
-            ...(osmWay.incline && { incline: osmWay.incline })
-        }
-    }
-
-    static createGraphFromOsmModel(
-        osmModel: OsmModel,
-        waySelectionFilter = OsmGraphUtils.DEFAULT_WAY_SELECTOR,
-        callbackVerticesMapping?: (mapping: [nodeId: number, vertex: Vertex][]) => void
-    ) {
-
-        const edges: Edge[] = [];
-        const verticesMapping: [nodeId: number, vertex: Vertex][] = [];
-        const elevatorVertices: [id: number, name: string | undefined, vertices: Vertex[]][] = [];
-
-        // 1. Create a function to retrieve a vertex which has already been created and avoid duplicates
-        const getOrCreateVertex = (osmNode: OsmNode, nodeLevel: Level_t) => {
-
-            // Check if a vertex with same coordinates already exists
-            let vertex: Vertex | null = verticesMapping
-                .find(([nodeId, v]) => {
-                    if (nodeId !== osmNode.id) return false;
-                    if (Level.intersect(v.coords.level, nodeLevel)) return true;
-                    // Specific case of exits
-                    return v.coords.level === null || nodeLevel === null;
-                })?.[1] || null;
-
-            // If the vertex already exists, return it
-            if (vertex) {
-                // In the case where vertices are linked to edges with level change
-                if (!Level.equals(vertex.coords.level, nodeLevel)) {
-                    vertex.coords.level = Level.intersection(vertex.coords.level, nodeLevel);
-                    if (vertex.coords.level === null) {
-                        vertex.coords.level = nodeLevel;
-                    }
-                }
-                return vertex;
-            }
-
-            // If it does not exist, create it
-            const newCoords = new Coordinates(osmNode.coords.lat, osmNode.coords.lng, null, nodeLevel)
-            vertex = new Vertex(newCoords, this.parseNodeProperties(osmNode));
-
-            verticesMapping.push([osmNode.id, vertex]);
-
-            if (osmNode.isElevator) {
-                let elevatorEntry = elevatorVertices.find(([id]) => osmNode.id === id);
-                if (!elevatorEntry) {
-                    elevatorEntry = [osmNode.id, osmNode.name, []];
-                    elevatorVertices.push(elevatorEntry);
-                }
-                elevatorEntry[2].push(vertex);
-            }
-
-            return vertex;
-        };
-
-        // 2. Go through OSM ways to create edges and vertices
-        osmModel.ways.forEach(way => {
-            if (!waySelectionFilter(way)) {
-                return;
-            }
-
-            const edgeProperties = this.parseWayProperties(way);
-
-            const processWayForLevel = (_level: Level_t) => {
-                for (let i = 1; i < way.nodes.length; i++) {
-
-                    let firstVertex = getOrCreateVertex(way.nodes[i - 1], _level);
-                    let secondVertex = getOrCreateVertex(way.nodes[i], _level);
-
-                    if (way.isOnewayBackward) {
-                        const tmpVertex = secondVertex;
-                        secondVertex = firstVertex;
-                        firstVertex = tmpVertex;
-                    }
-
-                    const edge = new Edge(firstVertex, secondVertex, edgeProperties);
-                    edges.push(edge);
-                }
-            }
-
-            processWayForLevel(way.level);
-            if ('repeat_on' in way.tags) {
-                way.tags.repeat_on.split(';').map(Level.fromString).forEach(processWayForLevel);
-            }
-
-        });
-
-        // 3. Manage elevators without explicit navigation graph inside.
-        //   It creates a graph from entries to the center of the elevator shape.
-        let fakeOsmNodeId = -1;
-        osmModel.ways
-            .filter(way => way.isElevator && way.isGeometryClosed)
-            .forEach(way => {
-                const entryVertices = way.nodes.map(node => verticesMapping.filter(([osmId]) => osmId === node.id).map(vm => vm[1])).flat();
-
-                // Horrible method but works for macro-problems
-                const elevatorCenter = way.nodes
-                    .reduce((acc, node) => [acc[0] + node.coords.lat, acc[1] + node.coords.lng], [0, 0])
-                    .map(val => val / way.nodes.length);
-                const elevatorLevel = entryVertices.reduce((acc, v) => Level.union(acc, v.coords.level), null as Level_t);
-                const elevatorCenterCoords = new Coordinates(elevatorCenter[0], elevatorCenter[1], null, elevatorLevel);
-
-                const elevatorCenterFakeOsmNode = new OsmNode(fakeOsmNodeId--, elevatorCenterCoords, { highway: 'elevator' });
-
-                entryVertices.forEach(entryVertex => {
-                    const vertexCenter = getOrCreateVertex(elevatorCenterFakeOsmNode, entryVertex.coords.level);
-                    edges.push(new Edge(vertexCenter, entryVertex, { externalId: way.id }));
-                })
-            });
-
-
-        // 4. Link elevators vertices
-        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++) {
-                    edges.push(new Edge(verticesOfEachLevel[i], verticesOfEachLevel[j], elevatorEdgeProps));
-                }
-            }
-        });
-
-        callbackVerticesMapping?.(verticesMapping);
-
-        return new Graph(verticesMapping.map(v => v[1]), edges);
-    }
-
-}

package/src/wemap-osm/OsmRouter.elevators.spec.ts

@@ -1,106 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { OsmParser } from '@wemap/osm';
-
-import OsmGraphUtils from './OsmGraphUtils.js';
-import GraphRouter from '../graph/GraphRouter.js';
-
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.01));
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
-const filePath = path.resolve(__dirname, '../../assets/elevator-models.osm');
-const osmXmlString = fs.readFileSync(filePath, 'utf8');
-const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-const graph =  OsmGraphUtils.createGraphFromOsmModel(osmModel);
-const router = new GraphRouter(graph);
-
-const n = (vertexName: string) => graph.getVertexByName(vertexName)!.coords
-
-describe('OsmRouter Elevators - Case 1', () => {
-
-    it('Itinerary 1', () => {
-        expect(router.calculateShortestPath(n('s1'), n('f1a')).route().hasRoute).true
-    });
-
-    it('Itinerary 2', () => {
-        expect(router.calculateShortestPath(n('s1'), n('f1b')).route().hasRoute).true
-    });
-
-    it('Itinerary 3', () => {
-        expect(router.calculateShortestPath(n('s1'), n('f1c')).route().hasRoute).true
-    });
-
-});
-
-
-describe('OsmRouter Elevators - Case 2', () => {
-
-    it('Itinerary 1', () => {
-        expect(router.calculateShortestPath(n('s2'), n('f2a')).route().hasRoute).true
-    });
-
-    it('Itinerary 2', () => {
-        expect(router.calculateShortestPath(n('s2'), n('f2b')).route().hasRoute).true
-    });
-
-    it('Itinerary 3', () => {
-        expect(router.calculateShortestPath(n('s2'), n('f2c')).route().hasRoute).true
-    });
-
-});
-
-
-describe('OsmRouter Elevators - Case 3', () => {
-
-    it('Itinerary 1', () => {
-        expect(router.calculateShortestPath(n('s3'), n('f3a')).route().hasRoute).true
-    });
-
-    it('Itinerary 2', () => {
-        expect(router.calculateShortestPath(n('s3'), n('f3b')).route().hasRoute).true
-    });
-
-    it('Itinerary 3', () => {
-        expect(router.calculateShortestPath(n('s3'), n('f3c')).route().hasRoute).true
-    });
-
-});
-
-describe('OsmRouter Elevators - Case 4', () => {
-
-    it('Itinerary 1', () => {
-        expect(router.calculateShortestPath(n('s4'), n('f4a')).route().hasRoute).true
-    });
-
-    it('Itinerary 2', () => {
-        expect(router.calculateShortestPath(n('s4'), n('f4b')).route().hasRoute).true
-    });
-
-    it('Itinerary 3', () => {
-        expect(router.calculateShortestPath(n('s4'), n('f4c')).route().hasRoute).true
-    });
-
-});
-
-describe('OsmRouter Elevators - Case 5', () => {
-
-    it('Itinerary 1', () => {
-        expect(router.calculateShortestPath(n('s5'), n('f5a')).route().hasRoute).true
-    });
-
-    it('Itinerary 2', () => {
-        expect(router.calculateShortestPath(n('s5'), n('f5b')).route().hasRoute).true
-    });
-
-    it('Itinerary 3', () => {
-        expect(router.calculateShortestPath(n('s5'), n('f5c')).route().hasRoute).true
-    });
-
-});

package/src/wemap-osm/OsmRouter.spec.ts

@@ -1,292 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Coordinates } from '@wemap/geo';
-import { OsmParser } from '@wemap/osm';
-
-import { LevelChange } from '../model/LevelChange.js';
-import { Step } from '../model/Step.js';
-import OsmGraphUtils from './OsmGraphUtils.js';
-import GraphRouter from '../graph/GraphRouter.js';
-import Vertex from '../graph/Vertex.js';
-import GraphRouterOptionsBuilder from '../graph/GraphRouterOptionsBuilder.js';
-import GraphRoute from '../graph/GraphRoute.js';
-import Itinerary from '../model/Itinerary.js';
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.01));
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
-const getVerticesNames = (graphRoute: GraphRoute) => {
-    return graphRoute.vertices.map(vertex => vertex.properties.name || null);
-};
-
-
-const itineraryStart = new Coordinates(43.6092754, 3.8842306, null, 2);
-const itineraryEnd = new Coordinates(43.6092602, 3.8842669, null, 1);
-
-
-const loadGraph = (fileName: string) => {
-    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    return OsmGraphUtils.createGraphFromOsmModel(osmModel);
-};
-
-const generateVertexNames = (start: number, end: number) =>
-    new Array(end - start + 1).fill(null).map((_, idx) => 'p' + (idx + start));
-
-describe('OsmRouter - Multi-level itinerary', () => {
-
-    const graph = loadGraph('bureaux-wemap-montpellier-network.osm');
-    const router = new GraphRouter(graph);
-
-    const route = router.calculateShortestPath(itineraryStart, itineraryEnd).route();
-    const itinerary = Itinerary.fromGraphRoute(route);
-
-    const p: Vertex[] = [];
-
-    it('Search for vertices', () => {
-        for (let i = 1; i <= 16; i++) {
-            p[i] = graph.getVertexByName('p' + i) as Vertex;
-            expect(p[i]).instanceOf(Vertex);
-        }
-    });
-
-    it('Router return shortest path', () => {
-        expect(getVerticesNames(route)).deep.equals(
-            ['proj on w2 (tmp)', ...generateVertexNames(7, 16)]
-        );
-    });
-
-    it('Verify steps', () => {
-
-        const steps = itinerary.steps;
-        expect(steps.length).equal(8);
-
-        expect(steps[0].coords.equals(itineraryStart.getSegmentProjection(p[6].coords, p[7].coords) as Coordinates)).true;
-        expect(steps[0].name).equals('w2');
-        expect(steps[0].number).equals(1);
-        expect(steps[0].angle).almost.equals(-1.57);
-        expect(steps[0].previousBearing).almost.equals(1.778);
-        expect(steps[0].nextBearing).almost.equals(0.207);
-        expect(steps[0].distance).almost.equals(2.328);
-        expect(steps[0].duration).almost.equals(2.095);
-        expect(steps[0].firstStep).true;
-        expect(steps[0].lastStep).false;
-        expect(steps[0].levelChange).is.null;
-        expect(steps[0].extras).is.empty;
-
-        expect(steps[1].coords.equals(p[8].coords)).true;
-        expect(steps[1].name).equals('w3');
-        expect(steps[1].number).equals(2);
-        expect(steps[1].distance).almost.equals(1.764);
-        expect(steps[1].firstStep).false;
-        expect(steps[1].lastStep).false;
-
-        expect(steps[2].coords.equals(p[9].coords)).true;
-        expect(steps[2].name).equals('w3');
-
-        expect(steps[3].coords.equals(p[10].coords)).true;
-        expect(steps[3].name).equals('w5');
-
-        expect(steps[4].coords.equals(p[11].coords)).true;
-        expect(steps[4].name).equals('w6');
-        expect(steps[4].levelChange).is.not.null;
-        expect((steps[4].levelChange as LevelChange).difference).equals(-1);
-        expect((steps[4].levelChange as LevelChange).direction).equals('down');
-        expect((steps[4].levelChange as LevelChange).type).equals('stairs');
-
-        expect(steps[5].coords.equals(p[14].coords)).true;
-        expect(steps[5].name).equals('w7');
-
-        expect(steps[6].coords.equals(p[15].coords)).true;
-        expect(steps[6].name).equals('w9');
-
-        expect(steps[7].coords.equals(p[16].coords)).true;
-        expect(steps[7].name).is.null;
-        expect(steps[7].lastStep).true;
-    });
-
-
-    it('router returns shortest path 2', () => {
-
-        const start = new Coordinates(43.609219, 3.8841743, null, 2);
-        const end = new Coordinates(43.60917216742, 3.8842355275, null, 2);
-        const itinerary2 = router.calculateShortestPath(start, end).route();
-
-        expect(getVerticesNames(itinerary2)).deep.equals(['proj on w1 (tmp)', 'p6', 'p5']);
-    });
-
-    it('do not use stairs', () => {
-
-        const itineraryWithoutStairs = router.calculateShortestPath(
-            itineraryStart, itineraryEnd,
-            GraphRouterOptionsBuilder.WITHOUT_STAIRS
-        ).route();
-        expect(itineraryWithoutStairs.vertices.length).equal(11);
-        itineraryWithoutStairs.edges.forEach((edge) => {
-            expect(edge.properties.areStairs).is.not.true;
-        });
-    });
-
-    // it('toCompressedJson / fromCompressedJson', () => {
-    //     const json = itinerary.toJson();
-    //     expect(() => JSON.stringify(json)).not.throw(Error);
-
-    //     const itineraryBis = Itinerary.fromJson(json);
-    //     verifyCoherence(itineraryBis);
-    //     expect(itineraryBis.vertices.length).equal(11);
-    //     verifyVerticesOrder(itineraryBis.vertices, ['w2', ...generateVertexNames(7, 16)]);
-    // });
-
-});
-
-describe('OsmRouter - One Way itinerary', () => {
-
-    const networkModel = loadGraph('one-way.osm');
-    const router = new GraphRouter(networkModel);
-
-    it('do not use oneway', () => {
-
-        const start = new Coordinates(43.6094542, 3.8842072);
-        const end = new Coordinates(43.6093792, 3.8841889);
-
-        const route = router.calculateShortestPath(start, end).route();
-        expect(route).is.not.undefined;
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p2', 'p3']);
-
-        const routeOtherWay = router.calculateShortestPath(end, start).route();
-        expect(routeOtherWay).is.not.undefined;
-        expect(getVerticesNames(routeOtherWay)).deep.equals(['p3', 'p2', 'p5', 'p4', 'p1', 'p0']);
-    });
-});
-
-
-describe('OsmRouter - Conveying', () => {
-
-    const networkModel = loadGraph('gare-de-lyon-extract.osm');
-    const router = new GraphRouter(networkModel);
-
-    it('do not use oneway conveying', () => {
-
-        const start = new Coordinates(48.8445715, 2.3718927, null, 0);
-        const end = new Coordinates(48.8444574, 2.3720728, null, -1);
-
-        const route = router.calculateShortestPath(start, end).route();
-        expect(getVerticesNames(route)).deep.equals(['p11', 'p12', 'p9', 'p8', 'p6', 'proj on null (tmp)']);
-
-        const routeOtherWay = router.calculateShortestPath(end, start).route();
-        expect(routeOtherWay).is.not.undefined;
-        expect(getVerticesNames(routeOtherWay)).deep.equals(['proj on null (tmp)', 'p7', 'p10', 'p11']);
-    });
-});
-
-
-describe('OsmRouter - Conveying - backward', () => {
-
-    const networkModel = loadGraph('network-conveying-backward.osm');
-    const router = new GraphRouter(networkModel);
-
-    it('do not use oneway conveying', () => {
-
-        const start = networkModel.getVertexByName('p6')!;
-        const end = networkModel.getVertexByName('p13')!;
-
-        const route = router.calculateShortestPathByVertex(start, end).route();
-        expect(route).is.not.undefined;
-        expect(getVerticesNames(route)).deep.equals(['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
-
-        const routeOtherWay = router.calculateShortestPathByVertex(end, start).route();
-        expect(routeOtherWay).is.not.undefined;
-        expect(getVerticesNames(routeOtherWay)).deep.equals(['p13', 'p12', 'p9', 'p8', 'p6']);
-    });
-});
-
-
-describe('OsmRouter - Instruction stairs same level', () => {
-
-    const networkModel = loadGraph('network-steps-same-level.osm');
-    const router = new GraphRouter(networkModel);
-
-    const getItinerary = (startName: string, endName: string) => {
-        const start = networkModel.getVertexByName(startName)!;
-        const end = networkModel.getVertexByName(endName)!;
-        return Itinerary.fromGraphRoute(router.calculateShortestPathByVertex(start, end).route());
-    }
-
-    const expectLevelChangeAtSecondStep = (steps: Step[], direction: 'up' | 'down', difference: number) => {
-        expect(steps.length).equals(3);
-        expect(steps[1].levelChange).is.not.null;
-        expect(steps[1].levelChange?.direction).equal(direction);
-        expect(steps[1].levelChange?.difference).equal(difference);
-    }
-
-    it('generate instructions for steps at same level', () => {
-
-        expect(getItinerary('start1', 'end1').steps.length).equal(1);
-        expect(getItinerary('start2', 'end2').steps.length).equal(1);
-
-        expectLevelChangeAtSecondStep(getItinerary('start3', 'end3').steps, 'up', 0);
-        expectLevelChangeAtSecondStep(getItinerary('start4', 'end4').steps, 'down', 0);
-        expectLevelChangeAtSecondStep(getItinerary('start5', 'end5').steps, 'down', 0);
-        expectLevelChangeAtSecondStep(getItinerary('start6', 'end6').steps, 'up', 0);
-
-        expectLevelChangeAtSecondStep(getItinerary('start7', 'end7').steps, 'up', 1);
-        expect(getItinerary('start8', 'end8').steps.length).equal(1);
-        expectLevelChangeAtSecondStep(getItinerary('start9', 'end9').steps, 'up', 1);
-        expectLevelChangeAtSecondStep(getItinerary('start10', 'end10').steps, 'down', 1); // incline > diff of levels
-    });
-});
-
-
-describe('OsmRouter - getTrip', () => {
-
-    const networkModel = loadGraph('gare-de-lest-network-pp-bounds.osm');
-    const router = new GraphRouter(networkModel);
-
-
-    const p1 = new Coordinates(48.87694226286171, 2.358214642814393, null, 0);
-    const p2 = new Coordinates(48.877231170388875, 2.358976282564408, null, 0);
-    const p3 = new Coordinates(48.876686873477645, 2.359162193531473, null, -1);
-    const p4 = new Coordinates(48.87644529052338, 2.3592866339368475, null, 0);
-    const p5 = new Coordinates(48.87686732039252, 2.3599553137054845, null, -1);
-
-    it('getTrip - Success', () => {
-        expect(router.getShortestTrip([p1, p2, p3, p4, p5])).is.not.empty;
-    });
-
-    it('getTrip - No route', () => {
-        const p6 = new Coordinates(0, 0);
-        expect(router.getShortestTrip([p1, p2, p3, p4, p5, p6])).is.empty;
-    });
-});
-
-
-describe('OsmRouter - create graph components', () => {
-
-    const networkModel = loadGraph('components.osm');
-    const router = new GraphRouter(networkModel);
-
-    const arraysEqual = <T>(a: T[], b: T[]) => JSON.stringify(a.sort()) === JSON.stringify(b.sort());
-    const findComponent = (components: Vertex[][], vertexNames: string[]) =>
-        components.find(c => arraysEqual(c.map(v => v.properties.name), vertexNames))
-
-    it('createComponents()', () => {
-        const components = router.calculateComponents();
-
-        // console.log(JSON.stringify(components.map(c => c.map(v => v.properties.name)), null, 4));
-        expect(components.length).equal(6);
-        expect(findComponent(components, ['p1', 'p2', 'p3', 'p4'])).to.be.not.undefined;
-        expect(findComponent(components, ['p11', 'p12', 'p13'])).to.be.not.undefined;
-        expect(findComponent(components, ['p13', 'p14'])).to.be.not.undefined;
-        expect(findComponent(components, ['p21', 'p22'])).to.be.not.undefined;
-        expect(findComponent(components, ['p31', 'p32', 'p32', 'p33', 'p34'])).to.be.not.undefined;
-        expect(findComponent(components, ['p41', 'p42', 'p43', 'p44', 'p45', 'p46', 'p47', 'p48'])).to.be.not.undefined;
-    });
-
-});

package/tests/CommonTest.ts

@@ -1,78 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-import { expect } from 'chai';
-
-import Edge from '../src/graph/Edge.js';
-import Vertex from '../src/graph/Vertex.js';
-import Graph from '../src/graph/Graph.js';
-
-const vertices = [
-    new Vertex(new Coordinates(43.6092404, 3.884099, null, 2), { name: 'p0' }), // 0
-    new Vertex(new Coordinates(43.6091965, 3.8841285, null, 2), { name: 'p1' }),
-    new Vertex(new Coordinates(43.6091888, 3.8841263, null, 2), { name: 'p2' }),
-    new Vertex(new Coordinates(43.6091361, 3.8841109, null, 2), { name: 'p3' }),
-    new Vertex(new Coordinates(43.6091194, 3.8842202, null, 2), { name: 'p4' }),
-    new Vertex(new Coordinates(43.6091722, 3.8842355, null, 2), { name: 'p5' }),
-    new Vertex(new Coordinates(43.6091749, 3.8842173, null, 2), { name: 'p6' }),
-    new Vertex(new Coordinates(43.609276, 3.8842467, null, 2), { name: 'p7' }),
-    new Vertex(new Coordinates(43.6092935, 3.8842518, null, 2), { name: 'p8' }),
-    new Vertex(new Coordinates(43.6093022, 3.8842702, null, 2), { name: 'p9' }),
-    new Vertex(new Coordinates(43.6093123, 3.8842731, null, 2), { name: 'p10' }), // 10
-    new Vertex(new Coordinates(43.6093234, 3.8842009, null, 2), { name: 'p11' }),
-    new Vertex(new Coordinates(43.6093629, 3.8842127, null, [1, 2]), { name: 'p12' }),
-    new Vertex(new Coordinates(43.6093597, 3.8842336, null, [1, 2]), { name: 'p13' }),
-    new Vertex(new Coordinates(43.6093202, 3.8842218, null, 1), { name: 'p14' }),
-    new Vertex(new Coordinates(43.6093123, 3.8842731, null, 1), { name: 'p15' }),
-    new Vertex(new Coordinates(43.6092681, 3.8842604, null, 1), { name: 'p16' }),
-    new Vertex(new Coordinates(43.6093279, 3.8842777, null, 1), { name: 'p17' }),
-    new Vertex(new Coordinates(43.6093279, 3.8842777, null, 2), { name: 'p18' }),
-    new Vertex(new Coordinates(43.6093323, 3.8842483, null, 2), { name: 'p19a' }),
-    new Vertex(new Coordinates(43.6093323, 3.8842483, null, 1), { name: 'p19b' }), // 20
-    new Vertex(new Coordinates(43.6093323, 3.8842483, null, 0), { name: 'p19c' }),
-    new Vertex(new Coordinates(43.6093032, 3.8844388, null, 0), { name: 'p21' }),
-    new Vertex(new Coordinates(43.6095297, 3.8845039, null, 0), { name: 'p26' }),
-    new Vertex(new Coordinates(43.6095624, 3.8845134), { name: 'p27' })
-];
-
-const n = (name: string) => vertices.find(vertex => vertex.properties.name === name) as Vertex;
-
-const edges = [
-    new Edge(n('p1'), n('p2'), { name: 'e0' }),
-    new Edge(n('p2'), n('p3'), { name: 'e1' }),
-    new Edge(n('p3'), n('p4'), { name: 'e2' }),
-    new Edge(n('p4'), n('p5'), { name: 'e3' }),
-    new Edge(n('p5'), n('p6'), { name: 'e4' }),
-    new Edge(n('p6'), n('p2'), { name: 'e5' }),
-    new Edge(n('p6'), n('p7'), { name: 'e6' }),
-    new Edge(n('p7'), n('p8'), { name: 'e7' }),
-    new Edge(n('p8'), n('p9'), { name: 'e8' }),
-    new Edge(n('p9'), n('p10'), { name: 'e9' }),
-    new Edge(n('p10'), n('p11'), { name: 'e10' }),
-    new Edge(n('p11'), n('p12'), { name: 'e11' }),
-    new Edge(n('p12'), n('p13'), { name: 'e12' }),
-    new Edge(n('p13'), n('p14'), { name: 'e13' }),
-    new Edge(n('p14'), n('p15'), { name: 'e14' }),
-    new Edge(n('p15'), n('p16'), { name: 'e15' }),
-    new Edge(n('p15'), n('p17'), { name: 'e16' }),
-    new Edge(n('p19b'), n('p17'), { name: 'e17' }),
-    new Edge(n('p10'), n('p18'), { name: 'e18' }),
-    new Edge(n('p19a'), n('p18'), { name: 'e19' }),
-    new Edge(n('p19a'), n('p19b'), { name: 'e20' }),
-    new Edge(n('p19b'), n('p19c'), { name: 'e21'}),
-    new Edge(n('p19c'), n('p21'), { name: 'e22' }),
-    new Edge(n('p21'), n('p26'), { name: 'e23' }),
-    new Edge(n('p26'), n('p27'), { name: 'e24' })
-];
-
-const graph = new Graph(vertices, edges);
-
-function verifyCoherence(graph: Graph) {
-    graph.edges.forEach(edge => {
-        expect(edge.vertex1).not.equal(edge.vertex2);
-    });
-}
-
-export {
-    vertices, edges, graph,
-    verifyCoherence,
-    Graph, Vertex, Edge
-};

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json"
-}

package/vite.config.ts

@@ -1,4 +0,0 @@
-import { generateConfigForLibrary } from '../../vite.common';
-
-export default generateConfigForLibrary('routers');
-