easy-richtextarea 4.0.34 → 4.0.36

package/src/operation/insert.js

@@ -1,221 +0,0 @@
-"use strict";
-
-import contentCompare from "../contentCompare";
-import DeleteOperation from "../operation/delete";
-
-import { INSERT_TYPE, DELETE_TYPE, EMPTY_TYPE } from "../types";
-
-export default class InsertOperation {
-  constructor(type, content, position) {
-	  this.type = type;
-    this.content = content;
-    this.position = position;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getContent() {
-    return this.content;
-  }
-
-  getPosition() {
-    return this.position;
-  }
-
-  transformContent(content) {
-    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;
-  }
-
-  transformOperation(operation) {
-    const type = operation.getType();
-
-    switch (type) {
-      case INSERT_TYPE:
-        return ((tau, rho) => {
-
-          if (tau.position < rho.position) {
-            return [tau.clone()];
-          }
-
-          if (tau.position === rho.position) {
-            if (tau.content === rho.content) {
-              return [tau.clone()];
-            }
-
-            if (tau.content !== rho.content) {
-              if (contentCompare(rho.content, tau.content)) {
-                return [rho.shift(tau)];
-              } else {
-                return [tau.clone()];
-              }
-            }
-          }
-
-          if (tau.position > rho.position) {
-            return [rho.shift(tau)];
-          }
-
-        })(operation, this);
-
-      case DELETE_TYPE:
-        return ((tau, rho) => {
-
-          if (tau.position + tau.content.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 EMPTY_TYPE:
-        return ((tau, rho) => {
-
-          return [tau.clone()];
-
-        })(operation, this);
-    }
-  }
-
-  transformSelection(selection) {
-    let transformedSelection;
-
-    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();
-    }
-
-    return transformedSelection;
-  }
-
-  shifted(offset) {
-    const content = this.content,
-          position = this.position + offset,
-          insertOperation = InsertOperation.fromContentAndPosition(content, position);
-
-    return insertOperation;
-  }
-
-  shift(operation) {
-    const length = this.content.length,
-				  offset = length,  ///
-          shiftedOperation = operation.shifted(offset);
-
-    return shiftedOperation;
-  }
-
-  left(deleteOperation) {
-    let content = deleteOperation.getContent();
-
-    const position = deleteOperation.getPosition(),
-          contentLength = this.position - position,
-          start = 0,
-          end = contentLength;  ///
-
-    content = content.substring(start, end);
-
-    deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
-
-    return deleteOperation;
-  }
-
-  right(deleteOperation) {
-    let content = deleteOperation.getContent(),
-        position = deleteOperation.getPosition();
-
-    const start = this.position - position;
-
-    position = this.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,
-          content = this.content,
-          position = this.position,
-          json = {
-            type,
-            content,
-            position
-          };
-
-    return json;
-  }
-
-  static fromJSON(json) {
-    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 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

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

package/src/operations/generate.js

@@ -1,46 +0,0 @@
-"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 start = left, ///
-          end = contentALength - right,
-          content = contentA.substring(start, end),
-          position = left, ///
-          deleteOperation = DeleteOperation.fromContentAndPosition(content, position);
-
-    operations.push(deleteOperation);
-  }
-
-  if (left + right !== contentBLength) {
-    const start = left, ///
-          end = contentBLength - right,
-          content = contentB.substring(start, end),
-          position = left, ///
-          insertOperation = InsertOperation.fromContentAndPosition(content, position);
-
-    operations.push(insertOperation);
-  }
-
-  return operations;
-}

package/src/operations/toJSON.js

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

package/src/transform/content.js

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

package/src/transform/operations.js

@@ -1,57 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { first, head, tail } = arrayUtilities;
-
-export default function transformOperations(tau, rho) {
-  if ((tau.length === 0) || (rho.length === 0)) {
-    return tau;
-  }
-
-  const tau1 = head(tau),
-        tau2 = tail(tau),
-        rho1 = head(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/transform/selection.js

@@ -1,11 +0,0 @@
-"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 +0,0 @@
-"use strict";
-
-export const EMPTY_TYPE = "empty";
-export const DELETE_TYPE = "delete";
-export const INSERT_TYPE = "insert";
-
-export default {
-  EMPTY_TYPE,
-  DELETE_TYPE,
-  INSERT_TYPE
-};

package/src/undoBuffer.js

@@ -1,119 +0,0 @@
-"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 { clear, filter, unshift } = arrayUtilities;
-
-export default class UndoBuffer {
-  constructor(undoOperations, redoOperations) {
-    this.undoOperations = undoOperations;
-    this.redoOperations = redoOperations;
-  }
-
-  getUndoOperations() {
-    return this.undoOperations;
-  }
-  
-  getRedoOperations() {
-    return this.redoOperations;
-  }
-
-  undo() {
-    let undoOperation = null;
-
-    const undoOperationsLength = this.undoOperations.length;
-
-    if (undoOperationsLength > 0) {
-      undoOperation = this.undoOperations.shift();
-
-      const invertedUndoOperation = undoOperation.invert(InsertOperation, DeleteOperation),
-            redoOperation = invertedUndoOperation;  ///
-
-      this.redoOperations.unshift(redoOperation);
-    }
-
-    return undoOperation;
-  }
-
-  redo() {
-    let redoOperation = null;
-
-    const redoOperationsLength = this.redoOperations.length;
-
-    if (redoOperationsLength > 0) {
-      redoOperation = this.redoOperations.shift();
-
-      const invertedRedoOperation = redoOperation.invert(InsertOperation, DeleteOperation),
-            undoOperation = invertedRedoOperation;  ///
-
-      this.undoOperations.unshift(undoOperation);
-    }
-
-    return redoOperation;
-  }
-
-  transform(operations) {
-    this.undoOperations = transformOperations(this.undoOperations, operations);
-
-    this.redoOperations = transformOperations(this.redoOperations, operations);
-    
-    filterEmptyOperations(this.undoOperations);
-
-    filterEmptyOperations(this.redoOperations);
-  }
-
-  addOperations(operations) {
-    const invertedOperations = invertOperations(operations),
-          reversedInvertedOperations = reverseOperations(invertedOperations),
-          undoOperations = reversedInvertedOperations;  ///
-
-    unshift(this.undoOperations, undoOperations);
-
-    clear(this.redoOperations);
-  }
-
-  static fromNothing() {
-    const undoOperations = [],
-          redoOperations = [],
-          undoBuffer = new UndoBuffer(undoOperations, redoOperations);
-
-    return undoBuffer;
-  }
-}
-
-function invertOperations(operations) {
-  const invertedOperations = operations.map((operation) => {
-    const invertedOperation = operation.invert(InsertOperation, DeleteOperation);
-
-    return invertedOperation;
-  });
-
-  return invertedOperations;
-}
-
-function reverseOperations(operations) {
-  const reversedOperations = operations.reduce((reversedOperations, operation) => {
-    const reversedOperation = operation;  ///
-
-    reversedOperations.unshift(reversedOperation);
-
-    return reversedOperations;
-  }, []);
-
-  return reversedOperations;
-}
-
-function filterEmptyOperations(operations) {
-  filter(operations, (operation) => {
-    const operationEmptyOperation = (operation instanceof EmptyOperation);
-
-    if (!operationEmptyOperation) {
-      return true;
-    }
-  });
-}

package/test/content/transform.js

@@ -1,57 +0,0 @@
-"use strict";
-
-const { assert } = require("chai"),
-      { DeleteOperation, InsertOperation, transformContent, generateOperations } = require("../../lib/browser");  ///
-
-describe("transformContent", () => {
-  describe("the array of operations is of zero length", () => {
-    it("leaves the content unchanged", () => {
-      const content = "jik8h",
-            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 = "jhUngfrcD",
-            deleteOperation = DeleteOperation.fromContentAndPosition("ngfr", 3),
-            operations = [
-              deleteOperation
-            ],
-            transformedContent = transformContent(content, operations),
-            expectedContent = "jhUcD";
-
-      assert.equal(transformedContent, expectedContent);
-    });
-  });
-
-  describe("the array of operations is contains a single insert operation", () => {
-    it("inserts the requisite characters", () => {
-      const content = "jubfEDf",
-            insertOperation = InsertOperation.fromContentAndPosition("avTgd", 2),
-            operations = [
-              insertOperation
-            ],
-            transformedContent = transformContent(content, operations),
-            expectedContent = "juavTgdbfEDf";
-
-      assert.equal(transformedContent, expectedContent);
-    });
-  });
-
-  describe("the array of operations is generated", () => {
-    it("returns the result of applying those operations", () => {
-      const contentA = "8hUjy",
-            contentB = "ABV8hUjykmj",
-            operations = generateOperations(contentA, contentB),
-            transformedContentA = transformContent(contentA, operations),
-            expectedContent = contentB;  ///
-
-      assert.equal(transformedContentA, expectedContent);
-    });
-  });
-});

package/test/helpers.js

@@ -1,91 +0,0 @@
-"use strict";
-
-const randomSeed = require("random-seed");
-
-const { EmptyOperation, InsertOperation, DeleteOperation } = require("../lib/browser");  ///
-
-const DEFAULT_CONTENT_LENGTH = 4,
-      DEFAULT_NUMBER_OF_OPERATIONS = 2,
-      MAXIMUM_INSERT_OPERATION_LENGTH = 4;
-
-const random = randomSeed.create(".");
-
-function content(length = DEFAULT_CONTENT_LENGTH) {
-  const content = generateContent(length);
-
-  return content;
-}
-
-function operations(content, numberOfOperations = DEFAULT_NUMBER_OF_OPERATIONS) {
-  const operations = [];
-
-  for (let i = 0; i < numberOfOperations; i++) {
-    const operation = generateOperation(content);
-
-    operations.push(operation);
-
-    content = operation.transformContent(content);
-  }
-
-  return operations;
-}
-
-module.exports = {
-  content,
-  operations
-};
-
-function generateContent(length) {
-  let content = "";
-
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-
-  for (let index = 0; index < length; index++) {
-    content += characters.charAt(random(characters.length));
-  }
-
-  return content;
-}
-
-function generateOperation(content) {
-  if (content === "") {
-    return [
-      generateEmptyOperation,
-      generateInsertOperation
-    ][random(2)](content);
-  } else {
-    return [
-      generateEmptyOperation,
-      generateInsertOperation,
-      generateDeleteOperation
-    ][random(3)](content);
-  }
-}
-
-function generateEmptyOperation(content) {
-  return EmptyOperation.fromNothing();
-}
-
-function generateInsertOperation(content) {
-  const contentLength = content.length,
-        position = random(contentLength + 1);
-
-  content = generateContent(MAXIMUM_INSERT_OPERATION_LENGTH); ///
-
-  return InsertOperation.fromContentAndPosition(content, position);
-}
-
-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.fromContentAndPosition(content, position);
-}