@bpmnkit/core 0.0.27 → 0.1.1

package/dist/layout/grid/grid-engine.js

@@ -0,0 +1,214 @@
+import { ELEMENT_SIZES, GRID_CELL_HEIGHT, GRID_CELL_WIDTH } from "../types.js";
+import { placeEdgeLabels } from "./edge-labels.js";
+import { buildFlowGraph } from "./flow-graph.js";
+import { collapseCollinear, connectElements, ensureExitBottom } from "./grid-router.js";
+import { createGridLayout } from "./walker.js";
+const DEFAULT_SIZE = { width: 100, height: 80 };
+const SUB_TYPES = new Set(["subProcess", "adHocSubProcess", "eventSubProcess", "transaction"]);
+const CHILD_SHIFT_X = 50; // upstream: CELL_W/2 − baseW/4
+const CHILD_SHIFT_Y = 40; // upstream: CELL_H − baseH − baseH/4
+export function gridLayoutFlowNodes(flowNodes, sequenceFlows) {
+    if (flowNodes.length === 0)
+        return { nodes: [], edges: [] };
+    const root = buildLevel(flowNodes, sequenceFlows, false);
+    const out = { nodes: [], edges: [] };
+    emitLevel(root, { x: 0, y: 0 }, out);
+    const nodeMap = new Map(out.nodes.map((n) => [n.id, n]));
+    placeEdgeLabels(out.edges, nodeMap);
+    return out;
+}
+function buildLevel(flowNodes, sequenceFlows, compact) {
+    const graph = buildFlowGraph(flowNodes, sequenceFlows);
+    const children = new Map();
+    for (const el of graph.elements) {
+        if (!SUB_TYPES.has(el.type))
+            continue;
+        const sub = el;
+        if (!sub.flowElements || sub.flowElements.length === 0)
+            continue;
+        const childFlows = sub.sequenceFlows ?? [];
+        const childCompact = el.type === "adHocSubProcess" && childFlows.length === 0;
+        children.set(el.id, buildLevel(sub.flowElements, childFlows, childCompact));
+    }
+    const grid = createGridLayout(graph, { compact });
+    expandForChildren(grid, children);
+    return { graph, grid, children };
+}
+/** Insert blank cols/rows after every cell holding an expanded subprocess (§A.2.3). */
+function expandForChildren(grid, children) {
+    if (children.size === 0)
+        return;
+    // columns, right-to-left
+    for (let c = grid.colCount() - 1; c >= 0; c--) {
+        let maxCols = 0;
+        for (const { element, col } of grid.elementsByPosition()) {
+            if (col !== c)
+                continue;
+            const child = children.get(element.id);
+            if (child)
+                maxCols = Math.max(maxCols, child.grid.colCount());
+        }
+        if (maxCols > 0)
+            grid.createCol(c, Math.max(maxCols, 2));
+    }
+    // rows, bottom-to-top
+    for (let r = grid.rowCount() - 1; r >= 0; r--) {
+        let maxRows = 0;
+        for (const { element, row } of grid.elementsByPosition()) {
+            if (row !== r)
+                continue;
+            const child = children.get(element.id);
+            if (child)
+                maxRows = Math.max(maxRows, child.grid.rowCount());
+        }
+        for (let i = 0; i < maxRows; i++)
+            grid.createRow(r);
+    }
+}
+function sizeOf(el) {
+    return ELEMENT_SIZES[el.type] ?? DEFAULT_SIZE;
+}
+function emitLevel(level, shift, out) {
+    const routables = new Map();
+    const expandedRowsByRow = new Map();
+    const boundaryBounds = new Map();
+    // Pass 1: shapes (+ boundary events + recursion into children)
+    for (const { element, row, col } of level.grid.elementsByPosition()) {
+        const base = sizeOf(element);
+        const child = level.children.get(element.id);
+        const bounds = {
+            x: col * GRID_CELL_WIDTH + (GRID_CELL_WIDTH - base.width) / 2 + shift.x,
+            y: row * GRID_CELL_HEIGHT + (GRID_CELL_HEIGHT - base.height) / 2 + shift.y,
+            width: child ? child.grid.colCount() * GRID_CELL_WIDTH + base.width : base.width,
+            height: child ? child.grid.rowCount() * GRID_CELL_HEIGHT + base.height : base.height,
+        };
+        const layoutNode = {
+            id: element.id,
+            type: element.type,
+            bounds,
+            layer: col,
+            position: row,
+            gridRow: row,
+        };
+        if (element.name)
+            layoutNode.label = element.name;
+        const lb = computeLabelBounds(element, bounds);
+        if (lb)
+            layoutNode.labelBounds = lb;
+        if (child)
+            layoutNode.isExpanded = true;
+        out.nodes.push(layoutNode);
+        routables.set(element.id, {
+            id: element.id,
+            bounds,
+            row,
+            col,
+            childGrid: child ? { rows: child.grid.rowCount(), cols: child.grid.colCount() } : undefined,
+        });
+        if (child) {
+            expandedRowsByRow.set(row, Math.max(expandedRowsByRow.get(row) ?? 0, child.grid.rowCount()));
+        }
+        // boundary events ride on the host's bottom edge
+        const attachers = level.graph.attachers.get(element.id) ?? [];
+        const n = attachers.length;
+        for (let i = 0; i < n; i++) {
+            const be = attachers[i];
+            const beBounds = {
+                x: bounds.x + ((i + 1) * bounds.width) / (n + 1) - 18,
+                y: bounds.y + bounds.height - 18,
+                width: 36,
+                height: 36,
+            };
+            const beNode = {
+                id: be.id,
+                type: be.type,
+                bounds: beBounds,
+                layer: col,
+                position: row,
+                gridRow: row,
+            };
+            if (be.name) {
+                beNode.label = be.name;
+                const labelWidth = Math.min(Math.max(be.name.length * 7, 40), GRID_CELL_WIDTH);
+                beNode.labelBounds = {
+                    x: beBounds.x + beBounds.width / 2 - labelWidth / 2,
+                    y: beBounds.y + beBounds.height + 4,
+                    width: labelWidth,
+                    height: 14,
+                };
+            }
+            out.nodes.push(beNode);
+            boundaryBounds.set(be.id, beBounds);
+            routables.set(be.id, {
+                id: be.id,
+                bounds: beBounds,
+                row,
+                col,
+                hostChildGrid: child
+                    ? { rows: child.grid.rowCount(), cols: child.grid.colCount() }
+                    : undefined,
+            });
+        }
+        if (child) {
+            emitLevel(child, { x: bounds.x + CHILD_SHIFT_X, y: bounds.y + CHILD_SHIFT_Y }, out);
+        }
+    }
+    // Pass 2: edges of THIS level
+    for (const flows of level.graph.outgoing.values()) {
+        for (const flow of flows) {
+            const source = routables.get(flow.sourceRef);
+            const target = routables.get(flow.targetRef);
+            if (!source || !target)
+                continue;
+            let waypoints = connectElements(source, target, level.grid, shift, expandedRowsByRow);
+            const beB = boundaryBounds.get(flow.sourceRef);
+            if (beB)
+                waypoints = ensureExitBottom(beB, waypoints);
+            const edge = {
+                id: flow.id,
+                sourceRef: flow.sourceRef,
+                targetRef: flow.targetRef,
+                waypoints: collapseCollinear(waypoints),
+            };
+            if (flow.name)
+                edge.label = flow.name;
+            out.edges.push(edge);
+        }
+    }
+}
+/** Copied from coordinates.ts:141 — events and gateways get a label below the shape. */
+function computeLabelBounds(node, bounds) {
+    if (!node.name)
+        return undefined;
+    // Cap label width to one grid cell so labels don't overlap adjacent elements
+    const labelWidth = Math.min(Math.max(node.name.length * 7, 40), GRID_CELL_WIDTH);
+    const labelHeight = 14;
+    switch (node.type) {
+        case "startEvent":
+        case "endEvent":
+        case "intermediateThrowEvent":
+        case "intermediateCatchEvent":
+            // Labels centered below events
+            return {
+                x: bounds.x + bounds.width / 2 - labelWidth / 2,
+                y: bounds.y + bounds.height + 4,
+                width: labelWidth,
+                height: labelHeight,
+            };
+        case "exclusiveGateway":
+        case "parallelGateway":
+        case "inclusiveGateway":
+        case "eventBasedGateway":
+            // Labels centered below gateway diamond (standard BPMN convention)
+            return {
+                x: bounds.x + bounds.width / 2 - labelWidth / 2,
+                y: bounds.y + bounds.height + 4,
+                width: labelWidth,
+                height: labelHeight,
+            };
+        default:
+            // Tasks/activities: labels centered inside — no separate label bounds needed
+            return undefined;
+    }
+}
+//# sourceMappingURL=grid-engine.js.map

