@seafile/sdoc-editor 0.4.35 → 0.4.37

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;