@lobehub/editor 1.17.1 → 1.18.0

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

@@ -4,3 +4,4 @@ export { default as ReactMarkdownPlugin } from './react';
 export type { MARKDOWN_READER_LEVEL } from './service/shortcut';
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, } from './service/shortcut';
 export { isPunctuationChar } from './utils';
+export { detectCodeLanguage, detectLanguage } from './utils/detectLanguage';

package/es/plugins/markdown/index.js

@@ -2,4 +2,5 @@ export { INSERT_MARKDOWN_COMMAND } from "./command";
 export { MarkdownPlugin } from "./plugin";
 export { default as ReactMarkdownPlugin } from "./react";
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX } from "./service/shortcut";
-export { isPunctuationChar } from "./utils";
+export { isPunctuationChar } from "./utils";
+export { detectCodeLanguage, detectLanguage } from "./utils/detectLanguage";

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

@@ -13,7 +13,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 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 { $isCodeNode } from '@lexical/code';
+import { $createCodeNode, $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";
@@ -21,6 +21,7 @@ import { 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";
 export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MarkdownPlugin, _KernelPlugin);
   var _super = _createSuper(MarkdownPlugin);
@@ -130,32 +131,64 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
 
         // If there's no text content, let Lexical handle it
         if (!text) 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;
         _this2.logger.debug('paste content analysis:', {
-          enablePasteMarkdown: enablePasteMarkdown,
+          clipboardTypes: Array.from(clipboardData.types || []),
           hasHTML: !!(html && html.trim()),
-          text: text.slice(0, 100) + (text.length > 100 ? '...' : '')
-        });
-
-        // Always force plain text paste first (prevents HTML formatting issues)
-        event.preventDefault();
-        event.stopPropagation();
-        editor.update(function () {
-          var selection = $getSelection();
-          if (!$isRangeSelection(selection)) return;
-
-          // Insert plain text
-          selection.insertText(text);
+          htmlLength: (html === null || html === void 0 ? void 0 : html.length) || 0,
+          textLength: text.length
         });
+        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 markdown formatting is disabled, we're done
         if (!enablePasteMarkdown) {
+          // Force plain text paste for external content
+          event.preventDefault();
+          event.stopPropagation();
+          editor.update(function () {
+            var selection = $getSelection();
+            if (!$isRangeSelection(selection)) return;
+
+            // Insert plain text
+            selection.insertText(text);
+          });
           _this2.logger.debug('markdown formatting disabled, plain text inserted');
           return true;
         }
 
+        // 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 (clipboardData.types.includes('application/x-lexical-editor')) {
+          _this2.logger.debug('rich content detected, letting Lexical handle paste');
+          return false;
+        }
+
+        // Check if markdown paste formatting is enabled (default: true)
+
+        // Check if content is code (JSON, SQL, etc.) and should be inserted as code block
+        var codeInfo = _this2.detectCodeContent(text);
+        if (codeInfo) {
+          // Code detected - insert as code block
+          _this2.logger.debug("code detected (".concat(codeInfo.language, "), inserting as code block"));
+          event.preventDefault();
+          event.stopPropagation();
+          editor.update(function () {
+            var selection = $getSelection();
+            if (!$isRangeSelection(selection)) return;
+
+            // Create code block node with detected language
+            var codeNode = $createCodeNode(codeInfo.language);
+            selection.insertNodes([codeNode]);
+
+            // Insert the code text into the code block
+            codeNode.select();
+            var codeSelection = $getSelection();
+            if ($isRangeSelection(codeSelection)) {
+              codeSelection.insertText(text);
+            }
+          });
+          return true; // Command handled
+        }
+
         // Check if the pasted plain text contains markdown patterns
         var hasMarkdownContent = _this2.detectMarkdownContent(text);
         if (hasMarkdownContent) {
@@ -171,52 +204,87 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           // No markdown detected - plain text is already inserted
           _this2.logger.debug('no markdown patterns detected, keeping as plain text');
         }
