@seafile/sea-email-editor 0.0.1

package/dist/extension/core/utils/index.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.match = exports.isEmptyParagraph = exports.generateHeaderElement = exports.generateEmptyElement = exports.generateElement = exports.generateDefaultText = exports.generateDefaultParagraph = exports.Placeholder = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("@/constants");
+var _elementTypes = require("../../constants/element-types");
+var _jsxRuntime = require("react/jsx-runtime");
+const match = (node, path, predicate) => {
+  if (!predicate) return true;
+  if (typeof predicate === 'object') {
+    return Object.entries(predicate).every(_ref => {
+      let [key, value] = _ref;
+      if (value && !Array.isArray(value)) {
+        return node[key] === value;
+      }
+      value = value ? value : [];
+      return value.includes(node[key]);
+    });
+  }
+  return predicate(node, path);
+};
+exports.match = match;
+const generateDefaultText = () => {
+  return {
+    id: _slugid.default.nice(),
+    text: ''
+  };
+};
+exports.generateDefaultText = generateDefaultText;
+const generateDefaultParagraph = () => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.PARAGRAPH,
+    children: [generateDefaultText()]
+  };
+};
+exports.generateDefaultParagraph = generateDefaultParagraph;
+const generateEmptyElement = type => {
+  return {
+    id: _slugid.default.nice(),
+    type,
+    children: [generateDefaultText()]
+  };
+};
+exports.generateEmptyElement = generateEmptyElement;
+const generateHeaderElement = text => {
+  const headerText = {
+    id: _slugid.default.nice(),
+    text: text
+  };
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.HEADER1,
+    children: [headerText]
+  };
+};
+
+/**
+ * @param {String} type
+ * @param {Object} options
+ * @param {Node[] | String} [options.childrenOrText = ''] If provide a string,that will generate a text node as children automatically
+ * @param {object} [options.props = {}]
+ * @returns {Node}
+ */
+exports.generateHeaderElement = generateHeaderElement;
+const generateElement = function (type) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let {
+    childrenOrText = '',
+    props = {}
+  } = options;
+  if (typeof childrenOrText === 'string') {
+    childrenOrText = [{
+      id: _slugid.default.nice(),
+      text: childrenOrText
+    }];
+  }
+  if (!Array.isArray(childrenOrText)) {
+    throw Error('childrenOrText must be a string or a Node array!');
+  }
+  return {
+    id: _slugid.default.nice(),
+    type,
+    children: childrenOrText,
+    ...props
+  };
+};
+exports.generateElement = generateElement;
+const isEmptyParagraph = node => {
+  if (node.type !== 'paragraph') return false;
+  if (node.children.length !== 1) return false;
+  const [child] = node.children;
+  if (Text.isText(child) && child.text === '' && child.type !== 'image') return true;
+  return false;
+};
+exports.isEmptyParagraph = isEmptyParagraph;
+const Placeholder = props => {
+  const {
+    title
+  } = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+    style: {
+      position: 'absolute',
+      top: '0px',
+      color: 'rgba(191,191,191,1)',
+      pointerEvents: 'none',
+      width: '100%',
+      maxWidth: '100%',
+      display: 'block',
+      userSelect: 'none',
+      textDecoration: 'none'
+    },
+    children: (0, _constants.gettext)(title)
+  });
+};
+exports.Placeholder = Placeholder;

package/dist/extension/event-transfer/get-event-transfer.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const getEventTransfer = data => {
+  const fragmentString = data.getData('application/x-slate-fragment');
+  const textContent = data.getData('text') || data.getData('text/plain') || '';
+  let fragmentContent = fragmentString ? JSON.parse(decodeURIComponent(window.atob(fragmentString))) : null;
+  const htmlContent = data.getData('text/html') || '';
+  const hasRtfContent = data.types.includes('text/rtf');
+
+  /**
+   *  compat old version slate: if clipboard content is old version slate fragment
+   *  return  html content
+   */
+  const files = data.files;
+  let type = 'text';
+  // Paste rtf format content which copied from PPT or Word or Excel as text to document
+  if (hasRtfContent) {
+    type = 'text';
+  } else if (files.length > 0) {
+    type = 'file';
+  } else if (fragmentContent && Array.isArray(fragmentContent)) {
+    type = 'fragment';
+  } else if (htmlContent) {
+    type = 'html';
+  }
+  return {
+    text: textContent,
+    html: htmlContent,
+    fragment: fragmentContent,
+    type,
+    files: files
+  };
+};
+var _default = exports.default = getEventTransfer;

