fix(history): renaming the delete method to be more explicit

Author: arnobl

src/api/history/TreeHistory.ts

@@ -146,12 +146,12 @@ export abstract class TreeHistory implements LinearHistoryBase {
     public abstract goTo(id: number): void;
 
     /**
-     * Deletes the targeted node. Works only if the history does not keep the
-     * usage path (see path()).
-     * @param id - The node ID to remove. It removes all the branch from this node.
-     * Does not remove the branch if the current node is in it.
+     * Deletes the targeted node and all its descendants.
+     * Works only if the history does not keep the usage path (see path()).
+     * @param id - The node ID to remove. It removes all the branch starting from this node included.
+     * Does nothing if the current node is part of the nodes to be removed.
      */
-    public abstract delete(id: number): void;
+    public abstract deleteFrom(id: number): void;
 
     /**
      * Retrieves the modifiable attributes of the undoable node identified by the given id.

src/impl/history/TreeHistoryImpl.ts

@@ -196,7 +196,7 @@ export class TreeHistoryImpl extends TreeHistory {
         this.sizePublisher.next(0);
     }
 
-    public delete(id: number): void {
+    public deleteFrom(id: number): void {
         // Cannot delete if keeping path
         if (this.keepPath) {
             return;
@@ -230,7 +230,7 @@ export class TreeHistoryImpl extends TreeHistory {
 
         // Cloning the array since 'delete' may alter the children list.
         for (const child of Array.from(node.children)) {
-            this.delete(child.id);
+            this.deleteFrom(child.id);
         }
 
         if (this.currentNode === node) {

test/history/TreeHistory.test.ts

@@ -77,7 +77,7 @@ describe("using a tree-based history", () => {
         });
 
         test("delete invalid node ok", () => {
-            history.delete(0);
+            history.deleteFrom(0);
             expect(history.size()).toBe(0);
             expect(history.currentNode).toBe(history.root);
             expect(history.size()).toBe(0);
@@ -162,7 +162,7 @@ describe("using a tree-based history", () => {
                             // eslint-disable-next-line jest/no-conditional-in-test
                             if (typeof v === "number") {
                                 history.goTo(v - 1);
-                                history.delete(v);
+                                history.deleteFrom(v);
                             } else {
                                 history.add(v);
                             }
@@ -480,19 +480,19 @@ describe("using a tree-based history", () => {
             });
 
             test("delete negative node ID ok", () => {
-                history.delete(-1);
+                history.deleteFrom(-1);
                 expect(history.size()).toBe(1);
                 expect(history.currentNode.undoable).toBe(undoable0);
             });
 
             test("delete invalid ok", () => {
-                history.delete(1);
+                history.deleteFrom(1);
                 expect(history.size()).toBe(1);
                 expect(history.currentNode.undoable).toBe(undoable0);
             });
 
             test("cannot delete the current branch", () => {
-                history.delete(0);
+                history.deleteFrom(0);
                 expect(history.size()).toBe(1);
                 expect(history.currentNode.undoable).toBe(undoable0);
             });
@@ -580,7 +580,7 @@ describe("using a tree-based history", () => {
 
             test("delete one root is OK", () => {
                 history.goTo(-1);
-                history.delete(1);
+                history.deleteFrom(1);
                 expect(history.undoableNodes[0]?.undoable).toBe(undoable0);
                 expect(history.undoableNodes[1]?.undoable).toBeUndefined();
                 expect(history.size()).toBe(1);
@@ -763,7 +763,7 @@ describe("using a tree-based history", () => {
             test("get last redoable when moving to 4 and history and delete 4", () => {
                 history.goTo(4);
                 history.undo();
-                history.delete(4);
+                history.deleteFrom(4);
                 expect(history.getLastRedo()).toBe(undoable3);
                 expect(history.size()).toBe(4);
             });
@@ -810,7 +810,7 @@ describe("using a tree-based history", () => {
             });
 
             test("delete 1", () => {
-                history.delete(1);
+                history.deleteFrom(1);
 
                 expect(history.size()).toBe(4);
                 expect(history.currentNode.undoable).toBe(undoable4);
@@ -830,7 +830,7 @@ describe("using a tree-based history", () => {
 
             test("delete 2", () => {
                 history.goTo(0);
-                history.delete(2);
+                history.deleteFrom(2);
 
                 expect(history.size()).toBe(2);
                 expect(history.currentNode.undoable).toBe(undoable0);
@@ -846,7 +846,7 @@ describe("using a tree-based history", () => {
 
             test("delete 0", () => {
                 history.goTo(1);
-                history.delete(2);
+                history.deleteFrom(2);
 
                 expect(history.size()).toBe(2);
                 expect(history.currentNode.undoable).toBe(undoable1);
@@ -858,7 +858,7 @@ describe("using a tree-based history", () => {
             });
 
             test("delete invalid 5", () => {
-                history.delete(5);
+                history.deleteFrom(5);
 
                 expect(history.size()).toBe(5);
                 expect(history.currentNode.undoable).toBe(undoable4);