@yalehwang/plantuml-js 0.2.2 → 0.3.0

package/dist/layout/elk-graph.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Model → ELK graph construction for the ELK engine: package containers,
+ * entity leaves, packed boxes for unconnected entities, and the layout-direction
+ * helpers for edges. Pure functions over the model.
+ */
+import type { ElkNode } from 'elkjs';
+import { PlantUmlModel, PlantUmlEntity, PlantUmlRelation } from '../foundation/model.js';
+export declare const PACKAGE_PREFIX = "pkg::";
+/** Id prefix of the invisible container that packs a package's unconnected entities. */
+export declare const ISOLATED_PREFIX = "iso::";
+/** Minimum frame width that keeps the package label tab readable. */
+export declare function packageMinWidth(name: string): number;
+/** Source endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
+export declare function layoutSource(relation: PlantUmlRelation): string;
+/** Target endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
+export declare function layoutTarget(relation: PlantUmlRelation): string;
+/** True when any relation connects entities that live in different containers. */
+export declare function hasContainerCrossingEdge(model: PlantUmlModel): boolean;
+export declare function entityLeaf(entity: PlantUmlEntity): ElkNode;
+/**
+ * One ELK node's `layoutOptions`, weakest first: built-in defaults, then the
+ * caller's raw `elk` escape-hatch keys (they override our defaults), then the
+ * named options the caller explicitly set (they win any key collision).
+ */
+export declare function mergeElkOptions(defaults: Record<string, string>, named: Record<string, string>, raw: Record<string, string> | undefined): Record<string, string>;
+export declare function buildChildren(model: PlantUmlModel, partitions: Map<string, number>, rawElk?: Record<string, string>): ElkNode[];
+export interface ElkGraphOptions {
+    /** Edge routing mode; omitted means the built-in ORTHOGONAL default. */
+    edgeRouting?: string;
+    mergeEdges?: boolean;
+    aspectRatio?: number;
+    /** Raw ELK options injected into the root and every package container (escape hatch). */
+    elk?: Record<string, string>;
+}
+/** The root ELK graph for one hierarchical run over the whole nested model. */
+export declare function buildElkGraph(model: PlantUmlModel, layers: string[], partitions: Map<string, number>, options: ElkGraphOptions): ElkNode;

package/dist/layout/elk-graph.js

