easy-richtextarea 3.0.154 → 4.0.3

package/src/operation/delete.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import EmptyOperation from "../operation/empty";
+
+import { insertType, deleteType, emptyType } from "../types";
+
+export default class DeleteOperation {
+  constructor(type, length, position) {
+	  this.type = type;
+    this.length = length;
+    this.position = position;
+  }
+
+  clone() {
+    return DeleteOperation.fromLengthAndPosition(this.length, this.position);
+  }
+
+  transformOperation(operation) {
+    switch (operation.type) {
+      case insertType:
+        return ((tau, rho) => {
+
+          if (tau.position <= rho.position) {
+            return [tau.clone()];
+          }
+
+          if (tau.position > rho.position) {
+            if (tau.position < rho.length + rho.position) {
+              return [tau.left(rho).shift(tau)];
+            }
+            if (tau.position >= rho.length + rho.position) {
+              return [rho.shift(tau)];
+            }
+          }
+
+        })(operation, this);
+
+      case deleteType:
+        return ((tau, rho) => {
+
+          if (tau.position < rho.position) {
+            if (tau.length + tau.position <= rho.position) {
+              return [tau.clone()];
+            }
+            if (tau.length + tau.position <= rho.length + rho.position) {
+              return [rho.takenFrom(tau)];
+            }
+            if (tau.length + tau.position > rho.length + rho.position) {
+              return [rho.split(tau)];
+            }
+          }
+
+          if (tau.position === rho.position) {
+            if (tau.length + tau.position <= rho.length + rho.position) {
+              return [EmptyOperation.fromNothing()];
+            }
+            if (tau.length + tau.position > rho.length + rho.position) {
+              return [rho.shift(rho.takenFrom(tau))];
+            }
+          }
+
+          if (tau.position >= rho.length + rho.position) {
+            return [rho.shift(tau)];
+          }
+
+          if (tau.position > rho.position) {
+            if (tau.length + tau.position <= rho.length + rho.position) {
+              return [EmptyOperation.fromNothing()];
+            }
+            if (tau.length + tau.position > rho.length + rho.position) {
+              return [rho.shift(rho.takenFrom(tau))];
+            }
+          }
+
+        })(operation, this);
+
+      case emptyType:
+        return ((tau, rho) => {
+
+          return [tau.clone()];
+
+        })(operation, this);
+    }
+  }
+
+  transformContent(content) {
+    return content.substring(0, this.position) + content.substring(this.length + this.position);
+  }
+
+  transformSelection(selection) {
+    let transformedSelection;
+
+    const length = this.length,  ///
+          startPosition = this.position, ///
+          endPosition = startPosition + length,
+          selectionStartPosition = selection.getStartPosition(),
+          selectionEndPosition = selection.getEndPosition();
+
+    let offset,
+        endOffset;
+
+    if (false) {
+      ///
+    } else if (selectionStartPosition >= endPosition) {
+      offset = -length;
+
+      transformedSelection = selection.shifted(offset);
+    } else if (selectionStartPosition >= startPosition) {
+      if (selectionEndPosition > endPosition) {
+        offset = startPosition - selectionStartPosition;
+        endOffset = selectionStartPosition - endPosition;
+
+        transformedSelection = selection.shifted(offset).endPositionShifted(endOffset);
+      } else {
+        const Selection = selection.constructor;  ///
+
+        transformedSelection = new Selection(startPosition, startPosition);
+      }
+    } else if (selectionEndPosition > endPosition) {
+      endOffset = -length;
+
+      transformedSelection = selection.endPositionShifted(endOffset);
+    } else if (selectionEndPosition > startPosition) {
+      endOffset = startPosition - selectionEndPosition;
+
+      transformedSelection = selection.endPositionShifted(endOffset);
+    } else {
+      transformedSelection = selection.clone();
+    }
+
+    return transformedSelection;
+  }
+
+  shifted(offset) {
+    const length = this.length,
+          position = this.position + offset,
+          deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+
+    return deleteOperation;
+  }
+
+  shift(operation) {
+    const offset = -this.length,
+          shiftedOperation = operation.shifted(offset);
+
+    return shiftedOperation
+  }
+
+  takenFrom(deleteOperation) {
+    let length = deleteOperation.length,
+        position = deleteOperation.position;
+
+    if (this.position > position && this.length + this.position >= length + position) {
+      length = this.position - position;
+
+      deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+    }
+
+    if (this.position <= position && this.length + this.position < length + position) {
+      length = length + position - this.position - this.length;
+      position = this.length + this.position;
+
+      deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+    }
+
+    return deleteOperation;
+  }
+
+  split(deleteOperation) {
+    let length = deleteOperation.length,
+        position = deleteOperation.position;
+
+    length = length - this.length;
+
+    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+
+    return deleteOperation;
+  }
+
+  toJSON() {
+    const type = this.type,
+          length = this.length,
+          position = this.position,
+          json = {
+            type,
+            length,
+            position,
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const { type, length, position } = json,
+          deleteOperation = new DeleteOperation(type, length, position);
+
+    return deleteOperation;
+  }
+
+  static fromLengthAndPosition(length, position) {
+    const type = deleteType, ///
+          deleteOperation = new DeleteOperation(type, length, position);
+
+    return deleteOperation;
+  }
+}

package/src/operation/empty.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { emptyType } from "../types";
+
+export default class EmptyOperation {
+  constructor(type) {
+    this.type = type;
+
+
+  }
+
+  clone() {
+    return EmptyOperation.fromNothing();
+  }
+
+  transformOperation(operation) {
+    return ((tau, rho) => {
+
+      return [tau.clone()];
+
+    })(operation, this);
+  }
+
+  transformContent(content) {
+    return content;
+  }
+
+  transformSelection(selection) {
+    const transformedSelection = selection.clone();
+
+    return transformedSelection;
+  }
+
+
+
+  shift(operation) {
+  	const offset = 0,
+          shiftedOperation = operation.shifted(offset);
+
+  	return shiftedOperation;
+  }
+
+
+
+
+
+  toJSON() {
+    const type = this.type,
+            json = {
+              type
+            };
+
+
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const { type } = json,
+          emptyOperation = new EmptyOperation(type);
+
+    return emptyOperation;
+  }
+
+  static fromNothing() {
+    const type = emptyType, ///
+          emptyOperation = new EmptyOperation(type);
+
+    return emptyOperation;
+  }
+}

package/src/operation/insert.js

@@ -0,0 +1,163 @@
+"use strict";
+
+import stringCompare from "../stringCompare";
+import DeleteOperation from "../operation/delete";
+
+import { insertType, deleteType, emptyType } from "../types";
+
+export default class InsertOperation {
+  constructor(type, string, position) {
+	  this.type = type;
+    this.string = string;
+    this.position = position;
+  }
+
+  clone() {
+    return InsertOperation.fromStringAndPosition(this.string, this.position);
+  }
+
+  transformOperation(operation) {
+    switch (operation.type) {
+      case insertType:
+        return ((tau, rho) => {
+
+          if (tau.position < rho.position) {
+            return [tau.clone()];
+          }
+
+          if (tau.position === rho.position) {
+            if (tau.string === rho.string) {
+              return [tau.clone()];
+            }
+            if (tau.string !== rho.string) {
+              if (stringCompare(rho.string, tau.string)) {
+                return [rho.shift(tau)];
+              } else {
+                return [tau.clone()];
+              }
+            }
+          }
+
+          if (tau.position > rho.position) {
+            return [rho.shift(tau)];
+          }
+
+        })(operation, this);
+
+      case deleteType:
+        return ((tau, rho) => {
+
+          if (tau.position + tau.length <= rho.position) {
+            return [tau.clone()];
+          }
+
+          if (tau.position < rho.position) {
+            return [rho.left(tau), rho.left(tau).shift(rho.shift(rho.right(tau)))];
+          }
+
+          if (tau.position >= rho.position) {
+            return [rho.shift(tau)];
+          }
+
+        })(operation, this);
+
+      case emptyType:
+        return ((tau, rho) => {
+
+          return [tau.clone()];
+
+        })(operation, this);
+    }
+  }
+
+  transformContent(content) {
+    return content.substring(0, this.position) + this.string + content.substring(this.position);
+  }
+
+  transformSelection(selection) {
+    let transformedSelection;
+
+    const startPosition = this.position, ///
+          length = this.string.length,
+          selectionStartPosition = selection.getStartPosition(),
+          selectionEndPosition = selection.getEndPosition(),
+          offset = length,  ///
+          endOffset = offset; ///
+
+    if (false) {
+
+    } else if (selectionStartPosition >= startPosition) {
+      transformedSelection = selection.shifted(offset);
+    } else if (selectionEndPosition > startPosition) {
+      transformedSelection = selection.endPositionShifted(endOffset);
+    } else {
+      transformedSelection = selection.clone();
+    }
+
+    return transformedSelection;
+  }
+
+  shifted(offset) {
+    const string = this.string,
+          position = this.position + offset,
+          insertOperation = InsertOperation.fromStringAndPosition(string, position);
+
+    return insertOperation;
+  }
+
+  shift(operation) {
+    const length = this.string.length,
+				  offset = length,  ///
+          shiftedOperation = operation.shifted(offset);
+
+    return shiftedOperation;
+  }
+
+  left(deleteOperation) {
+    const position = deleteOperation.position,
+          length = this.position - position;
+
+    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+
+    return deleteOperation;
+  }
+
+  right(deleteOperation) {
+    let length = deleteOperation.length,
+        position = deleteOperation.position;
+
+    length = length - this.position + position;
+    position = this.position;
+
+    deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+
+    return deleteOperation;
+  }
+
+  toJSON() {
+    const type = this.type,
+          string = this.string,
+          position = this.position,
+          json = {
+            type,
+            string,
+            position
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const { type, string, position } = json,
+          insertOperation = new InsertOperation(type, string, position);
+
+    return insertOperation;
+  }
+
+  static fromStringAndPosition(string, position) {
+    const type = insertType,  ///
+          insertOperation = new InsertOperation(type, string, position);
+
+    return insertOperation;
+  }
+}

package/src/operations/fromJSON.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import EmptyOperation from "../operation/empty";
+import DeleteOperation from "../operation/delete";
+import InsertOperation from "../operation/insert";
+
+import { emptyType, deleteType, insertType } from "../types";
+
+export default function operationsFromJSON(operationsJSON) {
+  const operations = operationsJSON.map((operationJSON) => {
+    let operation;
+
+    const json = operationJSON, ///
+          { type } = json;
+
+    switch (type) {
+      case emptyType:
+        operation = EmptyOperation.fromJSON(json);
+        break;
+
+      case deleteType:
+        operation = DeleteOperation.fromJSON(json);
+        break;
+
+      case insertType:
+        operation = InsertOperation.fromJSON(json);
+        break;
+    }
+
+    return operation;
+  });
+
+  return operations;
+}

package/src/operations/generate.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import InsertOperation from "../operation/insert";
+import DeleteOperation from "../operation/delete";
+
+export default function generateOperations(contentA, contentB) {
+  const operations = [],
+        contentALength = contentA.length,
+        contentBLength = contentB.length;
+  
+  let left, right;
+
+  for (left = 0; (left < contentALength) && (left < contentBLength); left++) {
+    if (contentA[left] !== contentB[left]) {
+      break;
+    }
+  }
+
+  for (right = 0; (right < contentALength - left) && (right < contentBLength - left); right++) {
+    if (contentA[contentALength - right - 1] !== contentB[contentBLength - right - 1]) {
+      break;
+    }
+  }
+
+  if (left + right !== contentALength) {
+    const length = contentALength - left - right,  ///
+          position = left, ///
+          deleteOperation = DeleteOperation.fromLengthAndPosition(length, position);
+
+    operations.push(deleteOperation);
+  }
+
+  if (left + right !== contentBLength) {
+    const string = contentB.substring(left, contentBLength - right),  ///
+          position = left, ///
+          insertOperation = InsertOperation.fromStringAndPosition(string, position);
+
+    operations.push(insertOperation);
+  }
+
+  return operations;
+}

package/src/operations/toJSON.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export default function operationsToJSON(operations) {
+  return operations.map((operation) => operation.toJSON());
+}

package/src/operations/transform.js

@@ -0,0 +1,57 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { first, tail } = arrayUtilities;
+
+export default function transformOperations(tau, rho) {
+  if ((tau.length === 0) || (rho.length === 0)) {
+    return tau;
+  }
+
+  const tau1 = [first(tau)],
+        tau2 = tail(tau),
+        rho1 = [first(rho)],
+        rho2 = tail(rho);
+
+  if (tau.length > 1 && rho.length > 1) {
+    return (
+      transformOperations(
+        transformOperations(tau1, rho1),
+        rho2
+      ).concat(
+        transformOperations(
+          transformOperations(
+            tau2,
+            transformOperations(rho1, tau1)
+          ),
+          transformOperations(
+            rho2,
+            transformOperations(tau1, rho1)
+          )
+        )
+      )
+    );
+  } else if ((tau.length > 1) && (rho.length === 1)) {
+    return (
+      transformOperations(tau1, rho).concat(
+        transformOperations(
+          tau2,
+          transformOperations(rho, tau1)
+        )
+      )
+    );
+  } else if ((tau.length === 1) && (rho.length > 1)) {
+    return (
+      transformOperations(
+        transformOperations(tau, rho1),
+        rho2
+      )
+    );
+  } else {
+    tau = first(tau); ///
+    rho = first(rho); ///
+
+    return rho.transformOperation(tau);
+  }
+}

package/src/stringCompare.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { EMPTY_STRING } from "./constants";
+
+export default function stringCompare(stringA, stringB) {
+  if ((stringA === EMPTY_STRING) && (stringB === EMPTY_STRING)) {
+    return false;
+  }
+
+  if (stringA === EMPTY_STRING) {
+    return true;
+  }
+
+  if (stringB === EMPTY_STRING) {
+    return false;
+  }
+
+  const codePointA = stringA.codePointAt(0),
+        codePointB = stringB.codePointAt(0);
+
+  if (codePointA < codePointB) {
+    return true;
+  }
+
+  if (codePointA > codePointB) {
+    return false;
+  }
+
+  const subStringA = stringA.substring(1),
+        subStringB = stringB.substring(1);
+
+  return stringCompare(subStringA, subStringB);
+}

package/src/types.js

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

package/test/content/transform.js

@@ -0,0 +1,59 @@
+"use strict";
+
+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(),
+            operations = [],
+            transformedContent = transformContent(content, operations),
+            expectedContent = content;  ///
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  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),
+            operations = [
+              deleteOperation
+            ],
+            transformedContent = transformContent(content, operations),
+            expectedContent = content.substring(2);
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  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),
+            operations = [
+              insertOperation
+            ],
+            transformedContent = transformContent(content, operations),
+            expectedContent = `xyz${content}`;
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  describe("the array of operations is generated", () => {
+    it("returns the result of applying those operations", () => {
+      const contentA = helpers.content(),
+            contentB = helpers.content(),
+            operations = generateOperations(contentA, contentB),
+            transformedContentA = transformContent(contentA, operations),
+            expectedContent = contentB;  ///
+
+      assert.equal(transformedContentA, expectedContent);
+    });
+  });
+});