+        if (clipboardData.types.includes('text/html') && clipboardData.types.includes('text/rtf')) {
+          // Code detected - insert as code block
+          _this2.logger.debug("code like, inserting as code block");
+          event.preventDefault();
+          event.stopPropagation();
+          editor.update(function () {
+            var selection = $getSelection();
+            if (!$isRangeSelection(selection)) return;
+
+            // Create code block node with detected language
+            var codeNode = $createCodeNode('plaintext');
+            selection.insertNodes([codeNode]);
+
+            // Insert the code text into the code block
+            codeNode.select();
+            var codeSelection = $getSelection();
+            if ($isRangeSelection(codeSelection)) {
+              codeSelection.insertText(text);
+            }
+          });
+          return true; // Command handled
+        }
+
+        // Force plain text paste for external content
+        event.preventDefault();
+        event.stopPropagation();
+        editor.update(function () {
+          var selection = $getSelection();
+          if (!$isRangeSelection(selection)) return;
+
+          // Insert plain text
+          selection.insertText(text);
+        });
         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.)
+     * 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
      */
   }, {
-    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
+    key: "detectCodeContent",
+    value: function detectCodeContent(text) {
+      // 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
+        if (detected.language === 'markdown') {
+          return null;
         }
+        this.logger.debug('language detected:', detected);
+        return detected;
       }
 
-      // 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;
+      // Fallback to fast detection for common formats
+      var fastDetected = detectCodeLanguage(text);
+      if (fastDetected) {
+        // Don't insert markdown as code block
+        if (fastDetected === 'markdown') {
+          return null;
+        }
+        return {
+          confidence: 80,
+          language: fastDetected
+        };
       }
+      return null;
+    }
 