@@ -0,0 +1,220 @@
+/**
+ * Model → ELK graph construction for the ELK engine: package containers,
+ * entity leaves, packed boxes for unconnected entities, and the layout-direction
+ * helpers for edges. Pure functions over the model.
+ */
+import { PACKAGE_LABEL, estimateEntitySize } from '../foundation/layout.js';
+import { measureTextWidth } from '../foundation/text-measure.js';
+import { relationSemantics } from '../foundation/relation-semantics.js';
+export const PACKAGE_PREFIX = 'pkg::';
+/** Id prefix of the invisible container that packs a package's unconnected entities. */
+export const ISOLATED_PREFIX = 'iso::';
+/** Unconnected entities in one container before they are packed into a grid... */
+const ISOLATED_PACK_MIN = 3;
+/** ...and only once laid side by side they would be wider than this (px). */
+const ISOLATED_ROW_MAX_WIDTH = 2000;
+/** Minimum frame width that keeps the package label tab readable. */
+export function packageMinWidth(name) {
+    return measureTextWidth(name, PACKAGE_LABEL.fontSize) + PACKAGE_LABEL.tabPadding + 20;
+}
+/** Source endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
+export function layoutSource(relation) {
+    return relationSemantics(relation.type).isReversed() ? relation.target : relation.source;
+}
+/** Target endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
+export function layoutTarget(relation) {
+    return relationSemantics(relation.type).isReversed() ? relation.source : relation.target;
+}
+/** True when any relation connects entities that live in different containers. */
+export function hasContainerCrossingEdge(model) {
+    const packageOf = new Map(model.entities.map((e) => [e.id, e.packageId]));
+    return model.relations.some((r) => packageOf.get(r.source) !== packageOf.get(r.target));
+}
+export function entityLeaf(entity) {
+    const size = estimateEntitySize(entity);
+    return { id: entity.id, width: size.width, height: size.height };
+}
+/** Packages with at least this many direct members are laid out top-down. */
+const FLOW_DOWN_MIN_MEMBERS = 12;
+/**
+ * One ELK node's `layoutOptions`, weakest first: built-in defaults, then the
+ * caller's raw `elk` escape-hatch keys (they override our defaults), then the
+ * named options the caller explicitly set (they win any key collision).
+ */
+export function mergeElkOptions(defaults, named, raw) {
+    return raw === undefined ? { ...defaults, ...named } : { ...defaults, ...raw, ...named };
+}
+export function buildChildren(model, partitions, rawElk) {
+    const pkgNodes = new Map();
+    const memberCount = new Map(model.packages.map((p) => [p.id, 0]));
+    for (const entity of model.entities) {
+        if (entity.packageId !== undefined && memberCount.has(entity.packageId)) {
+            memberCount.set(entity.packageId, memberCount.get(entity.packageId) + 1);
+        }
+    }
+    for (const pkg of model.packages) {
+        // Padding at the top keeps the package label tab clear of the first
+        // entity; the minimum width keeps the tab wide enough for the label when
+        // a package holds only a single short-named entity.
+        const minWidth = packageMinWidth(pkg.name);
+        const minHeight = PACKAGE_LABEL.tabHeight + 26 + 10; // tab + top/bottom padding
+        const defaults = {
+            'elk.padding': '[top=26,left=10,bottom=10,right=10]',
+            'elk.nodeSize.constraints': '[MINIMUM_SIZE]',
+            'elk.nodeSize.minimum': `[${minWidth.toFixed(1)}, ${minHeight.toFixed(1)}]`,
+        };
+        // A package's interior is laid out on its own (INHERIT hierarchy) and would
+        // fall back to ELK's default RIGHT, turning the dependency flow sideways.
+        // Big packages read top-down like the rest of the diagram; small ones stay compact.
+        if (memberCount.get(pkg.id) >= FLOW_DOWN_MIN_MEMBERS)
+            defaults['elk.direction'] = 'DOWN';
+        // The semantic-layer partition is named-option territory (layerOrder / "X Layer"
+        // packages), so it beats a same-key raw `elk` value.
+        const named = {};
+        const partition = partitions.get(pkg.id);
+        if (partition !== undefined)
+            named['elk.partitioning.partition'] = String(partition);
+        pkgNodes.set(pkg.id, {
+            id: PACKAGE_PREFIX + pkg.id,
+            children: [],
+            layoutOptions: mergeElkOptions(defaults, named, rawElk),
+        });
+    }
+    const connected = new Set();
+    for (const relation of model.relations) {
+        connected.add(relation.source);
+        connected.add(relation.target);
+    }
+    // Unconnected entities of one container are packed into a balanced grid by
+    // an invisible sub-container; left alone, the layered algorithm lines them
+    // all up in a single row and stretches the whole canvas.
+    const isolatedByOwner = new Map();
+    const ownerKey = (entity) => entity.packageId && pkgNodes.has(entity.packageId) ? entity.packageId : '';
+    for (const entity of model.entities) {
+        if (connected.has(entity.id))
+            continue;
+        const key = ownerKey(entity);
+        const list = isolatedByOwner.get(key);
+        if (list)
+            list.push(entity);
+        else
+            isolatedByOwner.set(key, [entity]);
+    }
+    const packed = new Set();
+    const groups = new Map();
+    for (const [key, list] of isolatedByOwner) {
+        if (list.length < ISOLATED_PACK_MIN)
+            continue;
+        const rowWidth = list.reduce((sum, e) => sum + estimateEntitySize(e).width + 40, 0);
+        if (rowWidth <= ISOLATED_ROW_MAX_WIDTH)
+            continue;
+        const layoutOptions = {
+            'elk.algorithm': 'rectpacking',
+            'elk.hierarchyHandling': 'SEPARATE_CHILDREN',
+            'elk.aspectRatio': '1.6',
+            'elk.spacing.nodeNode': '20',
+            'elk.padding': '[top=0,left=0,bottom=0,right=0]',
+        };
+        const partition = key === '' ? undefined : partitions.get(key);
+        if (partition !== undefined)
+            layoutOptions['elk.partitioning.partition'] = String(partition);
+        groups.set(key, {
+            id: ISOLATED_PREFIX + key,
+            children: list.map((e) => entityLeaf(e)),
+            layoutOptions,
+        });
+        for (const e of list)
+            packed.add(e.id);
+    }
+    const top = [];
+    for (const [key, group] of groups) {
+        if (key === '')
+            top.push(group);
+        else
+            pkgNodes.get(key).children.push(group);
+    }
+    for (const entity of model.entities) {
+        if (packed.has(entity.id))
+            continue;
+        const leaf = entityLeaf(entity);
+        const owner = entity.packageId ? pkgNodes.get(entity.packageId) : undefined;
+        if (owner)
+            owner.children.push(leaf);
+        else
+            top.push(leaf);
+    }
+    // Link nested packages into their parents; packages without a parent (or
+    // whose parent is unknown) sit at the top level.
+    for (const pkg of model.packages) {
+        const node = pkgNodes.get(pkg.id);
+        const parent = pkg.parentId ? pkgNodes.get(pkg.parentId) : undefined;
+        if (parent)
+            parent.children.push(node);
+        else
+            top.push(node);
+    }
+    return top;
+}
+/** The root ELK graph for one hierarchical run over the whole nested model. */
+export function buildElkGraph(model, layers, partitions, options) {
+    const partitionsActive = layers.length > 0;
+    // Memberless one-line boxes (overview / grouped / stub-only graphs) are tiny
+    // next to the default gaps, which leaves the canvas mostly empty.
+    const compact = model.packages.length === 0 && model.entities.every((e) => e.members.length === 0);
+    const children = buildChildren(model, partitions, options.elk);
+    const edges = model.relations.map((relation, i) => ({
+        id: `rel-${i}`,
+        sources: [layoutSource(relation)],
+        targets: [layoutTarget(relation)],
+    }));
+    const defaults = {
+        'elk.algorithm': 'layered',
+        'elk.direction': 'DOWN',
+        'elk.edgeRouting': 'ORTHOGONAL',
+        'elk.spacing.nodeNode': compact ? '12' : '20',
+        'elk.layered.spacing.nodeNodeBetweenLayers': compact ? '24' : '24',
+        // Ports keep a fixed side per edge, so same-direction edges fan out across
+        // one node edge instead of scattering onto every side (or one point).
+        'elk.layered.portConstraints': 'FIXED_SIDE',
+        // Keep wires off node sides and off each other (see layout-metrics edgeFlushCount).
+        'elk.spacing.edgeNode': '12',
+        'elk.spacing.edgeEdge': '10',
+        // Soft targets: pack disconnected components into a balanced rectangle
+        // instead of a long horizontal strip. (hierarchyHandling stays INHERIT
+        // unless cross-package edges exist — see the header comment.)
+        'elk.aspectRatio': '1.6',
+        'elk.separateConnectedComponents': 'true',
+        // INTERACTIVE placement keeps each layer's boxes centred on the widest
+        // partition instead of fanning them out sideways, which is what lets a
+        // topologically-stacked package diagram stay compact (see
+        // docs/layout-routing-eval.md).
+        'elk.layered.nodePlacement.strategy': 'INTERACTIVE',
+    };
+    // Values that come from an explicitly-set named option: these beat a raw
+    // `elk` key of the same name (documented precedence).
+    const named = {};
+    if (options.edgeRouting !== undefined)
+        named['elk.edgeRouting'] = options.edgeRouting;
+    if (options.aspectRatio !== undefined)
+        named['elk.aspectRatio'] = String(options.aspectRatio);
+    if (options.mergeEdges)
+        named['elk.layered.mergeEdges'] = 'true';
+    if (partitionsActive)
+        named['elk.partitioning.activate'] = 'true';
+    if (compact) {
+        defaults['elk.layered.nodePlacement.strategy'] = 'NETWORK_SIMPLEX';
+        defaults['elk.layered.spacing.edgeEdgeBetweenLayers'] = '5';
+        defaults['elk.layered.spacing.edgeNodeBetweenLayers'] = '12';
+    }
+    // Every edge that crosses a container boundary (package↔package or
+    // package↔top-level stub) needs INCLUDE_CHILDREN to get a routing section.
+    if (hasContainerCrossingEdge(model)) {
+        defaults['elk.hierarchyHandling'] = 'INCLUDE_CHILDREN';
+    }
+    return {
+        id: 'root',
+        layoutOptions: mergeElkOptions(defaults, named, options.elk),
+        children,
+        edges,
+    };
+}

