fix(history): renaming histories not to contain "undo"

Author: arnobl

CHANGELOG.md

@@ -303,7 +303,7 @@
 * change(api): encapsulating the bindings routines into a class
 * change(api): moving the undo/redo history into the bindings class. So removing the Single instance.
 * change(api): moving implementation classes into the impl folder
-* change(api): separating API / implementation of the UndoHistory
+* change(api): separating API / implementation of the LinearHistory
 * change(api): the error class must be located in the impl folder
 * change(api): the useless command registry and the registration policy removed
 * change(api): major refactoring of interaction data to match the Web API

src/api/binding/Bindings.ts

@@ -43,7 +43,7 @@ import type {GeneralTwoTouchData, TwoTouchData} from "../interaction/TwoTouchDat
 import type {WheelData} from "../interaction/WheelData";
 import type {WidgetData} from "../interaction/WidgetData";
 import type {Logger} from "../logging/Logger";
-import type {UndoHistoryBase} from "../undo/UndoHistoryBase";
+import type {LinearHistoryBase} from "../history/LinearHistoryBase";
 
 /**
  * Defines a partly defined binder for buttons
@@ -195,15 +195,15 @@ export type PartialThenBinder<XS extends Array<Interaction<object>>, A = unknown
 /**
  * A contextual object for creating binders and thus bindings.
  * allows the observation of the created bindings.
- * Provides an undo/redo history.
+ * Provides an history/redo history.
  * Why a pure abstract class and not an interface?
- * Because interfaces are not retained at runtime in TS and we want DI (that thus cannot inject interface types).
- * @template H -- The undo history algorithm
+ * Because interfaces are not retained at run time in TS, and we want DI (that thus cannot inject interface types).
+ * @template H -- The linear history
  * @category API Binding
  */
