@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/routing/algorithms/AStarRouter.js

@@ -1,331 +0,0 @@
-"use strict";
-// AStarRouter.ts - A* Pathfinding Algorithm Implementation (Phase 4.2)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AStarRouter = exports.AStarHeuristic = void 0;
-/**
- * Heuristic functions for A* algorithm
- */
-var AStarHeuristic;
-(function (AStarHeuristic) {
-    /** Manhattan distance (L1 norm) - best for grid-based movement */
-    AStarHeuristic["MANHATTAN"] = "manhattan";
-    /** Euclidean distance (L2 norm) - best for free movement */
-    AStarHeuristic["EUCLIDEAN"] = "euclidean";
-    /** Diagonal distance (Chebyshev/L∞ norm) - best for 8-directional movement */
-    AStarHeuristic["DIAGONAL"] = "diagonal";
-})(AStarHeuristic || (exports.AStarHeuristic = AStarHeuristic = {}));
-/**
- * Min-heap priority queue for A* open set
- */
-class PriorityQueue {
-    constructor() {
-        this.heap = [];
-    }
-    push(node) {
-        this.heap.push(node);
-        this.bubbleUp(this.heap.length - 1);
-    }
-    pop() {
-        if (this.heap.length === 0)
-            return undefined;
-        if (this.heap.length === 1)
-            return this.heap.pop();
-        const result = this.heap[0];
-        this.heap[0] = this.heap.pop();
-        this.bubbleDown(0);
-        return result;
-    }
-    isEmpty() {
-        return this.heap.length === 0;
-    }
-    bubbleUp(index) {
-        while (index > 0) {
-            const parentIndex = Math.floor((index - 1) / 2);
-            if (this.heap[index].f >= this.heap[parentIndex].f)
-                break;
-            [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
-            index = parentIndex;
-        }
-    }
-    bubbleDown(index) {
-        while (true) {
-            let minIndex = index;
-            const leftChild = 2 * index + 1;
-            const rightChild = 2 * index + 2;
-            if (leftChild < this.heap.length && this.heap[leftChild].f < this.heap[minIndex].f) {
-                minIndex = leftChild;
-            }
-            if (rightChild < this.heap.length && this.heap[rightChild].f < this.heap[minIndex].f) {
-                minIndex = rightChild;
-            }
-            if (minIndex === index)
-                break;
-            [this.heap[index], this.heap[minIndex]] = [this.heap[minIndex], this.heap[index]];
-            index = minIndex;
-        }
-    }
-}
-/**
- * A* Pathfinding Router
- */
-class AStarRouter {
-    constructor(obstacleMap, options = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        this.obstacleMap = obstacleMap;
-        this.options = {
-            heuristic: (_a = options.heuristic) !== null && _a !== void 0 ? _a : AStarHeuristic.MANHATTAN,
-            allowDiagonal: (_b = options.allowDiagonal) !== null && _b !== void 0 ? _b : true,
-            gridSize: (_c = options.gridSize) !== null && _c !== void 0 ? _c : 5,
-            smoothing: (_d = options.smoothing) !== null && _d !== void 0 ? _d : true,
-            obstacleMargin: (_e = options.obstacleMargin) !== null && _e !== void 0 ? _e : 5,
-            maxIterations: (_f = options.maxIterations) !== null && _f !== void 0 ? _f : 10000,
-        };
-    }
-    /**
-     * Get algorithm name
-     */
-    getName() {
-        return 'a-star';
-    }
-    /**
-     * Find path from start to end using A* algorithm
-     */
-    route(start, end) {
-        // Early exit if start equals end
-        if (this.pointsEqual(start, end)) {
-            return [start];
-        }
-        // Snap points to grid
-        const gridStart = this.snapToGrid(start);
-        const gridEnd = this.snapToGrid(end);
-        // If points snap to the same grid cell, return direct path
-        if (this.pointsEqual(gridStart, gridEnd)) {
-            return [start, end];
-        }
-        // Run A* algorithm
-        const path = this.findPath(gridStart, gridEnd);
-        if (path.length === 0) {
-            return [];
-        }
-        // Replace first and last points with original coordinates
-        path[0] = start;
-        path[path.length - 1] = end;
-        // Apply path smoothing if enabled
-        if (this.options.smoothing) {
-            return this.smoothPath(path);
-        }
-        return path;
-    }
-    /**
-     * Core A* pathfinding algorithm
-     */
-    findPath(start, end) {
-        const openSet = new PriorityQueue();
-        const closedSet = new Set();
-        const gScores = new Map();
-        // Initialize start node
-        const startNode = {
-            point: start,
-            g: 0,
-            h: this.heuristic(start, end),
-            f: this.heuristic(start, end),
-            parent: null,
-        };
-        openSet.push(startNode);
-        gScores.set(this.pointKey(start), 0);
-        let iterations = 0;
-        while (!openSet.isEmpty() && iterations < this.options.maxIterations) {
-            iterations++;
-            const current = openSet.pop();
-            const currentKey = this.pointKey(current.point);
-            // Check if we reached the goal
-            if (this.pointsEqual(current.point, end)) {
-                return this.reconstructPath(current);
-            }
-            closedSet.add(currentKey);
-            // Explore neighbors
-            const neighbors = this.getNeighbors(current.point);
-            for (const neighbor of neighbors) {
-                const neighborKey = this.pointKey(neighbor);
-                // Skip if in closed set
-                if (closedSet.has(neighborKey))
-                    continue;
-                // Skip if collides with obstacle
-                if (this.collidesWithObstacle(neighbor))
-                    continue;
-                // Calculate tentative g score
-                const tentativeG = current.g + this.distance(current.point, neighbor);
-                // Check if this is a better path
-                const existingG = gScores.get(neighborKey);
-                if (existingG !== undefined && tentativeG >= existingG) {
-                    continue;
-                }
-                // This is the best path so far
-                gScores.set(neighborKey, tentativeG);
-                const neighborNode = {
-                    point: neighbor,
-                    g: tentativeG,
-                    h: this.heuristic(neighbor, end),
-                    f: tentativeG + this.heuristic(neighbor, end),
-                    parent: current,
-                };
-                openSet.push(neighborNode);
-            }
-        }
-        // No path found
-        return [];
-    }
-    /**
-     * Reconstruct path from end node
-     */
-    reconstructPath(node) {
-        const path = [];
-        let current = node;
-        while (current !== null) {
-            path.unshift(current.point);
-            current = current.parent;
-        }
-        return path;
-    }
-    /**
-     * Get neighbors of a point
-     */
-    getNeighbors(point) {
-        const { gridSize } = this.options;
-        const neighbors = [];
-        // 4-directional movement (orthogonal)
-        const orthogonal = [
-            { x: point.x + gridSize, y: point.y }, // Right
-            { x: point.x - gridSize, y: point.y }, // Left
-            { x: point.x, y: point.y + gridSize }, // Down
-            { x: point.x, y: point.y - gridSize }, // Up
-        ];
-        neighbors.push(...orthogonal);
-        // 8-directional movement (diagonal)
-        if (this.options.allowDiagonal) {
-            const diagonal = [
-                { x: point.x + gridSize, y: point.y + gridSize }, // Down-right
-                { x: point.x - gridSize, y: point.y + gridSize }, // Down-left
-                { x: point.x + gridSize, y: point.y - gridSize }, // Up-right
-                { x: point.x - gridSize, y: point.y - gridSize }, // Up-left
-            ];
-            neighbors.push(...diagonal);
-        }
-        return neighbors;
-    }
-    /**
-     * Calculate heuristic distance
-     */
-    heuristic(a, b) {
-        const dx = Math.abs(b.x - a.x);
-        const dy = Math.abs(b.y - a.y);
-        switch (this.options.heuristic) {
-            case AStarHeuristic.MANHATTAN:
-                return dx + dy;
-            case AStarHeuristic.EUCLIDEAN:
-                return Math.sqrt(dx * dx + dy * dy);
-            case AStarHeuristic.DIAGONAL:
-                // Chebyshev distance
-                return Math.max(dx, dy);
-            default:
-                return dx + dy;
-        }
-    }
-    /**
-     * Calculate actual distance between two points
-     */
-    distance(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-    /**
-     * Check if point collides with obstacle (including margin)
-     */
-    collidesWithObstacle(point) {
-        const margin = this.options.obstacleMargin;
-        // Query obstacles in region around point
-        const obstacles = this.obstacleMap.queryRegion({
-            x: point.x - margin,
-            y: point.y - margin,
-            width: margin * 2,
-            height: margin * 2,
-        });
-        for (const obstacle of obstacles) {
-            // Check if point is within obstacle bounds + margin
-            if (point.x >= obstacle.x - margin &&
-                point.x <= obstacle.x + obstacle.width + margin &&
-                point.y >= obstacle.y - margin &&
-                point.y <= obstacle.y + obstacle.height + margin) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Smooth path by removing unnecessary waypoints
-     */
-    smoothPath(path) {
-        if (path.length <= 2)
-            return path;
-        const smoothed = [path[0]];
-        let currentIndex = 0;
-        while (currentIndex < path.length - 1) {
-            // Try to find the farthest point we can reach directly
-            let farthestIndex = currentIndex + 1;
-            for (let i = path.length - 1; i > currentIndex + 1; i--) {
-                if (this.hasLineOfSight(path[currentIndex], path[i])) {
-                    farthestIndex = i;
-                    break;
-                }
-            }
-            smoothed.push(path[farthestIndex]);
-            currentIndex = farthestIndex;
-        }
-        return smoothed;
-    }
-    /**
-     * Check if there's a clear line of sight between two points
-     */
-    hasLineOfSight(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        const steps = Math.ceil(distance / this.options.gridSize);
-        for (let i = 1; i < steps; i++) {
-            const t = i / steps;
-            const point = {
-                x: a.x + dx * t,
-                y: a.y + dy * t,
-            };
-            if (this.collidesWithObstacle(point)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Snap point to grid
-     */
-    snapToGrid(point) {
-        const { gridSize } = this.options;
-        return {
-            x: Math.round(point.x / gridSize) * gridSize,
-            y: Math.round(point.y / gridSize) * gridSize,
-        };
-    }
-    /**
-     * Create unique key for point
-     */
-    pointKey(point) {
-        return `${point.x},${point.y}`;
-    }
-    /**
-     * Check if two points are equal
-     */
-    pointsEqual(a, b) {
-        return a.x === b.x && a.y === b.y;
-    }
-}
-exports.AStarRouter = AStarRouter;
-//# sourceMappingURL=AStarRouter.js.map

package/src/libs/engine/src/routing/algorithms/DijkstraRouter.d.ts

@@ -1,74 +0,0 @@
-import type { Point } from '../../types';
-import type { ObstacleMap } from '../ObstacleMap';
-/**
- * Configuration options for Dijkstra router
- */
-export interface DijkstraOptions {
-    /** Allow diagonal movement (default: true) */
-    allowDiagonal?: boolean;
-    /** Grid size for discretization (default: 5) */
-    gridSize?: number;
-    /** Enable path smoothing (default: true) */
-    smoothing?: boolean;
-    /** Margin around obstacles (default: 5) */
-    obstacleMargin?: number;
-    /** Maximum iterations before giving up (default: 10000) */
-    maxIterations?: number;
-}
-/**
- * Dijkstra's Shortest Path Router
- * Guarantees shortest path but may be slower than A* for long distances
- */
-export declare class DijkstraRouter {
-    private obstacleMap;
-    private options;
-    constructor(obstacleMap: ObstacleMap, options?: DijkstraOptions);
-    /**
-     * Get algorithm name
-     */
-    getName(): string;
-    /**
-     * Find shortest path from start to end using Dijkstra's algorithm
-     */
-    route(start: Point, end: Point): Point[];
-    /**
-     * Core Dijkstra's shortest path algorithm
-     */
-    private findPath;
-    /**
-     * Reconstruct path from end node
-     */
-    private reconstructPath;
-    /**
-     * Get neighbors of a point
-     */
-    private getNeighbors;
-    /**
-     * Calculate distance between two points
-     */
-    private distance;
-    /**
-     * Check if point collides with obstacle (including margin)
-     */
-    private collidesWithObstacle;
-    /**
-     * Smooth path by removing unnecessary waypoints
-     */
-    private smoothPath;
-    /**
-     * Check if there's a clear line of sight between two points
-     */
-    private hasLineOfSight;
-    /**
-     * Snap point to grid
-     */
-    private snapToGrid;
-    /**
-     * Create unique key for point
-     */
-    private pointKey;
-    /**
-     * Check if two points are equal
-     */
-    private pointsEqual;
-}

package/src/libs/engine/src/routing/algorithms/DijkstraRouter.js

@@ -1,297 +0,0 @@
-"use strict";
-// DijkstraRouter.ts - Dijkstra's Shortest Path Algorithm (Phase 4.3)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DijkstraRouter = void 0;
-/**
- * Min-heap priority queue for Dijkstra
- */
-class PriorityQueue {
-    constructor() {
-        this.heap = [];
-    }
-    push(node) {
-        this.heap.push(node);
-        this.bubbleUp(this.heap.length - 1);
-    }
-    pop() {
-        if (this.heap.length === 0)
-            return undefined;
-        if (this.heap.length === 1)
-            return this.heap.pop();
-        const result = this.heap[0];
-        this.heap[0] = this.heap.pop();
-        this.bubbleDown(0);
-        return result;
-    }
-    isEmpty() {
-        return this.heap.length === 0;
-    }
-    bubbleUp(index) {
-        while (index > 0) {
-            const parentIndex = Math.floor((index - 1) / 2);
-            if (this.heap[index].distance >= this.heap[parentIndex].distance)
-                break;
-            [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
-            index = parentIndex;
-        }
-    }
-    bubbleDown(index) {
-        while (true) {
-            let minIndex = index;
-            const leftChild = 2 * index + 1;
-            const rightChild = 2 * index + 2;
-            if (leftChild < this.heap.length && this.heap[leftChild].distance < this.heap[minIndex].distance) {
-                minIndex = leftChild;
-            }
-            if (rightChild < this.heap.length && this.heap[rightChild].distance < this.heap[minIndex].distance) {
-                minIndex = rightChild;
-            }
-            if (minIndex === index)
-                break;
-            [this.heap[index], this.heap[minIndex]] = [this.heap[minIndex], this.heap[index]];
-            index = minIndex;
-        }
-    }
-}
-/**
- * Dijkstra's Shortest Path Router
- * Guarantees shortest path but may be slower than A* for long distances
- */
-class DijkstraRouter {
-    constructor(obstacleMap, options = {}) {
-        var _a, _b, _c, _d, _e;
-        this.obstacleMap = obstacleMap;
-        this.options = {
-            allowDiagonal: (_a = options.allowDiagonal) !== null && _a !== void 0 ? _a : true,
-            gridSize: (_b = options.gridSize) !== null && _b !== void 0 ? _b : 5,
-            smoothing: (_c = options.smoothing) !== null && _c !== void 0 ? _c : true,
-            obstacleMargin: (_d = options.obstacleMargin) !== null && _d !== void 0 ? _d : 5,
-            maxIterations: (_e = options.maxIterations) !== null && _e !== void 0 ? _e : 10000,
-        };
-    }
-    /**
-     * Get algorithm name
-     */
-    getName() {
-        return 'dijkstra';
-    }
-    /**
-     * Find shortest path from start to end using Dijkstra's algorithm
-     */
-    route(start, end) {
-        // Early exit if start equals end
-        if (this.pointsEqual(start, end)) {
-            return [start];
-        }
-        // Snap points to grid
-        const gridStart = this.snapToGrid(start);
-        const gridEnd = this.snapToGrid(end);
-        // If points snap to the same grid cell, return direct path
-        if (this.pointsEqual(gridStart, gridEnd)) {
-            return [start, end];
-        }
-        // Run Dijkstra's algorithm
-        const path = this.findPath(gridStart, gridEnd);
-        if (path.length === 0) {
-            return [];
-        }
-        // Replace first and last points with original coordinates
-        path[0] = start;
-        path[path.length - 1] = end;
-        // Apply path smoothing if enabled
-        if (this.options.smoothing) {
-            return this.smoothPath(path);
-        }
-        return path;
-    }
-    /**
-     * Core Dijkstra's shortest path algorithm
-     */
-    findPath(start, end) {
-        const openSet = new PriorityQueue();
-        const closedSet = new Set();
-        const distances = new Map();
-        // Initialize start node
-        const startNode = {
-            point: start,
-            distance: 0,
-            parent: null,
-        };
-        openSet.push(startNode);
-        distances.set(this.pointKey(start), 0);
-        let iterations = 0;
-        while (!openSet.isEmpty() && iterations < this.options.maxIterations) {
-            iterations++;
-            const current = openSet.pop();
-            const currentKey = this.pointKey(current.point);
-            // Check if we reached the goal
-            if (this.pointsEqual(current.point, end)) {
-                return this.reconstructPath(current);
-            }
-            closedSet.add(currentKey);
-            // Explore neighbors
-            const neighbors = this.getNeighbors(current.point);
-            for (const neighbor of neighbors) {
-                const neighborKey = this.pointKey(neighbor);
-                // Skip if in closed set
-                if (closedSet.has(neighborKey))
-                    continue;
-                // Skip if collides with obstacle
-                if (this.collidesWithObstacle(neighbor))
-                    continue;
-                // Calculate tentative distance
-                const tentativeDistance = current.distance + this.distance(current.point, neighbor);
-                // Check if this is a better path
-                const existingDistance = distances.get(neighborKey);
-                if (existingDistance !== undefined && tentativeDistance >= existingDistance) {
-                    continue;
-                }
-                // This is the best path so far
-                distances.set(neighborKey, tentativeDistance);
-                const neighborNode = {
-                    point: neighbor,
-                    distance: tentativeDistance,
-                    parent: current,
-                };
-                openSet.push(neighborNode);
-            }
-        }
-        // No path found
-        return [];
-    }
-    /**
-     * Reconstruct path from end node
-     */
-    reconstructPath(node) {
-        const path = [];
-        let current = node;
-        while (current !== null) {
-            path.unshift(current.point);
-            current = current.parent;
-        }
-        return path;
-    }
-    /**
-     * Get neighbors of a point
-     */
-    getNeighbors(point) {
-        const { gridSize } = this.options;
-        const neighbors = [];
-        // 4-directional movement (orthogonal)
-        const orthogonal = [
-            { x: point.x + gridSize, y: point.y }, // Right
-            { x: point.x - gridSize, y: point.y }, // Left
-            { x: point.x, y: point.y + gridSize }, // Down
-            { x: point.x, y: point.y - gridSize }, // Up
-        ];
-        neighbors.push(...orthogonal);
-        // 8-directional movement (diagonal)
-        if (this.options.allowDiagonal) {
-            const diagonal = [
-                { x: point.x + gridSize, y: point.y + gridSize }, // Down-right
-                { x: point.x - gridSize, y: point.y + gridSize }, // Down-left
-                { x: point.x + gridSize, y: point.y - gridSize }, // Up-right
-                { x: point.x - gridSize, y: point.y - gridSize }, // Up-left
-            ];
-            neighbors.push(...diagonal);
-        }
-        return neighbors;
-    }
-    /**
-     * Calculate distance between two points
-     */
-    distance(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-    /**
-     * Check if point collides with obstacle (including margin)
-     */
-    collidesWithObstacle(point) {
-        const margin = this.options.obstacleMargin;
-        // Query obstacles in region around point
-        const obstacles = this.obstacleMap.queryRegion({
-            x: point.x - margin,
-            y: point.y - margin,
-            width: margin * 2,
-            height: margin * 2,
-        });
-        for (const obstacle of obstacles) {
-            // Check if point is within obstacle bounds + margin
-            if (point.x >= obstacle.x - margin &&
-                point.x <= obstacle.x + obstacle.width + margin &&
-                point.y >= obstacle.y - margin &&
-                point.y <= obstacle.y + obstacle.height + margin) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Smooth path by removing unnecessary waypoints
-     */
-    smoothPath(path) {
-        if (path.length <= 2)
-            return path;
-        const smoothed = [path[0]];
-        let currentIndex = 0;
-        while (currentIndex < path.length - 1) {
-            // Try to find the farthest point we can reach directly
-            let farthestIndex = currentIndex + 1;
-            for (let i = path.length - 1; i > currentIndex + 1; i--) {
-                if (this.hasLineOfSight(path[currentIndex], path[i])) {
-                    farthestIndex = i;
-                    break;
-                }
-            }
-            smoothed.push(path[farthestIndex]);
-            currentIndex = farthestIndex;
-        }
-        return smoothed;
-    }
-    /**
-     * Check if there's a clear line of sight between two points
-     */
-    hasLineOfSight(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        const steps = Math.ceil(distance / this.options.gridSize);
-        for (let i = 1; i < steps; i++) {
-            const t = i / steps;
-            const point = {
-                x: a.x + dx * t,
-                y: a.y + dy * t,
-            };
-            if (this.collidesWithObstacle(point)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Snap point to grid
-     */
-    snapToGrid(point) {
-        const { gridSize } = this.options;
-        return {
-            x: Math.round(point.x / gridSize) * gridSize,
-            y: Math.round(point.y / gridSize) * gridSize,
-        };
-    }
-    /**
-     * Create unique key for point
-     */
-    pointKey(point) {
-        return `${point.x},${point.y}`;
-    }
-    /**
-     * Check if two points are equal
-     */
-    pointsEqual(a, b) {
-        return a.x === b.x && a.y === b.y;
-    }
-}
-exports.DijkstraRouter = DijkstraRouter;
-//# sourceMappingURL=DijkstraRouter.js.map