terra-draw-route-snap-mode 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "terra-draw-route-snap-mode",
-    "version": "0.1.3",
+    "version": "0.2.0",
     "description": "A mode for Terra Draw to provide snapping to a route network",
     "scripts": {
         "docs": "typedoc",
@@ -60,7 +60,7 @@
         "knip": "5.30.2",
         "microbundle": "0.15.0",
         "serve": "^14.2.4",
-        "terra-route": "^0.0.13",
+        "terra-route": "^0.0.14",
         "ts-jest": "^29.3.1",
         "ts-loader": "9.5.1",
         "tsx": "^4.19.3",

package/src/routing.spec.ts

@@ -35,102 +35,423 @@ describe("Routing", () => {
     const mockRouteFinder = {
         getRoute: jest.fn().mockReturnValue(mockRoute),
         setNetwork: jest.fn(),
+        expandNetwork: jest.fn(),
     };
 
-    it("should return null for empty network", () => {
-        const routing = new Routing({
-            network: {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    })
+
+    describe("constructor", () => {
+        it("should not be affected if the original network is mutated after construction", () => {
+            const inputNetwork: FeatureCollection<LineString> = {
                 type: "FeatureCollection",
                 features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [0, 0],
+                                [1, 1],
+                            ],
+                        },
+                        properties: {},
+                    },
                 ],
-            }, routeFinder: mockRouteFinder
-        });
+            };
+
+            const routing = new Routing({ network: inputNetwork, routeFinder: mockRouteFinder });
 
-        const closest = routing.getClosestNetworkCoordinate([0, 0]);
+            // Mutate the original object after construction
+            inputNetwork.features.pop();
 
-        expect(closest).toEqual(null);
+            // Routing should still behave as if the original feature exists
+            expect(routing.getClosestNetworkCoordinate([0, 0])).toEqual([0, 0]);
+            expect(routing.getClosestNetworkCoordinate([1, 1])).toEqual([1, 1]);
+
+            expect(routing.getRoute([0, 0], [1, 1])).toEqual({
+                type: "Feature",
+                geometry: {
+                    type: "LineString",
+                    coordinates: [
+                        [0, 0],
+                        [1, 1],
+                    ],
+                },
+                properties: {},
+            });
+        });
     });
 
