@osmix/router 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @osmix/router
 
+## 0.0.5
+
+### Patch Changes
+
+- 68d6bd8: Fix publishing for packages.
+- Updated dependencies [68d6bd8]
+  - @osmix/core@0.1.2
+  - @osmix/shared@0.0.7
+
 ## 0.0.4
 
 ### Patch Changes

package/dist/algorithms/bidirectional.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Bidirectional breadth-first search algorithm.
+ *
+ * Searches from both start and end simultaneously, terminating when the
+ * frontiers meet. Very fast for finding any path, but does not guarantee
+ * the shortest path. Use Dijkstra or A* when optimality is required.
+ *
+ * @module
+ */
+import type { RoutingAlgorithmFn } from "../types";
+/**
+ * Bidirectional BFS - fast path finding from both ends.
+ *
+ * Uses breadth-first search from both start and end, terminating when
+ * the frontiers meet. Very fast for finding any path, though not always
+ * the optimal shortest path. Use Dijkstra or A* if optimality is required.
+ */
+export declare const bidirectional: RoutingAlgorithmFn;
+//# sourceMappingURL=bidirectional.d.ts.map

package/dist/algorithms/bidirectional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidirectional.d.ts","sourceRoot":"","sources":["../../src/algorithms/bidirectional.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE/D;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,kBA+H3B,CAAA"}

package/dist/algorithms/bidirectional.js

@@ -0,0 +1,128 @@
+/**
+ * Bidirectional breadth-first search algorithm.
+ *
+ * Searches from both start and end simultaneously, terminating when the
+ * frontiers meet. Very fast for finding any path, but does not guarantee
+ * the shortest path. Use Dijkstra or A* when optimality is required.
+ *
+ * @module
+ */
+/**
+ * Bidirectional BFS - fast path finding from both ends.
+ *
+ * Uses breadth-first search from both start and end, terminating when
+ * the frontiers meet. Very fast for finding any path, though not always
+ * the optimal shortest path. Use Dijkstra or A* if optimality is required.
+ */
+export const bidirectional = (graph, start, end, getWeight) => {
+    if (start === end)
+        return [{ nodeIndex: start, cost: 0 }];
+    // Forward search state
+    const fDist = new Map();
+    const fPrev = new Map();
+    const fQueue = [start];
+    // Backward search state
+    const bDist = new Map();
+    const bPrev = new Map();
+    const bQueue = [end];
+    fDist.set(start, 0);
+    bDist.set(end, 0);
+    let meetNode = null;
+    while (fQueue.length > 0 && bQueue.length > 0) {
+        // Expand forward
+        if (fQueue.length > 0) {
+            const current = fQueue.shift();
+            const currentD = fDist.get(current);
+            // Check if backward search reached this node
+            if (bDist.has(current)) {
+                meetNode = current;
+                break;
+            }
+            for (const edge of graph(current)) {
+                const neighbor = edge.targetNodeIndex;
+                if (fDist.has(neighbor))
+                    continue;
+                const newD = currentD + getWeight(edge);
+                fDist.set(neighbor, newD);
+                fPrev.set(neighbor, {
+                    nodeIndex: neighbor,
+                    wayIndex: edge.wayIndex,
+                    previousNodeIndex: current,
+                    cost: newD,
+                });
+                fQueue.push(neighbor);
+                if (bDist.has(neighbor)) {
+                    meetNode = neighbor;
+                    break;
+                }
+            }
+            if (meetNode !== null)
+                break;
+        }
+        // Expand backward
+        if (bQueue.length > 0) {
+            const current = bQueue.shift();
+            const currentD = bDist.get(current);
+            // Check if forward search reached this node
+            if (fDist.has(current)) {
+                meetNode = current;
+                break;
+            }
+            for (const edge of graph(current)) {
+                const neighbor = edge.targetNodeIndex;
+                if (bDist.has(neighbor))
+                    continue;
+                const newD = currentD + getWeight(edge);
+                bDist.set(neighbor, newD);
+                bPrev.set(neighbor, {
+                    nodeIndex: neighbor,
+                    wayIndex: edge.wayIndex,
+                    previousNodeIndex: current,
+                    cost: newD,
+                });
+                bQueue.push(neighbor);
+                if (fDist.has(neighbor)) {
+                    meetNode = neighbor;
+                    break;
+                }
+            }
+            if (meetNode !== null)
+                break;
+        }
+    }
+    if (meetNode === null)
+        return null;
+    // Build forward path: start -> meet
+    const forward = [];
+    let curr = meetNode;
+    while (curr !== undefined && curr !== start) {
+        const seg = fPrev.get(curr);
+        if (!seg)
+            break;
+        forward.unshift(seg);
+        curr = seg.previousNodeIndex;
+    }
+    forward.unshift({ nodeIndex: start, cost: 0 });
+    // Build backward path: meet -> end (reverse direction)
+    // bDist represents distance FROM end TO node, so it decreases as we approach end.
+    // Correct cost = forward cost to meet + (backward dist at meet - backward dist at curr)
+    const meetForwardCost = fDist.get(meetNode);
+    const meetBackwardCost = bDist.get(meetNode);
+    curr = meetNode;
+    while (curr !== undefined && curr !== end) {
+        const seg = bPrev.get(curr);
+        if (!seg)
+            break;
+        curr = seg.previousNodeIndex;
+        if (curr !== undefined) {
+            forward.push({
+                nodeIndex: curr,
+                wayIndex: seg.wayIndex,
+                previousNodeIndex: seg.nodeIndex,
+                cost: meetForwardCost + meetBackwardCost - (bDist.get(curr) ?? 0),
+            });
+        }
+    }
+    return forward;
+};
+//# sourceMappingURL=bidirectional.js.map

