@lobehub/editor 1.17.0 → 1.17.2

package/es/plugins/common/plugin/index.js

@@ -24,7 +24,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { registerDragonSupport } from '@lexical/dragon';
 import { createEmptyHistoryState, registerHistory } from '@lexical/history';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from '@lexical/rich-text';
-import { $createLineBreakNode, $createParagraphNode, $isTextNode } from 'lexical';
+import { $createLineBreakNode, $createParagraphNode, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService, isPunctuationChar } from "../../markdown";
 import { registerCommands } from "../command";
@@ -82,7 +82,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       // Parse markdown options
       var markdownOption = (_this$config$markdown = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.markdownOption) !== null && _this$config$markdown !== void 0 ? _this$config$markdown : true;
       var isMarkdownEnabled = markdownOption !== false;
-      var softBreak = isMarkdownEnabled ? '\n\n' : '\n';
+      var breakMark = isMarkdownEnabled ? '\n\n' : '\n';
 
       // Determine which formats are enabled
       var formats = {
@@ -189,11 +189,11 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         markdownService.registerMarkdownShortCuts(textFormatShortcuts);
       }
       markdownService.registerMarkdownWriter('paragraph', function (ctx) {
-        ctx.wrap('', softBreak);
+        ctx.wrap('', '\n');
       });
       markdownService.registerMarkdownWriter('quote', function (ctx, node) {
         if ($isQuoteNode(node)) {
-          ctx.wrap('> ', softBreak);
+          ctx.wrap('> ', breakMark);
         }
       });
       markdownService.registerMarkdownWriter('heading', function (ctx, node) {
@@ -201,37 +201,37 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           switch (node.getTag()) {
             case 'h1':
               {
-                ctx.wrap('# ', '\n');
+                ctx.wrap('# ', breakMark);
                 break;
               }
             case 'h2':
               {
-                ctx.wrap('## ', '\n');
+                ctx.wrap('## ', breakMark);
                 break;
               }
             case 'h3':
               {
-                ctx.wrap('### ', '\n');
+                ctx.wrap('### ', breakMark);
                 break;
               }
             case 'h4':
               {
-                ctx.wrap('#### ', '\n');
+                ctx.wrap('#### ', breakMark);
                 break;
               }
             case 'h5':
               {
-                ctx.wrap('##### ', '\n');
+                ctx.wrap('##### ', breakMark);
                 break;
               }
             case 'h6':
               {
-                ctx.wrap('###### ', '\n');
+                ctx.wrap('###### ', breakMark);
                 break;
               }
             default:
               {
-                ctx.wrap('', softBreak);
+                ctx.wrap('', '\n');
                 break;
               }
           }
@@ -315,7 +315,14 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       var _this$config2;
       this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enableHotkey
-      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor));
+      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor),
+      // Convert soft line breaks (Shift+Enter) to hard line breaks (paragraph breaks)
+      // This allows breaking out of code blocks with Shift+Enter
+      editor.registerCommand(INSERT_LINE_BREAK_COMMAND, function () {
+        // Dispatch paragraph command instead of line break
+        editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);
+        return true; // Prevent default line break behavior
+      }, COMMAND_PRIORITY_HIGH));
       this.registerMarkdown(this.kernel);
     }
   }, {

package/es/plugins/markdown/data-source/markdown/parse.js

@@ -14,12 +14,13 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { preprocessMarkdownContent } from '@lobehub/ui';
 import { remark } from 'remark';
+import remarkCjkFriendly from 'remark-cjk-friendly';
 import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import { INodeHelper } from "../../../../editor-kernel/inode/helper";
 import { logger } from "../../utils/logger";
-import remarkSupersub from "./supersub";
 
 // 使用条件类型确保类型匹配
 
@@ -225,9 +226,9 @@ function registerDefaultReaders(markdownReaders) {
 }
 export function parseMarkdownToLexical(markdown) {
   var markdownReaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var ast = remark().use(remarkMath).use(remarkSupersub).use([[remarkGfm, {
+  var ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, {
     singleTilde: false
-  }]]).parse(markdown);
+  }]]).parse(preprocessMarkdownContent(markdown));
   logger.debug('Parsed MDAST:', ast);
   var ctx = new MarkdownContext(ast);
   registerDefaultReaders(markdownReaders);