package/dist/extension/event-transfer/set-event-transfer.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+const TRANSFER_TYPES = {
+  fragment: 'application/x-slate-fragment',
+  html: 'text/html',
+  text: 'text/plain'
+};
+
+// transform slate fragment and write to clipboard
+function setEventTransfer(event, type, content) {
+  const mime = TRANSFER_TYPES[type];
+  const transfer = event.dataTransfer || event.clipboardData;
+  if (type === 'fragment') {
+    // use the same encoding as slate
+    const encodedContent = window.btoa(encodeURIComponent(JSON.stringify(content)));
+    transfer.setData(mime, encodedContent);
+    let texts = '';
+    let textItem = '';
+    content.forEach(element => {
+      textItem = _slate.Node.string(element).replace(/\ufeff/, '');
+      texts += textItem + '\r\n';
+    });
+    transfer.setData('text', texts);
+  } else if (type === 'html') {
+    transfer.setData(mime, content);
+    transfer.setData('text', transfer.getData('text'));
+  } else {
+    transfer.setData('text', content);
+  }
+}
+var _default = exports.default = setEventTransfer;

package/dist/extension/highlight/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SetNodeToDecorations", {
+  enumerable: true,
+  get: function () {
+    return _setNodeDecorations.default;
+  }
+});
+Object.defineProperty(exports, "useHighlight", {
+  enumerable: true,
+  get: function () {
+    return _useHighlight.default;
+  }
+});
+var _setNodeDecorations = _interopRequireDefault(require("./set-node-decorations"));
+var _useHighlight = _interopRequireDefault(require("./use-highlight"));

package/dist/extension/highlight/normalize-tokens.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeTokens = void 0;
+const newlineRe = /\r\n|\r|\n/;
+const normalizeEmptyLines = line => {
+  if (line.length === 0) {
+    line.push({
+      types: ['plain'],
+      content: '\n',
+      empty: true
+    });
+  } else if (line.length === 1 && line[0].content === '') {
+    line[0].content = '\n';
+    line[0].empty = true;
+  }
+};
+const appendTypes = (types, add) => {
+  const typesSize = types.length;
+  if (typesSize > 0 && types[typesSize - 1] === add) {
+    return types;
+  }
+  return types.concat(add);
+};
+const normalizeTokens = tokens => {
+  const typeArrStack = [[]];
+  const tokenArrStack = [tokens];
+  const tokenArrIndexStack = [0];
+  const tokenArrSizeStack = [tokens.length];
+  let i = 0;
+  let stackIndex = 0;
+  let currentLine = [];
+  const acc = [currentLine];
+  while (stackIndex > -1) {
+    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
+      let content;
+      let types = typeArrStack[stackIndex];
+      const tokenArr = tokenArrStack[stackIndex];
+      const token = tokenArr[i];
+
+      // Determine content and append type to types if necessary
+      if (typeof token === 'string') {
+        types = stackIndex > 0 ? types : ['plain'];
+        content = token;
+      } else {
+        types = appendTypes(types, token.type);
+        if (token.alias) {
+          types = appendTypes(types, token.alias);
+        }
+        content = token.content;
+      }
+
+      // If token.content is an array, increase the stack depth and repeat this while-loop
+      if (typeof content !== 'string') {
+        stackIndex++;
+        typeArrStack.push(types);
+        tokenArrStack.push(content);
+        tokenArrIndexStack.push(0);
+        tokenArrSizeStack.push(content.length);
+        continue;
+      }
+
+      // Split by newlines
+      const splitByNewlines = content.split(newlineRe);
+      const newlineCount = splitByNewlines.length;
+      currentLine.push({
+        types,
+        content: splitByNewlines[0]
+      });
+
+      // Create a new line for each string on a new line
+      for (let i = 1; i < newlineCount; i++) {
+        normalizeEmptyLines(currentLine);
+        acc.push(currentLine = []);
+        currentLine.push({
+          types,
+          content: splitByNewlines[i]
+        });
+      }
+    }
+
+    // Decreate the stack depth
+    stackIndex--;
+    typeArrStack.pop();
+    tokenArrStack.pop();
+    tokenArrIndexStack.pop();
+    tokenArrSizeStack.pop();
+  }
+  normalizeEmptyLines(currentLine);
+  return acc;
+};
+exports.normalizeTokens = normalizeTokens;