package/dist/algorithms/bidirectional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidirectional.js","sourceRoot":"","sources":["../../src/algorithms/bidirectional.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Routing algorithm implementations.
+ *
+ * Provides three algorithms:
+ * - `dijkstra`: Optimal shortest path, explores all directions equally.
+ * - `astar`: Optimal with heuristic guidance, faster for point-to-point.
+ * - `bidirectional`: Fast BFS from both ends, finds *a* path (not always optimal).
+ *
+ * @module
+ */
+import type { RoutingAlgorithm, RoutingAlgorithmFn } from "../types";
+import { bidirectional } from "./bidirectional";
+import { astar, dijkstra } from "./shortest-path";
+export { astar, bidirectional, dijkstra };
+export type { RoutingAlgorithmFn };
+export declare const routingAlgorithms: Record<RoutingAlgorithm, RoutingAlgorithmFn>;
+//# sourceMappingURL=index.d.ts.map

package/dist/algorithms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAA;AACzC,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAElC,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,gBAAgB,EAAE,kBAAkB,CAI1E,CAAA"}

package/dist/algorithms/index.js

@@ -0,0 +1,19 @@
+/**
+ * Routing algorithm implementations.
+ *
+ * Provides three algorithms:
+ * - `dijkstra`: Optimal shortest path, explores all directions equally.
+ * - `astar`: Optimal with heuristic guidance, faster for point-to-point.
+ * - `bidirectional`: Fast BFS from both ends, finds *a* path (not always optimal).
+ *
+ * @module
+ */
+import { bidirectional } from "./bidirectional";
+import { astar, dijkstra } from "./shortest-path";
+export { astar, bidirectional, dijkstra };
+export const routingAlgorithms = {
+    dijkstra,
+    astar,
+    bidirectional,
+};
+//# sourceMappingURL=index.js.map

package/dist/algorithms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAA;AAGzC,MAAM,CAAC,MAAM,iBAAiB,GAAiD;IAC9E,QAAQ;IACR,KAAK;IACL,aAAa;CACb,CAAA"}

package/dist/algorithms/shortest-path.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shortest path algorithms (Dijkstra and A*).
+ *
+ * Both algorithms guarantee optimal paths. A* uses a heuristic to guide
+ * the search toward the destination, making it faster for most queries.
+ *
+ * @module
+ */
+import type { RoutingAlgorithmFn } from "../types";
+/**
+ * Dijkstra's algorithm - optimal shortest path without heuristic guidance.
+ * Explores nodes in order of increasing distance from start.
+ */
+export declare const dijkstra: RoutingAlgorithmFn;
+/**
+ * A* algorithm - uses heuristic to guide search toward destination.
+ * Typically faster than Dijkstra for point-to-point queries.
+ *
+ * The heuristic is adapted based on the metric:
+ * - distance: haversine distance in meters
+ * - time: haversine distance / max speed (lower bound on travel time in seconds)
+ */
+export declare const astar: RoutingAlgorithmFn;
+//# sourceMappingURL=shortest-path.d.ts.map

package/dist/algorithms/shortest-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortest-path.d.ts","sourceRoot":"","sources":["../../src/algorithms/shortest-path.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAA0B,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAkG1E;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,kBAEtB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE,kBAuBnB,CAAA"}

package/dist/algorithms/shortest-path.js

