@lobehub/editor 3.14.1 → 3.15.0

package/es/editor-kernel/kernel.d.ts

@@ -2,7 +2,7 @@ import { HistoryState } from '@lexical/history';
 import EventEmitter from 'eventemitter3';
 import { CommandListener, CommandListenerPriority, CommandPayloadType, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import { HotkeyId } from "../types/hotkey";
-import { IDecorator, IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, IServiceID } from "../types/kernel";
+import { IDecorator, IDocumentOptions, IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, ISelectionObject, IServiceID } from "../types/kernel";
 import { ILocaleKeys } from "../types/locale";
 import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
 import DataSource from './data-source';
@@ -22,6 +22,7 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     private historyState;
     private editor?;
     constructor();
+    cloneNodeEditor(): IEditorKernel;
     getHistoryState(): HistoryState;
     isEditable(): boolean;
     private detectDevelopmentMode;
@@ -40,7 +41,12 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     setRootElement(dom: HTMLElement, editable?: boolean): LexicalEditor;
     setEditable(editable: boolean): void;
     initNodeEditor(): LexicalEditor;
-    setDocument(type: string, content: any, options?: Record<string, unknown>): void;
+    setDocument(type: string, content: any, options?: IDocumentOptions): void;
+    setSelection(selection: ISelectionObject, opt?: {
+        collapseToEnd?: boolean;
+        collapseToStart?: boolean;
+    }): Promise<boolean>;
+    getSelection(): ISelectionObject | null;
     focus(): void;
     blur(): void;
     getDocument(type: string): DataSource | undefined;

package/es/editor-kernel/kernel.js

@@ -3,6 +3,10 @@ function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread n
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _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; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 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; }
@@ -20,16 +24,17 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 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 { createEmptyHistoryState } from '@lexical/history';
+import { $createTableSelection, $isTableNode, $isTableSelection } from '@lexical/table';
 import { get, merge, template, templateSettings } from 'es-toolkit/compat';
 import EventEmitter from 'eventemitter3';
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND, createEditor } from 'lexical';
+import { $createNodeSelection, $createRangeSelection, $getNodeByKey, $getSelection, $isElementNode, $isNodeSelection, $isRangeSelection, $setSelection, COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND, createEditor } from 'lexical';
 import defaultLocale from "../locale";
 import { $isRootTextContentEmpty } from "../plugins/common/utils";
 import { createDebugLogger } from "../utils/debug";
 import { getHotkeyById, registerHotkey as _registerHotkey } from "../utils/hotkey/registerHotkey";
 import { registerEvent } from "./event";
 import { KernelPlugin } from "./plugin";
