@seafile/sdoc-editor 0.4.36 → 0.4.37

package/dist/slate-convert/html-to-slate/index.js

@@ -0,0 +1,131 @@
+import slugid from 'slugid';
+import typeOf from 'type-of';
+import { INLINE_LEVEL_TYPES, LIST_ITEM, PARAGRAPH, TOP_LEVEL_TYPES, UNORDERED_LIST } from './constants';
+import rules from './rules';
+const cruftNewline = element => {
+  return !(element.nodeName === '#text' && element.nodeValue === '\n');
+};
+const deserializeElement = element => {
+  let node;
+  const next = elements => {
+    if (Object.prototype.toString.call(elements) === '[object NodeList]') {
+      elements = Array.from(elements);
+    }
+    switch (typeOf(elements)) {
+      case 'array':
+        return deserializeElements(elements);
+      case 'object':
+        return deserializeElement(elements);
+      case 'null':
+      case 'undefined':
+        return;
+      default:
+        throw new Error("The `next` argument was called with invalid children: \"".concat(elements, "\"."));
+    }
+  };
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if (!rule) continue;
+    const ret = rule(element, next);
+    const type = typeOf(ret);
+    if (type !== 'array' && type !== 'object' && type !== 'null' && type !== 'undefined') {
+      throw new Error("A rule returned an invalid deserialized representation: \"".concat(node, "\"."));
+    }
+
+    // Not eligible for current component processing
+    if (ret === undefined) {
+      continue;
+    }
+
+    // Empty tags will be discarded and not converted accordingly
+    if (ret === null) {
+      return null;
+    }
+
+    // Assign the final processing result to node
+    node = ret;
+    break;
+  }
+
+  // If node is undefined, it means that the label is not processed, and continue to process the child nodes of the element
+  return node || next(element.childNodes);
+};
+const deserializeElements = function () {
+  let elements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let isTopLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  let nodes = [];
+  elements.filter(cruftNewline).forEach(element => {
+    const node = deserializeElement(element);
+    switch (typeOf(node)) {
+      case 'array':
+        const formatNode = isTopLevel ? formatElementNodes(node) : node;
+        nodes = nodes.concat(formatNode);
+        break;
+      case 'object':
+        nodes.push(node);
+        break;
+      default:
+      // nothing todo
+    }
+  });
+
+  return nodes;
+};
+const formatElementNodes = nodes => {
+  if (nodes.length === 0) {
+    return [{
+      id: slugid.nice(),
+      type: PARAGRAPH,
+      children: [{
+        text: '',
+        id: slugid.nice()
+      }]
+    }];
+  }
+  nodes = nodes.reduce((memo, node) => {
+    if (TOP_LEVEL_TYPES.includes(node.type)) {
+      memo.push(node);
+    }
+    if (node.type === LIST_ITEM) {
+      const newNode = {
+        id: slugid.nice(),
+        type: UNORDERED_LIST,
+        children: [node]
+      };
+      memo.push(newNode);
+      return memo;
+    }
+
+    // The following types will not appear individually during the pasting process
+    // code_line
+    // table_row | table_cell
+
+    // text | image | link
+    if (!node.type || INLINE_LEVEL_TYPES.includes(node.type)) {
+      let prevNode = memo[memo.length - 1];
+      if (prevNode && prevNode.type === PARAGRAPH) {
+        prevNode.children.push(node);
+        return memo;
+      }
+      const newNode = {
+        id: slugid.nice(),
+        type: PARAGRAPH,
+        children: [node]
+      };
+      memo.push(newNode);
+      return memo;
+    }
+    return memo;
+  }, []);
+  return nodes;
+};
+const deserializeHtml = html => {
+  const parsed = new DOMParser().parseFromString(html, 'text/html');
+  const fragment = parsed.body;
+  const children = Array.from(fragment.childNodes);
+  let nodes = [];
+  nodes = deserializeElements(children, true);
+  nodes = formatElementNodes(nodes);
+  return nodes;
+};
+export default deserializeHtml;

package/dist/slate-convert/html-to-slate/rules/blockquote.js

@@ -0,0 +1,17 @@
+import slugid from 'slugid';
+import { BLOCKQUOTE } from '../constants';
+const blockquoteRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'BLOCKQUOTE') {
+    return {
+      id: slugid.nice(),
+      type: BLOCKQUOTE,
+      children: parseChild(childNodes)
+    };
+  }
+  return;
+};
+export default blockquoteRule;

package/dist/slate-convert/html-to-slate/rules/check-list.js