package/dist/layout/elk-result.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ELK result → `LayoutResult` mapping for the ELK engine: flatten the nested
+ * node tree into absolute boxes and turn edge sections into point lists.
+ */
+import type { ElkNode, ElkExtendedEdge } from 'elkjs';
+import { PlantUmlModel } from '../foundation/model.js';
+import { LayoutResult, NodeLayout, PackageLayout, Point } from '../foundation/layout.js';
+/**
+ * INCLUDE_CHILDREN sizes a container from its content and does not honour the
+ * `elk.nodeSize.minimum` we give package frames, so a single short-named
+ * entity can leave the frame narrower than its label tab. Widen those frames
+ * in place (never shrink) so the tab stays readable.
+ */
+export declare function enforcePackageMinWidth(model: PlantUmlModel, packages: PackageLayout[]): void;
+export declare function flatten(node: ElkNode, offsetX: number, offsetY: number, nodes: NodeLayout[], packages: PackageLayout[], offsets: Map<string, Point>): void;
+export declare function edgePoints(edge: ElkExtendedEdge, nodeById: Map<string, NodeLayout>, offsets: Map<string, Point>): Point[];
+/** Map a laid-out ELK graph back to the model's `LayoutResult`. */
+export declare function mapElkResult(model: PlantUmlModel, result: ElkNode): LayoutResult;

