easy-richtextarea 4.0.1 → 4.0.4

package/src/operation/delete.js

@@ -2,22 +2,32 @@
 
 import EmptyOperation from "../operation/empty";
 
-import { insertType, deleteType, emptyType } from "../types";
+import { INSERT_TYPE, DELETE_TYPE, EMPTY_TYPE } from "../types";
 
 export default class DeleteOperation {
-  constructor(type, length, position) {
+  constructor(type, content, position) {
 	  this.type = type;
-    this.length = length;
+    this.content = content;
     this.position = position;
   }
 
-  clone() {
-    return DeleteOperation.fromLengthAndPosition(this.length, this.position);
+  getType() {
+    return this.type;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  getPosition() {
+    return this.position;
   }
 
   transformOperation(operation) {
-    switch (operation.type) {
-      case insertType:
+    const type = operation.getType();
+
+    switch (type) {
+      case INSERT_TYPE:
         return ((tau, rho) => {
 
           if (tau.position <= rho.position) {
@@ -25,56 +35,61 @@ export default class DeleteOperation {
           }
 
           if (tau.position > rho.position) {
-            if (tau.position < rho.length + rho.position) {
+            if (tau.position < rho.content.length + rho.position) {
               return [tau.left(rho).shift(tau)];
             }
-            if (tau.position >= rho.length + rho.position) {
+
+            if (tau.position >= rho.content.length + rho.position) {
               return [rho.shift(tau)];
             }
           }
 
         })(operation, this);
 
-      case deleteType:
+      case DELETE_TYPE:
         return ((tau, rho) => {
 
           if (tau.position < rho.position) {
-            if (tau.length + tau.position <= rho.position) {
+            if (tau.content.length + tau.position <= rho.position) {
               return [tau.clone()];
             }
-            if (tau.length + tau.position <= rho.length + rho.position) {
+
+            if (tau.content.length + tau.position <= rho.content.length + rho.position) {
               return [rho.takenFrom(tau)];
             }
-            if (tau.length + tau.position > rho.length + rho.position) {
+
+            if (tau.content.length + tau.position > rho.content.length + rho.position) {
               return [rho.split(tau)];
             }
           }
 
           if (tau.position === rho.position) {
-            if (tau.length + tau.position <= rho.length + rho.position) {
+            if (tau.content.length + tau.position <= rho.content.length + rho.position) {
               return [EmptyOperation.fromNothing()];
             }
-            if (tau.length + tau.position > rho.length + rho.position) {
+
+            if (tau.content.length + tau.position > rho.content.length + rho.position) {
               return [rho.shift(rho.takenFrom(tau))];
             }
           }
 
-          if (tau.position >= rho.length + rho.position) {
+          if (tau.position >= rho.content.length + rho.position) {
             return [rho.shift(tau)];
           }
 
           if (tau.position > rho.position) {
-            if (tau.length + tau.position <= rho.length + rho.position) {
+            if (tau.content.length + tau.position <= rho.content.length + rho.position) {
               return [EmptyOperation.fromNothing()];
             }
-            if (tau.length + tau.position > rho.length + rho.position) {
+
+            if (tau.content.length + tau.position > rho.content.length + rho.position) {
               return [rho.shift(rho.takenFrom(tau))];
             }
           }
 
         })(operation, this);
 
-      case emptyType:
+      case EMPTY_TYPE:
         return ((tau, rho) => {
 
           return [tau.clone()];
@@ -84,44 +99,53 @@ export default class DeleteOperation {
   }
 
   transformContent(content) {
-    return content.substring(0, this.position) + content.substring(this.length + this.position);
+    let start, end;
+
+    start = 0;
+
+    end = this.position;
+
+    const leftContent = content.substring(start, end),
+          contentLength = this.content.length;
+
+    start = this.position + contentLength;
+
+    const rightContent = content.substring(start),
+          transformedContent = leftContent + rightContent;
+
+    return transformedContent;
   }
 
   transformSelection(selection) {
     let transformedSelection;
 
-    const length = this.length,  ///
+    const selectionStartPosition = selection.getStartPosition(),
+          selectionEndPosition = selection.getEndPosition(),
+          contentLength = this.content.length,
           startPosition = this.position, ///
-          endPosition = startPosition + length,
-          selectionStartPosition = selection.getStartPosition(),
-          selectionEndPosition = selection.getEndPosition();
-
-    let offset,
-        endOffset;
+          endPosition = startPosition + contentLength;
 
     if (false) {
       ///
     } else if (selectionStartPosition >= endPosition) {
-      offset = -length;
+      const offset = -contentLength;
 
       transformedSelection = selection.shifted(offset);
     } else if (selectionStartPosition >= startPosition) {
       if (selectionEndPosition > endPosition) {
-        offset = startPosition - selectionStartPosition;
-        endOffset = selectionStartPosition - endPosition;
+        const offset = startPosition - selectionStartPosition,
+              endOffset = selectionStartPosition - endPosition;
 
         transformedSelection = selection.shifted(offset).endPositionShifted(endOffset);
       } else {
-        const Selection = selection.constructor;  ///
-
-        transformedSelection = new Selection(startPosition, startPosition);
+        transformedSelection = selection.emptied();
       }
     } else if (selectionEndPosition > endPosition) {
-      endOffset = -length;
+      const endOffset = -contentLength;
 
       transformedSelection = selection.endPositionShifted(endOffset);
     } else if (selectionEndPosition > startPosition) {
-      endOffset = startPosition - selectionEndPosition;
+      const endOffset = startPosition - selectionEndPosition;
 
       transformedSelection = selection.endPositionShifted(endOffset);
     } else {
@@ -132,58 +156,96 @@ export default class DeleteOperation {
   }
 
   shifted(offset) {
-    const length = this.length,
+    const content = this.content,
           position = this.position + offset,
-          deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+          deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
 
     return deleteOperation;
   }
 
   shift(operation) {
-    const offset = -this.length,
+    const contentLength = this.content.length,
+          offset = -contentLength,
           shiftedOperation = operation.shifted(offset);
 
     return shiftedOperation
   }
 
   takenFrom(deleteOperation) {
-    let length = deleteOperation.length,
-        position = deleteOperation.position;
+    let content = deleteOperation.getContent(),
+        position = deleteOperation.getPosition();
+
+    let contentLength = content.length;
 
-    if (this.position > position && this.length + this.position >= length + position) {
-      length = this.position - position;
+    if ((this.position > position) && (this.position + this.content.length >= position + contentLength)) {
+      const contentLength = this.position - position,
+            start = 0,
+            end = start + contentLength;  ///
 
-      deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+      content = content.substring(start, end);
+
+      deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
     }
 
-    if (this.position <= position && this.length + this.position < length + position) {
-      length = length + position - this.position - this.length;
-      position = this.length + this.position;
+    if ((this.position <= position) && (this.position + this.content.length < position + contentLength)) {
+      contentLength = (position + contentLength) - (this.position + this.content.length);
+
+      const start = (this.position + this.content.length) - position,
+            end = start + contentLength;  ///
 
-      deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+      position = this.position + this.content.length;
+
+      content = content.substring(start, end);
+
+      deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
     }
 
     return deleteOperation;
   }
 
   split(deleteOperation) {
-    let length = deleteOperation.length,
-        position = deleteOperation.position;
+    let content = deleteOperation.getContent(),
+        position = deleteOperation.getPosition();
+
+    let start,
+        end;
+
+    start = 0;
+
+    end = this.position - position;
+
+    const leftContent = content.substring(start, end);
+
+    start = this.position - position + this.content.length;
+
+    const rightContent = content.substring(start);
+
+    content = leftContent + rightContent;
+
+    deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
+
+    return deleteOperation;
+  }
+
+  invert(InsertOperation, DeleteOperation) {
+    const insertOperation = InsertOperation.fromContentAndPosition(this.content, this.position);
 
-    length = length - this.length;
+    return insertOperation;
+  }
 
-    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+  clone() {
+    const deleteOperation = DeleteOperation.fromContentAndPosition(this.content, this.position);
 
     return deleteOperation;
   }
 
   toJSON() {
     const type = this.type,
-          length = this.length,
+          content = this.content,
           position = this.position,
           json = {
             type,
-            length,
+            content,
             position,
           };
 
@@ -191,15 +253,30 @@ export default class DeleteOperation {
   }
 
   static fromJSON(json) {
-    const { type, length, position } = json,
-          deleteOperation = new DeleteOperation(type, length, position);
+    const { type, content, position } = json,
+          deleteOperation = new DeleteOperation(type, content, position);
 
     return deleteOperation;
   }
 
-  static fromLengthAndPosition(length, position) {
-    const type = deleteType, ///
-          deleteOperation = new DeleteOperation(type, length, position);
+  static fromContentAndPosition(content, position) {
+    const type = DELETE_TYPE, ///
+          deleteOperation = new DeleteOperation(type, content, position);
+
+    return deleteOperation;
+  }
+
+  static fromContentAndSelection(content, selection) {
+    const startPosition = selection.getStartPosition(),
+          endPosition = selection.getEndPosition(),
+          begin = startPosition,  ///
+          end = endPosition;  ///
+
+    content = content.slice(begin, end);  ///
+
+    const type = DELETE_TYPE, ///
+          position = startPosition, ///
+          deleteOperation = new DeleteOperation(type, content, position);
 
     return deleteOperation;
   }

package/src/operation/empty.js

@@ -1,16 +1,14 @@
 "use strict";
 
-import { emptyType } from "../types";
+import { EMPTY_TYPE } from "../types";
 
 export default class EmptyOperation {
   constructor(type) {
     this.type = type;
-
-
   }
 
-  clone() {
-    return EmptyOperation.fromNothing();
+  getType() {
+    return this.type;
   }
 
   transformOperation(operation) {
@@ -22,7 +20,9 @@ export default class EmptyOperation {
   }
 
   transformContent(content) {
-    return content;
+    const transformedContent = content; ///
+
+    return transformedContent;
   }
 
   transformSelection(selection) {
@@ -31,8 +31,6 @@ export default class EmptyOperation {
     return transformedSelection;
   }
 
-
-
   shift(operation) {
   	const offset = 0,
           shiftedOperation = operation.shifted(offset);
@@ -40,17 +38,24 @@ export default class EmptyOperation {
   	return shiftedOperation;
   }
 
+  invert(InsertOperation, DeleteOperation) {
+    const type = EMPTY_TYPE,
+          emptyOperation = new EmptyOperation(type);
 
+    return emptyOperation;
+  }
 
+  clone() {
+    const emptyOperation = EmptyOperation.fromNothing();
 
+    return emptyOperation;
+  }
 
   toJSON() {
     const type = this.type,
-            json = {
-              type
-            };
-
-
+          json = {
+            type
+          };
 
     return json;
   }
@@ -63,7 +68,7 @@ export default class EmptyOperation {
   }
 
   static fromNothing() {
-    const type = emptyType, ///
+    const type = EMPTY_TYPE, ///
           emptyOperation = new EmptyOperation(type);
 
     return emptyOperation;

package/src/operation/insert.js

@@ -1,24 +1,34 @@
 "use strict";
 
-import stringCompare from "../stringCompare";
+import contentCompare from "../contentCompare";
 import DeleteOperation from "../operation/delete";
 
-import { insertType, deleteType, emptyType } from "../types";
+import { INSERT_TYPE, DELETE_TYPE, EMPTY_TYPE } from "../types";
 
 export default class InsertOperation {
-  constructor(type, string, position) {
+  constructor(type, content, position) {
 	  this.type = type;
-    this.string = string;
+    this.content = content;
     this.position = position;
   }
 
-  clone() {
-    return InsertOperation.fromStringAndPosition(this.string, this.position);
+  getType() {
+    return this.type;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  getPosition() {
+    return this.position;
   }
 
   transformOperation(operation) {
-    switch (operation.type) {
-      case insertType:
+    const type = operation.getType();
+
+    switch (type) {
+      case INSERT_TYPE:
         return ((tau, rho) => {
 
           if (tau.position < rho.position) {
@@ -26,11 +36,12 @@ export default class InsertOperation {
           }
 
           if (tau.position === rho.position) {
-            if (tau.string === rho.string) {
+            if (tau.content === rho.content) {
               return [tau.clone()];
             }
-            if (tau.string !== rho.string) {
-              if (stringCompare(rho.string, tau.string)) {
+
+            if (tau.content !== rho.content) {
+              if (contentCompare(rho.content, tau.content)) {
                 return [rho.shift(tau)];
               } else {
                 return [tau.clone()];
@@ -44,10 +55,10 @@ export default class InsertOperation {
 
         })(operation, this);
 
-      case deleteType:
+      case DELETE_TYPE:
         return ((tau, rho) => {
 
-          if (tau.position + tau.length <= rho.position) {
+          if (tau.position + tau.content.length <= rho.position) {
             return [tau.clone()];
           }
 
@@ -61,7 +72,7 @@ export default class InsertOperation {
 
         })(operation, this);
 
-      case emptyType:
+      case EMPTY_TYPE:
         return ((tau, rho) => {
 
           return [tau.clone()];
@@ -71,24 +82,41 @@ export default class InsertOperation {
   }
 
   transformContent(content) {
-    return content.substring(0, this.position) + this.string + content.substring(this.position);
+    let start,
+        end;
+
+    start = 0;
+
+    end = this.position;
+
+    const leftContent = content.substring(start, end);
+
+    start = this.position;
+
+    const rightContent = content.substring(start),
+          transformedContent = leftContent + this.content + rightContent;
+
+    return transformedContent;
   }
 
   transformSelection(selection) {
     let transformedSelection;
 
-    const startPosition = this.position, ///
-          length = this.string.length,
-          selectionStartPosition = selection.getStartPosition(),
-          selectionEndPosition = selection.getEndPosition(),
-          offset = length,  ///
-          endOffset = offset; ///
+    const selectionStartPosition = selection.getStartPosition(),
+          selectionEndPosition = selection.getEndPosition(), ///
+          contentLength = this.content.length,
+          startPosition = this.position; ///
 
     if (false) {
-
+      ///
     } else if (selectionStartPosition >= startPosition) {
+      const offset = contentLength; ///
+
       transformedSelection = selection.shifted(offset);
     } else if (selectionEndPosition > startPosition) {
+      const contentLength = this.content.length,
+            endOffset = contentLength;  ///
+
       transformedSelection = selection.endPositionShifted(endOffset);
     } else {
       transformedSelection = selection.clone();
@@ -98,15 +126,15 @@ export default class InsertOperation {
   }
 
   shifted(offset) {
-    const string = this.string,
+    const content = this.content,
           position = this.position + offset,
-          insertOperation = InsertOperation.fromStringAndPosition(string, position);
+          insertOperation = InsertOperation.fromContentAndPosition(content, position);
 
     return insertOperation;
   }
 
   shift(operation) {
-    const length = this.string.length,
+    const length = this.content.length,
 				  offset = length,  ///
           shiftedOperation = operation.shifted(offset);
 
@@ -114,33 +142,54 @@ export default class InsertOperation {
   }
 
   left(deleteOperation) {
-    const position = deleteOperation.position,
-          length = this.position - position;
+    let content = deleteOperation.getContent();
+
+    const position = deleteOperation.getPosition(),
+          contentLength = this.position - position,
+          start = 0,
+          end = contentLength;  ///
 
-    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+    content = content.substring(start, end);
+
+    deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
 
     return deleteOperation;
   }
 
   right(deleteOperation) {
-    let length = deleteOperation.length,
-        position = deleteOperation.position;
+    let content = deleteOperation.getContent(),
+        position = deleteOperation.getPosition();
+
+    const start = this.position - position;
 
-    length = length - this.position + position;
     position = this.position;
 
-    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+    content = content.substring(start);
+
+    deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
+
+    return deleteOperation;
+  }
+
+  invert(InsertOperation, DeleteOperation) {
+    const deleteOperation = DeleteOperation.fromContentAndPosition(this.content, this.position);
 
     return deleteOperation;
   }
 
+  clone() {
+    const insertOperation = InsertOperation.fromContentAndPosition(this.content, this.position);
+
+    return insertOperation;
+  }
+
   toJSON() {
     const type = this.type,
-          string = this.string,
+          content = this.content,
           position = this.position,
           json = {
             type,
-            string,
+            content,
             position
           };
 
@@ -148,15 +197,24 @@ export default class InsertOperation {
   }
 
   static fromJSON(json) {
-    const { type, string, position } = json,
-          insertOperation = new InsertOperation(type, string, position);
+    const { type, content, position } = json,
+          insertOperation = new InsertOperation(type, content, position);
+
+    return insertOperation;
+  }
+
+  static fromContentAndPosition(content, position) {
+    const type = INSERT_TYPE,  ///
+          insertOperation = new InsertOperation(type, content, position);
 
     return insertOperation;
   }
 
-  static fromStringAndPosition(string, position) {
-    const type = insertType,  ///
-          insertOperation = new InsertOperation(type, string, position);
+  static fromContentAndSelection(content, selection) {
+    const startPosition = selection.getStartPosition(),
+          type = INSERT_TYPE,  ///
+          position = startPosition, ///
+          insertOperation = new InsertOperation(type, content, position);
 
     return insertOperation;
   }

package/src/operations/fromJSON.js

@@ -4,7 +4,7 @@ import EmptyOperation from "../operation/empty";
 import DeleteOperation from "../operation/delete";
 import InsertOperation from "../operation/insert";
 
-import { emptyType, deleteType, insertType } from "../types";
+import { EMPTY_TYPE, DELETE_TYPE, INSERT_TYPE } from "../types";
 
 export default function operationsFromJSON(operationsJSON) {
   const operations = operationsJSON.map((operationJSON) => {
@@ -14,15 +14,15 @@ export default function operationsFromJSON(operationsJSON) {
           { type } = json;
 
     switch (type) {
-      case emptyType:
+      case EMPTY_TYPE:
         operation = EmptyOperation.fromJSON(json);
         break;
 
-      case deleteType:
+      case DELETE_TYPE:
         operation = DeleteOperation.fromJSON(json);
         break;
 
-      case insertType:
+      case INSERT_TYPE:
         operation = InsertOperation.fromJSON(json);
         break;
     }