@@ -0,0 +1,20 @@
+import slugid from 'slugid';
+import { CHECK_LIST_ITEM } from '../constants';
+const checkListRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  if (nodeName === 'INPUT' && element.getAttribute('type') === 'checkbox') {
+    return {
+      id: slugid.nice(),
+      type: CHECK_LIST_ITEM,
+      checked: element.getAttribute('checked') !== null,
+      children: [{
+        id: slugid.nice(),
+        text: ''
+      }]
+    };
+  }
+  return;
+};
+export default checkListRule;

package/dist/slate-convert/html-to-slate/rules/code-block.js

@@ -0,0 +1,83 @@
+import slugid from 'slugid';
+import { CODE_BLOCK, CODE_LINE } from '../constants';
+import { genCodeLangs } from '../helper';
+const codeBlockRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'PRE') {
+    const children = Array.from(childNodes).filter(item => item.nodeName === 'CODE');
+    let codeChild = children[0];
+    if (codeChild) {
+      let lang = codeChild.getAttribute('lang');
+      lang = genCodeLangs().find(item => item.value === lang) || 'plaintext';
+      return {
+        id: slugid.nice(),
+        language: lang,
+        type: CODE_BLOCK,
+        children: parseChild(children)
+      };
+    } else {
+      const lang = 'plaintext';
+      const content = childNodes[0].textContent;
+      const textArr = content.split('\n').filter(Boolean);
+      const children = textArr.map(text => {
+        return {
+          id: slugid.nice(),
+          type: CODE_LINE,
+          children: [{
+            id: slugid.nice(),
+            text: text
+          }]
+        };
+      });
+      return {
+        id: slugid.nice(),
+        language: lang,
+        type: CODE_BLOCK,
+        children: children
+      };
+    }
+  }
+  if (nodeName === 'CODE' && element.parentElement.nodeName === 'PRE') {
+    const childIsP = Array.from(childNodes).every(n => n.nodeName === 'P');
+    if (childIsP) {
+      return Array.from(childNodes).map(n => {
+        return {
+          id: slugid.nice(),
+          type: CODE_LINE,
+          children: [{
+            id: slugid.nice(),
+            text: n.textContent
+          }]
+        };
+      });
+    }
+    const content = element.textContent;
+    const hasNewLine = content.indexOf('\n') > -1;
+    if (!hasNewLine) {
+      return {
+        id: slugid.nice(),
+        type: CODE_LINE,
+        children: [{
+          id: slugid.nice(),
+          text: element.textContent
+        }]
+      };
+    }
+    const codes = content.slugid('\n').filter(Boolean);
+    return codes.map(item => {
+      return {
+        id: slugid.nice(),
+        type: CODE_LINE,
+        children: [{
+          id: slugid.nice(),
+          text: item
+        }]
+      };
+    });
+  }
+  return;
+};
+export default codeBlockRule;

package/dist/slate-convert/html-to-slate/rules/header.js

@@ -0,0 +1,17 @@
+import slugid from 'slugid';
+import { HEADER_LIST, HEADER_TYPE_MAP } from '../constants';
+const headerRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName && HEADER_LIST.includes(nodeName)) {
+    return {
+      id: slugid.nice(),
+      type: HEADER_TYPE_MAP[nodeName],
+      children: parseChild(childNodes)
+    };
+  }
+  return;
+};
+export default headerRule;

package/dist/slate-convert/html-to-slate/rules/image.js

@@ -0,0 +1,22 @@
+import slugid from 'slugid';
+import { IMAGE } from '../constants';
+const imageRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  if (nodeName === 'IMG') {
+    return {
+      id: slugid.nice(),
+      type: IMAGE,
+      data: {
+        src: element.getAttribute('src')
+      },
+      children: [{
+        text: '',
+        id: slugid.nice()
+      }]
+    };
+  }
+  return;
+};
+export default imageRule;

package/dist/slate-convert/html-to-slate/rules/index.js

@@ -0,0 +1,11 @@
+import blockquoteRule from './blockquote';
+import codeBlockRule from './code-block';
+import headerRule from './header';
+import imageRule from './image';
+import linkRule from './link';
+import listRule from './list';
+import paragraphRule from './paragraph';
+import tableRule from './table';
+import textRule from './text';
+const rules = [blockquoteRule, codeBlockRule, headerRule, imageRule, linkRule, listRule, tableRule, paragraphRule, textRule];
+export default rules;

package/dist/slate-convert/html-to-slate/rules/link.js

