promethee 1.4.8 → 1.4.9

data/node_modules/summernote/src/js/base/editing/Bullet.js

@@ -0,0 +1,201 @@
+import $ from 'jquery';
+import lists from '../core/lists';
+import func from '../core/func';
+import dom from '../core/dom';
+import range from '../core/range';
+
+export default class Bullet {
+  /**
+   * toggle ordered list
+   */
+  insertOrderedList(editable) {
+    this.toggleList('OL', editable);
+  }
+
+  /**
+   * toggle unordered list
+   */
+  insertUnorderedList(editable) {
+    this.toggleList('UL', editable);
+  }
+
+  /**
+   * indent
+   */
+  indent(editable) {
+    const rng = range.create(editable).wrapBodyInlineWithPara();
+
+    const paras = rng.nodes(dom.isPara, { includeAncestor: true });
+    const clustereds = lists.clusterBy(paras, func.peq2('parentNode'));
+
+    $.each(clustereds, (idx, paras) => {
+      const head = lists.head(paras);
+      if (dom.isLi(head)) {
+        this.wrapList(paras, head.parentNode.nodeName);
+      } else {
+        $.each(paras, (idx, para) => {
+          $(para).css('marginLeft', (idx, val) => {
+            return (parseInt(val, 10) || 0) + 25;
+          });
+        });
+      }
+    });
+
+    rng.select();
+  }
+
+  /**
+   * outdent
+   */
+  outdent(editable) {
+    const rng = range.create(editable).wrapBodyInlineWithPara();
+
+    const paras = rng.nodes(dom.isPara, { includeAncestor: true });
+    const clustereds = lists.clusterBy(paras, func.peq2('parentNode'));
+
+    $.each(clustereds, (idx, paras) => {
+      const head = lists.head(paras);
+      if (dom.isLi(head)) {
+        this.releaseList([paras]);
+      } else {
+        $.each(paras, (idx, para) => {
+          $(para).css('marginLeft', (idx, val) => {
+            val = (parseInt(val, 10) || 0);
+            return val > 25 ? val - 25 : '';
+          });
+        });
+      }
+    });
+
+    rng.select();
+  }
+
+  /**
+   * toggle list
+   *
+   * @param {String} listName - OL or UL
+   */
+  toggleList(listName, editable) {
+    const rng = range.create(editable).wrapBodyInlineWithPara();
+
+    let paras = rng.nodes(dom.isPara, { includeAncestor: true });
+    const bookmark = rng.paraBookmark(paras);
+    const clustereds = lists.clusterBy(paras, func.peq2('parentNode'));
+
+    // paragraph to list
+    if (lists.find(paras, dom.isPurePara)) {
+      let wrappedParas = [];
+      $.each(clustereds, (idx, paras) => {
+        wrappedParas = wrappedParas.concat(this.wrapList(paras, listName));
+      });
+      paras = wrappedParas;
+    // list to paragraph or change list style
+    } else {
+      const diffLists = rng.nodes(dom.isList, {
+        includeAncestor: true
+      }).filter((listNode) => {
+        return !$.nodeName(listNode, listName);
+      });
+
+      if (diffLists.length) {
+        $.each(diffLists, (idx, listNode) => {
+          dom.replace(listNode, listName);
+        });
+      } else {
+        paras = this.releaseList(clustereds, true);
+      }
+    }
+
+    range.createFromParaBookmark(bookmark, paras).select();
+  }
+
+  /**
+   * @param {Node[]} paras
+   * @param {String} listName
+   * @return {Node[]}
+   */
+  wrapList(paras, listName) {
+    const head = lists.head(paras);
+    const last = lists.last(paras);
+
+    const prevList = dom.isList(head.previousSibling) && head.previousSibling;
+    const nextList = dom.isList(last.nextSibling) && last.nextSibling;
+
+    const listNode = prevList || dom.insertAfter(dom.create(listName || 'UL'), last);
+
+    // P to LI
+    paras = paras.map((para) => {
+      return dom.isPurePara(para) ? dom.replace(para, 'LI') : para;
+    });
+
+    // append to list(<ul>, <ol>)
+    dom.appendChildNodes(listNode, paras);
+
+    if (nextList) {
+      dom.appendChildNodes(listNode, lists.from(nextList.childNodes));
+      dom.remove(nextList);
+    }
+
+    return paras;
+  }
+
+  /**
+   * @method releaseList
+   *
+   * @param {Array[]} clustereds
+   * @param {Boolean} isEscapseToBody
+   * @return {Node[]}
+   */
+  releaseList(clustereds, isEscapseToBody) {
+    let releasedParas = [];
+
+    $.each(clustereds, (idx, paras) => {
+      const head = lists.head(paras);
+      const last = lists.last(paras);
+
+      const headList = isEscapseToBody ? dom.lastAncestor(head, dom.isList) : head.parentNode;
+      const lastList = headList.childNodes.length > 1 ? dom.splitTree(headList, {
+        node: last.parentNode,
+        offset: dom.position(last) + 1
+      }, {
+        isSkipPaddingBlankHTML: true
+      }) : null;
+
+      const middleList = dom.splitTree(headList, {
+        node: head.parentNode,
+        offset: dom.position(head)
+      }, {
+        isSkipPaddingBlankHTML: true
+      });
+
+      paras = isEscapseToBody ? dom.listDescendant(middleList, dom.isLi)
+        : lists.from(middleList.childNodes).filter(dom.isLi);
+
+      // LI to P
+      if (isEscapseToBody || !dom.isList(headList.parentNode)) {
+        paras = paras.map((para) => {
+          return dom.replace(para, 'P');
+        });
+      }
+
+      $.each(lists.from(paras).reverse(), (idx, para) => {
+        dom.insertAfter(para, headList);
+      });
+
+      // remove empty lists
+      const rootLists = lists.compact([headList, middleList, lastList]);
+      $.each(rootLists, (idx, rootList) => {
+        const listNodes = [rootList].concat(dom.listDescendant(rootList, dom.isList));
+        $.each(listNodes.reverse(), (idx, listNode) => {
+          if (!dom.nodeLength(listNode)) {
+            dom.remove(listNode, true);
+          }
+        });
+      });
+
+      releasedParas = releasedParas.concat(paras);
+    });
+
+    return releasedParas;
+  }
+}

