@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/layout/layout-constraints.interface.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Layout Constraints System
+ *
+ * Provides fine-grained control over node positioning during layout operations.
+ * This allows for interactive editing, incremental layouts, and hierarchical positioning.
+ */
+/**
+ * Types of layout constraints that can be applied to nodes
+ */
+export type ConstraintType = 'pin' | 'fix-x' | 'fix-y' | 'boundary';
+/**
+ * Boundary definition for constraining node movement
+ */
+export interface Boundary {
+    /** Minimum X coordinate (inclusive) */
+    minX?: number;
+    /** Maximum X coordinate (inclusive) */
+    maxX?: number;
+    /** Minimum Y coordinate (inclusive) */
+    minY?: number;
+    /** Maximum Y coordinate (inclusive) */
+    maxY?: number;
+}
+/**
+ * Position definition for pinned nodes
+ */
+export interface Position {
+    x: number;
+    y: number;
+}
+/**
+ * Constraint definition for a single node
+ */
+export interface NodeConstraint {
+    /** ID of the node this constraint applies to */
+    nodeId: string;
+    /** Type of constraint */
+    type: ConstraintType;
+    /**
+     * Fixed position for 'pin' constraint
+     * The node will be locked to this exact position
+     */
+    position?: Position;
+    /**
+     * Fixed value for 'fix-x' or 'fix-y' constraints
+     * - For 'fix-x': The X coordinate is locked to this value, Y can vary
+     * - For 'fix-y': The Y coordinate is locked to this value, X can vary
+     */
+    value?: number;
+    /**
+     * Boundary limits for 'boundary' constraint
+     * The node position will be clamped within these bounds
+     */
+    boundary?: Boundary;
+    /**
+     * Priority of this constraint (higher = more important)
+     * Used when constraints conflict (default: 0)
+     */
+    priority?: number;
+}
+/**
+ * Collection of layout constraints to apply
+ */
+export interface LayoutConstraints {
+    /** Array of node constraints */
+    constraints: NodeConstraint[];
+    /**
+     * Strategy for handling conflicting constraints
+     * - 'priority': Use constraint priority to resolve conflicts
+     * - 'first': First constraint wins
+     * - 'last': Last constraint wins
+     */
+    conflictResolution?: 'priority' | 'first' | 'last';
+}
+/**
+ * Helper class for managing and applying layout constraints
+ */
+export declare class ConstraintManager {
+    private constraints;
+    constructor(constraints?: LayoutConstraints);
+    /**
+     * Add constraints to the manager
+     */
+    addConstraints(constraints: LayoutConstraints): void;
+    /**
+     * Get all constraints for a specific node
+     */
+    getConstraints(nodeId: string): NodeConstraint[];
+    /**
+     * Check if a node has any constraints
+     */
+    hasConstraints(nodeId: string): boolean;
+    /**
+     * Apply constraints to a position, returning the constrained position
+     */
+    applyConstraints(nodeId: string, proposedPosition: Position, conflictResolution?: 'priority' | 'first' | 'last'): Position;
+    /**
+     * Sort constraints based on conflict resolution strategy
+     */
+    private sortConstraints;
+    /**
+     * Clear all constraints
+     */
+    clear(): void;
+    /**
+     * Remove constraints for a specific node
+     */
+    removeConstraints(nodeId: string): void;
+    /**
+     * Get total number of constrained nodes
+     */
+    getConstrainedNodeCount(): number;
+    /**
+     * Get all constrained node IDs
+     */
+    getConstrainedNodeIds(): string[];
+}