@@ -0,0 +1,22 @@
+import slugid from 'slugid';
+import { LINK } from '../constants';
+const linkRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  const content = element.textContent || element.getAttribute('title') || element.getAttribute('href');
+  if (nodeName === 'A') {
+    return {
+      id: slugid.nice(),
+      type: LINK,
+      href: element.getAttribute('href'),
+      title: element.getAttribute('title'),
+      children: [{
+        id: slugid.nice(),
+        text: content
+      }]
+    };
+  }
+  return;
+};
+export default linkRule;

package/dist/slate-convert/html-to-slate/rules/list.js

@@ -0,0 +1,50 @@
+import slugid from 'slugid';
+import { LIST_ITEM, ORDERED_LIST, PARAGRAPH, UNORDERED_LIST } from '../constants';
+const PARAGRAPH_TAGS = ['DIV', 'P'];
+const listRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'UL') {
+    return {
+      id: slugid.nice(),
+      type: UNORDERED_LIST,
+      children: parseChild(childNodes)
+    };
+  }
+  if (nodeName === 'OL') {
+    return {
+      id: slugid.nice(),
+      type: ORDERED_LIST,
+      children: parseChild(childNodes)
+    };
+  }
+  if (nodeName === 'LI' && PARAGRAPH_TAGS.includes(element.firstChild.nodeName)) {
+    return {
+      id: slugid.nice(),
+      type: LIST_ITEM,
+      children: parseChild(childNodes)
+    };
+  }
+  if (nodeName === 'LI' && !PARAGRAPH_TAGS.includes(element.firstChild.nodeName)) {
+    return {
+      id: slugid.nice(),
+      type: LIST_ITEM,
+      children: [{
+        id: slugid.nice(),
+        type: PARAGRAPH,
+        children: parseChild(childNodes)
+      }]
+    };
+  }
+  if (PARAGRAPH_TAGS.includes(nodeName) && element.parentElement.nodeName === 'LI') {
+    return {
+      id: slugid.nice(),
+      type: PARAGRAPH,
+      children: parseChild(childNodes)
+    };
+  }
+  return;
+};
+export default listRule;

package/dist/slate-convert/html-to-slate/rules/paragraph.js

@@ -0,0 +1,17 @@
+import slugid from 'slugid';
+import { PARAGRAPH } from '../constants';
+const paragraphRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'P' && element.parentElement.nodeName !== 'LI') {
+    return {
+      id: slugid.nice(),
+      type: PARAGRAPH,
+      children: parseChild(childNodes)
+    };
+  }
+  return;
+};
+export default paragraphRule;

package/dist/slate-convert/html-to-slate/rules/table.js

@@ -0,0 +1,38 @@
+import slugid from 'slugid';
+import { TABLE, TABLE_CELL, TABLE_ROW } from '../constants';
+const tableRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'TABLE') {
+    return {
+      id: slugid.nice(),
+      type: TABLE,
+      children: parseChild(childNodes)
+    };
+  }
+  if (nodeName === 'THEAD' || nodeName === 'TBODY') {
+    return parseChild(childNodes);
+  }
+  if (nodeName === 'TR' && childNodes.length > 0) {
+    // patch
+    const children = Array.from(childNodes);
+    const hasTdOrTh = children.some(item => item.nodeName === 'TH' || item.nodeName === 'TD');
+    if (!hasTdOrTh) return;
+    return {
+      id: slugid.nice(),
+      type: TABLE_ROW,
+      children: parseChild(childNodes)
+    };
+  }
+  if (nodeName === 'TH' || nodeName === 'TD') {
+    return {
+      id: slugid.nice(),
+      type: TABLE_CELL,
+      children: parseChild(childNodes)
+    };
+  }
+  return;
+};
+export default tableRule;

package/dist/slate-convert/html-to-slate/rules/text.js

@@ -0,0 +1,56 @@
+import slugid from 'slugid';
+const textRule = (element, parseChild) => {
+  const {
+    nodeName,
+    nodeType
+  } = element;
+  if (nodeName === 'SPAN') {
+    return {
+      id: slugid.nice(),
+      text: element.textContent
+    };
+  }
+  if (nodeName === 'STRONG' || nodeName === 'B') {
+    return {
+      id: slugid.nice(),
+      bold: true,
+      text: element.textContent
+    };
+  }
+  if (nodeName === 'CODE' && element.parentElement.nodeName !== 'PRE') {
+    return {
+      id: slugid.nice(),
+      code: true,
+      text: element.textContent
+    };
+  }
+  if (nodeName === 'DEL') {
+    return {
+      id: slugid.nice(),
+      delete: true,
+      text: element.textContent
+    };
+  }
+  if (nodeName === 'I') {
+    return {
+      id: slugid.nice(),
+      italic: true,
+      text: element.textContent
+    };
+  }
+  if (nodeName === 'INS') {
+    return {
+      id: slugid.nice(),
+      add: true,
+      text: element.textContent
+    };
+  }
+  if (nodeType === 3) {
+    return {
+      id: slugid.nice(),
+      text: element.textContent
+    };
+  }
+  return;
+};
+export default textRule;

