@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/state/ConnectionStateManager.js

@@ -1,319 +0,0 @@
-"use strict";
-// ConnectionStateManager - Manages connection drag state
-// This is part of Phase 1: Engine Foundation for interaction modes
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionStateManager = void 0;
-// Wave 6 (Card 2 + Card 6): THE connection validator. This class used to carry
-// its own private copy of the input/output rules — one that silently skipped the
-// capacity check the rest of the engine enforced.
-const connection_rules_1 = require("../ports/connection-rules");
-/**
- * Manages connection creation state during drag operations
- */
-class ConnectionStateManager {
-    constructor(eventBus, diagram = null) {
-        this.validators = [];
-        /**
-         * Wave 6 (Card 6): the diagram the drag is happening in.
-         *
-         * `calculateValidTargets()` was a comment-only stub — "DiagramEngine will call
-         * setValidTargets() after analyzing the diagram" — and NOTHING in the tree ever
-         * called `setValidTargets()`. So `validTargetPorts` was permanently empty, and
-         * `InteractionController.updatePortHighlights()`, which loops over it to paint
-         * the valid targets, painted nothing. The "highlight every valid target" feature
-         * has never worked. Giving the manager the diagram is what finally lets it
-         * answer its own question.
-         */
-        this.diagram = null;
-        this.eventBus = eventBus;
-        this.diagram = diagram;
-        this.state = this.createInitialState();
-    }
-    /** Point the manager at the live diagram (DiagramEngine calls this on load). */
-    setDiagram(diagram) {
-        this.diagram = diagram;
-    }
-    /**
-     * Create initial empty state
-     */
-    createInitialState() {
-        return {
-            isConnecting: false,
-            sourcePort: null,
-            targetPort: null,
-            currentMousePosition: null,
-            previewPath: null,
-            validTargetNodes: new Set(),
-            validTargetPorts: new Set(),
-            invalidTargetPorts: new Map(),
-            isOverValidTarget: false,
-            rejectionReason: undefined,
-            rejectionMessage: undefined,
-        };
-    }
-    /**
-     * Start connection drag from a port
-     */
-    startConnection(sourcePort, startPoint) {
-        this.state = Object.assign(Object.assign({}, this.createInitialState()), { isConnecting: true, sourcePort, currentMousePosition: startPoint, previewPath: [startPoint] });
-        // Calculate valid targets based on port type and connection rules
-        this.calculateValidTargets(sourcePort);
-        // Emit event
-        this.eventBus.emit('connection:start', {
-            sourcePort,
-            startPoint,
-            validTargetPorts: Array.from(this.state.validTargetPorts),
-        });
-    }
-    /**
-     * Update connection drag position
-     */
-    updateConnection(currentPoint, hoveredPort) {
-        if (!this.state.isConnecting || !this.state.sourcePort) {
-            return;
-        }
-        const previousTargetPort = this.state.targetPort;
-        this.state.currentMousePosition = currentPoint;
-        this.state.targetPort = hoveredPort || null;
-        // Update preview path
-        // Get source port absolute position (will be calculated by renderer)
-        this.state.previewPath = [currentPoint]; // Renderer will add source point
-        // Check if over valid target. The VERDICT, not just the boolean — a rejected
-        // target has to be able to say why (Card 6's invalid cue).
-        const verdict = hoveredPort
-            ? this.evaluate(hoveredPort)
-            : { ok: false };
-        this.state.isOverValidTarget = verdict.ok;
-        this.state.rejectionReason = verdict.ok ? undefined : verdict.reason;
-        this.state.rejectionMessage = verdict.ok ? undefined : verdict.message;
-        // Emit update event
-        this.eventBus.emit('connection:update', {
-            currentPoint,
-            targetPort: hoveredPort,
-            isValid: this.state.isOverValidTarget,
-            rejectionReason: this.state.rejectionReason,
-            rejectionMessage: this.state.rejectionMessage,
-            previousTargetPort,
-        });
-        // Emit hover events if target changed
-        if (hoveredPort !== previousTargetPort) {
-            if (previousTargetPort) {
-                this.eventBus.emit('connection:port-leave', {
-                    port: previousTargetPort,
-                });
-            }
-            if (hoveredPort) {
-                this.eventBus.emit('connection:port-enter', {
-                    port: hoveredPort,
-                    isValid: this.state.isOverValidTarget,
-                    rejectionReason: this.state.rejectionReason,
-                    rejectionMessage: this.state.rejectionMessage,
-                });
-            }
-        }
-    }
-    /**
-     * Complete connection to target port
-     */
-    completeConnection(targetPort) {
-        if (!this.state.isConnecting || !this.state.sourcePort) {
-            this.cancelConnection();
-            return { success: false };
-        }
-        // Validate connection
-        if (!this.isValidConnection(targetPort)) {
-            this.cancelConnection();
-            return { success: false };
-        }
-        const sourcePort = this.state.sourcePort;
-        // Emit success event (DiagramEngine will create the actual link)
-        this.eventBus.emit('connection:complete', {
-            sourcePort,
-            targetPort,
-            sourcePortId: sourcePort.id,
-            targetPortId: targetPort.id,
-        });
-        // Reset state
-        this.resetState();
-        return { success: true };
-    }
-    /**
-     * Cancel connection
-     */
-    cancelConnection() {
-        if (this.state.isConnecting) {
-            this.eventBus.emit('connection:cancel', {
-                sourcePort: this.state.sourcePort,
-            });
-        }
-        this.resetState();
-    }
-    /**
-     * The full verdict for a candidate target — the ONE place this class decides
-     * what is legal. It delegates to `evaluatePortConnection`, the validator the
-     * whole engine now shares.
-     *
-     * This used to be a private re-implementation of the input/output rules that
-     * (a) never checked `maxConnections` — so an interactive drag would happily
-     * overfill a port the rest of the engine considered full — and (b) disagreed
-     * with the proximity-connect magnet about duplicates.
-     */
-    evaluate(targetPort) {
-        var _a;
-        const sourcePort = this.state.sourcePort;
-        if (!sourcePort)
-            return { ok: false };
-        const verdict = (0, connection_rules_1.evaluatePortConnection)(sourcePort, targetPort, {
-            sourceNode: this.nodeOf(sourcePort),
-            targetNode: this.nodeOf(targetPort),
-            links: (_a = this.diagram) === null || _a === void 0 ? void 0 : _a.getLinks(),
-            validators: this.validators,
-        });
-        if (!verdict.ok)
-            return verdict;
-        // A host that explicitly narrowed the target set (setValidTargets) still wins.
-        // Kept as a post-filter, and still only consulted when non-empty, so a host
-        // that never calls it is unaffected.
-        if (this.state.validTargetPorts.size > 0 && !this.state.validTargetPorts.has(targetPort.id)) {
-            return { ok: false, reason: 'custom', message: 'This connection is not allowed.' };
-        }
-        return verdict;
-    }
-    /** Legacy boolean facade — kept because callers and tests rely on it. */
-    isValidConnection(targetPort) {
-        return this.evaluate(targetPort).ok;
-    }
-    nodeOf(port) {
-        var _a, _b, _c;
-        if (!this.diagram)
-            return undefined;
-        if (port.nodeId) {
-            const byId = this.diagram.getNode(port.nodeId);
-            if (byId)
-                return byId;
-        }
-        return (_c = (_b = (_a = this.diagram).getNodeByPortId) === null || _b === void 0 ? void 0 : _b.call(_a, port.id)) !== null && _c !== void 0 ? _c : undefined;
-    }
-    /**
-     * Wave 6 (Card 6): partition EVERY port in the diagram into valid targets and
-     * rejected ones (with a reason), so the renderer can light up the whole graph
-     * the moment a drag starts.
-     *
-     * This was a comment-only stub. Nothing called `setValidTargets()`, so the set
-     * it promised to fill stayed empty forever and every downstream consumer —
-     * `InteractionController.updatePortHighlights()`, the `connection:start` event
-     * payload, the renderer's `isValidTarget` styling — silently had nothing to do.
-     */
-    calculateValidTargets(sourcePort) {
-        var _a;
-        const validNodes = new Set();
-        const validPorts = new Set();
-        const invalidPorts = new Map();
-        const diagram = this.diagram;
-        if (!diagram) {
-            // No diagram wired in: leave the sets EMPTY, which the post-filter above
-            // reads as "unconstrained". Same behaviour as before this method worked.
-            this.state.validTargetNodes = validNodes;
-            this.state.validTargetPorts = validPorts;
-            this.state.invalidTargetPorts = invalidPorts;
-            return;
-        }
-        const links = diagram.getLinks();
-        const sourceNode = this.nodeOf(sourcePort);
-        for (const node of diagram.getNodes()) {
-            for (const port of node.getPorts()) {
-                if (port.id === sourcePort.id)
-                    continue;
-                const verdict = (0, connection_rules_1.evaluatePortConnection)(sourcePort, port, {
-                    sourceNode,
-                    targetNode: node,
-                    links,
-                    validators: this.validators,
-                });
-                if (verdict.ok) {
-                    validPorts.add(port.id);
-                    validNodes.add(node.id);
-                }
-                else {
-                    invalidPorts.set(port.id, (_a = verdict.reason) !== null && _a !== void 0 ? _a : 'custom');
-                }
-            }
-        }
-        this.state.validTargetNodes = validNodes;
-        this.state.validTargetPorts = validPorts;
-        this.state.invalidTargetPorts = invalidPorts;
-    }
-    /**
-     * Set valid target ports (called by a host that wants to narrow the set
-     * further than the rules do — e.g. a wizard that only permits one legal move).
-     */
-    setValidTargets(nodeIds, portIds) {
-        this.state.validTargetNodes = nodeIds;
-        this.state.validTargetPorts = portIds;
-    }
-    /**
-     * Add a custom connection validator
-     */
-    addValidator(validator) {
-        this.validators.push(validator);
-    }
-    /**
-     * Remove a custom connection validator
-     */
-    removeValidator(validator) {
-        const index = this.validators.indexOf(validator);
-        if (index !== -1) {
-            this.validators.splice(index, 1);
-        }
-    }
-    /**
-     * Clear all custom validators
-     */
-    clearValidators() {
-        this.validators = [];
-    }
-    /**
-     * Get current state (read-only)
-     */
-    getState() {
-        return Object.assign(Object.assign({}, this.state), { validTargetNodes: new Set(this.state.validTargetNodes), validTargetPorts: new Set(this.state.validTargetPorts), invalidTargetPorts: new Map(this.state.invalidTargetPorts) });
-    }
-    /**
-     * Check if currently connecting
-     */
-    isConnecting() {
-        return this.state.isConnecting;
-    }
-    /**
-     * Get source port (if connecting)
-     */
-    getSourcePort() {
-        return this.state.sourcePort;
-    }
-    /**
-     * Get target port (if hovering over one)
-     */
-    getTargetPort() {
-        return this.state.targetPort;
-    }
-    /**
-     * Get current mouse position
-     */
-    getCurrentMousePosition() {
-        return this.state.currentMousePosition;
-    }
-    /**
-     * Check if hovering over valid target
-     */
-    isOverValidTarget() {
-        return this.state.isOverValidTarget;
-    }
-    /**
-     * Reset state to initial
-     */
-    resetState() {
-        this.state = this.createInitialState();
-    }
-}
-exports.ConnectionStateManager = ConnectionStateManager;
-//# sourceMappingURL=ConnectionStateManager.js.map

