Merge branch 'rewriting-version2.0' into Split-Merge-blocks

docs/caret.md

@@ -4,7 +4,7 @@ The `Caret` module contains methods working with caret. Uses [Range](https://dev
 between blocks. 
 
 Caret class implements basic Module class that holds User configuration
-and default CodeXEditor instances
+and default CodeX Editor instances
 
 You can read more about Module class [here]()
 
@@ -12,14 +12,12 @@ You can read more about Module class [here]()
 
 ## Methods
 
-
 ### setToBlock
 
 ```javascript
 Caret.setToBlock(block, offset, atEnd)
 ```
 
-
 > Method gets Block instance and puts caret to the text node with offset
 
 #### params

docs/sanitizer.md

@@ -0,0 +1,45 @@
+# CodeX Editor Sanitizer Module
+
+The `Sanitizer` module represents a set of methods that clears taint strings.
+Uses lightweight npm package with simple API [html-janitor](https://www.npmjs.com/package/html-janitor)
+ 
+Sanitizer class implements basic Module class that holds User configuration
+and default CodeX Editor instances
+
+You can read more about Module class [here]()
+
+## Properties
+
+Default Editor Sanitizer configuration according to the html-janitor API
+```javascript
+defaultConfig
+```
+
+Custom User configuration which passed on Editor initialization. Data type must be according to the html-janitor API
+```javascript
+sanitizerConfig
+```
+
+
+Property that holds an instance used in Module
+```javascript
+sanitizerInstance
+```
+
+## Methods 
+
+### clean
+
+```javascript
+clean(taintString, customConfig)
+```
+
+> Cleans up the passed taint string
+ 
+#### params
+
+| Param        | Type | Description|
+| -------------|------ |:-------------:|
+| taintString  | String | string that needs to be cleaned|
+| customConfig | Object | Can be passed new config per usage (Default: uses default configuration)|
+

src/codex.js

@@ -52,7 +52,7 @@
  * @property {String} placeholder        - First Block placeholder
  * @property {Object} sanitizer          - @todo fill desc
  * @property {Boolean} hideToolbar       - @todo fill desc
- * @property {Object} toolsConfig        - tools configuration {@link Tools#ToolsConfig}
+ * @property {Object} toolsConfig        - tools configuration {@link tools#ToolConfig}
  */
 
 /**

src/components/modules/_listeners.js

@@ -1,192 +0,0 @@
-/**
- * Codex Editor Listeners module
- *
- * @author Codex Team
- * @version 1.0
- */
-
-/**
- * Module-decorator for event listeners assignment
- */
-module.exports = function (listeners) {
-
-    var allListeners = [];
-
-    /**
-     * Search methods
-     *
-     * byElement, byType and byHandler returns array of suitable listeners
-     * one and all takes element, eventType, and handler and returns first (all) suitable listener
-     *
-     */
-    listeners.search = function () {
-
-        var byElement = function (element, context) {
-
-            var listenersOnElement = [];
-
-            context = context || allListeners;
-
-            for (var i = 0; i < context.length; i++) {
-
-                var listener = context[i];
-
-                if (listener.element === element) {
-
-                    listenersOnElement.push(listener);
-
-                }
-
-            }
-
-            return listenersOnElement;
-
-        };
-
-        var byType = function (eventType, context) {
-
-            var listenersWithType = [];
-
-            context = context || allListeners;
-
-            for (var i = 0; i < context.length; i++) {
-
-                var listener = context[i];
-
-                if (listener.type === eventType) {
-
-                    listenersWithType.push(listener);
-
-                }
-
-            }
-
-            return listenersWithType;
-
-        };
-
-        var byHandler = function (handler, context) {
-
-            var listenersWithHandler = [];
-
-            context = context || allListeners;
-
-            for (var i = 0; i < context.length; i++) {
-
-                var listener = context[i];
-
-                if (listener.handler === handler) {
-
-                    listenersWithHandler.push(listener);
-
-                }
-
-            }
-
-            return listenersWithHandler;
-
-        };
-
-        var one = function (element, eventType, handler) {
-
-            var result = allListeners;
-
-            if (element)
-                result = byElement(element, result);
-
-            if (eventType)
-                result = byType(eventType, result);
-
-            if (handler)
-                result = byHandler(handler, result);
-
-            return result[0];
-
-        };
-
-        var all = function (element, eventType, handler) {
-
-            var result = allListeners;
-
-            if (element)
-                result = byElement(element, result);
-
-            if (eventType)
-                result = byType(eventType, result);
-
-            if (handler)
-                result = byHandler(handler, result);
-
-            return result;
-
-        };
-
-        return {
-            byElement   : byElement,
-            byType      : byType,
-            byHandler   : byHandler,
-            one         : one,
-            all         : all
-        };
-
-    }();
-
-    listeners.add = function (element, eventType, handler, isCapture) {
-
-        element.addEventListener(eventType, handler, isCapture);
-
-        var data = {
-            element: element,
-            type: eventType,
-            handler: handler
-        };
-
-        var alreadyAddedListener = listeners.search.one(element, eventType, handler);
-
-        if (!alreadyAddedListener) {
-
-            allListeners.push(data);
-
-        }
-
-    };
-
-    listeners.remove = function (element, eventType, handler) {
-
-        element.removeEventListener(eventType, handler);
-
-        var existingListeners = listeners.search.all(element, eventType, handler);
-
-        for (var i = 0; i < existingListeners.length; i++) {
-
-            var index = allListeners.indexOf(existingListeners[i]);
-
-            if (index > 0) {
-
-                allListeners.splice(index, 1);
-
-            }
-
-        }
-
-    };
-
-    listeners.removeAll = function () {
-
-        allListeners.map(function (current) {
-
-            listeners.remove(current.element, current.type, current.handler);
-
-        });
-
-    };
-
-    listeners.get = function (element, eventType, handler) {
-
-        return listeners.search.all(element, eventType, handler);
-
-    };
-
-    return listeners;
-
-}({});

src/components/modules/blockManager.js

@@ -102,6 +102,44 @@ export default class BlockManager extends Module {
 
     }
 
+    /**
+     * Bind Events
+     * @param {Object} block
+     */
+    bindEvents(block) {
+
+        /**
+         * keydown on block
+         * @todo move to the keydown module
+         */
+        this.Editor.Listeners.on(block.pluginsContent, 'keydown', (event) => this.keyDownOnBlock(event));
+
+    }
+
+    /**
+     * @todo move to the keydown module
+     * @param {MouseEvent} event
+     */
+    keyDownOnBlock(event) {
+
+        switch(event.keyCode) {
+
+            case _.keyCodes.ENTER:
+                // this.enterPressedOnPluginsContent(event);
+                break;
+            case _.keyCodes.DOWN:
+            case _.keyCodes.RIGHT:
+                this.navigateNext();
+                break;
+            case _.keyCodes.UP:
+            case _.keyCodes.LEFT:
+                this.navigatePrevious();
+                break;
+
+        }
+
+    }
+
     /**
      * Set's caret to the next Block
      * Before moving caret, we should check if caret position is at the end of Plugins node
@@ -203,7 +241,7 @@ export default class BlockManager extends Module {
 
     }
 
-    @todo
+    // @todo
     /* split() {
 
         let extractedFragment = this.Editor.Caret.extractFromCaretPosition(),

src/components/modules/listeners.js

@@ -0,0 +1,217 @@
+/**
+ * Codex Editor Listeners module
+ *
+ * @module Listeners
+ *
+ * Module-decorator for event listeners assignment
+ *
+ * @author Codex Team
+ * @version 2.0.0
+ */
+
+/**
+ * @typedef {Listeners} Listeners
+ * @property {Array} allListeners
+ */
+
+export default class Listeners extends Module {
+
+    /**
+     * @constructor
+     * @param {EditorConfig} config
+     */
+    constructor({config}) {
+
+        super({config});
+        this.allListeners = [];
+
+    }
+
+    /**
+     * Assigns event listener on element
+     *
+     * @param {Element} element - DOM element that needs to be listened
+     * @param {String} eventType - event type
+     * @param {Function} handler - method that will be fired on event
+     * @param {Boolean} useCapture - use event bubbling
+     */
+    on(element, eventType, handler, useCapture = false) {
+
+        let assignedEventData = {
+            element,
+            eventType,
+            handler,
+            useCapture
+        };
+
+        let alreadyExist = this.findOne(element, eventType, handler);
+
+        if (alreadyExist) return;
+
+        this.allListeners.push(assignedEventData);
+        element.addEventListener(eventType, handler, useCapture);
+
+    }
+
+    /**
+     * Removes event listener from element
+     *
+     * @param {Element} element - DOM element that we removing listener
+     * @param {String} eventType - event type
+     * @param {Function} handler - remove handler, if element listens several handlers on the same event type
+     * @param {Boolean} useCapture - use event bubbling
+     */
+    off(element, eventType, handler, useCapture = false) {
+
+        let existingListeners = this.findAll(element, eventType, handler);
+
+        for (let i = 0; i < existingListeners.length; i++) {
+
+            let index = this.allListeners.indexOf(existingListeners[i]);
+
+            if (index > 0) {
+
+                this.allListeners.splice(index, 1);
+
+            }
+
+        }
+
+        element.removeEventListener(eventType, handler, useCapture);
+
+
+    }
+
+    /**
+     * Search method: looks for listener by passed element
+     * @param {Element} element - searching element
+     * @returns {Array} listeners that found on element
+     */
+    findByElement(element) {
+
+        let listenersOnElement = [];
+
+        for (let i = 0; i < this.allListeners.length; i++) {
+
+            let listener = this.allListeners[i];
+
+            if (listener.element === element) {
+
+                listenersOnElement.push(listener);
+
+            }
+
+        }
+
+        return listenersOnElement;
+
+    }
+
+    /**
+     * Search method: looks for listener by passed event type
+     * @param {String} eventType
+     * @return {Array} listeners that found on element
+     */
+    findByType(eventType) {
+
+        let listenersWithType = [];
+
+        for (let i = 0; i < this.allListeners.length; i++) {
+
+            let listener = this.allListeners[i];
+
+            if (listener.type === eventType) {
+
+                listenersWithType.push(listener);
+
+            }
+
+        }
+
+        return listenersWithType;
+
+    }
+
+    /**
+     * Search method: looks for listener by passed handler
+     * @param {Function} handler
+     * @return {Array} listeners that found on element
+     */
+    findByHandler(handler) {
+
+        let listenersWithHandler = [];
+
+        for (let i = 0; i < this.allListeners.length; i++) {
+
+            let listener = this.allListeners[i];
+
+            if (listener.handler === handler) {
+
+                listenersWithHandler.push(listener);
+
+            }
+
+        }
+
+        return listenersWithHandler;
+
+    }
+
+    /**
+     * @param {Element} element
+     * @param {String} eventType
+     * @param {Function} handler
+     * @return {Element|null}
+     */
+    findOne(element, eventType, handler) {
+
+        let foundListeners = this.findAll(element, eventType, handler);
+
+        return foundListeners.length > 0 ? foundListeners[0] : null;
+
+    }
+
+    /**
+     * @param {Element} element
+     * @param {String} eventType
+     * @param {Function} handler
+     * @return {Array}
+     */
+    findAll(element, eventType, handler) {
+
+        let foundAllListeners,
+            foundByElements = [],
+            foundByEventType = [],
+            foundByHandler = [];
+
+        if (element)
+            foundByElements = this.findByElement(element);
+
+        if (eventType)
+            foundByEventType = this.findByType(eventType);
+
+        if (handler)
+            foundByHandler = this.findByHandler(handler);
+
+        foundAllListeners = foundByElements.concat(foundByEventType, foundByHandler);
+
+        return foundAllListeners;
+
+    }
+
+    /**
+     * Removes all listeners
+     */
+    removeAll() {
+
+        this.allListeners.map( (current) => {
+
+            current.element.removeEventListener(current.eventType, current.handler);
+
+        });
+
+        this.allListeners = [];
+
+    }
+
+}