package/src/libs/engine/src/layout/layout-constraints.interface.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Layout Constraints System
+ *
+ * Provides fine-grained control over node positioning during layout operations.
+ * This allows for interactive editing, incremental layouts, and hierarchical positioning.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintManager = void 0;
+/**
+ * Helper class for managing and applying layout constraints
+ */
+class ConstraintManager {
+    constructor(constraints) {
+        this.constraints = new Map();
+        if (constraints) {
+            this.addConstraints(constraints);
+        }
+    }
+    /**
+     * Add constraints to the manager
+     */
+    addConstraints(constraints) {
+        for (const constraint of constraints.constraints) {
+            const existing = this.constraints.get(constraint.nodeId) || [];
+            existing.push(constraint);
+            this.constraints.set(constraint.nodeId, existing);
+        }
+    }
+    /**
+     * Get all constraints for a specific node
+     */
+    getConstraints(nodeId) {
+        return this.constraints.get(nodeId) || [];
+    }
+    /**
+     * Check if a node has any constraints
+     */
+    hasConstraints(nodeId) {
+        return this.constraints.has(nodeId);
+    }
+    /**
+     * Apply constraints to a position, returning the constrained position
+     */
+    applyConstraints(nodeId, proposedPosition, conflictResolution = 'priority') {
+        const nodeConstraints = this.getConstraints(nodeId);
+        if (nodeConstraints.length === 0) {
+            return proposedPosition;
+        }
+        // Sort constraints based on resolution strategy
+        const sorted = this.sortConstraints(nodeConstraints, conflictResolution);
+        let { x, y } = proposedPosition;
+        // Apply each constraint in order
+        for (const constraint of sorted) {
+            switch (constraint.type) {
+                case 'pin':
+                    if (constraint.position) {
+                        x = constraint.position.x;
+                        y = constraint.position.y;
+                    }
+                    break;
+                case 'fix-x':
+                    if (constraint.value !== undefined) {
+                        x = constraint.value;
+                    }
+                    break;
+                case 'fix-y':
+                    if (constraint.value !== undefined) {
+                        y = constraint.value;
+                    }
+                    break;
+                case 'boundary':
+                    if (constraint.boundary) {
+                        const b = constraint.boundary;
+                        if (b.minX !== undefined)
+                            x = Math.max(x, b.minX);
+                        if (b.maxX !== undefined)
+                            x = Math.min(x, b.maxX);
+                        if (b.minY !== undefined)
+                            y = Math.max(y, b.minY);
+                        if (b.maxY !== undefined)
+                            y = Math.min(y, b.maxY);
+                    }
+                    break;
+            }
+        }
+        return { x, y };
+    }
+    /**
+     * Sort constraints based on conflict resolution strategy
+     */
+    sortConstraints(constraints, strategy) {
+        const sorted = [...constraints];
+        // Constraints are applied sequentially, so the LAST one applied wins a
+        // contested field. Order them so the intended winner runs last.
+        switch (strategy) {
+            case 'priority':
+                // Ascending priority: the highest-priority constraint applies last
+                // (e.g. fix-x@1 proposes 600, boundary@2 clamps it to 500)
+                sorted.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+                break;
+            case 'first':
+                // First-declared wins: apply in reverse declaration order
+                sorted.reverse();
+                break;
+            case 'last':
+                // Last-declared wins: keep declaration order
+                break;
+        }
+        return sorted;
+    }
+    /**
+     * Clear all constraints
+     */
+    clear() {
+        this.constraints.clear();
+    }
+    /**
+     * Remove constraints for a specific node
+     */
+    removeConstraints(nodeId) {
+        this.constraints.delete(nodeId);
+    }
+    /**
+     * Get total number of constrained nodes
+     */
+    getConstrainedNodeCount() {
+        return this.constraints.size;
+    }
+    /**
+     * Get all constrained node IDs
+     */
+    getConstrainedNodeIds() {
+        return Array.from(this.constraints.keys());
+    }
+}
+exports.ConstraintManager = ConstraintManager;
+//# sourceMappingURL=layout-constraints.interface.js.map

package/src/libs/engine/src/layout/layout-constraints.interface.js.map

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

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

