@lobehub/editor 4.3.2 → 4.5.0

package/es/locale/index.d.ts

@@ -28,6 +28,8 @@ declare const _default: {
         unlink: string;
     };
     markdown: {
+        autoFormatMessage: string;
+        autoFormatTitle: string;
         cancel: string;
         confirm: string;
         parseMessage: string;

package/es/locale/index.js

@@ -28,6 +28,8 @@ export default {
     unlink: 'Unlink Link'
   },
   markdown: {
+    autoFormatMessage: 'Markdown was converted automatically. Use Command/Ctrl + Z to undo this conversion.',
+    autoFormatTitle: 'Markdown Converted',
     cancel: 'Cancel',
     confirm: 'Confirm',
     parseMessage: 'Convert to markdown format, existing content will be overwritten, confirm? (Auto close in 5 seconds)',

package/es/plugins/common/react/ReactPlainText.js

@@ -42,10 +42,13 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
     enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey,
     _ref$enablePasteMarkd = _ref.enablePasteMarkdown,
     enablePasteMarkdown = _ref$enablePasteMarkd === void 0 ? true : _ref$enablePasteMarkd,
+    _ref$autoFormatMarkdo = _ref.autoFormatMarkdown,
+    autoFormatMarkdown = _ref$autoFormatMarkdo === void 0 ? true : _ref$autoFormatMarkdo,
     _ref$markdownOption = _ref.markdownOption,
     markdownOption = _ref$markdownOption === void 0 ? true : _ref$markdownOption,
     _ref$pasteAsPlainText = _ref.pasteAsPlainText,
     pasteAsPlainText = _ref$pasteAsPlainText === void 0 ? false : _ref$pasteAsPlainText,
+    pasteMarkdownAutoConvertThreshold = _ref.pasteMarkdownAutoConvertThreshold,
     _ref$pasteVSCodeAsCod = _ref.pasteVSCodeAsCodeBlock,
     pasteVSCodeAsCodeBlock = _ref$pasteVSCodeAsCod === void 0 ? true : _ref$pasteVSCodeAsCod,
     onKeyDown = _ref.onKeyDown,
@@ -108,7 +111,9 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
     lineEmptyPlaceholder = _Children$only$props.lineEmptyPlaceholder;
   useLayoutEffect(function () {
     editor.registerPlugin(MarkdownPlugin, {
-      enablePasteMarkdown: enablePasteMarkdown
+      autoFormatMarkdown: autoFormatMarkdown,
+      enablePasteMarkdown: enablePasteMarkdown,
+      pasteMarkdownAutoConvertThreshold: pasteMarkdownAutoConvertThreshold
     });
     editor.registerPlugin(CommonPlugin, {
       enableHotkey: enableHotkey,
@@ -117,7 +122,7 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
       pasteVSCodeAsCodeBlock: pasteVSCodeAsCodeBlock,
       theme: restTheme ? _objectSpread(_objectSpread({}, computedThemeStyles), restTheme) : computedThemeStyles
     });
-  }, [editor, enableHotkey, enablePasteMarkdown, markdownOption, pasteAsPlainText, pasteVSCodeAsCodeBlock, restTheme, computedThemeStyles]);
+  }, [editor, enableHotkey, enablePasteMarkdown, autoFormatMarkdown, markdownOption, pasteAsPlainText, pasteMarkdownAutoConvertThreshold, pasteVSCodeAsCodeBlock, restTheme, computedThemeStyles]);
   useEffect(function () {
     var _editor$getLexicalEdi;
     var container = editorContainerRef.current;

package/es/plugins/common/react/type.d.ts

@@ -9,12 +9,17 @@ export interface ReactEditorContentProps {
 }
 export interface ReactPlainTextProps {
     autoFocus?: boolean;
+    /**
+     * Automatically convert pasted markdown once the detection threshold is reached
+     * @default true
+     */
+    autoFormatMarkdown?: boolean;
     children: ReactElement<ReactEditorContentProps>;
     className?: string;
     editable?: boolean;
     enableHotkey?: boolean;
     /**
-     * Enable automatic markdown formatting for pasted content
+     * Enable automatic markdown conversion for pasted content
      * @default true
      */
     enablePasteMarkdown?: boolean;
@@ -62,6 +67,11 @@ export interface ReactPlainTextProps {
      * @default false
      */
     pasteAsPlainText?: boolean;
+    /**
+     * Minimum markdown score required before auto conversion runs
+     * @default 5
+     */
+    pasteMarkdownAutoConvertThreshold?: number;
     /**
      * When pasting VS Code content (detected via vscode-editor-data clipboard type),
      * create a code block with the language from VS Code instead of pasting as plain text.

package/es/plugins/markdown/command/index.d.ts

@@ -1,4 +1,4 @@
-import { HistoryState, HistoryStateEntry } from '@lexical/history';
+import type { HistoryStateEntry } from '@lexical/history';
 import { LexicalEditor } from 'lexical';
 import { IEditorKernel } from "../../../types";
 import { MarkdownShortCutService } from '../service/shortcut';
@@ -9,4 +9,4 @@ export declare const INSERT_MARKDOWN_COMMAND: import("lexical").LexicalCommand<{
 export declare const GET_MARKDOWN_SELECTION_COMMAND: import("lexical").LexicalCommand<{
     onResult: (startLine: number, endLine: number) => void;
 }>;
-export declare function registerMarkdownCommand(editor: LexicalEditor, kernel: IEditorKernel, service: MarkdownShortCutService, history: HistoryState): () => void;
+export declare function registerMarkdownCommand(editor: LexicalEditor, kernel: IEditorKernel, service: MarkdownShortCutService): () => void;

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

@@ -1,39 +1,30 @@
 import { mergeRegister } from '@lexical/utils';
-import { $getSelection, $isRangeSelection, CAN_UNDO_COMMAND, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, createCommand } from 'lexical';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, HISTORY_PUSH_TAG, createCommand } from 'lexical';
 import { createDebugLogger } from "../../../utils/debug";
 import { parseMarkdownToLexical } from "../data-source/markdown/parse";
 import { $generateNodesFromSerializedNodes, $insertGeneratedNodes } from "../utils";
 var logger = createDebugLogger('plugin', 'markdown');
 export var INSERT_MARKDOWN_COMMAND = createCommand('INSERT_MARKDOWN_COMMAND');
 export var GET_MARKDOWN_SELECTION_COMMAND = createCommand('GET_MARKDOWN_SELECTION_COMMAND');
-function undoToEntry(editor, historyState, entry) {
-  var undoStack = historyState.undoStack;
-  var current = historyState.current;
-  if (current) {
-    undoStack.push(current);
-    editor.dispatchCommand(CAN_UNDO_COMMAND, false);
-  }
-  historyState.current = entry || null;
-  if (entry) {
-    editor.setEditorState(entry.editorState, {
-      tag: HISTORIC_TAG
-    });
-  }
-  return editor.getEditorState();
+function restoreToEntry(editor, entry) {
+  if (!entry) return;
+  editor.setEditorState(entry.editorState, {
+    tag: HISTORIC_TAG
+  });
 }
 var SPICAL_TEXT = "\uFFF0";
 var getLineNumber = function getLineNumber(content, charIndex) {
   return content.slice(0, Math.max(0, charIndex)).split('\n').length;
 };
-export function registerMarkdownCommand(editor, kernel, service, history) {
+export function registerMarkdownCommand(editor, kernel, service) {
   return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, function (payload) {
     var markdown = payload.markdown;
     logger.debug('INSERT_MARKDOWN_COMMAND payload:', payload);
-    undoToEntry(editor, history, payload.historyState);
-    queueMicrotask(function () {
+    restoreToEntry(editor, payload.historyState);
+    setTimeout(function () {
       editor.update(function () {
         try {
-          // Use the markdown data source to parse the content
+          // Force a new history entry so undo returns to the raw pasted text.
           var root = parseMarkdownToLexical(markdown, service.markdownReaders);
           var selection = $getSelection();
           var nodes = $generateNodesFromSerializedNodes(root.children);
@@ -43,8 +34,10 @@ export function registerMarkdownCommand(editor, kernel, service, history) {
         } catch (error) {
           logger.error('Failed to handle markdown paste:', error);
         }
+      }, {
+        tag: HISTORY_PUSH_TAG
       });
-    });
+    }, 0);
     return false;
   }, COMMAND_PRIORITY_HIGH // Priority
   ), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, function (payload) {

package/es/plugins/markdown/plugin/index.d.ts

@@ -1,9 +1,19 @@
 import { IEditorPluginConstructor } from "../../../types";
 export interface MarkdownPluginOptions {
     /**
-     * Enable automatic markdown formatting for pasted content
+     * Automatically convert pasted markdown once the detection threshold is reached
+     * @default true
+     */
+    autoFormatMarkdown?: boolean;
+    /**
+     * Enable automatic markdown conversion for pasted content
      * @default true
      */
     enablePasteMarkdown?: boolean;
+    /**
+     * Minimum markdown score required before auto conversion runs
+     * @default 5
+     */
+    pasteMarkdownAutoConvertThreshold?: number;
 }
 export declare const MarkdownPlugin: IEditorPluginConstructor<MarkdownPluginOptions>;

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

@@ -17,11 +17,116 @@ import { $isCodeNode } from '@lexical/code';
 import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, HISTORIC_TAG, KEY_ENTER_COMMAND, PASTE_COMMAND } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { createDebugLogger } from "../../../utils/debug";
-import { registerMarkdownCommand } from "../command";
+import { INSERT_MARKDOWN_COMMAND, registerMarkdownCommand } from "../command";
 import MarkdownDataSource from "../data-source/markdown-data-source";
 import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
 import { canContainTransformableMarkdown } from "../utils";
 import { detectCodeLanguage, detectLanguage } from "../utils/detectLanguage";
+var DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD = 5;
+var RICH_HTML_SELECTOR = 'strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]';
+var MARKDOWN_DETECTION_RULES = [{
+  name: 'headers',
+  score: 5,
+  test: function test(text) {
+    return /^#{1,6}\s+\S/m.test(text);
+  }
+}, {
+  name: 'code-fence-start',
+  score: 5,
+  test: function test(text) {
+    return /^```[\w-]*$/m.test(text);
+  }
+}, {
+  name: 'links',
+  score: 4,
+  test: function test(text) {
+    return /\[[^\]]+]\([^)]+\)/.test(text);
+  }
+}, {
+  name: 'images',
+  score: 5,
+  test: function test(text) {
+    return /!\[[^\]]*]\([^)]+\)/.test(text);
+  }
+}, {
+  name: 'tables',
+  score: 5,
+  test: function test(text) {
+    return /^\|.+\|$/m.test(text) && /^\|[\s:|-]+\|$/m.test(text);
+  }
+}, {
+  name: 'admonitions',
+  score: 5,
+  test: function test(text) {
+    return /^>\s*\[!(?:note|tip|warning|caution|important)]/im.test(text);
+  }
+}, {
+  name: 'task-lists',
+  score: 4,
+  test: function test(text) {
+    return /^[*-]\s+\[[ x]]/m.test(text);
+  }
+}, {
+  name: 'bold',
+  score: 2,
+  test: function test(text) {
+    return /\*\*.+?\*\*/.test(text);
+  }
+}, {
+  name: 'italic',
+  score: 1,
+  test: function test(text) {
+    return /(?<!\*)\*(?!\*)(?!\s).+?(?<!\s)(?<!\*)\*(?!\*)/.test(text);
+  }
+}, {
+  name: 'unordered-lists',
+  score: 1,
+  test: function test(text) {
+    return /^[*+-]\s+\S/m.test(text);
+  }
+}, {
+  name: 'ordered-lists',
+  score: 1,
+  test: function test(text) {
+    return /^\d+\.\s+\S/m.test(text);
+  }
+}, {
+  name: 'blockquotes',
+  score: 1,
+  test: function test(text) {
+    return /^>\s+\S/m.test(text);
+  }
+}, {
+  name: 'inline-code',
+  score: 1,
+  test: function test(text) {
+    return /`.+?`/.test(text);
+  }
+}, {
+  name: 'horizontal-rules',
+  score: 2,
+  test: function test(text) {
+    return /^[*_-]{3,}$/m.test(text);
+  }
+}, {
+  name: 'multi-paragraph',
+  score: 5,
+  test: function test(text) {
+    return text.split(/\n{2,}/).filter(Boolean).length >= 2;
+  }
+}, {
+  name: 'short-text-penalty',
+  score: -3,
+  test: function test(text) {
+    return text.length < 20;
+  }
+}, {
+  name: 'single-line-penalty',
+  score: -2,
+  test: function test(text) {
+    return !text.includes('\n');
+  }
+}];
 export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MarkdownPlugin, _KernelPlugin);
   var _super = _createSuper(MarkdownPlugin);
@@ -122,6 +227,7 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       }, COMMAND_PRIORITY_CRITICAL));
       this.register(editor.registerCommand(PASTE_COMMAND, function (event) {
         if (!(event instanceof ClipboardEvent)) return false;
+        if (!_this2.shouldHandlePasteMarkdown()) return false;
         var clipboardData = event.clipboardData;
         if (!clipboardData) return false;
 
@@ -139,33 +245,39 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           htmlLength: (html === null || html === void 0 ? void 0 : html.length) || 0,
           textLength: text.length
         });
-
-        // Check if the pasted plain text contains markdown patterns
-        var hasMarkdownContent = _this2.detectMarkdownContent(text);
-        if (hasMarkdownContent) {
-          // Markdown detected - show confirmation dialog
-          _this2.logger.debug('markdown patterns detected:', _this2.getMarkdownPatterns(text));
+        if (_this2.hasRichHTML(clipboardData)) {
+          _this2.logger.debug('rich HTML detected, skipping markdown auto-convert');
+          return false;
+        }
+        var detectionResult = _this2.getMarkdownDetectionResult(text);
+        if (detectionResult.shouldAutoConvert) {
+          _this2.logger.debug('markdown auto-convert detected:', detectionResult);
           var historyState = _this2.kernel.getHistoryState().current;
           setTimeout(function () {
+            editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
+              historyState: historyState,
+              markdown: text
+            });
             _this2.kernel.emit('markdownParse', {
               cacheState: editor.getEditorState(),
               historyState: historyState,
-              markdown: text
+              markdown: text,
+              matchedPatterns: detectionResult.matchedPatterns,
+              score: detectionResult.score
             });
           }, 10);
         } else {
-          // No markdown detected - plain text is already inserted
-          _this2.logger.debug('no markdown patterns detected, keeping as plain text');
+          _this2.logger.debug('markdown score below auto-convert threshold, keeping as plain text:', detectionResult);
         }
         return false;
       }, COMMAND_PRIORITY_CRITICAL));
-      this.register(registerMarkdownCommand(editor, this.kernel, this.service, this.kernel.getHistoryState()));
+      this.register(registerMarkdownCommand(editor, this.kernel, this.service));
     }
 
     /**
      * Detect if content is code and should be inserted as code block
      * Uses advanced language detection with pattern matching
-     * Excludes markdown as it should be handled by markdown formatting dialog
+     * Excludes markdown because markdown content is handled by the paste auto-convert flow
      */
   }, {
     key: "detectCodeContent",
@@ -173,7 +285,7 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       // Use the advanced language detector
       var detected = detectLanguage(text);
       if (detected && detected.confidence > 50) {
-        // Don't insert markdown as code block - it should trigger the formatting dialog
+        // Don't insert markdown as code block - it should use the markdown auto-convert flow
         if (detected.language === 'markdown') {
           return null;
         }
@@ -195,99 +307,64 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       }
       return null;
     }
+  }, {
+    key: "hasRichHTML",
+    value: function hasRichHTML(clipboardData) {
+      var html = clipboardData.getData('text/html');
+      if (!html) return false;
+      if (/data-vscode|vscode-/i.test(html)) return false;
+      if (typeof DOMParser === 'undefined') return false;
+      var doc = new DOMParser().parseFromString(html, 'text/html');
+      var richTags = doc.body.querySelectorAll(RICH_HTML_SELECTOR);
+      return richTags.length > 0;
+    }
 
     /**
-     * Detect if text contains markdown patterns
-     * Returns false if content is likely code (will be handled by detectCodeContent)
+     * Analyze pasted text and determine whether it should auto convert to markdown
      */
   }, {
-    key: "detectMarkdownContent",
-    value: function detectMarkdownContent(text) {
-      // If code is detected, don't treat as markdown
+    key: "getMarkdownDetectionResult",
+    value: function getMarkdownDetectionResult(text) {
       if (this.detectCodeContent(text)) {
-        return false;
+        return {
+          matchedPatterns: [],
+          score: 0,
+          shouldAutoConvert: false
+        };
       }
-      var markdownPatterns = [
-      // Headers
-      /^#{1,6}\s+/m,
-      // Bold/italic
-      /\*{1,2}[^*]+\*{1,2}/, /__?[^_]+__?/,
-      // Code blocks
-      /```[\S\s]*```/,
-      // Inline code
-      /`[^`]+`/,
-      // Links
-      /\[[^\]]*]\([^)]+\)/,
-      // Images
-      /!\[[^\]]*]\([^)]+\)/,
-      // Lists
-      /^[*+-]\s+/m, /^\d+\.\s+/m,
-      // Blockquotes
-      /^>\s+/m,
-      // Tables
-      /\|.*\|.*\|/,
-      // Horizontal rules
-      /^---+$/m, /^\*\*\*+$/m,
-      // Strikethrough
-      /~~[^~]+~~/];
-      return markdownPatterns.some(function (pattern) {
-        return pattern.test(text);
-      });
+      var matchedPatterns = [];
+      var score = 0;
+      var threshold = this.getPasteMarkdownAutoConvertThreshold();
+      for (var _i = 0, _MARKDOWN_DETECTION_R = MARKDOWN_DETECTION_RULES; _i < _MARKDOWN_DETECTION_R.length; _i++) {
+        var rule = _MARKDOWN_DETECTION_R[_i];
+        if (!rule.test(text)) continue;
+        matchedPatterns.push(rule.name);
+        score += rule.score;
+      }
+      return {
+        matchedPatterns: matchedPatterns,
+        score: score,
+        shouldAutoConvert: score >= threshold
+      };
     }
