easy-richtextarea 4.0.3 → 4.0.5

package/src/selection.js

@@ -14,12 +14,10 @@ export default class Selection {
     return this.endPosition;
   }
 
-  setStartPosition(startPosition) {
-    this.startPosition = startPosition;
-  }
+  isEmpty() {
+    const empty = (this.startPosition === this.endPosition);
 
-  setEndPosition(endPosition) {
-    this.endPosition = endPosition;
+    return empty;
   }
 
   isEqualTo(selection) {
@@ -37,11 +35,50 @@ export default class Selection {
     return equalTo;
   }
 
-  isDifferentTo(selection) {
-    const equalTo = this.isEqualTo(selection),
-          differentTo = !equalTo;
+  setStartPosition(startPosition) {
+    this.startPosition = startPosition;
+  }
+
+  setEndPosition(endPosition) {
+    this.endPosition = endPosition;
+  }
+
+  startPositionShifted(startOffset) {
+    const startPosition = this.startPosition + startOffset,
+          endPosition = this.endPosition,
+          selection = new Selection(startPosition, endPosition);
+
+    return selection;
+  }
+
+  endPositionShifted(endOffset) {
+    const startPosition = this.startPosition,
+          endPosition = this.endPosition + endOffset,
+          selection = new Selection(startPosition, endPosition);
 
-    return differentTo;
+    return selection;
+  }
+
+  shifted(offset) {
+    const startPosition = this.startPosition + offset,
+          endPosition = this.endPosition + offset,
+          selection = new Selection(startPosition, endPosition);
+
+    return selection;
+  }
+
+  emptied() {
+    const startPosition = this.startPosition,
+          endPosition = startPosition,  ///
+          selection = new Selection(startPosition, endPosition);
+
+    return selection;
+  }
+
+  clone() {
+    const selection = new Selection(this.startPosition, this.endPosition);
+
+    return selection;
   }
 
   static fromNothing() {
@@ -62,6 +99,13 @@ export default class Selection {
 
   }
 
+  static fromStartPosition(startPosition) {
+    const endPosition = startPosition,  ///
+          selection = new Selection(startPosition, endPosition);
+
+    return selection;
+  }
+
   static fromStartPositionAndEndPosition(startPosition, endPosition) {
     const selection = new Selection(startPosition, endPosition);
 

package/src/transform/content.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default function transformContent(content, operations) {
+  operations.forEach((operation) => {
+    const transformedContent = operation.transformContent(content);
+
+    content = transformedContent; ///
+  })
+
+  return content;
+}

package/src/{operations/transform.js → transform/operations.js}

@@ -2,16 +2,16 @@
 
 import { arrayUtilities } from "necessary";
 
-const { first, tail } = arrayUtilities;
+const { first, head, tail } = arrayUtilities;
 
 export default function transformOperations(tau, rho) {
   if ((tau.length === 0) || (rho.length === 0)) {
     return tau;
   }
 
-  const tau1 = [first(tau)],
+  const tau1 = head(tau),
         tau2 = tail(tau),
-        rho1 = [first(rho)],
+        rho1 = head(rho),
         rho2 = tail(rho);
 
   if (tau.length > 1 && rho.length > 1) {

package/src/transform/selection.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default function transformSelection(selection, operations) {
+  operations.forEach((operation) => {
+    const transformedSelection = operation.transformSelection(selection);
+
+    selection = transformedSelection; ///
+  })
+
+  return selection;
+}

package/src/types.js

@@ -1,11 +1,11 @@
 "use strict";
 
-export const emptyType = "empty";
-export const deleteType = "delete";
-export const insertType = "insert";
+export const EMPTY_TYPE = "empty";
+export const DELETE_TYPE = "delete";
+export const INSERT_TYPE = "insert";
 
 export default {
-  emptyType,
-  deleteType,
-  insertType
+  EMPTY_TYPE,
+  DELETE_TYPE,
+  INSERT_TYPE
 };

package/src/undoBuffer.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import EmptyOperation from "./operation/empty";
+import InsertOperation from "./operation/insert";
+import DeleteOperation from "./operation/delete";
+import transformOperations from "./transform/operations";
+
+const { push } = arrayUtilities;
+
+export default class UndoBuffer {
+  constructor(position, operations) {
+    this.position = position;
+    this.operations = operations;
+  }
+
+  getPosition() {
+    return this.position;
+  }
+
+  getOperations() {
+    return this.operations;
+  }
+
+  undo() {
+    let operation = null;
+
+    if (this.position > 0) {
+      this.position--;
+
+      operation = this.operations[this.position];
+
+      const invertedOperation = operation.invert(InsertOperation, DeleteOperation);
+
+      operation = invertedOperation;  ///
+    }
+
+    return operation;
+  }
+
+  redo() {
+    let operation = null;
+
+    const operationsLength = this.operations.length;
+
+    if (this.position < operationsLength) {
+      operation = this.operations[this.position];
+
+      this.position++;
+    }
+
+    return operation;
+  }
+
+  transform(operations) {
+    this.operations = transformOperations(this.operations, operations);
+
+    this.filterEmptyOperations();
+  }
+
+  addOperations(operations) {
+    const start = this.position;  ///
+
+    this.operations.splice(start);
+
+    push(this.operations, operations);
+
+    const operationsLength = this.operations.length;
+
+    this.position = operationsLength; ///
+  }
+
+  filterEmptyOperations() {
+    let length = this.operations.length,
+          position = 0;
+
+    while (position < length) {
+      const operation = this.operations[position];
+
+      if (operation instanceof EmptyOperation) {
+        const start = position, ///
+              deleteCount = 1;
+
+        this.operations.splice(start, deleteCount);
+
+        if (this.position > position) {
+          this.position--;
+        }
+      } else {
+        position++;
+      }
+
+      length = this.operations.length;
+    }
+  }
+
+  static fromNothing() {
+    const position = 0,
+          operations = [],
+          undoBuffer = new UndoBuffer(position, operations);
+
+    return undoBuffer;
+  }
+}

package/test/content/transform.js

@@ -3,12 +3,10 @@
 const { assert } = require("chai"),
       { DeleteOperation, InsertOperation, transformContent, generateOperations } = require("../../lib/main");  ///
 
-const helpers = require("../helpers");
-
 describe("transformContent", () => {
   describe("the array of operations is of zero length", () => {
     it("leaves the content unchanged", () => {
-      const content = helpers.content(),
+      const content = "jik8h",
             operations = [],
             transformedContent = transformContent(content, operations),
             expectedContent = content;  ///
@@ -19,13 +17,13 @@ describe("transformContent", () => {
 
   describe("the array of operations is contains a single delete operation", () => {
     it("deletes the requisite characters", () => {
-      const content = helpers.content(),
-            deleteOperation = DeleteOperation.fromLengthAndPosition(2, 0),
+      const content = "jhUngfrcD",
+            deleteOperation = DeleteOperation.fromContentAndPosition("ngfr", 3),
             operations = [
               deleteOperation
             ],
             transformedContent = transformContent(content, operations),
-            expectedContent = content.substring(2);
+            expectedContent = "jhUcD";
 
       assert.equal(transformedContent, expectedContent);
     });
@@ -33,13 +31,13 @@ describe("transformContent", () => {
 
   describe("the array of operations is contains a single insert operation", () => {
     it("inserts the requisite characters", () => {
-      const content = helpers.content(),
-            insertOperation = InsertOperation.fromStringAndPosition("xyz", 0),
+      const content = "jubfEDf",
+            insertOperation = InsertOperation.fromContentAndPosition("avTgd", 2),
             operations = [
               insertOperation
             ],
             transformedContent = transformContent(content, operations),
-            expectedContent = `xyz${content}`;
+            expectedContent = "juavTgdbfEDf";
 
       assert.equal(transformedContent, expectedContent);
     });
@@ -47,8 +45,8 @@ describe("transformContent", () => {
 
   describe("the array of operations is generated", () => {
     it("returns the result of applying those operations", () => {
-      const contentA = helpers.content(),
-            contentB = helpers.content(),
+      const contentA = "8hUjy",
+            contentB = "ABV8hUjykmj",
             operations = generateOperations(contentA, contentB),
             transformedContentA = transformContent(contentA, operations),
             expectedContent = contentB;  ///

package/test/helpers.js

@@ -11,8 +11,7 @@ const DEFAULT_CONTENT_LENGTH = 4,
 const random = randomSeed.create(".");
 
 function content(length = DEFAULT_CONTENT_LENGTH) {
-  const string = generateString(length),
-        content = string; ///
+  const content = generateContent(length);
 
   return content;
 }
@@ -36,50 +35,57 @@ module.exports = {
   operations
 };
 
-function generateString(length) {
-  let string = "";
+function generateContent(length) {
+  let content = "";
 
   const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
   for (let index = 0; index < length; index++) {
-    string += characters.charAt(random(characters.length));
+    content += characters.charAt(random(characters.length));
   }
 
-  return string;
+  return content;
 }
 
-function generateOperation(string) {
-  if (string === "") {
+function generateOperation(content) {
+  if (content === "") {
     return [
       generateEmptyOperation,
       generateInsertOperation
-    ][random(2)](string);
+    ][random(2)](content);
   } else {
     return [
       generateEmptyOperation,
       generateInsertOperation,
       generateDeleteOperation
-    ][random(3)](string);
+    ][random(3)](content);
   }
 }
 
-function generateEmptyOperation(string) {
+function generateEmptyOperation(content) {
   return EmptyOperation.fromNothing();
 }
 
-function generateInsertOperation(string) {
-  const stringLength = string.length,
-        position = random(stringLength + 1);
+function generateInsertOperation(content) {
+  const contentLength = content.length,
+        position = random(contentLength + 1);
 
-  string = generateString(MAXIMUM_INSERT_OPERATION_LENGTH); ///
+  content = generateContent(MAXIMUM_INSERT_OPERATION_LENGTH); ///
 
-  return InsertOperation.fromStringAndPosition(string, position);
+  return InsertOperation.fromContentAndPosition(content, position);
 }
 
-function generateDeleteOperation(string) {
-  const stringLength = string.length,
-        position = random(stringLength),
-        length = random(stringLength - position) + 1;
+function generateDeleteOperation(content) {
+  let contentLength = content.length;
+
+  const position = random(contentLength);
+
+  contentLength = random(contentLength - position) + 1;
+
+  const start = position,
+        end = start + contentLength;
+
+  content = content.substring(start, end);
 
-  return DeleteOperation.fromLengthAndPosition(length, position);
+  return DeleteOperation.fromContentAndPosition(content, position);
 }