@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/esm/editor/UndoRedoPro.js

@@ -0,0 +1,914 @@
+/**
+ * @file UndoRedoPro.ts
+ * @description Advanced Undo/Redo system with selective undo, branch history, snapshots
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Command-based undo/redo
+ * - Selective undo (undo specific actions without undoing newer ones)
+ * - Branch history (fork history at any point)
+ * - Automatic snapshots
+ * - Manual snapshots (named save points)
+ * - Action grouping (combine multiple actions)
+ * - Action filtering by category/target
+ * - History visualization data
+ * - Memory management (limit history size)
+ * - Serialization for persistence
+ */
+const DEFAULT_UNDO_REDO_CONFIG = {
+    maxHistorySize: 500,
+    maxBranches: 10,
+    autoSnapshotInterval: 50,
+    autoSnapshotOnBranch: true,
+    mergeConsecutiveActions: true,
+    mergeTimeWindow: 1000,
+    enableSelectiveUndo: true,
+    enableBranches: true,
+};
+// ============================================================
+// Undo/Redo Manager
+// ============================================================
+class UndoRedoManager {
+    constructor(config) {
+        this.executors = new Map();
+        // History
+        this.branches = new Map();
+        this.activeBranchId = 'main';
+        this.groups = new Map();
+        this.snapshots = new Map();
+        // State
+        this.currentGroupId = null;
+        this.actionsSinceSnapshot = 0;
+        this.isExecuting = false;
+        this.lastActionTime = 0;
+        this.config = { ...DEFAULT_UNDO_REDO_CONFIG, ...config };
+        // Create main branch
+        this.branches.set('main', {
+            id: 'main',
+            name: 'Main',
+            parentBranchId: null,
+            forkActionIndex: 0,
+            actions: [],
+            currentIndex: -1,
+            createdAt: Date.now(),
+            isActive: true,
+        });
+    }
+    // ─── Executor Registration ─────────────────────────────
+    registerExecutor(actionType, executor) {
+        this.executors.set(actionType, executor);
+    }
+    unregisterExecutor(actionType) {
+        this.executors.delete(actionType);
+    }
+    // ─── Action Execution ──────────────────────────────────
+    execute(action) {
+        if (this.isExecuting) {
+            return false;
+        }
+        const executor = this.executors.get(action.actionType);
+        if (!executor) {
+            console.warn(`No executor registered for action type: ${action.actionType}`);
+            return false;
+        }
+        // Validate action
+        if (executor.validate && !executor.validate(action.doData)) {
+            console.warn('Action validation failed');
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        const now = Date.now();
+        // Check for merge with previous action
+        if (this.config.mergeConsecutiveActions &&
+            now - this.lastActionTime < this.config.mergeTimeWindow) {
+            const lastAction = branch.actions[branch.currentIndex];
+            if (lastAction &&
+                lastAction.actionType === action.actionType &&
+                lastAction.targetId === action.targetId &&
+                executor.merge) {
+                const mergedData = executor.merge(lastAction.doData, action.doData);
+                if (mergedData !== null) {
+                    lastAction.doData = mergedData;
+                    lastAction.timestamp = now;
+                    this.lastActionTime = now;
+                    this.onHistoryChange?.();
+                    return true;
+                }
+            }
+        }
+        // Create full action
+        const fullAction = {
+            ...action,
+            id: this.generateId(),
+            timestamp: now,
+            groupId: this.currentGroupId ?? undefined,
+        };
+        // Execute the action
+        this.isExecuting = true;
+        try {
+            executor.execute(fullAction.doData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        // Clear redo history (actions after current index)
+        if (branch.currentIndex < branch.actions.length - 1) {
+            // Create branch if enabled
+            if (this.config.enableBranches && branch.actions.length > 0) {
+                this.createBranchFromCurrent('Auto-branch');
+            }
+            branch.actions = branch.actions.slice(0, branch.currentIndex + 1);
+        }
+        // Add action to history
+        branch.actions.push(fullAction);
+        branch.currentIndex = branch.actions.length - 1;
+        // Enforce max history size
+        this.enforceHistoryLimit(branch);
+        // Handle auto-snapshots
+        this.actionsSinceSnapshot++;
+        if (this.config.autoSnapshotInterval > 0 &&
+            this.actionsSinceSnapshot >= this.config.autoSnapshotInterval) {
+            this.createAutoSnapshot();
+        }
+        this.lastActionTime = now;
+        this.onHistoryChange?.();
+        this.onActionExecuted?.(fullAction, false);
+        return true;
+    }
+    // ─── Undo/Redo ─────────────────────────────────────────
+    undo() {
+        if (this.isExecuting) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch || branch.currentIndex < 0) {
+            return false;
+        }
+        // Handle group undo
+        if (this.currentGroupId) {
+            return this.undoGroup(this.currentGroupId);
+        }
+        const action = branch.actions[branch.currentIndex];
+        if (!action) {
+            return false;
+        }
+        // If action is part of a group, undo the whole group
+        if (action.groupId) {
+            return this.undoGroup(action.groupId);
+        }
+        return this.undoSingleAction(branch, action);
+    }
+    redo() {
+        if (this.isExecuting) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch || branch.currentIndex >= branch.actions.length - 1) {
+            return false;
+        }
+        const action = branch.actions[branch.currentIndex + 1];
+        if (!action) {
+            return false;
+        }
+        // If action is part of a group, redo the whole group
+        if (action.groupId && action.isGroupStart) {
+            return this.redoGroup(action.groupId);
+        }
+        return this.redoSingleAction(branch, action);
+    }
+    undoSingleAction(branch, action) {
+        const executor = this.executors.get(action.actionType);
+        if (!executor) {
+            return false;
+        }
+        this.isExecuting = true;
+        try {
+            executor.undo(action.undoData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        branch.currentIndex--;
+        this.onHistoryChange?.();
+        this.onActionExecuted?.(action, true);
+        return true;
+    }
+    redoSingleAction(branch, action) {
+        const executor = this.executors.get(action.actionType);
+        if (!executor) {
+            return false;
+        }
+        this.isExecuting = true;
+        try {
+            executor.execute(action.doData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        branch.currentIndex++;
+        this.onHistoryChange?.();
+        this.onActionExecuted?.(action, false);
+        return true;
+    }
+    canUndo() {
+        const branch = this.getActiveBranch();
+        return branch !== null && branch.currentIndex >= 0;
+    }
+    canRedo() {
+        const branch = this.getActiveBranch();
+        return branch !== null && branch.currentIndex < branch.actions.length - 1;
+    }
+    // ─── Selective Undo ────────────────────────────────────
+    undoAction(actionId) {
+        if (!this.config.enableSelectiveUndo) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        const actionIndex = branch.actions.findIndex((a) => a.id === actionId);
+        if (actionIndex === -1 || actionIndex > branch.currentIndex) {
+            return false;
+        }
+        const action = branch.actions[actionIndex];
+        const executor = this.executors.get(action.actionType);
+        if (!executor) {
+            return false;
+        }
+        // Execute undo
+        this.isExecuting = true;
+        try {
+            executor.undo(action.undoData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        // Mark action as selectively undone
+        action.metadata = action.metadata ?? {};
+        action.metadata.selectivelyUndone = true;
+        this.onHistoryChange?.();
+        this.onActionExecuted?.(action, true);
+        return true;
+    }
+    redoSelectiveAction(actionId) {
+        if (!this.config.enableSelectiveUndo) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        const action = branch.actions.find((a) => a.id === actionId);
+        if (!action || !action.metadata?.selectivelyUndone) {
+            return false;
+        }
+        const executor = this.executors.get(action.actionType);
+        if (!executor) {
+            return false;
+        }
+        // Execute redo
+        this.isExecuting = true;
+        try {
+            executor.execute(action.doData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        // Clear selective undo mark
+        delete action.metadata.selectivelyUndone;
+        this.onHistoryChange?.();
+        this.onActionExecuted?.(action, false);
+        return true;
+    }
+    // ─── Grouping ──────────────────────────────────────────
+    beginGroup(name, description = '') {
+        const groupId = this.generateId();
+        this.groups.set(groupId, {
+            id: groupId,
+            name,
+            description,
+            actionIds: [],
+            timestamp: Date.now(),
+            isCollapsed: true,
+        });
+        this.currentGroupId = groupId;
+        return groupId;
+    }
+    endGroup() {
+        if (!this.currentGroupId) {
+            return;
+        }
+        const group = this.groups.get(this.currentGroupId);
+        if (group && group.actionIds.length > 0) {
+            // Mark first and last actions
+            const branch = this.getActiveBranch();
+            if (branch) {
+                const firstAction = branch.actions.find((a) => a.id === group.actionIds[0]);
+                const lastAction = branch.actions.find((a) => a.id === group.actionIds[group.actionIds.length - 1]);
+                if (firstAction) {
+                    firstAction.isGroupStart = true;
+                }
+                if (lastAction) {
+                    lastAction.isGroupEnd = true;
+                }
+            }
+        }
+        this.currentGroupId = null;
+    }
+    cancelGroup() {
+        if (!this.currentGroupId) {
+            return;
+        }
+        const group = this.groups.get(this.currentGroupId);
+        if (group) {
+            // Undo all actions in group
+            for (let i = group.actionIds.length - 1; i >= 0; i--) {
+                const actionId = group.actionIds[i];
+                const branch = this.getActiveBranch();
+                if (branch) {
+                    const action = branch.actions.find((a) => a.id === actionId);
+                    if (action) {
+                        this.undoSingleAction(branch, action);
+                    }
+                }
+            }
+            this.groups.delete(this.currentGroupId);
+        }
+        this.currentGroupId = null;
+    }
+    undoGroup(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        // Undo all actions in group (reverse order)
+        for (let i = group.actionIds.length - 1; i >= 0; i--) {
+            const actionId = group.actionIds[i];
+            const action = branch.actions.find((a) => a.id === actionId);
+            if (action && branch.currentIndex >= branch.actions.indexOf(action)) {
+                this.undoSingleAction(branch, action);
+            }
+        }
+        return true;
+    }
+    redoGroup(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        // Redo all actions in group (forward order)
+        for (const actionId of group.actionIds) {
+            const action = branch.actions.find((a) => a.id === actionId);
+            const actionIndex = branch.actions.indexOf(action);
+            if (action && actionIndex === branch.currentIndex + 1) {
+                this.redoSingleAction(branch, action);
+            }
+        }
+        return true;
+    }
+    // ─── Snapshots ─────────────────────────────────────────
+    createSnapshot(name, description = '') {
+        if (!this.getStateSnapshot) {
+            console.warn('No state snapshot function registered');
+            return null;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return null;
+        }
+        const snapshot = {
+            id: this.generateId(),
+            name,
+            description,
+            timestamp: Date.now(),
+            actionIndex: branch.currentIndex,
+            stateData: this.getStateSnapshot(),
+            isAutoSnapshot: false,
+        };
+        this.snapshots.set(snapshot.id, snapshot);
+        this.actionsSinceSnapshot = 0;
+        this.onSnapshotCreated?.(snapshot);
+        return snapshot;
+    }
+    createAutoSnapshot() {
+        if (!this.getStateSnapshot) {
+            return;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return;
+        }
+        const snapshot = {
+            id: this.generateId(),
+            name: `Auto-snapshot ${new Date().toLocaleTimeString()}`,
+            description: 'Automatic snapshot',
+            timestamp: Date.now(),
+            actionIndex: branch.currentIndex,
+            stateData: this.getStateSnapshot(),
+            isAutoSnapshot: true,
+        };
+        this.snapshots.set(snapshot.id, snapshot);
+        this.actionsSinceSnapshot = 0;
+        this.onSnapshotCreated?.(snapshot);
+    }
+    restoreSnapshot(snapshotId) {
+        if (!this.restoreStateSnapshot) {
+            console.warn('No state restore function registered');
+            return false;
+        }
+        const snapshot = this.snapshots.get(snapshotId);
+        if (!snapshot) {
+            return false;
+        }
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        this.isExecuting = true;
+        try {
+            this.restoreStateSnapshot(snapshot.stateData);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+        branch.currentIndex = snapshot.actionIndex;
+        this.onHistoryChange?.();
+        return true;
+    }
+    getSnapshots() {
+        return Array.from(this.snapshots.values()).sort((a, b) => b.timestamp - a.timestamp);
+    }
+    deleteSnapshot(snapshotId) {
+        return this.snapshots.delete(snapshotId);
+    }
+    // ─── Branches ──────────────────────────────────────────
+    createBranch(name) {
+        if (!this.config.enableBranches) {
+            return null;
+        }
+        const parentBranch = this.getActiveBranch();
+        if (!parentBranch) {
+            return null;
+        }
+        if (this.branches.size >= this.config.maxBranches) {
+            // Remove oldest non-active branch
+            let oldest = null;
+            for (const branch of this.branches.values()) {
+                if (!branch.isActive && (!oldest || branch.createdAt < oldest.createdAt)) {
+                    oldest = branch;
+                }
+            }
+            if (oldest) {
+                this.branches.delete(oldest.id);
+            }
+        }
+        // Auto-snapshot before branch
+        if (this.config.autoSnapshotOnBranch && this.getStateSnapshot) {
+            this.createSnapshot(`Pre-branch: ${name}`, 'Automatic snapshot before branching');
+        }
+        const branch = {
+            id: this.generateId(),
+            name,
+            parentBranchId: parentBranch.id,
+            forkActionIndex: parentBranch.currentIndex,
+            actions: [...parentBranch.actions.slice(0, parentBranch.currentIndex + 1)],
+            currentIndex: parentBranch.currentIndex,
+            createdAt: Date.now(),
+            isActive: false,
+        };
+        this.branches.set(branch.id, branch);
+        return branch;
+    }
+    createBranchFromCurrent(name) {
+        const parentBranch = this.getActiveBranch();
+        if (!parentBranch) {
+            return null;
+        }
+        // Save current redo history as a branch
+        if (parentBranch.currentIndex < parentBranch.actions.length - 1) {
+            const branch = {
+                id: this.generateId(),
+                name: `${name} (${new Date().toLocaleTimeString()})`,
+                parentBranchId: parentBranch.id,
+                forkActionIndex: parentBranch.currentIndex,
+                actions: [...parentBranch.actions],
+                currentIndex: parentBranch.actions.length - 1,
+                createdAt: Date.now(),
+                isActive: false,
+            };
+            this.branches.set(branch.id, branch);
+            return branch;
+        }
+        return null;
+    }
+    switchBranch(branchId) {
+        const branch = this.branches.get(branchId);
+        if (!branch) {
+            return false;
+        }
+        // Deactivate current branch
+        const currentBranch = this.getActiveBranch();
+        if (currentBranch) {
+            currentBranch.isActive = false;
+        }
+        // Activate new branch
+        branch.isActive = true;
+        this.activeBranchId = branchId;
+        // Restore state if we have snapshot function
+        if (this.restoreStateSnapshot && this.getStateSnapshot) ;
+        this.onHistoryChange?.();
+        return true;
+    }
+    getBranches() {
+        return Array.from(this.branches.values());
+    }
+    getActiveBranch() {
+        return this.branches.get(this.activeBranchId) ?? null;
+    }
+    deleteBranch(branchId) {
+        if (branchId === 'main') {
+            return false;
+        }
+        const branch = this.branches.get(branchId);
+        if (!branch || branch.isActive) {
+            return false;
+        }
+        this.branches.delete(branchId);
+        return true;
+    }
+    mergeBranch(branchId) {
+        const branch = this.branches.get(branchId);
+        if (!branch || branch.isActive) {
+            return false;
+        }
+        const mainBranch = this.branches.get('main');
+        if (!mainBranch) {
+            return false;
+        }
+        // Append branch actions after fork point
+        const newActions = branch.actions.slice(branch.forkActionIndex + 1);
+        mainBranch.actions.push(...newActions);
+        mainBranch.currentIndex = mainBranch.actions.length - 1;
+        this.branches.delete(branchId);
+        this.onHistoryChange?.();
+        return true;
+    }
+    // ─── History Access ────────────────────────────────────
+    getHistory() {
+        const branch = this.getActiveBranch();
+        return branch ? [...branch.actions] : [];
+    }
+    getUndoHistory() {
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return [];
+        }
+        return branch.actions.slice(0, branch.currentIndex + 1);
+    }
+    getRedoHistory() {
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return [];
+        }
+        return branch.actions.slice(branch.currentIndex + 1);
+    }
+    getCurrentAction() {
+        const branch = this.getActiveBranch();
+        if (!branch || branch.currentIndex < 0) {
+            return null;
+        }
+        return branch.actions[branch.currentIndex];
+    }
+    getActionsByCategory(category) {
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return [];
+        }
+        return branch.actions.filter((a) => a.category === category);
+    }
+    getActionsByTarget(targetId) {
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return [];
+        }
+        return branch.actions.filter((a) => a.targetId === targetId);
+    }
+    getGroup(groupId) {
+        return this.groups.get(groupId);
+    }
+    // ─── History Visualization ─────────────────────────────
+    getHistoryTree() {
+        const nodes = [];
+        const mainBranch = this.branches.get('main');
+        if (mainBranch) {
+            const mainNode = {
+                id: 'main',
+                type: 'branch',
+                name: 'Main',
+                children: this.buildHistoryNodes(mainBranch),
+                isActive: mainBranch.isActive,
+                isCurrent: false,
+            };
+            nodes.push(mainNode);
+        }
+        // Add other branches
+        for (const [id, branch] of this.branches) {
+            if (id === 'main') {
+                continue;
+            }
+            const branchNode = {
+                id: branch.id,
+                type: 'branch',
+                name: branch.name,
+                children: this.buildHistoryNodes(branch),
+                isActive: branch.isActive,
+                isCurrent: false,
+                parentId: branch.parentBranchId ?? undefined,
+                forkIndex: branch.forkActionIndex,
+            };
+            nodes.push(branchNode);
+        }
+        return nodes;
+    }
+    buildHistoryNodes(branch) {
+        const nodes = [];
+        let currentGroupId = null;
+        let groupNode = null;
+        for (let i = 0; i < branch.actions.length; i++) {
+            const action = branch.actions[i];
+            const isCurrent = i === branch.currentIndex;
+            // Handle groups
+            if (action.groupId && action.groupId !== currentGroupId) {
+                const group = this.groups.get(action.groupId);
+                if (group) {
+                    groupNode = {
+                        id: action.groupId,
+                        type: 'group',
+                        name: group.name,
+                        children: [],
+                        isActive: false,
+                        isCurrent: false,
+                        isCollapsed: group.isCollapsed,
+                    };
+                    nodes.push(groupNode);
+                    currentGroupId = action.groupId;
+                }
+            }
+            if (action.isGroupEnd) {
+                currentGroupId = null;
+                groupNode = null;
+            }
+            // Check for snapshots at this index
+            for (const snapshot of this.snapshots.values()) {
+                if (snapshot.actionIndex === i) {
+                    const snapshotNode = {
+                        id: snapshot.id,
+                        type: 'snapshot',
+                        name: snapshot.name,
+                        children: [],
+                        isActive: false,
+                        isCurrent: false,
+                        timestamp: snapshot.timestamp,
+                    };
+                    if (groupNode) {
+                        groupNode.children.push(snapshotNode);
+                    }
+                    else {
+                        nodes.push(snapshotNode);
+                    }
+                }
+            }
+            const actionNode = {
+                id: action.id,
+                type: 'action',
+                name: action.name,
+                children: [],
+                isActive: i <= branch.currentIndex,
+                isCurrent,
+                category: action.category,
+                timestamp: action.timestamp,
+                selectivelyUndone: action.metadata?.selectivelyUndone === true,
+            };
+            if (groupNode) {
+                groupNode.children.push(actionNode);
+            }
+            else {
+                nodes.push(actionNode);
+            }
+        }
+        return nodes;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnHistoryChange(callback) {
+        this.onHistoryChange = callback;
+    }
+    setOnActionExecuted(callback) {
+        this.onActionExecuted = callback;
+    }
+    setOnSnapshotCreated(callback) {
+        this.onSnapshotCreated = callback;
+    }
+    setStateSnapshotFunctions(getSnapshot, restoreSnapshot) {
+        this.getStateSnapshot = getSnapshot;
+        this.restoreStateSnapshot = restoreSnapshot;
+    }
+    // ─── Utilities ─────────────────────────────────────────
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    enforceHistoryLimit(branch) {
+        while (branch.actions.length > this.config.maxHistorySize) {
+            const removed = branch.actions.shift();
+            branch.currentIndex--;
+            // Remove from groups
+            if (removed?.groupId) {
+                const group = this.groups.get(removed.groupId);
+                if (group) {
+                    group.actionIds = group.actionIds.filter((id) => id !== removed.id);
+                    if (group.actionIds.length === 0) {
+                        this.groups.delete(removed.groupId);
+                    }
+                }
+            }
+            // Update snapshot indices
+            for (const snapshot of this.snapshots.values()) {
+                if (snapshot.actionIndex > 0) {
+                    snapshot.actionIndex--;
+                }
+            }
+        }
+    }
+    jumpToAction(actionId) {
+        const branch = this.getActiveBranch();
+        if (!branch) {
+            return false;
+        }
+        const targetIndex = branch.actions.findIndex((a) => a.id === actionId);
+        if (targetIndex === -1) {
+            return false;
+        }
+        // Undo or redo to reach target
+        while (branch.currentIndex > targetIndex) {
+            if (!this.undo()) {
+                break;
+            }
+        }
+        while (branch.currentIndex < targetIndex) {
+            if (!this.redo()) {
+                break;
+            }
+        }
+        return branch.currentIndex === targetIndex;
+    }
+    clear() {
+        for (const branch of this.branches.values()) {
+            branch.actions = [];
+            branch.currentIndex = -1;
+        }
+        this.groups.clear();
+        this.snapshots.clear();
+        this.actionsSinceSnapshot = 0;
+        this.currentGroupId = null;
+        this.onHistoryChange?.();
+    }
+    // ─── Serialization ─────────────────────────────────────
+    serialize() {
+        const data = {
+            config: this.config,
+            branches: Object.fromEntries(Array.from(this.branches.entries()).map(([id, branch]) => [
+                id,
+                {
+                    ...branch,
+                    actions: branch.actions.map((a) => ({
+                        ...a,
+                        // Don't serialize complex data
+                        doData: JSON.stringify(a.doData),
+                        undoData: JSON.stringify(a.undoData),
+                    })),
+                },
+            ])),
+            activeBranchId: this.activeBranchId,
+            groups: Object.fromEntries(this.groups),
+            snapshots: Object.fromEntries(this.snapshots),
+        };
+        return JSON.stringify(data);
+    }
+    deserialize(json) {
+        try {
+            const data = JSON.parse(json);
+            this.config = { ...DEFAULT_UNDO_REDO_CONFIG, ...data.config };
+            this.activeBranchId = data.activeBranchId;
+            this.branches.clear();
+            for (const [id, branch] of Object.entries(data.branches)) {
+                const b = branch;
+                this.branches.set(id, {
+                    ...b,
+                    actions: b.actions.map((a) => ({
+                        ...a,
+                        doData: JSON.parse(a.doData),
+                        undoData: JSON.parse(a.undoData),
+                    })),
+                });
+            }
+            this.groups = new Map(Object.entries(data.groups));
+            this.snapshots = new Map(Object.entries(data.snapshots));
+            this.onHistoryChange?.();
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to deserialize undo/redo state:', error);
+            return false;
+        }
+    }
+}
+// ============================================================
+// Common Action Executors
+// ============================================================
+const CommonExecutors = {
+    setProperty: {
+        execute(data) {
+            data.target[data.property] = data.value;
+        },
+        undo(data) {
+            data.target[data.property] = data.oldValue;
+        },
+        merge(oldData, newData) {
+            if (oldData.property !== newData.property) {
+                return null;
+            }
+            return { ...oldData, value: newData.value };
+        },
+    },
+    arrayPush: {
+        execute(data) {
+            data.array.push(data.value);
+        },
+        undo(data) {
+            data.array.pop();
+        },
+    },
+    arrayRemove: {
+        execute(data) {
+            data.array.splice(data.index, 1);
+        },
+        undo(data) {
+            data.array.splice(data.index, 0, data.value);
+        },
+    },
+    mapSet: {
+        execute(data) {
+            data.map.set(data.key, data.value);
+        },
+        undo(data) {
+            if (data.hadValue) {
+                data.map.set(data.key, data.oldValue);
+            }
+            else {
+                data.map.delete(data.key);
+            }
+        },
+    },
+    mapDelete: {
+        execute(data) {
+            data.map.delete(data.key);
+        },
+        undo(data) {
+            data.map.set(data.key, data.value);
+        },
+    },
+};
+// ============================================================
+// Factory Functions
+// ============================================================
+function createUndoRedoManager(config) {
+    return new UndoRedoManager(config);
+}
+function createAction(name, actionType, category, doData, undoData, options) {
+    return {
+        name,
+        actionType,
+        category,
+        doData,
+        undoData,
+        description: options?.description ?? '',
+        targetId: options?.targetId,
+        targetType: options?.targetType,
+        metadata: options?.metadata,
+        groupId: options?.groupId,
+    };
+}
+
+export { CommonExecutors, DEFAULT_UNDO_REDO_CONFIG, UndoRedoManager, createAction, createUndoRedoManager };
+//# sourceMappingURL=UndoRedoPro.js.map