@lobehub/editor 1.6.2 → 1.7.1

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

@@ -4,7 +4,7 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 import { $isCodeHighlightNode } from '@lexical/code';
 import { $getSelection, $insertNodes, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
 import { $createCursorNode } from "../../common";
-import { $createCodeNode, $isCodeInlineNode } from "../node/code";
+import { $createCodeNode, $isCodeInlineNode, getCodeInlineNode } from "../node/code";
 export var INSERT_CODEINLINE_COMMAND = createCommand('INSERT_CODEINLINE_COMMAND');
 export function registerCodeInlineCommand(editor) {
   return editor.registerCommand(INSERT_CODEINLINE_COMMAND, function () {
@@ -18,24 +18,24 @@ export function registerCodeInlineCommand(editor) {
       if ($isCodeHighlightNode(focusNode) || $isCodeHighlightNode(anchorNode)) {
         return false;
       }
-      if (focusNode.getParent() !== anchorNode.getParent()) {
+      var code = getCodeInlineNode(focusNode);
+      if (code !== getCodeInlineNode(anchorNode)) {
         return false;
       }
-      var parentNode = focusNode.getParent();
-      if ($isCodeInlineNode(parentNode)) {
-        var _iterator = _createForOfIteratorHelper(parentNode.getChildren().slice(0)),
+      if ($isCodeInlineNode(code)) {
+        var _iterator = _createForOfIteratorHelper(code.getChildren().slice(0)),
           _step;
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done;) {
             var node = _step.value;
-            parentNode.insertBefore(node);
+            code.insertBefore(node);
           }
         } catch (err) {
           _iterator.e(err);
         } finally {
           _iterator.f();
         }
-        parentNode.remove();
+        code.remove();
         return true;
       }
       var codeNode = $createCodeNode(selection.getTextContent());

package/es/plugins/code/node/code.d.ts

@@ -1,4 +1,4 @@
-import { EditorConfig, LexicalEditor, SerializedElementNode } from 'lexical';
+import { EditorConfig, LexicalEditor, LexicalNode, SerializedElementNode } from 'lexical';
 import { CardLikeElementNode } from "../../common";
 export type SerializedCodeNode = SerializedElementNode;
 export declare class CodeNode extends CardLikeElementNode {
@@ -17,4 +17,5 @@ export declare class CodeNode extends CardLikeElementNode {
 }
 export declare function $createCodeNode(textContent?: string): CodeNode;
 export declare function $isCodeInlineNode(node: unknown): node is CodeNode;
+export declare function getCodeInlineNode(node: LexicalNode): LexicalNode | null;
 export declare function $isSelectionInCodeInline(editor: LexicalEditor): boolean;

package/es/plugins/code/node/code.js

@@ -16,7 +16,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { addClassNamesToElement } from '@lexical/utils';
 import { $applyNodeReplacement, $createTextNode, $getSelection, $isNodeSelection, $isRangeSelection } from 'lexical';
-import { $createCursorNode, CardLikeElementNode } from "../../common";
+import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common";
 export var CodeNode = /*#__PURE__*/function (_CardLikeElementNode) {
   _inherits(CodeNode, _CardLikeElementNode);
   var _super = _createSuper(CodeNode);
@@ -120,6 +120,25 @@ export function $createCodeNode(textContent) {
 export function $isCodeInlineNode(node) {
   return node instanceof CodeNode;
 }
+export function getCodeInlineNode(node) {
+  if ($isCursorNode(node)) {
+    var parent = node.getParent();
+    if ($isCodeInlineNode(parent)) {
+      return parent;
+    }
+    if ($isCodeInlineNode(node.getNextSibling())) {
+      return node.getNextSibling();
+    }
+    if ($isCodeInlineNode(node.getPreviousSibling())) {
+      return node.getPreviousSibling();
+    }
+    return null;
+  }
+  if ($isCodeInlineNode(node.getParent())) {
+    return node.getParent();
+  }
+  return null;
+}
 export function $isSelectionInCodeInline(editor) {
   return editor.read(function () {
     var selection = $getSelection();
@@ -129,11 +148,11 @@ export function $isSelectionInCodeInline(editor) {
     if ($isRangeSelection(selection)) {
       var focusNode = selection.focus.getNode();
       var anchorNode = selection.anchor.getNode();
-      if (focusNode.getParent() !== anchorNode.getParent()) {
+      var code = getCodeInlineNode(focusNode);
+      if (code !== getCodeInlineNode(anchorNode)) {
         return false;
       }
-      var parentNode = focusNode.getParent();
-      if ($isCodeInlineNode(parentNode)) {
+      if ($isCodeInlineNode(code)) {
         return true;
       }
       return false;

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

@@ -13,10 +13,12 @@ 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 { $setSelection } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { $createCursorNode } from "../../common";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerCodeInlineCommand } from "../command";
-import { CodeNode } from "../node/code";
+import { $createCodeNode, CodeNode } from "../node/code";
 import { registerCodeInline } from "./registry";
 export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(CodePlugin, _KernelPlugin);
@@ -49,6 +51,16 @@ export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         ctx.appendLine("`".concat(node.getTextContent(), "`"));
         return true;
       });
+      markdownService.registerMarkdownShortCuts([{
+        process: function process(selection) {
+          var text = selection.getTextContent();
+          selection.removeText();
+          selection.insertNodes([$createCodeNode(text), $createCursorNode()]);
+          $setSelection(selection);
+        },
+        tag: '`',
+        type: 'text-format'
+      }]);
     }
   }]);
   return CodePlugin;

package/es/plugins/code/plugin/registry.js

@@ -3,6 +3,7 @@ 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; }
 import { mergeRegister } from '@lexical/utils';
 import { $getNodeByKey } from 'lexical';
+import { $createCursorNode } from "../../common";
 import { HotkeyEnum } from "../../../types/hotkey";
 import { INSERT_CODEINLINE_COMMAND } from "../command";
 import { CodeNode } from "../node/code";
@@ -14,6 +15,7 @@ export function registerCodeInline(editor, kernel, options) {
     var mutatedNodes = _ref2.mutatedNodes;
     var codeChanged = mutatedNodes === null || mutatedNodes === void 0 ? void 0 : mutatedNodes.get(CodeNode);
     var keys = (codeChanged === null || codeChanged === void 0 ? void 0 : codeChanged.keys()) || [];
+    var needAddBefore = new Set();
     editor.read(function () {
       var _iterator = _createForOfIteratorHelper(keys),
         _step;
@@ -25,13 +27,8 @@ export function registerCodeInline(editor, kernel, options) {
             return;
           }
           var parent = node.getParent();
-          if ((parent === null || parent === void 0 ? void 0 : parent.__last) === key) {
-            var codeElement = editor.getElementByKey(key);
-            if (!(codeElement !== null && codeElement !== void 0 && codeElement.nextSibling)) {
-              parent
-              // @ts-expect-error not error
-              .getDOMSlot(editor.getElementByKey(parent.getKey())).setManagedLineBreak('decorator');
-            }
+          if ((parent === null || parent === void 0 ? void 0 : parent.getFirstChild()) === node) {
+            needAddBefore.add(node);
           }
         }
       } catch (err) {
@@ -40,6 +37,16 @@ export function registerCodeInline(editor, kernel, options) {
         _iterator.f();
       }
     });
+    if (needAddBefore.size > 0) {
+      editor.update(function () {
+        needAddBefore.forEach(function (node) {
+          var prev = node.getPreviousSibling();
+          if (!prev) {
+            node.insertBefore($createCursorNode());
+          }
+        });
+      });
+    }
   }), kernel.registerHotkey(HotkeyEnum.CodeInline, function () {
     return editor.dispatchCommand(INSERT_CODEINLINE_COMMAND, undefined);
   }, {

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

@@ -1,4 +1,4 @@
 export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND } from './command';
-export { $createCursorNode, $isCardLikeElementNode, CardLikeElementNode } from './node/cursor';
+export { $createCursorNode, $isCardLikeElementNode, $isCursorNode, CardLikeElementNode, } from './node/cursor';
 export * from './plugin';
 export * from './react';

package/es/plugins/common/index.js

@@ -1,4 +1,4 @@
 export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND } from "./command";
-export { $createCursorNode, $isCardLikeElementNode, CardLikeElementNode } from "./node/cursor";
+export { $createCursorNode, $isCardLikeElementNode, $isCursorNode, CardLikeElementNode } from "./node/cursor";
 export * from "./plugin";
 export * from "./react";

package/es/plugins/common/node/cursor.js

@@ -130,6 +130,14 @@ export function registerCursorNode(editor) {
               mutation = _step3$value[1];
             if (mutation === 'updated') {
               var cursorNode = $getNodeByKey(key);
+              if ((cursorNode === null || cursorNode === void 0 ? void 0 : cursorNode.getIndexWithinParent()) === 0) {
+                var nextElement = cursorNode.getNextSibling();
+                if (!$isCardLikeElementNode(nextElement) && !$isDecoratorNode(nextElement) && !$isCardLikeElementNode(cursorNode === null || cursorNode === void 0 ? void 0 : cursorNode.getParent())) {
+                  needRemove.add(cursorNode);
+                } else {
+                  continue;
+                }
+              }
               var element = cursorNode === null || cursorNode === void 0 ? void 0 : cursorNode.getPreviousSibling();
               if (!$isCardLikeElementNode(element) && !$isDecoratorNode(element) && !$isCardLikeElementNode(cursorNode === null || cursorNode === void 0 ? void 0 : cursorNode.getParent())) {
                 needRemove.add(cursorNode);

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

@@ -33,7 +33,7 @@ import TextDataSource from "../data-source/text-data-source";
 import { patchBreakLine, registerBreakLineClick } from "../node/ElementDOMSlot";
 import { CursorNode, registerCursorNode } from "../node/cursor";
 import { createBlockNode } from "../utils";
-import { registerHeaderBackspace, registerRichKeydown } from "./register";
+import { registerHeaderBackspace, registerLastElement, registerRichKeydown } from "./register";
 patchBreakLine();
 export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(CommonPlugin, _KernelPlugin);
@@ -117,10 +117,6 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         intraword: false,
         tag: '__',
         type: 'text-format'
-      }, {
-        format: ['code'],
-        tag: '`',
-        type: 'text-format'
       }, {
         format: ['strikethrough'],
         tag: '~~',
@@ -244,7 +240,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       var _this$config;
       this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
-      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor));
+      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor));
     }
   }, {
     key: "destroy",

package/es/plugins/common/plugin/register.d.ts

@@ -7,3 +7,4 @@ export interface RichKeydownOptions {
     enableHotkey?: boolean;
 }
 export declare function registerRichKeydown(editor: LexicalEditor, kernel: IEditor, options?: RichKeydownOptions): () => void;
+export declare function registerLastElement(editor: LexicalEditor): () => void;

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

@@ -90,7 +90,7 @@ function $isSelectionAtEndOfRoot(selection) {
 }
 export function registerHeaderBackspace(editor) {
   return editor.registerCommand(KEY_BACKSPACE_COMMAND, function (payload) {
-    // Handle backspace key press
+    // Handle backspace key press for heading nodes
     var headingNode = editor.read(function () {
       var selection = $getSelection();
       // Do not handle non-collapsed selection
@@ -289,4 +289,43 @@ export function registerRichKeydown(editor, kernel, options) {
     }
     return false;
   }, COMMAND_PRIORITY_EDITOR));
+}
+var NEEDS_FOLLOWING_PARAGRAPH_TYPES = new Set(['code', 'table']);
+export function registerLastElement(editor) {
+  var isProcessing = false;
+  return editor.registerUpdateListener(function (_ref2) {
+    var dirtyElements = _ref2.dirtyElements;
+    // Only process when root node or its direct children have changes
+    if (!dirtyElements.has('root') && !Array.from(dirtyElements.keys()).some(function (key) {
+      var _node$getParent;
+      var node = editor.getEditorState()._nodeMap.get(key);
+      return (node === null || node === void 0 || (_node$getParent = node.getParent()) === null || _node$getParent === void 0 ? void 0 : _node$getParent.getKey()) === 'root';
+    })) {
+      return;
+    }
+    if (isProcessing) return;
+    var needsParagraph = editor.read(function () {
+      var root = $getRoot();
+      var lastChild = root.getLastChild();
+
+      // Check if the last element needs a trailing paragraph
+      return NEEDS_FOLLOWING_PARAGRAPH_TYPES.has(lastChild === null || lastChild === void 0 ? void 0 : lastChild.getType());
+    });
+    if (needsParagraph) {
+      isProcessing = true;
+      queueMicrotask(function () {
+        editor.update(function () {
+          var root = $getRoot();
+          var currentLast = root.getLastChild();
+
+          // Double check to ensure the state still needs processing
+          if (NEEDS_FOLLOWING_PARAGRAPH_TYPES.has(currentLast === null || currentLast === void 0 ? void 0 : currentLast.getType())) {
+            var paragraph = $createParagraphNode();
+            root.append(paragraph);
+          }
+          isProcessing = false;
+        });
+      });
+    }
+  });
 }

package/es/plugins/markdown/service/shortcut.d.ts

@@ -1,8 +1,9 @@
-import { ElementNode, LexicalNode, TextFormatType, TextNode } from 'lexical';
+import { ElementNode, LexicalNode, RangeSelection, TextFormatType, TextNode } from 'lexical';
 import { IServiceID } from "../../../types/kernel";
 export type TextFormatTransformer = Readonly<{
-    format: ReadonlyArray<TextFormatType>;
+    format?: ReadonlyArray<TextFormatType>;
     intraword?: boolean;
+    process?: (selection: RangeSelection) => void;
     tag: string;
     type: 'text-format';
 }>;
@@ -129,8 +130,9 @@ export declare class MarkdownShortCutService implements IMarkdownShortCutService
         type: "text-match";
     }>[]>>;
     get textFormatTransformersByTrigger(): Readonly<Record<string, readonly Readonly<{
-        format: readonly TextFormatType[];
+        format?: readonly TextFormatType[] | undefined;
         intraword?: boolean | undefined;
+        process?: ((selection: RangeSelection) => void) | undefined;
         tag: string;
         type: "text-format";
     }>[]>>;

package/es/plugins/markdown/service/shortcut.js

@@ -234,50 +234,58 @@ function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransfor
       closeNode.setTextContent(closeNodeText);
       var openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
       openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
-      var selection = $getSelection();
+      var _selection = $getSelection();
       var nextSelection = $createRangeSelection();
       $setSelection(nextSelection);
       // Adjust offset based on deleted chars
       var newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
       nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text');
       nextSelection.focus.set(closeNode.__key, newOffset, 'text');
-
-      // Apply formatting to selected text
-      var _iterator5 = _createForOfIteratorHelper(matcher.format),
-        _step5;
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var format = _step5.value;
-          if (!nextSelection.hasFormat(format)) {
-            nextSelection.formatText(format);
+      if (matcher.process) {
+        matcher.process(nextSelection);
+        return true;
+      } else if (matcher.format) {
+        // Apply formatting to selected text
+        var _iterator5 = _createForOfIteratorHelper(matcher.format),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var format = _step5.value;
+            if (!nextSelection.hasFormat(format)) {
+              nextSelection.formatText(format);
+            }
           }
-        }
 
-        // Collapse selection up to the focus point
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
-      }
-      nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+          // Collapse selection up to the focus point
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
 
-      // Remove formatting from collapsed selection
-      var _iterator6 = _createForOfIteratorHelper(matcher.format),
-        _step6;
-      try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var _format = _step6.value;
-          if (nextSelection.hasFormat(_format)) {
-            nextSelection.toggleFormat(_format);
+        // Remove formatting from collapsed selection
+        var _iterator6 = _createForOfIteratorHelper(matcher.format),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var _format = _step6.value;
+            if (nextSelection.hasFormat(_format)) {
+              nextSelection.toggleFormat(_format);
+            }
           }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
         }
-      } catch (err) {
-        _iterator6.e(err);
-      } finally {
-        _iterator6.f();
-      }
-      if ($isRangeSelection(selection)) {
-        nextSelection.format = selection.format;
+        if ($isRangeSelection(_selection)) {
+          nextSelection.format = _selection.format;
+        }
+      } else {
+        // No format or process specified, nothing to do
+        $setSelection(_selection);
+        continue;
       }
       return true;
     }

package/package.json

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