@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/routing/ObstacleIndex.js

@@ -1,215 +0,0 @@
-"use strict";
-// Wave 8 (Performance & scale) — Card 6: the obstacle set, indexed.
-//
-// THE MEASURED PROBLEM. Every obstacle predicate in the routers was a LINEAR
-// SCAN of the whole obstacle array:
-//
-//   collidesWithObstacles(point) → for (const o of obstacles) { ...aabb test... }
-//
-// and A* calls it once per neighbour of every cell it expands. Profiling one
-// node-drag frame on the 5k-node benchmark scene counted
-//
-//   187,488 collision calls  ×  ~9,998 obstacles each  =  1.87 BILLION aabb tests
-//
-// in a SINGLE frame — 88% of a 2.2-second frame, all of it inside
-// `collidesWithObstacles`. The routing was never the expensive part; scanning
-// the scene to ask "is this one cell free?" was.
-//
-// This is a uniform grid hash over the obstacle rects. A point query looks at
-// only the cells the query square touches, so the cost is proportional to the
-// obstacles NEAR the query, not to the scene.
-//
-// PREDICATE PARITY IS THE WHOLE CONTRACT. This index does not approximate: it
-// narrows the candidate set and then runs the SAME exact test the linear scan
-// ran, including its inclusive (>=/<=) bounds. A point is in the candidate set
-// iff its margin-expanded query square shares a grid cell with the obstacle's
-// raw rect — and if the square and the rect intersect at all (even by a single
-// boundary point, which the inclusive test counts as a hit) that intersection
-// lies in some cell that both are registered in. So the candidate set is a
-// SUPERSET of the true hits, and the exact test culls the rest: same answer,
-// every time. That is what lets it drop under the 225-assertion line harness
-// without moving a single pixel.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObstacleIndex = void 0;
-exports.mergeObstacles = mergeObstacles;
-/** World units per cell. Nodes are ~140×70, so this holds a handful each. */
-const DEFAULT_CELL_SIZE = 128;
-/**
- * An obstacle that spans more than this many cells is not worth exploding into
- * the grid (a diagram-sized collapsed group block would own every cell). It
- * goes in a small "oversized" list that every query checks directly — which is
- * fine, because there are never many of them.
- */
-const MAX_CELLS_PER_OBSTACLE = 1024;
-/** Cell coordinates beyond this fall back to the oversized list (keeps the packed key exact). */
-const MAX_CELL_COORD = 1 << 20;
-class ObstacleIndex {
-    constructor(obstacles, cellSize = DEFAULT_CELL_SIZE) {
-        this.cells = new Map();
-        this.oversized = [];
-        this.cellSize = cellSize;
-        let n = 0;
-        for (const o of obstacles) {
-            if (!o)
-                continue;
-            n++;
-            this.insert(o);
-        }
-        this.count = n;
-    }
-    /** How many obstacles were indexed. */
-    get size() {
-        return this.count;
-    }
-    insert(o) {
-        const c = this.cellSize;
-        const minCx = Math.floor(o.x / c);
-        const maxCx = Math.floor((o.x + o.width) / c);
-        const minCy = Math.floor(o.y / c);
-        const maxCy = Math.floor((o.y + o.height) / c);
-        const spans = (maxCx - minCx + 1) * (maxCy - minCy + 1);
-        if (!Number.isFinite(spans) ||
-            spans > MAX_CELLS_PER_OBSTACLE ||
-            Math.abs(minCx) >= MAX_CELL_COORD ||
-            Math.abs(maxCx) >= MAX_CELL_COORD ||
-            Math.abs(minCy) >= MAX_CELL_COORD ||
-            Math.abs(maxCy) >= MAX_CELL_COORD) {
-            this.oversized.push(o);
-            return;
-        }
-        for (let cx = minCx; cx <= maxCx; cx++) {
-            for (let cy = minCy; cy <= maxCy; cy++) {
-                const key = ObstacleIndex.key(cx, cy);
-                const bucket = this.cells.get(key);
-                if (bucket)
-                    bucket.push(o);
-                else
-                    this.cells.set(key, [o]);
-            }
-        }
-    }
-    /** Exact, collision-free packing of two cell coords into one number (|coord| < 2^20). */
-    static key(cx, cy) {
-        return cx * 2097152 + (cy + 1048576);
-    }
-    /**
-     * Does the point, expanded by `margin`, touch any obstacle?
-     *
-     * Byte-for-byte the predicate `OrthogonalRouter.collidesWithObstacles` used to
-     * evaluate against the whole array — inclusive bounds and all.
-     */
-    collides(px, py, margin) {
-        for (const o of this.oversized) {
-            if (ObstacleIndex.hit(o, px, py, margin))
-                return true;
-        }
-        if (this.cells.size === 0)
-            return false;
-        const c = this.cellSize;
-        const minCx = Math.floor((px - margin) / c);
-        const maxCx = Math.floor((px + margin) / c);
-        const minCy = Math.floor((py - margin) / c);
-        const maxCy = Math.floor((py + margin) / c);
-        for (let cx = minCx; cx <= maxCx; cx++) {
-            for (let cy = minCy; cy <= maxCy; cy++) {
-                const bucket = this.cells.get(ObstacleIndex.key(cx, cy));
-                if (!bucket)
-                    continue;
-                for (const o of bucket) {
-                    if (ObstacleIndex.hit(o, px, py, margin))
-                        return true;
-                }
-            }
-        }
-        return false;
-    }
-    static hit(o, px, py, margin) {
-        return (px >= o.x - margin &&
-            px <= o.x + o.width + margin &&
-            py >= o.y - margin &&
-            py <= o.y + o.height + margin);
-    }
-    /**
-     * Every obstacle whose rect could overlap the axis-aligned box — the candidate
-     * set for a segment test. Conservative (a superset); the caller runs the exact
-     * geometry test on what comes back.
-     */
-    queryBox(minX, minY, maxX, maxY) {
-        const out = [];
-        const seen = this.oversized.length > 0 || this.cells.size > 0 ? new Set() : null;
-        if (!seen)
-            return out;
-        for (const o of this.oversized) {
-            if (o.x <= maxX && o.x + o.width >= minX && o.y <= maxY && o.y + o.height >= minY) {
-                seen.add(o);
-                out.push(o);
-            }
-        }
-        const c = this.cellSize;
-        const minCx = Math.floor(minX / c);
-        const maxCx = Math.floor(maxX / c);
-        const minCy = Math.floor(minY / c);
-        const maxCy = Math.floor(maxY / c);
-        // A pathological box (an infinite/NaN coordinate) would spin here; bail to
-        // the linear answer instead of hanging the frame.
-        if (!Number.isFinite(minCx) || !Number.isFinite(maxCx) || !Number.isFinite(minCy) || !Number.isFinite(maxCy)) {
-            return this.all();
-        }
-        for (let cx = minCx; cx <= maxCx; cx++) {
-            for (let cy = minCy; cy <= maxCy; cy++) {
-                const bucket = this.cells.get(ObstacleIndex.key(cx, cy));
-                if (!bucket)
-                    continue;
-                for (const o of bucket) {
-                    if (seen.has(o))
-                        continue;
-                    seen.add(o);
-                    out.push(o);
-                }
-            }
-        }
-        return out;
-    }
-    /** Every indexed obstacle (deduplicated). Escape hatch for degenerate queries. */
-    all() {
-        const seen = new Set(this.oversized);
-        for (const bucket of this.cells.values())
-            for (const o of bucket)
-                seen.add(o);
-        return [...seen];
-    }
-}
-exports.ObstacleIndex = ObstacleIndex;
-/**
- * Merge two obstacle sources into one array, collapsing entries that are the
- * SAME obstacle described twice.
- *
- * This exists because `RoutingEngine.route()` unions its global ObstacleMap with
- * the request's obstacles, and the renderer's request repeats what the engine
- * already registered — so a 5,000-node diagram was handing the router a
- * 9,998-entry obstacle array, and every one of those entries was scanned on
- * every collision test. Deduplication is keyed on id AND geometry, so two
- * entries that genuinely disagree about where an obstacle is are both kept:
- * the effective blocked region is unchanged.
- */
-function mergeObstacles(a, b) {
-    if (a.length === 0)
-        return b;
-    if (b.length === 0)
-        return a;
-    const out = [];
-    const seen = new Set();
-    for (const src of [a, b]) {
-        for (const o of src) {
-            if (!o)
-                continue;
-            const k = `${o.id}|${o.x}|${o.y}|${o.width}|${o.height}`;
-            if (seen.has(k))
-                continue;
-            seen.add(k);
-            out.push(o);
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=ObstacleIndex.js.map

package/src/libs/engine/src/routing/ObstacleMap.d.ts

@@ -1,68 +0,0 @@
-import type { Obstacle, Rectangle } from './types';
-import type { Point } from '../types';
-/**
- * ObstacleMap manages spatial indexing of obstacles for efficient queries
- * Uses a simple grid-based spatial index for O(1) lookups
- */
-export declare class ObstacleMap {
-    private obstacles;
-    private gridCellSize;
-    private spatialGrid;
-    /**
-     * Get number of obstacles in the map
-     */
-    size(): number;
-    /**
-     * Add an obstacle to the map
-     */
-    add(obstacle: Obstacle): void;
-    /**
-     * Remove an obstacle from the map
-     */
-    remove(id: string): boolean;
-    /**
-     * Get an obstacle by ID
-     */
-    get(id: string): Obstacle | undefined;
-    /**
-     * Update an obstacle (remove and re-add to update spatial index)
-     */
-    update(obstacle: Obstacle): void;
-    /**
-     * Clear all obstacles
-     */
-    clear(): void;
-    /**
-     * Query obstacles in a rectangular region
-     */
-    queryRegion(region: Rectangle): Obstacle[];
-    /**
-     * Query obstacles near a point within a given radius
-     */
-    queryNearPoint(point: Point, radius: number): Obstacle[];
-    /**
-     * Query obstacles along a line segment
-     */
-    queryLine(start: Point, end: Point): Obstacle[];
-    /**
-     * Get all obstacles as an array (Phase 1.6b)
-     */
-    getObstacles(): Obstacle[];
-    /**
-     * Check if a point is inside any obstacle
-     */
-    isPointInside(point: Point, respectMargin?: boolean): boolean;
-    /**
-     * Check if a line segment intersects any obstacle
-     */
-    doesLineIntersect(start: Point, end: Point, margin?: number): boolean;
-    private addToSpatialGrid;
-    private removeFromSpatialGrid;
-    private getOverlappingCells;
-    private rectanglesOverlap;
-    private pointInRectangle;
-    private lineIntersectsRectangle;
-    private lineSegmentsIntersect;
-    private getObstacleCenter;
-    private distance;
-}

package/src/libs/engine/src/routing/ObstacleMap.js

@@ -1,312 +0,0 @@
-"use strict";
-// ObstacleMap - Spatial indexing for efficient obstacle queries
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObstacleMap = void 0;
-/**
- * ObstacleMap manages spatial indexing of obstacles for efficient queries
- * Uses a simple grid-based spatial index for O(1) lookups
- */
-class ObstacleMap {
-    constructor() {
-        this.obstacles = new Map();
-        this.gridCellSize = 100; // Grid cell size for spatial indexing
-        this.spatialGrid = new Map();
-    }
-    /**
-     * Get number of obstacles in the map
-     */
-    size() {
-        return this.obstacles.size;
-    }
-    /**
-     * Add an obstacle to the map
-     */
-    add(obstacle) {
-        this.obstacles.set(obstacle.id, obstacle);
-        this.addToSpatialGrid(obstacle);
-    }
-    /**
-     * Remove an obstacle from the map
-     */
-    remove(id) {
-        const obstacle = this.obstacles.get(id);
-        if (!obstacle) {
-            return false;
-        }
-        this.removeFromSpatialGrid(obstacle);
-        return this.obstacles.delete(id);
-    }
-    /**
-     * Get an obstacle by ID
-     */
-    get(id) {
-        return this.obstacles.get(id);
-    }
-    /**
-     * Update an obstacle (remove and re-add to update spatial index)
-     */
-    update(obstacle) {
-        this.remove(obstacle.id);
-        this.add(obstacle);
-    }
-    /**
-     * Clear all obstacles
-     */
-    clear() {
-        this.obstacles.clear();
-        this.spatialGrid.clear();
-    }
-    /**
-     * Query obstacles in a rectangular region
-     */
-    queryRegion(region) {
-        const result = [];
-        const seen = new Set();
-        // Get all grid cells that overlap the region
-        const cells = this.getOverlappingCells(region);
-        for (const cellKey of cells) {
-            const obstacleIds = this.spatialGrid.get(cellKey);
-            if (!obstacleIds)
-                continue;
-            for (const id of obstacleIds) {
-                if (seen.has(id))
-                    continue;
-                seen.add(id);
-                const obstacle = this.obstacles.get(id);
-                if (obstacle && this.rectanglesOverlap(region, obstacle)) {
-                    result.push(obstacle);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Query obstacles near a point within a given radius
-     */
-    queryNearPoint(point, radius) {
-        const region = {
-            x: point.x - radius,
-            y: point.y - radius,
-            width: radius * 2,
-            height: radius * 2,
-        };
-        return this.queryRegion(region).filter((obstacle) => {
-            const center = this.getObstacleCenter(obstacle);
-            const distance = this.distance(point, center);
-            return distance <= radius;
-        });
-    }
-    /**
-     * Query obstacles along a line segment
-     */
-    queryLine(start, end) {
-        // Create bounding box for the line
-        const minX = Math.min(start.x, end.x);
-        const minY = Math.min(start.y, end.y);
-        const maxX = Math.max(start.x, end.x);
-        const maxY = Math.max(start.y, end.y);
-        const region = {
-            x: minX,
-            y: minY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-        // Get obstacles in bounding box, then filter by line intersection
-        return this.queryRegion(region).filter((obstacle) => {
-            return this.lineIntersectsRectangle(start, end, obstacle);
-        });
-    }
-    /**
-     * Get all obstacles as an array (Phase 1.6b)
-     */
-    getObstacles() {
-        return Array.from(this.obstacles.values());
-    }
-    /**
-     * Check if a point is inside any obstacle
-     */
-    isPointInside(point, respectMargin = false) {
-        var _a;
-        // When respecting margins, we need to query a larger region
-        // to find obstacles whose margins might contain this point
-        const maxMargin = respectMargin ? 100 : 1; // Assume max margin of 100px
-        const nearby = this.queryRegion({
-            x: point.x - maxMargin,
-            y: point.y - maxMargin,
-            width: maxMargin * 2,
-            height: maxMargin * 2,
-        });
-        for (const obstacle of nearby) {
-            const margin = respectMargin ? ((_a = obstacle.margin) !== null && _a !== void 0 ? _a : 0) : 0;
-            const expanded = {
-                x: obstacle.x - margin,
-                y: obstacle.y - margin,
-                width: obstacle.width + margin * 2,
-                height: obstacle.height + margin * 2,
-            };
-            if (this.pointInRectangle(point, expanded)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if a line segment intersects any obstacle
-     */
-    doesLineIntersect(start, end, margin = 0) {
-        // Expand query region by margin to catch nearby obstacles
-        const minX = Math.min(start.x, end.x) - margin;
-        const minY = Math.min(start.y, end.y) - margin;
-        const maxX = Math.max(start.x, end.x) + margin;
-        const maxY = Math.max(start.y, end.y) + margin;
-        const expandedRegion = {
-            x: minX,
-            y: minY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-        // Query obstacles in expanded region
-        const obstacles = this.queryRegion(expandedRegion);
-        for (const obstacle of obstacles) {
-            const expanded = {
-                x: obstacle.x - margin,
-                y: obstacle.y - margin,
-                width: obstacle.width + margin * 2,
-                height: obstacle.height + margin * 2,
-            };
-            if (this.lineIntersectsRectangle(start, end, expanded)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    // ========================================
-    // Private Helper Methods
-    // ========================================
-    addToSpatialGrid(obstacle) {
-        const cells = this.getOverlappingCells(obstacle);
-        for (const cellKey of cells) {
-            if (!this.spatialGrid.has(cellKey)) {
-                this.spatialGrid.set(cellKey, new Set());
-            }
-            this.spatialGrid.get(cellKey).add(obstacle.id);
-        }
-    }
-    removeFromSpatialGrid(obstacle) {
-        const cells = this.getOverlappingCells(obstacle);
-        for (const cellKey of cells) {
-            const cell = this.spatialGrid.get(cellKey);
-            if (cell) {
-                cell.delete(obstacle.id);
-                if (cell.size === 0) {
-                    this.spatialGrid.delete(cellKey);
-                }
-            }
-        }
-    }
-    getOverlappingCells(rect) {
-        const cells = [];
-        const minCellX = Math.floor(rect.x / this.gridCellSize);
-        const minCellY = Math.floor(rect.y / this.gridCellSize);
-        const maxCellX = Math.floor((rect.x + rect.width) / this.gridCellSize);
-        const maxCellY = Math.floor((rect.y + rect.height) / this.gridCellSize);
-        for (let x = minCellX; x <= maxCellX; x++) {
-            for (let y = minCellY; y <= maxCellY; y++) {
-                cells.push(`${x},${y}`);
-            }
-        }
-        return cells;
-    }
-    rectanglesOverlap(a, b) {
-        return !(a.x + a.width < b.x ||
-            b.x + b.width < a.x ||
-            a.y + a.height < b.y ||
-            b.y + b.height < a.y);
-    }
-    pointInRectangle(point, rect) {
-        return (point.x >= rect.x &&
-            point.x <= rect.x + rect.width &&
-            point.y >= rect.y &&
-            point.y <= rect.y + rect.height);
-    }
-    lineIntersectsRectangle(start, end, rect) {
-        // Check if either endpoint is inside the rectangle
-        if (this.pointInRectangle(start, rect) || this.pointInRectangle(end, rect)) {
-            return true;
-        }
-        // Check if line's bounding box overlaps with rectangle
-        const lineMinX = Math.min(start.x, end.x);
-        const lineMaxX = Math.max(start.x, end.x);
-        const lineMinY = Math.min(start.y, end.y);
-        const lineMaxY = Math.max(start.y, end.y);
-        const rectMinX = rect.x;
-        const rectMaxX = rect.x + rect.width;
-        const rectMinY = rect.y;
-        const rectMaxY = rect.y + rect.height;
-        // No overlap if bounding boxes don't intersect
-        if (lineMaxX < rectMinX || lineMinX > rectMaxX ||
-            lineMaxY < rectMinY || lineMinY > rectMaxY) {
-            return false;
-        }
-        // Check if line intersects any of the four edges
-        const corners = [
-            { x: rect.x, y: rect.y },
-            { x: rect.x + rect.width, y: rect.y },
-            { x: rect.x + rect.width, y: rect.y + rect.height },
-            { x: rect.x, y: rect.y + rect.height },
-        ];
-        for (let i = 0; i < 4; i++) {
-            const c1 = corners[i];
-            const c2 = corners[(i + 1) % 4];
-            if (this.lineSegmentsIntersect(start, end, c1, c2)) {
-                return true;
-            }
-        }
-        // If bounding boxes overlap but no edge intersections found, assume no collision
-        return false;
-    }
-    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);
-        };
-        const d1 = ccw(b1, b2, a1);
-        const d2 = ccw(b1, b2, a2);
-        const d3 = ccw(a1, a2, b1);
-        const d4 = ccw(a1, a2, b2);
-        // Standard intersection check
-        if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
-            ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
-            return true;
-        }
-        // Check for colinear overlapping segments
-        if (d1 === 0 && d2 === 0 && d3 === 0 && d4 === 0) {
-            // Segments are colinear, check if they overlap
-            const overlap1D = (min1, max1, min2, max2) => {
-                return Math.max(min1, min2) <= Math.min(max1, max2);
-            };
-            const a1x = Math.min(a1.x, a2.x);
-            const a2x = Math.max(a1.x, a2.x);
-            const a1y = Math.min(a1.y, a2.y);
-            const a2y = Math.max(a1.y, a2.y);
-            const b1x = Math.min(b1.x, b2.x);
-            const b2x = Math.max(b1.x, b2.x);
-            const b1y = Math.min(b1.y, b2.y);
-            const b2y = Math.max(b1.y, b2.y);
-            return overlap1D(a1x, a2x, b1x, b2x) && overlap1D(a1y, a2y, b1y, b2y);
-        }
-        return false;
-    }
-    getObstacleCenter(obstacle) {
-        return {
-            x: obstacle.x + obstacle.width / 2,
-            y: obstacle.y + obstacle.height / 2,
-        };
-    }
-    distance(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-}
-exports.ObstacleMap = ObstacleMap;
-//# sourceMappingURL=ObstacleMap.js.map

package/src/libs/engine/src/routing/ObstacleMapBuilder.d.ts

@@ -1,28 +0,0 @@
-import type { DiagramModel } from '../models/DiagramModel';
-import { ObstacleMap } from './ObstacleMap';
-export interface ObstacleMapOptions {
-    /** Margin to add around each obstacle */
-    margin?: number;
-}
-/**
- * ObstacleMapBuilder creates ObstacleMap from DiagramModel
- * Uses global bounds to account for transforms and hierarchy
- */
-export declare class ObstacleMapBuilder {
-    /**
-     * Build obstacle map from all nodes in diagram (Phase 1.6b)
-     * @param diagram The diagram model
-     * @param options Options for obstacle creation
-     * @returns ObstacleMap containing all diagram nodes as obstacles
-     */
-    static fromDiagram(diagram: DiagramModel, options?: ObstacleMapOptions): ObstacleMap;
-    /**
-     * Build obstacle map excluding specific nodes (Phase 1.6b)
-     * Useful for routing where source/target nodes should not be obstacles
-     * @param diagram The diagram model
-     * @param excludeIds Node IDs to exclude from obstacles
-     * @param options Options for obstacle creation
-     * @returns ObstacleMap containing diagram nodes except excluded ones
-     */
-    static fromDiagramExcluding(diagram: DiagramModel, excludeIds: string[], options?: ObstacleMapOptions): ObstacleMap;
-}

package/src/libs/engine/src/routing/ObstacleMapBuilder.js

@@ -1,76 +0,0 @@
-"use strict";
-// ObstacleMapBuilder - Builds ObstacleMap from DiagramModel (Phase 1.6b)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObstacleMapBuilder = void 0;
-const ObstacleMap_1 = require("./ObstacleMap");
-/**
- * ObstacleMapBuilder creates ObstacleMap from DiagramModel
- * Uses global bounds to account for transforms and hierarchy
- */
-class ObstacleMapBuilder {
-    /**
-     * Build obstacle map from all nodes in diagram (Phase 1.6b)
-     * @param diagram The diagram model
-     * @param options Options for obstacle creation
-     * @returns ObstacleMap containing all diagram nodes as obstacles
-     */
-    static fromDiagram(diagram, options = {}) {
-        var _a;
-        const map = new ObstacleMap_1.ObstacleMap();
-        const margin = (_a = options.margin) !== null && _a !== void 0 ? _a : 0;
-        for (const node of diagram.getNodes()) {
-            // Skip if explicitly marked as non-obstacle
-            if (node.getData('isObstacle') === false) {
-                continue;
-            }
-            // Use global bounds (accounts for transforms and hierarchy)
-            const bounds = node.getGlobalBounds();
-            const obstacle = {
-                id: node.id,
-                x: bounds.left - margin,
-                y: bounds.top - margin,
-                width: bounds.width + margin * 2,
-                height: bounds.height + margin * 2,
-            };
-            map.add(obstacle);
-        }
-        return map;
-    }
-    /**
-     * Build obstacle map excluding specific nodes (Phase 1.6b)
-     * Useful for routing where source/target nodes should not be obstacles
-     * @param diagram The diagram model
-     * @param excludeIds Node IDs to exclude from obstacles
-     * @param options Options for obstacle creation
-     * @returns ObstacleMap containing diagram nodes except excluded ones
-     */
-    static fromDiagramExcluding(diagram, excludeIds, options = {}) {
-        var _a;
-        const map = new ObstacleMap_1.ObstacleMap();
-        const margin = (_a = options.margin) !== null && _a !== void 0 ? _a : 0;
-        const excludeSet = new Set(excludeIds);
-        for (const node of diagram.getNodes()) {
-            // Skip excluded nodes
-            if (excludeSet.has(node.id)) {
-                continue;
-            }
-            // Skip if explicitly marked as non-obstacle
-            if (node.getData('isObstacle') === false) {
-                continue;
-            }
-            // Use global bounds (accounts for transforms and hierarchy)
-            const bounds = node.getGlobalBounds();
-            const obstacle = {
-                id: node.id,
-                x: bounds.left - margin,
-                y: bounds.top - margin,
-                width: bounds.width + margin * 2,
-                height: bounds.height + margin * 2,
-            };
-            map.add(obstacle);
-        }
-        return map;
-    }
-}
-exports.ObstacleMapBuilder = ObstacleMapBuilder;
-//# sourceMappingURL=ObstacleMapBuilder.js.map