package/dist/extension/highlight/prismjs.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _prismjs = _interopRequireDefault(require("prismjs"));
+require("prismjs/themes/prism.css");
+require("prismjs/components/prism-javascript");
+require("prismjs/components/prism-typescript");
+require("prismjs/components/prism-markup");
+require("prismjs/components/prism-markup-templating");
+require("prismjs/components/prism-go");
+require("prismjs/components/prism-php");
+require("prismjs/components/prism-c");
+require("prismjs/components/prism-python");
+require("prismjs/components/prism-java");
+require("prismjs/components/prism-cpp");
+require("prismjs/components/prism-csharp");
+require("prismjs/components/prism-sql");
+require("prismjs/components/prism-ruby");
+require("prismjs/components/prism-swift");
+require("prismjs/components/prism-bash");
+require("prismjs/components/prism-lua");
+require("prismjs/components/prism-json");
+var _default = exports.default = _prismjs.default;

package/dist/extension/highlight/set-node-decorations.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _slateReact = require("slate-react");
+var _elementTypes = require("../constants/element-types");
+var _prismjs = _interopRequireDefault(require("./prismjs"));
+var _normalizeTokens = require("./normalize-tokens");
+var _constant = require("../plugins/code-block/render-elem/constant");
+const mergeMaps = function () {
+  const map = new Map();
+  for (var _len = arguments.length, maps = new Array(_len), _key = 0; _key < _len; _key++) {
+    maps[_key] = arguments[_key];
+  }
+  for (const m of maps) {
+    for (const item of m) {
+      map.set(...item);
+    }
+  }
+  return map;
+};
+const getChildNodeToDecorations = _ref => {
+  let [block, blockPath] = _ref;
+  const nodeToDecorations = new Map();
+  const text = block.children.map(line => _slate.Node.string(line)).join('\n');
+  const language = _constant.LANGUAGE_MAP[block.lang] ? block.lang : 'text';
+  const tokens = _prismjs.default.tokenize(text, _prismjs.default.languages[language]);
+  const normalizedTokens = (0, _normalizeTokens.normalizeTokens)(tokens); // make tokens flat and grouped by line
+  const blockChildren = block.children;
+  for (let index = 0; index < normalizedTokens.length; index++) {
+    const tokens = normalizedTokens[index];
+    const element = blockChildren[index];
+    if (element) {
+      if (!nodeToDecorations.has(element)) {
+        nodeToDecorations.set(element, []);
+      }
+    }
+    let start = 0;
+    for (const token of tokens) {
+      const length = token.content.length;
+      if (!length) {
+        continue;
+      }
+      const end = start + length;
+      const path = [...blockPath, index, 0];
+      const range = {
+        anchor: {
+          path,
+          offset: start
+        },
+        focus: {
+          path,
+          offset: end
+        },
+        token: true,
+        ...Object.fromEntries(token.types.map(type => [type, true]))
+      };
+      if (nodeToDecorations.get(element)) {
+        nodeToDecorations.get(element).push(range);
+      }
+      start = end;
+    }
+  }
+  return nodeToDecorations;
+};
+const SetNodeToDecorations = () => {
+  const editor = (0, _slateReact.useSlate)();
+  const blockEntries = Array.from(_slate.Editor.nodes(editor, {
+    at: [],
+    mode: 'highest',
+    match: n => _slate.Element.isElement(n) && n.type === _elementTypes.CODE_BLOCK
+  }));
+  const nodeToDecorations = mergeMaps(...blockEntries.map(getChildNodeToDecorations));
+  editor.nodeToDecorations = nodeToDecorations;
+  return null;
+};
+var _default = exports.default = SetNodeToDecorations;

package/dist/extension/highlight/use-highlight.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHighlight = exports.default = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../constants/element-types");
+const useHighlight = editor => _ref => {
+  let [node, path] = _ref;
+  let ranges = [];
+  if (_slate.Element.isElement(node) && node.type === _elementTypes.CODE_LINE) {
+    var _editor$nodeToDecorat;
+    ranges = (editor === null || editor === void 0 ? void 0 : (_editor$nodeToDecorat = editor.nodeToDecorations) === null || _editor$nodeToDecorat === void 0 ? void 0 : _editor$nodeToDecorat.get(node)) || [];
+    return ranges;
+  }
+  return ranges;
+};
+exports.useHighlight = useHighlight;
+var _default = exports.default = useHighlight;

