@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/layout/layout-host.js

@@ -0,0 +1,523 @@
+"use strict";
+// Wave 7 (Auto-layout) — Card 3: the worker seam for layout.
+//
+// Direct descendant of routing/global/solver-host.ts (wave 5, card 7), which
+// solved the identical shape and shipped. Same three ideas, and they are the
+// reason this file is short:
+//
+//   • the algorithm stays PURE and SYNCHRONOUS, so the same code runs on both
+//     sides of the boundary and cannot drift;
+//   • `serveLayout(port)` IS the worker body — a message loop, nothing more;
+//   • the inline fallback LOOPS THROUGH THE SAME MESSAGE LOOP, so the protocol
+//     is exercised even in-process. There is one code path, not two, and a test
+//     proves the two produce byte-identical coordinates.
+//
+// And, as there: this host does NOT construct the Worker. Doing so would bake
+// one bundler's URL scheme into the engine — which is precisely the mistake the
+// old `LayoutWorkerPool` made (`new Worker('/assets/workers/layout.worker.js')`,
+// a path that no build in this repo has ever produced). The caller builds the
+// worker however its toolchain likes and hands the port in.
+//
+// WHAT THIS CARD ADDS OVER THE ROUTING PRECEDENT
+// -----------------------------------------------
+// Streaming progress, mid-run cancellation, time budgets, and partial results.
+//
+// The load-bearing one is PARTIAL RESULTS. A force layout cancelled after 200 of
+// 300 iterations has a perfectly usable picture. Throwing it away — which is what
+// the old `LayoutWorkerPool.cancelRequest()` did, by *rejecting* the promise — is
+// the difference between a tool that feels alive and one that feels broken.
+//
+// THE TRAP THAT MAKES NAIVE WORKER CANCELLATION A LIE
+// ---------------------------------------------------
+// A worker is single-threaded. While it runs a synchronous 300-iteration loop it
+// is NOT reading its message queue, so the `cancel` you posted sits there
+// undelivered until the loop it was meant to interrupt has finished. Setting a
+// flag from `onmessage` cannot possibly work; the old worker script even admitted
+// it in a comment ("we set the flag and hope the algorithm checks it").
+//
+// The fix is to make the run YIELD TO THE EVENT LOOP periodically, so pending
+// messages actually get delivered. Hence `sliceMs`: we compute for a slice, then
+// surrender the thread long enough for the queue to drain, then check the flag.
+// Cancellation latency is one slice, not one layout. (The alternative — a
+// SharedArrayBuffer the loop polls — needs cross-origin isolation headers, so it
+// is not a default we can rely on.)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutHost = void 0;
+exports.serveLayout = serveLayout;
+const tslib_1 = require("tslib");
+const component_packing_1 = require("./component-packing");
+const steppable_layout_1 = require("./steppable-layout");
+const layout_graph_1 = require("./layout-graph");
+const layout_registry_1 = require("./layout-registry");
+const layout_quality_metrics_1 = require("./layout-quality-metrics");
+// ---------------------------------------------------------------------------
+// The worker body.
+// ---------------------------------------------------------------------------
+/** How long to compute between surrenders of the thread. See the trap, above. */
+const DEFAULT_SLICE_MS = 12;
+/** Progress messages: at most one per ~frame… */
+const PROGRESS_EMIT_MIN_MS = 16;
+/** …unless the run advanced ≥10% since the last one (keeps FAST runs streamy). */
+const PROGRESS_EMIT_MIN_DELTA = 0.1;
+/**
+ * Surrender the thread just long enough for queued messages to be delivered.
+ *
+ * MessageChannel rather than `setTimeout(0)`: nested timeouts get clamped to 4ms
+ * by every browser, and paying 4ms per slice would cost more than the layout.
+ */
+function yieldToEventLoop() {
+    return new Promise((resolve) => {
+        if (typeof MessageChannel !== 'undefined') {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = () => {
+                channel.port1.close();
+                resolve();
+            };
+            channel.port2.postMessage(0);
+        }
+        else {
+            setTimeout(resolve, 0);
+        }
+    });
+}
+/**
+ * The worker's own resolver: build an adapter the first time it is named, and
+ * never build one that is not.
+ *
+ * LAZY ON PURPOSE. Eagerly constructing the built-ins means constructing ELK,
+ * and elkjs's constructor spawns its own nested Worker — which inside a Worker
+ * throws `_Worker is not a constructor` and kills the layout worker on the very
+ * line that starts it. See createBuiltInLayoutFactories().
+ *
+ * (ELK therefore remains a main-thread algorithm in practice — no great loss:
+ * elkjs already offloads itself to a worker of its own, so it never blocked the
+ * main thread the way dagre and force do.)
+ */
+function defaultResolver() {
+    const factories = (0, layout_registry_1.createBuiltInLayoutFactories)();
+    const built = new Map();
+    return (name) => {
+        const existing = built.get(name);
+        if (existing)
+            return existing;
+        const make = factories.get(name);
+        if (!make)
+            return undefined;
+        // MERGE (Cards 2 + 3): every algorithm the host runs is wrapped in COMPONENT
+        // PACKING before it is handed anything.
+        //
+        // Card 2 made packing a property of every registered layout by wrapping
+        // `apply(diagram)`. Card 3 then routed the flat path through this host, which
+        // ships `(nodes, links)` and runs the RAW adapter — stepping neatly around the
+        // wrapper. A disconnected graph promptly went back to laying its components on
+        // top of each other, which is precisely the bug Card 2 exists to kill (and its
+        // forest tests caught it the moment the two branches met).
+        //
+        // Wrapping here rather than at the call site means the INLINE and the WORKER
+        // paths pack identically — the same one-protocol discipline the rest of this
+        // file is built on. Packing is a provable no-op for a connected graph, so this
+        // costs nothing when there is nothing to pack.
+        const raw = make();
+        // Object.create, NOT a spread. Spreading a class instance copies only its OWN
+        // properties, so `step()`/`snapshot()` — which live on the prototype — vanish,
+        // `isSteppable()` goes false, and force silently drops off the steppable path
+        // onto the opaque one: no progress, no cancellation, no partial result. (That
+        // is exactly what happened when these two branches first met, and Card 3's own
+        // tests caught it.) Delegating through the prototype keeps the algorithm whole
+        // and overrides only `apply`.
+        const adapter = Object.create(raw);
+        adapter.apply = (nodes, links, options) => (0, component_packing_1.layoutWithComponentPacking)(raw.name, (n, l, o) => raw.apply(n, l, o), nodes, links, (options !== null && options !== void 0 ? options : {}));
+        built.set(name, adapter);
+        return adapter;
+    };
+}
+/**
+ * Serve layout requests on a port. This IS the worker's message loop — call it
+ * inside the worker script with `self`, or in a test with a fake port, or (see
+ * `LayoutHost`) on the inline side of a loopback pair.
+ */
+function serveLayout(port, deps = {}) {
+    var _a, _b;
+    const resolve = (_a = deps.resolve) !== null && _a !== void 0 ? _a : defaultResolver();
+    const now = (_b = deps.now) !== null && _b !== void 0 ? _b : (() => Date.now());
+    // Cancels are recorded by seq, NOT applied to "the current run". A cancel can
+    // legitimately arrive before its run does (the host sends one up-front when it
+    // is handed an already-aborted signal), and message order is preserved across
+    // a real port — so remembering it is both correct and simpler than racing.
+    const cancelled = new Set();
+    port.onmessage = (event) => {
+        const request = event.data;
+        if (request.kind === 'cancel') {
+            cancelled.add(request.target);
+            return;
+        }
+        void run(request);
+    };
+    function run(request) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { seq } = request;
+            try {
+                // Resolution can THROW, not merely return undefined: an adapter is
+                // constructed here, and construction can fail for reasons peculiar to the
+                // thread we are on (ELK's does, inside a Worker). A bare rethrow would
+                // surface as "_Worker is not a constructor" with no clue which layout or
+                // why — so name it.
+                let adapter;
+                try {
+                    adapter = resolve(request.algorithm);
+                }
+                catch (constructionError) {
+                    const detail = constructionError instanceof Error
+                        ? constructionError.message
+                        : String(constructionError);
+                    port.postMessage({
+                        seq,
+                        kind: 'error',
+                        message: `Layout '${request.algorithm}' could not be constructed in this context: ${detail}`,
+                    });
+                    return;
+                }
+                if (!adapter) {
+                    port.postMessage({
+                        seq,
+                        kind: 'error',
+                        message: `Unknown layout '${request.algorithm}'`,
+                    });
+                    return;
+                }
+                const { nodes, links } = (0, layout_graph_1.reviveGraph)(request.graph);
+                const sliceMs = (_a = request.sliceMs) !== null && _a !== void 0 ? _a : DEFAULT_SLICE_MS;
+                const startedAt = now();
+                const emit = (progress, phase, iteration, totalIterations) => {
+                    port.postMessage({
+                        seq,
+                        kind: 'progress',
+                        progress,
+                        phase,
+                        iteration,
+                        totalIterations,
+                    });
+                };
+                const finish = (result, partial, reason, iteration, totalIterations) => {
+                    cancelled.delete(seq);
+                    port.postMessage({
+                        seq,
+                        kind: 'result',
+                        algorithm: request.algorithm,
+                        positions: [...result.nodePositions],
+                        bounds: result.bounds,
+                        partial,
+                        reason,
+                        iteration,
+                        totalIterations,
+                        metadata: result.metadata,
+                        quality: result.quality,
+                        portAware: result.portAware,
+                        subgraph: result.subgraph,
+                        edgeBundling: result.edgeBundling,
+                    });
+                };
+                // -- The interruptible path -------------------------------------------
+                //
+                // TWO CARDS MEET HERE, AND ONE HAS TO YIELD. A steppable algorithm is driven
+                // through step()/snapshot(), which BYPASSES apply() — and apply() is where
+                // Card 2's component packing lives. So a disconnected graph run on the
+                // steppable path comes back with its components laid on top of each other:
+                // exactly the bug packing exists to kill.
+                //
+                // A forest therefore takes the packed path even when the algorithm could have
+                // been interrupted. The trade is stated rather than hidden: you lose mid-run
+                // cancellation on a DISCONNECTED force layout (it still runs off the main
+                // thread, and can still be cancelled before it starts), and you keep a picture
+                // that is actually readable. A connected graph — the overwhelmingly common
+                // case, and the one where a long force run actually hurts — is unaffected.
+                const componentCount = (0, component_packing_1.findConnectedComponents)(nodes, links).length;
+                if ((0, steppable_layout_1.isSteppable)(adapter) && componentCount <= 1) {
+                    const layoutRun = adapter.createRun(nodes, links, request.options);
+                    const total = layoutRun.totalIterations;
+                    emit(0, 'start', 0, total);
+                    let stop;
+                    let sliceStart = now();
+                    // Progress EMISSION is throttled independently of the YIELD cadence.
+                    // Found live: coupling them meant sliceMs:0 (maximal preemptibility)
+                    // posted one progress message PER ITERATION — ~4000 for a long force
+                    // run — flooding the caller's event loop so badly that a setTimeout
+                    // abort on the main thread fired only after the run had already
+                    // finished: signal cancellation raced, machine-speed dependent. The
+                    // yield IS the cancellation contract and stays per-slice; a progress
+                    // message is only worth sending every ~frame or every 10% of the run.
+                    let lastEmitAt = now();
+                    let lastEmitProgress = 0;
+                    for (;;) {
+                        if (cancelled.has(seq)) {
+                            stop = 'cancelled';
+                            break;
+                        }
+                        if (request.stopAfterIteration !== undefined &&
+                            layoutRun.iteration >= request.stopAfterIteration) {
+                            stop = 'iteration-cap';
+                            break;
+                        }
+                        if (request.timeBudgetMs !== undefined &&
+                            now() - startedAt >= request.timeBudgetMs) {
+                            stop = 'timeout';
+                            break;
+                        }
+                        if (!layoutRun.step())
+                            break; // converged, or hit the iteration cap
+                        // Slice boundary: surrender the thread so a `cancel` can actually be
+                        // delivered — and stream a progress event only when it is DUE
+                        // (≥ PROGRESS_EMIT_MIN_MS since the last one, or ≥ 10% more of the
+                        // run done), never per-slice.
+                        if (now() - sliceStart >= sliceMs) {
+                            const progressNow = total > 0 ? Math.min(layoutRun.iteration / total, 1) : 1;
+                            if (now() - lastEmitAt >= PROGRESS_EMIT_MIN_MS ||
+                                progressNow - lastEmitProgress >= PROGRESS_EMIT_MIN_DELTA) {
+                                emit(progressNow, 'iterating', layoutRun.iteration, total);
+                                lastEmitAt = now();
+                                lastEmitProgress = progressNow;
+                            }
+                            yield yieldToEventLoop();
+                            sliceStart = now();
+                        }
+                    }
+                    // A final progress event, always: consumers watch the stream reach its
+                    // true end value (a completed run must reach exactly 1 — the off-thread
+                    // demo asserts it), and the throttle above may have held the last one.
+                    emit(total > 0 ? Math.min(layoutRun.iteration / total, 1) : 1, 'iterating', layoutRun.iteration, total);
+                    // snapshot() is valid after ANY number of steps — including zero. This
+                    // is the whole point: a cancelled run hands back what it has.
+                    const result = layoutRun.snapshot();
+                    // ------------------------------------------------------------------
+                    // wave10/gallery — BUG FIX. Separate the boxes the simulation left on
+                    // top of each other.
+                    //
+                    // This branch bypasses `adapter.apply()` on purpose — it has to, because
+                    // `apply()` is one opaque call and this path exists to step, report and
+                    // cancel. But `apply()` is where the overlap pass lived, so bypassing it
+                    // silently bypassed that too.
+                    //
+                    // FORCE IS THE ONLY STEPPABLE BUILT-IN. So the single algorithm that
+                    // actually needs overlap removal — force lays out dimensionless POINTS —
+                    // was the single algorithm that never received it, and
+                    // `engine.layout('force')` returned intersecting node boxes. Every unit
+                    // test stayed green: they all reach force through `apply()`.
+                    //
+                    // Applied to the PARTIAL result too, deliberately. A cancelled force run
+                    // is meant to leave "a real, coherent picture" behind (see
+                    // commitLayoutPositions) — a pile of stacked boxes is not one.
+                    // ------------------------------------------------------------------
+                    (0, component_packing_1.separateOverlappingNodes)(nodes, result.nodePositions, request.options);
+                    result.bounds = boundsOfPositions(nodes, result.nodePositions);
+                    // `calculateQuality` must mean the same thing on both paths. The steppable
+                    // adapters compute it in `apply()`, which we bypass here, so compute it
+                    // the same way — against the positions we actually ended on, partial or
+                    // not. (Assessing a best-so-far layout is if anything more useful: it is
+                    // how a caller decides whether the partial answer is worth keeping.)
+                    if (request.options.calculateQuality) {
+                        for (const node of nodes) {
+                            const position = result.nodePositions.get(node.id);
+                            if (position)
+                                node.setPosition(position.x, position.y);
+                        }
+                        result.quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
+                            includeSuggestions: true,
+                            canvasDimensions: request.options.canvasDimensions,
+                        });
+                    }
+                    emit(stop ? Math.min(layoutRun.iteration / (total || 1), 1) : 1, stop !== null && stop !== void 0 ? stop : 'done', layoutRun.iteration, total);
+                    finish(result, stop !== undefined, stop, layoutRun.iteration, total);
+                    return;
+                }
+                // -- The opaque path (dagre, ELK, spectral, community) ------------------
+                //
+                // One shot into third-party code; there is no honest way to interrupt it
+                // mid-call. It still runs OFF THE MAIN THREAD, which is the actual win —
+                // a 500ms dagre pass no longer freezes input. What we cannot do is stop it
+                // half-way, so we check for cancellation at the only boundaries that exist.
+                emit(0, 'start', 0, 1);
+                if (cancelled.has(seq)) {
+                    // Never started: the best-so-far is the graph exactly as it came in.
+                    finish(unchanged(request.graph), true, 'cancelled', 0, 1);
+                    return;
+                }
+                const result = yield adapter.apply(nodes, links, request.options);
+                emit(1, 'done', 1, 1);
+                finish(result, false, undefined, 1, 1);
+            }
+            catch (error) {
+                cancelled.delete(seq);
+                port.postMessage({
+                    seq,
+                    kind: 'error',
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+    }
+}
+/**
+ * The bounding box of `positions`, using each node's real size.
+ *
+ * Needed because the overlap pass MOVES boxes: a `bounds` computed by the
+ * algorithm before separation is stale the moment anything is pushed apart, and a
+ * caller that fits the camera to it would clip the diagram it just laid out.
+ */
+function boundsOfPositions(nodes, positions) {
+    var _a, _b, _c, _d;
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const node of nodes) {
+        const p = positions.get(node.id);
+        if (!p)
+            continue;
+        minX = Math.min(minX, p.x);
+        minY = Math.min(minY, p.y);
+        maxX = Math.max(maxX, p.x + ((_b = (_a = node.size) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0));
+        maxY = Math.max(maxY, p.y + ((_d = (_c = node.size) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0));
+    }
+    if (!Number.isFinite(minX))
+        return { x: 0, y: 0, width: 0, height: 0 };
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+/** The identity layout: every node exactly where it already was. */
+function unchanged(graph) {
+    const nodePositions = new Map();
+    for (const node of graph.nodes) {
+        nodePositions.set(node.id, { x: node.position.x, y: node.position.y });
+    }
+    const xs = graph.nodes.map((n) => n.position.x);
+    const ys = graph.nodes.map((n) => n.position.y);
+    const rights = graph.nodes.map((n) => n.position.x + n.size.width);
+    const bottoms = graph.nodes.map((n) => n.position.y + n.size.height);
+    const x = xs.length ? Math.min(...xs) : 0;
+    const y = ys.length ? Math.min(...ys) : 0;
+    return {
+        nodePositions,
+        bounds: {
+            x,
+            y,
+            width: rights.length ? Math.max(...rights) - x : 0,
+            height: bottoms.length ? Math.max(...bottoms) - y : 0,
+        },
+        metadata: { algorithm: 'unchanged', executionTime: 0 },
+    };
+}
+/**
+ * The caller-side host.
+ *
+ * Pass a real Worker (or anything satisfying `LayoutPort`) to run off-thread;
+ * pass nothing to run inline on the same thread. Identical behaviour, no protocol
+ * drift, because BOTH paths speak through `serveLayout`.
+ */
+class LayoutHost {
+    constructor(port, deps = {}) {
+        this.seq = 0;
+        this.pending = new Map();
+        if (port) {
+            this.port = port;
+        }
+        else {
+            // Inline fallback: a loopback "port" pair served by the same loop the
+            // worker would run. The protocol is exercised even in-process, which is
+            // what stops the two paths from drifting — and is what makes the
+            // worker-vs-inline determinism test meaningful rather than tautological.
+            const hostSide = { postMessage: () => void 0, onmessage: null };
+            const workerSide = {
+                onmessage: null,
+                postMessage: (msg) => { var _a; return (_a = hostSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(hostSide, { data: msg }); },
+            };
+            serveLayout(workerSide, deps);
+            hostSide.postMessage = (msg) => { var _a; return (_a = workerSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(workerSide, { data: msg }); };
+            this.port = hostSide;
+        }
+        this.port.onmessage = (event) => {
+            var _a;
+            const message = event.data;
+            const entry = this.pending.get(message.seq);
+            if (!entry)
+                return;
+            if (message.kind === 'progress') {
+                (_a = entry.onProgress) === null || _a === void 0 ? void 0 : _a.call(entry, {
+                    progress: message.progress,
+                    phase: message.phase,
+                    iteration: message.iteration,
+                    totalIterations: message.totalIterations,
+                });
+                return;
+            }
+            this.pending.delete(message.seq);
+            if (message.kind === 'error') {
+                entry.reject(new Error(message.message));
+                return;
+            }
+            entry.resolve({
+                algorithm: message.algorithm,
+                nodePositions: new Map(message.positions),
+                bounds: message.bounds,
+                partial: message.partial,
+                reason: message.reason,
+                iteration: message.iteration,
+                totalIterations: message.totalIterations,
+                metadata: message.metadata,
+                quality: message.quality,
+                portAware: message.portAware,
+                subgraph: message.subgraph,
+                edgeBundling: message.edgeBundling,
+            });
+        };
+    }
+    run(algorithm, graph, options = {}, runOptions = {}) {
+        const seq = ++this.seq;
+        const { signal, onProgress, timeBudgetMs, sliceMs, stopAfterIteration } = runOptions;
+        return new Promise((resolve, reject) => {
+            this.pending.set(seq, { resolve, reject, onProgress });
+            // An already-aborted signal cancels the run BEFORE it is posted. Message
+            // order is preserved across a real port, so the server sees the cancel
+            // first and the run returns a zero-iteration partial rather than burning
+            // a slice of work that nobody wants.
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                this.port.postMessage({ seq: 0, kind: 'cancel', target: seq });
+            }
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
+                if (this.pending.has(seq)) {
+                    this.port.postMessage({ seq: 0, kind: 'cancel', target: seq });
+                }
+            });
+            this.port.postMessage({
+                seq,
+                kind: 'run',
+                algorithm,
+                graph,
+                options: stripNonClonable(options),
+                timeBudgetMs,
+                sliceMs,
+                stopAfterIteration,
+            });
+        });
+    }
+}
+exports.LayoutHost = LayoutHost;
+/**
+ * Drop anything that structured clone would choke on.
+ *
+ * Callers hand `engine.layout()` one options bag, and it is entirely reasonable
+ * for that bag to carry a callback. Posting one to a real Worker throws
+ * DataCloneError — a crash that only appears once someone actually enables the
+ * worker, i.e. exactly the bug that ships. Strip at the seam instead.
+ */
+function stripNonClonable(options) {
+    const out = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (typeof value === 'function')
+            continue;
+        if (typeof AbortSignal !== 'undefined' && value instanceof AbortSignal)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+//# sourceMappingURL=layout-host.js.map

package/src/libs/engine/src/layout/layout-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-host.js","sourceRoot":"","sources":["../../../../../../engine/src/layout/layout-host.ts"],"names":[],"mappings":"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"}

package/src/libs/engine/src/layout/layout-presets.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Layout Presets Library
+ *
+ * Pre-configured layout settings for common diagram scenarios.
+ * Includes both layout options and constraint configurations.
+ */
+import { DagreLayoutOptions } from './dagre-layout-adapter';
+import { ELKLayoutOptions } from './elk-layout-adapter';
+import { LayoutConstraints } from './layout-constraints.interface';
+import { IncrementalLayoutOptions } from './incremental-layout.interface';
+/**
+ * Layout preset configuration
+ */
+export interface LayoutPreset {
+    /** Unique identifier for the preset */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of when to use this preset */
+    description: string;
+    /** Which adapter to use */
+    adapter: 'dagre' | 'elk';
+    /** Layout options for the adapter */
+    options: Partial<DagreLayoutOptions> | Partial<ELKLayoutOptions>;
+    /** Optional pre-configured constraints */
+    constraints?: LayoutConstraints;
+    /** Optional incremental layout settings */
+    incrementalOptions?: Partial<IncrementalLayoutOptions>;
+    /** Tags for categorization */
+    tags?: string[];
+}
+/**
+ * Category of layout presets
+ */
+export interface LayoutPresetCategory {
+    /** Category name */
+    name: string;
+    /** Category description */
+    description: string;
+    /** Presets in this category */
+    presets: LayoutPreset[];
+}
+/**
+ * Predefined layout presets for common scenarios
+ */
+export declare class LayoutPresets {
+    /**
+     * Organizational/Hierarchical Layouts
+     */
+    static readonly HIERARCHICAL: LayoutPresetCategory;
+    /**
+     * Process/Flow Layouts
+     */
+    static readonly FLOW: LayoutPresetCategory;
+    /**
+     * Network/Graph Layouts
+     */
+    static readonly NETWORK: LayoutPresetCategory;
+    /**
+     * Architecture/System Layouts
+     */
+    static readonly ARCHITECTURE: LayoutPresetCategory;
+    /**
+     * Interactive/Dashboard Layouts
+     */
+    static readonly INTERACTIVE: LayoutPresetCategory;
+    /**
+     * Get all preset categories
+     */
+    static getAllCategories(): LayoutPresetCategory[];
+    /**
+     * Get all presets across all categories
+     */
+    static getAllPresets(): LayoutPreset[];
+    /**
+     * Find preset by ID
+     */
+    static findPreset(id: string): LayoutPreset | undefined;
+    /**
+     * Find presets by tag
+     */
+    static findPresetsByTag(tag: string): LayoutPreset[];
+    /**
+     * Find presets by adapter type
+     */
+    static findPresetsByAdapter(adapter: 'dagre' | 'elk'): LayoutPreset[];
+    /**
+     * Search presets by name or description
+     */
+    static searchPresets(query: string): LayoutPreset[];
+}