@seafile/seafile-editor 0.3.76

package/dist/utils/copy-to-clipboard.js

@@ -0,0 +1,47 @@
+import deselectCurrent from 'toggle-selection';
+
+function copy(text) {
+  var reselectPrevious,
+      range,
+      selection,
+      mark,
+      success = false;
+
+  try {
+    reselectPrevious = deselectCurrent();
+    range = document.createRange();
+    selection = document.getSelection();
+    mark = document.createElement('span');
+    mark.textContent = text;
+    document.body.appendChild(mark);
+    range.selectNode(mark);
+    selection.addRange(range);
+    var successful = document.execCommand('copy');
+
+    if (!successful) {
+      console.log('copy command was unsuccessful');
+    }
+
+    success = true;
+  } catch (err) {
+    console.error('unable to copy using execCommand');
+  } finally {
+    if (selection) {
+      if (typeof selection.removeRange == 'function') {
+        selection.removeRange(range);
+      } else {
+        selection.removeAllRanges();
+      }
+    }
+
+    if (mark) {
+      document.body.removeChild(mark);
+    }
+
+    reselectPrevious();
+  }
+
+  return success;
+}
+
+export default copy;

package/dist/utils/deserialize-html.js

@@ -0,0 +1,282 @@
+import { jsx } from '../lib/slate-hyperscript/';
+import { generateTableRow, generateTableCell } from '../editor/element-model/table';
+var ELEMENT_TAGS = {
+  A: function A(el) {
+    return {
+      type: 'link',
+      data: {
+        href: el.getAttribute('href')
+      }
+    };
+  },
+  BLOCKQUOTE: function BLOCKQUOTE() {
+    return {
+      type: 'blockquote'
+    };
+  },
+  H1: function H1() {
+    return {
+      type: 'header_one'
+    };
+  },
+  H2: function H2() {
+    return {
+      type: 'header_two'
+    };
+  },
+  H3: function H3() {
+    return {
+      type: 'header_three'
+    };
+  },
+  H4: function H4() {
+    return {
+      type: 'header_four'
+    };
+  },
+  H5: function H5() {
+    return {
+      type: 'header_five'
+    };
+  },
+  H6: function H6() {
+    return {
+      type: 'header_six'
+    };
+  },
+  IMG: function IMG(el) {
+    return {
+      type: 'image',
+      children: [{
+        text: ''
+      }],
+      data: {
+        src: el.getAttribute('src')
+      }
+    };
+  },
+  LI: function LI() {
+    return {
+      type: 'list_item',
+      data: {}
+    };
+  },
+  OL: function OL() {
+    return {
+      type: 'ordered_list'
+    };
+  },
+  P: function P() {
+    return {
+      type: 'paragraph'
+    };
+  },
+  UL: function UL() {
+    return {
+      type: 'unordered_list'
+    };
+  },
+  TABLE: function TABLE() {
+    return {
+      type: 'table'
+    };
+  },
+  BR: function BR() {
+    return {
+      text: ''
+    };
+  }
+};
+var HEADER_LIST = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];
+var TEXT_TAGS = {
+  CODE: function CODE() {
+    return {
+      CODE: true
+    };
+  },
+  DEL: function DEL() {
+    return {
+      DELETE: true
+    };
+  },
+  EM: function EM() {
+    return {
+      ITALIC: true
+    };
+  },
+  I: function I() {
+    return {
+      ITALIC: true
+    };
+  },
+  STRONG: function STRONG() {
+    return {
+      BOLD: true
+    };
+  },
+  INS: function INS() {
+    return {
+      INS: true
+    };
+  }
+};
+
+var parseTable = function parseTable(el) {
+  if (el.parentNode.nodeName !== 'BODY') {
+    return null;
+  }
+
+  var tableWidth = 0;
+  Array.from(el.rows[0].childNodes).forEach(function (cell, index) {
+    if (cell.nodeName === 'TD' || cell.nodeName === 'TH') {
+      tableWidth += Number(cell.getAttribute('colspan')) || 1;
+    }
+  });
+  var rowList = [];
+
+  for (var rowIndex = 0; rowIndex < el.rows.length; rowIndex++) {
+    var cells = el.rows[rowIndex].cells;
+    var cellsList = [];
+
+    for (var columnIndex = 0; columnIndex < cells.length; columnIndex++) {
+      var cell = cells[columnIndex];
+      cellsList.push(generateTableCell({
+        children: [{
+          type: 'paragraph',
+          children: [{
+            text: cell.textContent
+          }]
+        }]
+      }));
+    }
+
+    if (cellsList.length < tableWidth) {
+      var count = tableWidth - cellsList.length;
+
+      for (var i = 0; i < count; i++) {
+        cellsList.push(generateTableCell({
+          children: [{
+            type: 'paragraph',
+            children: [{
+              text: ''
+            }]
+          }]
+        }));
+      }
+    }
+
+    rowList.push(generateTableRow({
+      children: cellsList
+    }));
+  }
+
+  return rowList;
+};
+
+var deserializeHtml = function deserializeHtml(el) {
+  if (el.nodeType === 3) {
+    // remove \n character
+    if (el.textContent === '\n' || el.textContent === '\r') {
+      return null;
+    }
+
+    if (el.parentElement.nodeName === 'BODY') {
+      var text = el.textContent.replace(/(\n|\r\n)/g, '');
+      if (text.length === 0) return null;
+      return {
+        type: 'paragraph',
+        children: [{
+          text: text
+        }]
+      };
+    }
+
+    return el.textContent;
+  } else if (el.nodeType !== 1) {
+    return null;
+  }
+
+  var nodeName = el.nodeName;
+  var parent = el;
+  var children = Array.from(parent.childNodes).map(deserializeHtml).flat(); // deserialize task list
+
+  if (nodeName === 'LI') {
+    if (el.className && el.className.indexOf('task-list-item') >= 0) {
+      return jsx('element', {
+        data: {
+          checked: false
+        },
+        type: 'list_item'
+      }, children);
+    }
+  }
+
+  if (nodeName === 'PRE' && el.childNodes[0] && el.childNodes[0].nodeName === 'CODE') {
+    // deserialize code block
+    var code = el.childNodes[0];
+    var codeChildren = [];
+    code.childNodes.forEach(function (codeLine, index) {
+      if (codeLine.innerText) {
+        codeChildren.push({
+          type: 'code_line',
+          children: [{
+            text: codeLine.innerText
+          }]
+        });
+      }
+    });
+    return {
+      data: {
+        syntax: null
+      },
+      children: codeChildren,
+      type: 'code_block'
+    };
+  }
+
+  if (el.nodeName === 'BODY') {
+    return jsx('fragment', {}, children);
+  }
+
+  if (ELEMENT_TAGS[nodeName]) {
+    var attrs = ELEMENT_TAGS[nodeName](el);
+
+    if (nodeName === 'IMG') {
+      return jsx('element', attrs, [{
+        text: ''
+      }]);
+    } // modify BR into an empty text node
+
+
+    if (nodeName === 'BR') {
+      return '';
+    }
+
+    if (nodeName === 'TABLE') {
+      return jsx('element', attrs, parseTable(el));
+    }
+
+    if (nodeName === 'A' || HEADER_LIST.includes(nodeName)) {
+      return jsx('element', attrs, [{
+        text: el.textContent
+      }]);
+    }
+
+    return jsx('element', attrs, children);
+  }
+
+  if (TEXT_TAGS[nodeName]) {
+    var _attrs = TEXT_TAGS[nodeName](el);
+
+    return children.map(function (child) {
+      return jsx('text', _attrs, child);
+    });
+  }
+
+  return children;
+};
+
+export var htmlDeserializer = function htmlDeserializer(html) {
+  var parsed = new DOMParser().parseFromString(html, 'text/html');
+  return deserializeHtml(parsed.body);
+};