package/dist/extension/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ElementTypes", {
+  enumerable: true,
+  get: function () {
+    return _constants.ElementTypes;
+  }
+});
+Object.defineProperty(exports, "Plugins", {
+  enumerable: true,
+  get: function () {
+    return _plugins.default;
+  }
+});
+Object.defineProperty(exports, "SetNodeToDecorations", {
+  enumerable: true,
+  get: function () {
+    return _highlight.SetNodeToDecorations;
+  }
+});
+Object.defineProperty(exports, "Toolbar", {
+  enumerable: true,
+  get: function () {
+    return _toolbar.default;
+  }
+});
+Object.defineProperty(exports, "getNodePathById", {
+  enumerable: true,
+  get: function () {
+    return _core.getNodePathById;
+  }
+});
+Object.defineProperty(exports, "isEmptyParagraph", {
+  enumerable: true,
+  get: function () {
+    return _core.isEmptyParagraph;
+  }
+});
+Object.defineProperty(exports, "renderElement", {
+  enumerable: true,
+  get: function () {
+    return _renderElement.default;
+  }
+});
+Object.defineProperty(exports, "renderLeaf", {
+  enumerable: true,
+  get: function () {
+    return _renderLeaf.default;
+  }
+});
+Object.defineProperty(exports, "useHighlight", {
+  enumerable: true,
+  get: function () {
+    return _highlight.useHighlight;
+  }
+});
+var _constants = require("./constants");
+var _core = require("./core");
+var _highlight = require("./highlight");
+var _renderElement = _interopRequireDefault(require("./render/render-element"));
+var _renderLeaf = _interopRequireDefault(require("./render/render-leaf"));
+var _toolbar = _interopRequireDefault(require("./toolbar"));
+var _plugins = _interopRequireDefault(require("./plugins"));

package/dist/extension/plugins/blockquote/helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setBlockQuoteType = exports.isMenuDisabled = exports.getBlockQuoteType = void 0;
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _elementTypes = require("../../constants/element-types");
+var _core = require("../../core");
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
+    match: n => {
+      const type = (0, _core.getNodeType)(n);
+
+      // Only available for p and blockquote
+      if (type === _elementTypes.PARAGRAPH) return true;
+      if (type === _elementTypes.BLOCKQUOTE) return true;
+      if (type === _elementTypes.UNORDERED_LIST) return true;
+      if (type === _elementTypes.ORDERED_LIST) return true;
+      if (type === _elementTypes.CHECK_LIST_ITEM) return true;
+      if (type && type.startWith && type.startWith('header')) return true;
+      if (type === _elementTypes.IMAGE) return true;
+      return false;
+    },
+    universal: true,
+    mode: 'highest' // Match top level
+  });
+
+  // Match to p blockquote, do not disable
+  if (nodeEntry) {
+    return false;
+  }
+  return true;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getBlockQuoteType = editor => {
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => (0, _core.getNodeType)(n) === _elementTypes.BLOCKQUOTE,
+    universal: true
+  });
+  if (!match) return _elementTypes.PARAGRAPH;
+  const [n] = match;
+  return (0, _core.getNodeType)(n);
+};
+exports.getBlockQuoteType = getBlockQuoteType;
+const setBlockQuoteType = (editor, active) => {
+  if (!active) {
+    const blockquoteNode = {
+      id: _slugid.default.nice(),
+      type: _elementTypes.BLOCKQUOTE
+    };
+    _slate.Transforms.wrapNodes(editor, blockquoteNode, {
+      mode: 'highest',
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+    });
+  } else {
+    _slate.Transforms.unwrapNodes(editor, {
+      mode: 'highest',
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+    });
+  }
+  (0, _core.focusEditor)(editor);
+};
+exports.setBlockQuoteType = setBlockQuoteType;

package/dist/extension/plugins/blockquote/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementTypes = require("../../constants/element-types");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render-elem"));
+const BlockquotePlugin = {
+  type: _elementTypes.BLOCKQUOTE,
+  nodeType: 'element',
+  editorMenus: [],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = BlockquotePlugin;

package/dist/extension/plugins/blockquote/menu/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = BlockquoteMenu;
+var _react = _interopRequireWildcard(require("react"));
+var _components = require("../../../../components");
+var _menusConfig = require("../../../constants/menus-config");
+var _elementTypes = require("../../../constants/element-types");
+var _helpers = require("../helpers");
+var _jsxRuntime = require("react/jsx-runtime");
+const menuConfig = _menusConfig.MENUS_CONFIG_MAP[_elementTypes.BLOCKQUOTE];
+const isActive = editor => {
+  return (0, _helpers.getBlockQuoteType)(editor) === _elementTypes.BLOCKQUOTE;
+};
+function BlockquoteMenu(_ref) {
+  let {
+    className,
+    readonly,
+    editor
+  } = _ref;
+  const onClick = (0, _react.useCallback)(event => {
+    const active = isActive(editor);
+    (0, _helpers.setBlockQuoteType)(editor, active);
+  }, [editor]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ToolbarItem, {
+    className: className,
+    disabled: (0, _helpers.isMenuDisabled)(editor, readonly),
+    isActive: isActive(editor),
+    onClick: onClick,
+    ...menuConfig
+  });
+}