@@ -0,0 +1,70 @@
+import { NodeModel } from '../models/NodeModel';
+import { LinkModel } from '../models/LinkModel';
+/** A port, as it crosses the boundary. Ids are preserved — see above. */
+export interface LayoutGraphPort {
+    id: string;
+    type: 'input' | 'output' | 'bi';
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    /** Order within a side — carried so multi-port sides revive in the same order. */
+    index?: number;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+/** A node, as it crosses the boundary: geometry + topology only. */
+export interface LayoutGraphNode {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Container membership — the nested-layout card needs it; harmless otherwise. */
+    parentId?: string;
+    /**
+     * wave13: how `position` relates to the parent. Absent on pre-v3 payloads, which meant
+     * summation — i.e. 'relative'; the consumer below applies exactly that default.
+     */
+    positionMode?: 'absolute' | 'relative' | 'layout';
+    ports?: LayoutGraphPort[];
+}
+/** A link, as it crosses the boundary. */
+export interface LayoutGraphLink {
+    id: string;
+    sourceNodeId?: string;
+    targetNodeId?: string;
+    sourcePortId?: string;
+    targetPortId?: string;
+}
+/** A whole graph, structured-clone-safe: no functions, no class instances. */
+export interface LayoutGraph {
+    nodes: LayoutGraphNode[];
+    links: LayoutGraphLink[];
+}
+/**
+ * Freeze a live graph into the wire format.
+ *
+ * Emits nodes and links in CANONICAL (id-sorted) order — the same discipline
+ * Card 0 established in `fromAdapter`. Determinism needs both halves: a seeded
+ * PRNG *and* a stable input order. Serialising in map-iteration order would
+ * quietly reintroduce the divergence Card 0 just removed, because an authored
+ * diagram and the same diagram loaded from JSON do not iterate alike.
+ */
+export declare function serializeGraph(nodes: NodeModel[], links: LinkModel[]): LayoutGraph;
+/**
+ * Rebuild live models from the wire format, on whichever thread we landed on.
+ *
+ * The revived models are THROWAWAY: the algorithm mutates them, we read the
+ * positions out of the result, and the engine commits those positions onto the
+ * REAL nodes via `setPosition()` so the spatial index and the routing obstacle
+ * map see the move. Nothing that happens to these copies escapes.
+ */
+export declare function reviveGraph(graph: LayoutGraph): {
+    nodes: NodeModel[];
+    links: LinkModel[];
+};

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

@@ -0,0 +1,119 @@
+"use strict";
+// Wave 7 (Auto-layout) — Card 3: the wire format for off-thread layout.
+//
+// A layout that runs behind a postMessage boundary cannot be handed NodeModel
+// instances: structured clone rejects class instances with methods, event
+// emitters and (in NodeModel's case) a back-reference to the whole diagram. So
+// the graph crosses the boundary as PLAIN DATA and is revived on the other side.
+//
+// WHAT CROSSES, AND WHY THAT IS EXACTLY ENOUGH
+// --------------------------------------------
+// Every algorithm registered in the Card 0 registry (dagre, elk, force,
+// spectral, community) was audited for what it actually reads off a model. The
+// complete list is:
+//
+//     node.id, node.position, node.size
+//     link.id, link.sourceNodeId, link.targetNodeId,
+//     link.sourcePortId, link.targetPortId
+//
+// — geometry and topology, nothing else. So that is what the wire format
+// carries. This is not a guess; it is the grep.
+//
+// `node.data` is deliberately NOT carried. It holds arbitrary application
+// payloads, and application payloads routinely contain functions, class
+// instances or DOM references — all of which throw DataCloneError the moment a
+// real Worker is handed one. Since no layout algorithm reads it, carrying it
+// would buy nothing and would turn "you used a worker" into a production crash
+// for anyone whose node data is not clonable.
+//
+// Ports ARE carried, with their ids preserved. NodeModel auto-creates four
+// default ports in its constructor with FRESH ids, so a naive revive would hand
+// the algorithm a node whose port ids no longer match the `sourcePortId` on the
+// links pointing at it — referential integrity silently broken, and port-aware
+// layout quietly wrong. Reviving replaces the auto-created ports with the real
+// ones.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeGraph = serializeGraph;
+exports.reviveGraph = reviveGraph;
+const NodeModel_1 = require("../models/NodeModel");
+const LinkModel_1 = require("../models/LinkModel");
+const PortModel_1 = require("../models/PortModel");
+const rng_1 = require("./rng");
+/**
+ * Freeze a live graph into the wire format.
+ *
+ * Emits nodes and links in CANONICAL (id-sorted) order — the same discipline
+ * Card 0 established in `fromAdapter`. Determinism needs both halves: a seeded
+ * PRNG *and* a stable input order. Serialising in map-iteration order would
+ * quietly reintroduce the divergence Card 0 just removed, because an authored
+ * diagram and the same diagram loaded from JSON do not iterate alike.
+ */
+function serializeGraph(nodes, links) {
+    return {
+        nodes: (0, rng_1.inStableOrder)(nodes).map((node) => (Object.assign(Object.assign({ id: node.id, type: node.type, position: { x: node.position.x, y: node.position.y }, size: { width: node.size.width, height: node.size.height } }, (node.parentId
+            ? { parentId: node.parentId, positionMode: node.positionMode }
+            : {})), { ports: node.getPorts().map((port) => (Object.assign(Object.assign(Object.assign({ id: port.id, type: port.type }, (port.side ? { side: port.side } : {})), (port.index !== undefined ? { index: port.index } : {})), (port.position
+                ? { position: { x: port.position.x, y: port.position.y } }
+                : {})))) }))),
+        links: (0, rng_1.inStableOrder)(links).map((link) => ({
+            id: link.id,
+            sourceNodeId: link.sourceNodeId,
+            targetNodeId: link.targetNodeId,
+            sourcePortId: link.sourcePortId,
+            targetPortId: link.targetPortId,
+        })),
+    };
+}
+/**
+ * Rebuild live models from the wire format, on whichever thread we landed on.
+ *
+ * The revived models are THROWAWAY: the algorithm mutates them, we read the
+ * positions out of the result, and the engine commits those positions onto the
+ * REAL nodes via `setPosition()` so the spatial index and the routing obstacle
+ * map see the move. Nothing that happens to these copies escapes.
+ */
+function reviveGraph(graph) {
+    const nodes = graph.nodes.map((serialized) => {
+        var _a;
+        const node = new NodeModel_1.NodeModel({
+            id: serialized.id,
+            type: serialized.type,
+            position: Object.assign({}, serialized.position),
+            size: Object.assign({}, serialized.size),
+        });
+        if (serialized.parentId) {
+            node.parentId = serialized.parentId;
+            // wave13: carry the positioning semantics with the relationship. A payload that
+            // predates positionMode-on-parents meant summation, i.e. 'relative' — the same
+            // default the v2→v3 document migration applies. Without this, the ephemeral layout
+            // copy would default to 'absolute' and getBoundingBox() would place parented nodes
+            // differently here than in the live model.
+            node.positionMode = (_a = serialized.positionMode) !== null && _a !== void 0 ? _a : 'relative';
+        }
+        // Replace the four auto-created default ports with the real ones, ids
+        // intact — otherwise every link's sourcePortId/targetPortId dangles.
+        if (serialized.ports) {
+            for (const existing of node.getPorts()) {
+                node.removePort(existing.id);
+            }
+            for (const port of serialized.ports) {
+                node.addPort(new PortModel_1.PortModel(Object.assign(Object.assign(Object.assign({ id: port.id, type: port.type }, (port.side ? { side: port.side } : {})), (port.index !== undefined ? { index: port.index } : {})), (port.position ? { position: Object.assign({}, port.position) } : {}))));
+            }
+        }
+        return node;
+    });
+    const links = graph.links.map((serialized) => {
+        var _a, _b;
+        const link = new LinkModel_1.LinkModel((_a = serialized.sourcePortId) !== null && _a !== void 0 ? _a : '', (_b = serialized.targetPortId) !== null && _b !== void 0 ? _b : '');
+        // `id` is readonly on DiagramEntity and LinkModel's constructor takes none,
+        // so a revived link would otherwise get a fresh random id and the result
+        // could not be keyed back to the original. Same cast DiagramEntity itself
+        // uses when rehydrating from JSON.
+        link.id = serialized.id;
+        link.sourceNodeId = serialized.sourceNodeId;
+        link.targetNodeId = serialized.targetNodeId;
+        return link;
+    });
+    return { nodes, links };
+}
+//# sourceMappingURL=layout-graph.js.map

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

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

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

@@ -0,0 +1,147 @@
+/**
+ * Layout History and Undo/Redo System
+ *
+ * Manages layout state history and enables undo/redo operations.
+ * Essential for interactive editing workflows.
+ */
+import { NodeModel } from '../models/NodeModel';
+/**
+ * Snapshot of node positions at a point in time
+ */
+export interface LayoutSnapshot {
+    /** Unique identifier for this snapshot */
+    id: string;
+    /** Timestamp when snapshot was created */
+    timestamp: number;
+    /** Node positions */
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    /** Optional description */
+    description?: string;
+    /** Layout algorithm used */
+    algorithm?: string;
+    /** Layout options used */
+    options?: any;
+}
+/**
+ * Options for layout history management
+ */
+export interface LayoutHistoryOptions {
+    /** Maximum number of history entries to keep */
+    maxHistorySize?: number;
+    /** Whether to automatically create snapshots */
+    autoSnapshot?: boolean;
+    /** Minimum time between auto-snapshots (ms) */
+    minSnapshotInterval?: number;
+}
+/**
+ * Layout History Manager
+ *
+ * Manages undo/redo stack for layout operations
+ */
+export declare class LayoutHistory {
+    private history;
+    private currentIndex;
+    private maxHistorySize;
+    private lastSnapshotTime;
+    private minSnapshotInterval;
+    constructor(options?: LayoutHistoryOptions);
+    /**
+     * Create and push a new snapshot
+     *
+     * @param nodes - Current nodes
+     * @param description - Optional description
+     * @param algorithm - Layout algorithm used
+     * @param options - Layout options used
+     * @returns The created snapshot
+     */
+    pushSnapshot(nodes: NodeModel[], description?: string, algorithm?: string, options?: any): LayoutSnapshot;
+    /**
+     * Undo to previous snapshot
+     *
+     * @returns The snapshot to restore, or undefined if can't undo
+     */
+    undo(): LayoutSnapshot | undefined;
+    /**
+     * Redo to next snapshot
+     *
+     * @returns The snapshot to restore, or undefined if can't redo
+     */
+    redo(): LayoutSnapshot | undefined;
+    /**
+     * Check if undo is possible
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is possible
+     */
+    canRedo(): boolean;
+    /**
+     * Get current snapshot
+     */
+    getCurrentSnapshot(): LayoutSnapshot | undefined;
+    /**
+     * Get all snapshots
+     */
+    getAllSnapshots(): LayoutSnapshot[];
+    /**
+     * Get snapshot by ID
+     */
+    getSnapshotById(id: string): LayoutSnapshot | undefined;
+    /**
+     * Restore a specific snapshot by ID
+     *
+     * @param id - Snapshot ID to restore
+     * @returns The snapshot, or undefined if not found
+     */
+    restoreSnapshot(id: string): LayoutSnapshot | undefined;
+    /**
+     * Clear all history
+     */
+    clear(): void;
+    /**
+     * Get history size
+     */
+    size(): number;
+    /**
+     * Get current index in history
+     */
+    getCurrentIndex(): number;
+    /**
+     * Apply snapshot to nodes
+     *
+     * @param snapshot - Snapshot to apply
+     * @param nodes - Nodes to update
+     * @returns Number of nodes updated
+     */
+    static applySnapshot(snapshot: LayoutSnapshot, nodes: NodeModel[]): number;
+    /**
+     * Generate unique ID for snapshot
+     */
+    private generateId;
+    /**
+     * Export history to JSON
+     */
+    exportToJSON(): string;
+    /**
+     * Import history from JSON
+     *
+     * @param json - JSON string to import
+     * @returns True if successful
+     */
+    importFromJSON(json: string): boolean;
+    /**
+     * Get history statistics
+     */
+    getStatistics(): {
+        totalSnapshots: number;
+        currentIndex: number;
+        canUndo: boolean;
+        canRedo: boolean;
+        oldestTimestamp: number;
+        newestTimestamp: number;
+        averageInterval: number;
+    };
+}