@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,8 +0,0 @@
-import type { IRouter, RouteRequest, RoutedPath } from '../types';
-/**
- * StraightRouter creates a direct straight line from start to end
- */
-export declare class StraightRouter implements IRouter {
-    getName(): string;
-    route(request: RouteRequest): RoutedPath | null;
-}

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

@@ -1,53 +0,0 @@
-"use strict";
-// StraightRouter - Simple straight-line routing
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StraightRouter = void 0;
-/**
- * StraightRouter creates a direct straight line from start to end
- */
-class StraightRouter {
-    getName() {
-        return 'straight';
-    }
-    route(request) {
-        const { start, end } = request;
-        // Handle same start and end point
-        if (start.x === end.x && start.y === end.y) {
-            return {
-                points: [{ x: start.x, y: start.y }],
-                totalLength: 0,
-                bendCount: 0,
-                cost: 0,
-                segments: [],
-            };
-        }
-        // Create straight line path
-        const points = [
-            { x: start.x, y: start.y },
-            { x: end.x, y: end.y },
-        ];
-        // Calculate distance
-        const dx = end.x - start.x;
-        const dy = end.y - start.y;
-        const length = Math.sqrt(dx * dx + dy * dy);
-        // Calculate angle in degrees
-        const angleRad = Math.atan2(dy, dx);
-        const angleDeg = (angleRad * 180) / Math.PI;
-        return {
-            points,
-            totalLength: length,
-            bendCount: 0,
-            cost: length,
-            segments: [
-                {
-                    start: points[0],
-                    end: points[1],
-                    length,
-                    angle: angleDeg,
-                },
-            ],
-        };
-    }
-}
-exports.StraightRouter = StraightRouter;
-//# sourceMappingURL=StraightRouter.js.map

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

@@ -1,59 +0,0 @@
-import type { Point } from '../../types';
-import type { ObstacleMap } from '../ObstacleMap';
-/**
- * Configuration options for Visibility Graph router
- */
-export interface VisibilityGraphOptions {
-    /** Margin around obstacles (default: 1) - corners placed outside obstacle bounds */
-    obstacleMargin?: number;
-}
-/**
- * Visibility Graph Router
- * Optimal for environments with few obstacles and open spaces
- * Creates graph of obstacle corners and finds shortest geometric path
- */
-export declare class VisibilityGraphRouter {
-    private obstacleMap;
-    private options;
-    constructor(obstacleMap: ObstacleMap, options?: VisibilityGraphOptions);
-    /**
-     * Get algorithm name
-     */
-    getName(): string;
-    /**
-     * Find shortest geometric path using visibility graph
-     */
-    route(start: Point, end: Point): Point[];
-    /**
-     * Extract all vertices (corners) from obstacles plus start/end
-     */
-    private extractVertices;
-    /**
-     * Build visibility graph - connect vertices with line-of-sight
-     */
-    private buildVisibilityGraph;
-    /**
-     * Find shortest path through visibility graph using Dijkstra
-     */
-    private findShortestPath;
-    /**
-     * Check if two points have line-of-sight (no obstacles blocking)
-     */
-    private hasLineOfSight;
-    /**
-     * Check if line segment intersects with rectangle
-     */
-    private lineIntersectsRectangle;
-    /**
-     * Check if two line segments intersect
-     */
-    private lineSegmentsIntersect;
-    /**
-     * Calculate Euclidean distance between two points
-     */
-    private distance;
-    /**
-     * Check if two points are equal
-     */
-    private pointsEqual;
-}

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