package/dist/layout/grid/grid-router.d.ts

@@ -0,0 +1,36 @@
+import type { Bounds, Waypoint } from "../types.js";
+import type { Grid } from "./grid.js";
+/** Routing endpoint: absolute bounds plus grid position. */
+export interface RoutableNode {
+    id: string;
+    bounds: Bounds;
+    row: number;
+    col: number;
+    /** Child grid dims when this node is an expanded subprocess. */
+    childGrid?: {
+        rows: number;
+        cols: number;
+    };
+    /** For boundary events: the host's childGrid (if the host is expanded). */
+    hostChildGrid?: {
+        rows: number;
+        cols: number;
+    };
+}
+/**
+ * Compute orthogonal waypoints between two grid-placed nodes.
+ * Port of bpmn-auto-layout's connectElements (lib/utils/layoutUtil.js:52),
+ * with the level shift applied consistently (upstream drops it for
+ * subprocess children).
+ */
+export declare function connectElements(source: RoutableNode, target: RoutableNode, grid: Grid<{
+    id: string;
+}>, shift: {
+    x: number;
+    y: number;
+}, expandedRowsByRow: Map<number, number>): Waypoint[];
+/** Force an edge to leave through a boundary event's bottom docking point. */
+export declare function ensureExitBottom(be: Bounds, waypoints: Waypoint[]): Waypoint[];
+/** Remove intermediate waypoints that lie on a straight segment; round coordinates. */
+export declare function collapseCollinear(waypoints: Waypoint[]): Waypoint[];
+//# sourceMappingURL=grid-router.d.ts.map

