@yalehwang/plantuml-js 0.2.2 → 0.3.0

package/dist/foundation/layout.js

@@ -0,0 +1,298 @@
+/**
+ * LayoutEngine — the pluggable layout contract. A LayoutEngine is a pure
+ * function from PlantUmlModel to concrete positions; the parser never talks
+ * to a layout engine and the renderer never talks to the parser, so swapping
+ * engines (elkjs, @viz-js/viz, a custom tuner) is an injection, not a rewrite.
+ */
+import { measureTextWidth, MONOSPACE_FONT_SIZE } from './text-measure.js';
+/**
+ * Shared drawing metrics. The renderer reads these so entity sizing and the
+ * emitted SVG stay in lockstep: the font family and size are bound to the same
+ * monospace advance [[../text-measure]] measures with.
+ */
+export const METRICS = {
+    fontFamily: 'monospace',
+    fontSize: MONOSPACE_FONT_SIZE,
+    lineHeight: 18,
+    paddingX: 10,
+    paddingY: 8,
+    minWidth: 60,
+};
+/**
+ * Package label-tab geometry, shared by the renderer and the layout-metrics
+ * overlap counter so a drawn tab and a measured tab are the same rectangle.
+ */
+export const PACKAGE_LABEL = {
+    tabHeight: 20,
+    fontSize: 12,
+    tabPadding: 8,
+};
+/** Spacing grid (px). Entity box sizes snap up to a multiple of it. */
+export const GRID = 8;
+export function snapUp(n, grid = GRID) {
+    return Math.ceil(n / grid) * grid;
+}
+/** Reconstruct the name drawn in the title compartment, generics expanded. */
+export function displayName(entity) {
+    const generics = entity.generics;
+    if (!generics || generics.length === 0)
+        return entity.name;
+    return `${entity.name}<${generics.join(', ')}>`;
+}
+/**
+ * Approximate the on-canvas size of an entity box. The title plus every member
+ * line contributes one row; the width is the longest rendered line measured
+ * through the text table plus padding, never below MIN_WIDTH.
+ */
+export function estimateEntitySize(entity) {
+    const lines = [
+        displayName(entity),
+        ...entity.members.map((m) => m.raw),
+    ];
+    const longest = lines.reduce((max, line) => Math.max(max, measureTextWidth(line, METRICS.fontSize)), 0);
+    const width = snapUp(Math.max(METRICS.minWidth, longest + METRICS.paddingX * 2));
+    const height = snapUp(lines.length * METRICS.lineHeight + METRICS.paddingY * 2);
+    return { width, height };
+}
+/** Entity count up to which `full` is chosen automatically. */
+export const DETAIL_FULL_MAX_ENTITIES = 40;
+/** Entity count up to which `compact` is chosen automatically (beyond: `names`). */
+export const DETAIL_COMPACT_MAX_ENTITIES = 150;
+/** Member rows kept per entity in `compact` mode. */
+export const COMPACT_MEMBER_ROWS = 4;
+export function autoDetail(entityCount) {
+    if (entityCount <= DETAIL_FULL_MAX_ENTITIES)
+        return 'full';
+    if (entityCount <= DETAIL_COMPACT_MAX_ENTITIES)
+        return 'compact';
+    return 'names';
+}
+/**
+ * Reduce member rows to the requested detail level *before* layout, so boxes
+ * are sized for what is actually drawn. `undefined` picks by entity count.
+ */
+export function applyDetail(model, detail) {
+    const level = detail ?? autoDetail(model.entities.length);
+    if (level === 'full')
+        return model;
+    return {
+        ...model,
+        entities: model.entities.map((entity) => {
+            const total = entity.members.length;
+            if (level === 'names')
+                return total === 0 ? entity : { ...entity, members: [] };
+            if (total <= COMPACT_MEMBER_ROWS)
+                return entity;
+            const kept = entity.members.slice(0, COMPACT_MEMBER_ROWS);
+            const more = {
+                visibility: 'public',
+                name: '…',
+                kind: 'field',
+                modifiers: [],
+                raw: `… +${total - COMPACT_MEMBER_ROWS} more (${total} members)`,
+            };
+            return { ...entity, members: [...kept, more] };
+        }),
+    };
+}
+/**
+ * Group nodes into rows: within one package (or the top level), nodes whose
+ * vertical extents overlap belong to the same layered-layout rank. Returns
+ * arrays of node ids, each sorted top-to-bottom.
+ */
+export function layoutRows(model, layout) {
+    const pkgOf = new Map(model.entities.map((e) => [e.id, e.packageId ?? '']));
+    const groups = new Map();
+    for (const node of layout.nodes) {
+        const key = pkgOf.get(node.id) ?? '';
+        const list = groups.get(key);
+        if (list)
+            list.push(node);
+        else
+            groups.set(key, [node]);
+    }
+    const rows = [];
+    for (const list of groups.values()) {
+        const sorted = list.slice().sort((a, b) => a.y - b.y || a.x - b.x);
+        let row = [];
+        let bottom = -Infinity;
+        for (const node of sorted) {
+            if (row.length > 0 && node.y >= bottom) {
+                rows.push(row);
+                row = [];
+                bottom = -Infinity;
+            }
+            row.push(node);
+            bottom = Math.max(bottom, node.y + node.height);
+        }
+        if (row.length > 0)
+            rows.push(row);
+    }
+    return rows;
+}
+/**
+ * Top-align the nodes of every row (never moving a node down or out of its
+ * package) and keep edges attached: an endpoint on a moved node shifts with it,
+ * dragging along the next bend when the first segment is horizontal, so
+ * orthogonal routes stay orthogonal. Mutates and returns `layout`.
+ */
+export function alignRows(model, layout) {
+    if (model.entities.length > ALIGN_MAX_ENTITIES)
+        return layout;
+    const edges = layout.edges ?? [];
+    for (const row of layoutRows(model, layout)) {
+        if (row.length < 2)
+            continue;
+        const top = Math.min(...row.map((n) => n.y));
+        for (const node of row) {
+            const dy = top - node.y;
+            if (dy === 0)
+                continue;
+            // Moving up must not run the box into another node or a foreign edge.
+            const next = { x: node.x, y: top, width: node.width, height: node.height };
+            if (layout.nodes.some((o) => o !== node && boxesOverlap(next, o)))
+                continue;
+            if (edges.some((e) => e.source !== node.id && e.target !== node.id && polylineHitsBox(e.points, next))) {
+                continue;
+            }
+            // Re-attach the node's own edges; refuse the move if any orthogonal
+            // edge would turn diagonal.
+            const patched = new Map();
+            let ok = true;
+            for (const edge of edges) {
+                if (edge.source !== node.id && edge.target !== node.id)
+                    continue;
+                const pts = edge.points.map((p) => ({ ...p }));
+                if (pts.length < 2)
+                    continue;
+                const wasOrthogonal = isOrthogonal(edge.points);
+                const ends = [
+                    [edge.source, 0, 1],
+                    [edge.target, pts.length - 1, pts.length - 2],
+                ];
+                for (const [id, i, nxt] of ends) {
+                    if (id !== node.id)
+                        continue;
+                    const horizontal = Math.abs(pts[i].y - pts[nxt].y) < 0.01;
+                    if (horizontal) {
+                        // A side port still inside the moved box's span needs no change.
+                        if (pts[i].y > top && pts[i].y < top + node.height)
+                            continue;
+                        pts[i].y += dy;
+                        if (pts.length > 2)
+                            pts[nxt].y += dy;
+                    }
+                    else {
+                        pts[i].y += dy;
+                    }
+                }
+                if (wasOrthogonal && !isOrthogonal(pts)) {
+                    ok = false;
+                    break;
+                }
+                patched.set(edge, pts);
+            }
+            if (!ok)
+                continue;
+            node.y = top;
+            for (const [edge, pts] of patched)
+                edge.points = pts;
+        }
+    }
+    return layout;
+}
+/**
+ * Top-align an isolated package frame (no edge touches any entity inside it)
+ * with the topmost side-by-side neighbour frame, so a lone package sits level
+ * with its neighbour instead of floating at its own offset. Only moves up, and
+ * only when the frame (with its contents) stays clear of everything else.
+ * Mutates and returns `layout`.
+ */
+export function alignIsolatedFrames(model, layout) {
+    const frames = layout.packages ?? [];
+    const roots = model.packages.filter((p) => p.parentId === undefined);
+    if (roots.length < 2 || frames.length === 0)
+        return layout;
+    const parentOf = new Map(model.packages.map((p) => [p.id, p.parentId]));
+    const rootOf = (id) => {
+        let cur = id;
+        while (cur !== undefined && parentOf.get(cur) !== undefined)
+            cur = parentOf.get(cur);
+        return cur;
+    };
+    const entityRoot = new Map(model.entities.map((e) => [e.id, rootOf(e.packageId)]));
+    const touched = new Set();
+    for (const r of model.relations) {
+        for (const id of [r.source, r.target]) {
+            const root = entityRoot.get(id);
+            if (root !== undefined)
+                touched.add(root);
+        }
+        if (r.sourcePackageId)
+            touched.add(rootOf(r.sourcePackageId));
+        if (r.targetPackageId)
+            touched.add(rootOf(r.targetPackageId));
+    }
+    const byId = new Map(frames.map((f) => [f.id, f]));
+    const rootFrames = roots.map((r) => byId.get(r.id)).filter((f) => f !== undefined);
+    for (const frame of rootFrames) {
+        if (touched.has(frame.id))
+            continue;
+        const neighbours = rootFrames.filter((g) => g !== frame && g.y < frame.y && g.y + g.height > frame.y &&
+            (g.x + g.width <= frame.x || frame.x + frame.width <= g.x));
+        if (neighbours.length === 0)
+            continue;
+        const top = Math.min(...neighbours.map((g) => g.y));
+        const dy = top - frame.y;
+        const inFrame = (pid) => rootOf(pid) === frame.id;
+        const memberNodes = layout.nodes.filter((n) => inFrame(model.entities.find((e) => e.id === n.id)?.packageId));
+        const memberFrames = frames.filter((f) => inFrame(f.id));
+        const moved = { x: frame.x, y: top, width: frame.width, height: frame.height };
+        const others = [
+            ...rootFrames.filter((g) => g !== frame),
+            ...layout.nodes.filter((n) => !memberNodes.includes(n)),
+        ];
+        if (others.some((o) => boxesOverlap(moved, o)))
+            continue;
+        if ((layout.edges ?? []).some((e) => polylineHitsBox(e.points, moved)))
+            continue;
+        for (const n of memberNodes)
+            n.y += dy;
+        for (const f of memberFrames)
+            f.y += dy;
+    }
+    return layout;
+}
+function isOrthogonal(points) {
+    for (let i = 0; i + 1 < points.length; i++) {
+        if (Math.abs(points[i].x - points[i + 1].x) > 0.01 && Math.abs(points[i].y - points[i + 1].y) > 0.01) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Row alignment is skipped above this size (its blocking checks are O(n·m)). */
+const ALIGN_MAX_ENTITIES = 150;
+function boxesOverlap(a, b) {
+    return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+/** True when any segment's bounding box crosses the box interior. */
+function polylineHitsBox(points, box) {
+    for (let i = 0; i + 1 < points.length; i++) {
+        const a = points[i];
+        const b = points[i + 1];
+        const seg = {
+            x: Math.min(a.x, b.x),
+            y: Math.min(a.y, b.y),
+            width: Math.abs(a.x - b.x),
+            height: Math.abs(a.y - b.y),
+        };
+        if (seg.x < box.x + box.width && box.x < seg.x + seg.width &&
+            seg.y <= box.y + box.height && box.y <= seg.y + seg.height &&
+            !(seg.width === 0 && (seg.x <= box.x || seg.x >= box.x + box.width)) &&
+            !(seg.height === 0 && (seg.y <= box.y || seg.y >= box.y + box.height))) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/{model.d.ts → foundation/model.d.ts}

@@ -43,6 +43,14 @@ export interface PlantUmlEntity {
      * no members and are drawn with a distinct frame.
      */
     stub?: boolean;
+    /** Names of the stubs merged into a group stub; listed in its `<title>`. */
+    groupMembers?: string[];
+    /**
+     * True when the entity was never declared and only exists because a relation
+     * named it (an implicit/external type such as `Error`). Drawn with a weaker
+     * style and grouped under a synthetic External package.
+     */
+    external?: boolean;
 }
 export type RelationType = 'inheritance' | 'implementation' | 'dependency' | 'association' | 'aggregation' | 'composition';
 export interface PlantUmlRelation {
@@ -63,6 +71,18 @@ export interface PlantUmlRelation {
     weight?: number;
     /** True when this edge is a cycle feedback arc, drawn in a distinct color. */
     feedback?: boolean;
+    /**
+     * One line per original relation folded into an inter-package corridor edge
+     * (`A --> B`); rendered as the edge's `<title>`.
+     */
+    descriptions?: string[];
+    /**
+     * Set when the authored endpoint named a package rather than an entity: the
+     * edge is laid out against a representative entity inside it, and the
+     * layout clips its end to the package frame boundary.
+     */
+    sourcePackageId?: string;
+    targetPackageId?: string;
 }
 export interface PlantUmlPackage {
     id: string;

package/dist/foundation/relation-semantics.d.ts

@@ -0,0 +1,49 @@
+/**
+ * RelationType semantics — the single place that knows what each relation kind
+ * *means*.
+ *
+ * `RelationType` is a closed enum, but its behaviour used to be decided
+ * independently by every consumer: layout reversal in `elk-graph`/`compound`,
+ * line style and arrowheads in `svg`/`viz`, bundling and reduction eligibility
+ * in `svg`/`transform`. The copies drifted — the viz DOT said `implementation`
+ * was dashed while the SVG renderer drew it solid. Consumers now read this
+ * table and only translate the facts into their own output format (SVG DOM,
+ * DOT attributes, ELK endpoints).
+ *
+ * It lives in `foundation/` (the shared lowest layer) because layout/, render/
+ * and transform/ all consume it: a module at the `src/` root would be imported
+ * by subdirectories that the root itself imports, creating a package cycle.
+ */
+import type { RelationType } from './model.js';
+/** Shape a relation type puts at the arrow end (`none`: no head). */
+export type RelationArrowKind = 'triangle' | 'chevron' | 'diamond' | 'none';
+/**
+ * The behavioural facts of one relation type, exposed as **methods**. Each
+ * fact is a decision, not a rendering instruction: `isDashed()` is "this line
+ * is dashed", `svg.ts` decides *which* dash token that maps to.
+ *
+ * The methods are the whole public surface — consumers ask the value object
+ * what to do instead of reading how it remembers the answer. That keeps the
+ * representation private: a fact that later becomes a computation (rather than
+ * a stored boolean) changes only this module, not every call site.
+ */
+export interface RelationSemantics {
+    /** Layout direction is reversed: the arrow target sits above the source. */
+    isReversed(): boolean;
+    /** The connection line is dashed. */
+    isDashed(): boolean;
+    /** Shape of the arrowhead. */
+    arrowKind(): RelationArrowKind;
+    /** A diamond head is filled (composition) rather than hollow (aggregation). */
+    isFilled(): boolean;
+    /** A weak relation, drawn in the lighter edge colour. */
+    isWeak(): boolean;
+    /** Eligible for edge bundling and automatic transitive reduction. */
+    isBundlable(): boolean;
+}
+/** Every relation type and the behaviour it implies. */
+export declare const RELATION_SEMANTICS: Readonly<Record<RelationType, RelationSemantics>>;
+/** The behavioural facts of one relation type. */
+export declare function relationSemantics(type: RelationType): RelationSemantics;
+/** Every relation type, in declaration order (for consumers that iterate the closed enum). */
+export declare const RELATION_TYPES: readonly RelationType[];

package/dist/foundation/relation-semantics.js

@@ -0,0 +1,112 @@
+/**
+ * RelationType semantics — the single place that knows what each relation kind
+ * *means*.
+ *
+ * `RelationType` is a closed enum, but its behaviour used to be decided
+ * independently by every consumer: layout reversal in `elk-graph`/`compound`,
+ * line style and arrowheads in `svg`/`viz`, bundling and reduction eligibility
+ * in `svg`/`transform`. The copies drifted — the viz DOT said `implementation`
+ * was dashed while the SVG renderer drew it solid. Consumers now read this
+ * table and only translate the facts into their own output format (SVG DOM,
+ * DOT attributes, ELK endpoints).
+ *
+ * It lives in `foundation/` (the shared lowest layer) because layout/, render/
+ * and transform/ all consume it: a module at the `src/` root would be imported
+ * by subdirectories that the root itself imports, creating a package cycle.
+ */
+/** Build the methods-only public view over one private fact set. */
+function semantics(facts) {
+    return Object.freeze({
+        isReversed: () => facts.reversed,
+        isDashed: () => facts.dashed,
+        arrowKind: () => facts.arrowKind,
+        isFilled: () => facts.filled,
+        isWeak: () => facts.weak,
+        isBundlable: () => facts.bundlable,
+    });
+}
+/**
+ * Relation types whose layout direction is reversed so the arrow target sits
+ * above the source. The one and only definition of this fact.
+ */
+const REVERSED_RELATION_TYPES = new Set(['inheritance', 'implementation']);
+/** Every relation type and the behaviour it implies. */
+export const RELATION_SEMANTICS = {
+    inheritance: semantics({
+        reversed: REVERSED_RELATION_TYPES.has('inheritance'),
+        dashed: false,
+        arrowKind: 'triangle',
+        filled: false,
+        weak: false,
+        bundlable: false,
+    }),
+    implementation: semantics({
+        reversed: REVERSED_RELATION_TYPES.has('implementation'),
+        // PlantUML `..|>` — dashed, but not a "weak" (lighter) edge.
+        dashed: true,
+        arrowKind: 'triangle',
+        filled: false,
+        weak: false,
+        bundlable: false,
+    }),
+    dependency: semantics({
+        reversed: false,
+        dashed: true,
+        arrowKind: 'chevron',
+        filled: false,
+        weak: true,
+        bundlable: true,
+    }),
+    association: semantics({
+        reversed: false,
+        dashed: false,
+        arrowKind: 'chevron',
+        filled: false,
+        weak: false,
+        bundlable: true,
+    }),
+    aggregation: semantics({
+        reversed: false,
+        dashed: false,
+        arrowKind: 'diamond',
+        filled: false,
+        weak: false,
+        bundlable: false,
+    }),
+    composition: semantics({
+        reversed: false,
+        dashed: false,
+        arrowKind: 'diamond',
+        filled: true,
+        weak: false,
+        bundlable: false,
+    }),
+};
+/**
+ * Facts for a relation type outside the closed `RelationType` domain. External
+ * input (JSON fixtures, hosts) can carry such a type; every consumer used to
+ * treat it as an anonymous line via `Set.has()` / `===` checks — no reversal,
+ * no dash, no arrowhead, not weak, not bundlable. Keep exactly that instead of
+ * failing the lookup.
+ */
+const UNKNOWN_RELATION_SEMANTICS = semantics({
+    reversed: false,
+    dashed: false,
+    arrowKind: 'none',
+    filled: false,
+    weak: false,
+    bundlable: false,
+});
+/** The behavioural facts of one relation type. */
+export function relationSemantics(type) {
+    return RELATION_SEMANTICS[type] ?? UNKNOWN_RELATION_SEMANTICS;
+}
+/** Every relation type, in declaration order (for consumers that iterate the closed enum). */
+export const RELATION_TYPES = [
+    'inheritance',
+    'implementation',
+    'dependency',
+    'association',
+    'aggregation',
+    'composition',
+];

package/dist/{text-measure.d.ts → foundation/text-measure.d.ts}

@@ -21,6 +21,8 @@ export declare const MONOSPACE_ADVANCE_EM = 0.61;
  * its shape, contributes the same advance.
  */
 export declare function measureTextWidth(text: string, fontSize?: number): number;
+/** Width of `text` in monospace cells: CJK / fullwidth code points count 2, the rest 1. */
+export declare function textUnits(text: string): number;
 export interface TextMeasurer {
     width(text: string, fontSize?: number): number;
 }

package/dist/{text-measure.js → foundation/text-measure.js}

@@ -21,7 +21,26 @@ export const MONOSPACE_ADVANCE_EM = 0.61;
  * its shape, contributes the same advance.
  */
 export function measureTextWidth(text, fontSize = MONOSPACE_FONT_SIZE) {
-    return Math.ceil(text.length * MONOSPACE_ADVANCE_EM * fontSize * 100) / 100;
+    return Math.ceil(textUnits(text) * MONOSPACE_ADVANCE_EM * fontSize * 100) / 100;
+}
+/** East Asian wide / fullwidth ranges: these glyphs advance two monospace cells. */
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd));
+}
+/** Width of `text` in monospace cells: CJK / fullwidth code points count 2, the rest 1. */
+export function textUnits(text) {
+    let units = 0;
+    for (const ch of text)
+        units += isWide(ch.codePointAt(0)) ? 2 : 1;
+    return units;
 }
 export function createTextMeasurer() {
     return { width: (text, fontSize) => measureTextWidth(text, fontSize) };

package/dist/index.d.ts

@@ -6,10 +6,10 @@
  * bundle stays free of the Graphviz WASM.
  */
 import { VizLayoutEngine } from './layout/viz.js';
-import { renderDot } from './render-dot.js';
+import { renderDot } from './foundation/render-dot.js';
 import { Renderer, RendererOptions } from './core.js';
 export * from './core.js';
-export type { GraphvizEngine } from './render-dot.js';
+export type { GraphvizEngine } from './foundation/render-dot.js';
 export { renderDot, VizLayoutEngine };
 /**
  * Build a renderer. `layout` is `'elk'` (default), `'viz'` (experimental), or a

package/dist/index.js

@@ -6,7 +6,7 @@
  * bundle stays free of the Graphviz WASM.
  */
 import { VizLayoutEngine } from './layout/viz.js';
-import { renderDot } from './render-dot.js';
+import { renderDot } from './foundation/render-dot.js';
 import { createRenderer as createCoreRenderer, } from './core.js';
 export * from './core.js';
 export { renderDot, VizLayoutEngine };

package/dist/layout/compound.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Compound layout — lay packages out as independent blocks, place the blocks,
+ * then route the edges that cross block boundaries.
+ *
+ * A single hierarchical layered run (`INCLUDE_CHILDREN`) routes every edge but
+ * stacks all layers of every package into one tall strip: the 660-entity
+ * archguard `all-classes` graph came out 13455×79369. Here each top-level
+ * package is laid out on its own (packed to a balanced rectangle), the blocks
+ * are arranged as plain nodes — layered for small block counts, rectpacking for
+ * large ones — and [[routeOrthogonal]] draws the cross-block edges around the
+ * leaf boxes along the channels between blocks.
+ */
+import type { ELK as ElkInstance, ElkNode } from 'elkjs';
+import type { PlantUmlModel } from '../foundation/model.js';
+import { type LayoutResult } from '../foundation/layout.js';
+import { type BoxPlacementContext, type PlacementStrategy, type PlacementStrategyOptions, type StubOrbit } from './placement-strategy.js';
+export type { StubOrbit } from './placement-strategy.js';
+export interface CompoundOptions extends PlacementStrategyOptions {
+    edgeRouting?: string;
+    /** Rip-up passes of the cross-block router; its default when omitted. */
+    ripupPasses?: number;
+    /**
+     * Extra block-placement strategies tried, in order, before the built-in
+     * chain; the first to return a placement wins (see [[./placement-strategy]]).
+     */
+    placementStrategies?: PlacementStrategy[];
+}
+export declare const DEFAULT_STUB_ORBIT: StubOrbit;
+export declare function compoundLayout(elk: ElkInstance, model: PlantUmlModel, options: CompoundOptions): Promise<LayoutResult>;
+/**
+ * Equal-column grid for unconnected boxes: the column width is the widest box,
+ * rows are as tall as their tallest box and boxes are top-left aligned, so
+ * columns and rows line up. The column count is the one whose block lands
+ * closest to `aspect`; the last row alone may be short. `tight` sizes each column
+ * to its own widest box and hands the narrowest boxes to the first columns; without
+ * it every column is as wide as the widest box overall and the flow order is kept.
+ */
+export declare function gridPack(children: ElkNode[], order: string[], aspect: number, gap: number, rowGap?: number, tight?: boolean): ElkNode;
+/** Box placement strategies: the equal-column grid and the ordered shelf pack. */
+export declare const gridPackPlacementStrategy: PlacementStrategy<BoxPlacementContext>;
+export declare const orderedShelfPackPlacementStrategy: PlacementStrategy<BoxPlacementContext>;
+/** Stubs orbit the placed main blocks instead of taking part in their placement. */
+export declare const stubOrbitPlacementStrategy: PlacementStrategy;
+/** Semantic layers as stacked bands of blocks. */
+export declare const layerRowsPlacementStrategy: PlacementStrategy;
+/**
+ * Height-sorted shelf packing of the blocks; [[packedBlocksPlacementStrategy]]
+ * keeps it as one candidate beside ELK's own rect-packing runs.
+ */
+export declare const shelfPackBlocksPlacementStrategy: PlacementStrategy;
+/**
+ * Rect packing of the blocks: height-sorted shelves are tried beside ELK's own
+ * rectpacking at a few ratios, and the tightest canvas near the target wins.
+ */
+export declare const packedBlocksPlacementStrategy: PlacementStrategy;
+/** Blocks placed by ELK's layered algorithm (no partitions, few enough to layer). */
+export declare const elkLayeredPlacementStrategy: PlacementStrategy;
+/** Built-in block placement chain, tried after any injected strategies. */
+export declare const DEFAULT_PLACEMENT_STRATEGIES: readonly PlacementStrategy[];