@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/layout/spectral-layout-adapter.js

@@ -1,379 +0,0 @@
-"use strict";
-/**
- * Spectral Layout Adapter
- *
- * Uses graph spectral theory (eigenvalues/eigenvectors) for optimal node placement.
- * Minimizes edge crossings and preserves graph symmetry mathematically.
- *
- * Best for:
- * - Circuit diagrams
- * - Network topology
- * - Symmetric graphs
- * - Mathematical optimization
- *
- * Algorithm: Graph Laplacian spectral decomposition
- *
- * @module layout/spectral-layout-adapter
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpectralLayoutAdapter = void 0;
-const tslib_1 = require("tslib");
-const rng_1 = require("./rng");
-const layout_quality_metrics_1 = require("./layout-quality-metrics");
-/**
- * Matrix helper class
- */
-class Matrix {
-    constructor(rows, cols, fill = 0) {
-        this.rows = rows;
-        this.cols = cols;
-        this.data = Array(rows)
-            .fill(0)
-            .map(() => Array(cols).fill(fill));
-    }
-    get(i, j) {
-        return this.data[i][j];
-    }
-    set(i, j, value) {
-        this.data[i][j] = value;
-    }
-    add(other) {
-        const result = new Matrix(this.rows, this.cols);
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                result.set(i, j, this.get(i, j) + other.get(i, j));
-            }
-        }
-        return result;
-    }
-    subtract(other) {
-        const result = new Matrix(this.rows, this.cols);
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                result.set(i, j, this.get(i, j) - other.get(i, j));
-            }
-        }
-        return result;
-    }
-    multiply(scalar) {
-        const result = new Matrix(this.rows, this.cols);
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                result.set(i, j, this.get(i, j) * scalar);
-            }
-        }
-        return result;
-    }
-    multiplyVector(v) {
-        const result = new Array(this.rows).fill(0);
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                result[i] += this.get(i, j) * v[j];
-            }
-        }
-        return result;
-    }
-    transpose() {
-        const result = new Matrix(this.cols, this.rows);
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                result.set(j, i, this.get(i, j));
-            }
-        }
-        return result;
-    }
-}
-/**
- * Vector operations
- */
-class VectorOps {
-    static dot(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            sum += a[i] * b[i];
-        }
-        return sum;
-    }
-    static norm(v) {
-        return Math.sqrt(this.dot(v, v));
-    }
-    static normalize(v) {
-        const n = this.norm(v);
-        return v.map(x => x / (n + 1e-10));
-    }
-    static subtract(a, b) {
-        return a.map((x, i) => x - b[i]);
-    }
-    static add(a, b) {
-        return a.map((x, i) => x + b[i]);
-    }
-    static multiply(v, scalar) {
-        return v.map(x => x * scalar);
-    }
-}
-/**
- * Spectral Layout Adapter
- *
- * Uses eigendecomposition of graph Laplacian for optimal layout.
- */
-class SpectralLayoutAdapter {
-    constructor() {
-        this.name = 'spectral';
-        /**
-         * Card 0: the run's seeded generator. Established once per apply() so every
-         * helper below draws from the SAME reproducible stream — the seed alone is not
-         * enough if each helper mints its own generator.
-         */
-        this.rng = (0, rng_1.createLayoutRng)();
-    }
-    /**
-     * Apply spectral layout
-     */
-    apply(nodes_1, links_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (nodes, links, options = {}) {
-            var _a, _b, _c, _d, _e, _f;
-            this.rng = (0, rng_1.createLayoutRng)(options === null || options === void 0 ? void 0 : options.seed);
-            const startTime = performance.now();
-            // Merge with defaults
-            const opts = Object.assign({ normalized: (_a = options.normalized) !== null && _a !== void 0 ? _a : true, dimensions: (_b = options.dimensions) !== null && _b !== void 0 ? _b : 2, scale: (_c = options.scale) !== null && _c !== void 0 ? _c : 500, center: (_d = options.center) !== null && _d !== void 0 ? _d : true, convergenceThreshold: (_e = options.convergenceThreshold) !== null && _e !== void 0 ? _e : 1e-6, maxIterations: (_f = options.maxIterations) !== null && _f !== void 0 ? _f : 1000 }, options);
-            const n = nodes.length;
-            if (n === 0) {
-                return {
-                    nodePositions: new Map(),
-                    bounds: { x: 0, y: 0, width: 0, height: 0 },
-                    metadata: {
-                        algorithm: 'spectral',
-                        executionTime: performance.now() - startTime,
-                        nodeCount: 0,
-                        linkCount: 0,
-                    },
-                };
-            }
-            // Build node index map
-            const nodeIndexMap = new Map(nodes.map((node, i) => [node.id, i]));
-            // Build adjacency matrix
-            const adjacency = new Matrix(n, n, 0);
-            const validLinks = links.filter(link => link.sourceNodeId && link.targetNodeId);
-            for (const link of validLinks) {
-                const i = nodeIndexMap.get(link.sourceNodeId);
-                const j = nodeIndexMap.get(link.targetNodeId);
-                if (i !== undefined && j !== undefined) {
-                    adjacency.set(i, j, 1);
-                    adjacency.set(j, i, 1); // Undirected
-                }
-            }
-            // Build degree matrix
-            const degree = new Matrix(n, n, 0);
-            for (let i = 0; i < n; i++) {
-                let deg = 0;
-                for (let j = 0; j < n; j++) {
-                    deg += adjacency.get(i, j);
-                }
-                degree.set(i, i, deg);
-            }
-            // Build Laplacian matrix: L = D - A
-            const laplacian = degree.subtract(adjacency);
-            // For normalized Laplacian: L_norm = D^(-1/2) * L * D^(-1/2)
-            let L = laplacian;
-            if (opts.normalized) {
-                const D_inv_sqrt = new Matrix(n, n, 0);
-                for (let i = 0; i < n; i++) {
-                    const deg = degree.get(i, i);
-                    D_inv_sqrt.set(i, i, deg > 0 ? 1 / Math.sqrt(deg) : 0);
-                }
-                // L_norm = D^(-1/2) * L * D^(-1/2)
-                const temp = new Matrix(n, n, 0);
-                for (let i = 0; i < n; i++) {
-                    for (let j = 0; j < n; j++) {
-                        let sum = 0;
-                        for (let k = 0; k < n; k++) {
-                            sum += D_inv_sqrt.get(i, k) * laplacian.get(k, j);
-                        }
-                        temp.set(i, j, sum);
-                    }
-                }
-                L = new Matrix(n, n, 0);
-                for (let i = 0; i < n; i++) {
-                    for (let j = 0; j < n; j++) {
-                        let sum = 0;
-                        for (let k = 0; k < n; k++) {
-                            sum += temp.get(i, k) * D_inv_sqrt.get(k, j);
-                        }
-                        L.set(i, j, sum);
-                    }
-                }
-            }
-            // Compute smallest non-zero eigenvectors using power iteration
-            // For spectral layout, we want eigenvectors 2 and 3 (after trivial eigenvector)
-            const eigenvectors = [];
-            for (let dim = 0; dim < Math.min(opts.dimensions, n - 1); dim++) {
-                const eigenvector = this.computeEigenvector(L, eigenvectors, opts.maxIterations, opts.convergenceThreshold);
-                eigenvectors.push(eigenvector);
-            }
-            // If we have fewer eigenvectors than dimensions, pad with random
-            while (eigenvectors.length < opts.dimensions) {
-                eigenvectors.push(Array(n)
-                    .fill(0)
-                    .map(() => this.rng.next() - 0.5) // Card 0: seeded, was Math.random()
-                );
-            }
-            // Build positions from eigenvectors
-            const nodePositions = new Map();
-            for (let i = 0; i < n; i++) {
-                const node = nodes[i];
-                const x = eigenvectors[0][i] * opts.scale;
-                const y = eigenvectors[1][i] * opts.scale;
-                nodePositions.set(node.id, { x, y });
-            }
-            // Center the layout
-            if (opts.center) {
-                let cx = 0, cy = 0;
-                nodePositions.forEach(pos => {
-                    cx += pos.x;
-                    cy += pos.y;
-                });
-                cx /= nodePositions.size;
-                cy /= nodePositions.size;
-                nodePositions.forEach((pos, id) => {
-                    nodePositions.set(id, {
-                        x: pos.x - cx,
-                        y: pos.y - cy,
-                    });
-                });
-            }
-            // Apply positions to nodes
-            nodes.forEach(node => {
-                const position = nodePositions.get(node.id);
-                if (position) {
-                    node.setPosition(position.x, position.y);
-                }
-            });
-            // Calculate bounds
-            const bounds = this.calculateBounds(nodePositions);
-            const endTime = performance.now();
-            // Calculate quality metrics if requested
-            let quality = undefined;
-            if (options.calculateQuality) {
-                quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
-                    includeSuggestions: true,
-                    canvasDimensions: options.canvasDimensions,
-                });
-            }
-            return {
-                nodePositions,
-                bounds,
-                metadata: {
-                    algorithm: 'spectral',
-                    normalized: opts.normalized,
-                    dimensions: opts.dimensions,
-                    executionTime: endTime - startTime,
-                    nodeCount: nodes.length,
-                    linkCount: links.length,
-                },
-                quality,
-            };
-        });
-    }
-    /**
-     * Compute eigenvector using power iteration
-     */
-    computeEigenvector(matrix, previousEigenvectors, maxIterations, threshold) {
-        const n = matrix.rows;
-        // Initialize with random vector
-        let v = Array(n)
-            .fill(0)
-            .map(() => this.rng.next() - 0.5); // Card 0: seeded, was Math.random()
-        v = VectorOps.normalize(v);
-        // Orthogonalize against previous eigenvectors
-        for (const prev of previousEigenvectors) {
-            const dot = VectorOps.dot(v, prev);
-            v = VectorOps.subtract(v, VectorOps.multiply(prev, dot));
-        }
-        v = VectorOps.normalize(v);
-        let converged = false;
-        let iteration = 0;
-        while (!converged && iteration < maxIterations) {
-            // v_new = L * v
-            const v_new_raw = matrix.multiplyVector(v);
-            // Orthogonalize
-            let v_new = v_new_raw;
-            for (const prev of previousEigenvectors) {
-                const dot = VectorOps.dot(v_new, prev);
-                v_new = VectorOps.subtract(v_new, VectorOps.multiply(prev, dot));
-            }
-            // Normalize
-            v_new = VectorOps.normalize(v_new);
-            // Check convergence
-            const diff = VectorOps.subtract(v_new, v);
-            const change = VectorOps.norm(diff);
-            if (change < threshold) {
-                converged = true;
-            }
-            v = v_new;
-            iteration++;
-        }
-        return v;
-    }
-    /**
-     * Calculate bounding box
-     */
-    calculateBounds(positions) {
-        if (positions.size === 0) {
-            return { x: 0, y: 0, width: 0, height: 0 };
-        }
-        let minX = Infinity, minY = Infinity;
-        let maxX = -Infinity, maxY = -Infinity;
-        positions.forEach(pos => {
-            minX = Math.min(minX, pos.x);
-            minY = Math.min(minY, pos.y);
-            maxX = Math.max(maxX, pos.x);
-            maxY = Math.max(maxY, pos.y);
-        });
-        // Add padding
-        const padding = 50;
-        minX -= padding;
-        minY -= padding;
-        maxX += padding;
-        maxY += padding;
-        return {
-            x: minX,
-            y: minY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-    }
-    /**
-     * Apply incremental layout (Phase 1 compatibility)
-     */
-    applyIncremental(nodes, links, incrementalOptions, layoutOptions) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // Spectral layout doesn't support true incremental layout
-            // Just apply full layout
-            const result = yield this.apply(nodes, links, layoutOptions);
-            return Object.assign(Object.assign({}, result), { incremental: {
-                    newNodeIds: incrementalOptions.newNodeIds || [],
-                    pinnedNodeIds: [],
-                    movedNodeIds: nodes.map(n => n.id),
-                    strategy: 'full-relayout',
-                    constraintsApplied: 0,
-                } });
-        });
-    }
-    /**
-     * Validate options
-     */
-    validateOptions(options) {
-        if (options.dimensions !== undefined && options.dimensions < 1) {
-            return false;
-        }
-        if (options.scale !== undefined && options.scale <= 0) {
-            return false;
-        }
-        if (options.maxIterations !== undefined && options.maxIterations < 1) {
-            return false;
-        }
-        return true;
-    }
-}
-exports.SpectralLayoutAdapter = SpectralLayoutAdapter;
-//# sourceMappingURL=spectral-layout-adapter.js.map

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