@@ -0,0 +1,115 @@
+/**
+ * Shortest path algorithms (Dijkstra and A*).
+ *
+ * Both algorithms guarantee optimal paths. A* uses a heuristic to guide
+ * the search toward the destination, making it faster for most queries.
+ *
+ * @module
+ */
+import { haversineDistance } from "@osmix/shared/haversine-distance";
+import { BinaryHeap } from "../binary-heap";
+/**
+ * Maximum speed (m/s) for time-based heuristic.
+ * Uses 130 km/h (~36.1 m/s) to ensure admissibility on all road types.
+ */
+const MAX_SPEED_MS = (130 * 1000) / 3600;
+/**
+ * A* shortest path algorithm with configurable heuristic.
+ *
+ * When heuristic returns 0 for all nodes, this is equivalent to Dijkstra's algorithm.
+ * With an admissible heuristic (never overestimates), guarantees optimal paths.
+ */
+function shortestPath(graph, start, end, getWeight, heuristic) {
+    // Same node - trivial path
+    if (start === end)
+        return [{ nodeIndex: start, cost: 0 }];
+    const gScore = new Map(); // Best known cost to reach node
+    const previous = new Map(); // How we reached each node
+    const closed = new Set(); // Fully processed nodes
+    const heap = new BinaryHeap();
+    gScore.set(start, 0);
+    heap.push(start, heuristic(start));
+    while (heap.size > 0) {
+        const current = heap.pop();
+        // Reached destination
+        if (current === end)
+            return reconstructPath(previous, start, end);
+        // Already seen this node
+        if (closed.has(current))
+            continue;
+        closed.add(current);
+        const currentG = gScore.get(current);
+        for (const edge of graph(current)) {
+            const neighbor = edge.targetNodeIndex;
+            if (closed.has(neighbor))
+                continue;
+            const tentativeG = currentG + getWeight(edge);
+            const existingG = gScore.get(neighbor);
+            if (existingG === undefined || tentativeG < existingG) {
+                gScore.set(neighbor, tentativeG);
+                previous.set(neighbor, {
+                    nodeIndex: neighbor,
+                    wayIndex: edge.wayIndex,
+                    previousNodeIndex: current,
+                    cost: tentativeG,
+                });
+                const f = tentativeG + heuristic(neighbor);
+                heap.push(neighbor, f);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Reconstruct path from predecessor map.
+ */
+function reconstructPath(previous, start, end) {
+    const path = [];
+    let current = end;
+    while (current !== undefined) {
+        const segment = previous.get(current);
+        if (!segment) {
+            path.unshift({ nodeIndex: current, cost: 0 });
+            break;
+        }
+        path.unshift(segment);
+        current = segment.previousNodeIndex;
+    }
+    if (path.length === 0 || path[0]?.nodeIndex !== start) {
+        path.unshift({ nodeIndex: start, cost: 0 });
+    }
+    return path;
+}
+/**
+ * Dijkstra's algorithm - optimal shortest path without heuristic guidance.
+ * Explores nodes in order of increasing distance from start.
+ */
+export const dijkstra = (graph, start, end, getWeight) => {
+    return shortestPath(graph, start, end, getWeight, () => 0);
+};
+/**
+ * A* algorithm - uses heuristic to guide search toward destination.
+ * Typically faster than Dijkstra for point-to-point queries.
+ *
+ * The heuristic is adapted based on the metric:
+ * - distance: haversine distance in meters
+ * - time: haversine distance / max speed (lower bound on travel time in seconds)
+ */
+export const astar = (graph, start, end, getWeight, getCoord, metric) => {
+    if (!getCoord)
+        return null;
+    const endCoord = getCoord(end);
+    if (!endCoord)
+        return null;
+    // Haversine heuristic scaled by metric
+    // For time: divide by max speed to get admissible time estimate
+    const heuristic = (nodeIndex) => {
+        const coord = getCoord(nodeIndex);
+        if (!coord)
+            return 0;
+        const distance = haversineDistance(endCoord, coord);
+        return metric === "time" ? distance / MAX_SPEED_MS : distance;
+    };
+    return shortestPath(graph, start, end, getWeight, heuristic);
+};
+//# sourceMappingURL=shortest-path.js.map

package/dist/algorithms/shortest-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortest-path.js","sourceRoot":"","sources":["../../src/algorithms/shortest-path.ts"],"names":[],"mappings":"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"}

package/dist/binary-heap.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Priority queue implementation for pathfinding algorithms.
+ * @module
+ */
+/**
+ * Min-heap priority queue optimized for pathfinding.
+ *
+ * Uses a binary heap stored in a flat array for cache-friendly access.
+ * Tracks item positions to support O(log n) priority updates (decrease-key).
+ *
+ * Operations:
+ * - `push(item, priority)`: O(log n) - adds or updates item priority.
+ * - `pop()`: O(log n) - removes and returns minimum priority item.
+ * - `has(item)`: O(1) - checks if item is in heap.
+ */
+export declare class BinaryHeap {
+    private heap;
+    private priorities;
+    private positions;
+    get size(): number;
+    /**
+     * Add an item with given priority. If item exists, updates priority if lower.
+     */
+    push(item: number, priority: number): void;
+    /**
+     * Remove and return the minimum-priority item.
+     */
+    pop(): number | undefined;
+    /**
+     * Check if item is in the heap.
+     */
+    has(item: number): boolean;
+    /**
+     * Clear all items.
+     */
+    clear(): void;
+    private bubbleUp;
+    private bubbleDown;
+}
+//# sourceMappingURL=binary-heap.d.ts.map

package/dist/binary-heap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-heap.d.ts","sourceRoot":"","sources":["../src/binary-heap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACtB,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,SAAS,CAAiC;IAElD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAiB1C;;OAEG;IACH,GAAG,IAAI,MAAM,GAAG,SAAS;IAmBzB;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,QAAQ;IAwBhB,OAAO,CAAC,UAAU;CAuClB"}

package/dist/binary-heap.js

@@ -0,0 +1,122 @@
+/**
+ * Priority queue implementation for pathfinding algorithms.
+ * @module
+ */
+/**
+ * Min-heap priority queue optimized for pathfinding.
+ *
+ * Uses a binary heap stored in a flat array for cache-friendly access.
+ * Tracks item positions to support O(log n) priority updates (decrease-key).
+ *
+ * Operations:
+ * - `push(item, priority)`: O(log n) - adds or updates item priority.
+ * - `pop()`: O(log n) - removes and returns minimum priority item.
+ * - `has(item)`: O(1) - checks if item is in heap.
+ */
+export class BinaryHeap {
+    heap = [];
+    priorities = [];
+    positions = new Map();
+    get size() {
+        return this.heap.length;
+    }
+    /**
+     * Add an item with given priority. If item exists, updates priority if lower.
+     */
+    push(item, priority) {
+        const existing = this.positions.get(item);
+        if (existing !== undefined) {
+            if (priority < this.priorities[existing]) {
+                this.priorities[existing] = priority;
+                this.bubbleUp(existing);
+            }
+            return;
+        }
+        const index = this.heap.length;
+        this.heap.push(item);
+        this.priorities.push(priority);
+        this.positions.set(item, index);
+        this.bubbleUp(index);
+    }
+    /**
+     * Remove and return the minimum-priority item.
+     */
+    pop() {
+        if (this.heap.length === 0)
+            return undefined;
+        const min = this.heap[0];
+        this.positions.delete(min);
+        const last = this.heap.pop();
+        const lastPriority = this.priorities.pop();
+        if (this.heap.length > 0) {
+            this.heap[0] = last;
+            this.priorities[0] = lastPriority;
+            this.positions.set(last, 0);
+            this.bubbleDown(0);
+        }
+        return min;
+    }
+    /**
+     * Check if item is in the heap.
+     */
+    has(item) {
+        return this.positions.has(item);
+    }
+    /**
+     * Clear all items.
+     */
+    clear() {
+        this.heap.length = 0;
+        this.priorities.length = 0;
+        this.positions.clear();
+    }
+    bubbleUp(startIndex) {
+        const item = this.heap[startIndex];
+        const priority = this.priorities[startIndex];
+        let index = startIndex;
+        while (index > 0) {
+            const parentIndex = (index - 1) >> 1;
+            const parentPriority = this.priorities[parentIndex];
+            if (priority >= parentPriority)
+                break;
+            // Swap with parent
+            this.heap[index] = this.heap[parentIndex];
+            this.priorities[index] = parentPriority;
+            this.positions.set(this.heap[index], index);
+            index = parentIndex;
+        }
+        this.heap[index] = item;
+        this.priorities[index] = priority;
+        this.positions.set(item, index);
+    }
+    bubbleDown(startIndex) {
+        const length = this.heap.length;
+        const item = this.heap[startIndex];
+        const priority = this.priorities[startIndex];
+        let index = startIndex;
+        while (true) {
+            const leftIndex = (index << 1) + 1;
+            const rightIndex = leftIndex + 1;
+            let smallest = index;
+            if (leftIndex < length &&
+                this.priorities[leftIndex] < this.priorities[smallest]) {
+                smallest = leftIndex;
+            }
+            if (rightIndex < length &&
+                this.priorities[rightIndex] < this.priorities[smallest]) {
+                smallest = rightIndex;
+            }
+            if (smallest === index)
+                break;
+            // Swap with smallest child
+            this.heap[index] = this.heap[smallest];
+            this.priorities[index] = this.priorities[smallest];
+            this.positions.set(this.heap[index], index);
+            index = smallest;
+        }
+        this.heap[index] = item;
+        this.priorities[index] = priority;
+        this.positions.set(item, index);
+    }
+}
+//# sourceMappingURL=binary-heap.js.map

package/dist/binary-heap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-heap.js","sourceRoot":"","sources":["../src/binary-heap.ts"],"names":[],"mappings":"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"}