@nuraly/lumenui 0.2.1 → 0.2.2

package/dist/src/components/canvas/controllers/selection.controller.js

@@ -0,0 +1,202 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseCanvasController } from './base.controller.js';
+/**
+ * Controller for managing selection state (nodes and edges)
+ */
+export class SelectionController extends BaseCanvasController {
+    constructor(host) {
+        super(host);
+        this.undoController = null;
+    }
+    /**
+     * Set the undo controller (called after initialization)
+     */
+    setUndoController(controller) {
+        this.undoController = controller;
+    }
+    /**
+     * Clear all selections
+     */
+    clearSelection() {
+        this._host.selectedNodeIds = new Set();
+        this._host.selectedEdgeIds = new Set();
+        this._host.contextMenu = null;
+    }
+    /**
+     * Select all nodes and edges
+     */
+    selectAll() {
+        this._host.selectedNodeIds = new Set(this._host.workflow.nodes.map(n => n.id));
+        this._host.selectedEdgeIds = new Set(this._host.workflow.edges.map(e => e.id));
+    }
+    /**
+     * Select a node
+     */
+    selectNode(nodeId, addToSelection = false) {
+        if (!addToSelection) {
+            this.clearSelection();
+        }
+        this._host.selectedNodeIds.add(nodeId);
+        this._host.selectedNodeIds = new Set(this._host.selectedNodeIds);
+    }
+    /**
+     * Deselect a node
+     */
+    deselectNode(nodeId) {
+        this._host.selectedNodeIds.delete(nodeId);
+        this._host.selectedNodeIds = new Set(this._host.selectedNodeIds);
+    }
+    /**
+     * Toggle node selection
+     */
+    toggleNodeSelection(nodeId) {
+        if (this._host.selectedNodeIds.has(nodeId)) {
+            this.deselectNode(nodeId);
+        }
+        else {
+            this.selectNode(nodeId, true);
+        }
+    }
+    /**
+     * Select an edge
+     */
+    selectEdge(edgeId, addToSelection = false) {
+        if (!addToSelection) {
+            this.clearSelection();
+        }
+        this._host.selectedEdgeIds.add(edgeId);
+        this._host.selectedEdgeIds = new Set(this._host.selectedEdgeIds);
+    }
+    /**
+     * Check if a node is selected
+     */
+    isNodeSelected(nodeId) {
+        return this._host.selectedNodeIds.has(nodeId);
+    }
+    /**
+     * Check if an edge is selected
+     */
+    isEdgeSelected(edgeId) {
+        return this._host.selectedEdgeIds.has(edgeId);
+    }
+    /**
+     * Get selected nodes
+     */
+    getSelectedNodes() {
+        return this._host.workflow.nodes.filter(n => this._host.selectedNodeIds.has(n.id));
+    }
+    /**
+     * Get selected edges
+     */
+    getSelectedEdges() {
+        return this._host.workflow.edges.filter(e => this._host.selectedEdgeIds.has(e.id));
+    }
+    /**
+     * Delete selected items
+     */
+    deleteSelected() {
+        if (this._host.readonly)
+            return;
+        const nodeIdsToDelete = this._host.selectedNodeIds;
+        const edgeIdsToDelete = this._host.selectedEdgeIds;
+        // Get the nodes and edges being deleted for undo
+        const nodesToDelete = this._host.workflow.nodes.filter(n => nodeIdsToDelete.has(n.id));
+        const edgesToDelete = this._host.workflow.edges.filter(e => edgeIdsToDelete.has(e.id) ||
+            nodeIdsToDelete.has(e.sourceNodeId) ||
+            nodeIdsToDelete.has(e.targetNodeId));
+        // Record for undo before making changes
+        if (this.undoController && (nodesToDelete.length > 0 || edgesToDelete.length > 0)) {
+            this.undoController.recordBulkDeleted(nodesToDelete, edgesToDelete);
+        }
+        this._host.setWorkflow(Object.assign(Object.assign({}, this._host.workflow), { nodes: this._host.workflow.nodes.filter(n => !nodeIdsToDelete.has(n.id)), edges: this._host.workflow.edges.filter(e => !edgeIdsToDelete.has(e.id) &&
+                !nodeIdsToDelete.has(e.sourceNodeId) &&
+                !nodeIdsToDelete.has(e.targetNodeId)) }));
+        this.clearSelection();
+        this._host.dispatchWorkflowChanged();
+    }
+    /**
+     * Duplicate selected nodes and their connecting edges
+     */
+    duplicateSelected() {
+        var _a;
+        if (this._host.readonly || this._host.selectedNodeIds.size === 0)
+            return;
+        const nodesToDuplicate = this._host.workflow.nodes.filter(n => this._host.selectedNodeIds.has(n.id));
+        // Map from old node ID to new node ID
+        const idMap = new Map();
+        const newNodes = [];
+        const newEdges = [];
+        // Duplicate nodes
+        for (const node of nodesToDuplicate) {
+            const newId = this.generateNodeId();
+            idMap.set(node.id, newId);
+            newNodes.push(Object.assign(Object.assign({}, node), { id: newId, name: this.generateUniqueName(node.name), position: {
+                    x: node.position.x + 40,
+                    y: node.position.y + 40,
+                }, ports: {
+                    inputs: node.ports.inputs.map(p => (Object.assign({}, p))),
+                    configs: (_a = node.ports.configs) === null || _a === void 0 ? void 0 : _a.map(p => (Object.assign({}, p))),
+                    outputs: node.ports.outputs.map(p => (Object.assign({}, p))),
+                } }));
+        }
+        // Duplicate edges that connect the selected nodes
+        const edgesToDuplicate = this._host.workflow.edges.filter(e => this._host.selectedNodeIds.has(e.sourceNodeId) &&
+            this._host.selectedNodeIds.has(e.targetNodeId));
+        for (const edge of edgesToDuplicate) {
+            const newSourceId = idMap.get(edge.sourceNodeId);
+            const newTargetId = idMap.get(edge.targetNodeId);
+            if (newSourceId && newTargetId) {
+                newEdges.push(Object.assign(Object.assign({}, edge), { id: this.generateEdgeId(), sourceNodeId: newSourceId, targetNodeId: newTargetId }));
+            }
+        }
+        // Record for undo before making changes
+        if (this.undoController) {
+            this.undoController.recordNodesDuplicated(newNodes, newEdges);
+        }
+        // Set selection before workflow update
+        const newNodeIds = new Set(newNodes.map(n => n.id));
+        const newEdgeIds = new Set(newEdges.map(e => e.id));
+        this._host.selectedNodeIds = newNodeIds;
+        this._host.selectedEdgeIds = newEdgeIds;
+        this._host.setWorkflow(Object.assign(Object.assign({}, this._host.workflow), { nodes: [...this._host.workflow.nodes, ...newNodes], edges: [...this._host.workflow.edges, ...newEdges] }));
+        this._host.dispatchWorkflowChanged();
+        // Ensure selection persists after workflow update
+        this._host.updateComplete.then(() => {
+            this._host.selectedNodeIds = newNodeIds;
+            this._host.selectedEdgeIds = newEdgeIds;
+            this._host.requestUpdate();
+        });
+    }
+    /**
+     * Open configuration for the first selected node
+     */
+    openConfigForSelected() {
+        if (this._host.selectedNodeIds.size === 0)
+            return;
+        const nodeId = Array.from(this._host.selectedNodeIds)[0];
+        const node = this._host.workflow.nodes.find(n => n.id === nodeId);
+        if (node) {
+            this._host.configuredNode = node;
+        }
+    }
+    /**
+     * Check if there are any selections
+     */
+    hasSelection() {
+        return this._host.selectedNodeIds.size > 0 || this._host.selectedEdgeIds.size > 0;
+    }
+    /**
+     * Get count of selected items
+     */
+    getSelectionCount() {
+        return {
+            nodes: this._host.selectedNodeIds.size,
+            edges: this._host.selectedEdgeIds.size,
+        };
+    }
+}
+//# sourceMappingURL=selection.controller.js.map