-      // 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');
+    /**
+     * Detect if text contains markdown patterns
+     * Returns false if content is likely code (will be handled by detectCodeContent)
+     */
+  }, {
+    key: "detectMarkdownContent",
+    value: function detectMarkdownContent(text) {
+      // If code is detected, don't treat as markdown
+      if (this.detectCodeContent(text)) {
         return false;
       }
       var markdownPatterns = [

package/es/plugins/markdown/utils/detectLanguage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Language detection utility for code snippets
+ * Uses pattern matching and heuristics to identify programming languages
+ */
+interface LanguageDetectionResult {
+    confidence: number;
+    language: string;
+}
+/**
+ * Detect the programming language of a code snippet
+ * @param code - The code snippet to analyze
+ * @returns Language detection result with confidence score
+ */
+export declare function detectLanguage(code: string): LanguageDetectionResult | null;
+/**
+ * Simple detection for common formats with high confidence
+ * Falls back to detectLanguage for more complex detection
+ */
+export declare function detectCodeLanguage(code: string): string | null;
+export {};

package/es/plugins/markdown/utils/detectLanguage.js

@@ -0,0 +1,267 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+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; }
+/**
+ * Language detection utility for code snippets
+ * Uses pattern matching and heuristics to identify programming languages
+ */
+
+var LANGUAGE_PATTERNS = {
+  // Shell/Config
+  bash: {
+    optional: [/\|\||&&/, /echo\s+/, /if\s+\[/],
+    required: [/^#!\/bin\/(ba)?sh/, /\${?\w+}?/],
+    weight: 7
+  },
+  csharp: {
+    optional: [/\[.*]/, /async\s+Task/, /var\s+\w+\s*=/],
+    required: [/(public|private|protected)\s+(class|interface|namespace)/, /using\s+\w+/],
+    weight: 8
+  },
+  css: {
+    optional: [/@media|@import|@keyframes/, /!important/],
+    required: [/[#.]?[\w-]+\s*{/, /:\s*[\w#%-]+;/],
+    weight: 8
+  },
+  dockerfile: {
+    required: [/^FROM\s+/, /^(RUN|CMD|COPY|ADD|WORKDIR|ENV|EXPOSE)\s+/m],
+    weight: 10
+  },
+  go: {
+    optional: [/import\s+\(/, /:=/, /defer|goroutine/],
+    required: [/package\s+\w+/, /func\s+\w+/],
+    weight: 8
+  },
+  graphql: {
+    optional: [/fragment\s+/, /on\s+\w+/],
+    required: [/(query|mutation|subscription)\s+/, /{[\S\s]*}/],
+    weight: 8
+  },
+  // Web languages
+  html: {
+    optional: [/<\/\w+>/, /class=|id=/],
+    required: [/<(html|head|body|div|span|p|a|img|script|style|link|meta)/i],
+    weight: 9
+  },
+  ini: {
+    exclude: [/^\s*</, /{.*}/],
+    required: [/^\[.*]$/m, /\w+\s*=\s*/],
+    weight: 6
+  },
+  java: {
+    optional: [/@Override|@Autowired/, /extends|implements/, /System\.out/],
+    required: [/(public|private|protected)\s+(class|interface|static)/, /\w+\s+\w+\s*\([^)]*\)\s*{/],
+    weight: 8
+  },
+  // JavaScript family
+  javascript: {
+    exclude: [/^\s*</, /interface\s+\w+/, /:\s*\w+\s*[;=]/],
+    optional: [/=>\s*{/, /console\.(log|error|warn)/, /\.then\(/, /require\(/],
+    required: [/(function|const|let|var|class|import|export|async|await)\s/],
+    weight: 7
+  },
+  // Data formats
+  json: {
+    optional: [/"[^"]*"\s*:/, /:\s*["'[{]/],
+    required: [/^\s*[[{]/, /[\]}]\s*$/],
+    weight: 10
+  },
+  jsx: {
+    exclude: [/^\s*<!DOCTYPE/, /^\s*<html/],
+    optional: [/className=/, /{.*}/, /import.*from/],
+    required: [/<\w+[^>]*>/, /(const|function|class)\s+\w+/],
+    weight: 8
+  },
+  makefile: {
+    optional: [/\$\(.*\)/, /\.PHONY/],
+    required: [/^[\w-]+:\s*/, /^\t/m],
+    weight: 7
+  },
+  // Other common languages
+  markdown: {
+    optional: [/```/, /\*\*.*\*\*/, /^\s*[*+-]\s+/m],
+    required: [/^#{1,6}\s+/, /\[.*]\(.*\)/],
+    weight: 6
+  },
+  php: {
+    optional: [/function\s+\w+/, /class\s+\w+/, /echo|print/],
+    required: [/<\?php/, /\$\w+/],
+    weight: 10
+  },
+  powershell: {
+    optional: [/\|\s*Where/, /\|\s*Select/, /param\(/],
+    required: [/\$\w+/, /(Get|Set|New|Remove)-\w+/],
+    weight: 8
+  },
+  // Backend languages
+  python: {
+    optional: [/if __name__|print\(/, /self\.|lambda/, /@\w+\s*$/m],
+    required: [/(def|class|import|from)\s+\w+/, /:\s*$/m],
+    weight: 8
+  },
+  ruby: {
+    optional: [/do\s*\|.*\|/, /puts|require/, /:\w+\s*=>/],
+    required: [/(def|class|module|end)\s/, /@\w+/],
+    weight: 7
+  },
+  rust: {
+    optional: [/::\w+/, /&mut|&str/, /#\[derive\(/],
+    required: [/(fn|struct|impl|trait|use)\s+/, /let\s+(mut\s+)?\w+/],
+    weight: 8
+  },
+  scss: {
+    optional: [/@mixin|@include|@extend/, /#{.*}/],
+    required: [/\$[\w-]+\s*:/, /[&@]\w+/],
+    weight: 8
+  },
+  // Database
+  sql: {
+    optional: [/from|where|join|group by|order by/i, /\*/],
+    required: [/(select|insert|update|delete|create|alter|drop)\s+/i],
+    weight: 9
+  },
+  // Config formats
+  toml: {
+    optional: [/\[\[.*]]/, /"""[\S\s]*"""/],
+    required: [/^\[.*]$/m, /\w+\s*=\s*[\w"']/],
+    weight: 8
+  },
+  tsx: {
+    optional: [/:\s*React\./, /:\s*FC</, /useState|useEffect/],
+    required: [/<\w+[^>]*>/, /interface|type\s+\w+/],
+    weight: 9
+  },
+  typescript: {
+    optional: [/<\w+>/, /as\s+\w+/, /implements|extends/],
+    required: [/(interface|type|enum)\s+\w+/, /:\s*\w+(\[]|<.+>)?\s*[);=]/],
+    weight: 8
+  },
+  xml: {
+    optional: [/<\/\w+>/, /xmlns/],
+    required: [/<\?xml|<\w+[^>]*>/],
+    weight: 9
+  },
+  yaml: {
+    exclude: [/^\s*[[\]{]/],
+    required: [/^[\s-]*\w+:\s*/, /^[\s-]*-\s+/m],
+    weight: 8
+  }
+};
+
+/**
+ * Detect the programming language of a code snippet
+ * @param code - The code snippet to analyze
+ * @returns Language detection result with confidence score
+ */
+export function detectLanguage(code) {
+  if (!code || code.trim().length === 0) {
+    return null;
+  }
+  var trimmed = code.trim();
+  var scores = {};
+
+  // Test each language pattern
+  for (var _i = 0, _Object$entries = Object.entries(LANGUAGE_PATTERNS); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      language = _Object$entries$_i[0],
+      pattern = _Object$entries$_i[1];
+    var score = 0;
+    var baseWeight = pattern.weight || 5;
+
+    // Check exclude patterns first
+    if (pattern.exclude) {
+      var hasExclude = pattern.exclude.some(function (regex) {
+        return regex.test(trimmed);
+      });
+      if (hasExclude) {
+        continue; // Skip this language
+      }
+    }
+
+    // Check required patterns
+    if (pattern.required) {
+      var allRequired = pattern.required.every(function (regex) {
+        return regex.test(trimmed);
+      });
+      if (!allRequired) {
+        continue; // All required patterns must match
+      }
+      score += baseWeight * 2; // Strong indicator
+    }
+
+    // Check optional patterns
+    if (pattern.optional) {
+      var matchedOptional = pattern.optional.filter(function (regex) {
+        return regex.test(trimmed);
+      }).length;
+      score += matchedOptional * baseWeight;
+    }
+    if (score > 0) {
+      scores[language] = score;
+    }
+  }
+
+  // Find language with highest score
+  var entries = Object.entries(scores);
+  if (entries.length === 0) {
+    return null;
+  }
+  entries.sort(function (a, b) {
+    return b[1] - a[1];
+  });
+  var _entries$ = _slicedToArray(entries[0], 2),
+    topLanguage = _entries$[0],
+    topScore = _entries$[1];
+
+  // Calculate confidence (0-100)
+  var maxPossibleScore = (LANGUAGE_PATTERNS[topLanguage].weight || 5) * 5;
+  var confidence = Math.min(100, Math.round(topScore / maxPossibleScore * 100));
+
+  // Only return if confidence is high enough
+  if (confidence < 30) {
+    return null;
+  }
+  return {
+    confidence: confidence,
+    language: topLanguage
+  };
+}
+
+/**
+ * Simple detection for common formats with high confidence
+ * Falls back to detectLanguage for more complex detection
+ */
+export function detectCodeLanguage(code) {
+  var trimmed = code.trim();
+
+  // Fast path for JSON
+  if (trimmed.startsWith('{') && trimmed.endsWith('}') || trimmed.startsWith('[') && trimmed.endsWith(']')) {
+    try {
+      JSON.parse(trimmed);
+      return 'json';
+    } catch (_unused) {
+      // Not valid JSON
+    }
+  }
+
+  // Fast path for common patterns
+  if (/^\s*(select|insert|update|delete|create|alter|drop)\s+/i.test(code)) {
+    return 'sql';
+  }
+  if (/^<\?xml/i.test(code)) {
+    return 'xml';
+  }
+  if (/^FROM\s+|^RUN\s+|^CMD\s+/m.test(code)) {
+    return 'dockerfile';
+  }
+  if (/<\?php/.test(code)) {
+    return 'php';
+  }
+
+  // Use pattern matching for complex detection
+  var result = detectLanguage(code);
+  return result && result.confidence > 50 ? result.language : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.17.1",
+  "version": "1.18.0",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",