data/node_modules/summernote/src/js/base/editing/History.js

@@ -0,0 +1,105 @@
+import range from '../core/range';
+
+export default class History {
+  constructor($editable) {
+    this.stack = [];
+    this.stackOffset = -1;
+    this.$editable = $editable;
+    this.editable = $editable[0];
+  }
+
+  makeSnapshot() {
+    const rng = range.create(this.editable);
+    const emptyBookmark = {s: {path: [], offset: 0}, e: {path: [], offset: 0}};
+
+    return {
+      contents: this.$editable.html(),
+      bookmark: (rng ? rng.bookmark(this.editable) : emptyBookmark)
+    };
+  }
+
+  applySnapshot(snapshot) {
+    if (snapshot.contents !== null) {
+      this.$editable.html(snapshot.contents);
+    }
+    if (snapshot.bookmark !== null) {
+      range.createFromBookmark(this.editable, snapshot.bookmark).select();
+    }
+  }
+
+  /**
+  * @method rewind
+  * Rewinds the history stack back to the first snapshot taken.
+  * Leaves the stack intact, so that "Redo" can still be used.
+  */
+  rewind() {
+    // Create snap shot if not yet recorded
+    if (this.$editable.html() !== this.stack[this.stackOffset].contents) {
+      this.recordUndo();
+    }
+
+    // Return to the first available snapshot.
+    this.stackOffset = 0;
+
+    // Apply that snapshot.
+    this.applySnapshot(this.stack[this.stackOffset]);
+  }
+
+  /**
+  * @method reset
+  * Resets the history stack completely; reverting to an empty editor.
+  */
+  reset() {
+    // Clear the stack.
+    this.stack = [];
+
+    // Restore stackOffset to its original value.
+    this.stackOffset = -1;
+
+    // Clear the editable area.
+    this.$editable.html('');
+
+    // Record our first snapshot (of nothing).
+    this.recordUndo();
+  }
+
+  /**
+   * undo
+   */
+  undo() {
+    // Create snap shot if not yet recorded
+    if (this.$editable.html() !== this.stack[this.stackOffset].contents) {
+      this.recordUndo();
+    }
+
+    if (this.stackOffset > 0) {
+      this.stackOffset--;
+      this.applySnapshot(this.stack[this.stackOffset]);
+    }
+  }
+
+  /**
+   * redo
+   */
+  redo() {
+    if (this.stack.length - 1 > this.stackOffset) {
+      this.stackOffset++;
+      this.applySnapshot(this.stack[this.stackOffset]);
+    }
+  }
+
+  /**
+   * recorded undo
+   */
+  recordUndo() {
+    this.stackOffset++;
+
+    // Wash out stack after stackOffset
+    if (this.stack.length > this.stackOffset) {
+      this.stack = this.stack.slice(0, this.stackOffset);
+    }
+
+    // Create new snapshot and push it to the end
+    this.stack.push(this.makeSnapshot());
+  }
+}

data/node_modules/summernote/src/js/base/editing/Style.js

