@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/layout/CompoundLayoutService.js

@@ -0,0 +1,616 @@
+"use strict";
+// CompoundLayoutService — Wave-5 Card 5, rebuilt for Wave-7 Card 4 (nested
+// container / subgraph layout).
+//
+// ---------------------------------------------------------------------------
+// WHAT WAVE 5 SHIPPED, AND WHAT IT DID NOT (the audit)
+// ---------------------------------------------------------------------------
+//
+// Wave 5 built the bottom-up skeleton and it was sound: deepest-first, each
+// group's direct nodes + child-group unit boxes arranged by its own algorithm,
+// child groups translated as whole subtrees, parents fitted around them. It was
+// also verified against the real dagre adapter. All of that survives.
+//
+// But it was NEVER CALLED. Not by the engine, not by a command, not by the
+// renderer — only by its own spec (`grep -rn CompoundLayoutService libs apps`
+// returned the file, the spec, and an `export *`). So the nested-layout stack
+// was dead for the SECOND time: wave 5 found `SubgraphLayoutManager` dead
+// because nothing built `GroupInfo.memberNodeIds`, built this service as the
+// bridge — and then nothing called the bridge either. Card 4 wires it to
+// `engine.layout()`, which is now the only entry point that exists.
+//
+// Four things were genuinely missing, and each is a visible bug:
+//
+//   1. CROSS-CONTAINER EDGES WERE INVISIBLE AT THE ROOT. `layoutTopLevel()`
+//      called `adapter.apply(units, [], {})` — an empty link array. Containers
+//      at the top level were therefore arranged with ZERO knowledge of the
+//      edges between them: A→B and A↛B produced the same picture, and the
+//      cross edge flapped across the diagram. This is precisely the sub-flow
+//      failure React Flow is known for. Per-group levels DID induce edges
+//      (`buildUnitLinks`), so the machinery existed — the root just never used
+//      it. Both levels now go through ONE `arrangeLevel()`; see INDUCED EDGES.
+//
+//   2. A COLLAPSED GROUP WAS TREATED AS A CONTAINER. Collapse hides members but
+//      leaves them in `group.members`, so layout re-arranged the hidden nodes
+//      and `fitToContents` then re-inflated the placeholder frame back to full
+//      size — one layout pass silently un-collapsed every collapsed group. A
+//      collapsed group is a LEAF (the routing track already treats it as one
+//      solid obstacle); it is now placed, never entered.
+//
+//   3. THE COLLAPSE PROXY NODE WAS ORPHANED. On collapse, wave 5 re-homes every
+//      boundary-crossing edge onto a proxy placeholder node. `buildUnitLinks`
+//      could not resolve that proxy to any unit, so a collapsed container
+//      contributed NO edges at all — and `translateSubtree` did not move the
+//      proxy either, so placing a collapsed container left its only visible box
+//      behind at the old coordinates. One fix closes both: a group's subtree now
+//      includes the proxy nodes of the collapsed groups within it.
+//
+//   4. `fixed` GROUPS COULD BE OVERLAPPED. Wave 5's honest scope-down: a fixed
+//      group was excluded from the unit set entirely, so the parent arranged the
+//      other units straight through it. Fixed groups are now real units in the
+//      layout input (their edges count) and are pinned afterwards, with a
+//      guaranteed-terminating separation pass. See FIXED CONTAINERS.
+//
+// And one that would have poisoned everything: the level's unit order came from
+// `group.members` (a Set — insertion order) and `diagram.getLinks()` (unsorted),
+// so the same graph built in a different order laid out differently. Card 0
+// established canonical input ordering for exactly this reason; the compound
+// path now obeys it at every depth.
+//
+// ---------------------------------------------------------------------------
+// INDUCED EDGES — the crux of the card
+// ---------------------------------------------------------------------------
+//
+// An edge from a node inside container A to a node inside container B must be
+// seen by the layout that positions A and B — i.e. at their LOWEST COMMON
+// ANCESTOR, and nowhere else. So at every level we project each real edge onto
+// the units of THAT level:
+//
+//   resolveUnit(level, nodeId) =
+//     nodeId                        if it is a direct node member of the level
+//     the child container of the level whose SUBTREE contains it   (any depth)
+//     undefined                     if it is outside the level entirely
+//
+// An edge is induced onto the level iff both ends resolve to units and the units
+// DIFFER. Consequences, all of them the behaviour we want:
+//
+//   • a→b inside one container       → both ends resolve to that container, so it
+//                                      is dropped at the parent (su === tu) and
+//                                      handled INSIDE the container. Right.
+//   • deep-A → deep-B, siblings      → induced A→B at the parent. The containers
+//                                      land next to each other. Right.
+//   • deep-A → loose root node       → drops out of A's own level (the far end is
+//                                      not a unit of A) and reappears at the root,
+//                                      where A is a unit and the loose node is a
+//                                      unit. Induced exactly once, at the LCA.
+//   • depth is irrelevant            → `subtreeNodeIds` recurses, so an edge from
+//                                      depth 4 induces onto the depth-1 container.
+//
+// Parallel edges between the same unit pair collapse to one induced edge (dagre
+// would rank the pair identically anyway); direction is preserved, so A→B and
+// B→A stay distinct and the flow direction survives.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompoundLayoutService = void 0;
+const tslib_1 = require("tslib");
+const NodeModel_1 = require("../models/NodeModel");
+const LinkModel_1 = require("../models/LinkModel");
+const layout_registry_1 = require("./layout-registry");
+/** Ids sort ascending — canonical input order, at every depth (Card 0). */
+const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+class CompoundLayoutService {
+    constructor(diagram, options = {}) {
+        this.diagram = diagram;
+        this.options = options;
+    }
+    /** Run the compound layout over the whole diagram. */
+    layout() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const result = {
+                laidOut: [],
+                skipped: [],
+                collapsed: [],
+                groupBounds: new Map(),
+                nodePositions: new Map(),
+                bounds: { x: 0, y: 0, width: 0, height: 0 },
+            };
+            // Deepest-first: a parent is laid out only after its children are fitted.
+            // Sorted by id FIRST so that ties in depth resolve identically no matter
+            // what order the groups were added in (Array.prototype.sort is stable).
+            const groups = this.diagram
+                .getGroups()
+                .slice()
+                .sort(byId)
+                .sort((a, b) => this.diagram.getDepth(b.id) - this.diagram.getDepth(a.id));
+            for (const group of groups) {
+                // Inside a collapsed container: everything here is hidden and its geometry
+                // is owned by the collapse snapshot, which expand() restores verbatim.
+                // Laying it out would be work nobody can see, on coordinates that get
+                // overwritten. Don't enter a collapsed container.
+                if (this.hasCollapsedAncestor(group)) {
+                    result.skipped.push(group.id);
+                    result.groupBounds.set(group.id, group.getOuterBounds());
+                    continue;
+                }
+                // A collapsed group is a LEAF. It gets PLACED by its parent (its unit box
+                // is the placeholder), but never entered and never re-fitted — fitting it
+                // would inflate the placeholder back around the hidden members and undo
+                // the collapse.
+                if (group.isCollapsed) {
+                    result.collapsed.push(group.id);
+                    result.skipped.push(group.id);
+                    result.groupBounds.set(group.id, group.getOuterBounds());
+                    continue;
+                }
+                if (this.isFixed(group)) {
+                    result.skipped.push(group.id);
+                    // A fixed group is still fitted so parents see a correct box, unless it
+                    // already has an explicit frame.
+                    if (!group.size) {
+                        this.applyDefaultPadding(group);
+                        group.fitToContents(this.diagram);
+                    }
+                    result.groupBounds.set(group.id, group.getOuterBounds());
+                    continue;
+                }
+                yield this.arrangeLevel(this.buildLevel(group));
+                this.applyDefaultPadding(group);
+                group.fitToContents(this.diagram);
+                result.laidOut.push(group.id);
+                result.groupBounds.set(group.id, group.getOuterBounds());
+            }
+            if (this.options.layoutTopLevel) {
+                yield this.arrangeLevel(this.buildLevel(null));
+                // Root containers moved, so refresh the bounds we report for them.
+                for (const group of groups) {
+                    result.groupBounds.set(group.id, group.getOuterBounds());
+                }
+            }
+            this.collectResult(result);
+            return result;
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // One level — used for a container's interior AND for the root. Wave 5 had two
+    // near-copies of this, and the root copy is the one that forgot the edges.
+    // ---------------------------------------------------------------------------
+    /** Gather the units of a level, in canonical order. */
+    buildLevel(group) {
+        const memberNodes = [];
+        const childGroups = [];
+        if (group) {
+            for (const id of group.members) {
+                const node = this.diagram.getNode(id);
+                if (node) {
+                    memberNodes.push(node);
+                    continue;
+                }
+                const child = this.diagram.getGroup(id);
+                if (child)
+                    childGroups.push(child);
+            }
+        }
+        else {
+            // Top level: root containers + nodes that belong to no container at all.
+            // Proxy placeholders are excluded — a proxy is not a loose node, it IS its
+            // collapsed container, and the container is already a unit here.
+            const grouped = new Set();
+            for (const g of this.diagram.getGroups()) {
+                for (const nid of this.subtreeNodeIds(g))
+                    grouped.add(nid);
+            }
+            for (const node of this.diagram.getNodes()) {
+                if (!grouped.has(node.id) && !this.diagram.isProxyNode(node))
+                    memberNodes.push(node);
+            }
+            for (const g of this.diagram.getGroups()) {
+                if (!g.parentGroupId)
+                    childGroups.push(g);
+            }
+        }
+        memberNodes.sort(byId);
+        childGroups.sort(byId);
+        return {
+            group,
+            memberNodes,
+            movableChildren: childGroups.filter((g) => !this.isFixed(g)),
+            fixedChildren: childGroups.filter((g) => this.isFixed(g)),
+        };
+    }
+    /** Arrange one level's units and commit their positions. */
+    arrangeLevel(level) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (level.memberNodes.length + level.movableChildren.length === 0) {
+                return;
+            }
+            const positions = yield this.arrangeUnits(level);
+            this.pinFixedUnits(level, positions);
+            this.applyUnitPositions(level, positions);
+        });
+    }
+    /**
+     * Arrange the units of a level and return TOP-LEFT positions by unit id. The
+     * adapter is a black box: feed it nodes + induced links, read back the map.
+     */
+    arrangeUnits(level) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const algo = this.resolveAlgorithm(level.group);
+            // Fixed containers ARE units in the layout input — their edges have to count
+            // (that is how the movable units learn to sit near what they connect to).
+            // They are pinned back to their true positions afterwards.
+            const containers = [...level.movableChildren, ...level.fixedChildren].sort(byId);
+            const unitNodes = [...level.memberNodes, ...containers.map((c) => standIn(c))];
+            const adapter = algo === 'grid' ? undefined : (_a = this.options.adapters) === null || _a === void 0 ? void 0 : _a[algo];
+            if (!adapter) {
+                // Built-in grid (also the fallback when a requested adapter isn't wired).
+                return this.gridArrange(unitNodes);
+            }
+            const unitLinks = this.buildUnitLinks(level);
+            const res = yield adapter.apply(unitNodes, unitLinks, (0, layout_registry_1.translateOptions)(algo, this.resolveLayoutOptions(level.group)));
+            // Trust only the returned map (black box) — never the adapter's own writes.
+            const out = new Map();
+            for (const [id, pos] of res.nodePositions) {
+                out.set(id, { x: pos.x, y: pos.y });
+            }
+            // Any unit the adapter didn't place keeps its current top-left.
+            for (const n of unitNodes) {
+                if (!out.has(n.id))
+                    out.set(n.id, { x: n.position.x, y: n.position.y });
+            }
+            return out;
+        });
+    }
+    /**
+     * INDUCED EDGES. Project every real link onto this level's units, keeping only
+     * the ones whose ends land on two DIFFERENT units. See the header — this is
+     * the whole point of the card, and the root level used to skip it entirely.
+     */
+    buildUnitLinks(level) {
+        const directNodeIds = new Set(level.memberNodes.map((n) => n.id));
+        // node id → the unit (container) of THIS level that contains it, at any
+        // depth. Fixed containers are included: an edge to a pinned container still
+        // tells the layout where the other end wants to be.
+        const nodeToUnit = new Map();
+        for (const container of [...level.movableChildren, ...level.fixedChildren]) {
+            for (const nid of this.subtreeNodeIds(container)) {
+                nodeToUnit.set(nid, container.id);
+            }
+        }
+        const resolveUnit = (nodeId) => {
+            if (!nodeId)
+                return undefined;
+            if (directNodeIds.has(nodeId))
+                return nodeId;
+            return nodeToUnit.get(nodeId);
+        };
+        const endpointNodeId = (nodeId, portId) => { var _a; return nodeId !== null && nodeId !== void 0 ? nodeId : (portId ? (_a = this.diagram.getNodeByPortId(portId)) === null || _a === void 0 ? void 0 : _a.id : undefined); };
+        const seen = new Set();
+        const out = [];
+        // Canonical link order — the adapter's output depends on input order.
+        for (const link of [...this.diagram.getLinks()].sort(byId)) {
+            const su = resolveUnit(endpointNodeId(link.sourceNodeId, link.sourcePortId));
+            const tu = resolveUnit(endpointNodeId(link.targetNodeId, link.targetPortId));
+            if (!su || !tu || su === tu)
+                continue;
+            const key = `${su}->${tu}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const l = new LinkModel_1.LinkModel('', '');
+            l.sourceNodeId = su;
+            l.targetNodeId = tu;
+            out.push(l);
+        }
+        return out;
+    }
+    // ---------------------------------------------------------------------------
+    // FIXED CONTAINERS
+    //
+    // Wave 5's scope-down: "fixed groups are pinned but the parent arranges only
+    // non-fixed units around them, so overlap with a fixed group is possible."
+    // Closed, in two steps:
+    //
+    //   1. The fixed container is a real unit in the layout input, so the engine
+    //      sizes a hole for it and routes the other units around it. We then snap
+    //      it back to its true position and translate the whole arrangement by the
+    //      same delta — with ONE fixed container that lands the arrangement exactly
+    //      around it, overlap-free by construction, because the engine already
+    //      separated its nodes.
+    //
+    //   2. With SEVERAL fixed containers the engine's relative placement of them
+    //      cannot match reality (they are pinned at arbitrary spots), so overlap is
+    //      still possible. A separation pass then translates the whole movable
+    //      arrangement — never individual units, which would shred the engine's
+    //      work — by the smallest displacement that clears the collision, and
+    //      repeats. It terminates: the loop is bounded, and the fallback (park the
+    //      arrangement clear below every fixed box) is unconditionally overlap-free.
+    //
+    // WHAT `fixed` MEANS, precisely: pinned WITHIN ITS PARENT'S ARRANGEMENT. The
+    // parent never rearranges it and never lays out its interior — but the parent
+    // does still CARRY it, rigidly, when the parent itself moves. It has to: a
+    // child that refused to follow its parent would end up outside the parent's
+    // frame, which is not something a container can mean. So a fixed ROOT container
+    // is pinned in world coordinates (nothing above it to carry it), and a fixed
+    // CHILD keeps its offset inside its parent. Both are covered by the spec.
+    // ---------------------------------------------------------------------------
+    pinFixedUnits(level, positions) {
+        var _a;
+        if (level.fixedChildren.length === 0)
+            return;
+        const fixedBoxes = level.fixedChildren
+            .slice()
+            .sort(byId)
+            .map((g) => (Object.assign({ id: g.id }, g.getOuterBounds())));
+        // Step 1 — anchor the arrangement on the first fixed container: shift
+        // everything so that container lands on its real, pinned position.
+        const anchor = fixedBoxes[0];
+        const placed = positions.get(anchor.id);
+        if (placed) {
+            const dx = anchor.x - placed.x;
+            const dy = anchor.y - placed.y;
+            if (dx !== 0 || dy !== 0) {
+                for (const [id, p] of positions) {
+                    positions.set(id, { x: p.x + dx, y: p.y + dy });
+                }
+            }
+        }
+        // Fixed units are never placed by the layout — restore their true corners.
+        for (const box of fixedBoxes) {
+            positions.set(box.id, { x: box.x, y: box.y });
+        }
+        // Step 2 — separate. Only the movable units may move.
+        const movable = [
+            ...level.memberNodes.map((n) => ({ id: n.id, w: n.size.width, h: n.size.height })),
+            ...level.movableChildren.map((g) => {
+                const b = g.getOuterBounds();
+                return { id: g.id, w: Math.max(1, b.width), h: Math.max(1, b.height) };
+            }),
+        ].sort((a, b) => (a.id < b.id ? -1 : 1));
+        const boxOf = (u) => {
+            var _a;
+            const p = (_a = positions.get(u.id)) !== null && _a !== void 0 ? _a : { x: 0, y: 0 };
+            return { x: p.x, y: p.y, width: u.w, height: u.h };
+        };
+        const shift = (dx, dy) => {
+            for (const u of movable) {
+                const p = positions.get(u.id);
+                if (p)
+                    positions.set(u.id, { x: p.x + dx, y: p.y + dy });
+            }
+        };
+        const MAX_PASSES = 16;
+        for (let pass = 0; pass < MAX_PASSES; pass++) {
+            // Smallest escape among all (movable unit × fixed box) collisions.
+            let best;
+            for (const u of movable) {
+                const ub = boxOf(u);
+                for (const fb of fixedBoxes) {
+                    const mtv = minimumTranslation(ub, fb);
+                    if (!mtv)
+                        continue;
+                    const mag = Math.abs(mtv.dx) + Math.abs(mtv.dy);
+                    if (!best || mag < best.mag)
+                        best = Object.assign(Object.assign({}, mtv), { mag });
+                }
+            }
+            if (!best)
+                return; // clear
+            shift(best.dx, best.dy);
+        }
+        // Fallback: still colliding after the bounded search (pathological pinning).
+        // Park the whole arrangement below every fixed box — ugly, but the invariant
+        // "no unit overlaps a fixed container" holds unconditionally.
+        let stillColliding = false;
+        for (const u of movable) {
+            const ub = boxOf(u);
+            if (fixedBoxes.some((fb) => minimumTranslation(ub, fb))) {
+                stillColliding = true;
+                break;
+            }
+        }
+        if (!stillColliding)
+            return;
+        const fixedBottom = Math.max(...fixedBoxes.map((fb) => fb.y + fb.height));
+        const movableTop = Math.min(...movable.map((u) => boxOf(u).y));
+        shift(0, fixedBottom + ((_a = this.options.gridGap) !== null && _a !== void 0 ? _a : 40) - movableTop);
+    }
+    /** Apply arranged unit positions: move nodes; translate child subtrees. */
+    applyUnitPositions(level, positions) {
+        for (const node of level.memberNodes) {
+            const p = positions.get(node.id);
+            // setPosition (not a raw write) so the spatial index and the routing
+            // obstacle map see the move.
+            if (p)
+                node.setPosition(p.x, p.y);
+        }
+        for (const child of level.movableChildren) {
+            const p = positions.get(child.id);
+            if (!p)
+                continue;
+            const cur = child.getOuterBounds();
+            const dx = p.x - cur.x;
+            const dy = p.y - cur.y;
+            if (dx !== 0 || dy !== 0) {
+                this.translateSubtree(child, dx, dy);
+            }
+        }
+    }
+    /** Shift a group and everything inside it (nodes + nested groups) by (dx,dy). */
+    translateSubtree(group, dx, dy) {
+        // subtreeNodeIds includes the proxy placeholder of any collapsed group in
+        // the subtree — without it, placing a collapsed container moved the frame
+        // and the hidden members but left the only VISIBLE box behind.
+        for (const nid of this.subtreeNodeIds(group)) {
+            const node = this.diagram.getNode(nid);
+            if (node)
+                node.setPosition(node.position.x + dx, node.position.y + dy);
+        }
+        // Move the group frame(s) too (self + descendant groups).
+        const groupsToMove = [group, ...this.diagram.getDescendants(group.id)];
+        for (const g of groupsToMove) {
+            const b = g.getOuterBounds();
+            g.setFrame({ x: b.x + dx, y: b.y + dy, width: b.width, height: b.height });
+        }
+    }
+    /**
+     * All node ids inside a group's subtree (direct + nested), PLUS the collapse
+     * placeholder of every collapsed group within it.
+     *
+     * The proxy is not a member of the group it stands for — collapse just adds it
+     * to the diagram — but it is geometrically and semantically INSIDE it: it is
+     * the container's visible box, and every edge that crossed the container's
+     * boundary now terminates on it. So for both purposes this set serves —
+     * translating a subtree, and resolving an edge endpoint to a unit — the proxy
+     * belongs to its group.
+     */
+    subtreeNodeIds(group) {
+        const out = new Set();
+        const walk = (g) => {
+            var _a;
+            const proxyId = (_a = g.collapsedState) === null || _a === void 0 ? void 0 : _a.proxyNodeId;
+            if (proxyId)
+                out.add(proxyId);
+            for (const id of g.members) {
+                if (this.diagram.getNode(id))
+                    out.add(id);
+                else {
+                    const child = this.diagram.getGroup(id);
+                    if (child)
+                        walk(child);
+                }
+            }
+        };
+        walk(group);
+        return out;
+    }
+    /** Deterministic grid over units by their size; returns TOP-LEFT positions. */
+    gridArrange(units) {
+        var _a;
+        const gap = (_a = this.options.gridGap) !== null && _a !== void 0 ? _a : 40;
+        const cols = Math.max(1, Math.ceil(Math.sqrt(units.length)));
+        // Uniform cell = max unit size, so boxes never overlap regardless of order.
+        const cellW = Math.max(1, ...units.map((u) => u.size.width));
+        const cellH = Math.max(1, ...units.map((u) => u.size.height));
+        const out = new Map();
+        units.forEach((u, i) => {
+            const row = Math.floor(i / cols);
+            const col = i % cols;
+            out.set(u.id, { x: col * (cellW + gap), y: row * (cellH + gap) });
+        });
+        return out;
+    }
+    /** Final positions + overall bounds, for the LayoutResult contract. */
+    collectResult(result) {
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const node of [...this.diagram.getNodes()].sort(byId)) {
+            result.nodePositions.set(node.id, { x: node.position.x, y: node.position.y });
+            minX = Math.min(minX, node.position.x);
+            minY = Math.min(minY, node.position.y);
+            maxX = Math.max(maxX, node.position.x + node.size.width);
+            maxY = Math.max(maxY, node.position.y + node.size.height);
+        }
+        for (const b of result.groupBounds.values()) {
+            minX = Math.min(minX, b.x);
+            minY = Math.min(minY, b.y);
+            maxX = Math.max(maxX, b.x + b.width);
+            maxY = Math.max(maxY, b.y + b.height);
+        }
+        result.bounds = Number.isFinite(minX)
+            ? { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+            : { x: 0, y: 0, width: 0, height: 0 };
+    }
+    // --- per-group config resolution (GroupInfo contract) ----------------------
+    override(group) {
+        var _a;
+        return (_a = this.options.groupOverrides) === null || _a === void 0 ? void 0 : _a[group.id];
+    }
+    isFixed(group) {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.override(group)) === null || _a === void 0 ? void 0 : _a.fixed) !== null && _b !== void 0 ? _b : (_c = group.subgraphLayout) === null || _c === void 0 ? void 0 : _c.fixed) !== null && _d !== void 0 ? _d : false;
+    }
+    /**
+     * Fallback inner padding for a container that carries none of its own.
+     *
+     * `defaultPadding` was DECLARED AND NEVER READ — wave 5 shipped the option and
+     * no consumption site, so it was the same "declared but never consumed" shape
+     * as `GroupInfo.padding` before it. Padding is Card 3's (`GroupModel.padding`,
+     * which `fitToContents` reads), so the fallback has to be established ON the
+     * group before the fit, not smuggled into a parallel padding path.
+     */
+    applyDefaultPadding(group) {
+        const fallback = this.options.defaultPadding;
+        if (fallback === undefined || group.padding !== undefined)
+            return;
+        group.padding = fallback;
+    }
+    /** Is this group inside a container that is currently collapsed? */
+    hasCollapsedAncestor(group) {
+        return this.diagram.getAncestors(group.id).some((a) => a.isCollapsed);
+    }
+    /** null = the top level, which uses the default algorithm. */
+    resolveAlgorithm(group) {
+        var _a, _b, _c, _d, _e, _f;
+        const fallback = (_a = this.options.defaultAlgorithm) !== null && _a !== void 0 ? _a : 'grid';
+        if (!group)
+            return fallback;
+        const raw = (_e = (_c = (_b = this.override(group)) === null || _b === void 0 ? void 0 : _b.layoutAlgorithm) !== null && _c !== void 0 ? _c : (_d = group.subgraphLayout) === null || _d === void 0 ? void 0 : _d.algorithm) !== null && _e !== void 0 ? _e : 'inherit';
+        if (raw === 'inherit' || raw === undefined) {
+            return (_f = this.inheritedAlgorithm(group)) !== null && _f !== void 0 ? _f : fallback;
+        }
+        return raw;
+    }
+    /** Walk up the containment tree for the nearest ancestor's explicit algorithm. */
+    inheritedAlgorithm(group) {
+        var _a, _b, _c;
+        for (const ancestor of this.diagram.getAncestors(group.id)) {
+            const a = (_b = (_a = this.override(ancestor)) === null || _a === void 0 ? void 0 : _a.layoutAlgorithm) !== null && _b !== void 0 ? _b : (_c = ancestor.subgraphLayout) === null || _c === void 0 ? void 0 : _c.algorithm;
+            if (a && a !== 'inherit')
+                return a;
+        }
+        return undefined;
+    }
+    /** Base (unified) options, with this group's own options merged over them. */
+    resolveLayoutOptions(group) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!group)
+            return Object.assign({}, ((_a = this.options.layoutOptions) !== null && _a !== void 0 ? _a : {}));
+        return Object.assign(Object.assign(Object.assign({}, ((_b = this.options.layoutOptions) !== null && _b !== void 0 ? _b : {})), ((_d = (_c = group.subgraphLayout) === null || _c === void 0 ? void 0 : _c.layoutOptions) !== null && _d !== void 0 ? _d : {})), ((_f = (_e = this.override(group)) === null || _e === void 0 ? void 0 : _e.layoutOptions) !== null && _f !== void 0 ? _f : {}));
+    }
+}
+exports.CompoundLayoutService = CompoundLayoutService;
+/** A child container, as a single opaque box the parent's engine can place. */
+function standIn(group) {
+    const b = group.getOuterBounds();
+    return new NodeModel_1.NodeModel({
+        id: group.id,
+        type: 'group-unit',
+        position: { x: b.x, y: b.y },
+        size: { width: Math.max(1, b.width), height: Math.max(1, b.height) },
+    });
+}
+/**
+ * The smallest translation that moves `a` out of `b`, or undefined when they do
+ * not overlap. Ties break +x before -x before +y before -y, so the result is a
+ * pure function of the geometry — no iteration order can leak in.
+ */
+function minimumTranslation(a, b) {
+    const right = b.x + b.width - a.x; // push a right, clear of b
+    const left = a.x + a.width - b.x; // push a left
+    const down = b.y + b.height - a.y; // push a down
+    const up = a.y + a.height - b.y; // push a up
+    if (right <= 0 || left <= 0 || down <= 0 || up <= 0) {
+        return undefined; // separated on at least one axis
+    }
+    const best = Math.min(right, left, down, up);
+    if (best === right)
+        return { dx: right, dy: 0 };
+    if (best === left)
+        return { dx: -left, dy: 0 };
+    if (best === down)
+        return { dx: 0, dy: down };
+    return { dx: 0, dy: -up };
+}
+//# sourceMappingURL=CompoundLayoutService.js.map