package/dist/layout/grid/grid-router.js

@@ -0,0 +1,190 @@
+import { GRID_CELL_HEIGHT, GRID_CELL_WIDTH } from "../types.js";
+const H = GRID_CELL_HEIGHT; // 140
+const W = GRID_CELL_WIDTH; // 150
+const HALF_H = H / 2; // 70
+const HALF_W = W / 2; // 75
+const TASK_HALF_HEIGHT = 40;
+const BOUNDARY_STEM = 20;
+function mid(b) {
+    return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+}
+function dock(point, rect, dir) {
+    switch (dir) {
+        case "t":
+            return { x: point.x, y: rect.y };
+        case "b":
+            return { x: point.x, y: rect.y + rect.height };
+        case "l":
+            return { x: rect.x, y: point.y };
+        case "r":
+            return { x: rect.x + rect.width, y: point.y };
+    }
+}
+function sourceGridOf(node) {
+    return node.childGrid ?? node.hostChildGrid;
+}
+/**
+ * Compute orthogonal waypoints between two grid-placed nodes.
+ * Port of bpmn-auto-layout's connectElements (lib/utils/layoutUtil.js:52),
+ * with the level shift applied consistently (upstream drops it for
+ * subprocess children).
+ */
+export function connectElements(source, target, grid, shift, expandedRowsByRow) {
+    const sMid = mid(source.bounds);
+    const tMid = mid(target.bounds);
+    const dX = target.col - source.col;
+    const dY = target.row - source.row;
+    const cellTop = (row) => row * H + shift.y;
+    const cellLeft = (col) => col * W + shift.x;
+    const srcGrid = sourceGridOf(source);
+    // Self-loop
+    if (dX === 0 && dY === 0 && source.id === target.id) {
+        const loopX = cellLeft(source.col) + (srcGrid ? (srcGrid.cols + 1) * W : W);
+        const topY = cellTop(source.row);
+        return [
+            dock(sMid, source.bounds, "r"),
+            { x: loopX, y: sMid.y },
+            { x: loopX, y: topY },
+            { x: tMid.x, y: topY },
+            dock(tMid, target.bounds, "t"),
+        ];
+    }
+    // Back-edge (loop closing leftwards)
+    if (dX < 0) {
+        if (sMid.y >= tMid.y) {
+            const extraRows = srcGrid ? srcGrid.rows + 1 : 1 + (expandedRowsByRow.get(source.row) ?? 0);
+            const downY = cellTop(source.row) + extraRows * H;
+            return [
+                dock(sMid, source.bounds, "b"),
+                { x: sMid.x, y: downY },
+                { x: tMid.x, y: downY },
+                dock(tMid, target.bounds, "b"),
+            ];
+        }
+        const upY = sMid.y - HALF_H;
+        return [
+            dock(sMid, source.bounds, "t"),
+            { x: sMid.x, y: upY },
+            { x: tMid.x, y: upY },
+            dock(tMid, target.bounds, "t"),
+        ];
+    }
+    // Same row, forward
+    if (dY === 0) {
+        if (isDirectPathBlocked(source, target, grid)) {
+            const extraRows = srcGrid ? srcGrid.rows + 1 : 1;
+            const underY = cellTop(source.row) + extraRows * H;
+            return [
+                dock(sMid, source.bounds, "b"),
+                { x: sMid.x, y: underY },
+                { x: tMid.x, y: underY },
+                dock(tMid, target.bounds, "b"),
+            ];
+        }
+        const first = dock(sMid, source.bounds, "r");
+        const last = dock(tMid, target.bounds, "l");
+        // Expanded boxes dock at header height, not box middle
+        if (source.childGrid)
+            first.y = source.bounds.y + TASK_HALF_HEIGHT;
+        if (target.childGrid)
+            last.y = target.bounds.y + TASK_HALF_HEIGHT;
+        if (first.y !== last.y) {
+            // header-height correction created a step — resolve with an L
+            return collapseCollinear([first, { x: last.x, y: first.y }, last]);
+        }
+        return [first, last];
+    }
+    // Same column, vertical
+    if (dX === 0) {
+        if (isDirectPathBlocked(source, target, grid)) {
+            const yOff = -Math.sign(dY) * HALF_H;
+            return [
+                dock(sMid, source.bounds, "r"),
+                { x: sMid.x + HALF_W, y: sMid.y },
+                { x: sMid.x + HALF_W, y: tMid.y + yOff },
+                { x: tMid.x, y: tMid.y + yOff },
+                dock(tMid, target.bounds, yOff > 0 ? "b" : "t"),
+            ];
+        }
+        return [
+            dock(sMid, source.bounds, dY > 0 ? "b" : "t"),
+            dock(tMid, target.bounds, dY > 0 ? "t" : "b"),
+        ];
+    }
+    // Diagonal forward: try the single-bend route
+    const direct = directManhattan(source, target, grid, dY);
+    if (direct)
+        return direct;
+    // Fallback: 6-point S-route
+    const yOff = -Math.sign(dY) * HALF_H;
+    return [
+        dock(sMid, source.bounds, "r"),
+        { x: sMid.x + HALF_W, y: sMid.y },
+        { x: sMid.x + HALF_W, y: tMid.y + yOff },
+        { x: tMid.x - HALF_W, y: tMid.y + yOff },
+        { x: tMid.x - HALF_W, y: tMid.y },
+        dock(tMid, target.bounds, "l"),
+    ];
+}
+function directManhattan(source, target, grid, dY) {
+    const sMid = mid(source.bounds);
+    const tMid = mid(target.bounds);
+    if (dY > 0) {
+        // bend at (targetRow, sourceCol): down, then right
+        const count = grid.getElementsInRange({ row: source.row, col: source.col }, { row: target.row, col: source.col }).length +
+            grid.getElementsInRange({ row: target.row, col: source.col }, { row: target.row, col: target.col }).length;
+        if (count > 2)
+            return undefined;
+        return [
+            dock(sMid, source.bounds, "b"),
+            { x: sMid.x, y: tMid.y },
+            dock(tMid, target.bounds, "l"),
+        ];
+    }
+    // bend at (sourceRow, targetCol): right, then up
+    const count = grid.getElementsInRange({ row: source.row, col: source.col }, { row: source.row, col: target.col }).length +
+        grid.getElementsInRange({ row: source.row, col: target.col }, { row: target.row, col: target.col }).length;
+    if (count > 2)
+        return undefined;
+    return [dock(sMid, source.bounds, "r"), { x: tMid.x, y: sMid.y }, dock(tMid, target.bounds, "b")];
+}
+function isDirectPathBlocked(source, target, grid) {
+    // Each range is counted only when there is movement along that axis —
+    // otherwise a same-row edge would double-count its target and always block.
+    let total = 0;
+    if (target.col !== source.col) {
+        total += grid.getElementsInRange({ row: source.row, col: source.col }, { row: source.row, col: target.col }).length;
+    }
+    if (target.row !== source.row) {
+        total += grid.getElementsInRange({ row: source.row, col: target.col }, { row: target.row, col: target.col }).length;
+    }
+    return total > 2;
+}
+/** Force an edge to leave through a boundary event's bottom docking point. */
+export function ensureExitBottom(be, waypoints) {
+    if (waypoints.length === 0)
+        return waypoints;
+    const exit = { x: be.x + be.width / 2, y: be.y + be.height };
+    const stemY = exit.y + BOUNDARY_STEM;
+    const rest = waypoints.slice(1);
+    const rejoin = rest[0] ?? exit;
+    return collapseCollinear([exit, { x: exit.x, y: stemY }, { x: rejoin.x, y: stemY }, ...rest]);
+}
+/** Remove intermediate waypoints that lie on a straight segment; round coordinates. */
+export function collapseCollinear(waypoints) {
+    const rounded = waypoints.map((w) => ({ x: Math.round(w.x), y: Math.round(w.y) }));
+    const out = [];
+    for (const p of rounded) {
+        const a = out[out.length - 2];
+        const b = out[out.length - 1];
+        if (b && b.x === p.x && b.y === p.y)
+            continue;
+        if (a && b && ((a.x === b.x && b.x === p.x) || (a.y === b.y && b.y === p.y))) {
+            out[out.length - 1] = p;
+            continue;
+        }
+        out.push(p);
+    }
+    return out;
+}
+//# sourceMappingURL=grid-router.js.map