-    it("should find the closest network coordinate with exact match", () => {
-        const routing = new Routing({ network, routeFinder: mockRouteFinder });
+    describe("getClosestNetworkCoordinate", () => {
+        it("should return null for empty network", () => {
+            const routing = new Routing({
+                network: {
+                    type: "FeatureCollection",
+                    features: [
+                    ],
+                }, routeFinder: mockRouteFinder
+            });
+
+            const closest = routing.getClosestNetworkCoordinate([0, 0]);
+
+            expect(closest).toEqual(null);
+        });
+
+        it("should find the closest network coordinate with exact match", () => {
+            const routing = new Routing({ network, routeFinder: mockRouteFinder });
+
+            const closest = routing.getClosestNetworkCoordinate([0, 0]);
+
+            expect(closest).toEqual([0, 0]);
+        });
 
-        const closest = routing.getClosestNetworkCoordinate([0, 0]);
+        it("should find the closest network coordinate if not exact match", () => {
+            const routing = new Routing({ network, routeFinder: mockRouteFinder });
+
+            const closest = routing.getClosestNetworkCoordinate([0.1, 0.1]);
+
+            expect(closest).toEqual([0, 0]);
+        });
+
+        it("should still return a closest coordinate when a network repeats points", () => {
+            const networkWithDuplicates: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [0, 0],
+                                [1, 1],
+                                [1, 1],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
 
-        expect(closest).toEqual([0, 0]);
+            const routing = new Routing({ network: networkWithDuplicates, routeFinder: mockRouteFinder });
+            expect(routing.getClosestNetworkCoordinate([1, 1])).toEqual([1, 1]);
+        });
     });
 
-    it("should find the closest network coordinate if not exact match", () => {
-        const routing = new Routing({ network, routeFinder: mockRouteFinder });
+    describe("getRoute", () => {
+        it("should return a route and cache it if enabled", () => {
+            const routing = new Routing({ network, routeFinder: mockRouteFinder, useCache: true });
+
+            const route = routing.getRoute([0, 0], [1, 1]);
+
+            expect(route).toEqual(mockRoute);
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1);
+
+            // Call again to hit cache
+            const cachedRoute = routing.getRoute([0, 0], [1, 1]);
+
+            expect(cachedRoute).toEqual(mockRoute);
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1); // Still 1 because cache used
+        });
+
+        it("should call the route finder again when the previous result was null", () => {
+            const nullRouteFinder = {
+                getRoute: jest.fn().mockReturnValue(null),
+                setNetwork: jest.fn(),
+                expandNetwork: jest.fn(),
+            };
 
-        const closest = routing.getClosestNetworkCoordinate([0.1, 0.1]);
+            const routing = new Routing({ network, routeFinder: nullRouteFinder, useCache: true });
 
-        expect(closest).toEqual([0, 0]);
+            expect(routing.getRoute([0, 0], [1, 1])).toBeNull();
+            expect(routing.getRoute([0, 0], [1, 1])).toBeNull();
+            expect(nullRouteFinder.getRoute).toHaveBeenCalledTimes(2);
+        });
+
+        it("should return a new route if cache is disabled", () => {
+            const routing = new Routing({ network, routeFinder: mockRouteFinder, useCache: false });
+
+            routing.getRoute([0, 0], [1, 1]);
+            routing.getRoute([0, 0], [1, 1]);
+
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(2);
+        });
     });
 
-    it("should return a route and cache it if enabled", () => {
-        const routing = new Routing({ network, routeFinder: mockRouteFinder, useCache: true });
+    describe("setNetwork", () => {
+        it("should clear the route cache when the network is replaced", () => {
+            const routing = new Routing({ network, routeFinder: mockRouteFinder, useCache: true });
+
+            routing.getRoute([0, 0], [1, 1]);
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1);
+
+            // Warm cache
+            routing.getRoute([0, 0], [1, 1]);
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1);
 
-        const route = routing.getRoute([0, 0], [1, 1]);
+            const newNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [10, 10],
+                                [11, 11],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
+
+            routing.setNetwork(newNetwork);
+
+            // Cache should be cleared, so it calls through again.
+            routing.getRoute([0, 0], [1, 1]);
+            expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(2);
+        });
+
+        it("should not be affected if the original network is mutated after setNetwork", () => {
+            const terraRoute = new TerraRoute();
+            terraRoute.buildRouteGraph(network);
+
+            const routing = new Routing({
+                network,
+                routeFinder: {
+                    getRoute: terraRoute.getRoute.bind(terraRoute),
+                    setNetwork: terraRoute.buildRouteGraph.bind(terraRoute),
+                    expandNetwork: terraRoute.expandRouteGraph.bind(terraRoute),
+                },
+            });
+
+            const replacementNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [10, 10],
+                                [11, 11],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
 
-        expect(route).toEqual(mockRoute);
-        expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1);
+            routing.setNetwork(replacementNetwork);
 
-        // Call again to hit cache
-        const cachedRoute = routing.getRoute([0, 0], [1, 1]);
+            // Mutate the original object after setNetwork
+            replacementNetwork.features.pop();
 
-        expect(cachedRoute).toEqual(mockRoute);
-        expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(1); // Still 1 because cache used
+            // Routing should still behave as if the replacement feature exists
+            expect(routing.getClosestNetworkCoordinate([10, 10])).toEqual([10, 10]);
+            expect(routing.getClosestNetworkCoordinate([11, 11])).toEqual([11, 11]);
+
+            expect(routing.getRoute([10, 10], [11, 11])).toEqual({
+                type: "Feature",
+                geometry: {
+                    type: "LineString",
+                    coordinates: [
+                        [10, 10],
+                        [11, 11],
+                    ],
+                },
+                properties: {},
+            });
+
+        });
     });
 
-    it("should return a new route if cache is disabled", () => {
-        const routing = new Routing({ network, routeFinder: mockRouteFinder, useCache: false });
+    describe("expandRouteNetwork", () => {
+        it("should clear the route cache when the network is expanded", () => {
+            const routing = new Routing({
+                network,
+                routeFinder: mockRouteFinder,
+                useCache: true,
+            });
+
+            const additionalNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [2, 2],
+                                [3, 3],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
+
+            const getRouteSpy = jest.spyOn(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (routing as any).routeFinder,
+                "getRoute"
+            );
+
+            routing.getRoute([0, 0], [1, 1]);
+            routing.getRoute([0, 0], [1, 1]);
+            expect(getRouteSpy).toHaveBeenCalledTimes(1);
+
+            routing.expandRouteNetwork(additionalNetwork);
+
+            // Cache should be cleared after expansion.
+            routing.getRoute([0, 0], [1, 1]);
+            expect(getRouteSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it("should expand the route network and re-index points", () => {
+            const routing = new Routing({
+                network,
+                routeFinder: mockRouteFinder,
+                useCache: true,
+            });
 
-        routing.getRoute([0, 0], [1, 1]);
-        routing.getRoute([0, 0], [1, 1]);
+            expect(routing.getClosestNetworkCoordinate([2, 2])).toEqual([1, 1]);
 
-        expect(mockRouteFinder.getRoute).toHaveBeenCalledTimes(2);
+            const additionalNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [2, 2],
+                                [3, 3],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
+
+            const expandSpy = jest.spyOn(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (routing as any).routeFinder,
+                "expandNetwork"
+            );
+            routing.expandRouteNetwork(additionalNetwork);
+
+            expect(expandSpy).toHaveBeenCalledWith(additionalNetwork);
+
+            expect(routing.getClosestNetworkCoordinate([1, 1])).toEqual([1, 1]);
+            expect(routing.getClosestNetworkCoordinate([2, 2])).toEqual([2, 2]);
+            expect(routing.getClosestNetworkCoordinate([3, 3])).toEqual([3, 3]);
+
+        });
     });
 
-    it('should update the network correctly with real a route finder', () => {
-        const terraRoute = new TerraRoute();
-        terraRoute.buildRouteGraph(network);
+    describe("integration (TerraRoute)", () => {
+        it('should update the network correctly with real a route finder', () => {
+            const terraRoute = new TerraRoute();
+            terraRoute.buildRouteGraph(network);
 
-        const routing = new Routing({
-            network, routeFinder: {
-                getRoute: terraRoute.getRoute.bind(terraRoute),
-                setNetwork: terraRoute.buildRouteGraph.bind(terraRoute)
-            }
+            const routing = new Routing({
+                network, routeFinder: {
+                    getRoute: terraRoute.getRoute.bind(terraRoute),
+                    setNetwork: terraRoute.buildRouteGraph.bind(terraRoute),
+                    expandNetwork: terraRoute.expandRouteGraph.bind(terraRoute)
+                }
+            });
+
+            jest.spyOn(routing, "setNetwork");
+
+            const existingRoute = routing.getRoute([0, 0], [1, 1]);
+            expect(existingRoute?.geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+            expect(routing.getRoute([2, 2], [3, 3])).toBeNull();
+
+            const newNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [2, 2],
+                                [3, 3],
+                            ],
+                        },
+                        properties: {},
+                    },
+                ],
+            };
+
+            routing.setNetwork(newNetwork);
+
+            expect(routing.setNetwork).toHaveBeenCalledWith(newNetwork);
+
+            const newRoute = routing.getRoute([2, 2], [3, 3]);
+            expect(newRoute?.geometry.coordinates).toEqual([[2, 2], [3, 3]]);
+            expect(routing.getRoute([0, 0], [1, 1])).toBeNull();
         });
 
-        jest.spyOn(routing, "setNetwork");
-
-        const existingRoute = routing.getRoute([0, 0], [1, 1]);
-        expect(existingRoute?.geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        expect(routing.getRoute([2, 2], [3, 3])).toBeNull();
-
-        const newNetwork: FeatureCollection<LineString> = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [2, 2],
-                            [3, 3],
-                        ],
+        it('should be able to route after expanding the network', () => {
+            const terraRoute = new TerraRoute();
+            terraRoute.buildRouteGraph(network);
+
+            const routing = new Routing({
+                network, routeFinder: {
+                    getRoute: terraRoute.getRoute.bind(terraRoute),
+                    setNetwork: terraRoute.buildRouteGraph.bind(terraRoute),
+                    expandNetwork: terraRoute.expandRouteGraph.bind(terraRoute)
+                }
+            });
+
+            jest.spyOn(routing, "expandRouteNetwork");
+
+            const existingRoute = routing.getRoute([0, 0], [1, 1]);
+            expect(existingRoute?.geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+            expect(routing.getRoute([2, 2], [3, 3])).toBeNull();
+
+            const newNetwork: FeatureCollection<LineString> = {
+                type: "FeatureCollection",
+                features: [
+                    {
+                        type: "Feature",
+                        geometry: {
+                            type: "LineString",
+                            coordinates: [
+                                [2, 2],
+                                [3, 3],
+                            ],
+                        },
+                        properties: {},
                     },
-                    properties: {},
-                },
-            ],
-        };
+                ],
+            };
+
+            routing.expandRouteNetwork(newNetwork);
 
-        routing.setNetwork(newNetwork);
+            expect(routing.expandRouteNetwork).toHaveBeenCalledWith(newNetwork);
 
-        expect(routing.setNetwork).toHaveBeenCalledWith(newNetwork);
+            const newRoute = routing.getRoute([2, 2], [3, 3]);
+            expect(newRoute?.geometry.coordinates).toEqual([[2, 2], [3, 3]]);
+            expect(routing.getRoute([0, 0], [1, 1])).toEqual({
+                type: "Feature",
+                geometry: {
+                    type: "LineString",
+                    coordinates: [
+                        [0, 0],
+                        [1, 1],
+                    ],
+                },
+                properties: {},
+            });
 
-        const newRoute = routing.getRoute([2, 2], [3, 3]);
-        expect(newRoute?.geometry.coordinates).toEqual([[2, 2], [3, 3]]);
-        expect(routing.getRoute([0, 0], [1, 1])).toBeNull();
+            // 1, 1 is not connected to 2, 2
+            expect(routing.getRoute([0, 0], [3, 3])).toBeNull();
+        });
     });
 });

package/src/routing.ts

@@ -11,6 +11,7 @@ import {
 export type RouteFinder = {
   getRoute: (positionA: Feature<Point>, positionB: Feature<Point>) => Feature<LineString> | null
   setNetwork: (network: FeatureCollection<LineString>) => void
+  expandNetwork: (additionalNetwork: FeatureCollection<LineString>) => void
 }
 
 export interface RoutingInterface {
@@ -33,8 +34,8 @@ export class Routing implements RoutingInterface {
     network: FeatureCollection<LineString>, useCache?: boolean,
     routeFinder: RouteFinder
   }) {
-    this.useCache = options.useCache || true;
-    this.network = options.network;
+    this.useCache = options.useCache !== undefined ? options.useCache : true;
+    this.network = this.clone(options.network);
     this.routeFinder = options.routeFinder;
 
     this.initialise();
@@ -96,7 +97,7 @@ export class Routing implements RoutingInterface {
    * @param network The network to use
    */
   public setNetwork(network: FeatureCollection<LineString>) {
-    this.network = network;
+    this.network = this.clone(network);
 
     // Ensure the network is updated correctly for the router finder
     this.routeFinder.setNetwork(network);
@@ -105,6 +106,24 @@ export class Routing implements RoutingInterface {
     this.initialise();
   }
 
+  public expandRouteNetwork(additionalNetwork: FeatureCollection<LineString>) {
+    const clonedNetwork = this.clone(additionalNetwork);
+
+    // Ensure the network is updated correctly for the router finder
+    this.routeFinder.expandNetwork(clonedNetwork);
+
+    const mergedNetwork = {
+      type: "FeatureCollection",
+      features: [...clonedNetwork.features, ...this.network.features]
+    } as FeatureCollection<LineString>;
+
+    this.network = mergedNetwork;
+
+    // Re-initialize all internal data structures for this class
+    // TODO: Is there a way to avoid re-initialising here?
+    this.initialise();
+  }
+
   /**
    * Get the route between two coordinates returned as a GeoJSON LineString
    * @param startCoord start coordinate
@@ -152,4 +171,8 @@ export class Routing implements RoutingInterface {
     return route;
 
   }
+
+  private clone(network: FeatureCollection<LineString>) {
+    return JSON.parse(JSON.stringify(network)) as FeatureCollection<LineString>;
+  }
 }

package/src/terra-draw-route-snap.mode.spec.ts

@@ -5,6 +5,7 @@ describe("TerraDrawRouteSnapMode", () => {
     const mockRouteFinder = {
         getRoute: jest.fn(),
         setNetwork: jest.fn(),
+        expandNetwork: jest.fn(),
     };
 
     it("should construct the class correctly", () => {