package/dist/src/components/canvas/controllers/touch.controller.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { ReactiveControllerHost } from 'lit';
+import { BaseCanvasController } from './base.controller.js';
+import { CanvasHost } from '../interfaces/index.js';
+import { ViewportController } from './viewport.controller.js';
+import { DragController } from './drag.controller.js';
+import { SelectionController } from './selection.controller.js';
+/**
+ * Controller for handling touch interactions on the canvas.
+ * Detects gestures (pan, pinch-zoom, drag, tap, double-tap) and
+ * delegates to existing controllers using synthetic MouseEvent objects.
+ */
+export declare class TouchController extends BaseCanvasController {
+    private readonly viewportController;
+    private readonly dragController;
+    private readonly selectionController;
+    private readonly activeTouches;
+    private gestureType;
+    private initialPinchDistance;
+    private initialPinchZoom;
+    private lastTapTime;
+    private lastTapPosition;
+    private touchStartPos;
+    private touchTargetNode;
+    constructor(host: CanvasHost & ReactiveControllerHost, viewportController: ViewportController, dragController: DragController, selectionController: SelectionController);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private readonly handleTouchStart;
+    private readonly handleTouchMove;
+    private readonly handleTouchEnd;
+    private startPinchGesture;
+    private promoteGesture;
+    private handleTap;
+    private handlePinchEnd;
+    private updateActiveTouches;
+    private updateCursorPosition;
+    private handlePinchMove;
+    /**
+     * Check if a touch event targets a UI overlay element (toolbar, sidebar, etc.)
+     * that should receive normal browser touch/click handling.
+     */
+    private isTouchOnUIOverlay;
+    private createSyntheticMouseEvent;
+    private getDistance;
+    private getMidpoint;
+    private findNodeFromTouch;
+    private findNodeElementFromTouch;
+    private isDoubleTap;
+    private resetGesture;
+}
+//# sourceMappingURL=touch.controller.d.ts.map