package/dist/layout/grid/grid.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Sparse row/column grid used by the grid layout engine.
+ * Port of bpmn-io bpmn-auto-layout's Grid (lib/Grid.js) with two fixes:
+ * an explicit optional position (upstream conflated [0,0] with "no
+ * position") and a working row-splice guard.
+ */
+export declare class Grid<T> {
+    private grid;
+    /** Without a position, start a new bottom row; with one, place exactly there. */
+    add(element: T, position?: [number, number]): void;
+    createRow(afterIndex?: number): void;
+    createCol(afterIndex: number, count: number): void;
+    addAfter(element: T, newElement: T): void;
+    addBelow(element: T, newElement: T): void;
+    find(element: T): [number, number];
+    get(row: number, col: number): T | undefined;
+    getElementsInRange(from: {
+        row: number;
+        col: number;
+    }, to: {
+        row: number;
+        col: number;
+    }): T[];
+    /**
+     * Move an element to the current last column of the grid (right-align
+     * before a fan-out). No-op when that cell is occupied — upstream would
+     * overwrite; we keep the no-overwrite invariant.
+     */
+    adjustGridPosition(element: T): void;
+    adjustRowForMultipleIncoming(sources: T[], element: T): void;
+    adjustColumnForMultipleIncoming(sources: T[], element: T): void;
+    getAllElements(): T[];
+    getGridDimensions(): [number, number];
+    elementsByPosition(): Array<{
+        element: T;
+        row: number;
+        col: number;
+    }>;
+    getElementsTotal(): number;
+    rowCount(): number;
+    colCount(): number;
+}
+//# sourceMappingURL=grid.d.ts.map

package/dist/layout/grid/grid.js

@@ -0,0 +1,174 @@
+/**
+ * Sparse row/column grid used by the grid layout engine.
+ * Port of bpmn-io bpmn-auto-layout's Grid (lib/Grid.js) with two fixes:
+ * an explicit optional position (upstream conflated [0,0] with "no
+ * position") and a working row-splice guard.
+ */
+export class Grid {
+    grid = [];
+    /** Without a position, start a new bottom row; with one, place exactly there. */
+    add(element, position) {
+        if (!position) {
+            this.grid.push([element]);
+            return;
+        }
+        const [row, col] = position;
+        while (this.grid.length <= row)
+            this.grid.push([]);
+        const gridRow = this.grid[row];
+        if (gridRow[col] !== undefined) {
+            throw new Error(`Grid cell (${row},${col}) is already occupied`);
+        }
+        gridRow[col] = element;
+    }
+    createRow(afterIndex) {
+        if (afterIndex === undefined) {
+            this.grid.push([]);
+            return;
+        }
+        this.grid.splice(afterIndex + 1, 0, []);
+    }
+    createCol(afterIndex, count) {
+        for (const row of this.grid) {
+            if (row.length > afterIndex) {
+                row.splice(afterIndex + 1, 0, ...new Array(count).fill(undefined));
+            }
+        }
+    }
+    addAfter(element, newElement) {
+        const [row, col] = this.find(element);
+        if (row < 0) {
+            this.add(newElement);
+            return;
+        }
+        this.grid[row]?.splice(col + 1, 0, newElement);
+    }
+    addBelow(element, newElement) {
+        const [row, col] = this.find(element);
+        if (row < 0) {
+            this.add(newElement);
+            return;
+        }
+        while (this.grid.length <= row + 1)
+            this.grid.push([]);
+        const below = this.grid[row + 1];
+        if (below[col] !== undefined) {
+            this.grid.splice(row + 1, 0, []);
+        }
+        this.add(newElement, [row + 1, col]);
+    }
+    find(element) {
+        for (let r = 0; r < this.grid.length; r++) {
+            const row = this.grid[r];
+            if (!row)
+                continue;
+            for (let c = 0; c < row.length; c++) {
+                if (row[c] === element)
+                    return [r, c];
+            }
+        }
+        return [-1, -1];
+    }
+    get(row, col) {
+        return this.grid[row]?.[col];
+    }
+    getElementsInRange(from, to) {
+        const r1 = Math.min(from.row, to.row);
+        const r2 = Math.max(from.row, to.row);
+        const c1 = Math.min(from.col, to.col);
+        const c2 = Math.max(from.col, to.col);
+        const out = [];
+        for (let r = r1; r <= r2; r++) {
+            for (let c = c1; c <= c2; c++) {
+                const el = this.get(r, c);
+                if (el !== undefined)
+                    out.push(el);
+            }
+        }
+        return out;
+    }
+    /**
+     * Move an element to the current last column of the grid (right-align
+     * before a fan-out). No-op when that cell is occupied — upstream would
+     * overwrite; we keep the no-overwrite invariant.
+     */
+    adjustGridPosition(element) {
+        const [row, col] = this.find(element);
+        if (row < 0)
+            return;
+        const maxCol = this.colCount() - 1;
+        if (col < maxCol - 1 && this.get(row, maxCol) === undefined) {
+            const gridRow = this.grid[row];
+            gridRow[col] = undefined;
+            while (gridRow.length <= maxCol)
+                gridRow.push(undefined);
+            gridRow[maxCol] = element;
+        }
+    }
+    adjustRowForMultipleIncoming(sources, element) {
+        const [row, col] = this.find(element);
+        if (row < 0)
+            return;
+        const rows = sources.map((s) => this.find(s)[0]).filter((r) => r >= 0);
+        if (rows.length === 0)
+            return;
+        const lowestRow = Math.min(...rows);
+        if (lowestRow < row && this.get(lowestRow, col) === undefined) {
+            const gridRow = this.grid[row];
+            gridRow[col] = undefined;
+            this.add(element, [lowestRow, col]);
+        }
+    }
+    adjustColumnForMultipleIncoming(sources, element) {
+        const [row, col] = this.find(element);
+        if (row < 0)
+            return;
+        const cols = sources.map((s) => this.find(s)[1]).filter((c) => c >= 0);
+        if (cols.length === 0)
+            return;
+        const maxCol = Math.max(...cols);
+        if (maxCol + 1 > col) {
+            const gridRow = this.grid[row];
+            gridRow[col] = undefined;
+            // splice-free targeted set; grow the row as needed
+            while (gridRow.length <= maxCol + 1)
+                gridRow.push(undefined);
+            if (gridRow[maxCol + 1] === undefined) {
+                gridRow[maxCol + 1] = element;
+            }
+            else {
+                this.addBelow(gridRow[maxCol + 1], element);
+            }
+        }
+    }
+    getAllElements() {
+        return this.elementsByPosition().map((e) => e.element);
+    }
+    getGridDimensions() {
+        return [this.rowCount(), this.colCount()];
+    }
+    elementsByPosition() {
+        const out = [];
+        for (let r = 0; r < this.grid.length; r++) {
+            const row = this.grid[r];
+            if (!row)
+                continue;
+            for (let c = 0; c < row.length; c++) {
+                const el = row[c];
+                if (el !== undefined)
+                    out.push({ element: el, row: r, col: c });
+            }
+        }
+        return out;
+    }
+    getElementsTotal() {
+        return new Set(this.getAllElements()).size;
+    }
+    rowCount() {
+        return this.grid.length;
+    }
+    colCount() {
+        return this.grid.reduce((max, row) => Math.max(max, row.length), 0);
+    }
+}
+//# sourceMappingURL=grid.js.map

package/dist/layout/grid/walker.d.ts

@@ -0,0 +1,11 @@
+import type { BpmnFlowElement } from "../../bpmn/bpmn-model.js";
+import type { FlowGraph } from "./flow-graph.js";
+import { Grid } from "./grid.js";
+/**
+ * Place every element of the graph into a Grid via the bpmn-io DFS walk.
+ * `compact` bypasses the walk and packs row-major (adHoc tool palettes).
+ */
+export declare function createGridLayout(graph: FlowGraph, opts?: {
+    compact?: boolean;
+}): Grid<BpmnFlowElement>;
+//# sourceMappingURL=walker.d.ts.map