package/dist/layout/elk-result.js

@@ -0,0 +1,127 @@
+/**
+ * ELK result → `LayoutResult` mapping for the ELK engine: flatten the nested
+ * node tree into absolute boxes and turn edge sections into point lists.
+ */
+import { PACKAGE_PREFIX, ISOLATED_PREFIX, packageMinWidth, } from './elk-graph.js';
+import { relationSemantics } from '../foundation/relation-semantics.js';
+/**
+ * INCLUDE_CHILDREN sizes a container from its content and does not honour the
+ * `elk.nodeSize.minimum` we give package frames, so a single short-named
+ * entity can leave the frame narrower than its label tab. Widen those frames
+ * in place (never shrink) so the tab stays readable.
+ */
+export function enforcePackageMinWidth(model, packages) {
+    const byId = new Map(packages.map((p) => [p.id, p]));
+    for (const pkg of model.packages) {
+        const box = byId.get(pkg.id);
+        if (!box)
+            continue;
+        const min = packageMinWidth(pkg.name);
+        if (box.width < min)
+            box.width = min;
+    }
+}
+export function flatten(node, offsetX, offsetY, nodes, packages, offsets) {
+    const x = (node.x ?? 0) + offsetX;
+    const y = (node.y ?? 0) + offsetY;
+    offsets.set(node.id, { x, y });
+    if (node.id.startsWith(PACKAGE_PREFIX)) {
+        packages.push({
+            id: node.id.slice(PACKAGE_PREFIX.length),
+            x,
+            y,
+            width: node.width ?? 0,
+            height: node.height ?? 0,
+        });
+        for (const child of node.children ?? []) {
+            flatten(child, x, y, nodes, packages, offsets);
+        }
+    }
+    else if (node.id.startsWith(ISOLATED_PREFIX)) {
+        for (const child of node.children ?? []) {
+            flatten(child, x, y, nodes, packages, offsets);
+        }
+    }
+    else {
+        nodes.push({
+            id: node.id,
+            x,
+            y,
+            width: node.width ?? 0,
+            height: node.height ?? 0,
+        });
+    }
+}
+export function edgePoints(edge, nodeById, offsets) {
+    const sections = edge.sections ?? [];
+    if (sections.length === 0) {
+        return straightEdge(edge, nodeById);
+    }
+    const containerOffset = offsets.get(edge.container ?? 'root') ?? {
+        x: 0,
+        y: 0,
+    };
+    const points = [];
+    for (const section of sections) {
+        for (const p of sectionPoints(section)) {
+            const shifted = { x: p.x + containerOffset.x, y: p.y + containerOffset.y };
+            const last = points[points.length - 1];
+            if (!last || Math.abs(last.x - shifted.x) > 0.01 || Math.abs(last.y - shifted.y) > 0.01) {
+                points.push(shifted);
+            }
+        }
+    }
+    return points.length >= 2 ? points : straightEdge(edge, nodeById);
+}
+function sectionPoints(section) {
+    const pts = [];
+    if (section.startPoint)
+        pts.push(section.startPoint);
+    for (const b of section.bendPoints ?? [])
+        pts.push(b);
+    if (section.endPoint)
+        pts.push(section.endPoint);
+    return pts;
+}
+function straightEdge(edge, nodeById) {
+    const source = nodeById.get(edge.sources?.[0] ?? '');
+    const target = nodeById.get(edge.targets?.[0] ?? '');
+    if (!source || !target)
+        return [];
+    return [
+        { x: source.x + source.width / 2, y: source.y + source.height / 2 },
+        { x: target.x + target.width / 2, y: target.y + target.height / 2 },
+    ];
+}
+/** Map a laid-out ELK graph back to the model's `LayoutResult`. */
+export function mapElkResult(model, result) {
+    const nodes = [];
+    const packages = [];
+    const offsets = new Map([['root', { x: 0, y: 0 }]]);
+    for (const child of result.children ?? []) {
+        flatten(child, 0, 0, nodes, packages, offsets);
+    }
+    enforcePackageMinWidth(model, packages);
+    const nodeById = new Map(nodes.map((n) => [n.id, n]));
+    const laidEdges = (result.edges ?? []).map((edge, i) => {
+        const relation = model.relations[i];
+        const reversed = relation !== undefined && relationSemantics(relation.type).isReversed();
+        const points = edgePoints(edge, nodeById, offsets);
+        return {
+            id: edge.id ?? `rel-${i}`,
+            // Keep the model's direction (not the possibly-reversed layout
+            // direction) so the renderer's arrowheads and the overlap counter both
+            // see the endpoints the author wrote.
+            source: relation?.source ?? (edge.sources?.[0] ?? ''),
+            target: relation?.target ?? (edge.targets?.[0] ?? ''),
+            points: reversed ? points.slice().reverse() : points,
+        };
+    });
+    return {
+        nodes,
+        edges: laidEdges,
+        packages,
+        width: result.width ?? 0,
+        height: result.height ?? 0,
+    };
+}