-import { EDITOR_THEME_KEY, createEmptyEditorState, generateEditorId, noop, registerEditorKernel, unregisterEditorKernel } from "./utils";
+import { $closest, EDITOR_THEME_KEY, createEmptyEditorState, generateEditorId, noop, registerEditorKernel, unregisterEditorKernel } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   _inherits(Kernel, _EventEmitter);
@@ -61,6 +66,17 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     return _this;
   }
   _createClass(Kernel, [{
+    key: "cloneNodeEditor",
+    value: function cloneNodeEditor() {
+      var newKernel = new Kernel();
+      newKernel.registerPlugins(this.plugins);
+      newKernel.initNodeEditor();
+      newKernel.setDocument('json', this.getDocument('json') || '{}', {
+        keepId: true
+      });
+      return newKernel;
+    }
+  }, {
     key: "getHistoryState",
     value: function getHistoryState() {
       return this.historyState;
@@ -271,13 +287,141 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         this.logger.error('❌ Editor not initialized');
         throw new Error("Editor is not initialized.");
       }
-      this.historyState.redoStack = [];
-      this.historyState.undoStack = [];
-      this.historyState.current = null;
+      // Clear history if not keeping history
+      if (!(options !== null && options !== void 0 && options.keepHistory)) {
+        this.historyState.redoStack = [];
+        this.historyState.undoStack = [];
+        this.historyState.current = null;
+      }
       datasource.read(this.editor, content, options);
       this.emit('documentChange', type, content);
       this.logger.debug("\uD83D\uDCE5 Set ".concat(type, " document"));
     }
+  }, {
+    key: "setSelection",
+    value: function setSelection(selection, opt) {
+      var _this4 = this;
+      if (!this.editor) {
+        this.logger.error('❌ Editor not initialized');
+        throw new Error("Editor is not initialized.");
+      }
+      var editor = this.editor;
+      return new Promise(function (resolve) {
+        editor.update(function () {
+          try {
+            if (selection.type === 'range') {
+              var startNodeId = opt !== null && opt !== void 0 && opt.collapseToEnd ? selection.endNodeId : selection.startNodeId;
+              var endNodeId = opt !== null && opt !== void 0 && opt.collapseToStart ? selection.startNodeId : selection.endNodeId;
+              var startOffset = opt !== null && opt !== void 0 && opt.collapseToEnd ? selection.endOffset : selection.startOffset;
+              var endOffset = opt !== null && opt !== void 0 && opt.collapseToStart ? selection.startOffset : selection.endOffset;
+              var anchorNode = $getNodeByKey(startNodeId);
+              var focusNode = $getNodeByKey(endNodeId);
+              if (!anchorNode || !focusNode) {
+                _this4.logger.error('❌ Nodes for selection not found');
+                resolve(false);
+                return;
+              }
+              var rng = $createRangeSelection();
+              rng.anchor.set(anchorNode.getKey(), startOffset, $isElementNode(anchorNode) ? 'element' : 'text');
+              rng.focus.set(focusNode.getKey(), endOffset, $isElementNode(focusNode) ? 'element' : 'text');
+              $setSelection(rng);
+              resolve(true);
+              return;
+            }
+            if (selection.type === 'node') {
+              var node = $getNodeByKey(selection.startNodeId);
+              if (!node) {
+                _this4.logger.error('❌ Node for selection not found');
+                resolve(false);
+                return;
+              }
+              var nodeSel = $createNodeSelection();
+              nodeSel.add(selection.startNodeId);
+              $setSelection(nodeSel);
+              resolve(true);
+              return;
+            }
+            if (selection.type === 'table') {
+              var startNode = $getNodeByKey(selection.startNodeId);
+              if (!startNode) {
+                _this4.logger.error('❌ Node for selection not found');
+                resolve(false);
+                return;
+              }
+              var endNode = $getNodeByKey(selection.endNodeId);
+              if (!endNode) {
+                _this4.logger.error('❌ Node for selection not found');
+                resolve(false);
+                return;
+              }
+              var table1 = $closest(startNode, function (n) {
+                return $isTableNode(n);
+              });
+              var table2 = $closest(endNode, function (n) {
+                return $isTableNode(n);
+              });
+              if (!table1 || !table2 || table1 !== table2) {
+                _this4.logger.error('❌ Table nodes for selection not found or do not match');
+                resolve(false);
+                return;
+              }
+              var _rng = $createTableSelection();
+              _rng.set(table1.getKey(), selection.startNodeId, selection.endNodeId);
+              $setSelection(_rng);
+              resolve(true);
+              return;
+            }
+            resolve(false);
+          } catch (error) {
+            _this4.logger.error('❌ Error setting selection:', error);
+            resolve(false);
+          }
+        });
+      });
+    }
+  }, {
+    key: "getSelection",
+    value: function getSelection() {
+      if (!this.editor) {
+        this.logger.error('❌ Editor not initialized');
+        throw new Error("Editor is not initialized.");
+      }
+      return this.editor.read(function () {
+        var selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          return {
+            endNodeId: selection.focus.getNode().getKey(),
+            endOffset: selection.focus.offset,
+            startNodeId: selection.anchor.getNode().getKey(),
+            startOffset: selection.anchor.offset,
+            type: 'range'
+          };
+        }
+        if ($isNodeSelection(selection)) {
+          return {
+            endNodeId: selection.getNodes()[0].getKey(),
+            endOffset: 0,
+            startNodeId: selection.getNodes()[0].getKey(),
+            startOffset: 0,
+            type: 'node'
+          };
+        }
+        if ($isTableSelection(selection)) {
+          var _selection$getStartEn = selection.getStartEndPoints(),
+            _selection$getStartEn2 = _slicedToArray(_selection$getStartEn, 2),
+            start = _selection$getStartEn2[0],
+            end = _selection$getStartEn2[1];
+          return {
+            endNodeId: end.getNode().getKey(),
+            endOffset: end.offset,
+            startNodeId: start.getNode().getKey(),
+            startOffset: start.offset,
+            type: 'table'
+          };
+        }
+        return null;
+      });
+    }
   }, {
     key: "focus",
     value: function focus() {
@@ -608,12 +752,12 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "isEmpty",
     get: function get() {
-      var _this4 = this;
+      var _this5 = this;
       if (!this.editor) {
         return true;
       }
       return this.editor.getEditorState().read(function () {
-        return $isRootTextContentEmpty(_this4.editor.isComposing(), true);
+        return $isRootTextContentEmpty(_this5.editor.isComposing(), true);
       });
     }
   }, {
@@ -656,7 +800,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "registerHighCommand",
     value: function registerHighCommand(command, listener, priority) {
-      var _this5 = this;
+      var _this6 = this;
       var lexicalEditor = this.editor;
       if (!lexicalEditor) {
         throw new Error('Editor is not initialized.');
@@ -667,7 +811,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         commandsMap.set(command, [new Set(), new Set(), new Set(), new Set(), new Set()]);
         this._commandsClean.set(command, lexicalEditor.registerCommand(command, function (payload) {
           for (var i = 4; i >= 0; i--) {
-            var listenerInPriorityOrder = _this5._commands.get(command);
+            var listenerInPriorityOrder = _this6._commands.get(command);
             if (listenerInPriorityOrder !== undefined) {
               var listenersSet = listenerInPriorityOrder[i];
               var _iterator5 = _createForOfIteratorHelper(listenersSet),
@@ -704,9 +848,9 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         if (listenersInPriorityOrder.every(function (listenersSet) {
           return listenersSet.size === 0;
         })) {
-          var _this5$_commandsClean;
+          var _this6$_commandsClean;
           commandsMap.delete(command);
-          (_this5$_commandsClean = _this5._commandsClean.get(command)) === null || _this5$_commandsClean === void 0 || _this5$_commandsClean();
+          (_this6$_commandsClean = _this6._commandsClean.get(command)) === null || _this6$_commandsClean === void 0 || _this6$_commandsClean();
         }
       };
     }

package/es/index.d.ts

@@ -27,6 +27,7 @@ export { getHotkeyById } from './utils/hotkey/registerHotkey';
 export { isPureUrl, isValidUrl } from './utils/url';
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, } from './utils/debug';
 export { Kernel } from './editor-kernel/kernel';
+export { scrollIntoView } from './utils/scrollIntoView';
 /**
  * Enable hot reload mode globally for all editor instances
  * Call this in your app's entry point during development

package/es/index.js

@@ -33,6 +33,7 @@ export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole,
 
 // Hot reload utilities
 export { Kernel } from "./editor-kernel/kernel";
+export { scrollIntoView } from "./utils/scrollIntoView";
 
 /**
  * Enable hot reload mode globally for all editor instances

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

@@ -1,8 +1,12 @@
 import { HistoryState, HistoryStateEntry } from '@lexical/history';
 import { LexicalEditor } from 'lexical';
+import { IEditorKernel } from "../../../types";
 import { MarkdownShortCutService } from '../service/shortcut';
 export declare const INSERT_MARKDOWN_COMMAND: import("lexical").LexicalCommand<{
     historyState: HistoryStateEntry | null;
     markdown: string;
 }>;
-export declare function registerMarkdownCommand(editor: LexicalEditor, service: MarkdownShortCutService, history: HistoryState): () => void;
+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;

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

@@ -1,9 +1,11 @@
-import { $getSelection, CAN_UNDO_COMMAND, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, createCommand } from 'lexical';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, CAN_UNDO_COMMAND, COMMAND_PRIORITY_HIGH, HISTORIC_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;
@@ -19,8 +21,12 @@ function undoToEntry(editor, historyState, entry) {
   }
   return editor.getEditorState();
 }
-export function registerMarkdownCommand(editor, service, history) {
-  return editor.registerCommand(INSERT_MARKDOWN_COMMAND, function (payload) {
+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) {
+  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);
@@ -41,5 +47,48 @@ export function registerMarkdownCommand(editor, service, history) {
     });
     return false;
   }, COMMAND_PRIORITY_HIGH // Priority
-  );
+  ), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, function (payload) {
+    var newEditor = kernel.cloneNodeEditor();
+    var s = kernel.getSelection();
+    if (s) {
+      var _newEditor$getLexical;
+      newEditor.setSelection(s);
+      (_newEditor$getLexical = newEditor.getLexicalEditor()) === null || _newEditor$getLexical === void 0 || _newEditor$getLexical.update(function () {
+        var sel = $getSelection();
+        if (!sel) {
+          return;
+        }
+        if ($isRangeSelection(sel)) {
+          var _sel$anchor = sel.anchor,
+            anchorKey = _sel$anchor.key,
+            anchorOffset = _sel$anchor.offset,
+            anchorType = _sel$anchor.type;
+          var _sel$focus = sel.focus,
+            focusKey = _sel$focus.key,
+            focusOffset = _sel$focus.offset,
+            focusType = _sel$focus.type;
+          var newRang = sel.clone();
+          newRang.anchor.set(anchorKey, anchorOffset, anchorType);
+          newRang.focus.set(anchorKey, anchorOffset, anchorType);
+          newRang.insertText(SPICAL_TEXT);
+          newRang.focus.set(focusKey, focusOffset, focusType);
+          newRang.anchor.set(focusKey, focusOffset, focusType);
+          newRang.insertText(SPICAL_TEXT);
+        }
+      }, {
+        onUpdate: function onUpdate() {
+          var markdownContent = newEditor.getDocument('markdown');
+          var startIndex = markdownContent.indexOf(SPICAL_TEXT);
+          var endIndex = markdownContent.lastIndexOf(SPICAL_TEXT);
+          var startLine = getLineNumber(markdownContent, startIndex);
+          var endLine = getLineNumber(markdownContent, endIndex);
+          payload.onResult(startLine, endLine);
+          logger.debug('GET_MARKDOWN_SELECTION_COMMAND markdownContent:', markdownContent);
+          logger.debug('GET_MARKDOWN_SELECTION_COMMAND startLine:', startLine, 'endLine:', endLine);
+          return markdownContent;
+        }
+      });
+    }
+    return false;
+  }, COMMAND_PRIORITY_HIGH));
 }

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

@@ -1,4 +1,4 @@
-export { INSERT_MARKDOWN_COMMAND } from './command';
+export { GET_MARKDOWN_SELECTION_COMMAND, INSERT_MARKDOWN_COMMAND } from './command';
 export { MarkdownPlugin } from './plugin';
 export { default as ReactMarkdownPlugin } from './react';
 export type { MARKDOWN_READER_LEVEL } from './service/shortcut';

package/es/plugins/markdown/index.js

@@ -1,4 +1,4 @@
-export { INSERT_MARKDOWN_COMMAND } from "./command";
+export { GET_MARKDOWN_SELECTION_COMMAND, 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";

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

@@ -159,7 +159,7 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
         return false;
       }, COMMAND_PRIORITY_CRITICAL));
-      this.register(registerMarkdownCommand(editor, this.service, this.kernel.getHistoryState()));
+      this.register(registerMarkdownCommand(editor, this.kernel, this.service, this.kernel.getHistoryState()));
     }
 
     /**

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

@@ -44,8 +44,8 @@ export var SlashPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _createClass(SlashPlugin, [{
     key: "triggerClose",
     value: function triggerClose() {
-      var _this$config;
-      (_this$config = this.config) === null || _this$config === void 0 || _this$config.triggerClose();
+      var _this$config, _this$config$triggerC;
+      (_this$config = this.config) === null || _this$config === void 0 || (_this$config$triggerC = _this$config.triggerClose) === null || _this$config$triggerC === void 0 || _this$config$triggerC.call(_this$config);
       this.currentSlashTrigger = null;
       this.currentSlashTriggerIndex = -1;
       // After an explicit close, suppress reopening until next typing input

package/es/types/kernel.d.ts

@@ -18,6 +18,19 @@ export type IServiceID<Service> = {
     readonly __serviceId: string;
     __serviceType?: Service;
 };
+export interface ISelectionObject {
+    endNodeId: string;
+    endOffset: number;
+    startNodeId: string;
+    startOffset: number;
+    type: 'range' | 'node' | 'table';
+}
+export interface IDocumentOptions {
+    [key: string]: unknown;
+    keepHistory?: boolean;
+    /** only work for json datasource */
+    keepId?: boolean;
+}
 export interface IKernelEventMap {
     /**
      * Document change event
@@ -88,6 +101,10 @@ export interface IEditor {
      * Get document editor root node
      */
     getRootElement(): HTMLElement | null;
+    /**
+     * Get editor selection information
+     */
+    getSelection(): ISelectionObject | null;
     /**
      * Get document editor selection content of specified type
      * @param type
@@ -186,7 +203,7 @@ export interface IEditor {
      * @param type
      * @param content
      */
-    setDocument(type: string, content: any, options?: Record<string, unknown>): void;
+    setDocument(type: string, content: any, options?: IDocumentOptions): void;
     /**
      * Enable or disable editor editing capability
      * @param editable
@@ -197,6 +214,14 @@ export interface IEditor {
      * @param dom
      */
     setRootElement(dom: HTMLElement, editable?: boolean): LexicalEditor;
+    /**
+     * set editor selection
+     * @param selection
+     */
+    setSelection(selection: ISelectionObject, opt?: {
+        collapseToEnd?: boolean;
+        collapseToStart?: boolean;
+    }): Promise<boolean>;
     /**
      * Get translation text
      * @param key Translation key
@@ -214,6 +239,10 @@ export interface IEditor {
  * API provided to plugins
  */
 export interface IEditorKernel extends IEditor {
+    /**
+     * Clone the current editor kernel instance
+     */
+    cloneNodeEditor(): IEditorKernel;
     emit<T extends keyof IKernelEventMap>(event: T, params: Parameters<IKernelEventMap[T]>[0]): void;
     /**
      * Get editor Node decorator for specific Node rendering

package/es/utils/scrollIntoView.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scroll the current selection into view, centered vertically in the viewport
+ * @param offsetY Optional vertical offset from center (default: 0)
+ */
+export declare function scrollIntoView(offsetY?: number): void;

package/es/utils/scrollIntoView.js

@@ -0,0 +1,45 @@
+/**
+ * Scroll the current selection into view, centered vertically in the viewport
+ * @param offsetY Optional vertical offset from center (default: 0)
+ */
+export function scrollIntoView() {
+  var offsetY = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  // Skip on server side
+  if (typeof window === 'undefined' || typeof document === 'undefined') {
+    return;
+  }
+  var selection = window.getSelection();
+  if (!selection || selection.rangeCount === 0) {
+    return;
+  }
+  var range = selection.getRangeAt(0);
+  var rect = range.getBoundingClientRect();
+
+  // If selection has no visible rect, try to get it from the focus node
+  if (rect.height === 0 && rect.width === 0) {
+    var focusNode = selection.focusNode;
+    if (focusNode) {
+      var element = focusNode.nodeType === Node.ELEMENT_NODE ? focusNode : focusNode.parentElement;
+      if (element) {
+        element.scrollIntoView({
+          behavior: 'smooth',
+          block: 'center'
+        });
+      }
+    }
+    return;
+  }
+
+  // Calculate the center position of the selection
+  var selectionCenter = rect.top + rect.height / 2;
+  var viewportCenter = window.innerHeight / 2;
+
+  // Calculate scroll amount needed to center the selection
+  var scrollAmount = selectionCenter - viewportCenter + offsetY;
+
+  // Perform smooth scroll
+  window.scrollBy({
+    behavior: 'smooth',
+    top: scrollAmount
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "3.14.1",
+  "version": "3.15.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",