@@ -1,40 +0,0 @@
-import { NodeModel } from '../models/NodeModel';
-import { LinkModel } from '../models/LinkModel';
-import { LayoutAdapter, LayoutOptions, LayoutResult } from './layout-adapter.interface';
-/**
- * An in-flight, pre-emptible layout computation.
- *
- * Pure and synchronous by construction: no DOM, no clock, no `Math.random()`.
- * That is what lets the identical object run on the main thread and inside a
- * Worker and produce byte-identical coordinates — the property Card 0 bought
- * and this card must not spend.
- */
-export interface LayoutRun {
-    /** Iterations completed so far. */
-    readonly iteration: number;
-    /** Iterations this run would do if left alone — the denominator for progress. */
-    readonly totalIterations: number;
-    /**
-     * Advance exactly one iteration.
-     *
-     * @returns true if there is more work to do, false once converged or done.
-     */
-    step(): boolean;
-    /**
-     * The best answer so far. Must be safe to call at ANY point — before the
-     * first step (returns the input positions), midway (returns the partial
-     * simulation), or after the last (returns the final layout).
-     */
-    snapshot(): LayoutResult;
-}
-/**
- * A layout adapter that can be driven a step at a time.
- *
- * Optional: `isSteppable()` is a type guard, and the host degrades gracefully
- * for adapters that are not.
- */
-export interface SteppableLayoutAdapter extends LayoutAdapter {
-    createRun(nodes: NodeModel[], links: LinkModel[], options?: Partial<LayoutOptions>): LayoutRun;
-}
-/** Can this adapter be pre-empted mid-run? */
-export declare function isSteppable(adapter: LayoutAdapter): adapter is SteppableLayoutAdapter;

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