package/dist/src/components/canvas/controllers/touch.controller.js

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseCanvasController } from './base.controller.js';
+const DOUBLE_TAP_THRESHOLD = 300;
+const DOUBLE_TAP_DISTANCE = 30;
+const TAP_MOVE_THRESHOLD = 10;
+/** CSS classes of UI overlay elements that should receive normal browser touch/click handling */
+const UI_OVERLAY_CLASSES = [
+    'canvas-toolbar',
+    'wb-sidebar',
+    'zoom-controls',
+    'context-menu',
+    'wb-floating-toolbar',
+    'wb-color-picker-panel',
+    'presence-bar',
+    'config-panel',
+    'config-panel-content',
+    'wb-action-indicator',
+    'node-palette',
+];
+/**
+ * Controller for handling touch interactions on the canvas.
+ * Detects gestures (pan, pinch-zoom, drag, tap, double-tap) and
+ * delegates to existing controllers using synthetic MouseEvent objects.
+ */
+export class TouchController extends BaseCanvasController {
+    constructor(host, viewportController, dragController, selectionController) {
+        super(host);
+        this.activeTouches = new Map();
+        this.gestureType = 'none';
+        this.initialPinchDistance = 0;
+        this.initialPinchZoom = 1;
+        this.lastTapTime = 0;
+        this.lastTapPosition = { x: 0, y: 0 };
+        this.touchStartPos = null;
+        this.touchTargetNode = null;
+        // ===== TOUCH EVENT HANDLERS =====
+        this.handleTouchStart = (e) => {
+            if (this._host.disabled)
+                return;
+            // Let UI overlay elements (toolbar, sidebar, etc.) handle their own touches
+            if (this.isTouchOnUIOverlay(e))
+                return;
+            // Prevent browser from generating synthetic mouse events
+            e.preventDefault();
+            this.updateActiveTouches(e.changedTouches);
+            const count = this.activeTouches.size;
+            if (count === 2) {
+                this.startPinchGesture();
+                return;
+            }
+            if (count === 1) {
+                const touch = e.changedTouches[0];
+                this.touchStartPos = { x: touch.clientX, y: touch.clientY };
+                this.touchTargetNode = this.findNodeFromTouch(e);
+                this.gestureType = 'pending';
+            }
+        };
+        this.handleTouchMove = (e) => {
+            if (this._host.disabled || this.gestureType === 'none')
+                return;
+            e.preventDefault();
+            this.updateActiveTouches(e.changedTouches);
+            this.updateCursorPosition(e);
+            if (this.gestureType === 'pinch' && this.activeTouches.size >= 2) {
+                this.handlePinchMove();
+                return;
+            }
+            if (this.activeTouches.size !== 1)
+                return;
+            const touch = e.touches[0];
+            if (!touch || !this.touchStartPos)
+                return;
+            const dist = Math.hypot(touch.clientX - this.touchStartPos.x, touch.clientY - this.touchStartPos.y);
+            if (this.gestureType === 'pending' && dist > TAP_MOVE_THRESHOLD) {
+                this.promoteGesture(touch);
+            }
+            if (this.gestureType === 'drag') {
+                this.dragController.handleDrag(this.createSyntheticMouseEvent(touch));
+            }
+            else if (this.gestureType === 'pan') {
+                this.viewportController.handlePanDrag(this.createSyntheticMouseEvent(touch));
+            }
+        };
+        this.handleTouchEnd = (e) => {
+            if (this._host.disabled || this.gestureType === 'none')
+                return;
+            e.preventDefault();
+            // Remove ended touches
+            for (const t of Array.from(e.changedTouches)) {
+                this.activeTouches.delete(t.identifier);
+            }
+            const remaining = this.activeTouches.size;
+            if (this.gestureType === 'pinch') {
+                this.handlePinchEnd(remaining);
+                return;
+            }
+            // Only process end if all fingers are lifted
+            if (remaining > 0)
+                return;
+            const touch = e.changedTouches[0];
+            if (this.gestureType === 'pan') {
+                this.viewportController.stopPan();
+            }
+            else if (this.gestureType === 'drag') {
+                this.dragController.stopDrag();
+            }
+            else if (this.gestureType === 'pending' && this.touchStartPos) {
+                this.handleTap(touch);
+            }
+            this.resetGesture();
+        };
+        this.viewportController = viewportController;
+        this.dragController = dragController;
+        this.selectionController = selectionController;
+    }
+    hostConnected() {
+        this._host.updateComplete.then(() => {
+            const wrapper = this.canvasWrapper;
+            if (!wrapper)
+                return;
+            wrapper.addEventListener('touchstart', this.handleTouchStart, { passive: false });
+            wrapper.addEventListener('touchmove', this.handleTouchMove, { passive: false });
+            wrapper.addEventListener('touchend', this.handleTouchEnd, { passive: false });
+            wrapper.addEventListener('touchcancel', this.handleTouchEnd, { passive: false });
+        });
+    }
+    hostDisconnected() {
+        const wrapper = this.canvasWrapper;
+        if (!wrapper)
+            return;
+        wrapper.removeEventListener('touchstart', this.handleTouchStart);
+        wrapper.removeEventListener('touchmove', this.handleTouchMove);
+        wrapper.removeEventListener('touchend', this.handleTouchEnd);
+        wrapper.removeEventListener('touchcancel', this.handleTouchEnd);
+    }
+    // ===== GESTURE HELPERS =====
+    startPinchGesture() {
+        // Cancel any pending single-touch gesture
+        if (this.gestureType === 'drag' && this.dragController.isDragging()) {
+            this.dragController.stopDrag();
+        }
+        if (this.gestureType === 'pan' && this._host.isPanning) {
+            this.viewportController.stopPan();
+        }
+        this.gestureType = 'pinch';
+        const touches = Array.from(this.activeTouches.values());
+        this.initialPinchDistance = this.getDistance(touches[0], touches[1]);
+        this.initialPinchZoom = this._host.viewport.zoom;
+    }
+    promoteGesture(touch) {
+        if (this.touchTargetNode) {
+            this.gestureType = 'drag';
+            const synth = this.createSyntheticMouseEvent(touch);
+            if (!this._host.selectedNodeIds.has(this.touchTargetNode.id)) {
+                this.selectionController.clearSelection();
+                this.selectionController.selectNode(this.touchTargetNode.id, false);
+            }
+            this.dragController.startDrag(this.touchTargetNode, synth);
+        }
+        else {
+            this.gestureType = 'pan';
+            const startSynth = this.createSyntheticMouseEvent({ clientX: this.touchStartPos.x, clientY: this.touchStartPos.y });
+            this.viewportController.startPan(startSynth);
+        }
+    }
+    handleTap(touch) {
+        const now = Date.now();
+        const isDoubleTap = this.isDoubleTap(touch.clientX, touch.clientY, now);
+        if (isDoubleTap && this.touchTargetNode) {
+            const nodeEl = this.findNodeElementFromTouch();
+            if (nodeEl) {
+                nodeEl.dispatchEvent(new CustomEvent('node-dblclick', {
+                    detail: { node: this.touchTargetNode },
+                    bubbles: true,
+                    composed: true,
+                }));
+            }
+        }
+        else if (this.touchTargetNode) {
+            this.selectionController.clearSelection();
+            this.selectionController.selectNode(this.touchTargetNode.id, false);
+            this._host.dispatchNodeSelected(this.touchTargetNode);
+        }
+        else {
+            this.selectionController.clearSelection();
+        }
+        this.lastTapTime = now;
+        this.lastTapPosition = { x: touch.clientX, y: touch.clientY };
+    }
+    handlePinchEnd(remaining) {
+        if (remaining === 1) {
+            this.gestureType = 'pan';
+            const touch = Array.from(this.activeTouches.values())[0];
+            this.viewportController.startPan(this.createSyntheticMouseEvent(touch));
+        }
+        else if (remaining === 0) {
+            this.resetGesture();
+        }
+    }
+    updateActiveTouches(touchList) {
+        for (const t of Array.from(touchList)) {
+            this.activeTouches.set(t.identifier, t);
+        }
+    }
+    updateCursorPosition(e) {
+        if (e.touches.length >= 1 && this.canvasWrapper) {
+            const touch = e.touches[0];
+            const rect = this.canvasWrapper.getBoundingClientRect();
+            this._host.lastMousePosition = {
+                x: (touch.clientX - rect.left - this._host.viewport.panX) / this._host.viewport.zoom,
+                y: (touch.clientY - rect.top - this._host.viewport.panY) / this._host.viewport.zoom,
+            };
+        }
+    }
+    // ===== PINCH HANDLING =====
+    handlePinchMove() {
+        const touches = Array.from(this.activeTouches.values());
+        if (touches.length < 2)
+            return;
+        const currentDistance = this.getDistance(touches[0], touches[1]);
+        if (this.initialPinchDistance === 0)
+            return;
+        const scale = currentDistance / this.initialPinchDistance;
+        const newZoom = this.initialPinchZoom * scale;
+        const mid = this.getMidpoint(touches[0], touches[1]);
+        this.viewportController.setZoomAtPoint(newZoom, mid.clientX, mid.clientY);
+    }
+    // ===== HELPERS =====
+    /**
+     * Check if a touch event targets a UI overlay element (toolbar, sidebar, etc.)
+     * that should receive normal browser touch/click handling.
+     */
+    isTouchOnUIOverlay(e) {
+        const path = e.composedPath();
+        for (const el of path) {
+            if (el === this.canvasWrapper)
+                break; // stop at wrapper boundary
+            if (el instanceof HTMLElement) {
+                for (const cls of UI_OVERLAY_CLASSES) {
+                    if (el.classList.contains(cls))
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    createSyntheticMouseEvent(touch) {
+        return new MouseEvent('mousemove', {
+            clientX: touch.clientX,
+            clientY: touch.clientY,
+            button: 0,
+            bubbles: true,
+        });
+    }
+    getDistance(t1, t2) {
+        return Math.hypot(t1.clientX - t2.clientX, t1.clientY - t2.clientY);
+    }
+    getMidpoint(t1, t2) {
+        return {
+            clientX: (t1.clientX + t2.clientX) / 2,
+            clientY: (t1.clientY + t2.clientY) / 2,
+        };
+    }
+    findNodeFromTouch(e) {
+        const path = e.composedPath();
+        for (const el of path) {
+            if (el instanceof HTMLElement && el.dataset.nodeId) {
+                return this._host.workflow.nodes.find(n => n.id === el.dataset.nodeId) || null;
+            }
+        }
+        return null;
+    }
+    findNodeElementFromTouch() {
+        var _a;
+        const host = this._host;
+        if (!host.shadowRoot)
+            return null;
+        const nodeId = (_a = this.touchTargetNode) === null || _a === void 0 ? void 0 : _a.id;
+        if (!nodeId)
+            return null;
+        return host.shadowRoot.querySelector(`whiteboard-node[data-node-id="${nodeId}"]`);
+    }
+    isDoubleTap(x, y, now) {
+        const dt = now - this.lastTapTime;
+        return dt < DOUBLE_TAP_THRESHOLD && Math.hypot(x - this.lastTapPosition.x, y - this.lastTapPosition.y) < DOUBLE_TAP_DISTANCE;
+    }
+    resetGesture() {
+        this.gestureType = 'none';
+        this.touchTargetNode = null;
+        this.touchStartPos = null;
+        this.initialPinchDistance = 0;
+        this.initialPinchZoom = 1;
+    }
+}
+//# sourceMappingURL=touch.controller.js.map

package/dist/src/components/canvas/controllers/undo.controller.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { ReactiveControllerHost } from 'lit';
+import { BaseCanvasController } from './base.controller.js';
+import { CanvasHost } from '../interfaces/index.js';
+import type { WorkflowNode, WorkflowEdge, Position, UndoProvider } from '../workflow-canvas.types.js';
+/**
+ * Controller for undo/redo operations.
+ * Delegates all undo/redo logic to an externally-provided UndoProvider
+ * so the UI library never imports from the redux store.
+ */
+export declare class UndoController extends BaseCanvasController {
+    private _undoProvider;
+    constructor(host: CanvasHost & ReactiveControllerHost);
+    /**
+     * Set the undo provider (injected by the host)
+     */
+    set undoProvider(provider: UndoProvider | null);
+    get undoProvider(): UndoProvider | null;
+    /**
+     * Get the current workflow ID
+     */
+    private getWorkflowId;
+    /**
+     * Execute undo
+     */
+    performUndo(): boolean;
+    /**
+     * Execute redo
+     */
+    performRedo(): boolean;
+    /**
+     * Check if undo is available
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available
+     */
+    canRedo(): boolean;
+    /**
+     * Get undo tooltip text
+     */
+    getUndoTooltip(): string;
+    /**
+     * Get redo tooltip text
+     */
+    getRedoTooltip(): string;
+    /**
+     * Record that a node was added
+     */
+    recordNodeAdded(node: WorkflowNode): void;
+    /**
+     * Record that a node was deleted
+     */
+    recordNodeDeleted(node: WorkflowNode, connectedEdges: WorkflowEdge[]): void;
+    /**
+     * Record that nodes were moved
+     */
+    recordNodesMoved(moves: Array<{
+        nodeId: string;
+        oldPosition: Position;
+        newPosition: Position;
+    }>): void;
+    /**
+     * Record that a node's configuration was updated
+     */
+    recordNodeConfigUpdated(nodeId: string, changes: Partial<WorkflowNode>, previousState: Partial<WorkflowNode>): void;
+    /**
+     * Record that an edge was added
+     */
+    recordEdgeAdded(edge: WorkflowEdge): void;
+    /**
+     * Record that an edge was deleted
+     */
+    recordEdgeDeleted(edge: WorkflowEdge): void;
+    /**
+     * Record a bulk delete operation
+     */
+    recordBulkDeleted(nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    /**
+     * Record that nodes were pasted
+     */
+    recordNodesPasted(nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    /**
+     * Record that nodes were duplicated
+     */
+    recordNodesDuplicated(nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    /**
+     * Flush any pending operations (call before undo)
+     */
+    flushPending(): void;
+    /**
+     * Clear undo history for the current workflow
+     */
+    clearHistory(): void;
+}
+//# sourceMappingURL=undo.controller.d.ts.map