package/es/plugins/markdown/plugin/index.js

@@ -130,66 +130,114 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
 
         // If there's no text content, let Lexical handle it
         if (!text) return false;
+        _this2.logger.debug('paste content analysis:', {
+          clipboardTypes: Array.from(clipboardData.types || []),
+          hasHTML: !!(html && html.trim()),
+          htmlLength: (html === null || html === void 0 ? void 0 : html.length) || 0,
+          textLength: text.length
+        });
+
+        // Check if this is likely a rich-text paste from the editor or other rich editor
+        // Rich text pastes typically have HTML that's more complex than just wrapping text
+        if (html && html.trim()) {
+          var htmlDoc = new DOMParser().parseFromString(html, 'text/html');
+          var hasRichContent =
+          // Has block elements (p, div, h1-h6, etc.)
+          htmlDoc.querySelectorAll('p, div, h1, h2, h3, h4, h5, h6, ul, ol, li, table').length > 0 ||
+          // Has inline formatting (strong, em, code, etc.)
+          htmlDoc.querySelectorAll('strong, em, b, i, u, code, span[style]').length > 0 ||
+          // Has data attributes (often used by editors to store metadata)
+          htmlDoc.querySelectorAll('[data-lexical-text], [data-lexical-decorator]').length > 0;
+          if (hasRichContent) {
+            // This looks like rich content from an editor - let Lexical handle it
+            _this2.logger.debug('rich content detected, letting Lexical handle paste');
+            return false;
+          }
+        }
 
         // Check if markdown paste formatting is enabled (default: true)
         var enablePasteMarkdown = (_this2$config$enableP = (_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.enablePasteMarkdown) !== null && _this2$config$enableP !== void 0 ? _this2$config$enableP : true;
-        if (!enablePasteMarkdown) {
-          // Force plain text paste - ignore all formatting (like Cmd+Shift+V)
-          _this2.logger.debug('paste markdown formatting is disabled, inserting as plain text');
-          event.preventDefault();
-          event.stopPropagation();
-          editor.update(function () {
-            var selection = $getSelection();
-            if (!$isRangeSelection(selection)) return;
 
-            // Simply insert the plain text
-            selection.insertText(text);
-          });
-          return true;
-        }
+        // Force plain text paste for external content
+        event.preventDefault();
+        event.stopPropagation();
+        editor.update(function () {
+          var selection = $getSelection();
+          if (!$isRangeSelection(selection)) return;
 
-        // If there's HTML content, it's a rich text paste
-        // Let Lexical's rich text handler process it
-        if (html && html.trim()) {
-          _this2.logger.debug('paste content analysis: HTML detected, letting Lexical handle it');
-          return false;
+          // Insert plain text
+          selection.insertText(text);
+        });
+
+        // If markdown formatting is disabled, we're done
+        if (!enablePasteMarkdown) {
+          _this2.logger.debug('markdown formatting disabled, plain text inserted');
+          return true;
         }
 
-        // Only handle plain text paste - check for markdown patterns
+        // Check if the pasted plain text contains markdown patterns
         var hasMarkdownContent = _this2.detectMarkdownContent(text);
-        _this2.logger.debug('paste content analysis:', {
-          hasHTML: false,
-          hasMarkdown: hasMarkdownContent,
-          markdownPatterns: _this2.getMarkdownPatterns(text),
-          text: text.slice(0, 100) + (text.length > 100 ? '...' : '')
-        });
         if (hasMarkdownContent) {
-          // Handle markdown paste
-          // return this.handleMarkdownPaste(editor, text);
-          var cacheState = editor.getEditorState();
-          _this2.kernel.emit('markdownParse', {
-            cacheState: cacheState,
-            markdown: text
-          });
-          // setTimeout(() => {
-          //   editor.setEditorState(cacheState);
-          //   editor.update(() => {
-          //     this.handleMarkdownPaste(editor, text);
-          //   });
-          // }, 5000);
-          return false;
+          // Markdown detected - show confirmation dialog
+          _this2.logger.debug('markdown patterns detected:', _this2.getMarkdownPatterns(text));
+          setTimeout(function () {
+            _this2.kernel.emit('markdownParse', {
+              cacheState: editor.getEditorState(),
+              markdown: text
+            });
+          }, 10);
+        } else {
+          // No markdown detected - plain text is already inserted
+          _this2.logger.debug('no markdown patterns detected, keeping as plain text');
         }
-        return false;
+        return true; // Command handled
       }, COMMAND_PRIORITY_CRITICAL));
       this.register(registerMarkdownCommand(editor, this.service));
     }
 
     /**
      * Detect if text contains markdown patterns
+     * Returns false if content is likely code (JSON, HTML, SQL, etc.)
      */
   }, {
     key: "detectMarkdownContent",
     value: function detectMarkdownContent(text) {
+      var trimmed = text.trim();
+
+      // Check if content is JSON
+      if (trimmed.startsWith('{') && trimmed.endsWith('}') || trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        try {
+          JSON.parse(trimmed);
+          this.logger.debug('content is valid JSON, not treating as markdown');
+          return false;
+        } catch (_unused) {
+          // Not valid JSON, continue checking
+        }
+      }
+
+      // Check if content has significant HTML structure
+      var htmlTagPattern = /<[a-z][\S\s]*?>/gi;
+      var htmlMatches = text.match(htmlTagPattern);
+      if (htmlMatches && htmlMatches.length > 5) {
+        // More than 5 HTML tags suggests this is HTML content, not markdown
+        this.logger.debug('content has significant HTML structure, not treating as markdown');
+        return false;
+      }
+
+      // Check if content looks like code (SQL, XML, etc.)
+      // Common patterns: SQL keywords, XML declarations, file paths
+      var codePatterns = [/^\s*(select|insert|update|delete|create|alter|drop)\s+/im,
+      // SQL
+      /^\s*<\?xml/i,
+      // XML declaration
+      /^[a-z]:\\|^\/[a-z]/im // File paths (Windows/Unix)
+      ];
+      if (codePatterns.some(function (pattern) {
+        return pattern.test(text);
+      })) {
+        this.logger.debug('content looks like code, not treating as markdown');
+        return false;
+      }
       var markdownPatterns = [
       // Headers
       /^#{1,6}\s+/m,

package/es/plugins/markdown/react/index.js

@@ -6,7 +6,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { Button, Space, notification } from 'antd';
+import { Button } from '@lobehub/ui';
+import { Space, notification } from 'antd';
 import { UNDO_COMMAND } from 'lexical';
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react";
@@ -35,7 +36,6 @@ var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
             return api.destroy();
           },
           size: "small",
-          type: "link",
           children: t('markdown.cancel')
         }), /*#__PURE__*/_jsx(Button, {
           onClick: function onClick() {
@@ -56,7 +56,7 @@ var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
         duration: 5,
         key: key,
         message: t('markdown.parseTitle'),
-        onClose: close
+        showProgress: true
       });
     };
     editor.on('markdownParse', handleEvent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.17.0",
+  "version": "1.17.2",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -56,6 +56,7 @@
     "react-error-boundary": "^6.0.0",
     "react-layout-kit": "^2.0.0",
     "react-merge-refs": "^3.0.2",
+    "remark-cjk-friendly": "^1.2.1",
     "remark-supersub": "^1.0.0",
     "shiki": "^3.9.2",
     "ts-key-enum": "^3.0.13",