terra-route 0.0.4 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
 # Terra Route
 
-Terra Route aims to be a fast library for routing on GeoJSON LineStrings networks, where LineStrings share identical coordinates. Terra Routes main aim is currently performance.
+Terra Route aims to be a fast library for routing on GeoJSON LineStrings networks, where LineStrings share identical coordinates. Terra Routes main aim is currently performance - it uses bidirectional A* to help achieve this.
 
 ## Install
 
@@ -89,7 +89,7 @@ You can run the benchmarks yourself using:
 npm run benchmark
 ```
 
-Using default Haversine distance, Terra Route is approximately 1.6x faster than GeoJSON Path Finder with Haversine distance. If you pass in the CheapRuler distance metric (you can use the exposed `createCheapRuler` function), it is about 3x faster. 
+Using default Haversine distance, Terra Route is approximately 3x faster than GeoJSON Path Finder with Haversine distance. If you pass in the CheapRuler distance metric (you can use the exposed `createCheapRuler` function), it is about 5x faster. 
 
 ## Limitations
 

package/eslint.config.mjs

@@ -0,0 +1,54 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import tsParser from "@typescript-eslint/parser";
+import eslintPluginPrettier from "eslint-plugin-prettier";
+import prettierConfig from "eslint-config-prettier";
+import json from "@eslint/json";
+import markdown from "@eslint/markdown";
+
+const ignores = ["**/node_modules", "**/dist", "**/docs", ".github", ".husky", ".vscode", "**/public", "**/coverage", "packages/e2e/playwright-report"];
+
+export default [
+    {
+        ignores
+    },
+    {
+        files: ["**/*.json"],
+        language: "json/json",
+        plugins: {
+            json,
+        }
+    },
+    {
+        files: ["**/*.md"],
+        plugins: {
+            markdown
+        },
+        language: "markdown/commonmark",
+    },
+    {
+        name: "prettier", // Configuration name
+        files: ["**/*.{js,jsx,ts,tsx,json,md,yml,yaml,html,css}"],
+        ignores: ['**.json'],
+        plugins: {
+            prettier: eslintPluginPrettier, // Include Prettier plugin
+        },
+        rules: {
+            ...prettierConfig.rules, // Disable ESLint rules that conflict with Prettier
+        },
+    },
+    {
+        name: "typescript", // Configuration name
+        files: ["**/*.ts"], // TypeScript-specific configuration
+        plugins: {
+            "@typescript-eslint": typescriptEslint, // Include TypeScript ESLint plugin
+        },
+        languageOptions: {
+            parser: tsParser,
+        },
+        rules: {
+            "@typescript-eslint/no-empty-function": "warn",
+            "@typescript-eslint/no-explicit-any": "warn",
+            "no-console": process.env.CI ? "error" : "warn",
+        },
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "terra-route",
-    "version": "0.0.4",
+    "version": "0.0.5",
     "description": "A library for routing along GeoJSON LineString networks",
     "scripts": {
         "docs": "typedoc",
@@ -10,10 +10,12 @@
         "build": "microbundle",
         "watch": "microbundle --watch --format modern",
         "unused": "knip",
-        "lint": "eslint --ext .ts src/",
-        "lint:quiet": "eslint --ext .ts --quiet src/",
-        "lint:fix": "eslint --fix --ext .ts src/",
-        "lint:fix:quiet": "eslint --fix --quiet --ext .ts src/"
+        "lint": "eslint --config eslint.config.mjs",
+        "lint:quiet": "eslint --quiet --config eslint.config.mjs",
+        "lint:fix": "eslint --fix --config eslint.config.mjs",
+        "lint:fix:quiet": "eslint --fix --quiet --config eslint.config.mjs",
+        "format": "prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\"",
+        "format:quiet": "prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\" --log-level=silent"
     },
     "type": "module",
     "source": "src/terra-route.ts",
@@ -29,6 +31,8 @@
     "author": "James Milner",
     "license": "MIT",
     "devDependencies": {
+        "@eslint/json": "^0.11.0",
+        "@eslint/markdown": "^6.3.0",
         "@types/jest": "^29.5.14",
         "@types/lodash": "^4.17.13",
         "@typescript-eslint/eslint-plugin": "8.16.0",
@@ -47,9 +51,7 @@
         "typedoc": "^0.28.1",
         "typescript": "^5.8.3"
     },
-    "dependencies": {
-        "@turf/turf": "^7.1.0"
-    },
+    "dependencies": {},
     "keywords": [
         "geojson",
         "linestring",
@@ -60,25 +62,6 @@
         "astar",
         "djikstra"
     ],
-    "eslintConfig": {
-        "parser": "@typescript-eslint/parser",
-        "plugins": [
-            "@typescript-eslint"
-        ],
-        "rules": {
-            "@typescript-eslint/no-empty-function": "warn",
-            "@typescript-eslint/no-explicit-any": "warn"
-        },
-        "extends": [
-            "plugin:@typescript-eslint/recommended",
-            "prettier"
-        ]
-    },
-    "prettier": {
-        "printWidth": 80,
-        "semi": true,
-        "useTabs": true
-    },
     "knip": {
         "$schema": "https://unpkg.com/knip@5/schema.json",
         "entry": [

package/src/terra-route.spec.ts

@@ -378,7 +378,7 @@ describe("TerraRoute", () => {
     it('is able to route through a interconnected hexagonal star polygon ignoring other routes than the direct line', () => {
         const network = generateStarPolygon(5, 1, [0, 0]);
         const points = getUniqueCoordinatesFromLineStrings(network);
-
+        routeFinder.buildRouteGraph(network);
 
         for (let i = 0; i < points.length - 1; i++) {
             const start = createPointFeature(points[i]);
@@ -393,6 +393,7 @@ describe("TerraRoute", () => {
     it('is able to route through a interconnected hexadecagon star polygon ignoring other routes than the direct line', () => {
         const network = generateStarPolygon(16, 1, [0, 0]);
         const points = getUniqueCoordinatesFromLineStrings(network);
+        routeFinder.buildRouteGraph(network);
 
         for (let i = 0; i < points.length - 1; i++) {
             const start = createPointFeature(points[i]);
@@ -407,6 +408,7 @@ describe("TerraRoute", () => {
     it('is able to route around a non-interconnected hexagon star polygon', () => {
         const network = generateStarPolygon(5, 1, [0, 0], false);
         const points = getUniqueCoordinatesFromLineStrings(network)
+        routeFinder.buildRouteGraph(network);
 
         for (let i = 1; i < points.length; i++) {
             const start = createPointFeature(points[0]);
@@ -425,6 +427,7 @@ describe("TerraRoute", () => {
     it('is able to route around a non-interconnected hexadecagon star polygon', () => {
         const network = generateStarPolygon(16, 1, [0, 0], false);
         const points = getUniqueCoordinatesFromLineStrings(network)
+        routeFinder.buildRouteGraph(network);
 
         for (let i = 1; i < points.length; i++) {
             const start = createPointFeature(points[0]);
@@ -445,6 +448,7 @@ describe("TerraRoute", () => {
         const depth = 5;
         const network = generateTreeFeatureCollection(depth, 2)
         const points = getUniqueCoordinatesFromLineStrings(network)
+        routeFinder.buildRouteGraph(network);
 
         const start = createPointFeature(points[0]);
         const end = createPointFeature(points[points.length - 1]);
@@ -457,8 +461,8 @@ describe("TerraRoute", () => {
 
     it('is able to traverse a concentric graph with 3 rings', () => {
         const network = generateConcentricRings(3, 10, 1, [0, 0])
-
         const points = getUniqueCoordinatesFromLineStrings(network)
+        routeFinder.buildRouteGraph(network);
 
         for (let i = 1; i < points.length; i++) {
             const start = createPointFeature(points[0]);
@@ -475,9 +479,7 @@ describe("TerraRoute", () => {
 
     it('is able to traverse a concentric graph with 5 rings', () => {
         const network = generateConcentricRings(5, 10, 1, [0, 0])
-
         const points = getUniqueCoordinatesFromLineStrings(network)
-
         routeFinder.buildRouteGraph(network);
 
         for (let i = 1; i < points.length; i++) {

package/src/terra-route.ts

@@ -44,11 +44,11 @@ class TerraRoute {
             return latMap.get(lat)!;
         }
 
-        const idx = this.coords.length;
+        const index = this.coords.length;
         this.coords.push(coord);
-        latMap.set(lat, idx);
+        latMap.set(lat, index);
 
-        return idx;
+        return index;
     }
 
     /**
@@ -68,21 +68,21 @@ class TerraRoute {
         for (const feature of this.network.features) {
             const coords = feature.geometry.coordinates;
             for (let i = 0; i < coords.length - 1; i++) {
-                const aIdx = this.coordinateIndex(coords[i]);
-                const bIdx = this.coordinateIndex(coords[i + 1]);
+                const aIndex = this.coordinateIndex(coords[i]);
+                const bIndex = this.coordinateIndex(coords[i + 1]);
                 const distance = this.distanceMeasurement(coords[i], coords[i + 1]);
 
-                if (!this.adjacencyList.has(aIdx)) this.adjacencyList.set(aIdx, []);
-                if (!this.adjacencyList.has(bIdx)) this.adjacencyList.set(bIdx, []);
+                if (!this.adjacencyList.has(aIndex)) this.adjacencyList.set(aIndex, []);
+                if (!this.adjacencyList.has(bIndex)) this.adjacencyList.set(bIndex, []);
 
-                this.adjacencyList.get(aIdx)!.push({ node: bIdx, distance });
-                this.adjacencyList.get(bIdx)!.push({ node: aIdx, distance });
+                this.adjacencyList.get(aIndex)!.push({ node: bIndex, distance });
+                this.adjacencyList.get(bIndex)!.push({ node: aIndex, distance });
             }
         }
     }
 
     /**
-    * Computes the shortest route between two points in the network using A* algorithm.
+    * Computes the shortest route between two points in the network using bidirectional A* algorithm.
     * 
     * @param start - A GeoJSON Point Feature representing the start location.
     * @param end - A GeoJSON Point Feature representing the end location.
@@ -92,52 +92,96 @@ class TerraRoute {
     */
     public getRoute(start: Feature<Point>, end: Feature<Point>): Feature<LineString> | null {
         if (!this.network) {
-            throw new Error("Network not built. Please call buildNetworkGraph(network) first.");
+            throw new Error("Network not built. Please call buildRouteGraph(network) first.");
         }
 
-        const startIdx = this.coordinateIndex(start.geometry.coordinates);
-        const endIdx = this.coordinateIndex(end.geometry.coordinates);
+        const startIndex = this.coordinateIndex(start.geometry.coordinates);
+        const endIndex = this.coordinateIndex(end.geometry.coordinates);
 
-        if (startIdx === endIdx) {
+        if (startIndex === endIndex) {
             return null;
         }
 
-        const openSet = new MinHeap();
-        openSet.insert(0, startIdx);
-        const cameFrom = new Map<number, number>();
-        const gScore = new Map<number, number>([[startIdx, 0]]);
+        const openSetForward = new MinHeap();
+        const openSetBackward = new MinHeap();
+        openSetForward.insert(0, startIndex);
+        openSetBackward.insert(0, endIndex);
 
-        while (openSet.size() > 0) {
-            const current = openSet.extractMin()!;
+        const cameFromForward = new Map<number, number>();
+        const cameFromBackward = new Map<number, number>();
+        const gScoreForward = new Map<number, number>([[startIndex, 0]]);
+        const gScoreBackward = new Map<number, number>([[endIndex, 0]]);
 
-            if (current === endIdx) {
-                const path: Position[] = [];
-                let currNode: number | undefined = current;
-                while (currNode !== undefined) {
-                    path.unshift(this.coords[currNode]);
-                    currNode = cameFrom.get(currNode);
+        const visitedForward = new Set<number>();
+        const visitedBackward = new Set<number>();
+
+        let meetingNode: number | null = null;
+
+        while (openSetForward.size() > 0 && openSetBackward.size() > 0) {
+            const currentForward = openSetForward.extractMin()!;
+            visitedForward.add(currentForward);
+
+            if (visitedBackward.has(currentForward)) {
+                meetingNode = currentForward;
+                break;
+            }
+
+            for (const neighbor of this.adjacencyList.get(currentForward) || []) {
+                const tentativeG = (gScoreForward.get(currentForward) ?? Infinity) + neighbor.distance;
+                if (tentativeG < (gScoreForward.get(neighbor.node) ?? Infinity)) {
+                    cameFromForward.set(neighbor.node, currentForward);
+                    gScoreForward.set(neighbor.node, tentativeG);
+                    const fScore = tentativeG + this.distanceMeasurement(this.coords[neighbor.node], this.coords[endIndex]);
+                    openSetForward.insert(fScore, neighbor.node);
                 }
-                return {
-                    type: "Feature",
-                    geometry: { type: "LineString", coordinates: path },
-                    properties: {},
-                };
             }
 
-            const neighbors = this.adjacencyList.get(current) || [];
+            const currentBackward = openSetBackward.extractMin()!;
+            visitedBackward.add(currentBackward);
+
+            if (visitedForward.has(currentBackward)) {
+                meetingNode = currentBackward;
+                break;
+            }
 
-            for (const neighbor of neighbors) {
-                const tentativeGScore = (gScore.get(current) ?? Infinity) + neighbor.distance;
-                if (tentativeGScore < (gScore.get(neighbor.node) ?? Infinity)) {
-                    cameFrom.set(neighbor.node, current);
-                    gScore.set(neighbor.node, tentativeGScore);
-                    const fScore = tentativeGScore + this.distanceMeasurement(this.coords[neighbor.node], this.coords[endIdx]);
-                    openSet.insert(fScore, neighbor.node);
+            for (const neighbor of this.adjacencyList.get(currentBackward) || []) {
+                const tentativeG = (gScoreBackward.get(currentBackward) ?? Infinity) + neighbor.distance;
+                if (tentativeG < (gScoreBackward.get(neighbor.node) ?? Infinity)) {
+                    cameFromBackward.set(neighbor.node, currentBackward);
+                    gScoreBackward.set(neighbor.node, tentativeG);
+                    const fScore = tentativeG + this.distanceMeasurement(this.coords[neighbor.node], this.coords[startIndex]);
+                    openSetBackward.insert(fScore, neighbor.node);
                 }
             }
         }
 
-        return null;
+        if (meetingNode === null) {
+            return null;
+        }
+
+        // Reconstruct forward path
+        const pathForward: Position[] = [];
+        let node = meetingNode;
+        while (node !== undefined) {
+            pathForward.unshift(this.coords[node]);
+            node = cameFromForward.get(node)!;
+        }
+
+        // Reconstruct backward path (omit meeting node to avoid duplication)
+        const pathBackward: Position[] = [];
+        node = cameFromBackward.get(meetingNode)!;
+        while (node !== undefined) {
+            pathBackward.push(this.coords[node]);
+            node = cameFromBackward.get(node)!;
+        }
+
+        const fullPath = [...pathForward, ...pathBackward];
+
+        return {
+            type: "Feature",
+            geometry: { type: "LineString", coordinates: fullPath },
+            properties: {},
+        };
     }
 }