-export abstract class Bindings<H extends UndoHistoryBase> {
+export abstract class Bindings<H extends LinearHistoryBase> {
     /**
-     * The undo/redo history of the current binding context
+     * The history/redo history of the current binding context
      */
     public abstract readonly undoHistory: H;
 
@@ -572,10 +572,10 @@ export abstract class Bindings<H extends UndoHistoryBase> {
         accInit?: A): PartialTouchMouseDnDTypedBinder<A>;
 
     /**
-     * Creates two bindings for undo and redo operations with buttons.
-     * @param undo - The undo button
+     * Creates two bindings for history and redo operations with buttons.
+     * @param undo - The history button
      * @param redo - The redo button
-     * @param catchFn - The function that will treat the errors for both undo and redo bindings
+     * @param catchFn - The function that will treat the errors for both history and redo bindings
      */
     public abstract undoRedoBinder(undo: Widget<HTMLButtonElement>, redo: Widget<HTMLButtonElement>, catchFn?: ((err: unknown) => void)):
     [Binding<Command, Interaction<WidgetData<HTMLButtonElement>>, unknown>,
@@ -591,7 +591,7 @@ export abstract class Bindings<H extends UndoHistoryBase> {
     /**
      * Clears all the data of this binding context:
      * the possible current `BindingsObserver` object;
-     * the undo/redo history.
+     * the history/redo history.
      */
     public abstract clear(): void;
 

src/api/binding/VisitorBinding.ts

@@ -17,7 +17,7 @@ import type {Bindings} from "./Bindings";
 import type {Command} from "../command/Command";
 import type {Interaction} from "../interaction/Interaction";
 import type {VisitorInteraction} from "../interaction/VisitorInteraction";
-import type {UndoHistoryBase} from "../undo/UndoHistoryBase";
+import type {LinearHistoryBase} from "../history/LinearHistoryBase";
 
 /**
  * The main interface for visiting user interactions.
@@ -26,5 +26,5 @@ import type {UndoHistoryBase} from "../undo/UndoHistoryBase";
 export interface VisitorBinding extends VisitorInteraction {
     visitBinding(binding: Binding<Command, Interaction<object>, unknown>): void;
 
-    visitBindings(bindings: Bindings<UndoHistoryBase>): void;
+    visitBindings(bindings: Bindings<LinearHistoryBase>): void;
 }

src/api/command/Command.ts

@@ -32,7 +32,7 @@ export type CmdStatus =
  * A command is produced and executed in reaction of a user interaction.
  * It follows the command design pattern.
  * It contains statements to execute to perform the command.
- * The interface Undoable can be used to add undo/redo features to a command.
+ * The interface Undoable can be used to add history/redo features to a command.
  * @category API Command
  */
 export interface Command {

src/api/command/ModifiableCommand.ts

@@ -11,9 +11,9 @@
  * You should have received a copy of the GNU General Public License
  * along with Interacto.  If not, see <https://www.gnu.org/licenses/>.
  */
-import {isUndoableType} from "../undo/Undoable";
+import {isUndoableType} from "../history/Undoable";
 import type {Command} from "./Command";
-import type {Undoable} from "../undo/Undoable";
+import type {Undoable} from "../history/Undoable";
 
 const INTERACTO_MODIFIABLE: unique symbol = Symbol("interacto-cmd-modifiable");
 

src/api/undo/UndoHistory.ts src/api/history/LinearHistory.tssrc/api/undo/UndoHistory.ts renamed to src/api/history/LinearHistory.ts

@@ -13,16 +13,16 @@
  */
 
 import type {Undoable} from "./Undoable";
-import type {UndoHistoryBase} from "./UndoHistoryBase";
+import type {LinearHistoryBase} from "./LinearHistoryBase";
 import type {Observable} from "rxjs";
 
 /**
- * A history of undone/redone objects.
+ * A linear command history.
  * Why a pure abstract class and not an interface?
  * Because interfaces are not retained at runtime in TS and we want DI (that thus cannot inject interface types).
  * @category API History
  */
-export abstract class UndoHistory implements UndoHistoryBase {
+export abstract class LinearHistory implements LinearHistoryBase {
     public abstract add(undoable: Undoable): void;
 
     public abstract clear(): void;
@@ -73,7 +73,7 @@ export abstract class UndoHistory implements UndoHistoryBase {
 
     /**
      * The number of elements the history contains.
-     * Provide both the size of the undo and the redo stacks in the produced tuple.
+     * Provide both the size of the history and the redo stacks in the produced tuple.
      */
     public abstract size(): [undos: number, redos: number];
 

src/api/undo/UndoHistoryBase.ts src/api/history/LinearHistoryBase.tssrc/api/undo/UndoHistoryBase.ts renamed to src/api/history/LinearHistoryBase.ts

@@ -16,10 +16,10 @@ import type {Undoable} from "./Undoable";
 import type {Observable} from "rxjs";
 
 /**
- * The base interface for undo histories.
+ * The base interface for linear histories.
  * @category API History
  */
-export interface UndoHistoryBase {
+export interface LinearHistoryBase {
     /**
      * Undoes the last undoable object.
      */

src/api/undo/TreeUndoHistory.ts src/api/history/TreeHistory.tssrc/api/undo/TreeUndoHistory.ts renamed to src/api/history/TreeHistory.ts

@@ -13,16 +13,16 @@
  */
 
 import type {Undoable, UndoableSnapshot} from "./Undoable";
-import type {UndoHistoryBase} from "./UndoHistoryBase";
+import type {LinearHistoryBase} from "./LinearHistoryBase";
 import type {Observable} from "rxjs";
 
 /**
- * The interface for nodes in a tree-based history.
+ * The type that defines the concept of a node stored in a tree-based history.
  * @category API History
  */
 export interface UndoableTreeNode {
     /**
-     * Among the children of the node, iidentifies the one that was undone recently.
+     * Among the children of the node, identifies the one that was undone recently.
      */
     lastChildUndone: UndoableTreeNode | undefined;
 
@@ -73,7 +73,7 @@ export interface UndoableTreeNodeDTO {
     readonly id: number;
 
     /**
-     * The undoable object contained in the node, in an unkown format as
+     * The undoable object contained in the node, in an unknown format as
      * the format is defined by the developer while exporting the history.
      */
     readonly undoable: unknown;
@@ -101,13 +101,13 @@ export interface TreeUndoHistoryDTO {
 }
 
 /**
- * Tree-based undo history.
- * On adding undoables after an undo operation, the redoable objects are no more flush but
- * kept in the history as a granch of the graph.
+ * The type that defines the concept of a tree-based history.
+ * On adding undoable objects after a history operation, the redoable objects are no more flush but
+ * kept in the history as a branch of the graph.
  * Useful for exploration.
  * @category API History
  */
-export abstract class TreeUndoHistory implements UndoHistoryBase {
+export abstract class TreeHistory implements LinearHistoryBase {
     /**
      * States whether the path of kept. If kept, users cannot delete
      * nodes.
@@ -134,7 +134,7 @@ export abstract class TreeUndoHistory implements UndoHistoryBase {
 
     /**
      * The current node. As the history is a tree in which one can navigate using
-     * undo, redo, gotTo, this current node refers to the node
+     * history, redo, gotTo, this current node refers to the node
      * where the system state is.
      */
     public abstract get currentNode(): UndoableTreeNode;
@@ -212,7 +212,7 @@ export abstract class TreeUndoHistory implements UndoHistoryBase {
     /**
      * Imports the given DTO history. Flushes the current history.
      * @param dtoHistory - The DTO history to import.
-     * @param fn - The convertion fonction that transforms undoable DTO (of nodes) into Undoable.
+     * @param fn - The transformation function that transforms undoable DTO (of nodes) into Undoable.
      */
     public abstract import(dtoHistory: TreeUndoHistoryDTO, fn: (dtoUndoable: unknown) => Undoable): void;
 

src/api/undo/Undoable.ts src/api/history/Undoable.tssrc/api/undo/Undoable.ts renamed to src/api/history/Undoable.ts

@@ -19,7 +19,7 @@
 export type PrimitiveUndoableSnapshot = HTMLElement | SVGElement | string;
 
 /**
- * The type of the visual snpashot that an undoable command can produce
+ * The type of the visual snapshot that an undoable command can produce
  * @category API History
  */
 export type UndoableSnapshot = PrimitiveUndoableSnapshot | Promise<PrimitiveUndoableSnapshot> | undefined;
@@ -40,13 +40,13 @@ export interface Undoable {
     redo(): void;
 
     /**
-     * @returns The name of the undo command.
+     * @returns The name of the history command.
      */
     getUndoName(): string;
 
     /**
      * Gives some information about the impact of a command.
-     * @returns Information about the impact of the commmand as an SVG element or text.
+     * @returns Information about the impact of the command as an SVG element or text.
      */
     getVisualSnapshot(): UndoableSnapshot;
 

src/impl/binder/Binder.ts

@@ -26,7 +26,7 @@ import type {Command} from "../../api/command/Command";
 import type {Interaction, InteractionDataType} from "../../api/interaction/Interaction";
 import type {Logger} from "../../api/logging/Logger";
 import type {LogLevel} from "../../api/logging/LogLevel";
-import type {UndoHistoryBase} from "../../api/undo/UndoHistoryBase";
+import type {LinearHistoryBase} from "../../api/history/LinearHistoryBase";
 
 /**
  * The base class that defines the concept of binding builder (called binder).
@@ -67,7 +67,7 @@ implements CmdBinder<C>, InteractionBinder<I, A, D>, InteractionCmdBinder<C, I,
 
     protected observer: BindingsObserver | undefined;
 
-    protected undoHistory: UndoHistoryBase;
+    protected undoHistory: LinearHistoryBase;
 
     protected logger: Logger;
 
@@ -89,7 +89,7 @@ implements CmdBinder<C>, InteractionBinder<I, A, D>, InteractionCmdBinder<C, I,
 
     protected linterRules: Map<RuleName, Severity>;
 
-    protected constructor(undoHistory: UndoHistoryBase, logger: Logger, observer?: BindingsObserver,
+    protected constructor(undoHistory: LinearHistoryBase, logger: Logger, observer?: BindingsObserver,
                           binder?: Partial<Binder<C, I, A, D>>, acc?: A) {
         this.widgets = [];
         this.dynamicNodes = [];