package/dist/layout/elk.d.ts

@@ -21,21 +21,23 @@
  *   edges share an in/out side and spread across distinct ports instead of
  *   piling onto one point.
  *
- * Cross-package edges would otherwise come back from ELK without any routing
- * section (the `INHERIT` hierarchy mode leaves them unresolved), so when the
- * model contains edges that cross *between two different packages* the engine
- * switches that layout to `INCLUDE_CHILDREN` — that is what lets ELK route
- * those edges around unrelated boxes and keeps `edgeNodeIntersections` at zero.
+ * Edges that cross a container boundary (package↔package, or package↔top-level
+ * stub) would otherwise come back from ELK without any routing section (the
+ * `INHERIT` hierarchy mode leaves them unresolved, and they degrade to straight
+ * diagonals), so when the model contains such edges the engine switches that
+ * layout to `INCLUDE_CHILDREN`, which routes them around unrelated boxes.
  *
- * A package↔top-level edge (e.g. a single-package view whose neighbours are
- * top-level stubs) deliberately does *not* switch the hierarchy handling:
- * `INCLUDE_CHILDREN` flattens a package with disconnected children into a
- * single-row strip instead of a packed grid, which is exactly the failure the
- * Tests Layer view used to show (`package-pkg-Tests_Layer` at aspect 14.9).
+ * `INCLUDE_CHILDREN` is one layered run over the whole nested graph, so it can
+ * flatten a package into a strip or stack a big graph into a sliver. When the
+ * result is badly proportioned (or the graph is very large) the engine falls
+ * back to the compound layout in [[./compound]]: each top-level package is laid
+ * out as its own block, blocks are packed, and cross-block edges are routed by
+ * the grid router in [[./grid-router]].
  */
 import type { ElkPoint } from 'elkjs';
