@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,117 +0,0 @@
-/**
- * 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

@@ -1,138 +0,0 @@
-"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-graph.d.ts

@@ -1,70 +0,0 @@
-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

@@ -1,119 +0,0 @@
-"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-history.d.ts

@@ -1,147 +0,0 @@
-/**
- * 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;
-    };
-}