@@ -1,258 +0,0 @@
-"use strict";
-// VisibilityGraphRouter.ts - Visibility Graph Algorithm (Phase 4.3)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisibilityGraphRouter = void 0;
-/**
- * Min-heap priority queue
- */
-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;
-        }
-    }
-}
-/**
- * Visibility Graph Router
- * Optimal for environments with few obstacles and open spaces
- * Creates graph of obstacle corners and finds shortest geometric path
- */
-class VisibilityGraphRouter {
-    constructor(obstacleMap, options = {}) {
-        var _a;
-        this.obstacleMap = obstacleMap;
-        this.options = {
-            obstacleMargin: (_a = options.obstacleMargin) !== null && _a !== void 0 ? _a : 1,
-        };
-    }
-    /**
-     * Get algorithm name
-     */
-    getName() {
-        return 'visibility-graph';
-    }
-    /**
-     * Find shortest geometric path using visibility graph
-     */
-    route(start, end) {
-        // Early exit if start equals end
-        if (this.pointsEqual(start, end)) {
-            return [start];
-        }
-        // Check for direct line of sight
-        if (this.hasLineOfSight(start, end)) {
-            return [start, end];
-        }
-        // Get all obstacles from map
-        const obstacles = this.obstacleMap.queryRegion({
-            x: Math.min(start.x, end.x) - 1000,
-            y: Math.min(start.y, end.y) - 1000,
-            width: Math.abs(end.x - start.x) + 2000,
-            height: Math.abs(end.y - start.y) + 2000,
-        });
-        if (obstacles.length === 0) {
-            return [start, end];
-        }
-        // Extract vertices from obstacles
-        const vertices = this.extractVertices(obstacles, start, end);
-        // Build visibility graph
-        const graph = this.buildVisibilityGraph(vertices, obstacles);
-        // Find shortest path through graph
-        const path = this.findShortestPath(graph, vertices, 0, 1); // 0 = start, 1 = end
-        if (path.length === 0) {
-            // Fallback to direct path if no path found
-            return [start, end];
-        }
-        return path;
-    }
-    /**
-     * Extract all vertices (corners) from obstacles plus start/end
-     */
-    extractVertices(obstacles, start, end) {
-        const vertices = [start, end];
-        const margin = this.options.obstacleMargin;
-        for (const obstacle of obstacles) {
-            // Add four corners of obstacle (with margin)
-            vertices.push({ x: obstacle.x - margin, y: obstacle.y - margin }, // Top-left
-            { x: obstacle.x + obstacle.width + margin, y: obstacle.y - margin }, // Top-right
-            { x: obstacle.x + obstacle.width + margin, y: obstacle.y + obstacle.height + margin }, // Bottom-right
-            { x: obstacle.x - margin, y: obstacle.y + obstacle.height + margin } // Bottom-left
-            );
-        }
-        return vertices;
-    }
-    /**
-     * Build visibility graph - connect vertices with line-of-sight
-     */
-    buildVisibilityGraph(vertices, obstacles) {
-        const graph = Array.from({ length: vertices.length }, () => []);
-        // For each pair of vertices, check if they can see each other
-        for (let i = 0; i < vertices.length; i++) {
-            for (let j = i + 1; j < vertices.length; j++) {
-                if (this.hasLineOfSight(vertices[i], vertices[j], obstacles)) {
-                    const distance = this.distance(vertices[i], vertices[j]);
-                    // Add bidirectional edge
-                    graph[i].push({ to: j, weight: distance });
-                    graph[j].push({ to: i, weight: distance });
-                }
-            }
-        }
-        return graph;
-    }
-    /**
-     * Find shortest path through visibility graph using Dijkstra
-     */
-    findShortestPath(graph, vertices, startIdx, endIdx) {
-        const distances = new Array(vertices.length).fill(Infinity);
-        const parents = new Array(vertices.length).fill(-1);
-        const visited = new Set();
-        const queue = new PriorityQueue();
-        distances[startIdx] = 0;
-        queue.push({ vertex: startIdx, distance: 0, parent: null });
-        while (!queue.isEmpty()) {
-            const current = queue.pop();
-            if (visited.has(current.vertex))
-                continue;
-            visited.add(current.vertex);
-            // Reached end
-            if (current.vertex === endIdx) {
-                break;
-            }
-            // Explore neighbors
-            for (const edge of graph[current.vertex]) {
-                if (visited.has(edge.to))
-                    continue;
-                const newDistance = distances[current.vertex] + edge.weight;
-                if (newDistance < distances[edge.to]) {
-                    distances[edge.to] = newDistance;
-                    parents[edge.to] = current.vertex;
-                    queue.push({ vertex: edge.to, distance: newDistance, parent: current.vertex });
-                }
-            }
-        }
-        // Reconstruct path
-        if (parents[endIdx] === -1) {
-            return []; // No path found
-        }
-        const path = [];
-        let current = endIdx;
-        while (current !== -1) {
-            path.unshift(vertices[current]);
-            current = parents[current];
-        }
-        return path;
-    }
-    /**
-     * Check if two points have line-of-sight (no obstacles blocking)
-     */
-    hasLineOfSight(a, b, obstacles) {
-        const obs = obstacles || this.obstacleMap.queryRegion({
-            x: Math.min(a.x, b.x) - 10,
-            y: Math.min(a.y, b.y) - 10,
-            width: Math.abs(b.x - a.x) + 20,
-            height: Math.abs(b.y - a.y) + 20,
-        });
-        for (const obstacle of obs) {
-            if (this.lineIntersectsRectangle(a, b, obstacle)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Check if line segment intersects with rectangle
-     */
-    lineIntersectsRectangle(a, b, rect) {
-        // Check if line segment intersects any of the four edges of rectangle
-        const edges = [
-            { p1: { x: rect.x, y: rect.y }, p2: { x: rect.x + rect.width, y: rect.y } }, // Top
-            { p1: { x: rect.x + rect.width, y: rect.y }, p2: { x: rect.x + rect.width, y: rect.y + rect.height } }, // Right
-            { p1: { x: rect.x + rect.width, y: rect.y + rect.height }, p2: { x: rect.x, y: rect.y + rect.height } }, // Bottom
-            { p1: { x: rect.x, y: rect.y + rect.height }, p2: { x: rect.x, y: rect.y } }, // Left
-        ];
-        for (const edge of edges) {
-            if (this.lineSegmentsIntersect(a, b, edge.p1, edge.p2)) {
-                return true;
-            }
-        }
-        // Also check if line passes through interior
-        const midpoint = {
-            x: (a.x + b.x) / 2,
-            y: (a.y + b.y) / 2,
-        };
-        if (midpoint.x > rect.x &&
-            midpoint.x < rect.x + rect.width &&
-            midpoint.y > rect.y &&
-            midpoint.y < rect.y + rect.height) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Check if two line segments intersect
-     */
-    lineSegmentsIntersect(a1, a2, b1, b2) {
-        const ccw = (a, b, c) => {
-            return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
-        };
-        return (ccw(a1, b1, b2) !== ccw(a2, b1, b2) &&
-            ccw(a1, a2, b1) !== ccw(a1, a2, b2));
-    }
-    /**
-     * Calculate Euclidean 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 two points are equal
-     */
-    pointsEqual(a, b) {
-        return a.x === b.x && a.y === b.y;
-    }
-}
-exports.VisibilityGraphRouter = VisibilityGraphRouter;
-//# sourceMappingURL=VisibilityGraphRouter.js.map

package/src/libs/engine/src/routing/global/GlobalRouteSolver.d.ts

@@ -1,64 +0,0 @@
-import type { Obstacle } from '../types';
-import type { Point } from '../../types';
-type Side = 'left' | 'right' | 'top' | 'bottom';
-export interface SolverEdge {
-    id: string;
-    start: Point;
-    end: Point;
-    sourceDirection?: Side;
-    targetDirection?: Side;
-    /** per-edge jetty override; defaults to the solver's gridSize */
-    jetty?: number;
-}
-export interface SolverOptions {
-    gridSize?: number;
-    obstacleMargin?: number;
-    /** cost added per step through a cell occupied by K other edges: K × this */
-    congestionPenalty?: number;
-    /** cost added per step through a cell that another edge crosses PERPENDICULAR to this step */
-    crossingPenalty?: number;
-    /** refinement passes over the whole edge set */
-    passes?: number;
-    /** per-edge search budget (ManhattanRouter maxIterations) */
-    maxIterations?: number;
-    bendCost?: number;
-}
-export interface SolverStats {
-    /** edges routed in the last solve/solveIncremental call */
-    edgesRouted: number;
-    /** edges served untouched from the previous solution */
-    edgesReused: number;
-}
-export declare class GlobalRouteSolver {
-    private readonly options;
-    private readonly router;
-    private routes;
-    private edges;
-    private obstacles;
-    /** cell → per-axis occupancy laid down by each edge: id → 'h' | 'v' */
-    private field;
-    private _stats;
-    constructor(options?: SolverOptions);
-    get stats(): Readonly<SolverStats>;
-    /** Full solve. Deterministic: edges route in id order, every pass. */
-    solve(edges: SolverEdge[], obstacles: Obstacle[]): Map<string, Point[]>;
-    /**
-     * Re-solve after a change: `changed` edges re-route (removed ones pass with
-     * `removed: true`), and so does every edge whose current route touches a cell
-     * a changed edge occupied before or after. Everything else is served as-is.
-     */
-    solveIncremental(changed: Array<{
-        edge: SolverEdge;
-        removed?: boolean;
-    }>, obstacles?: Obstacle[]): Map<string, Point[]>;
-    private routeEdge;
-    /**
-     * Manhattan-style search with the shared penalty field added per step:
-     * congestion (any other edge in the cell) and crossing (another edge through
-     * the cell PERPENDICULAR to this step). Same moves, same U-turn ban, same
-     * jetty handling as ManhattanRouter — the field term is the only addition.
-     */
-    private penalisedRoute;
-    private clearFromField;
-}
-export {};