easy-richtextarea 4.0.19 → 4.0.21

package/lib/undoBuffer.js

@@ -44,97 +44,102 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
-var push = _necessary.arrayUtilities.push;
+var clear = _necessary.arrayUtilities.clear, filter = _necessary.arrayUtilities.filter, unshift = _necessary.arrayUtilities.unshift;
 var UndoBuffer = /*#__PURE__*/ function() {
-    function UndoBuffer(position, operations) {
+    function UndoBuffer(undoOperations, redoOperations) {
         _classCallCheck(this, UndoBuffer);
-        this.position = position;
-        this.operations = operations;
+        this.undoOperations = undoOperations;
+        this.redoOperations = redoOperations;
     }
     _createClass(UndoBuffer, [
         {
-            key: "getPosition",
-            value: function getPosition() {
-                return this.position;
+            key: "getUndoOperations",
+            value: function getUndoOperations() {
+                return this.undoOperations;
             }
         },
         {
-            key: "getOperations",
-            value: function getOperations() {
-                return this.operations;
+            key: "getRedoOperations",
+            value: function getRedoOperations() {
+                return this.redoOperations;
             }
         },
         {
             key: "undo",
             value: function undo() {
-                var operation = null;
-                if (this.position > 0) {
-                    this.position--;
-                    operation = this.operations[this.position];
-                    var invertedOperation = operation.invert(_insert.default, _delete.default);
-                    operation = invertedOperation; ///
+                var undoOperation = null;
+                var undoOperationsLength = this.undoOperations.length;
+                if (undoOperationsLength > 0) {
+                    undoOperation = this.undoOperations.shift();
+                    var invertedUndoOperation = undoOperation.invert(_insert.default, _delete.default), redoOperation = invertedUndoOperation; ///
+                    this.redoOperations.unshift(redoOperation);
                 }
-                return operation;
+                return undoOperation;
             }
         },
         {
             key: "redo",
             value: function redo() {
-                var operation = null;
-                var operationsLength = this.operations.length;
-                if (this.position < operationsLength) {
-                    operation = this.operations[this.position];
-                    this.position++;
+                var redoOperation = null;
+                var redoOperationsLength = this.redoOperations.length;
+                if (redoOperationsLength > 0) {
+                    redoOperation = this.redoOperations.shift();
+                    var invertedRedoOperation = redoOperation.invert(_insert.default, _delete.default), undoOperation = invertedRedoOperation; ///
+                    this.undoOperations.unshift(undoOperation);
                 }
-                return operation;
+                return redoOperation;
             }
         },
         {
             key: "transform",
             value: function transform(operations) {
-                this.operations = (0, _operations.default)(this.operations, operations);
-                this.filterEmptyOperations();
+                this.undoOperations = (0, _operations.default)(this.undoOperations, operations);
+                this.redoOperations = (0, _operations.default)(this.redoOperations, operations);
+                filterEmptyOperations(this.undoOperations);
+                filterEmptyOperations(this.redoOperations);
             }
         },
         {
             key: "addOperations",
             value: function addOperations(operations) {
-                var start = this.position; ///
-                this.operations.splice(start);
-                push(this.operations, operations);
-                var operationsLength = this.operations.length;
-                this.position = operationsLength; ///
-            }
-        },
-        {
-            key: "filterEmptyOperations",
-            value: function filterEmptyOperations() {
-                var length = this.operations.length, position = 0;
-                while(position < length){
-                    var operation = this.operations[position];
-                    if (_instanceof(operation, _empty.default)) {
-                        var start = position, deleteCount = 1;
-                        this.operations.splice(start, deleteCount);
-                        if (this.position > position) {
-                            this.position--;
-                        }
-                    } else {
-                        position++;
-                    }
-                    length = this.operations.length;
-                }
+                var invertedOperations = invertOperations(operations), reversedInvertedOperations = reverseOperations(invertedOperations), undoOperations = reversedInvertedOperations; ///
+                unshift(this.undoOperations, undoOperations);
+                clear(this.redoOperations);
             }
         }
     ], [
         {
             key: "fromNothing",
             value: function fromNothing() {
-                var position = 0, operations = [], undoBuffer = new UndoBuffer(position, operations);
+                var undoOperations = [], redoOperations = [], undoBuffer = new UndoBuffer(undoOperations, redoOperations);
                 return undoBuffer;
             }
         }
     ]);
     return UndoBuffer;
 }();
+function invertOperations(operations) {
+    var invertedOperations = operations.map(function(operation) {
+        var invertedOperation = operation.invert(_insert.default, _delete.default);
+        return invertedOperation;
+    });
+    return invertedOperations;
+}
+function reverseOperations(operations) {
+    var reversedOperations = operations.reduce(function(reversedOperations, operation) {
+        var reversedOperation = operation; ///
+        reversedOperations.unshift(reversedOperation);
+        return reversedOperations;
+    }, []);
+    return reversedOperations;
+}
+function filterEmptyOperations(operations) {
+    filter(operations, function(operation) {
+        var operationEmptyOperation = _instanceof(operation, _empty.default);
+        if (!operationEmptyOperation) {
+            return true;
+        }
+    });
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/undoBuffer.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport EmptyOperation from \"./operation/empty\";\nimport InsertOperation from \"./operation/insert\";\nimport DeleteOperation from \"./operation/delete\";\nimport transformOperations from \"./transform/operations\";\n\nconst { clear, filter, unshift } = arrayUtilities;\n\nexport default class UndoBuffer {\n  constructor(undoOperations, redoOperations) {\n    this.undoOperations = undoOperations;\n    this.redoOperations = redoOperations;\n  }\n\n  getUndoOperations() {\n    return this.undoOperations;\n  }\n  \n  getRedoOperations() {\n    return this.redoOperations;\n  }\n\n  undo() {\n    let undoOperation = null;\n\n    const undoOperationsLength = this.undoOperations.length;\n\n    if (undoOperationsLength > 0) {\n      undoOperation = this.undoOperations.shift();\n\n      const invertedUndoOperation = undoOperation.invert(InsertOperation, DeleteOperation),\n            redoOperation = invertedUndoOperation;  ///\n\n      this.redoOperations.unshift(redoOperation);\n    }\n\n    return undoOperation;\n  }\n\n  redo() {\n    let redoOperation = null;\n\n    const redoOperationsLength = this.redoOperations.length;\n\n    if (redoOperationsLength > 0) {\n      redoOperation = this.redoOperations.shift();\n\n      const invertedRedoOperation = redoOperation.invert(InsertOperation, DeleteOperation),\n            undoOperation = invertedRedoOperation;  ///\n\n      this.undoOperations.unshift(undoOperation);\n    }\n\n    return redoOperation;\n  }\n\n  transform(operations) {\n    this.undoOperations = transformOperations(this.undoOperations, operations);\n\n    this.redoOperations = transformOperations(this.redoOperations, operations);\n    \n    filterEmptyOperations(this.undoOperations);\n\n    filterEmptyOperations(this.redoOperations);\n  }\n\n  addOperations(operations) {\n    const invertedOperations = invertOperations(operations),\n          reversedInvertedOperations = reverseOperations(invertedOperations),\n          undoOperations = reversedInvertedOperations;  ///\n\n    unshift(this.undoOperations, undoOperations);\n\n    clear(this.redoOperations);\n  }\n\n  static fromNothing() {\n    const undoOperations = [],\n          redoOperations = [],\n          undoBuffer = new UndoBuffer(undoOperations, redoOperations);\n\n    return undoBuffer;\n  }\n}\n\nfunction invertOperations(operations) {\n  const invertedOperations = operations.map((operation) => {\n    const invertedOperation = operation.invert(InsertOperation, DeleteOperation);\n\n    return invertedOperation;\n  });\n\n  return invertedOperations;\n}\n\nfunction reverseOperations(operations) {\n  const reversedOperations = operations.reduce((reversedOperations, operation) => {\n    const reversedOperation = operation;  ///\n\n    reversedOperations.unshift(reversedOperation);\n\n    return reversedOperations;\n  }, []);\n\n  return reversedOperations;\n}\n\nfunction filterEmptyOperations(operations) {\n  filter(operations, (operation) => {\n    const operationEmptyOperation = (operation instanceof EmptyOperation);\n\n    if (!operationEmptyOperation) {\n      return true;\n    }\n  });\n}\n"],"names":["UndoBuffer","clear","arrayUtilities","filter","unshift","undoOperations","redoOperations","getUndoOperations","getRedoOperations","undo","undoOperation","undoOperationsLength","length","shift","invertedUndoOperation","invert","InsertOperation","DeleteOperation","redoOperation","redo","redoOperationsLength","invertedRedoOperation","transform","operations","transformOperations","filterEmptyOperations","addOperations","invertedOperations","invertOperations","reversedInvertedOperations","reverseOperations","fromNothing","undoBuffer","map","operation","invertedOperation","reversedOperations","reduce","reversedOperation","operationEmptyOperation","EmptyOperation"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "easy-richtextarea",
   "author": "James Smith",
-  "version": "4.0.19",
+  "version": "4.0.21",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/easy-richtextarea",
   "description": "A textarea element that handles and hands off events well.",

package/src/eventTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { eventTypes } from "easy";
+
+export const { CUT_EVENT_TYPE,
+               COPY_EVENT_TYPE,
+               BLUR_EVENT_TYPE,
+               PASTE_EVENT_TYPE,
+               INPUT_EVENT_TYPE,
+               FOCUS_EVENT_TYPE,
+               CHANGE_EVENT_TYPE,
+               SCROLL_EVENT_TYPE,
+               KEYDOWN_EVENT_TYPE,
+               CONTEXTMENU_EVENT_TYPE,
+               SELECTIONCHANGE_EVENT_TYPE } = eventTypes;
+
+export const FIND_EVENT_TYPE = "find";

package/src/example/richTextarea.js

@@ -6,19 +6,11 @@ import { RichTextarea } from "../browser";  ///
 
 export default withStyle(RichTextarea)`
 
-  color: #eee;
-  width: 64rem;
+  width: 48rem;
+  border: solid 1px black;
   resize: none;
-  height: 64rem;
+  height: 32rem;
   padding: 0.25rem;
-  font-size: 1.6rem;
   font-family: monospace;
-  margin-right: 2rem;
-  background-color: #222;
-    
-  ::selection {
-    color: #fff;
-    background-color: #c80;
-  }
 
 `;

package/src/example/view.js

@@ -3,63 +3,48 @@
 import RichTextarea from "./richTextarea";
 
 const content = "",
-      activeRichTextarea =
+      richTextarea =
 
-        <RichTextarea onChange={changeHandler} onScroll={scrollHandler} onFocus={focusHandler} onBlur={blurHandler} />
-
-      ,
-      inactiveRichTextarea =
-
-        <RichTextarea />
+        <RichTextarea onFind={findHandler} onBlur={blurHandler} onFocus={focusHandler} onChange={changeHandler} onScroll={scrollHandler} />
 
       ;
 
-activeRichTextarea.setContent(content);
+richTextarea.setContent(content);
 
-activeRichTextarea.activate();
+richTextarea.activate();
 
 const View = (properties) =>
 
   <div className="view">
-    {activeRichTextarea}
-    {inactiveRichTextarea}
+    {richTextarea}
   </div>
 
 ;
 
 export default View;
 
-function changeHandler(event, element) {
-  const contentChanged = activeRichTextarea.hasContentChanged(),
-        selectionChanged = activeRichTextarea.hasSelectionChanged();
-
-  console.log(contentChanged, selectionChanged)
-
-  if (contentChanged) {
-    const content = activeRichTextarea.getContent();
-
-    inactiveRichTextarea.setContent(content);
-  }
-
-  if (selectionChanged) {
-    const selection = activeRichTextarea.getSelection();
-
-    inactiveRichTextarea.setSelection(selection);
-  }
+function findHandler(event, element) {
+  console.log("find")
 }
 
-function scrollHandler(event, element) {
-  const scrollTop = activeRichTextarea.getScrollTop(),
-        scrollLeft = activeRichTextarea.getScrollLeft();
-
-  inactiveRichTextarea.setScrollTop(scrollTop);
-  inactiveRichTextarea.setScrollLeft(scrollLeft);
+function blurHandler(event, element) {
+  console.log("blur")
 }
 
 function focusHandler(event, element) {
   console.log("focus")
 }
 
-function blurHandler(event, element) {
-  console.log("blur")
+function changeHandler(event, element) {
+  const contentChanged = richTextarea.hasContentChanged(),
+        selectionChanged = richTextarea.hasSelectionChanged();
+
+  console.log(contentChanged, selectionChanged)
+}
+
+function scrollHandler(event, element) {
+  const scrollTop = richTextarea.getScrollTop(),
+        scrollLeft = richTextarea.getScrollLeft();
+
+  console.log(scrollTop, scrollLeft)
 }

package/src/keyCodes.js

@@ -1,3 +1,4 @@
 "use strict";
 
+export const F_KEY_CODE = 70;
 export const Z_KEY_CODE = 90;

package/src/richTextarea.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { Element, document, eventTypes } from "easy";
+import { Element, document } from "easy";
 
 import Selection from "./selection"
 import UndoBuffer from "./undoBuffer";
@@ -10,20 +10,20 @@ import transformContent from "./transform/content";
 import transformSelection from "./transform/selection";
 import generateOperations from "./operations/generate";
 
-import { Z_KEY_CODE } from "./keyCodes";
 import { TEXT, EMPTY_STRING } from "./constants";
-
-const { CUT_EVENT_TYPE,
-        COPY_EVENT_TYPE,
-        BLUR_EVENT_TYPE,
-        PASTE_EVENT_TYPE,
-        INPUT_EVENT_TYPE,
-        FOCUS_EVENT_TYPE,
-        CHANGE_EVENT_TYPE,
-        SCROLL_EVENT_TYPE,
-        KEYDOWN_EVENT_TYPE,
-        CONTEXTMENU_EVENT_TYPE,
-        SELECTIONCHANGE_EVENT_TYPE } = eventTypes;
+import { F_KEY_CODE, Z_KEY_CODE } from "./keyCodes";
+import { CUT_EVENT_TYPE,
+         COPY_EVENT_TYPE,
+         FIND_EVENT_TYPE,
+         BLUR_EVENT_TYPE,
+         PASTE_EVENT_TYPE,
+         INPUT_EVENT_TYPE,
+         FOCUS_EVENT_TYPE,
+         CHANGE_EVENT_TYPE,
+         SCROLL_EVENT_TYPE,
+         KEYDOWN_EVENT_TYPE,
+         CONTEXTMENU_EVENT_TYPE,
+         SELECTIONCHANGE_EVENT_TYPE } from "./eventTypes";
 
 export default class RichTextarea extends Element {
   constructor(selector, focused, readOnly, undoBuffer, previousContent, previousSelection) {
@@ -132,6 +132,18 @@ export default class RichTextarea extends Element {
       }
     }
 
+    if (keyCode === F_KEY_CODE) {
+      const { ctrlKey, metaKey } = event;
+
+      if (ctrlKey || metaKey) {
+        this.find(event, element);
+
+        event.preventDefault();
+
+        return;
+      }
+    }
+
     defer(() => {
       this.intermediateHandler(event, element);
     });
@@ -313,18 +325,28 @@ export default class RichTextarea extends Element {
     }
   }
 
+  find(event, element) {
+    const eventType = FIND_EVENT_TYPE;
+
+    this.callHandlers(eventType, event, element);
+  }
+
   undo(event, element) {
-    const operation = this.undoBuffer.undo();
+    const undoOperation = this.undoBuffer.undo();
+
+    if (undoOperation !== null) {
+      const operation = undoOperation;  ///
 
-    if (operation !== null) {
       this.revert(event, element, operation);
     }
   }
 
   redo(event, element) {
-    const operation = this.undoBuffer.redo();
+    const redoOperation = this.undoBuffer.redo();
+
+    if (redoOperation !== null) {
+      const operation = redoOperation;  ///
 
-    if (operation !== null) {
       this.revert(event, element, operation);
     }
   }
@@ -433,6 +455,20 @@ export default class RichTextarea extends Element {
     this.removeClass("active");
   }
 
+  onFind(findHandler, element) {
+    const eventType = FIND_EVENT_TYPE,
+          handler = findHandler;  ///
+
+    this.addEventListener(eventType, handler, element);
+  }
+
+  offFind(findHandler, element) {
+    const eventType = FIND_EVENT_TYPE,
+          handler = findHandler;  ///
+
+    this.removeEventListener(eventType, handler, element);
+  }
+
   onBlur(blurHandler, element) {
     const eventType = BLUR_EVENT_TYPE,
           handler = blurHandler;  ///
@@ -490,11 +526,12 @@ export default class RichTextarea extends Element {
   }
 
   didMount() {
-    const { onChange, onScroll, onFocus, onBlur } = this.properties,
-          changeHandler = onChange, ///
-          scrollHandler = onScroll, ///
+    const { onFind, onBlur, onFocus, onChange, onScroll } = this.properties,
+          findHandler = onFind, ///
+          blurHandler = onBlur, ///
           focusHandler = onFocus, ///
-          blurHandler = onBlur; ///
+          changeHandler = onChange, ///
+          scrollHandler = onScroll; ///
 
     const content = this.getContent(),
           selection = this.getSelection();
@@ -503,13 +540,15 @@ export default class RichTextarea extends Element {
 
     this.previousSelection = selection;  ///
 
-    changeHandler && this.onChange(changeHandler, this);
+    findHandler && this.onFind(findHandler, this);
 
-    scrollHandler && this.onScroll(scrollHandler, this);
+    blurHandler && this.onBlur(blurHandler, this);
 
     focusHandler && this.onFocus(focusHandler, this);
 
-    blurHandler && this.onBlur(blurHandler, this);
+    changeHandler && this.onChange(changeHandler, this);
+
+    scrollHandler && this.onScroll(scrollHandler, this);
 
     this.on(CUT_EVENT_TYPE, this.cutHandler);
 
@@ -523,19 +562,22 @@ export default class RichTextarea extends Element {
   }
 
   willUnmount() {
-    const { onChange, onScroll, onFocus, onBlur } = this.properties,
-          changeHandler = onChange, ///
-          scrollHandler = onScroll, ///
-          focusHandler = onFocus, ///
-          blurHandler = onBlur; ///
+    const { onFind, onBlur, onFocus, onChange, onScroll } = this.properties,
+            findHandler = onFind, ///
+            blurHandler = onBlur, ///
+            focusHandler = onFocus, ///
+            changeHandler = onChange, ///
+            scrollHandler = onScroll; ///
 
-    changeHandler && this.offChange(changeHandler, this);
+    findHandler && this.offFind(findHandler, this);
 
-    scrollHandler && this.offScroll(scrollHandler, this);
+    blurHandler && this.offBlur(blurHandler, this);
 
     focusHandler && this.offFocus(focusHandler, this);
 
-    blurHandler && this.offBlur(blurHandler, this);
+    changeHandler && this.offChange(changeHandler, this);
+
+    scrollHandler && this.offScroll(scrollHandler, this);
 
     this.off(CUT_EVENT_TYPE, this.cutHandler);
 
@@ -557,10 +599,11 @@ export default class RichTextarea extends Element {
   static tagName = "textarea";
 
   static ignoredProperties = [
+    "onFind",
+    "onBlur",
+    "onFocus",
     "onChange",
     "onScroll",
-    "onFocus",
-    "onBlur"
   ];
 
   static defaultProperties = {