package/dist/utils/diff/compare-strings.js

@@ -0,0 +1,46 @@
+function compareTwoStrings(str1, str2) {
+  if (!str1.length && !str2.length) return 1; // if both are empty strings
+
+  if (!str1.length || !str2.length) return 0; // if only one is empty string
+
+  if (str1.toUpperCase() === str2.toUpperCase()) return 1; // identical
+
+  if (str1.length === 1 && str2.length === 1) return 0; // both are 1-letter strings
+
+  var pairs1 = wordLetterPairs(str1);
+  var pairs2 = wordLetterPairs(str2);
+  var union = pairs1.length + pairs2.length;
+  var intersection = 0;
+  pairs1.forEach(function (pair1) {
+    for (var i = 0, pair2; pair2 = pairs2[i]; i++) {
+      if (pair1 !== pair2) continue;
+      intersection++;
+      pairs2.splice(i, 1);
+      break;
+    }
+  });
+  return intersection * 2 / union;
+}
+
+function flattenDeep(arr) {
+  return Array.isArray(arr) ? arr.reduce(function (a, b) {
+    return a.concat(flattenDeep(b));
+  }, []) : [arr];
+}
+
+function letterPairs(str) {
+  var pairs = [];
+
+  for (var i = 0, max = str.length - 1; i < max; i++) {
+    pairs[i] = str.substring(i, i + 2);
+  }
+
+  return pairs;
+}
+
+function wordLetterPairs(str) {
+  var pairs = str.toUpperCase().split(' ').map(letterPairs);
+  return flattenDeep(pairs);
+}
+
+export { compareTwoStrings };