@ngx-km/path-finding 0.0.1

package/fesm2022/ngx-km-path-finding.mjs

@@ -0,0 +1,1002 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+
+/**
+ * Path Finding Models
+ *
+ * Types and interfaces for obstacle-aware path routing between nodes.
+ */
+/**
+ * Default path finding options
+ */
+const DEFAULT_PATH_FINDING_OPTIONS = {
+    pathType: 'orthogonal',
+    obstaclePadding: 20,
+    cornerPadding: 10,
+    connectionSpacing: 15,
+    allowOverlap: false,
+    spreadAnchors: true,
+    anchorSpacing: 15,
+};
+
+/**
+ * Path Utilities
+ *
+ * Functions for path manipulation, simplification, and measurement.
+ */
+/**
+ * Calculate the length of a route using Manhattan distance (orthogonal segments)
+ * Used for comparing route candidates
+ */
+function calculateRouteLength(points) {
+    let length = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        length += Math.abs(points[i + 1].x - points[i].x) + Math.abs(points[i + 1].y - points[i].y);
+    }
+    return length;
+}
+/**
+ * Calculate total path length using Euclidean distance
+ * Excludes control points for bezier curves
+ */
+function calculatePathLength(waypoints) {
+    let length = 0;
+    const points = waypoints.filter((w) => !w.isControlPoint);
+    for (let i = 0; i < points.length - 1; i++) {
+        length += Math.hypot(points[i + 1].x - points[i].x, points[i + 1].y - points[i].y);
+    }
+    return length;
+}
+/**
+ * Calculate the midpoint of a path
+ * Returns the point at half the total path length
+ */
+function calculateMidpoint(waypoints) {
+    if (waypoints.length === 0)
+        return { x: 0, y: 0 };
+    if (waypoints.length === 1)
+        return { x: waypoints[0].x, y: waypoints[0].y };
+    const nonControlPoints = waypoints.filter((w) => !w.isControlPoint);
+    if (nonControlPoints.length >= 2) {
+        const totalLength = calculatePathLength(nonControlPoints);
+        const targetLength = totalLength / 2;
+        let accumulatedLength = 0;
+        for (let i = 0; i < nonControlPoints.length - 1; i++) {
+            const segmentLength = Math.hypot(nonControlPoints[i + 1].x - nonControlPoints[i].x, nonControlPoints[i + 1].y - nonControlPoints[i].y);
+            if (accumulatedLength + segmentLength >= targetLength) {
+                const remainingLength = targetLength - accumulatedLength;
+                const ratio = segmentLength > 0 ? remainingLength / segmentLength : 0;
+                return {
+                    x: nonControlPoints[i].x + (nonControlPoints[i + 1].x - nonControlPoints[i].x) * ratio,
+                    y: nonControlPoints[i].y + (nonControlPoints[i + 1].y - nonControlPoints[i].y) * ratio,
+                };
+            }
+            accumulatedLength += segmentLength;
+        }
+    }
+    const midIndex = Math.floor(nonControlPoints.length / 2);
+    return { x: nonControlPoints[midIndex].x, y: nonControlPoints[midIndex].y };
+}
+/**
+ * Simplify path by removing collinear points
+ * This reduces redundant waypoints while preserving path shape
+ */
+function simplifyPath(waypoints) {
+    if (waypoints.length <= 2)
+        return waypoints;
+    const simplified = [waypoints[0]];
+    for (let i = 1; i < waypoints.length - 1; i++) {
+        const prev = simplified[simplified.length - 1];
+        const curr = waypoints[i];
+        const next = waypoints[i + 1];
+        const isCollinear = (Math.abs(prev.x - curr.x) < 0.001 && Math.abs(curr.x - next.x) < 0.001) ||
+            (Math.abs(prev.y - curr.y) < 0.001 && Math.abs(curr.y - next.y) < 0.001);
+        if (!isCollinear) {
+            simplified.push(curr);
+        }
+    }
+    simplified.push(waypoints[waypoints.length - 1]);
+    return simplified;
+}
+
+/**
+ * Anchor Utilities
+ *
+ * Functions for calculating connection points and anchor slot assignments.
+ */
+/**
+ * Get preferred connection side based on relative position of nodes
+ */
+function getPreferredSide(from, to) {
+    const fromCenterX = from.x + from.width / 2;
+    const fromCenterY = from.y + from.height / 2;
+    const toCenterX = to.x + to.width / 2;
+    const toCenterY = to.y + to.height / 2;
+    const dx = toCenterX - fromCenterX;
+    const dy = toCenterY - fromCenterY;
+    if (Math.abs(dx) > Math.abs(dy)) {
+        return dx > 0 ? 'right' : 'left';
+    }
+    else {
+        return dy > 0 ? 'bottom' : 'top';
+    }
+}
+/**
+ * Get connection point on a node
+ */
+function getConnectionPoint(node, targetNode, forcedAnchor, cornerPadding, slot, anchorSpacing) {
+    const side = forcedAnchor || getPreferredSide(node, targetNode);
+    const point = getPointOnSide(node, side, cornerPadding, slot, anchorSpacing);
+    return { side, x: point.x, y: point.y };
+}
+/**
+ * Get point on a specific side of a node
+ * Uses even distribution when multiple slots are on the same side
+ */
+function getPointOnSide(node, side, cornerPadding, slot, _anchorSpacing // kept for API compatibility but not used
+) {
+    // Calculate position on edge using even distribution
+    const isVerticalSide = side === 'left' || side === 'right';
+    const edgeLength = isVerticalSide ? node.height : node.width;
+    const usableLength = edgeLength - 2 * cornerPadding;
+    let edgePosition;
+    if (slot && slot.totalSlots > 1) {
+        // Distribute evenly: for N slots, divide into N+1 segments
+        const t = (slot.slotIndex + 1) / (slot.totalSlots + 1);
+        edgePosition = cornerPadding + t * usableLength;
+    }
+    else {
+        // Single slot or no slot - use center
+        edgePosition = edgeLength / 2;
+    }
+    switch (side) {
+        case 'top':
+            return {
+                x: node.x + edgePosition,
+                y: node.y,
+            };
+        case 'bottom':
+            return {
+                x: node.x + edgePosition,
+                y: node.y + node.height,
+            };
+        case 'left':
+            return {
+                x: node.x,
+                y: node.y + edgePosition,
+            };
+        case 'right':
+            return {
+                x: node.x + node.width,
+                y: node.y + edgePosition,
+            };
+    }
+}
+/**
+ * Get a padded point - sits at padding distance from node edge
+ * Uses even distribution when multiple slots are on the same side
+ */
+function getPaddedPoint(node, side, padding, cornerPadding, slot) {
+    // Calculate position on edge using even distribution
+    const isVerticalSide = side === 'left' || side === 'right';
+    const edgeLength = isVerticalSide ? node.height : node.width;
+    const usableLength = edgeLength - 2 * cornerPadding;
+    let edgePosition;
+    if (slot && slot.totalSlots > 1) {
+        // Distribute evenly: for N slots, divide into N+1 segments
+        const t = (slot.slotIndex + 1) / (slot.totalSlots + 1);
+        edgePosition = cornerPadding + t * usableLength;
+    }
+    else {
+        // Single slot or no slot - use center
+        edgePosition = edgeLength / 2;
+    }
+    switch (side) {
+        case 'top': {
+            const edgeX = node.x + edgePosition;
+            return {
+                x: edgeX,
+                y: node.y - padding,
+                side,
+                nodeEdgeX: edgeX,
+                nodeEdgeY: node.y,
+            };
+        }
+        case 'bottom': {
+            const edgeX = node.x + edgePosition;
+            return {
+                x: edgeX,
+                y: node.y + node.height + padding,
+                side,
+                nodeEdgeX: edgeX,
+                nodeEdgeY: node.y + node.height,
+            };
+        }
+        case 'left': {
+            const edgeY = node.y + edgePosition;
+            return {
+                x: node.x - padding,
+                y: edgeY,
+                side,
+                nodeEdgeX: node.x,
+                nodeEdgeY: edgeY,
+            };
+        }
+        case 'right': {
+            const edgeY = node.y + edgePosition;
+            return {
+                x: node.x + node.width + padding,
+                y: edgeY,
+                side,
+                nodeEdgeX: node.x + node.width,
+                nodeEdgeY: edgeY,
+            };
+        }
+    }
+}
+/**
+ * Calculate actual slot positions on a node edge
+ * Uses even distribution across the available edge space
+ */
+function calculateSlotPositions(node, side, totalSlots, cornerPadding = 5) {
+    const positions = [];
+    // Calculate the available range on this edge
+    const isVerticalSide = side === 'left' || side === 'right';
+    const edgeLength = isVerticalSide ? node.height : node.width;
+    const usableLength = edgeLength - 2 * cornerPadding;
+    for (let i = 0; i < totalSlots; i++) {
+        // Distribute evenly: for N slots, divide into N+1 segments
+        // and place slots at positions 1, 2, ..., N
+        const t = (i + 1) / (totalSlots + 1);
+        const offset = cornerPadding + t * usableLength;
+        switch (side) {
+            case 'top':
+                positions.push({ x: node.x + offset, y: node.y });
+                break;
+            case 'bottom':
+                positions.push({ x: node.x + offset, y: node.y + node.height });
+                break;
+            case 'left':
+                positions.push({ x: node.x, y: node.y + offset });
+                break;
+            case 'right':
+                positions.push({ x: node.x + node.width, y: node.y + offset });
+                break;
+        }
+    }
+    return positions;
+}
+/**
+ * Find optimal slot assignment to minimize crossings
+ * Returns an array where assignment[connIndex] = slotIndex
+ */
+function findOptimalSlotAssignment(connections, slotPositions) {
+    const n = connections.length;
+    // For small numbers, try all permutations to find the best one
+    if (n <= 6) {
+        return findBestPermutation(connections, slotPositions);
+    }
+    // For larger numbers, use greedy assignment based on distance
+    return greedySlotAssignment(connections, slotPositions);
+}
+/**
+ * Try all permutations to find the one with minimum total distance
+ */
+function findBestPermutation(connections, slotPositions) {
+    const n = connections.length;
+    const indices = Array.from({ length: n }, (_, i) => i);
+    let bestAssignment = indices.slice();
+    let bestScore = Infinity;
+    // Generate all permutations
+    const permute = (arr, start) => {
+        if (start === arr.length - 1) {
+            // Calculate score for this permutation
+            let totalDist = 0;
+            for (let i = 0; i < n; i++) {
+                const slot = slotPositions[arr[i]];
+                const conn = connections[i];
+                totalDist += Math.hypot(conn.otherNodeX - slot.x, conn.otherNodeY - slot.y);
+            }
+            if (totalDist < bestScore) {
+                bestScore = totalDist;
+                bestAssignment = arr.slice();
+            }
+            return;
+        }
+        for (let i = start; i < arr.length; i++) {
+            [arr[start], arr[i]] = [arr[i], arr[start]];
+            permute(arr, start + 1);
+            [arr[start], arr[i]] = [arr[i], arr[start]];
+        }
+    };
+    permute(indices, 0);
+    return bestAssignment;
+}
+/**
+ * Greedy slot assignment for larger numbers of connections
+ */
+function greedySlotAssignment(connections, slotPositions) {
+    const n = connections.length;
+    const assignment = new Array(n).fill(-1);
+    const usedSlots = new Set();
+    // Create distance matrix
+    const distances = [];
+    for (let c = 0; c < n; c++) {
+        for (let s = 0; s < n; s++) {
+            const dist = Math.hypot(connections[c].otherNodeX - slotPositions[s].x, connections[c].otherNodeY - slotPositions[s].y);
+            distances.push({ connIdx: c, slotIdx: s, dist });
+        }
+    }
+    // Sort by distance and greedily assign
+    distances.sort((a, b) => a.dist - b.dist);
+    for (const { connIdx, slotIdx } of distances) {
+        if (assignment[connIdx] === -1 && !usedSlots.has(slotIdx)) {
+            assignment[connIdx] = slotIdx;
+            usedSlots.add(slotIdx);
+        }
+    }
+    return assignment;
+}
+/**
+ * Calculate anchor slot assignments based on actual path results
+ * This uses the sides that were actually chosen by the routing algorithm
+ */
+function calculateAnchorSlotsFromPaths(paths, nodeMap) {
+    const slots = new Map();
+    // Group connections by node and side
+    const connectionsByNodeSide = new Map();
+    for (const path of paths) {
+        const sourceNode = nodeMap.get(path.sourceId);
+        const targetNode = nodeMap.get(path.targetId);
+        if (!sourceNode || !targetNode)
+            continue;
+        // Use the actual sides from the calculated path
+        const sourceSide = path.sourcePoint.side;
+        const targetSide = path.targetPoint.side;
+        // Source connection
+        const sourceKey = `${path.sourceId}:${sourceSide}`;
+        if (!connectionsByNodeSide.has(sourceKey)) {
+            connectionsByNodeSide.set(sourceKey, []);
+        }
+        connectionsByNodeSide.get(sourceKey).push({
+            relationshipId: path.relationshipId,
+            isSource: true,
+            otherNodeX: targetNode.x + targetNode.width / 2,
+            otherNodeY: targetNode.y + targetNode.height / 2,
+        });
+        // Target connection
+        const targetKey = `${path.targetId}:${targetSide}`;
+        if (!connectionsByNodeSide.has(targetKey)) {
+            connectionsByNodeSide.set(targetKey, []);
+        }
+        connectionsByNodeSide.get(targetKey).push({
+            relationshipId: path.relationshipId,
+            isSource: false,
+            otherNodeX: sourceNode.x + sourceNode.width / 2,
+            otherNodeY: sourceNode.y + sourceNode.height / 2,
+        });
+    }
+    // Assign slots for each node-side combination
+    for (const [key, connections] of connectionsByNodeSide) {
+        const [nodeId, side] = key.split(':');
+        const node = nodeMap.get(nodeId);
+        if (!node)
+            continue;
+        const totalSlots = connections.length;
+        if (totalSlots === 1) {
+            // Single connection - just assign slot 0
+            const conn = connections[0];
+            const slotKey = `${conn.relationshipId}-${conn.isSource ? 'source' : 'target'}`;
+            slots.set(slotKey, {
+                nodeId,
+                side,
+                relationshipId: conn.relationshipId,
+                isSource: conn.isSource,
+                slotIndex: 0,
+                totalSlots: 1,
+            });
+            continue;
+        }
+        // Calculate the actual slot positions on the node edge
+        const slotPositions = calculateSlotPositions(node, side, totalSlots);
+        // Find optimal assignment: pair each connection with a slot position
+        // to minimize total distance and avoid crossings
+        const assignment = findOptimalSlotAssignment(connections, slotPositions);
+        // Assign slots based on the optimal pairing
+        assignment.forEach((slotIndex, connIndex) => {
+            const conn = connections[connIndex];
+            const slotKey = `${conn.relationshipId}-${conn.isSource ? 'source' : 'target'}`;
+            slots.set(slotKey, {
+                nodeId,
+                side,
+                relationshipId: conn.relationshipId,
+                isSource: conn.isSource,
+                slotIndex,
+                totalSlots,
+            });
+        });
+    }
+    return slots;
+}
+
+/**
+ * Geometry Utilities
+ *
+ * Core geometric types and functions for path finding calculations.
+ */
+/**
+ * Clamp a value between min and max
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * Create a Rect from a PathNode
+ */
+function createRect(node) {
+    return {
+        x: node.x,
+        y: node.y,
+        width: node.width,
+        height: node.height,
+        right: node.x + node.width,
+        bottom: node.y + node.height,
+        centerX: node.x + node.width / 2,
+        centerY: node.y + node.height / 2,
+    };
+}
+/**
+ * Create a padded Rect from a PathNode
+ */
+function createPaddedRect(node, padding) {
+    return {
+        x: node.x - padding,
+        y: node.y - padding,
+        width: node.width + padding * 2,
+        height: node.height + padding * 2,
+        right: node.x + node.width + padding,
+        bottom: node.y + node.height + padding,
+        centerX: node.x + node.width / 2,
+        centerY: node.y + node.height / 2,
+    };
+}
+/**
+ * Expand a Rect by padding amount on all sides
+ */
+function expandRect(rect, padding) {
+    return {
+        x: rect.x - padding,
+        y: rect.y - padding,
+        width: rect.width + padding * 2,
+        height: rect.height + padding * 2,
+        right: rect.right + padding,
+        bottom: rect.bottom + padding,
+        centerX: rect.centerX,
+        centerY: rect.centerY,
+    };
+}
+/**
+ * Check if a line segment passes through rectangle interior (not just touches edge)
+ * Used for obstacle collision detection in orthogonal routing
+ */
+function linePassesThroughRect(p1, p2, rect) {
+    // Check bounding box overlap first
+    const lineMinX = Math.min(p1.x, p2.x);
+    const lineMaxX = Math.max(p1.x, p2.x);
+    const lineMinY = Math.min(p1.y, p2.y);
+    const lineMaxY = Math.max(p1.y, p2.y);
+    // No overlap at all
+    if (lineMaxX <= rect.x || lineMinX >= rect.right)
+        return false;
+    if (lineMaxY <= rect.y || lineMinY >= rect.bottom)
+        return false;
+    // For orthogonal lines, check if line passes through interior
+    const isVertical = Math.abs(p1.x - p2.x) < 0.001;
+    const isHorizontal = Math.abs(p1.y - p2.y) < 0.001;
+    if (isVertical) {
+        // Vertical line: passes through if x is strictly inside rect
+        return p1.x > rect.x && p1.x < rect.right;
+    }
+    if (isHorizontal) {
+        // Horizontal line: passes through if y is strictly inside rect
+        return p1.y > rect.y && p1.y < rect.bottom;
+    }
+    // Diagonal line (shouldn't happen for orthogonal routing)
+    return true;
+}
+
+/**
+ * Orthogonal Path Strategy
+ *
+ * Generates paths with right-angle turns only (Manhattan-style routing).
+ * Supports obstacle avoidance with multiple routing strategies.
+ */
+/**
+ * Orthogonal path strategy - routes paths with right-angle turns
+ */
+class OrthogonalStrategy {
+    calculatePath(context) {
+        const { source, target, relationship, allNodes, options, sourceSlot, targetSlot } = context;
+        const padding = options.obstaclePadding;
+        // Create rectangles for collision detection
+        const sourceRect = createRect(source);
+        const targetRect = createRect(target);
+        // Get obstacles (all nodes except source and target, with padding)
+        const obstacles = options.allowOverlap
+            ? []
+            : allNodes
+                .filter((n) => n.id !== source.id && n.id !== target.id)
+                .map((n) => createPaddedRect(n, padding));
+        // If we have slots from a previous pass, force those sides to maintain consistency
+        const forcedSourceSide = sourceSlot?.side ?? relationship.sourceAnchor;
+        const forcedTargetSide = targetSlot?.side ?? relationship.targetAnchor;
+        const bestRoute = this.findBestOrthogonalRoute(source, target, sourceRect, targetRect, obstacles, padding, forcedSourceSide, forcedTargetSide, options.cornerPadding, sourceSlot, targetSlot);
+        return {
+            sourcePoint: {
+                side: bestRoute.sourceSide,
+                x: bestRoute.waypoints[0].x,
+                y: bestRoute.waypoints[0].y,
+            },
+            targetPoint: {
+                side: bestRoute.targetSide,
+                x: bestRoute.waypoints[bestRoute.waypoints.length - 1].x,
+                y: bestRoute.waypoints[bestRoute.waypoints.length - 1].y,
+            },
+            waypoints: bestRoute.waypoints,
+        };
+    }
+    /**
+     * Find the best orthogonal route using padded-edge approach
+     */
+    findBestOrthogonalRoute(sourceNode, targetNode, sourceRect, targetRect, obstacles, padding, forcedSourceSide, forcedTargetSide, cornerPadding, sourceSlot, targetSlot) {
+        const candidates = [];
+        // Determine which sides to try
+        const sourceSides = forcedSourceSide
+            ? [forcedSourceSide]
+            : ['top', 'right', 'bottom', 'left'];
+        const targetSides = forcedTargetSide
+            ? [forcedTargetSide]
+            : ['top', 'right', 'bottom', 'left'];
+        // Try all side combinations
+        for (const sourceSide of sourceSides) {
+            for (const targetSide of targetSides) {
+                // Get padded points (at padding distance from node edge)
+                const sourcePadded = getPaddedPoint(sourceNode, sourceSide, padding, cornerPadding, sourceSlot);
+                const targetPadded = getPaddedPoint(targetNode, targetSide, padding, cornerPadding, targetSlot);
+                // Find route between padded points
+                const paddedRoute = this.findPaddedRoute(sourcePadded, targetPadded, sourceRect, targetRect, obstacles, padding);
+                if (paddedRoute) {
+                    // Extend route to actual node edges
+                    const fullRoute = this.extendRouteToEdges(paddedRoute, sourcePadded, targetPadded);
+                    const length = calculateRouteLength(fullRoute);
+                    candidates.push({
+                        waypoints: fullRoute,
+                        length,
+                        sourceSide,
+                        targetSide,
+                    });
+                }
+            }
+        }
+        // Return the shortest valid route
+        if (candidates.length > 0) {
+            candidates.sort((a, b) => a.length - b.length);
+            return candidates[0];
+        }
+        // Fallback: simple direct route
+        const preferredSourceSide = forcedSourceSide || getPreferredSide(sourceNode, targetNode);
+        const preferredTargetSide = forcedTargetSide || getPreferredSide(targetNode, sourceNode);
+        const sourcePadded = getPaddedPoint(sourceNode, preferredSourceSide, padding, cornerPadding, sourceSlot);
+        const targetPadded = getPaddedPoint(targetNode, preferredTargetSide, padding, cornerPadding, targetSlot);
+        const fallbackRoute = this.createFallbackRoute(sourcePadded, targetPadded);
+        const fullRoute = this.extendRouteToEdges(fallbackRoute, sourcePadded, targetPadded);
+        return {
+            waypoints: fullRoute,
+            length: Infinity,
+            sourceSide: preferredSourceSide,
+            targetSide: preferredTargetSide,
+        };
+    }
+    /**
+     * Find route between padded points avoiding obstacles
+     */
+    findPaddedRoute(source, target, sourceRect, targetRect, obstacles, padding) {
+        // Create padded obstacle rects for collision detection
+        // Include source and target nodes as obstacles (paths shouldn't go through them)
+        const paddedSourceRect = expandRect(sourceRect, padding);
+        const paddedTargetRect = expandRect(targetRect, padding);
+        const allObstacles = [...obstacles, paddedSourceRect, paddedTargetRect];
+        // Try strategies in order of simplicity
+        const strategies = [
+            () => this.tryDirect(source, target, allObstacles),
+            () => this.tryLShape(source, target, allObstacles),
+            () => this.tryZShape(source, target, allObstacles),
+            () => this.tryUShape(source, target, sourceRect, targetRect, allObstacles, padding),
+        ];
+        for (const strategy of strategies) {
+            const route = strategy();
+            if (route) {
+                return simplifyPath(route);
+            }
+        }
+        return null;
+    }
+    /**
+     * Try direct route (straight line between padded points)
+     */
+    tryDirect(source, target, obstacles) {
+        // Only works if horizontally or vertically aligned
+        const isHorizontal = Math.abs(source.y - target.y) < 1;
+        const isVertical = Math.abs(source.x - target.x) < 1;
+        if (!isHorizontal && !isVertical)
+            return null;
+        const route = [
+            { x: source.x, y: source.y },
+            { x: target.x, y: target.y },
+        ];
+        if (this.isRouteValid(route, obstacles)) {
+            return route;
+        }
+        return null;
+    }
+    /**
+     * Try L-shaped route (one bend)
+     */
+    tryLShape(source, target, obstacles) {
+        const isHorizontalSource = source.side === 'left' || source.side === 'right';
+        const isHorizontalTarget = target.side === 'left' || target.side === 'right';
+        // L-route only works when source and target are on different axis
+        if (isHorizontalSource === isHorizontalTarget)
+            return null;
+        const routes = [];
+        if (isHorizontalSource) {
+            // Source horizontal, target vertical: go horizontal first, then vertical
+            routes.push([
+                { x: source.x, y: source.y },
+                { x: target.x, y: source.y },
+                { x: target.x, y: target.y },
+            ]);
+        }
+        else {
+            // Source vertical, target horizontal: go vertical first, then horizontal
+            routes.push([
+                { x: source.x, y: source.y },
+                { x: source.x, y: target.y },
+                { x: target.x, y: target.y },
+            ]);
+        }
+        for (const route of routes) {
+            if (this.isRouteValid(route, obstacles)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    /**
+     * Try Z-shaped route (two bends)
+     */
+    tryZShape(source, target, obstacles) {
+        const isHorizontalSource = source.side === 'left' || source.side === 'right';
+        const isHorizontalTarget = target.side === 'left' || target.side === 'right';
+        const routes = [];
+        if (isHorizontalSource && isHorizontalTarget) {
+            // Both horizontal: route with vertical middle segment
+            const midX = (source.x + target.x) / 2;
+            routes.push([
+                { x: source.x, y: source.y },
+                { x: midX, y: source.y },
+                { x: midX, y: target.y },
+                { x: target.x, y: target.y },
+            ]);
+        }
+        else if (!isHorizontalSource && !isHorizontalTarget) {
+            // Both vertical: route with horizontal middle segment
+            const midY = (source.y + target.y) / 2;
+            routes.push([
+                { x: source.x, y: source.y },
+                { x: source.x, y: midY },
+                { x: target.x, y: midY },
+                { x: target.x, y: target.y },
+            ]);
+        }
+        // Sort by length and return first valid
+        routes.sort((a, b) => calculateRouteLength(a) - calculateRouteLength(b));
+        for (const route of routes) {
+            if (this.isRouteValid(route, obstacles)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    /**
+     * Try U-shaped route (goes around nodes)
+     */
+    tryUShape(source, target, sourceRect, targetRect, obstacles, padding) {
+        const routes = [];
+        // Calculate bounds for going around
+        const minX = Math.min(sourceRect.x, targetRect.x) - padding * 2;
+        const maxX = Math.max(sourceRect.right, targetRect.right) + padding * 2;
+        const minY = Math.min(sourceRect.y, targetRect.y) - padding * 2;
+        const maxY = Math.max(sourceRect.bottom, targetRect.bottom) + padding * 2;
+        // Route around top
+        routes.push([
+            { x: source.x, y: source.y },
+            { x: source.x, y: minY },
+            { x: target.x, y: minY },
+            { x: target.x, y: target.y },
+        ]);
+        // Route around bottom
+        routes.push([
+            { x: source.x, y: source.y },
+            { x: source.x, y: maxY },
+            { x: target.x, y: maxY },
+            { x: target.x, y: target.y },
+        ]);
+        // Route around left
+        routes.push([
+            { x: source.x, y: source.y },
+            { x: minX, y: source.y },
+            { x: minX, y: target.y },
+            { x: target.x, y: target.y },
+        ]);
+        // Route around right
+        routes.push([
+            { x: source.x, y: source.y },
+            { x: maxX, y: source.y },
+            { x: maxX, y: target.y },
+            { x: target.x, y: target.y },
+        ]);
+        // Sort by length and return first valid
+        routes.sort((a, b) => calculateRouteLength(a) - calculateRouteLength(b));
+        for (const route of routes) {
+            if (this.isRouteValid(route, obstacles)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    /**
+     * Create fallback route when no valid route is found
+     */
+    createFallbackRoute(source, target) {
+        const isHorizontalSource = source.side === 'left' || source.side === 'right';
+        if (isHorizontalSource) {
+            return [
+                { x: source.x, y: source.y },
+                { x: target.x, y: source.y },
+                { x: target.x, y: target.y },
+            ];
+        }
+        else {
+            return [
+                { x: source.x, y: source.y },
+                { x: source.x, y: target.y },
+                { x: target.x, y: target.y },
+            ];
+        }
+    }
+    /**
+     * Extend route from padded points to actual node edges
+     */
+    extendRouteToEdges(paddedRoute, source, target) {
+        const result = [];
+        // Add start point at node edge
+        result.push({ x: source.nodeEdgeX, y: source.nodeEdgeY });
+        // Add all waypoints from padded route
+        for (const wp of paddedRoute) {
+            result.push({ x: wp.x, y: wp.y });
+        }
+        // Add end point at node edge
+        result.push({ x: target.nodeEdgeX, y: target.nodeEdgeY });
+        return simplifyPath(result);
+    }
+    /**
+     * Check if route is valid (doesn't pass through obstacles)
+     */
+    isRouteValid(route, obstacles) {
+        for (let i = 0; i < route.length - 1; i++) {
+            const p1 = route[i];
+            const p2 = route[i + 1];
+            for (const obs of obstacles) {
+                if (linePassesThroughRect(p1, p2, obs)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+
+/**
+ * Bezier Path Strategy
+ *
+ * Generates smooth curved paths using cubic bezier curves.
+ * Control points are positioned based on connection sides.
+ */
+/**
+ * Bezier path strategy - creates smooth curved paths
+ */
+class BezierStrategy {
+    calculatePath(context) {
+        const { source, target, relationship, options, sourceSlot, targetSlot } = context;
+        const sourcePoint = getConnectionPoint(source, target, relationship.sourceAnchor, options.cornerPadding, sourceSlot, options.anchorSpacing);
+        const targetPoint = getConnectionPoint(target, source, relationship.targetAnchor, options.cornerPadding, targetSlot, options.anchorSpacing);
+        const waypoints = this.calculateBezierPath(sourcePoint, targetPoint);
+        return {
+            sourcePoint,
+            targetPoint,
+            waypoints,
+        };
+    }
+    /**
+     * Calculate bezier path with control points
+     */
+    calculateBezierPath(source, target) {
+        const controlDistance = Math.max(50, Math.hypot(target.x - source.x, target.y - source.y) * 0.3);
+        const sourceControl = this.getControlPointForBezier(source, controlDistance);
+        const targetControl = this.getControlPointForBezier(target, controlDistance);
+        return [
+            { x: source.x, y: source.y },
+            { x: sourceControl.x, y: sourceControl.y, isControlPoint: true },
+            { x: targetControl.x, y: targetControl.y, isControlPoint: true },
+            { x: target.x, y: target.y },
+        ];
+    }
+    /**
+     * Get control point position based on connection side
+     */
+    getControlPointForBezier(connection, distance) {
+        switch (connection.side) {
+            case 'top':
+                return { x: connection.x, y: connection.y - distance };
+            case 'bottom':
+                return { x: connection.x, y: connection.y + distance };
+            case 'left':
+                return { x: connection.x - distance, y: connection.y };
+            case 'right':
+                return { x: connection.x + distance, y: connection.y };
+        }
+    }
+}
+
+/**
+ * Straight Path Strategy
+ *
+ * Generates direct line paths between nodes.
+ * Simple and fast, but may overlap obstacles.
+ */
+/**
+ * Straight path strategy - creates direct line paths
+ */
+class StraightStrategy {
+    calculatePath(context) {
+        const { source, target, relationship, options, sourceSlot, targetSlot } = context;
+        const sourcePoint = getConnectionPoint(source, target, relationship.sourceAnchor, options.cornerPadding, sourceSlot, options.anchorSpacing);
+        const targetPoint = getConnectionPoint(target, source, relationship.targetAnchor, options.cornerPadding, targetSlot, options.anchorSpacing);
+        const waypoints = [
+            { x: sourcePoint.x, y: sourcePoint.y },
+            { x: targetPoint.x, y: targetPoint.y },
+        ];
+        return {
+            sourcePoint,
+            targetPoint,
+            waypoints,
+        };
+    }
+}
+
+/**
+ * Path Finding Service
+ *
+ * Calculates obstacle-aware paths between nodes using smart routing.
+ * Automatically selects optimal connection sides to find shortest valid paths.
+ *
+ * Uses strategy pattern for different path types:
+ * - Orthogonal: Right-angle turns with obstacle avoidance
+ * - Bezier: Smooth curved paths
+ * - Straight: Direct line paths
+ */
+class PathFindingService {
+    strategies = {
+        orthogonal: new OrthogonalStrategy(),
+        bezier: new BezierStrategy(),
+        straight: new StraightStrategy(),
+    };
+    /**
+     * Calculate paths for all relationships
+     */
+    calculatePaths(input) {
+        const options = { ...DEFAULT_PATH_FINDING_OPTIONS, ...input.options };
+        const nodeMap = new Map();
+        for (const node of input.nodes) {
+            nodeMap.set(node.id, node);
+        }
+        // First pass: calculate paths without anchor spreading to determine actual sides
+        const initialPaths = [];
+        for (const relationship of input.relationships) {
+            const sourceNode = nodeMap.get(relationship.sourceId);
+            const targetNode = nodeMap.get(relationship.targetId);
+            if (!sourceNode || !targetNode) {
+                console.warn(`PathFindingService: Relationship "${relationship.id}" references unknown node`);
+                continue;
+            }
+            const path = this.calculatePath(sourceNode, targetNode, relationship, input.nodes, options, undefined, undefined);
+            initialPaths.push(path);
+        }
+        // If anchor spreading is disabled, return initial paths
+        if (!options.spreadAnchors) {
+            return { paths: initialPaths };
+        }
+        // Second pass: calculate anchor slots based on actual sides used, then recalculate paths
+        const anchorSlots = calculateAnchorSlotsFromPaths(initialPaths, nodeMap);
+        const paths = [];
+        for (const relationship of input.relationships) {
+            const sourceNode = nodeMap.get(relationship.sourceId);
+            const targetNode = nodeMap.get(relationship.targetId);
+            if (!sourceNode || !targetNode) {
+                continue;
+            }
+            const sourceSlot = anchorSlots.get(`${relationship.id}-source`);
+            const targetSlot = anchorSlots.get(`${relationship.id}-target`);
+            const path = this.calculatePath(sourceNode, targetNode, relationship, input.nodes, options, sourceSlot, targetSlot);
+            paths.push(path);
+        }
+        return { paths };
+    }
+    /**
+     * Calculate a single path between two nodes
+     */
+    calculatePath(source, target, relationship, allNodes, options, sourceSlot, targetSlot) {
+        const strategy = this.strategies[options.pathType];
+        const context = {
+            source,
+            target,
+            relationship,
+            allNodes,
+            options,
+            sourceSlot,
+            targetSlot,
+        };
+        const result = strategy.calculatePath(context);
+        const midpoint = calculateMidpoint(result.waypoints);
+        const length = calculatePathLength(result.waypoints);
+        return {
+            relationshipId: relationship.id,
+            sourceId: relationship.sourceId,
+            targetId: relationship.targetId,
+            sourcePoint: result.sourcePoint,
+            targetPoint: result.targetPoint,
+            waypoints: result.waypoints,
+            midpoint,
+            length,
+            pathType: options.pathType,
+        };
+    }
+    /**
+     * Recalculate paths (convenience method)
+     */
+    recalculatePaths(input) {
+        return this.calculatePaths(input);
+    }
+    /**
+     * Calculate a single path (convenience method)
+     */
+    calculateSinglePath(source, target, relationship, obstacles, options) {
+        const fullOptions = { ...DEFAULT_PATH_FINDING_OPTIONS, ...options };
+        return this.calculatePath(source, target, relationship, obstacles, fullOptions, undefined, undefined);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: PathFindingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: PathFindingService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: PathFindingService, decorators: [{
+            type: Injectable
+        }] });
+
+// Models - Values
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BezierStrategy, DEFAULT_PATH_FINDING_OPTIONS, OrthogonalStrategy, PathFindingService, StraightStrategy, calculateAnchorSlotsFromPaths, calculateMidpoint, calculatePathLength, calculateRouteLength, calculateSlotPositions, clamp, createPaddedRect, createRect, expandRect, findOptimalSlotAssignment, getConnectionPoint, getPaddedPoint, getPointOnSide, getPreferredSide, linePassesThroughRect, simplifyPath };
+//# sourceMappingURL=ngx-km-path-finding.mjs.map