package/src/libs/engine/src/state/DiagramStore.d.ts

@@ -1,134 +0,0 @@
-import type { Viewport } from '../types';
-import type { DiagramModel } from '../models/DiagramModel';
-export interface RenderStats {
-    fps: number;
-    renderTime: number;
-    nodeCount: number;
-    linkCount: number;
-    visibleNodes: number;
-    visibleLinks: number;
-}
-export interface DiagramState {
-    diagram: DiagramModel | null;
-    selectedNodes: Set<string>;
-    selectedLinks: Set<string>;
-    hoveredElement: string | null;
-    focusedElement: string | null;
-    viewport: Viewport;
-    zoom: number;
-    gridEnabled: boolean;
-    snapEnabled: boolean;
-    activeTool: string;
-    toolOptions: Record<string, any>;
-    mode: 'design' | 'runtime' | 'readonly';
-    locked: boolean;
-    theme: 'light' | 'dark';
-    showMinimap: boolean;
-    showToolbar: boolean;
-    showProperties: boolean;
-    renderStats: RenderStats;
-    errors: Error[];
-    warnings: string[];
-}
-export interface StateSnapshot {
-    timestamp: number;
-    state: DiagramState;
-    version: string;
-}
-export type StateListener = (state: DiagramState, changes: string[]) => void;
-export type PathListener = (value: any, oldValue: any) => void;
-export declare class DiagramStore {
-    private state;
-    private listeners;
-    private globalListeners;
-    private history;
-    private maxHistorySize;
-    private computedCache;
-    private batching;
-    private batchedChanges;
-    constructor(initialState?: Partial<DiagramState>);
-    /**
-     * Get current state (immutable)
-     */
-    getState(): Readonly<DiagramState>;
-    /**
-     * Set state with change tracking
-     */
-    setState(updater: (state: DiagramState) => void): void;
-    /**
-     * Get state value by path
-     */
-    select<T>(path: string): T;
-    /**
-     * Get state value by path
-     */
-    get(path: string): any;
-    /**
-     * Set state value by path
-     */
-    set(path: string, value: any): void;
-    /**
-     * Subscribe to all state changes
-     */
-    subscribe(listener: StateListener): () => void;
-    /**
-     * Subscribe to path changes
-     */
-    watch(path: string, listener: PathListener): () => void;
-    /**
-     * Computed value with memoization
-     */
-    computed<T>(key: string, compute: (state: DiagramState) => T, deps?: string[]): T;
-    /**
-     * Batch multiple state updates
-     */
-    batch(fn: () => void): void;
-    /**
-     * Reset to initial state
-     */
-    reset(initialState?: Partial<DiagramState>): void;
-    /**
-     * Time travel to history index
-     */
-    timeTravel(index: number): void;
-    /**
-     * Get history
-     */
-    getHistory(): ReadonlyArray<StateSnapshot>;
-    /**
-     * Create snapshot
-     */
-    createSnapshot(): StateSnapshot;
-    /**
-     * Restore snapshot
-     */
-    restoreSnapshot(snapshot: StateSnapshot): void;
-    /**
-     * Create initial state
-     */
-    private createInitialState;
-    /**
-     * Diff two states
-     */
-    private diffState;
-    /**
-     * Notify listeners of changes
-     */
-    private notifyListeners;
-    /**
-     * Invalidate computed values
-     */
-    private invalidateComputed;
-    /**
-     * Add to history
-     */
-    private addToHistory;
-    /**
-     * Deep clone object (handles Sets, Maps, Arrays, Objects)
-     */
-    private deepClone;
-    /**
-     * Deep freeze object
-     */
-    private deepFreeze;
-}