@@ -0,0 +1,158 @@
+import $ from 'jquery';
+import env from '../core/env';
+import func from '../core/func';
+import lists from '../core/lists';
+import dom from '../core/dom';
+
+export default class Style {
+  /**
+   * @method jQueryCSS
+   *
+   * [workaround] for old jQuery
+   * passing an array of style properties to .css()
+   * will result in an object of property-value pairs.
+   * (compability with version < 1.9)
+   *
+   * @private
+   * @param  {jQuery} $obj
+   * @param  {Array} propertyNames - An array of one or more CSS properties.
+   * @return {Object}
+   */
+  jQueryCSS($obj, propertyNames) {
+    if (env.jqueryVersion < 1.9) {
+      const result = {};
+      $.each(propertyNames, (idx, propertyName) => {
+        result[propertyName] = $obj.css(propertyName);
+      });
+      return result;
+    }
+    return $obj.css(propertyNames);
+  }
+
+  /**
+   * returns style object from node
+   *
+   * @param {jQuery} $node
+   * @return {Object}
+   */
+  fromNode($node) {
+    const properties = ['font-family', 'font-size', 'text-align', 'list-style-type', 'line-height'];
+    const styleInfo = this.jQueryCSS($node, properties) || {};
+    styleInfo['font-size'] = parseInt(styleInfo['font-size'], 10);
+    return styleInfo;
+  }
+
+  /**
+   * paragraph level style
+   *
+   * @param {WrappedRange} rng
+   * @param {Object} styleInfo
+   */
+  stylePara(rng, styleInfo) {
+    $.each(rng.nodes(dom.isPara, {
+      includeAncestor: true
+    }), (idx, para) => {
+      $(para).css(styleInfo);
+    });
+  }
+
+  /**
+   * insert and returns styleNodes on range.
+   *
+   * @param {WrappedRange} rng
+   * @param {Object} [options] - options for styleNodes
+   * @param {String} [options.nodeName] - default: `SPAN`
+   * @param {Boolean} [options.expandClosestSibling] - default: `false`
+   * @param {Boolean} [options.onlyPartialContains] - default: `false`
+   * @return {Node[]}
+   */
+  styleNodes(rng, options) {
+    rng = rng.splitText();
+
+    const nodeName = (options && options.nodeName) || 'SPAN';
+    const expandClosestSibling = !!(options && options.expandClosestSibling);
+    const onlyPartialContains = !!(options && options.onlyPartialContains);
+
+    if (rng.isCollapsed()) {
+      return [rng.insertNode(dom.create(nodeName))];
+    }
+
+    let pred = dom.makePredByNodeName(nodeName);
+    const nodes = rng.nodes(dom.isText, {
+      fullyContains: true
+    }).map((text) => {
+      return dom.singleChildAncestor(text, pred) || dom.wrap(text, nodeName);
+    });
+
+    if (expandClosestSibling) {
+      if (onlyPartialContains) {
+        const nodesInRange = rng.nodes();
+        // compose with partial contains predication
+        pred = func.and(pred, (node) => {
+          return lists.contains(nodesInRange, node);
+        });
+      }
+
+      return nodes.map((node) => {
+        const siblings = dom.withClosestSiblings(node, pred);
+        const head = lists.head(siblings);
+        const tails = lists.tail(siblings);
+        $.each(tails, (idx, elem) => {
+          dom.appendChildNodes(head, elem.childNodes);
+          dom.remove(elem);
+        });
+        return lists.head(siblings);
+      });
+    } else {
+      return nodes;
+    }
+  }
+
+  /**
+   * get current style on cursor
+   *
+   * @param {WrappedRange} rng
+   * @return {Object} - object contains style properties.
+   */
+  current(rng) {
+    const $cont = $(!dom.isElement(rng.sc) ? rng.sc.parentNode : rng.sc);
+    let styleInfo = this.fromNode($cont);
+
+    // document.queryCommandState for toggle state
+    // [workaround] prevent Firefox nsresult: "0x80004005 (NS_ERROR_FAILURE)"
+    try {
+      styleInfo = $.extend(styleInfo, {
+        'font-bold': document.queryCommandState('bold') ? 'bold' : 'normal',
+        'font-italic': document.queryCommandState('italic') ? 'italic' : 'normal',
+        'font-underline': document.queryCommandState('underline') ? 'underline' : 'normal',
+        'font-subscript': document.queryCommandState('subscript') ? 'subscript' : 'normal',
+        'font-superscript': document.queryCommandState('superscript') ? 'superscript' : 'normal',
+        'font-strikethrough': document.queryCommandState('strikethrough') ? 'strikethrough' : 'normal',
+        'font-family': document.queryCommandValue('fontname') || styleInfo['font-family']
+      });
+    } catch (e) {}
+
+    // list-style-type to list-style(unordered, ordered)
+    if (!rng.isOnList()) {
+      styleInfo['list-style'] = 'none';
+    } else {
+      const orderedTypes = ['circle', 'disc', 'disc-leading-zero', 'square'];
+      const isUnordered = $.inArray(styleInfo['list-style-type'], orderedTypes) > -1;
+      styleInfo['list-style'] = isUnordered ? 'unordered' : 'ordered';
+    }
+
+    const para = dom.ancestor(rng.sc, dom.isPara);
+    if (para && para.style['line-height']) {
+      styleInfo['line-height'] = para.style.lineHeight;
+    } else {
+      const lineHeight = parseInt(styleInfo['line-height'], 10) / parseInt(styleInfo['font-size'], 10);
+      styleInfo['line-height'] = lineHeight.toFixed(1);
+    }
+
+    styleInfo.anchor = rng.isOnAnchor() && dom.ancestor(rng.sc, dom.isAnchor);
+    styleInfo.ancestors = dom.listAncestor(rng.sc, dom.isEditable);
+    styleInfo.range = rng;
+
+    return styleInfo;
+  }
+}