-
-    /**
-     * Get specific markdown patterns found in text
-     */
   }, {
-    key: "getMarkdownPatterns",
-    value: function getMarkdownPatterns(text) {
-      var patterns = [{
-        name: 'headers',
-        regex: /^#{1,6}\s+/m
-      }, {
-        name: 'bold',
-        regex: /\*{2}[^*]+\*{2}/
-      }, {
-        name: 'italic',
-        regex: /\*[^*]+\*/
-      }, {
-        name: 'code-blocks',
-        regex: /```[\S\s]*```/
-      }, {
-        name: 'inline-code',
-        regex: /`[^`]+`/
-      }, {
-        name: 'links',
-        regex: /\[[^\]]*]\([^)]+\)/
-      }, {
-        name: 'images',
-        regex: /!\[[^\]]*]\([^)]+\)/
-      }, {
-        name: 'lists',
-        regex: /^[*+-]\s+/m
-      }, {
-        name: 'ordered-lists',
-        regex: /^\d+\.\s+/m
-      }, {
-        name: 'blockquotes',
-        regex: /^>\s+/m
-      }, {
-        name: 'tables',
-        regex: /\|.*\|.*\|/
-      }, {
-        name: 'horizontal-rules',
-        regex: /^---+$/m
-      }, {
-        name: 'strikethrough',
-        regex: /~~[^~]+~~/
-      }];
-      return patterns.filter(function (_ref2) {
-        var regex = _ref2.regex;
-        return regex.test(text);
-      }).map(function (_ref3) {
-        var name = _ref3.name;
-        return name;
-      });
+    key: "getPasteMarkdownAutoConvertThreshold",
+    value: function getPasteMarkdownAutoConvertThreshold() {
+      var _this$config;
+      var threshold = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.pasteMarkdownAutoConvertThreshold;
+      if (typeof threshold !== 'number' || Number.isNaN(threshold)) {
+        return DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD;
+      }
+      return Math.max(1, threshold);
+    }
+  }, {
+    key: "shouldHandlePasteMarkdown",
+    value: function shouldHandlePasteMarkdown() {
+      var _this$config2, _this$config3;
+      if (((_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enablePasteMarkdown) === false) {
+        return false;
+      }
+      return ((_this$config3 = this.config) === null || _this$config3 === void 0 ? void 0 : _this$config3.autoFormatMarkdown) !== false;
     }
 
     // /**

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

@@ -6,67 +6,33 @@ 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 } from '@lobehub/ui';
-import { Space, notification } from 'antd';
+import { toast } from '@lobehub/ui';
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react";
 import { useTranslation } from "../../../editor-kernel/react/useTranslation";
 import { INodePlugin } from "../../inode";
-import { INSERT_MARKDOWN_COMMAND } from "../command";
 import { MarkdownPlugin } from "../plugin";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
 var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
   var _useLexicalComposerCo = useLexicalComposerContext(),
     _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
     editor = _useLexicalComposerCo2[0];
-  var _notification$useNoti = notification.useNotification(),
-    _notification$useNoti2 = _slicedToArray(_notification$useNoti, 2),
-    api = _notification$useNoti2[0],
-    contextHolder = _notification$useNoti2[1];
   var t = useTranslation();
   useLayoutEffect(function () {
     editor.registerPlugin(INodePlugin);
     editor.registerPlugin(MarkdownPlugin);
-    var handleEvent = function handleEvent(_ref) {
-      var markdown = _ref.markdown,
-        historyState = _ref.historyState;
-      var key = "open".concat(Date.now());
-      var actions = /*#__PURE__*/_jsxs(Space, {
-        children: [/*#__PURE__*/_jsx(Button, {
-          onClick: function onClick() {
-            return api.destroy();
-          },
-          size: "small",
-          children: t('markdown.cancel')
-        }), /*#__PURE__*/_jsx(Button, {
-          onClick: function onClick() {
-            editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
-              historyState: historyState,
-              markdown: markdown
-            });
-            api.destroy();
-          },
-          size: "small",
-          type: "primary",
-          children: t('markdown.confirm')
-        })]
-      });
-      api.open({
-        actions: actions,
-        description: t('markdown.parseMessage'),
-        duration: 5,
-        key: key,
-        message: t('markdown.parseTitle'),
-        showProgress: true
+    var handleEvent = function handleEvent() {
+      toast.info({
+        description: t('markdown.autoFormatMessage'),
+        duration: 5000,
+        title: t('markdown.autoFormatTitle')
       });
     };
     editor.on('markdownParse', handleEvent);
     return function () {
       editor.off('markdownParse', handleEvent);
     };
-  }, [editor]);
-  return contextHolder;
+  }, [editor, t]);
+  return null;
 };
 ReactMarkdownPlugin.displayName = 'ReactMarkdownPlugin';
 export default ReactMarkdownPlugin;

package/es/react/Editor/Editor.js

@@ -57,8 +57,11 @@ var Editor = /*#__PURE__*/memo(function (_ref) {
     autoFocus = _ref.autoFocus,
     _ref$enablePasteMarkd = _ref.enablePasteMarkdown,
     enablePasteMarkdown = _ref$enablePasteMarkd === void 0 ? true : _ref$enablePasteMarkd,
+    _ref$autoFormatMarkdo = _ref.autoFormatMarkdown,
+    autoFormatMarkdown = _ref$autoFormatMarkdo === void 0 ? true : _ref$autoFormatMarkdo,
     _ref$markdownOption = _ref.markdownOption,
     markdownOption = _ref$markdownOption === void 0 ? true : _ref$markdownOption,
+    pasteMarkdownAutoConvertThreshold = _ref.pasteMarkdownAutoConvertThreshold,
     _ref$pasteAsPlainText = _ref.pasteAsPlainText,
     pasteAsPlainText = _ref$pasteAsPlainText === void 0 ? false : _ref$pasteAsPlainText,
     _ref$pasteVSCodeAsCod = _ref.pasteVSCodeAsCodeBlock,
@@ -82,7 +85,7 @@ var Editor = /*#__PURE__*/memo(function (_ref) {
     return onTextChange ? debounce(onTextChange, debounceWait) : undefined;
   }, [onTextChange, debounceWait]);
   var memoPlugins = useMemo(function () {
-    return [enablePasteMarkdown && ReactMarkdownPlugin].concat(_toConsumableArray(plugins)).filter(Boolean).map(function (plugin, index) {
+    return [enablePasteMarkdown && autoFormatMarkdown && ReactMarkdownPlugin].concat(_toConsumableArray(plugins)).filter(Boolean).map(function (plugin, index) {
       var withNoProps = typeof plugin === 'function';
       if (withNoProps) return /*#__PURE__*/createElement(plugin, {
         key: index
@@ -91,7 +94,7 @@ var Editor = /*#__PURE__*/memo(function (_ref) {
         key: index
       }, plugin[1]));
     });
-  }, [plugins, enablePasteMarkdown, ReactMarkdownPlugin]);
+  }, [plugins, enablePasteMarkdown, autoFormatMarkdown, ReactMarkdownPlugin]);
   var memoMention = useMemo(function () {
     if (!enableMention) return;
     return /*#__PURE__*/_jsx(ReactMentionPlugin, {
@@ -119,6 +122,7 @@ var Editor = /*#__PURE__*/memo(function (_ref) {
     onInit: onInit,
     children: [memoPlugins, memoSlash, memoMention, /*#__PURE__*/_jsx(ReactPlainText, {
       autoFocus: autoFocus,
+      autoFormatMarkdown: autoFormatMarkdown,
       className: className,
       editable: editable,
       enablePasteMarkdown: enablePasteMarkdown,
@@ -133,6 +137,7 @@ var Editor = /*#__PURE__*/memo(function (_ref) {
       onPressEnter: onPressEnter,
       onTextChange: debouncedOnTextChange,
       pasteAsPlainText: pasteAsPlainText,
+      pasteMarkdownAutoConvertThreshold: pasteMarkdownAutoConvertThreshold,
       pasteVSCodeAsCodeBlock: pasteVSCodeAsCodeBlock,
       style: style,
       variant: variant,