feat(history): can create an alternative branch by ignoring one given command

Author: arnobl

src/api/history/TreeHistory.ts

@@ -153,6 +153,15 @@ export abstract class TreeHistory implements LinearHistoryBase {
      */
     public abstract deleteFrom(id: number): void;
 
+    /**
+     * Creates an alternative branch that does not contain the targeted node.
+     * If the targeted node has no child, nothing happens.
+     * Otherwise, the history creates a new branch at the parent level without the targeted node.
+     * Does not delete anything, so compatible with the usage path (see path()).
+     * @param id - The node ID to remove.
+     */
+    public abstract deleteNode(id: number): void;
+
     /**
      * Retrieves the modifiable attributes of the undoable node identified by the given id.
      * See the method `getModifiableCmdAttributes` in the class `ModifiableCommand`.

src/impl/history/TreeHistoryImpl.ts

@@ -197,14 +197,10 @@ export class TreeHistoryImpl extends TreeHistory {
     }
 
     public deleteFrom(id: number): void {
-        // Cannot delete if keeping path
-        if (this.keepPath) {
-            return;
-        }
-
         const node = this.undoableNodes[id];
 
-        if (node === undefined) {
+        // Cannot delete if keeping path
+        if (this.keepPath || node === undefined) {
             return;
         }
 
@@ -246,6 +242,26 @@ export class TreeHistoryImpl extends TreeHistory {
         return getModifiableCmdAttributes(node.undoable);
     }
 
+    public deleteNode(id: number): void {
+        const node = this.undoableNodes[id];
+        const parent = node?.parent;
+
+        // Cannot delete if keeping path.
+        // If the node to delete has no child, just a simple removal.
+        if (this.keepPath || parent === undefined || node === undefined || node.children.length === 0) {
+            return;
+        }
+
+        const currentId = this.currentNode.id;
+        this.goTo(parent.id);
+        // Cloning the child trees of the node to remove.
+        // The goal is to create new branches at the parent level without the node to remove.
+        const clonedTree = this.cloneSubtree(node);
+        this.addClonedSubtree(clonedTree);
+        // Going back to the original position
+        this.goTo(currentId);
+    }
+
     public applyModifiedAttributesOn(id: number, data: object): void {
         // not `at(i)` since at considers -1 as last one
         const node = this.undoableNodes[id];
@@ -279,19 +295,28 @@ export class TreeHistoryImpl extends TreeHistory {
         }
     }
 
-    private proceedModifiedNode(currentNode: UndoableTreeNode): void {
+    /**
+     * Takes a modified command and re-processes it within the history
+     * @param node - The modified command to re-executed
+     */
+    private proceedModifiedNode(node: UndoableTreeNode): void {
         // Executing the cloned undoable object
-        currentNode.undoable.redo();
+        node.undoable.redo();
         // Must refresh the visual snapshot cache
-        if (currentNode.undoable instanceof UndoableCommand) {
-            currentNode.undoable.refreshCache();
+        if (node.undoable instanceof UndoableCommand) {
+            node.undoable.refreshCache();
         }
         // Adding the novel commands to the history
-        this.add(currentNode.undoable);
+        this.add(node.undoable);
     }
 
-    private addClonedSubtree(currentNode: UndoableTreeNode): void {
-        for (const child of currentNode.children) {
+    /**
+     * Adds the given node and its child trees in the history.
+     * Re-execute the added nodes.
+     * @param node - The node to add (and its children)
+     */
+    private addClonedSubtree(node: UndoableTreeNode): void {
+        for (const child of node.children) {
             this.proceedModifiedNode(child);
             this.undo();
             this.addClonedSubtree(child);

test/history/TreeHistory.test.ts

@@ -1101,6 +1101,55 @@ describe("using a tree-based history", () => {
         });
     });
 
+    describe("when deleting nodes", () => {
+        beforeEach(() => {
+            history = new TreeHistoryImpl(false, true);
+            history.add(undoable0);
+            history.add(undoable1);
+            // A - B*
+        });
+
+        test("no effect when using bad id", () => {
+            history.goTo(history.root.children[0].id);
+            history.deleteNode(10);
+            // A* - B
+            expect(history.size()).toBe(2);
+        });
+
+        test("does nothing the node if it has no child", () => {
+            history.goTo(history.root.children[0].id);
+            history.deleteNode(history.root.children[0].children[0].id);
+            // A* - B
+            expect(history.size()).toBe(2);
+            expect(history.currentNode.undoable).toBe(undoable0);
+        });
+
+        test("no effect if trying to remove the root", () => {
+            history.deleteNode(history.root.id);
+            // A - B*
+            expect(history.size()).toBe(2);
+        });
+
+        test("creates a branch with correct undoable objects", () => {
+            history.add(new CmdModifiableDouble());
+            history.undo();
+            history.add(new CmdModifiableDouble3());
+            // A - B - C|D*
+            history.deleteNode(1);
+
+            // A - B - C|D*
+            //   - C'
+            //   - D'
+            expect(history.size()).toBe(6);
+            expect(history.root.children).toHaveLength(1);
+            expect(history.root.children[0].children).toHaveLength(3);
+            expect(history.root.children[0].children[0].children).toHaveLength(2);
+            expect(history.root.children[0].children[1].undoable).toBeInstanceOf(CmdModifiableDouble);
+            expect(history.root.children[0].children[2].undoable).toBeInstanceOf(CmdModifiableDouble3);
+            expect(history.root.children[0].children[0].undoable).toBe(undoable1);
+        });
+    });
+
     describe("using a standard tree history storing modifiable commands", () => {
         let cmd: CmdModifiableDouble;