@seafile/sea-email-editor 0.0.10 → 0.0.11

package/dist/editor/main/index.css

@@ -12,6 +12,7 @@
   flex: 1;
   width: 100%;
   padding: 10px;
+  overflow-y: scroll;
 }
 
 .sea-email-editor .sea-email-editor-content *:first-child {

package/dist/editor/main/index.js

@@ -75,13 +75,19 @@ const Main = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
     const [firstNode] = editor.children;
     if (!firstNode) return;
     if (focusRange && focusRange !== null && focusRange !== void 0 && focusRange.anchor) {
-      const startOfFirstNode = _slate.Editor.start(editor, focusRange.anchor.path);
-      const range = {
-        anchor: startOfFirstNode,
-        focus: startOfFirstNode
-      };
-      (0, _core.focusEditor)(editor, range);
-      setTimeout(() => (0, _core.focusEditor)(editor, focusRange), 0);
+      try {
+        const startOfFirstNode = _slate.Editor.start(editor, focusRange.anchor.path);
+        const range = {
+          anchor: startOfFirstNode,
+          focus: startOfFirstNode
+        };
+        (0, _core.focusEditor)(editor, range);
+        setTimeout(() => (0, _core.focusEditor)(editor, focusRange), 0);
+      } catch {
+        focusRangeRef.current = null;
+        focusNode(editor);
+        return;
+      }
       focusRangeRef.current = null;
       return;
     }

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

@@ -10,6 +10,17 @@ var _typeOf = _interopRequireDefault(require("type-of"));
 var _constants = require("./constants");
 var _rules = _interopRequireDefault(require("./rules"));
 var _helper = require("./helper");
+var _dom = require("../../utils/dom");
+const generateDefaultValue = () => {
+  return [{
+    id: _slugid.default.nice(),
+    type: _constants.PARAGRAPH,
+    children: [{
+      text: '',
+      id: _slugid.default.nice()
+    }]
+  }];
+};
 const cruftNewline = element => {
   return !(element.nodeName === '#text' && element.nodeValue === '\n');
 };
@@ -98,14 +109,7 @@ const deserializeElements = function () {
 
 const formatElementNodes = nodes => {
   if (nodes.length === 0) {
-    return [{
-      id: _slugid.default.nice(),
-      type: _constants.PARAGRAPH,
-      children: [{
-        text: '',
-        id: _slugid.default.nice()
-      }]
-    }];
+    return generateDefaultValue();
   }
   nodes = nodes.reduce((memo, node) => {
     if (_constants.TOP_LEVEL_TYPES.includes(node.type)) {
@@ -145,10 +149,9 @@ const formatElementNodes = nodes => {
   return nodes;
 };
 const deserializeHtml = html => {
-  const parsed = new DOMParser().parseFromString(html.replace('\n', '').replace('  ', ''), 'text/html');
-  const fragment = parsed.body;
-  fragment.querySelectorAll('style, title').forEach(el => el.remove());
-  const children = Array.from(fragment.childNodes);
+  const HTMLBody = (0, _dom.parseAndCleanHTML)(html);
+  if (!HTMLBody) return generateDefaultValue();
+  const children = Array.from(HTMLBody.childNodes);
   let nodes = [];
   nodes = deserializeElements(children, true);
   nodes = formatElementNodes(nodes);

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

@@ -13,7 +13,7 @@ const paragraphRule = (element, parseChild) => {
     nodeName,
     childNodes
   } = element;
-  if (nodeName === 'DIV' && element.parentElement.nodeName !== 'LI') {
+  if ((nodeName === 'DIV' || nodeName === 'ARTICLE') && element.parentElement.nodeName !== 'LI') {
     if (childNodes.length === 0) {
       const node = {
         id: _slugid.default.nice(),
@@ -25,10 +25,14 @@ const paragraphRule = (element, parseChild) => {
       };
       return (0, _helper.mergeElementOther2SlateNode)(element, node);
     }
+    const children = parseChild(childNodes);
     const node = {
       id: _slugid.default.nice(),
       type: _constants.PARAGRAPH,
-      children: parseChild(childNodes)
+      children: children.length === 0 ? [{
+        id: _slugid.default.nice(),
+        text: ''
+      }] : children
     };
     return (0, _helper.mergeElementOther2SlateNode)(element, node);
   }

package/dist/utils/common.js

@@ -33,8 +33,10 @@ const isUrl = url => {
 // Check document is empty or only contains void nodes
 exports.isUrl = isUrl;
 const isDocumentEmpty = editor => {
-  const document = editor.children;
+  const document = editor === null || editor === void 0 ? void 0 : editor.children;
+  if (!Array.isArray(document) || document.length === 0) return true;
   const [firstChildNode] = document;
+  if (!firstChildNode || !Array.isArray(firstChildNode.children)) return true;
   // Check if document has only one block node
   const isWrapperEmpty = document.length === 1 && _slate.Node.string(firstChildNode).length === 0;
   if (!isWrapperEmpty) return false;

package/dist/utils/dom.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.addClass = addClass;
 exports.getTarget = exports.getEventClassName = exports.getDataAttr = exports.canUseDOM = exports.addClassName = void 0;
 exports.hasClass = hasClass;
-exports.isNearBottom = exports.isInputOrEditorActive = void 0;
+exports.parseAndCleanHTML = exports.isNearBottom = exports.isInputOrEditorActive = void 0;
 exports.removeClass = removeClass;
 exports.removeClassName = void 0;
+var _typeDetection = require("./type-detection");
 const canUseDOM = exports.canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
 const getEventClassName = e => {
   // svg mouseEvent event.target.className is an object
@@ -130,4 +131,318 @@ const isNearBottom = function (element) {
   const distanceToBottom = scrollHeight - (scrollTop + clientHeight);
   return distanceToBottom <= threshold;
 };
-exports.isNearBottom = isNearBottom;
+exports.isNearBottom = isNearBottom;
+const cleanWhiteSpace = function () {
+  let html = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return html.replace(/\s*[\n\t\r]+\s*/g, '');
+};
+const removeInvalidNodes = root => {
+  if (!root || !root.querySelectorAll) return;
+  const elementsToRemove = root.querySelectorAll('style, title, script, link[rel="stylesheet"]');
+  elementsToRemove.forEach(element => {
+    element.remove();
+  });
+  for (let i = root.childNodes.length - 1; i >= 0; i--) {
+    const child = root.childNodes[i];
+    if (child.nodeType === Node.COMMENT_NODE) {
+      root.removeChild(child);
+    } else if (child.nodeType === Node.ELEMENT_NODE) {
+      removeInvalidNodes(child);
+    }
+  }
+};
+const stripCSSComments = function () {
+  let cssText = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return cssText.replace(/\/\*[\s\S]*?\*\//g, '');
+};
+const splitByDelimiter = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let delimiter = arguments.length > 1 ? arguments[1] : undefined;
+  const parts = [];
+  let buffer = '';
+  let quote = '';
+  let roundDepth = 0;
+  let squareDepth = 0;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    const prevChar = value[i - 1];
+    if (quote) {
+      buffer += char;
+      if (char === quote && prevChar !== '\\') {
+        quote = '';
+      }
+      continue;
+    }
+    if (char === '"' || char === '\'') {
+      quote = char;
+      buffer += char;
+      continue;
+    }
+    if (char === '(') {
+      roundDepth += 1;
+      buffer += char;
+      continue;
+    }
+    if (char === ')') {
+      roundDepth = Math.max(0, roundDepth - 1);
+      buffer += char;
+      continue;
+    }
+    if (char === '[') {
+      squareDepth += 1;
+      buffer += char;
+      continue;
+    }
+    if (char === ']') {
+      squareDepth = Math.max(0, squareDepth - 1);
+      buffer += char;
+      continue;
+    }
+    if (char === delimiter && roundDepth === 0 && squareDepth === 0) {
+      parts.push(buffer);
+      buffer = '';
+      continue;
+    }
+    buffer += char;
+  }
+  if (buffer) {
+    parts.push(buffer);
+  }
+  return parts;
+};
+const findMatchingParenIndex = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let quote = '';
+  let depth = 0;
+  for (let i = startIndex; i < value.length; i++) {
+    const char = value[i];
+    const prevChar = value[i - 1];
+    if (quote) {
+      if (char === quote && prevChar !== '\\') {
+        quote = '';
+      }
+      continue;
+    }
+    if (char === '"' || char === '\'') {
+      quote = char;
+      continue;
+    }
+    if (char === '(') {
+      depth += 1;
+      continue;
+    }
+    if (char === ')') {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+};
+const getInlineStyleState = element => {
+  const properties = [];
+  for (let i = 0; i < element.style.length; i++) {
+    properties.push(element.style[i]);
+  }
+  return properties.reduce((state, property) => {
+    state[property] = {
+      value: element.style.getPropertyValue(property),
+      priority: element.style.getPropertyPriority(property),
+      specificity: 1000,
+      order: Number.MAX_SAFE_INTEGER
+    };
+    return state;
+  }, {});
+};
+const compareStylePriority = (currentStyle, nextStyle) => {
+  if (!currentStyle) return true;
+  const currentImportant = currentStyle.priority === 'important';
+  const nextImportant = nextStyle.priority === 'important';
+  if (currentImportant !== nextImportant) {
+    return nextImportant;
+  }
+  if (currentStyle.specificity !== nextStyle.specificity) {
+    return nextStyle.specificity > currentStyle.specificity;
+  }
+  return nextStyle.order >= currentStyle.order;
+};
+const applyStyleDeclarations = function (element) {
+  let declarationText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let metadata = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let styleStateMap = arguments.length > 3 ? arguments[3] : undefined;
+  if (!element || !declarationText) return;
+  const styleState = styleStateMap.get(element) || getInlineStyleState(element);
+  splitByDelimiter(declarationText, ';').forEach(declaration => {
+    const separatorIndex = declaration.indexOf(':');
+    if (separatorIndex < 0) return;
+    const property = declaration.slice(0, separatorIndex).trim();
+    let value = declaration.slice(separatorIndex + 1).trim();
+    if (!property || !value) return;
+    let priority = '';
+    if (/!important\s*$/i.test(value)) {
+      priority = 'important';
+      value = value.replace(/\s*!important\s*$/i, '').trim();
+    }
+    const nextStyle = {
+      value,
+      priority,
+      specificity: metadata.specificity || 0,
+      order: metadata.order || 0
+    };
+    if (compareStylePriority(styleState[property], nextStyle)) {
+      styleState[property] = nextStyle;
+    }
+  });
+  styleStateMap.set(element, styleState);
+};
+const calculateSelectorSpecificity = function () {
+  let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  const pseudoFunctionNames = ['is', 'not', 'has', 'where'];
+  let normalizedSelector = selector.replace(/::[\w-]+/g, ' ');
+  let pseudoSpecificity = 0;
+  pseudoFunctionNames.forEach(pseudoName => {
+    const token = `:${pseudoName}(`;
+    let tokenIndex = normalizedSelector.indexOf(token);
+    while (tokenIndex > -1) {
+      const contentStartIndex = tokenIndex + token.length - 1;
+      const contentEndIndex = findMatchingParenIndex(normalizedSelector, contentStartIndex);
+      if (contentEndIndex < 0) break;
+      const content = normalizedSelector.slice(contentStartIndex + 1, contentEndIndex);
+      if (pseudoName !== 'where') {
+        const specificityList = splitByDelimiter(content, ',').map(item => calculateSelectorSpecificity(item.trim())).filter(Boolean);
+        pseudoSpecificity += specificityList.length > 0 ? Math.max(...specificityList) : 0;
+      }
+      normalizedSelector = normalizedSelector.slice(0, tokenIndex) + ' ' + normalizedSelector.slice(contentEndIndex + 1);
+      tokenIndex = normalizedSelector.indexOf(token);
+    }
+  });
+  const idCount = (normalizedSelector.match(/#[\w-]+/g) || []).length;
+  const classCount = (normalizedSelector.match(/\.[\w-]+/g) || []).length;
+  const attributeCount = (normalizedSelector.match(/\[[^\]]+\]/g) || []).length;
+  const pseudoClassCount = (normalizedSelector.match(/:(?!:)[\w-]+(?:\([^)]*\))?/g) || []).length;
+  const elementSelector = normalizedSelector.replace(/#[\w-]+/g, ' ').replace(/\.[\w-]+/g, ' ').replace(/\[[^\]]+\]/g, ' ').replace(/:(?!:)[\w-]+(?:\([^)]*\))?/g, ' ').replace(/[>+~*]/g, ' ');
+  const typeCount = (elementSelector.match(/(^|\s)[a-zA-Z][\w-]*/g) || []).length;
+  return pseudoSpecificity + idCount * 100 + (classCount + attributeCount + pseudoClassCount) * 10 + typeCount;
+};
+const applyCollectedStyles = styleStateMap => {
+  styleStateMap.forEach((styleState, element) => {
+    const properties = Object.keys(styleState);
+    element.removeAttribute('style');
+    properties.forEach(property => {
+      const item = styleState[property];
+      if (!(item !== null && item !== void 0 && item.value)) return;
+      element.style.setProperty(property, item.value, item.priority);
+    });
+  });
+};
+const splitCSSBlocks = function () {
+  let cssText = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  const blocks = [];
+  let buffer = '';
+  let depth = 0;
+  let quote = '';
+  let roundDepth = 0;
+  for (let i = 0; i < cssText.length; i++) {
+    const char = cssText[i];
+    const prevChar = cssText[i - 1];
+    buffer += char;
+    if (quote) {
+      if (char === quote && prevChar !== '\\') {
+        quote = '';
+      }
+      continue;
+    }
+    if (char === '"' || char === '\'') {
+      quote = char;
+      continue;
+    }
+    if (char === '(') {
+      roundDepth += 1;
+      continue;
+    }
+    if (char === ')') {
+      roundDepth = Math.max(0, roundDepth - 1);
+      continue;
+    }
+    if (roundDepth > 0) {
+      continue;
+    }
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        blocks.push(buffer.trim());
+        buffer = '';
+      }
+    }
+  }
+  return blocks;
+};
+const inlineCSSRules = function (root) {
+  let cssText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let styleStateMap = arguments.length > 2 ? arguments[2] : undefined;
+  let context = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
+    order: 0
+  };
+  const normalizedCSS = stripCSSComments(cssText).trim();
+  if (!normalizedCSS) return;
+  splitCSSBlocks(normalizedCSS).forEach(block => {
+    const startIndex = block.indexOf('{');
+    const endIndex = block.lastIndexOf('}');
+    if (startIndex < 0 || endIndex < 0 || endIndex <= startIndex) return;
+    const selectorText = block.slice(0, startIndex).trim();
+    const declarationText = block.slice(startIndex + 1, endIndex).trim();
+    if (!selectorText || !declarationText) return;
+    if (selectorText.startsWith('@')) {
+      if (declarationText.includes('{')) {
+        inlineCSSRules(root, declarationText, styleStateMap, context);
+      }
+      return;
+    }
+    splitByDelimiter(selectorText, ',').forEach(selector => {
+      const normalizedSelector = selector.trim();
+      if (!normalizedSelector) return;
+      try {
+        const metadata = {
+          specificity: calculateSelectorSpecificity(normalizedSelector),
+          order: context.order++
+        };
+        root.querySelectorAll(normalizedSelector).forEach(element => {
+          applyStyleDeclarations(element, declarationText, metadata, styleStateMap);
+        });
+      } catch {
+        // Ignore selectors that cannot be queried, such as pseudo-elements.
+      }
+    });
+  });
+};
+const convertStyleToInlineStyle = parsed => {
+  const styleStateMap = new Map();
+  const context = {
+    order: 0
+  };
+  parsed.querySelectorAll('style').forEach(styleElement => {
+    inlineCSSRules(parsed, styleElement.textContent || '', styleStateMap, context);
+  });
+  applyCollectedStyles(styleStateMap);
+};
+const parseAndCleanHTML = function () {
+  let html = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  if (!html) return null;
+  if ((0, _typeDetection.isNumber)(html)) {
+    html = String(html);
+  }
+  if (!(0, _typeDetection.isString)(html)) return null;
+  const sanitizedHTML = cleanWhiteSpace(html);
+  const parsed = new DOMParser().parseFromString(sanitizedHTML, 'text/html');
+  convertStyleToInlineStyle(parsed);
+  const body = parsed.body;
+  removeInvalidNodes(body);
+  return body;
+};
+exports.parseAndCleanHTML = parseAndCleanHTML;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seafile/sea-email-editor",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "A Slate-based rich email editor with HTML, markdown, tables, images, links, and block plugins.",
   "main": "dist/index.js",
   "dependencies": {