package/dist/slate-convert/index.js

@@ -0,0 +1,8 @@
+import mdStringToSlate from './md-to-slate';
+import slateToMdString from './slate-to-md';
+import processor from './md-to-html';
+import deserializeHtml from './html-to-slate';
+export { mdStringToSlate, slateToMdString, processor,
+// md string to html
+deserializeHtml // html -> slate notes
+};

package/dist/slate-convert/md-to-html/index.js

@@ -0,0 +1,48 @@
+import { unified } from 'unified';
+import markdown from 'remark-parse';
+import gfm from 'remark-gfm';
+import math from 'remark-math';
+import breaks from 'remark-breaks';
+import remarkRehype from 'remark-rehype';
+import mathjax from 'rehype-mathjax/browser';
+import rehypeSlug from 'rehype-slug';
+import rehypeRaw from 'rehype-raw';
+import rehypeFormat from 'rehype-format';
+import rehypeSanitize from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+import sanitizeSchema from './sanitize-schema';
+
+// mdString -> mdast -> html ast -> html
+const processor = unified()
+// Handles markdown basic syntax
+// https://github.com/remarkjs/remark/tree/main
+.use(markdown)
+// Handle markdown extension syntax
+// https://github.com/remarkjs/remark-gfm
+.use(gfm)
+// https://github.com/remarkjs/remark-math
+.use(math)
+// https://github.com/remarkjs/remark-breaks
+.use(breaks).use(remarkRehype, {
+  allowDangerousHtml: true
+}) // convert mdast -> hast
+// https://www.npmjs.com/package/rehype-mathjax
+.use(mathjax, {
+  displayMath: ['$$', '$$']
+})
+// https://www.npmjs.com/package/rehype-raw
+.use(rehypeRaw)
+// https://www.npmjs.com/package/rehype-format
+.use(rehypeFormat, {
+  blanks: ['pre', 'code']
+})
+// https://github.com/rehypejs/rehype-slug
+.use(rehypeSlug)
+// https://github.com/rehypejs/rehype-sanitize
+.use(rehypeSanitize, sanitizeSchema)
+// https://github.com/rehypejs/rehype/tree/main/packages/rehype-stringify
+.use(rehypeStringify);
+
+// transform rules: https://github.com/syntax-tree/mdast-util-to-hast
+
+export default processor;

package/dist/slate-convert/md-to-html/sanitize-schema.js

@@ -0,0 +1,17 @@
+import deepmerge from 'deepmerge';
+import { defaultSchema } from 'hast-util-sanitize';
+const customSchema = {
+  'tagNames': ['input', 'code', 'span', 'div', 'blockquote', 'pre'],
+  'attributes': {
+    'input': ['type'],
+    'li': ['className'],
+    'code': ['className'],
+    'span': ['className'],
+    'div': ['className']
+  },
+  'protocols': {
+    'src': ['http', 'https', 'cid']
+  }
+};
+const sanitizeSchema = deepmerge(defaultSchema, customSchema);
+export default sanitizeSchema;

package/dist/slate-convert/md-to-slate/index.js

@@ -0,0 +1,38 @@
+import { unified } from 'unified';
+import markdown from 'remark-parse';
+import gfm from 'remark-gfm';
+import math from 'remark-math';
+import { generateDefaultParagraph } from '../../basic-sdk/extension/core';
+import { formatMdToSlate } from './transform';
+
+// md string -> md ast
+const getProcessor = () => {
+  const processor = unified().use(markdown) // Handles markdown basic syntax
+  .use(gfm) // Handle markdown extension syntax
+  .use(math); // Handles markdown math formulas
+
+  return processor;
+};
+const reconciledSlateNodes = nodes => {
+  return nodes;
+};
+
+// md string --> md ast --> slate ast
+// https://github.com/syntax-tree/mdast
+const mdStringToSlate = mdString => {
+  if (!mdString) return [generateDefaultParagraph()];
+  let content = mdString;
+  if (typeof mdString === 'number') {
+    content = mdString + '';
+  }
+
+  // md string --> md ast
+  const root = getProcessor().parse(content);
+
+  // md ast --> slate ast
+  const slateNodes = formatMdToSlate(root.children);
+
+  // Format the document
+  return reconciledSlateNodes(slateNodes);
+};
+export default mdStringToSlate;