@@ -1,34 +0,0 @@
-"use strict";
-// Wave 7 (Auto-layout) — Card 3: what it takes for a layout to be *interruptible*.
-//
-// "Cancellable" is the word people use for an algorithm that checks a flag once,
-// at the end, and then throws its work away. That is not cancellation, it is a
-// late apology. A force layout that has done 200 of its 300 iterations has a
-// perfectly usable picture; the difference between a tool that feels alive and
-// one that feels broken is whether you hand that picture back.
-//
-// So an interruptible layout is not one that can be *stopped*. It is one that
-// can be stopped AND ASKED WHAT IT HAS. Two obligations, and the second is the
-// one that gets forgotten:
-//
-//   step()      — advance a bounded, cheap slice of work; return false when done.
-//   snapshot()  — the best answer SO FAR, valid after *any* number of steps,
-//                 including zero.
-//
-// The host (layout-host.ts) drives step() and consults the cancel flag and the
-// time budget between steps, so pre-emption latency is one iteration, not one
-// layout. When it stops early it calls snapshot() and flags the result partial.
-//
-// An adapter that cannot offer this — dagre and ELK are single-shot calls into
-// third-party code, and there is no honest way to interrupt them mid-call —
-// simply does not implement it. The host detects that and runs them as one
-// opaque step. They still go off the main thread (which is the actual win: a
-// 500ms dagre pass no longer freezes input); they just cannot be pre-empted
-// half-way. Pretending otherwise would be the lie this file exists to avoid.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSteppable = isSteppable;
-/** Can this adapter be pre-empted mid-run? */
-function isSteppable(adapter) {
-    return typeof adapter.createRun === 'function';
-}
-//# sourceMappingURL=steppable-layout.js.map