easy-richtextarea 4.0.19 → 4.0.20

package/src/undoBuffer.js

@@ -7,99 +7,113 @@ import InsertOperation from "./operation/insert";
 import DeleteOperation from "./operation/delete";
 import transformOperations from "./transform/operations";
 
-const { push } = arrayUtilities;
+const { clear, filter, unshift } = arrayUtilities;
 
 export default class UndoBuffer {
-  constructor(position, operations) {
-    this.position = position;
-    this.operations = operations;
+  constructor(undoOperations, redoOperations) {
+    this.undoOperations = undoOperations;
+    this.redoOperations = redoOperations;
   }
 
-  getPosition() {
-    return this.position;
+  getUndoOperations() {
+    return this.undoOperations;
   }
-
-  getOperations() {
-    return this.operations;
+  
+  getRedoOperations() {
+    return this.redoOperations;
   }
 
   undo() {
-    let operation = null;
+    let undoOperation = null;
 
-    if (this.position > 0) {
-      this.position--;
+    const undoOperationsLength = this.undoOperations.length;
 
-      operation = this.operations[this.position];
+    if (undoOperationsLength > 0) {
+      undoOperation = this.undoOperations.shift();
 
-      const invertedOperation = operation.invert(InsertOperation, DeleteOperation);
+      const invertedUndoOperation = undoOperation.invert(InsertOperation, DeleteOperation),
+            redoOperation = invertedUndoOperation;  ///
 
-      operation = invertedOperation;  ///
+      this.redoOperations.unshift(redoOperation);
     }
 
-    return operation;
+    return undoOperation;
   }
 
   redo() {
-    let operation = null;
+    let redoOperation = null;
+
+    const redoOperationsLength = this.redoOperations.length;
 
-    const operationsLength = this.operations.length;
+    if (redoOperationsLength > 0) {
+      redoOperation = this.redoOperations.shift();
 
-    if (this.position < operationsLength) {
-      operation = this.operations[this.position];
+      const invertedRedoOperation = redoOperation.invert(InsertOperation, DeleteOperation),
+            undoOperation = invertedRedoOperation;  ///
 
-      this.position++;
+      this.undoOperations.unshift(undoOperation);
     }
 
-    return operation;
+    return redoOperation;
   }
 
   transform(operations) {
-    this.operations = transformOperations(this.operations, operations);
+    this.undoOperations = transformOperations(this.undoOperations, operations);
 
-    this.filterEmptyOperations();
+    this.redoOperations = transformOperations(this.redoOperations, operations);
+    
+    filterEmptyOperations(this.undoOperations);
+
+    filterEmptyOperations(this.redoOperations);
   }
 
   addOperations(operations) {
-    const start = this.position;  ///
+    const invertedOperations = invertOperations(operations),
+          reversedInvertedOperations = reverseOperations(invertedOperations),
+          undoOperations = reversedInvertedOperations;  ///
 
-    this.operations.splice(start);
+    unshift(this.undoOperations, undoOperations);
 
-    push(this.operations, operations);
+    clear(this.redoOperations);
+  }
 
-    const operationsLength = this.operations.length;
+  static fromNothing() {
+    const undoOperations = [],
+          redoOperations = [],
+          undoBuffer = new UndoBuffer(undoOperations, redoOperations);
 
-    this.position = operationsLength; ///
+    return undoBuffer;
   }
+}
+
+function invertOperations(operations) {
+  const invertedOperations = operations.map((operation) => {
+    const invertedOperation = operation.invert(InsertOperation, DeleteOperation);
 
-  filterEmptyOperations() {
-    let length = this.operations.length,
-          position = 0;
+    return invertedOperation;
+  });
 
-    while (position < length) {
-      const operation = this.operations[position];
+  return invertedOperations;
+}
 
-      if (operation instanceof EmptyOperation) {
-        const start = position, ///
-              deleteCount = 1;
+function reverseOperations(operations) {
+  const reversedOperations = operations.reduce((reversedOperations, operation) => {
+    const reversedOperation = operation;  ///
 
-        this.operations.splice(start, deleteCount);
+    reversedOperations.unshift(reversedOperation);
 
-        if (this.position > position) {
-          this.position--;
-        }
-      } else {
-        position++;
-      }
+    return reversedOperations;
+  }, []);
 
-      length = this.operations.length;
-    }
-  }
+  return reversedOperations;
+}
 
-  static fromNothing() {
-    const position = 0,
-          operations = [],
-          undoBuffer = new UndoBuffer(position, operations);
+function filterEmptyOperations(operations) {
+  filter(operations, (operation) => {
+    const operationEmptyOperation = (operation instanceof EmptyOperation);
 
-    return undoBuffer;
-  }
+    if (!operationEmptyOperation) {
+      return true;
+    }
+  });
 }