-import { PlantUmlModel } from '../model.js';
-import { LayoutEngine, LayoutResult } from '../layout.js';
+import { PlantUmlModel } from '../foundation/model.js';
+import { LayoutEngine, LayoutResult } from '../foundation/layout.js';
+import { type LayoutStrategy } from './strategy.js';
 /** Edge routing strategies, evaluated in docs/layout-routing-eval.md. */
 export type EdgeRoutingMode = 'ORTHOGONAL' | 'POLYLINE' | 'SPLINES';
 /** Tuning knobs for the ELK engine. All are optional with sensible defaults. */
@@ -54,34 +56,62 @@ export interface ElkLayoutOptions {
      * into a weighted edge; default false.
      */
     mergeEdges?: boolean;
+    /**
+     * Target canvas width/height ratio (`elk.aspectRatio`), e.g. 16/9 for a
+     * desktop panel or 9/16 for a portrait phone. Default 1.6.
+     */
+    aspectRatio?: number;
+    /**
+     * Extra layout strategies tried, in order, before the built-in decision
+     * chain; the first to return a result wins (see [[./strategy]]).
+     */
+    strategies?: LayoutStrategy[];
+    /**
+     * Raw ELK options (`elk.*` keys), the escape hatch for knobs that have no
+     * named option here — e.g.
+     * `{ 'elk.layered.layering.strategy': 'COFFMAN_GRAHAM',
+     *    'elk.layered.layering.coffmanGraham.layerBound': '2' }` to cap how many
+     * nodes sit side by side per layer, which a plain `aspectRatio` cannot do.
+     *
+     * Every key is injected into the root graph *and* every package container
+     * node, recursively, so nested packages honour it too. Values override the
+     * engine's built-in defaults, but an explicitly-set named option wins a
+     * same-key collision (`aspectRatio` over `elk.aspectRatio`, `edgeRouting`
+     * over `elk.edgeRouting`, `mergeEdges` over `elk.layered.mergeEdges`).
+     *
+     * Known elkjs crash: `INCLUDE_CHILDREN` + `COFFMAN_GRAHAM` +
+     * `coffmanGraham.layerBound=2` + `elk.aspectRatio=1.6` throws
+     * `TypeError: Cannot read properties of undefined (reading 'c')`; steer clear
+     * of that exact combination (bound=2 with a different ratio is fine).
+     */
+    elk?: Record<string, string>;
 }
+/** Clear space kept between any edge point and the canvas side. */
+export declare const CANVAS_EDGE_MARGIN = 16;
+/**
+ * Translate and grow the canvas so no edge point (or node/frame) sits closer
+ * than [[CANVAS_EDGE_MARGIN]] to a canvas side — a line hugging the border is
+ * easily cropped.
+ */
+export declare function fitCanvas(layout: LayoutResult): LayoutResult;
 export declare class ElkLayoutEngine implements LayoutEngine {
     private readonly elk;
     private readonly options;
     constructor(options?: ElkLayoutOptions);
     layout(model: PlantUmlModel): Promise<LayoutResult>;
-    /** Source endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
-    private layoutSource;
-    /** Target endpoint of the edge *as laid out* (reversed for inheritance/implementation). */
-    private layoutTarget;
-    /** Ordered, de-duplicated list of semantic layers (dependency topology by default). */
-    private resolveLayerOrder;
-    /** Map each package to its partition index (layers first, unlayered last). */
-    private assignPartitions;
-    /** True when any relation connects entities in two *different* packages. */
-    private hasCrossPackageEdge;
-    private buildChildren;
-    private entityLeaf;
+    private layoutRaw;
+    /**
+     * A mid-scale root layer (many top-level packages) whose single hierarchical
+     * run left a large hole: the packed compound blocks are tried instead.
+     */
+    private isGappyMidScale;
     /**
-     * INCLUDE_CHILDREN sizes a container from its content and does not honour the
-     * `elk.nodeSize.minimum` we give package frames, so a single short-named
-     * entity can leave the frame narrower than its label tab. Widen those frames
-     * in place (never shrink) so the tab stays readable.
+     * Caller-requested canvas ratio: run both strategies and keep whichever lands
+     * closer (in log distance) to the target. The default path never gets here.
      */
-    private enforcePackageMinWidth;
-    private flatten;
-    private edgePoints;
-    private sectionPoints;
-    private straightEdge;
+    private layoutToward;
+    private compound;
+    /** One ELK run over the whole nested graph (`INCLUDE_CHILDREN`). */
+    private hierarchicalLayout;
 }
 export type { ElkPoint };